@nx/rollup 17.0.2 → 17.0.4

package/LICENSE

@@ -1,6 +1,6 @@
 (The MIT License)
 
-Copyright (c) 2017-2023 Narwhal Technologies Inc.
+Copyright (c) 2017-2024 Narwhal Technologies Inc.
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

package/README.md

@@ -1,4 +1,9 @@
-<p style="text-align: center;"><img src="https://raw.githubusercontent.com/nrwl/nx/master/images/nx.png" width="600" alt="Nx - Smart, Fast and Extensible Build System"></p>
+<p style="text-align: center;">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/nrwl/nx/master/images/nx-dark.svg">
+    <img alt="Nx - Smart Monorepos · Fast CI" src="https://raw.githubusercontent.com/nrwl/nx/master/images/nx-light.svg" width="100%">
+  </picture>
+</p>
 
 <div style="text-align: center;">
 
@@ -15,9 +20,9 @@
 
 <hr>
 
-# Nx: Smart, Fast and Extensible Build System
+# Nx: Smart Monorepos · Fast CI
 
-Nx is a next generation build system with first class monorepo support and powerful integrations.
+Nx is a build system with built-in tooling and advanced CI capabilities. It helps you maintain and scale monorepos, both locally and on CI.
 
 This package is a [Rollup plugin for Nx](https://nx.dev/packages/rollup).
 
@@ -59,5 +64,5 @@ npx nx@latest init
 - [Blog Posts About Nx](https://blog.nrwl.io/nx/home)
 
 <p style="text-align: center;"><a href="https://nx.dev/#learning-materials" target="_blank" rel="noreferrer"><img src="https://raw.githubusercontent.com/nrwl/nx/master/images/nx-courses-and-videos.svg" 
-width="100%" alt="Nx - Smart, Fast and Extensible Build System"></a></p>
+width="100%" alt="Nx - Smart Monorepos · Fast CI"></a></p>
 

package/migrations.json

@@ -25,5 +25,15 @@
       "factory": "./src/migrations/update-16-6-0/explicitly-set-projects-to-update-buildable-deps"
     }
   },
