@nx/rollup 0.0.0-pr-22179-271588f → 0.0.0-pr-26482-ebe2dba

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

@@ -24,7 +24,7 @@
 
 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).
+This package is a [Rollup plugin for Nx](https://nx.dev/nx-api/rollup).
 
 ## Getting Started
 

package/migrations.json

@@ -1,11 +1,5 @@
 {
   "generators": {
-    "add-babel-inputs": {
-      "cli": "nx",
-      "version": "15.0.0-beta.0",
-      "description": "Adds babel.config.json to the hash of all tasks",
-      "factory": "./src/migrations/update-15-0-0/add-babel-inputs"
-    },
     "update-16-0-0-add-nx-packages": {
       "cli": "nx",
       "version": "16.0.0-beta.1",
@@ -25,5 +19,28 @@
       "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
+        }
+      }
+    },
+    "19.0.0": {
+      "version": "19.0.0-beta.0",
+      "packages": {
+        "@rollup/plugin-url": {
+          "version": "^8.0.2",
+          "alwaysAddToPackageJson": false
+        },
+        "@svgr/rollup": {
+          "version": "^8.1.0",
+          "alwaysAddToPackageJson": false
+        }
+      }
+    }
+  }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/rollup",
-  "version": "0.0.0-pr-22179-271588f",
+  "version": "0.0.0-pr-26482-ebe2dba",
   "private": false,
   "description": "The Nx Plugin for Rollup contains executors and generators that support building applications using Rollup.",
   "repository": {
@@ -14,7 +14,7 @@
     "Web",
     "CLI"
   ],
-  "main": "./index.js",
+  "main": "./index",
   "typings": "./index.d.ts",
   "author": "Victor Savkin",
   "license": "MIT",
@@ -29,36 +29,26 @@
     "migrations": "./migrations.json"
   },
   "dependencies": {
-    "@rollup/plugin-babel": "^5.3.0",
-    "@rollup/plugin-commonjs": "^20.0.0",
-    "@rollup/plugin-image": "^2.1.0",
-    "@rollup/plugin-json": "^4.1.0",
-    "@rollup/plugin-node-resolve": "^13.0.4",
+    "@rollup/plugin-babel": "^6.0.4",
+    "@rollup/plugin-commonjs": "^25.0.7",
+    "@rollup/plugin-image": "^3.0.3",
+    "@rollup/plugin-json": "^6.1.0",
+    "@rollup/plugin-node-resolve": "^15.2.3",
     "autoprefixer": "^10.4.9",
     "babel-plugin-transform-async-to-promises": "^0.8.15",
     "chalk": "^4.1.0",
-    "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",
-    "rxjs": "^7.8.0",
+    "postcss": "^8.4.38",
+    "rollup": "^4.14.0",
+    "rollup-plugin-copy": "^3.5.0",
+    "rollup-plugin-postcss": "^4.0.2",
+    "rollup-plugin-typescript2": "^0.36.0",
     "tslib": "^2.3.0",
-    "@nx/devkit": "0.0.0-pr-22179-271588f",
-    "@nx/js": "0.0.0-pr-22179-271588f",
-    "@nrwl/rollup": "0.0.0-pr-22179-271588f"
+    "@nx/devkit": "0.0.0-pr-26482-ebe2dba",
+    "@nx/js": "0.0.0-pr-26482-ebe2dba",
+    "@nrwl/rollup": "0.0.0-pr-26482-ebe2dba"
   },
   "publishConfig": {
     "access": "public"
   },
-  "exports": {
-    "./package.json": "./package.json",
-    ".": "./index.js",
-    "./executors.json": "./executors.json",
-    "./generators.json": "./generators.json",
-    "./migrations.json": "./migrations.json",
-    "./plugin": "./plugin.js"
-  },
   "type": "commonjs"
 }

package/src/executors/rollup/lib/normalize.d.ts

@@ -1,11 +1,8 @@
 import { ExecutorContext } from '@nx/devkit';
