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'))
);
const pluginFn = () => [
isProd && tslint({
throwError: true,
configuration: `tslint${isProd ? '.prod' : ''}.json`,
}),
typescript({ tsconfig: `./tsconfig${isProd ? '.prod' : ''}.json` }),
isProd && terser(),
isProd && filesize({ showBrotliSize: true }),
];
].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}`))
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;
}
});
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 );
}
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`
}
}))
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)
]
}
];
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'
},
import typescript2 from 'rollup-plugin-typescript2'
export default {
entry: 'src/main.ts',
dest: 'lib/index.js',
format: 'cjs',
plugins: [
typescript2({
typescript: require('typescript')
})
]
};
// 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,
}),
],
};
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];
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
// }
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`,
}
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',
},
},
};
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: {
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})
]
};
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
}
}
}),
],
}
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()
]
}
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',