-  "packageJsonUpdates": {}
+  "packageJsonUpdates": {
+    "18.2.0": {
+      "version": "18.2.0-beta.1",
+      "packages": {
+        "core-js": {
+          "version": "3.36.1",
+          "alwaysAddToPackageJson": false
+        }
+      }
+    }
+  }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/rollup",
-  "version": "17.0.2",
+  "version": "17.0.4",
   "private": false,
   "description": "The Nx Plugin for Rollup contains executors and generators that support building applications using Rollup.",
   "repository": {
@@ -37,18 +37,16 @@
     "autoprefixer": "^10.4.9",
     "babel-plugin-transform-async-to-promises": "^0.8.15",
     "chalk": "^4.1.0",
-    "fast-glob": "^3.2.7",
     "postcss": "^8.4.14",
     "rollup": "^2.56.2",
     "rollup-plugin-copy": "^3.4.0",
     "rollup-plugin-peer-deps-external": "^2.2.4",
     "rollup-plugin-postcss": "^4.0.1",
-    "rollup-plugin-typescript2": "0.34.1",
-    "rxjs": "^7.8.0",
+    "rollup-plugin-typescript2": "0.36.0",
     "tslib": "^2.3.0",
-    "@nx/devkit": "17.0.2",
-    "@nx/js": "17.0.2",
-    "@nrwl/rollup": "17.0.2"
+    "@nx/devkit": "17.0.4",
+    "@nx/js": "17.0.4",
+    "@nrwl/rollup": "17.0.4"
   },
   "publishConfig": {
     "access": "public"

package/plugin.d.ts

@@ -0,0 +1 @@
+export { createNodes, RollupPluginOptions } from './src/plugins/plugin';

package/plugin.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNodes = void 0;
+var plugin_1 = require("./src/plugins/plugin");
+Object.defineProperty(exports, "createNodes", { enumerable: true, get: function () { return plugin_1.createNodes; } });

package/src/executors/rollup/lib/update-package-json.js

@@ -21,7 +21,8 @@ function updatePackageJson(options, packageJson) {
         });
         packageJson.module = esmExports['.'];
         if (!hasCjsFormat) {
-            packageJson.type = 'module';
+            if (!options.skipTypeField)
+                packageJson.type = 'module';
             packageJson.main ??= esmExports['.'];
         }
         if (options.generateExportsField) {

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

@@ -1,12 +1,15 @@
 import * as rollup from 'rollup';
-import type { ExecutorContext } from '@nx/devkit';
+import { type ExecutorContext } from '@nx/devkit';
 import { DependentBuildableProjectNode } from '@nx/js/src/utils/buildable-libs-utils';
+import type { PackageJson } from 'nx/src/utils/package-json';
 import { RollupExecutorOptions } from './schema';
 import { NormalizedRollupExecutorOptions } from './lib/normalize';
-export type RollupExecutorEvent = {
+export declare function rollupExecutor(rawOptions: RollupExecutorOptions, context: ExecutorContext): AsyncGenerator<never, AsyncIterable<unknown> | {
     success: boolean;
-    outfile?: string;
-};
-export declare function rollupExecutor(rawOptions: RollupExecutorOptions, context: ExecutorContext): AsyncGenerator<RollupExecutorEvent, any, undefined>;
-export declare function createRollupOptions(options: NormalizedRollupExecutorOptions, dependencies: DependentBuildableProjectNode[], context: ExecutorContext, packageJson: any, sourceRoot: string, npmDeps: string[]): rollup.InputOptions[];
+    outfile: string;
+} | {
+    success: boolean;
+    outfile?: undefined;
+}, unknown>;
+export declare function createRollupOptions(options: NormalizedRollupExecutorOptions, dependencies: DependentBuildableProjectNode[], context: ExecutorContext, packageJson: PackageJson, sourceRoot: string, npmDeps: string[]): Promise<rollup.RollupOptions>;
 export default rollupExecutor;

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

@@ -6,20 +6,18 @@ 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 run_rollup_1 = require("./lib/run-rollup");
+const type_definitions_1 = require("@nx/js/src/plugins/rollup/type-definitions");
 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 type_definitions_1 = require("@nx/js/src/plugins/rollup/type-definitions");
+const config_utils_1 = require("@nx/devkit/src/utils/config-utils");
+const async_iterable_1 = require("@nx/devkit/src/utils/async-iterable");
 // These use require because the ES import isn't correct.
 const commonjs = require('@rollup/plugin-commonjs');
 const image = require('@rollup/plugin-image');
@@ -31,17 +29,18 @@ 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 { 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 = createRollupOptions(options, dependencies, context, packageJson, sourceRoot, npmDeps);
+    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) => {
+        // region Watch build
+        return (0, async_iterable_1.createAsyncIterable)(({ next }) => {
+            const watcher = rollup.watch(rollupOptions);
             watcher.on('event', (data) => {
                 if (data.code === 'START') {
                     devkit_1.logger.info(`Bundling ${context.projectName}...`);
@@ -49,51 +48,54 @@ async function* rollupExecutor(rawOptions, context) {
                 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 });
+                    next({ success: true, outfile });
                 }
                 else if (data.code === 'ERROR') {
                     devkit_1.logger.error(`Error during bundle: ${data.error.message}`);
-                    obs.next({ success: false });
+                    next({ success: false });
                 }
             });
-            // Teardown logic. Close watcher when unsubscribed.
-            return () => watcher.close();
-        }));
+            const processExitListener = (signal) => () => {
+                watcher.close();
+            };
+            process.once('SIGTERM', processExitListener);
+            process.once('SIGINT', processExitListener);
+            process.once('SIGQUIT', processExitListener);
+        });
+        // endregion
     }
     else {
-        devkit_1.logger.info(`Bundling ${context.projectName}...`);
-        // Delete output path before bundling
-        if (options.deleteOutputPath) {
-            (0, fs_1.deleteOutputDir)(context.root, options.outputPath);
+        // region Single build
+        try {
+            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();
+            const bundle = await rollup.rollup(rollupOptions);
+            const output = Array.isArray(rollupOptions.output)
+                ? rollupOptions.output
+                : [rollupOptions.output];
+            for (const o of output) {
+                await bundle.write(o);
+            }
+            const end = process.hrtime.bigint();
+            const duration = `${(Number(end - start) / 1_000_000_000).toFixed(2)}s`;
+            (0, update_package_json_1.updatePackageJson)(options, packageJson);
+            devkit_1.logger.info(`⚡ Done in ${duration}`);
+            return { success: true, outfile };
         }
-        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();
+        catch {
+            devkit_1.logger.error(`Bundle failed: ${context.projectName}`);
+            return { success: false };
+        }
+        // endregion
     }
 }
 exports.rollupExecutor = rollupExecutor;
 // -----------------------------------------------------------------------------
