function getConfig({ isUMD }) {
return {
input: `src/${libraryName}.ts`,
output: [
isUMD
? {
file: getFileName(pkg.main.replace('.js', '.umd.js')),
name: camelCase(libraryName),
format: 'umd',
}
: { file: getFileName(pkg.main), format: 'cjs' },
],
sourcemap: true,
watch: {
include: 'src/**',
},
external: isUMD ? [] : id => id === 'react' || /codemirror/.test(id),
plugins: [
// Compile TypeScript files
typescript({ useTsconfigDeclarationDir: true }),
// Allow bundling cjs modules (unlike webpack, rollup doesn't understand cjs)
isUMD && commonjs(),
// Allow node_modules resolution, so you can use 'external' to control
// which external modules to include in the bundle
// https://github.com/rollup/rollup-plugin-node-resolve#usage
isUMD && resolve(),
// Resolve source maps to the original source
sourceMaps(),
minify && uglify(),
],
};
}
private static compileGlobals(cachePath: string, tree: PageTree) {
const pageCachePath = join(cachePath, tree.context.$PAGE.$name);
return rollup.rollup({
entry: tree.scripts.globals.map(x => x.path),
context: "window",
plugins: [
includes({ paths: [ join(pageCachePath, "scripts")] }),
multientry({ exports: false }),
nodeResolve({ jsnext: true }),
commonjs({}),
babel({
presets: [
[
"es2015",
{
"modules": false
}
]
],
"plugins": [
"external-helpers"
],
exclude: "node_modules/**"
})
]
}).then(bundle => bundle.generate({format: "iife", exports: "none", sourceMap: true}).code);
}
export function createRollupBundle(config: BundleConfig): Promise<any> {
const bundleOptions: any = {
context: 'this',
external: Object.keys(ROLLUP_GLOBALS),
entry: config.entry,
};
const writeOptions = {
// Keep the moduleId empty because we don't want to force developers to a specific moduleId.
moduleId: '',
moduleName: config.moduleName || 'ng.material',
banner: LICENSE_BANNER,
format: config.format,
dest: config.dest,
globals: ROLLUP_GLOBALS,
sourceMap: true
};
// When creating a UMD, we want to exclude tslib from the `external` bundle option so that it
// is inlined into the bundle.
if (config.format === 'umd') {
bundleOptions.plugins = [rollupNodeResolutionPlugin()];
const external = Object.keys(ROLLUP_GLOBALS);
external.splice(external.indexOf('tslib'), 1);
bundleOptions.external = external;
}
return rollup.rollup(bundleOptions).then((bundle: any) => bundle.write(writeOptions));
}
/** Creates a rollup bundle of a specified JavaScript file.*/
private async createRollupBundle(config: RollupBundleConfig) {
const bundleOptions = {
context: 'this',
external: Object.keys(rollupGlobals),
input: config.entry,
onwarn: (message: string) => {
// TODO(jelbourn): figure out *why* rollup warns about certain symbols not being found
// when those symbols don't appear to be in the input file in the first place.
if (/but never used/.test(message)) {
return false;
}
console.warn(message);
},
plugins: [
rollupRemoveLicensesPlugin,
]
};
const writeOptions = {
name: config.moduleName || 'ng.flexLayout',
amd: {id: config.importName},
banner: buildConfig.licenseBanner,
format: config.format,
file: config.dest,
globals: rollupGlobals,
sourcemap: true
};
// For UMD bundles, we need to adjust the `external` bundle option in order to include
// all necessary code in the bundle.
if (config.format === 'umd') {
bundleOptions.plugins.push(rollupNodeResolutionPlugin());
// For all UMD bundles, we want to exclude tslib from the `external` bundle option so that
// it is inlined into the bundle.
let external = Object.keys(rollupGlobals);
external.splice(external.indexOf('tslib'), 1);
// If each secondary entry-point is re-exported at the root, we want to exlclude those
// secondary entry-points from the rollup globals because we want the UMD for this package
// to include *all* of the sources for those entry-points.
if (this.buildPackage.exportsSecondaryEntryPointsAtRoot &&
config.moduleName === `ng.${this.buildPackage.name}`) {
const importRegex = new RegExp(`@angular/${this.buildPackage.name}/.+`);
external = external.filter(e => !importRegex.test(e));
// Use the rollup-alias plugin to map imports of the form `@angular/material/button`
// to the actual file location so that rollup can resolve the imports (otherwise they
// will be treated as external dependencies and not included in the bundle).
bundleOptions.plugins.push(
rollupAlias(this.getResolvedSecondaryEntryPointImportPaths(config.dest)));
}
bundleOptions.external = external;
}
return rollup.rollup(bundleOptions).then((bundle: any) => bundle.write(writeOptions));
}
const buildCjsPackage = ({ env }) => {
return {
input: `compiled/index.js`,
output: [
{
file: `dist/index.${env}.js`,
name: libraryName,
format: 'cjs',
sourcemap: true,
exports: 'named',
globals: {
react: 'React',
'prop-types': 'PropTypes',
},
},
],
external: ['react', 'react-dom'],
plugins: [
commonjs({
include: /node_modules/,
namedExports: {
'../../node_modules/lodash/lodash.js': [
'flatten',
'find',
'upperFirst',
'debounce',
'isNil',
'isNumber',
'flattenDeep',
'map',
'chunk',
'sortBy',
'uniqueId',
'zip',
'omit',
],
'../../node_modules/react-color/lib/components/common': ['Saturation', 'Hue', 'Alpha'],
},
}),
resolve(),
sourceMaps(),
env === 'production' && terser(),
],
};
};
gulp.task('task:worker:test:bundle', done => rollup
.rollup({
entry: 'tmp/esm/src/worker/builds/test.js',
plugins: [
new SwRewriter(),
nodeResolve({jsnext: true, main: true}),
commonjs({
include: 'node_modules/**',
namedExports: {
'node_modules/jshashes/hashes.js': ['SHA1']
}
})
]
})
.then(bundle => bundle.write({
format: 'iife',
dest: 'tmp/es5/bundles/worker-test.js',
})));
gulp.task('task:worker:basic:bundle', done => rollup
.rollup({
entry: 'tmp/esm/src/worker/builds/basic.js',
plugins: [
// TODO(alxhub): Switch to rxjs-es when export bug is fixed.
new SwRewriter(),
nodeResolve({jsnext: true, main: true}),
commonjs({
include: 'node_modules/**',
namedExports: {
'node_modules/jshashes/hashes.js': ['SHA1']
}
})
]
})
.then(bundle => bundle.write({
format: 'iife',
dest: 'tmp/es5/bundles/worker-basic.js',
})));
gulp.task('task:app:bundle', done => rollup
.rollup({
entry: 'tmp/esm/src/index.js',
plugins: [
nodeResolve({jsnext: true, main: true}),
commonjs({
include: 'node_modules/**',
}),
],
external: [
'@angular/core',
]
})
.then(bundle => bundle.write({
format: 'umd',
moduleName: 'ng.appShell',
dest: 'tmp/es5/bundles/app-shell.umd.js',
globals: {
'@angular/core': 'ng.core',
},
})));
gulp.task('task:compile:rollup', done => {
rollup
.rollup({
entry: 'tmp/ngc/app/main.js',
plugins: [
new RxRewriter(),
rollupResolveNode({
jsnext: true,
main: true,
extensions: ['.js'],
preferBuiltins: false
})
]
})
.then(bundle => bundle.write({
format: 'cjs',
dest: 'tmp/rollup/app.js'
}))
.catch(err => {
console.error(err);
})
.then(() => done());
})
const pluginBabel = require('rollup-plugin-babel')
const pluginNodeResolve = require('rollup-plugin-node-resolve')
const pluginCommonJS = require('rollup-plugin-commonjs')
const pluginImage = require('rollup-plugin-url')
const pluginMarkdown = require('rollup-plugin-md')
const pluginTypescript = require('rollup-plugin-typescript')
const pluginReplace = require('rollup-plugin-replace')
const path = require('path')
export const plugins = [
pluginImage(),
pluginMarkdown(),
pluginNodeResolve(),
pluginCommonJS(),
pluginReplace({ 'process.env.NODE_ENV': '"production"' }),
pluginTypescript({
tsconfig: false,
experimentalDecorators: true,
module: 'es2015'
}),
pluginBabel({
presets: [
[
require.resolve('@babel/preset-env'),
{
modules: false,
targets: {
browsers: ['last 2 versions']
}
}
]
