@nx/rollup 0.0.0-pr-22179-271588f

package/src/executors/rollup/rollup.impl.js

@@ -0,0 +1,288 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRollupOptions = exports.rollupExecutor = void 0;
+const ts = require("typescript");
+const rollup = require("rollup");
+const peerDepsExternal = require("rollup-plugin-peer-deps-external");
+const plugin_babel_1 = require("@rollup/plugin-babel");
+const path_1 = require("path");
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const rxjs_for_await_1 = require("@nx/devkit/src/utils/rxjs-for-await");
+const autoprefixer = require("autoprefixer");
+const devkit_1 = require("@nx/devkit");
+const buildable_libs_utils_1 = require("@nx/js/src/utils/buildable-libs-utils");
+const plugin_node_resolve_1 = require("@rollup/plugin-node-resolve");
+const type_definitions_1 = require("@nx/js/src/plugins/rollup/type-definitions");
+const run_rollup_1 = require("./lib/run-rollup");
+const normalize_1 = require("./lib/normalize");
+const analyze_plugin_1 = require("./lib/analyze-plugin");
+const fs_1 = require("../../utils/fs");
+const swc_plugin_1 = require("./lib/swc-plugin");
+const update_package_json_1 = require("./lib/update-package-json");
+const config_utils_1 = require("@nx/devkit/src/utils/config-utils");
+// These use require because the ES import isn't correct.
+const commonjs = require('@rollup/plugin-commonjs');
+const image = require('@rollup/plugin-image');
+const json = require('@rollup/plugin-json');
+const copy = require('rollup-plugin-copy');
+const postcss = require('rollup-plugin-postcss');
+const fileExtensions = ['.js', '.jsx', '.ts', '.tsx'];
+async function* rollupExecutor(rawOptions, context) {
+    process.env.NODE_ENV ??= 'production';
+    const project = context.projectsConfigurations.projects[context.projectName];
+    const sourceRoot = project.sourceRoot;
+    const { target, dependencies } = (0, buildable_libs_utils_1.calculateProjectBuildableDependencies)(context.taskGraph, context.projectGraph, context.root, context.projectName, context.targetName, context.configurationName, true);
+    const options = (0, normalize_1.normalizeRollupExecutorOptions)(rawOptions, context, sourceRoot);
+    const packageJson = (0, devkit_1.readJsonFile)(options.project);
+    const npmDeps = (context.projectGraph.dependencies[context.projectName] ?? [])
+        .filter((d) => d.target.startsWith('npm:'))
+        .map((d) => d.target.slice(4));
+    const rollupOptions = await createRollupOptions(options, dependencies, context, packageJson, sourceRoot, npmDeps);
+    const outfile = resolveOutfile(context, options);
+    if (options.watch) {
+        const watcher = rollup.watch(rollupOptions);
+        return yield* (0, rxjs_for_await_1.eachValueFrom)(new rxjs_1.Observable((obs) => {
+            watcher.on('event', (data) => {
+                if (data.code === 'START') {
+                    devkit_1.logger.info(`Bundling ${context.projectName}...`);
+                }
+                else if (data.code === 'END') {
+                    (0, update_package_json_1.updatePackageJson)(options, packageJson);
+                    devkit_1.logger.info('Bundle complete. Watching for file changes...');
+                    obs.next({ success: true, outfile });
+                }
+                else if (data.code === 'ERROR') {
+                    devkit_1.logger.error(`Error during bundle: ${data.error.message}`);
+                    obs.next({ success: false });
+                }
+            });
+            // Teardown logic. Close watcher when unsubscribed.
+            return () => watcher.close();
+        }));
+    }
+    else {
+        devkit_1.logger.info(`Bundling ${context.projectName}...`);
+        // Delete output path before bundling
+        if (options.deleteOutputPath) {
+            (0, fs_1.deleteOutputDir)(context.root, options.outputPath);
+        }
+        const start = process.hrtime.bigint();
+        return (0, rxjs_1.from)(rollupOptions)
+            .pipe((0, operators_1.concatMap)((opts) => (0, run_rollup_1.runRollup)(opts).pipe((0, operators_1.catchError)((e) => {
+            devkit_1.logger.error(`Error during bundle: ${e}`);
+            return (0, rxjs_1.of)({ success: false });
+        }))), (0, operators_1.scan)((acc, result) => {
+            if (!acc.success)
+                return acc;
+            return result;
+        }, { success: true, outfile }), (0, operators_1.last)(), (0, operators_1.tap)({
+            next: (result) => {
+                if (result.success) {
+                    const end = process.hrtime.bigint();
+                    const duration = `${(Number(end - start) / 1000000000).toFixed(2)}s`;
+                    (0, update_package_json_1.updatePackageJson)(options, packageJson);
+                    devkit_1.logger.info(`⚡ Done in ${duration}`);
+                }
+                else {
+                    devkit_1.logger.error(`Bundle failed: ${context.projectName}`);
+                }
+            },
+        }))
+            .toPromise();
+    }
+}
+exports.rollupExecutor = rollupExecutor;
+// -----------------------------------------------------------------------------
+async function createRollupOptions(options, dependencies, context, packageJson, sourceRoot, npmDeps) {
+    const useBabel = options.compiler === 'babel';
+    const useTsc = options.compiler === 'tsc';
+    const useSwc = options.compiler === 'swc';
+    const tsConfigPath = (0, devkit_1.joinPathFragments)(context.root, options.tsConfig);
+    const configFile = ts.readConfigFile(tsConfigPath, ts.sys.readFile);
+    const config = ts.parseJsonConfigFileContent(configFile.config, ts.sys, (0, path_1.dirname)(tsConfigPath));
+    if (!options.format || !options.format.length) {
+        options.format = readCompatibleFormats(config);
+    }
+    if (packageJson.type === 'module') {
+        if (options.format.includes('cjs')) {
+            devkit_1.logger.warn(`Package type is set to "module" but "cjs" format is included. Going to use "esm" format instead. You can change the package type to "commonjs" or remove type in the package.json file.`);
+        }
+        options.format = ['esm'];
+    }
+    else if (packageJson.type === 'commonjs') {
+        if (options.format.includes('esm')) {
+            devkit_1.logger.warn(`Package type is set to "commonjs" but "esm" format is included. Going to use "cjs" format instead. You can change the package type to "module" or remove type in the package.json file.`);
+        }
+        options.format = ['cjs'];
+    }
+    const _rollupOptions = options.format.map(async (format, idx) => {
+        // Either we're generating only one format, so we should bundle types
+        // OR we are generating dual formats, so only bundle types for CJS.
+        const shouldBundleTypes = options.format.length === 1 || format === 'cjs';
+        const plugins = [
+            copy({
+                targets: convertCopyAssetsToRollupOptions(options.outputPath, options.assets),
+            }),
+            image(),
+            json(),
+            (useTsc || shouldBundleTypes) &&
+                require('rollup-plugin-typescript2')({
+                    check: !options.skipTypeCheck,
+                    tsconfig: options.tsConfig,
+                    tsconfigOverride: {
+                        compilerOptions: createTsCompilerOptions(config, dependencies, options),
+                    },
+                }),
+            shouldBundleTypes &&
+                (0, type_definitions_1.typeDefinitions)({
+                    main: options.main,
+                    projectRoot: options.projectRoot,
+                }),
+            peerDepsExternal({
+                packageJsonPath: options.project,
+            }),
+            postcss({
+                inject: true,
+                extract: options.extractCss,
+                autoModules: true,
+                plugins: [autoprefixer],
+                use: {
+                    less: {
+                        javascriptEnabled: options.javascriptEnabled,
+                    },
+                },
+            }),
+            (0, plugin_node_resolve_1.default)({
+                preferBuiltins: true,
+                extensions: fileExtensions,
+            }),
+            useSwc && (0, swc_plugin_1.swc)(),
+            useBabel &&
+                (0, plugin_babel_1.getBabelInputPlugin)({
+                    // Lets `@nx/js/babel` preset know that we are packaging.
+                    caller: {
+                        // @ts-ignore
+                        // Ignoring type checks for caller since we have custom attributes
+                        isNxPackage: true,
+                        // Always target esnext and let rollup handle cjs
+                        supportsStaticESM: true,
+                        isModern: true,
+                    },
+                    cwd: (0, path_1.join)(context.root, sourceRoot),
+                    rootMode: options.babelUpwardRootMode ? 'upward' : undefined,
+                    babelrc: true,
+                    extensions: fileExtensions,
+                    babelHelpers: 'bundled',
+                    skipPreflightCheck: true, // pre-flight check may yield false positives and also slows down the build
+                    exclude: /node_modules/,
+                    plugins: [
+                        format === 'esm'
+                            ? undefined
+                            : require.resolve('babel-plugin-transform-async-to-promises'),
+                    ].filter(Boolean),
+                }),
+            commonjs(),
+            (0, analyze_plugin_1.analyze)(),
+        ];
+        let externalPackages = [
+            ...Object.keys(packageJson.dependencies || {}),
+            ...Object.keys(packageJson.peerDependencies || {}),
+        ]; // If external is set to none, include all dependencies and peerDependencies in externalPackages
+        if (options.external === 'all') {
+            externalPackages = externalPackages
+                .concat(dependencies.map((d) => d.name))
+                .concat(npmDeps);
+        }
+        else if (Array.isArray(options.external) && options.external.length > 0) {
+            externalPackages = externalPackages.concat(options.external);
+        }
+        externalPackages = [...new Set(externalPackages)];
+        const mainEntryFileName = options.outputFileName || options.main;
+        const input = {};
+        input[(0, path_1.parse)(mainEntryFileName).name] = options.main;
+        options.additionalEntryPoints.forEach((entry) => {
+            input[(0, path_1.parse)(entry).name] = entry;
+        });
+        const rollupConfig = {
+            input,
+            output: {
+                format,
+                dir: `${options.outputPath}`,
+                name: (0, devkit_1.names)(context.projectName).className,
+                entryFileNames: `[name].${format}.js`,
+                chunkFileNames: `[name].${format}.js`,
+            },
+            external: (id) => {
+                return externalPackages.some((name) => id === name || id.startsWith(`${name}/`)); // Could be a deep import
+            },
+            plugins,
+        };
+        const userDefinedRollupConfigs = options.rollupConfig.map((plugin) => (0, config_utils_1.loadConfigFile)(plugin));
+        let finalConfig = rollupConfig;
+        for (const _config of userDefinedRollupConfigs) {
+            const config = await _config;
+            if (typeof config === 'function') {
+                finalConfig = config(finalConfig, options);
+            }
+            else {
+                finalConfig = {
+                    ...finalConfig,
+                    ...config,
+                    plugins: [
+                        ...(finalConfig.plugins?.length > 0 ? finalConfig.plugins : []),
+                        ...(config.plugins?.length > 0 ? config.plugins : []),
+                    ],
+                };
+            }
+        }
+        return finalConfig;
+    });
+    const rollupOptions = [];
+    for (const rollupOption of _rollupOptions) {
+        rollupOptions.push(await rollupOption);
+    }
+    return rollupOptions;
+}
+exports.createRollupOptions = createRollupOptions;
+function createTsCompilerOptions(config, dependencies, options) {
+    const compilerOptionPaths = (0, buildable_libs_utils_1.computeCompilerOptionsPaths)(config, dependencies);
+    const compilerOptions = {
+        rootDir: options.projectRoot,
+        allowJs: options.allowJs,
+        declaration: true,
+        paths: compilerOptionPaths,
+    };
+    if (config.options.module === ts.ModuleKind.CommonJS) {
+        compilerOptions['module'] = 'ESNext';
+    }
+    if (options.compiler === 'swc') {
+        compilerOptions['emitDeclarationOnly'] = true;
+    }
+    return compilerOptions;
+}
+function convertCopyAssetsToRollupOptions(outputPath, assets) {
+    return assets
+        ? assets.map((a) => ({
+            src: (0, path_1.join)(a.input, a.glob).replace(/\\/g, '/'),
+            dest: (0, path_1.join)(outputPath, a.output).replace(/\\/g, '/'),
+        }))
+        : undefined;
+}
+function readCompatibleFormats(config) {
+    switch (config.options.module) {
+        case ts.ModuleKind.CommonJS:
+        case ts.ModuleKind.UMD:
+        case ts.ModuleKind.AMD:
+            return ['cjs'];
+        default:
+            return ['esm'];
+    }
+}
+function resolveOutfile(context, options) {
+    if (!options.format?.includes('cjs'))
+        return undefined;
+    const { name } = (0, path_1.parse)(options.outputFileName ?? options.main);
+    return (0, path_1.resolve)(context.root, options.outputPath, `${name}.cjs.js`);
+}
+exports.default = rollupExecutor;