-import type { AssetGlobPattern, RollupExecutorOptions } from '../schema';
+import type { RollupExecutorOptions } from '../schema';
 export interface NormalizedRollupExecutorOptions extends RollupExecutorOptions {
-    entryRoot: string;
     projectRoot: string;
-    assets: AssetGlobPattern[];
     rollupConfig: string[];
 }
-export declare function normalizeRollupExecutorOptions(options: RollupExecutorOptions, context: ExecutorContext, sourceRoot: string): NormalizedRollupExecutorOptions;
+export declare function normalizeRollupExecutorOptions(options: RollupExecutorOptions, context: ExecutorContext): NormalizedRollupExecutorOptions;
 export declare function normalizePluginPath(pluginPath: void | string, root: string): string;
-export declare function normalizeAssets(assets: any[], root: string, sourceRoot: string): AssetGlobPattern[];

package/src/executors/rollup/lib/normalize.js

@@ -1,37 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizeAssets = exports.normalizePluginPath = exports.normalizeRollupExecutorOptions = void 0;
+exports.normalizePluginPath = exports.normalizeRollupExecutorOptions = void 0;
 const path_1 = require("path");
-const fs_1 = require("fs");
-const devkit_1 = require("@nx/devkit");
-const js_1 = require("@nx/js");
-function normalizeRollupExecutorOptions(options, context, sourceRoot) {
+function normalizeRollupExecutorOptions(options, context) {
     const { root } = context;
-    const main = `${root}/${options.main}`;
-    const entryRoot = (0, path_1.dirname)(main);
-    const project = options.project
-        ? `${root}/${options.project}`
-        : (0, path_1.join)(root, 'package.json');
-    const projectRoot = (0, path_1.dirname)(project);
-    const outputPath = `${root}/${options.outputPath}`;
     return {
         ...options,
-        // de-dupe formats
-        format: Array.from(new Set(options.format)),
         rollupConfig: []
             .concat(options.rollupConfig)
             .filter(Boolean)
             .map((p) => normalizePluginPath(p, root)),
-        assets: options.assets
-            ? normalizeAssets(options.assets, root, sourceRoot)
-            : undefined,
-        main,
-        entryRoot,
-        project,
-        projectRoot,
-        outputPath,
+        projectRoot: context.projectGraph.nodes[context.projectName].data.root,
         skipTypeCheck: options.skipTypeCheck || false,
-        additionalEntryPoints: (0, js_1.createEntryPoints)(options.additionalEntryPoints, context.root),
     };
 }
 exports.normalizeRollupExecutorOptions = normalizeRollupExecutorOptions;
@@ -47,40 +27,3 @@ function normalizePluginPath(pluginPath, root) {
     }
 }
 exports.normalizePluginPath = normalizePluginPath;
