Esempio n. 1
0
function baseConfig() {
  return {
    input: resolve('./src/index.ts'),
    output: [
      outputConfig('', 'umd', {
        globals: {
          vue: 'Vue',
          'vue-class-component': 'VueClassComponent',
          'vue-property-decorator': 'vue-property-decorator',
        },
      }),
      outputConfig('.esm', 'esm'),
      outputConfig('.common', 'cjs'),
    ],
    external: [
      'vue',
      'vue-router',
      'vue-class-component',
      'vue-property-decorator',
      '@ionic/core/loader',
      '@ionic/core/css/ionic.bundle.css',
      '@ionic/core/dist/ionic/svg',
      'ionicons/dist/collection/icon/icon.css',
    ],
    plugins: [vue(), typescript({ useTsconfigDeclarationDir: true })],
  }
}
module.exports = (input, banner, intro) =>
	rollup
		.rollup({
			input: input,
			plugins: [
				typescript(),
				uglify({
					mangle: false,
					output: {
						comments: 'some'
					}
				})
			]
		})
		.then(bundle => bundle
			.write({
				name: 'justcore',
				format: 'umd',
				banner: banner,
				intro: intro,
				file: 'dist/justcore.umd.min.js',
				exports: 'named'
			})
			.then(() => console.info('PROD UMD bundled successfully'))
		);