-function createRollupOptions(options, dependencies, context, packageJson, sourceRoot, npmDeps) {
+async function createRollupOptions(options, dependencies, context, packageJson, sourceRoot, npmDeps) {
     const useBabel = options.compiler === 'babel';
     const useTsc = options.compiler === 'tsc';
     const useSwc = options.compiler === 'swc';
@@ -103,112 +105,129 @@ function createRollupOptions(options, dependencies, context, packageJson, source
     if (!options.format || !options.format.length) {
         options.format = readCompatibleFormats(config);
     }
-    return options.format.map((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,
-                    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);
+    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.`);
         }
-        else if (Array.isArray(options.external) && options.external.length > 0) {
-            externalPackages = externalPackages.concat(options.external);
+        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.`);
         }
-        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`,
+        options.format = ['cjs'];
+    }
+    const plugins = [
+        copy({
+            targets: convertCopyAssetsToRollupOptions(options.outputPath, options.assets),
+        }),
+        image(),
+        json(),
+        // Needed to generate type definitions, even if we're using babel or swc.
+        require('rollup-plugin-typescript2')({
+            check: !options.skipTypeCheck,
+            tsconfig: options.tsConfig,
+            tsconfigOverride: {
+                compilerOptions: createTsCompilerOptions(config, dependencies, options),
             },
-            external: (id) => {
-                return externalPackages.some((name) => id === name || id.startsWith(`${name}/`)); // Could be a deep import
+        }),
+        (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,
+                },
             },
-            plugins,
-        };
-        return options.rollupConfig.reduce((currentConfig, plugin) => {
-            return require(plugin)(currentConfig, options);
-        }, rollupConfig);
+        }),
+        (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/,
+            }),
+        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: options.format.map((format) => ({
+            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;
 }
 exports.createRollupOptions = createRollupOptions;
 function createTsCompilerOptions(config, dependencies, options) {

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

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

package/src/generators/configuration/configuration.js

@@ -4,16 +4,21 @@ 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 task = await (0, init_1.rollupInitGenerator)(tree, {
-        ...options,
-        skipFormat: true,
-    });
+    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);
-    await (0, devkit_1.formatFiles)(tree);
-    return task;
+    if (!options.skipFormat) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+    return (0, devkit_1.runTasksInSerial)(...tasks);
 }
 exports.configurationGenerator = configurationGenerator;
 function checkForTargetConflicts(tree, options) {
@@ -25,6 +30,7 @@ function checkForTargetConflicts(tree, options) {
     }
 }
 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)) {

package/src/generators/configuration/schema.json

@@ -1,5 +1,5 @@
 {
-  "$schema": "http://json-schema.org/schema",
+  "$schema": "https://json-schema.org/schema",
   "$id": "NxRollupProject",
   "cli": "nx",
   "title": "Add Rollup Configuration to a project",

package/src/generators/init/init.js

@@ -2,23 +2,38 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.rollupInitGenerator = void 0;
 const devkit_1 = require("@nx/devkit");
-const versions_1 = require("@nx/js/src/utils/versions");
-const versions_2 = require("../../utils/versions");
+const versions_1 = require("../../utils/versions");
+const update_package_scripts_1 = require("@nx/devkit/src/utils/update-package-scripts");
+const plugin_1 = require("../../plugins/plugin");
+function addPlugin(tree) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    nxJson.plugins ??= [];
+    for (const plugin of nxJson.plugins) {
+        if (typeof plugin === 'string'
+            ? plugin === '@nx/rollup/plugin'
+            : plugin.plugin === '@nx/rollup/plugin') {
+            return;
+        }
+    }
+    nxJson.plugins.push({
+        plugin: '@nx/rollup/plugin',
+        options: {
+            buildTargetName: 'build',
+        },
+    });
+    (0, devkit_1.updateNxJson)(tree, nxJson);
+}
 async function rollupInitGenerator(tree, schema) {
-    let task;
-    if (schema.compiler === 'swc') {
-        task = (0, devkit_1.addDependenciesToPackageJson)(tree, {}, {
-            '@nx/rollup': versions_2.nxVersion,
-            '@swc/helpers': versions_1.swcHelpersVersion,
-            '@swc/core': versions_1.swcCoreVersion,
-            'swc-loader': versions_2.swcLoaderVersion,
-        });
+    let task = () => { };
+    if (!schema.skipPackageJson) {
+        task = (0, devkit_1.addDependenciesToPackageJson)(tree, {}, { '@nx/rollup': versions_1.nxVersion }, undefined, schema.keepExistingVersions);
+    }
+    schema.addPlugin ??= process.env.NX_ADD_PLUGINS !== 'false';
+    if (schema.addPlugin) {
+        addPlugin(tree);
     }
-    else {
-        task = (0, devkit_1.addDependenciesToPackageJson)(tree, {}, {
-            '@nx/rollup': versions_2.nxVersion,
-            tslib: versions_2.tsLibVersion,
-        });
+    if (schema.updatePackageScripts) {
+        await (0, update_package_scripts_1.updatePackageScripts)(tree, plugin_1.createNodes);
     }
     if (!schema.skipFormat) {
         await (0, devkit_1.formatFiles)(tree);

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

@@ -1,4 +1,7 @@
 export interface Schema {
-  compiler?: 'babel' | 'swc' | 'tsc';
   skipFormat?: boolean;
+  skipPackageJson?: boolean;
+  keepExistingVersions?: boolean;
+  updatePackageScripts?: boolean;
+  addPlugin?: boolean;
 }

package/src/generators/init/schema.json

@@ -1,21 +1,32 @@
 {
-  "$schema": "http://json-schema.org/schema",
+  "$schema": "https://json-schema.org/schema",
   "$id": "NxWebpackInit",
   "cli": "nx",
   "title": "Init Webpack Plugin",
   "description": "Init Webpack Plugin.",
   "type": "object",
   "properties": {
-    "compiler": {
-      "type": "string",
-      "enum": ["babel", "swc", "tsc"],
-      "description": "The compiler to initialize for.",
-      "default": "babel"
-    },
     "skipFormat": {
       "description": "Skip formatting files.",
       "type": "boolean",
       "default": false
+    },
+    "skipPackageJson": {
+      "description": "Do not add dependencies to `package.json`.",
+      "type": "boolean",
+      "default": false
+    },
+    "keepExistingVersions": {
+      "type": "boolean",
+      "x-priority": "internal",
+      "description": "Keep existing dependencies versions",
+      "default": false
+    },
+    "updatePackageScripts": {
+      "type": "boolean",
+      "x-priority": "internal",
+      "description": "Update `package.json` scripts with inferred targets",
+      "default": false
     }
   },
   "required": []

package/src/plugins/plugin.d.ts

@@ -0,0 +1,6 @@
+import { type CreateDependencies, type CreateNodes } from '@nx/devkit';
+export declare const createDependencies: CreateDependencies;
+export interface RollupPluginOptions {
+    buildTargetName?: string;
+}
+export declare const createNodes: CreateNodes<RollupPluginOptions>;

package/src/plugins/plugin.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNodes = exports.createDependencies = void 0;
+const cache_directory_1 = require("nx/src/utils/cache-directory");
+const path_1 = require("path");
+const fs_1 = require("fs");
+const devkit_1 = require("@nx/devkit");
+const calculate_hash_for_create_nodes_1 = require("@nx/devkit/src/utils/calculate-hash-for-create-nodes");
+const js_1 = require("@nx/js");
+const get_named_inputs_1 = require("@nx/devkit/src/utils/get-named-inputs");
+const loadConfigFile = require("rollup/dist/loadConfigFile");
+const cachePath = (0, path_1.join)(cache_directory_1.projectGraphCacheDirectory, 'rollup.hash');
+const targetsCache = (0, fs_1.existsSync)(cachePath) ? readTargetsCache() : {};
+const calculatedTargets = {};
+function readTargetsCache() {
+    return (0, devkit_1.readJsonFile)(cachePath);
+}
+function writeTargetsToCache(targets) {
+    (0, devkit_1.writeJsonFile)(cachePath, targets);
+}
+const createDependencies = () => {
+    writeTargetsToCache(calculatedTargets);
+    return [];
+};
+exports.createDependencies = createDependencies;
+exports.createNodes = [
+    '**/rollup.config.{js,cjs,mjs}',
+    async (configFilePath, options, context) => {
+        const projectRoot = (0, path_1.dirname)(configFilePath);
+        const fullyQualifiedProjectRoot = (0, path_1.join)(context.workspaceRoot, projectRoot);
+        // Do not create a project if package.json and project.json do not exist
+        const siblingFiles = (0, fs_1.readdirSync)(fullyQualifiedProjectRoot);
+        if (!siblingFiles.includes('package.json') &&
+            !siblingFiles.includes('project.json')) {
+            return {};
+        }
+        options = normalizeOptions(options);
+        const hash = (0, calculate_hash_for_create_nodes_1.calculateHashForCreateNodes)(projectRoot, options, context, [
+            (0, js_1.getLockFileName)((0, devkit_1.detectPackageManager)(context.workspaceRoot)),
+        ]);
+        const targets = targetsCache[hash]
+            ? targetsCache[hash]
+            : await buildRollupTarget(configFilePath, projectRoot, options, context);
+        calculatedTargets[hash] = targets;
+        return {
+            projects: {
+                [projectRoot]: {
+                    root: projectRoot,
+                    targets,
+                },
+            },
+        };
+    },
+];
+async function buildRollupTarget(configFilePath, projectRoot, options, context) {
+    const namedInputs = (0, get_named_inputs_1.getNamedInputs)(projectRoot, context);
+    const rollupConfig = (await loadConfigFile((0, devkit_1.joinPathFragments)(context.workspaceRoot, configFilePath))).options;
+    const outputs = getOutputs(rollupConfig, projectRoot);
+    const targets = {};
+    targets[options.buildTargetName] = {
+        command: `rollup -c ${(0, path_1.basename)(configFilePath)}`,
+        options: { cwd: projectRoot },
+        cache: true,
+        dependsOn: [`^${options.buildTargetName}`],
+        inputs: [
+            ...('production' in namedInputs
+                ? ['production', '^production']
+                : ['default', '^default']),
+        ],
+        outputs,
+    };
+    return targets;
+}
+function getOutputs(rollupConfigs, projectRoot) {
+    const outputs = new Set();
+    for (const rollupConfig of rollupConfigs) {
+        if (rollupConfig.output) {
+            const rollupConfigOutputs = [];
+            if (Array.isArray(rollupConfig.output)) {
+                rollupConfigOutputs.push(...rollupConfig.output);
+            }
+            else {
+                rollupConfigOutputs.push(rollupConfig.output);
+            }
+            for (const output of rollupConfigOutputs) {
+                const outputPathFromConfig = output.dir
+                    ? output.dir
+                    : output.file
+                        ? (0, path_1.dirname)(output.file)
+                        : 'dist';
+                const outputPath = projectRoot === '.'
+                    ? (0, devkit_1.joinPathFragments)(`{workspaceRoot}`, outputPathFromConfig)
+                    : (0, devkit_1.joinPathFragments)(`{workspaceRoot}`, projectRoot, outputPathFromConfig);
+                outputs.add(outputPath);
+            }
+        }
+    }
+    return Array.from(outputs);
+}
+function normalizeOptions(options) {
+    options ??= {};
+    options.buildTargetName ??= 'build';
+    return options;
+}

package/src/utils/ensure-dependencies.d.ts

@@ -0,0 +1,5 @@
+import { type GeneratorCallback, type Tree } from '@nx/devkit';
+export type EnsureDependenciesOptions = {
+    compiler?: 'babel' | 'swc' | 'tsc';
+};
+export declare function ensureDependencies(tree: Tree, options: EnsureDependenciesOptions): GeneratorCallback;

package/src/utils/ensure-dependencies.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureDependencies = void 0;
+const devkit_1 = require("@nx/devkit");
+const versions_1 = require("@nx/js/src/utils/versions");
+const versions_2 = require("./versions");
+function ensureDependencies(tree, options) {
+    switch (options.compiler) {
+        case 'swc':
+            return (0, devkit_1.addDependenciesToPackageJson)(tree, {}, {
+                '@swc/helpers': versions_1.swcHelpersVersion,
+                '@swc/core': versions_1.swcCoreVersion,
+                'swc-loader': versions_2.swcLoaderVersion,
+            });
+        case 'babel':
+            return (0, devkit_1.addDependenciesToPackageJson)(tree, {}, {
+                'core-js': versions_2.coreJsVersion, // needed for preset-env to work
+                tslib: versions_2.tsLibVersion,
+            });
+        default:
+            return (0, devkit_1.addDependenciesToPackageJson)(tree, {}, { tslib: versions_2.tsLibVersion });
+    }
+}
+exports.ensureDependencies = ensureDependencies;

package/src/utils/versions.d.ts

@@ -1,3 +1,4 @@
 export declare const nxVersion: any;
 export declare const swcLoaderVersion = "0.1.15";
 export declare const tsLibVersion = "^2.3.0";
+export declare const coreJsVersion = "^3.36.1";

package/src/utils/versions.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.tsLibVersion = exports.swcLoaderVersion = exports.nxVersion = void 0;
+exports.coreJsVersion = exports.tsLibVersion = exports.swcLoaderVersion = exports.nxVersion = void 0;
 exports.nxVersion = require('../../package.json').version;
 exports.swcLoaderVersion = '0.1.15';
 exports.tsLibVersion = '^2.3.0';
+exports.coreJsVersion = '^3.36.1';

package/src/executors/rollup/lib/run-rollup.d.ts

@@ -1,4 +0,0 @@
-import * as rollup from 'rollup';
-export declare function runRollup(options: rollup.RollupOptions): import("rxjs").Observable<{
-    success: boolean;
-}>;

package/src/executors/rollup/lib/run-rollup.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.runRollup = void 0;
-const rollup = require("rollup");
-const rxjs_1 = require("rxjs");
-const operators_1 = require("rxjs/operators");
-function runRollup(options) {
-    return (0, rxjs_1.from)(rollup.rollup(options)).pipe((0, operators_1.switchMap)((bundle) => {
-        const outputOptions = Array.isArray(options.output)
-            ? options.output
-            : [options.output];
-        return (0, rxjs_1.from)(Promise.all(outputOptions.map((o) => bundle.write(o))));
-    }), (0, operators_1.map)(() => ({ success: true })));
-}
-exports.runRollup = runRollup;