@nx/rollup 17.0.4 → 17.0.6

package/LICENSE

@@ -1,6 +1,6 @@
 (The MIT License)
 
-Copyright (c) 2017-2024 Narwhal Technologies Inc.
+Copyright (c) 2017-2023 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,9 +1,4 @@
-<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>
+<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>
 
 <div style="text-align: center;">
 
@@ -20,9 +15,9 @@
 
 <hr>
 
-# Nx: Smart Monorepos · Fast CI
+# Nx: Smart, Fast and Extensible Build System
 
-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.
+Nx is a next generation build system with first class monorepo support and powerful integrations.
 
 This package is a [Rollup plugin for Nx](https://nx.dev/packages/rollup).
 
@@ -64,5 +59,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 Monorepos · Fast CI"></a></p>
+width="100%" alt="Nx - Smart, Fast and Extensible Build System"></a></p>
 

package/migrations.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/rollup",
-  "version": "17.0.4",
+  "version": "v17.0.6",
   "private": false,
   "description": "The Nx Plugin for Rollup contains executors and generators that support building applications using Rollup.",
   "repository": {
@@ -37,16 +37,18 @@
     "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.36.0",
+    "rollup-plugin-typescript2": "0.34.1",
+    "rxjs": "^7.8.0",
     "tslib": "^2.3.0",
-    "@nx/devkit": "17.0.4",
-    "@nx/js": "17.0.4",
-    "@nrwl/rollup": "17.0.4"
+    "@nx/devkit": "v17.0.6",
+    "@nx/js": "v17.0.6",
+    "@nrwl/rollup": "v17.0.6"
   },
   "publishConfig": {
     "access": "public"

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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,15 @@
+"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;

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

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

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

@@ -1,15 +1,12 @@
 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 declare function rollupExecutor(rawOptions: RollupExecutorOptions, context: ExecutorContext): AsyncGenerator<never, AsyncIterable<unknown> | {
+export type RollupExecutorEvent = {
     success: boolean;
-    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>;
+    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[];
 export default rollupExecutor;

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

@@ -6,18 +6,20 @@ 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");
-const async_iterable_1 = require("@nx/devkit/src/utils/async-iterable");
+const type_definitions_1 = require("@nx/js/src/plugins/rollup/type-definitions");
 // These use require because the ES import isn't correct.
 const commonjs = require('@rollup/plugin-commonjs');
 const image = require('@rollup/plugin-image');
@@ -29,18 +31,17 @@ async function* rollupExecutor(rawOptions, context) {
     process.env.NODE_ENV ??= 'production';
     const project = context.projectsConfigurations.projects[context.projectName];
     const sourceRoot = project.sourceRoot;
-    const { dependencies } = (0, buildable_libs_utils_1.calculateProjectBuildableDependencies)(context.taskGraph, context.projectGraph, context.root, context.projectName, context.targetName, context.configurationName, true);
+    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 rollupOptions = createRollupOptions(options, dependencies, context, packageJson, sourceRoot, npmDeps);
     const outfile = resolveOutfile(context, options);
     if (options.watch) {
-        // region Watch build
-        return (0, async_iterable_1.createAsyncIterable)(({ next }) => {
-            const watcher = rollup.watch(rollupOptions);
+        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}...`);
@@ -48,54 +49,51 @@ 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...');
-                    next({ success: true, outfile });
+                    obs.next({ success: true, outfile });
                 }
                 else if (data.code === 'ERROR') {
                     devkit_1.logger.error(`Error during bundle: ${data.error.message}`);
-                    next({ success: false });
+                    obs.next({ success: false });
                 }
             });
-            const processExitListener = (signal) => () => {
-                watcher.close();
-            };
-            process.once('SIGTERM', processExitListener);
-            process.once('SIGINT', processExitListener);
-            process.once('SIGQUIT', processExitListener);
-        });
-        // endregion
+            // Teardown logic. Close watcher when unsubscribed.
+            return () => watcher.close();
+        }));
     }
     else {
-        // 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 };
-        }
-        catch {
-            devkit_1.logger.error(`Bundle failed: ${context.projectName}`);
-            return { success: false };
+        devkit_1.logger.info(`Bundling ${context.projectName}...`);
+        // Delete output path before bundling
+        if (options.deleteOutputPath) {
+            (0, fs_1.deleteOutputDir)(context.root, options.outputPath);
         }
-        // endregion
+        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) {
+function createRollupOptions(options, dependencies, context, packageJson, sourceRoot, npmDeps) {
     const useBabel = options.compiler === 'babel';
     const useTsc = options.compiler === 'tsc';
     const useSwc = options.compiler === 'swc';
@@ -105,129 +103,112 @@ async function createRollupOptions(options, dependencies, context, packageJson,
     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 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),
-            },
-        }),
-        (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,
+    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,
+                    },
                 },
-                cwd: (0, path_1.join)(context.root, sourceRoot),
-                rootMode: options.babelUpwardRootMode ? 'upward' : undefined,
-                babelrc: true,
+            }),
+            (0, plugin_node_resolve_1.default)({
+                preferBuiltins: 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);
+            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);
         }
-        else {
-            finalConfig = {
-                ...finalConfig,
-                ...config,
-                plugins: [
-                    ...(finalConfig.plugins?.length > 0 ? finalConfig.plugins : []),
-                    ...(config.plugins?.length > 0 ? config.plugins : []),
-                ],
-            };
+        else if (Array.isArray(options.external) && options.external.length > 0) {
+            externalPackages = externalPackages.concat(options.external);
         }
-    }
-    return finalConfig;
+        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,
+        };
+        return options.rollupConfig.reduce((currentConfig, plugin) => {
+            return require(plugin)(currentConfig, options);
+        }, rollupConfig);
+    });
 }
 exports.createRollupOptions = createRollupOptions;
 function createTsCompilerOptions(config, dependencies, options) {

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

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

package/src/generators/configuration/configuration.js

@@ -4,21 +4,16 @@ 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));
-    }
+    const task = await (0, init_1.rollupInitGenerator)(tree, {
+        ...options,
+        skipFormat: true,
+    });
     options.buildTarget ??= 'build';
     checkForTargetConflicts(tree, options);
     addBuildTarget(tree, options);
-    if (!options.skipFormat) {
-        await (0, devkit_1.formatFiles)(tree);
-    }
-    return (0, devkit_1.runTasksInSerial)(...tasks);
+    await (0, devkit_1.formatFiles)(tree);
+    return task;
 }
 exports.configurationGenerator = configurationGenerator;
 function checkForTargetConflicts(tree, options) {
@@ -30,7 +25,6 @@ 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": "https://json-schema.org/schema",
+  "$schema": "http://json-schema.org/schema",
   "$id": "NxRollupProject",
   "cli": "nx",
   "title": "Add Rollup Configuration to a project",

package/src/generators/init/init.js

@@ -2,38 +2,23 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.rollupInitGenerator = void 0;
 const devkit_1 = require("@nx/devkit");
-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);
-}
+const versions_1 = require("@nx/js/src/utils/versions");
+const versions_2 = require("../../utils/versions");
 async function rollupInitGenerator(tree, schema) {
-    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);
+    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,
+        });
     }
-    if (schema.updatePackageScripts) {
-        await (0, update_package_scripts_1.updatePackageScripts)(tree, plugin_1.createNodes);
+    else {
+        task = (0, devkit_1.addDependenciesToPackageJson)(tree, {}, {
+            '@nx/rollup': versions_2.nxVersion,
+            tslib: versions_2.tsLibVersion,
+        });
     }
     if (!schema.skipFormat) {
         await (0, devkit_1.formatFiles)(tree);

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

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

package/src/generators/init/schema.json

@@ -1,32 +1,21 @@
 {
-  "$schema": "https://json-schema.org/schema",
+  "$schema": "http://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/utils/versions.d.ts

@@ -1,4 +1,3 @@
 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,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.coreJsVersion = exports.tsLibVersion = exports.swcLoaderVersion = exports.nxVersion = void 0;
+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/plugin.d.ts

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

package/plugin.js

@@ -1,5 +0,0 @@
-"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/plugins/plugin.d.ts

@@ -1,6 +0,0 @@
-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

@@ -1,104 +0,0 @@
-"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

@@ -1,5 +0,0 @@
-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

@@ -1,24 +0,0 @@
-"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;