-function normalizeAssets(assets, root, sourceRoot) {
-    return assets.map((asset) => {
-        if (typeof asset === 'string') {
-            const assetPath = (0, devkit_1.normalizePath)(asset);
-            const resolvedAssetPath = (0, path_1.resolve)(root, assetPath);
-            const resolvedSourceRoot = (0, path_1.resolve)(root, sourceRoot);
-            if (!resolvedAssetPath.startsWith(resolvedSourceRoot)) {
-                throw new Error(`The ${resolvedAssetPath} asset path must start with the project source root: ${sourceRoot}`);
-            }
-            const isDirectory = (0, fs_1.statSync)(resolvedAssetPath).isDirectory();
-            const input = isDirectory
-                ? resolvedAssetPath
-                : (0, path_1.dirname)(resolvedAssetPath);
-            const output = (0, path_1.relative)(resolvedSourceRoot, (0, path_1.resolve)(root, input));
-            const glob = isDirectory ? '**/*' : (0, path_1.basename)(resolvedAssetPath);
-            return {
-                input,
-                output,
-                glob,
-            };
-        }
-        else {
-            if (asset.output.startsWith('..')) {
-                throw new Error('An asset cannot be written to a location outside of the output path.');
-            }
-            const assetPath = (0, devkit_1.normalizePath)(asset.input);
-            const resolvedAssetPath = (0, path_1.resolve)(root, assetPath);
-            return {
-                ...asset,
-                input: resolvedAssetPath,
-                // Now we remove starting slash to make Webpack place it from the output root.
-                output: asset.output.replace(/^\//, ''),
-            };
-        }
-    });
-}
-exports.normalizeAssets = normalizeAssets;

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

@@ -1,13 +1,7 @@
 import * as rollup from 'rollup';
-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 { type ExecutorContext } from '@nx/devkit';
 import { RollupExecutorOptions } from './schema';
 import { NormalizedRollupExecutorOptions } from './lib/normalize';
-export type RollupExecutorEvent = {
-    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: PackageJson, sourceRoot: string, npmDeps: string[]): Promise<rollup.InputOptions[]>;
+export declare function rollupExecutor(rawOptions: RollupExecutorOptions, context: ExecutorContext): AsyncGenerator<unknown, any, undefined>;
+export declare function createRollupOptions(options: NormalizedRollupExecutorOptions, context: ExecutorContext): Promise<rollup.RollupOptions | rollup.RollupOptions[]>;
 export default rollupExecutor;

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

@@ -1,284 +1,108 @@
 "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'];
+const async_iterable_1 = require("@nx/devkit/src/utils/async-iterable");
+const with_nx_1 = require("../../plugins/with-nx/with-nx");
+const buildable_libs_utils_1 = require("@nx/js/src/utils/buildable-libs-utils");
 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 options = (0, normalize_1.normalizeRollupExecutorOptions)(rawOptions, context);
+    const rollupOptions = await createRollupOptions(options, context);
     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 yield* (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}...`);
                 }
                 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);
-        }
-        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}`);
+        // region Single build
+        try {
+            devkit_1.logger.info(`Bundling ${context.projectName}...`);
+            const start = process.hrtime.bigint();
+            const allRollupOptions = Array.isArray(rollupOptions)
+                ? rollupOptions
+                : [rollupOptions];
+            for (const opts of allRollupOptions) {
+                const bundle = await rollup.rollup(opts);
+                const output = Array.isArray(opts.output) ? opts.output : [opts.output];
+                for (const o of output) {
+                    await bundle.write(o);
                 }
-                else {
-                    devkit_1.logger.error(`Bundle failed: ${context.projectName}`);
-                }
-            },
-        }))
-            .toPromise();
+            }
+            const end = process.hrtime.bigint();
+            const duration = `${(Number(end - start) / 1_000_000_000).toFixed(2)}s`;
+            devkit_1.logger.info(`⚡ Done in ${duration}`);
+            return { success: true, outfile };
+        }
+        catch (e) {
+            if (e.formatted) {
+                devkit_1.logger.info(e.formatted);
+            }
+            else if (e.message) {
+                devkit_1.logger.info(e.message);
+            }
+            devkit_1.logger.error(e);
+            devkit_1.logger.error(`Bundle failed: ${context.projectName}`);
+            return { success: false };
+        }
+        // endregion
     }
 }
 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.`);
+async function createRollupOptions(options, context) {
+    const { dependencies } = (0, buildable_libs_utils_1.calculateProjectBuildableDependencies)(context.taskGraph, context.projectGraph, context.root, context.projectName, context.targetName, context.configurationName, true);
+    const rollupConfig = (0, with_nx_1.withNx)(options, {}, dependencies);
+    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);
         }
-        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.`);
+        else {
+            finalConfig = {
+                ...finalConfig,
+                ...config,
+                plugins: [
+                    ...(Array.isArray(finalConfig.plugins) &&
+                        finalConfig.plugins?.length > 0
+                        ? finalConfig.plugins
+                        : []),
+                    ...(config.plugins?.length > 0 ? config.plugins : []),
+                ],
+            };
         }
-        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;
+    return finalConfig;
 }
 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;

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

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