package/src/executors/rollup/schema.d.ts

@@ -0,0 +1,36 @@
+type Compiler = 'babel' | 'swc';
+
+export interface AssetGlobPattern {
+  glob: string;
+  input: string;
+  output: string;
+  ignore?: string[];
+}
+
+export interface Globals {
+  moduleId: string;
+  global: string;
+}
+
+export interface RollupExecutorOptions {
+  outputPath: string;
+  tsConfig: string;
+  allowJs?: boolean;
+  project: string;
+  main: string;
+  outputFileName?: string;
+  extractCss?: boolean | string;
+  external?: string[] | 'all' | 'none';
+  rollupConfig?: string | string[];
+  watch?: boolean;
+  assets?: any[];
+  deleteOutputPath?: boolean;
+  format?: ('cjs' | 'esm')[];
+  compiler?: 'babel' | 'tsc' | 'swc';
+  javascriptEnabled?: boolean;
+  generateExportsField?: boolean;
+  additionalEntryPoints?: string[];
+  skipTypeCheck?: boolean;
+  babelUpwardRootMode?: boolean;
+  skipTypeField?: boolean;
+}

package/src/executors/rollup/schema.json

@@ -0,0 +1,182 @@
+{
+  "version": 2,
+  "outputCapture": "direct-nodejs",
+  "title": "Web Library Rollup Target (Experimental)",
+  "description": "Packages a library for different web usages (ESM, CommonJS).",
+  "cli": "nx",
+  "type": "object",
+  "properties": {
+    "project": {
+      "type": "string",
+      "description": "The path to package.json file.",
+      "x-priority": "important"
+    },
+    "main": {
+      "type": "string",
+      "description": "The path to the entry file, relative to project.",
+      "alias": "entryFile",
+      "x-completion-type": "file",
+      "x-completion-glob": "**/*@(.js|.ts)",
+      "x-priority": "important"
+    },
+    "outputPath": {
+      "type": "string",
+      "description": "The output path of the generated files.",
+      "x-completion-type": "directory",
+      "x-priority": "important"
+    },
+    "outputFileName": {
+      "type": "string",
+      "description": "Name of the main output file. Defaults same basename as 'main' file."
+    },
+    "deleteOutputPath": {
+      "type": "boolean",
+      "description": "Delete the output path before building.",
+      "default": true
+    },
+    "tsConfig": {
+      "type": "string",
+      "description": "The path to tsconfig file.",
+      "x-completion-type": "file",
+      "x-completion-glob": "tsconfig.*.json",
+      "x-priority": "important"
+    },
+    "allowJs": {
+      "type": "boolean",
+      "description": "Allow JavaScript files to be compiled.",
+      "default": false
+    },
+    "format": {
+      "type": "array",
+      "description": "List of module formats to output. Defaults to matching format from tsconfig (e.g. CJS for CommonJS, and ESM otherwise).",
+      "alias": "f",
+      "items": {
+        "type": "string",
+        "enum": ["esm", "cjs"]
+      }
+    },
+    "external": {
+      "type": "array",
+      "description": "A list of external modules that will not be bundled (`react`, `react-dom`, etc.). Can also be set to `all` (bundle nothing) or `none` (bundle everything).",
+      "oneOf": [
+        {
+          "type": "string",
+          "enum": ["all", "none"]
+        },
+        {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        }
+      ]
+    },
+    "watch": {
+      "type": "boolean",
+      "description": "Enable re-building when files change.",
+      "default": false
+    },
+    "rollupConfig": {
+      "oneOf": [
+        {
+          "type": "array",
+          "items": {
+            "type": "string",
+            "x-completion-type": "file",
+            "x-completion-glob": "rollup?(*)@(.js|.ts)"
+          }
+        },
+        {
+          "type": "string",
+          "x-completion-type": "file",
+          "x-completion-glob": "rollup?(*)@(.js|.ts)"
+        }
+      ],
+      "description": "Path to a function which takes a rollup config and returns an updated rollup config."
+    },
+    "extractCss": {
+      "type": ["boolean", "string"],
+      "description": "CSS files will be extracted to the output folder. Alternatively custom filename can be provided (e.g. styles.css)",
+      "default": true
+    },
+    "assets": {
+      "type": "array",
+      "description": "List of static assets.",
+      "default": [],
+      "items": {
+        "$ref": "#/definitions/assetPattern"
+      }
+    },
+    "compiler": {
+      "type": "string",
+      "enum": ["babel", "swc", "tsc"],
+      "default": "babel",
+      "description": "Which compiler to use."
+    },
+    "babelUpwardRootMode": {
+      "type": "boolean",
+      "description": "Whether to set rootmode to upward. See https://babeljs.io/docs/en/options#rootmode",
+      "default": false
+    },
+    "javascriptEnabled": {
+      "type": "boolean",
+      "description": "Sets `javascriptEnabled` option for less loader",
+      "default": false
+    },
+    "generateExportsField": {
+      "type": "boolean",
+      "alias": "exports",
+      "description": "Update the output package.json file's 'exports' field. This field is used by Node and bundles.",
+      "default": false,
+      "x-priority": "important"
+    },
+    "additionalEntryPoints": {
+      "type": "array",
+      "description": "Additional entry-points to add to exports field in the package.json file.",
+      "items": {
+        "type": "string"
+      },
+      "x-priority": "important"
+    },
+    "skipTypeCheck": {
+      "type": "boolean",
+      "description": "Whether to skip TypeScript type checking.",
+      "default": false
+    },
+    "skipTypeField": {
+      "type": "boolean",
+      "description": "Prevents 'type' field from being added to compiled package.json file. Use this if you are having an issue with this field.",
+      "default": false
+    }
+  },
+  "required": ["tsConfig", "main", "outputPath"],
+  "definitions": {
+    "assetPattern": {
+      "oneOf": [
+        {
+          "type": "object",
+          "properties": {
+            "glob": {
+              "type": "string",
+              "description": "The pattern to match."
+            },
+            "input": {
+              "type": "string",
+              "description": "The input directory path in which to apply `glob`. Defaults to the project root."
+            },
+            "output": {
+              "type": "string",
+              "description": "Relative path within the output folder."
+            }
+          },
+          "additionalProperties": false,
+          "required": ["glob", "input", "output"]
+        },
+        {
+          "type": "string"
+        }
+      ]
+    }
+  },
+  "examplesFile": "../../docs/rollup-examples.md"
+}