Esempio n. 3
0
const pluginFn = () => [
  isProd && tslint({
    throwError: true,
    configuration: `tslint${isProd ? '.prod' : ''}.json`,
  }),
  typescript({ tsconfig: `./tsconfig${isProd ? '.prod' : ''}.json` }),
  isProd && terser(),
  isProd && filesize({ showBrotliSize: true }),
];
Esempio n. 4
0
].forEach((opts) => build({
    input: './src/index.ts',
    plugins: [
      typescript({
        tsconfig: './tsconfig.browser.json'
      }),
      opts.file.endsWith('min.js') ? uglify() : {}
    ]
  }, opts).then(() => console.log(`bundled: ${opts.file}`))
Esempio n. 5
0
    bundle.bundleTypes.forEach(async (type) => {
        const filename = getFilename(bundle.name, type);
        const rollupOutputConfig = {
            dir: resolve(buildDir, type.format),
            format: type.format,
            file: filename,
            sourcemap: false,
            interop: false
        };
        const rollupInputConfig = {
            input: resolve(context, bundle.entry),
            plugins: [
                resolver(),
                replace({
                    __DEV__: type.asserts
                }),
                commonjs(),
                typescript({
                    tsconfigOverride: {
                        compilerOptions: {
                            declarationDir: resolve(buildDir, bundle.typings),
                            module: 'esnext',
                        }
                    },
                    useTsconfigDeclarationDir: false,
                    clean: true
                }),
                type.minify && uglify()
            ],
            external: bundle.externals
        };
        const bundleKey = `${chalk.white.bold(filename)}${chalk.dim(` (${type.format.toLowerCase()})`)}`;

        try {
            console.log(`${chalk.bgYellow.black(' BUILDING ')} ${bundleKey}`);
            const result = await rollup(rollupInputConfig);
            const writer = await result.write(rollupOutputConfig);
            console.log(`${chalk.bgGreen.black(' COMPLETE ')} ${bundleKey}`);
            if (type === BUNDLE_TYPES.NODE_PROD) {
                console.log(chalk.green(`@bem-react/${process.env.PKG} gzip size:`), execSync(`../../node_modules/.bin/gzip-size ${join(buildDir, type.format, filename)}`).toString());
            }
        }
        catch (error) {
            console.log(`${chalk.bgRed.black(' OH NOES! ')} ${bundleKey}`);
            throw error;
        }
    });
Esempio n. 6
0
module.exports = (input, banner, intro) =>
	rollup
		.rollup({
			input: input,
			plugins: [
				typescript()
			]
		})
		.then(bundle => bundle
			.write({
				name: 'justcore',
				format: 'es',
				banner: banner,
				intro: intro,
				file: 'dist/justcore.module.js'
			})
			.then(() => console.info('ES6 bundled successfully'))
		);
function entry( changes ) {

    var options = {
        name:'main',
        dest:'public/out',
        src: './src/main.ts',
        rollup: {
            inputOptions: {
                plugins: [
                    typescript( { check:false } ),
                    resolve( { jsnext: true, main: true, browser:true } ),
                    commonjs(),
                ]
            },
            outputOptions: { format: 'iife', sourcemap: true }
        },
        uglify: {}
    }

    function lnminify(){
        return gulp.src( options.dest + "/" + options.rollup.outputOptions.name + ".js" )
            .pipe( rename( options.rollup.outputOptions.name + ".min.js") )
            .pipe( uglify( options.uglify ) )
            .pipe( gulp.dest( options.dest ) );
    
    }
    
    function lnbundle(){
        return rollup.rollup( options.rollup.inputOptions ).then( bundle => {
            return bundle.write( options.rollup.outputOptions );
        });
    }


    options = merge.recursive( options, changes );

    // inject autogenerated settings
    let r = options.rollup;
    r.inputOptions.input = ( r.inputOptions.input ) ? r.inputOptions.input : options.src, 
    r.outputOptions.file = ( r.outputOptions.file ) ? r.outputOptions.file : options.dest + '/' + options.name + '.js', 
    r.outputOptions.name = ( r.outputOptions.name ) ? r.outputOptions.name : options.name;

    return gulp.series( lnbundle, lnminify );
}
Esempio n. 8
0
export default ['umd', 'es', 'cjs'].map(format => ({
    input: 'modules/RouteNode.ts',
    plugins: [
        nodeResolve({ module: true, jsnext: true }),
        typescript({
            useTsconfigDeclarationDir: true,
            clean: true
        })
    ].filter(Boolean),
    external:
        format === 'umd'
            ? []
            : Object.keys(require('./package.json').dependencies),
    output: {
        name: 'RouteNode',
        format,
        file: `dist/${format}/route-node.js`
    }
}))
Esempio n. 9
0
module.exports = (intro) =>
	rollup
		.rollup({
			input: 'tests/**/*-tests.ts',
			plugins: [
				multiEntry(),
				typescript({
					clean: true
				})
			]
		})
		.then(bundle => bundle.write({
			format: 'iife',
			file: 'tests/bundle.js',
			intro: intro,
			name: 'tests'
		}))
		.then(() => {
			const configPath = path.resolve('./karma.conf.js');
			const config = karma.config.parseConfig(configPath);
			new karma.Server(config).start();
		});
export default [
    {
        input: './src/lib/Lib.ts',
        external: [ 'typescript-collections', 'sanctuary-type-classes'],
        output: [
          { file: "dist/sodium.umd.min.js", name: "Sodium", format: 'umd', sourcemap: true,
            globals: {
                'typescript-collections': 'Collections',
                'sanctuary-type-classes': 'Z'
            }
          },
        ],
        plugins: [
            replace({
                'process.env.NODE_ENV': JSON.stringify( process.env['NODE_ENV'] )
            }),

            typescript({
                tsconfigOverride: {
                    compilerOptions: {
                        declaration: false //will be run as a separate step via tsc which is more thorough
                    }
                },
                useTsconfigDeclarationDir: true,
            }),

            uglify({}, minify)
        ]
    }
];
Esempio n. 11
0
const noDeclarationConfig = Object.assign({}, typescriptConfig, {
  tsconfigOverride: { compilerOptions: { declaration: false } }
});

const config = {
  input: 'src/index.ts'
};

const umd = Object.assign({}, config, {
  output: {
    file: 'dist/framesync.js',
    format: 'umd',
    name: 'framesync',
    exports: 'named'
  },
  plugins: [resolve(), typescript(noDeclarationConfig)]
});

const umdProd = Object.assign({}, umd, {
  output: Object.assign({}, umd.output, {
    file: 'dist/framesync.min.js'
  }),
  plugins: [resolve(), typescript(noDeclarationConfig), uglify()]
});

const es = Object.assign({}, config, {
  output: {
    file: 'dist/framesync.es.js',
    format: 'es',
    exports: 'named'
  },
Esempio n. 12
0
import typescript2 from 'rollup-plugin-typescript2'

export default {
  entry: 'src/main.ts',
  dest: 'lib/index.js',
  format: 'cjs',
  plugins: [
    typescript2({
      typescript: require('typescript')
    })
  ]
};
Esempio n. 13
0
// Copyright 2018 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

import typescript from 'rollup-plugin-typescript2';
import node from 'rollup-plugin-node-resolve';

export default {
  input: "src/turbo-visualizer.ts",
  plugins: [node(), typescript({abortOnError:false})],
  output: {file: "build/turbolizer.js", format: "iife", sourcemap: true}
};
import typescript from 'rollup-plugin-typescript2';

export default [
  {
    input: 'src/aurelia-templating-resources.ts',
    output: [
      {
        file: 'dist/es2015/aurelia-templating-resources.js',
        format: 'esm'
      }
    ],
    plugins: [
      typescript({
        cacheRoot: '.rollupcache',
        tsconfigOverride: {
          compilerOptions: {
            removeComments: true,
          }
        }
      })
    ]
  },
  {
    input: 'src/aurelia-templating-resources.ts',
    output: [{
      file: 'dist/es2017/aurelia-templating-resources.js',
      format: 'esm'
    }],
    plugins: [
      typescript({
        cacheRoot: '.rollupcache',
        tsconfigOverride: {
import typescript from "rollup-plugin-typescript2";
import resolve from "rollup-plugin-node-resolve";
import uglify from "rollup-plugin-uglify-es";
import { settings } from "../package.json";

export default {
    input: `./src/${settings.input}`,
    output: [
        {
            format: "iife",
            name: settings.namespace.module,
            file: `./dist/${settings.namespace.file}.min.js`,
            sourcemap: true
        }
    ],
    plugins: [
        resolve(),
        typescript({
            cacheRoot: "./.cache/ts/iife-min",
            tsconfigOverride: {
                compilerOptions: {
                    target: "es2015"
                }
            }
        }),
        uglify()
    ]
};
import typescript from "rollup-plugin-typescript2";

export default {
  input: "src/index.tsx",
  output: [
    {
      file: "dist/index.umd.js",
      format: "umd",
      name: "ReactGoogleCharts"
    },
    {
      file: "dist/index.esm.js",
      format: "esm"
    },
    {
      file: "dist/index.cjs.js",
      format: "cjs"
    }
  ],
  external: ["react-load-script", "react"],
  plugins: [
    typescript({
      typescript: require("typescript"),
      abortOnError: false
    })
  ]
};
import replace from 'rollup-plugin-replace';
import typescript from 'typescript';
import {
  banner, external, globals, stubProcess,
} from '../../tools/rollup-utils';
import pkg from './package.json';

export default {
  input: 'src/index.ts',
  output: [
    {
      file: pkg.main, format: 'umd', name: pkg.globalName, sourcemap: true, globals: globals(), intro: stubProcess,
    },
    { file: pkg.module, format: 'es', sourcemap: true },
  ],
  external: external(__dirname),
  plugins: [
    typescriptRollup({
      typescript,
      useTsconfigDeclarationDir: true
    }),
    replace({
      "/** @class */": "/*#__PURE__*/",
      delimiters: ["", ""],
    }),
    license({
      banner,
    }),
  ],
};
Esempio n. 18
0
  return id => pattern.test(id);
};

const deps = Object.keys(pkg.dependencies || {})
const peerDeps = Object.keys(pkg.peerDependencies || {})

const config = {
  input: 'src/index.ts',
  external: makeExternalPredicate(deps.concat(peerDeps))
};

const es = Object.assign({}, config, {
  output: {
    file: pkg.module,
    format: 'es',
    exports: 'named'
  },
  plugins: [typescript(noDeclarationConfig)]
});

const cjs = Object.assign({}, config, {
  output: {
    file: pkg.main,
    format: 'cjs',
    exports: 'named'
  },
  plugins: [typescript(typescriptConfig)]
});

export default [es, cjs];
Esempio n. 19
0
	output: [
		{
			format: 'umd',
			file: 'lib/SVGPathData.js',
			sourcemap: true,
      name: 'svgpathdata'
		},
		{
      format: 'es',
      sourcemap: true,
      file: 'lib/SVGPathData.module.js'
    },
  ],
  plugins: [
		typescriptPlugin({
			typescript
		}),
    uglify({}, uglifyEs)
  ],
  // onwarn: function (warning, warn) {
  //   // Suppress this error message... there are hundreds of them. Angular team says to ignore it.
  //   // https://github.com/rollup/rollup/wiki/Troubleshooting#this-is-undefined
  //   if ('THIS_IS_UNDEFINED' === warning.code) return
  //   if ('CIRCULAR_DEPENDENCY' === warning.code) {
	// 		const m = warning.message.match(/^Circular dependency: (.*) -> .* -> .*$/)
	// 		if (m) {
	// 			const start = m[1]
	// 			if (start.match(/out[/\\]index.js|src[/\\]index.ts/)) {
	// 				// this is a loop of length three starting at the index file: don't warn
	// 				return
	// 			}
Esempio n. 20
0
export default [{
  input: `src/${entryName}.ts`,
  output: {
    file: `dist/es2015/${entryName}.js`,
    format: 'es'
  },
  plugins: [
    typescript({
      useTsconfigDeclarationDir: true,
      // tsconfigDefaults: defaultCfg,
      // tsconfig: undefined,
      tsconfigOverride: {
        compilerOptions: {
          module: 'es2015',
          target: 'es2015',
          declarationDir: 'dist/types'
        },
        include: ['src'],
        exclude: undefined
      },
      cacheRoot: '.rollupcache'
    })
  ]
}].concat(!isProduction
  ? []
  : [
    {
      input: `src/${entryName}.ts`,
      output: {
        file: `dist/es2017/${entryName}.js`,
Esempio n. 21
0
}

export default [
  // Build 1: ES6 modules for Node.
  {
    input: 'src/awilix.ts',
    external: ['glob', 'path', 'util', 'camel-case'],
    treeshake: { pureExternalModules: true },
    onwarn,
    output: [
      {
        file: 'lib/awilix.module.js',
        format: 'es'
      }
    ],
    plugins: [typescript(tsOpts)]
  },
  // Build 2: ES modules for browser builds.
  {
    input: 'src/awilix.ts',
    external: ['glob', 'path', 'util'],
    treeshake: { pureExternalModules: true },
    onwarn,
    output: [
      {
        name: 'Awilix',
        file: 'lib/awilix.browser.js',
        format: 'es'
      },
      {
        name: 'Awilix',
import typescript from "rollup-plugin-typescript2";
import resolve from "rollup-plugin-node-resolve";
import { terser } from "rollup-plugin-terser";
import { settings } from "../package.json";

export default {
    input: `./src/main.ts`,
    output: [
        {
            format: "iife",
            name: settings.namespace.module,
            file: `./dist/${settings.namespace.file}.min.js`,
            sourcemap: true
        }
    ],
    plugins: [
        resolve(),
        typescript({
            cacheRoot: "./.cache/ts/iife-min"
        }),
        terser()
    ]
};
import replace from 'rollup-plugin-replace';
import typescript from 'rollup-plugin-typescript2';

export default {
  input: 'src/index.tsx',
  ignore: ['stories'],
  plugins: [
    typescript({
      tsconfig: 'tsconfig.json',
      exclude: ['*.d.ts', 'stories'],
    }),
    replace({ 'process.env.NODE_ENV': JSON.stringify('production') }),
  ],
  external: ['react', 'react-motion', 're-resizable', 'lodash.isequal', 'resize-observer-polyfill', 'lodash.debounce'],
  output: {
    sourcemap: true,
    exports: 'named',
    name: 'react-sortable-pane',
    globals: {
      react: 'React',
    },
  },
};
Esempio n. 24
0
import replace from 'rollup-plugin-replace';
import typescript2 from 'rollup-plugin-typescript2';
import uglify from 'rollup-plugin-uglify';

export default {
  input: `src/index.ts`,
  output: {
    name: 'hw',
    file: `dist/bundle.js`,
    format: 'iife',
    sourcemap: false
  },
  plugins: [
    typescript2({
      typescript: require('typescript'),
      "experimentalDecorators": true,
      "emitDecoratorMetadata": true
    }),
    replace({
      delimiters: ['', ''],
      values: {
        '/** @class */': '/** @__PURE__ */'
      }
    }),
    nodeResolve({jsnext: true, module: true}),
    commonjs({
      include: 'node_modules/rxjs/**',
    }),
    uglify({
      mangle: true,
      compress: {
Esempio n. 25
0
const typescript = require('rollup-plugin-typescript2')
const pkg = require('./package.json')
const alias = require('rollup-plugin-alias')
const { join } = require('path')
const cwd = __dirname
module.exports = {
  input: 'src/index.ts',
  plugins: [
    alias({
      'nerv-shared': join(cwd, '../nerv-shared/dist/index'),
      'nerv-utils': join(cwd, '../nerv-utils/dist/index')
    }),
    typescript()
  ],
  output: [
    {
      format: 'cjs',
      sourcemap: true,
      file: join(__dirname, 'dist/index.js')
    },
    {
      format: 'es',
      sourcemap: true,
      file: join(__dirname, pkg.module)
    }
  ]
}
import clear from 'rollup-plugin-clear';
import resolve from 'rollup-plugin-node-resolve';
import commonjs from 'rollup-plugin-commonjs';
import typescript from 'rollup-plugin-typescript2';
import screeps from 'rollup-plugin-screeps';

let cfg;
const dest = process.env.DEST;
if (!dest) {
  console.log('No destination specified - code will be compiled but not uploaded');
} else if ((cfg = require('./screeps')[dest]) == null) {
  throw new Error('Invalid upload destination');
}

export default {
  input: 'src/main.ts',
  output: {
    file: 'dist/main.js',
    format: 'cjs',
    sourcemap: true
  },

  plugins: [
    clear({ targets: ['dist'] }),
    resolve(),
    commonjs(),
    typescript({tsconfig: './tsconfig.json'}),
    screeps({config: cfg, dryRun: cfg == null})
  ]
};
Esempio n. 27
0
import pkg from './package.json'

export default {
    input: 'src/comparators.ts',
    output: [
        {
            dir: "dist/umd",
            format: 'umd',
            name: 'Comparators'
        },
    ],
    external: [
        ...Object.keys(pkg.dependencies || {}),
        ...Object.keys(pkg.peerDependencies || {}),
    ],

    plugins: [
        typescript({
            typescript: require('typescript'),
            tsconfig: "tsconfig.base.json",
            tsconfigOverride: {
                compilerOptions: {
                    declaration: true,
                    inlineSources: false // unfortunately, rollup-plugin-tyescript2 doesn't do inline source maps
                }
            }
        }),
    ],
}
Esempio n. 28
0
import typescript from "rollup-plugin-typescript2";
import autoExternal from "rollup-plugin-auto-external";
import path from "path";

export default {
  input: path.resolve(__dirname, "./src/main.ts"),
  output: {
    file: path.resolve(__dirname, "../main.js"),
    format: "cjs"
  },
  external: ["electron"],
  plugins: [
    typescript({
      tsconfig: path.resolve(__dirname, "./tsconfig.json")
    }),
    autoExternal({
      builtins: true,
      packagePath: path.resolve(__dirname, "../package.json")
    })
  ]
};
import clear from "rollup-plugin-clear";
import resolve from "rollup-plugin-node-resolve";
import commonjs from "rollup-plugin-commonjs";
import typescript from "rollup-plugin-typescript2";
import buble      from 'rollup-plugin-buble';
import multiEntry from 'rollup-plugin-multi-entry';

export default {
  input: 'test/unit/**/*.test.ts',
  output: {
    file: 'dist/test-unit.bundle.js',
    name: 'lib',
    sourcemap: true,
    format: 'iife',
    globals: {
      chai: 'chai',
      it: 'it',
      describe: 'describe'
    }
  },
  external: ['chai', 'it', 'describe'],
  plugins: [
    clear({ targets: ["dist/test.bundle.js"] }),
    resolve(),
    commonjs(),
    typescript({tsconfig: "./tsconfig.json"}),
    multiEntry(),
    buble()
  ]
}
Esempio n. 30
0
export default [
  // CommonJS
  {
    input: 'src/hibp.ts',
    output: {
      file: 'lib/hibp.js',
      format: 'cjs',
      sourcemap: true,
      indent: false,
    },
    external,
    plugins: [
      json({ preferConst: true }),
      babel(babelOpts),
      typescript(typescriptOpts),
    ],
  },

  // ESM
  {
    input: glob.sync('src/**/*.ts', {
      ignore: [
        '**/__mocks__/**',
        '**/__tests__/**',
        '**/*.test.ts',
        '**/*.d.ts',
      ],
    }),
    output: {
      dir: 'es',