package/src/generators/configuration/configuration.d.ts

@@ -0,0 +1,4 @@
+import { Tree, GeneratorCallback } from '@nx/devkit';
+import { RollupProjectSchema } from './schema';
+export declare function configurationGenerator(tree: Tree, options: RollupProjectSchema): Promise<GeneratorCallback>;
+export default configurationGenerator;

package/src/generators/configuration/configuration.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configurationGenerator = void 0;
+const devkit_1 = require("@nx/devkit");
+const get_import_path_1 = require("@nx/js/src/utils/get-import-path");
+const init_1 = require("../init/init");
+const add_build_target_defaults_1 = require("@nx/devkit/src/generators/add-build-target-defaults");
+const ensure_dependencies_1 = require("../../utils/ensure-dependencies");
+async function configurationGenerator(tree, options) {
+    const tasks = [];
+    tasks.push(await (0, init_1.rollupInitGenerator)(tree, { ...options, skipFormat: true }));
+    if (!options.skipPackageJson) {
+        tasks.push((0, ensure_dependencies_1.ensureDependencies)(tree, options));
+    }
+    options.buildTarget ??= 'build';
+    checkForTargetConflicts(tree, options);
+    addBuildTarget(tree, options);
+    if (!options.skipFormat) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+    return (0, devkit_1.runTasksInSerial)(...tasks);
+}
+exports.configurationGenerator = configurationGenerator;
+function checkForTargetConflicts(tree, options) {
+    if (options.skipValidation)
+        return;
+    const project = (0, devkit_1.readProjectConfiguration)(tree, options.project);
+    if (project.targets?.[options.buildTarget]) {
+        throw new Error(`Project "${options.project}" already has a ${options.buildTarget} target. Pass --skipValidation to ignore this error.`);
+    }
+}
+function addBuildTarget(tree, options) {
+    (0, add_build_target_defaults_1.addBuildTargetDefaults)(tree, '@nx/rollup:rollup', options.buildTarget);
+    const project = (0, devkit_1.readProjectConfiguration)(tree, options.project);
+    const packageJsonPath = (0, devkit_1.joinPathFragments)(project.root, 'package.json');
+    if (!tree.exists(packageJsonPath)) {
+        const importPath = options.importPath || (0, get_import_path_1.getImportPath)(tree, options.project);
+        (0, devkit_1.writeJson)(tree, packageJsonPath, {
+            name: importPath,
+            version: '0.0.1',
+        });
+    }
+    const prevBuildOptions = project.targets?.[options.buildTarget]?.options;
+    const buildOptions = {
+        main: options.main ??
+            prevBuildOptions?.main ??
+            (0, devkit_1.joinPathFragments)(project.root, 'src/main.ts'),
+        outputPath: prevBuildOptions?.outputPath ??
+            (0, devkit_1.joinPathFragments)('dist', project.root === '.' ? project.name : project.root),
+        tsConfig: options.tsConfig ??
+            prevBuildOptions?.tsConfig ??
+            (0, devkit_1.joinPathFragments)(project.root, 'tsconfig.lib.json'),
+        additionalEntryPoints: prevBuildOptions?.additionalEntryPoints,
+        generateExportsField: prevBuildOptions?.generateExportsField,
+        compiler: options.compiler ?? 'babel',
+        project: `${project.root}/package.json`,
+        external: options.external,
+        format: options.format,
+    };
+    if (options.rollupConfig) {
+        buildOptions.rollupConfig = options.rollupConfig;
+    }
+    if (tree.exists((0, devkit_1.joinPathFragments)(project.root, 'README.md'))) {
+        buildOptions.assets = [
+            {
+                glob: `${project.root}/README.md`,
+                input: '.',
+                output: '.',
+            },
+        ];
+    }
+    (0, devkit_1.updateProjectConfiguration)(tree, options.project, {
+        ...project,
+        targets: {
+            ...project.targets,
+            [options.buildTarget]: {
+                executor: '@nx/rollup:rollup',
+                outputs: ['{options.outputPath}'],
+                defaultConfiguration: 'production',
+                options: buildOptions,
+                configurations: {
+                    production: {
+                        optimization: true,
+                        sourceMap: false,
+                        namedChunks: false,
+                        extractLicenses: true,
+                        vendorChunk: false,
+                    },
+                },
+            },
+        },
+    });
+}
+exports.default = configurationGenerator;

package/src/generators/configuration/schema.d.ts

@@ -0,0 +1,14 @@
+export interface RollupProjectSchema {
+  project: string;
+  main?: string;
+  tsConfig?: string;
+  compiler?: 'babel' | 'swc' | 'tsc';
+  skipFormat?: boolean;
+  skipPackageJson?: boolean;
+  skipValidation?: boolean;
+  importPath?: string;
+  external?: string[];
+  rollupConfig?: string;
+  buildTarget?: string;
+  format?: ('cjs' | 'esm')[];
+}