@nx/rollup 19.2.0-beta.4 → 19.2.0-beta.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/rollup",
-  "version": "19.2.0-beta.4",
+  "version": "19.2.0-beta.6",
   "private": false,
   "description": "The Nx Plugin for Rollup contains executors and generators that support building applications using Rollup.",
   "repository": {
@@ -43,9 +43,9 @@
     "rollup-plugin-postcss": "^4.0.2",
     "rollup-plugin-typescript2": "^0.36.0",
     "tslib": "^2.3.0",
-    "@nx/devkit": "19.2.0-beta.4",
-    "@nx/js": "19.2.0-beta.4",
-    "@nrwl/rollup": "19.2.0-beta.4"
+    "@nx/devkit": "19.2.0-beta.6",
+    "@nx/js": "19.2.0-beta.6",
+    "@nrwl/rollup": "19.2.0-beta.6"
   },
   "publishConfig": {
     "access": "public"

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,9 +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 { RollupExecutorOptions } from './schema';
 import { NormalizedRollupExecutorOptions } from './lib/normalize';
 export declare function rollupExecutor(rawOptions: RollupExecutorOptions, context: ExecutorContext): AsyncGenerator<unknown, any, undefined>;
-export declare function createRollupOptions(options: NormalizedRollupExecutorOptions, dependencies: DependentBuildableProjectNode[], context: ExecutorContext, packageJson: PackageJson, sourceRoot: string, npmDeps: string[]): Promise<rollup.RollupOptions | rollup.RollupOptions[]>;
+export declare function createRollupOptions(options: NormalizedRollupExecutorOptions, context: ExecutorContext): Promise<rollup.RollupOptions | rollup.RollupOptions[]>;
 export default rollupExecutor;

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

@@ -1,40 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createRollupOptions = exports.rollupExecutor = void 0;
-const ts = require("typescript");
 const rollup = require("rollup");
-const plugin_babel_1 = require("@rollup/plugin-babel");
 const path_1 = require("path");
-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 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");
-// 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 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 { 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) {
         // region Watch build
@@ -45,7 +23,6 @@ async function* rollupExecutor(rawOptions, context) {
                     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...');
                     next({ success: true, outfile });
                 }
@@ -67,10 +44,6 @@ async function* rollupExecutor(rawOptions, context) {
         // 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 allRollupOptions = Array.isArray(rollupOptions)
                 ? rollupOptions
@@ -84,7 +57,6 @@ async function* rollupExecutor(rawOptions, context) {
             }
             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 };
         }
@@ -104,116 +76,9 @@ async function* rollupExecutor(rawOptions, context) {
 }
 exports.rollupExecutor = rollupExecutor;
 // -----------------------------------------------------------------------------
-async function createRollupOptions(options, dependencies, context, packageJson, sourceRoot, npmDeps) {
-    const useBabel = options.compiler === 'babel';
-    const useSwc = options.compiler === 'swc';
-    const tsConfigPath = (0, devkit_1.joinPathFragments)(context.root, options.tsConfig);
-    const configFile = ts.readConfigFile(tsConfigPath, ts.sys.readFile);
-    const config = ts.parseJsonConfigFileContent(configFile.config, ts.sys, (0, path_1.dirname)(tsConfigPath));
-    if (!options.format || !options.format.length) {
-        options.format = readCompatibleFormats(config);
-    }
-    if (packageJson.type === 'module') {
-        if (options.format.includes('cjs')) {
-            devkit_1.logger.warn(`Package type is set to "module" but "cjs" format is included. Going to use "esm" format instead. You can change the package type to "commonjs" or remove type in the package.json file.`);
-        }
-        options.format = ['esm'];
-    }
-    else if (packageJson.type === 'commonjs') {
-        if (options.format.includes('esm')) {
-            devkit_1.logger.warn(`Package type is set to "commonjs" but "esm" format is included. Going to use "cjs" format instead. You can change the package type to "module" or remove type in the package.json file.`);
-        }
-        options.format = ['cjs'];
-    }
-    const 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,
-        }),
-        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/,
-            }),
-        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,
-    };
+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) {
@@ -238,40 +103,6 @@ async function createRollupOptions(options, dependencies, context, packageJson,
     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;

package/src/generators/configuration/configuration.js

@@ -6,21 +6,56 @@ 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");
+const has_plugin_1 = require("../../utils/has-plugin");
 async function configurationGenerator(tree, options) {
     const tasks = [];
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    const addPluginDefault = process.env.NX_ADD_PLUGINS !== 'false' &&
+        nxJson.useInferencePlugins !== false;
+    options.addPlugin ??= addPluginDefault;
     tasks.push(await (0, init_1.rollupInitGenerator)(tree, { ...options, skipFormat: true }));
     if (!options.skipPackageJson) {
         tasks.push((0, ensure_dependencies_1.ensureDependencies)(tree, options));
     }
-    options.buildTarget ??= 'build';
-    checkForTargetConflicts(tree, options);
-    addBuildTarget(tree, options);
+    if ((0, has_plugin_1.hasPlugin)(tree)) {
+        createRollupConfig(tree, options);
+    }
+    else {
+        options.buildTarget ??= 'build';
+        checkForTargetConflicts(tree, options);
+        addBuildTarget(tree, options);
+    }
+    addPackageJson(tree, options);
     if (!options.skipFormat) {
         await (0, devkit_1.formatFiles)(tree);
     }
     return (0, devkit_1.runTasksInSerial)(...tasks);
 }
 exports.configurationGenerator = configurationGenerator;
+function createRollupConfig(tree, options) {
+    const project = (0, devkit_1.readProjectConfiguration)(tree, options.project);
+    const buildOptions = {
+        outputPath: (0, devkit_1.joinPathFragments)((0, devkit_1.offsetFromRoot)(project.root), 'dist', project.root === '.' ? project.name : project.root),
+        compiler: options.compiler ?? 'babel',
+        main: options.main ?? './src/index.ts',
+        tsConfig: options.tsConfig ?? './tsconfig.lib.json',
+    };
+    tree.write((0, devkit_1.joinPathFragments)(project.root, 'rollup.config.js'), (0, devkit_1.stripIndents) `
+      const { withNx } = require('@nx/rollup/with-nx');
+      
+      module.exports = withNx({
+        main: '${buildOptions.main}',
+        outputPath: '${buildOptions.outputPath}',
+        tsConfig: '${buildOptions.tsConfig}',
+        compiler: '${buildOptions.compiler}',
+        format: ${JSON.stringify(options.format ?? ['esm'])},
+        assets:[{ input: '.', output: '.', glob:'*.md'}],
+      }, {
+        // Provide additional rollup configuration here. See: https://rollupjs.org/configuration-options
+        // e.g. 
+        // output: { sourcemap: true },
+      });`);
+}
 function checkForTargetConflicts(tree, options) {
     if (options.skipValidation)
         return;
@@ -29,8 +64,7 @@ function checkForTargetConflicts(tree, options) {
         throw new Error(`Project "${options.project}" already has a ${options.buildTarget} target. Pass --skipValidation to ignore this error.`);
     }
 }
-function addBuildTarget(tree, options) {
-    (0, add_build_target_defaults_1.addBuildTargetDefaults)(tree, '@nx/rollup:rollup', options.buildTarget);
+function addPackageJson(tree, options) {
     const project = (0, devkit_1.readProjectConfiguration)(tree, options.project);
     const packageJsonPath = (0, devkit_1.joinPathFragments)(project.root, 'package.json');
     if (!tree.exists(packageJsonPath)) {
@@ -40,11 +74,15 @@ function addBuildTarget(tree, options) {
             version: '0.0.1',
         });
     }
+}
+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 prevBuildOptions = project.targets?.[options.buildTarget]?.options;
     const buildOptions = {
         main: options.main ??
             prevBuildOptions?.main ??
-            (0, devkit_1.joinPathFragments)(project.root, 'src/main.ts'),
+            (0, devkit_1.joinPathFragments)(project.root, 'src/index.ts'),
         outputPath: prevBuildOptions?.outputPath ??
             (0, devkit_1.joinPathFragments)('dist', project.root === '.' ? project.name : project.root),
         tsConfig: options.tsConfig ??
@@ -76,17 +114,7 @@ function addBuildTarget(tree, options) {
             [options.buildTarget]: {
                 executor: '@nx/rollup:rollup',
                 outputs: ['{options.outputPath}'],
-                defaultConfiguration: 'production',
                 options: buildOptions,
-                configurations: {
-                    production: {
-                        optimization: true,
-                        sourceMap: false,
-                        namedChunks: false,
-                        extractLicenses: true,
-                        vendorChunk: false,
-                    },
-                },
             },
         },
     });

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

@@ -11,4 +11,5 @@ export interface RollupProjectSchema {
   rollupConfig?: string;
   buildTarget?: string;
   format?: ('cjs' | 'esm')[];
+  addPlugin?: boolean;
 }

package/src/generators/init/init.js

@@ -7,10 +7,15 @@ const add_plugin_1 = require("@nx/devkit/src/utils/add-plugin");
 const plugin_1 = require("../../plugins/plugin");
 async function rollupInitGenerator(tree, schema) {
     let task = () => { };
+    schema.addPlugin ??= process.env.NX_ADD_PLUGINS !== 'false';
     if (!schema.skipPackageJson) {
-        task = (0, devkit_1.addDependenciesToPackageJson)(tree, {}, { '@nx/rollup': versions_1.nxVersion }, undefined, schema.keepExistingVersions);
+        const devDependencies = { '@nx/rollup': versions_1.nxVersion };
+        if (schema.addPlugin) {
+            // Ensure user can run Rollup CLI.
+            devDependencies['rollup'] = versions_1.rollupVersion;
+        }
+        task = (0, devkit_1.addDependenciesToPackageJson)(tree, {}, devDependencies, undefined, schema.keepExistingVersions);
     }
-    schema.addPlugin ??= process.env.NX_ADD_PLUGINS !== 'false';
     if (schema.addPlugin) {
         await (0, add_plugin_1.addPluginV1)(tree, await (0, devkit_1.createProjectGraphAsync)(), '@nx/rollup/plugin', plugin_1.createNodes, {
             buildTargetName: ['build', 'rollup:build', 'rollup-build'],

package/src/plugins/delete-output.d.ts

@@ -0,0 +1,5 @@
+import type { Plugin } from 'rollup';
+export interface DeleteOutputOptions {
+    dirs: string[];
+}
+export declare function deleteOutput(options: DeleteOutputOptions): Plugin;

package/src/plugins/delete-output.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteOutput = void 0;
+const fs_1 = require("../utils/fs");
+function deleteOutput(options) {
+    return {
+        name: 'rollup-plugin-nx-delete-output',
+        buildStart: () => options.dirs.forEach((dir) => (0, fs_1.deleteOutputDir)(process.cwd(), dir)),
+    };
+}
+exports.deleteOutput = deleteOutput;

package/src/plugins/package-json/generate-package-json.d.ts

@@ -0,0 +1,12 @@
+import type { Plugin } from 'rollup';
+import type { PackageJson } from 'nx/src/utils/package-json';
+export interface GeneratePackageJsonOptions {
+    outputPath: string;
+    main: string;
+    format: string[];
+    generateExportsField?: boolean;
+    skipTypeField?: boolean;
+    outputFileName?: string;
+    additionalEntryPoints?: string[];
+}
+export declare function generatePackageJson(options: GeneratePackageJsonOptions, packageJson: PackageJson): Plugin;

package/src/plugins/package-json/generate-package-json.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generatePackageJson = void 0;
+const update_package_json_1 = require("./update-package-json");
+function generatePackageJson(options, packageJson) {
+    return {
+        name: 'rollup-plugin-nx-generate-package-json',
+        writeBundle: () => {
+            (0, update_package_json_1.updatePackageJson)(options, packageJson);
+        },
+    };
+}
+exports.generatePackageJson = generatePackageJson;

package/src/plugins/package-json/update-package-json.d.ts

@@ -0,0 +1,10 @@
+import { PackageJson } from 'nx/src/utils/package-json';
+export declare function updatePackageJson(options: {
+    outputPath: string;
+    main: string;
+    format: string[];
+    generateExportsField?: boolean;
+    skipTypeField?: boolean;
+    outputFileName?: string;
+    additionalEntryPoints?: string[];
+}, packageJson: PackageJson): void;

package/src/{executors/rollup/lib → plugins/package-json}/update-package-json.js

@@ -5,7 +5,6 @@ const path_1 = require("path");
 const fileutils_1 = require("nx/src/utils/fileutils");
 const fs_1 = require("fs");
 const devkit_1 = require("@nx/devkit");
-// TODO(jack): Use updatePackageJson from @nx/js instead.
 function updatePackageJson(options, packageJson) {
     const hasEsmFormat = options.format.includes('esm');
     const hasCjsFormat = options.format.includes('cjs');
@@ -59,8 +58,8 @@ function updatePackageJson(options, packageJson) {
                     // Make sure both ESM and CJS point to same instance of the package because libs like React, RxJS, etc. requires it.
                     // Also need a special .cjs.default.js file that re-exports the `default` from CJS, or else
                     // default import in Node will not work.
-                    (0, fs_1.writeFileSync)((0, path_1.join)(options.outputPath, filePath.replace(/\.cjs\.js$/, '.cjs.default.js')), `exports._default = require('./${(0, path_1.parse)(filePath).base}').default;`);
-                    (0, fs_1.writeFileSync)((0, path_1.join)(options.outputPath, fauxEsmFilePath), 
+                    (0, fs_1.writeFileSync)((0, path_1.join)(devkit_1.workspaceRoot, options.outputPath, filePath.replace(/\.cjs\.js$/, '.cjs.default.js')), `exports._default = require('./${(0, path_1.parse)(filePath).base}').default;`);
+                    (0, fs_1.writeFileSync)((0, path_1.join)(devkit_1.workspaceRoot, options.outputPath, fauxEsmFilePath), 
                     // Re-export from relative CJS file, and Node will synthetically export it as ESM.
                     (0, devkit_1.stripIndents) `
             export * from './${relativeFile}';
@@ -73,16 +72,18 @@ function updatePackageJson(options, packageJson) {
             }
         }
     }
-    (0, fileutils_1.writeJsonFile)(`${options.outputPath}/package.json`, packageJson);
+    (0, fileutils_1.writeJsonFile)((0, path_1.join)(devkit_1.workspaceRoot, options.outputPath, 'package.json'), packageJson);
 }
 exports.updatePackageJson = updatePackageJson;
 function getExports(options) {
-    const mainFile = options.outputFileName
-        ? options.outputFileName.replace(/\.[tj]s$/, '')
-        : (0, path_1.basename)(options.main).replace(/\.[tj]s$/, '');
-    const exports = {
-        '.': './' + mainFile + options.fileExt,
-    };
+    const exports = {};
+    // Users may provide custom input option and skip the main field.
+    if (options.main) {
+        const mainFile = options.outputFileName
+            ? options.outputFileName.replace(/\.[tj]s$/, '')
+            : (0, path_1.basename)(options.main).replace(/\.[tj]s$/, '');
+        exports['.'] = './' + mainFile + options.fileExt;
+    }
     if (options.additionalEntryPoints) {
         for (const file of options.additionalEntryPoints) {
             const { name: fileName } = (0, path_1.parse)(file);

package/src/plugins/plugin.js

@@ -40,9 +40,7 @@ exports.createNodes = [
             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 hash = await (0, calculate_hash_for_create_nodes_1.calculateHashForCreateNodes)(projectRoot, options, context, [(0, js_1.getLockFileName)((0, devkit_1.detectPackageManager)(context.workspaceRoot))]);
         targetsCache[hash] ??= await buildRollupTarget(configFilePath, projectRoot, options, context);
         return {
             projects: {

package/src/plugins/with-nx/get-project-node.d.ts

@@ -0,0 +1,2 @@
+import { ProjectGraphProjectNode } from '@nx/devkit';
+export declare function getProjectNode(): ProjectGraphProjectNode;

package/src/plugins/with-nx/get-project-node.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProjectNode = void 0;
+const devkit_1 = require("@nx/devkit");
+function getProjectNode() {
+    // During graph construction, project is not necessary. Return a stub.
+    if (global.NX_GRAPH_CREATION) {
+        return {
+            type: 'lib',
+            name: '',
+            data: {
+                root: '',
+            },
+        };
+    }
+    else {
+        const projectGraph = (0, devkit_1.readCachedProjectGraph)();
+        const projectName = process.env.NX_TASK_TARGET_PROJECT;
+        return projectGraph.nodes[projectName];
+    }
+}
+exports.getProjectNode = getProjectNode;

package/src/plugins/with-nx/normalize-options.d.ts

@@ -0,0 +1,2 @@
+import type { NormalizedRollupWithNxPluginOptions, RollupWithNxPluginOptions } from './with-nx-options';
+export declare function normalizeOptions(projectRoot: string, sourceRoot: string, options: RollupWithNxPluginOptions): NormalizedRollupWithNxPluginOptions;

package/src/plugins/with-nx/normalize-options.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeOptions = void 0;
+const node_path_1 = require("node:path");
+const node_fs_1 = require("node:fs");
+const devkit_1 = require("@nx/devkit");
+const js_1 = require("@nx/js");
+function normalizeOptions(projectRoot, sourceRoot, options) {
+    if (global.NX_GRAPH_CREATION)
+        return options;
+    normalizeRelativePaths(projectRoot, options);
+    return {
+        ...options,
+        additionalEntryPoints: (0, js_1.createEntryPoints)(options.additionalEntryPoints, devkit_1.workspaceRoot),
+        allowJs: options.allowJs ?? false,
+        assets: options.assets
+            ? normalizeAssets(options.assets, devkit_1.workspaceRoot, sourceRoot)
+            : [],
+        babelUpwardRootMode: options.babelUpwardRootMode ?? false,
+        compiler: options.compiler ?? 'babel',
+        deleteOutputPath: options.deleteOutputPath ?? true,
+        extractCss: options.extractCss ?? true,
+        format: options.format ? Array.from(new Set(options.format)) : undefined,
+        generateExportsField: options.generateExportsField ?? false,
+        javascriptEnabled: options.javascriptEnabled ?? false,
+        skipTypeCheck: options.skipTypeCheck ?? false,
+        skipTypeField: options.skipTypeField ?? false,
+    };
+}
+exports.normalizeOptions = normalizeOptions;
+function normalizeAssets(assets, root, sourceRoot) {
+    return assets.map((asset) => {
+        if (typeof asset === 'string') {
+            const assetPath = (0, devkit_1.normalizePath)(asset);
+            const resolvedAssetPath = (0, node_path_1.resolve)(root, assetPath);
+            const resolvedSourceRoot = (0, node_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, node_fs_1.statSync)(resolvedAssetPath).isDirectory();
+            const input = isDirectory
+                ? resolvedAssetPath
+                : (0, node_path_1.dirname)(resolvedAssetPath);
+            const output = (0, node_path_1.relative)(resolvedSourceRoot, (0, node_path_1.resolve)(root, input));
+            const glob = isDirectory ? '**/*' : (0, node_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, node_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(/^\//, ''),
+            };
+        }
+    });
+}
+function normalizeRelativePaths(projectRoot, options) {
+    for (const [fieldName, fieldValue] of Object.entries(options)) {
+        if (isRelativePath(fieldValue)) {
+            options[fieldName] = (0, node_path_1.join)(projectRoot, fieldValue);
+        }
+        else if (Array.isArray(fieldValue)) {
+            for (let i = 0; i < fieldValue.length; i++) {
+                if (isRelativePath(fieldValue[i])) {
+                    fieldValue[i] = (0, node_path_1.join)(projectRoot, fieldValue[i]);
+                }
+            }
+        }
+    }
+}
+function isRelativePath(val) {
+    return typeof val === 'string' && val.startsWith('.');
+}

package/src/plugins/with-nx/with-nx-options.d.ts

@@ -0,0 +1,33 @@
+export interface RollupWithNxPluginOptions {
+    additionalEntryPoints?: string[];
+    allowJs?: boolean;
+    assets?: any[];
+    babelUpwardRootMode?: boolean;
+    compiler?: 'babel' | 'tsc' | 'swc';
+    deleteOutputPath?: boolean;
+    external?: string[] | 'all' | 'none';
+    extractCss?: boolean | string;
+    format?: ('cjs' | 'esm')[];
+    generateExportsField?: boolean;
+    javascriptEnabled?: boolean;
+    main: string;
+    /** @deprecated Do not set this. The package.json file in project root is detected automatically. */
+    project?: string;
+    outputFileName?: string;
+    outputPath: string;
+    rollupConfig?: string | string[];
+    skipTypeCheck?: boolean;
+    skipTypeField?: boolean;
+    tsConfig: string;
+}
+export interface AssetGlobPattern {
+    glob: string;
+    ignore?: string[];
+    input: string;
+    output: string;
+}
+export interface NormalizedRollupWithNxPluginOptions extends RollupWithNxPluginOptions {
+    assets: AssetGlobPattern[];
+    compiler: 'babel' | 'tsc' | 'swc';
+    format: ('cjs' | 'esm')[];
+}

package/src/plugins/with-nx/with-nx-options.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/plugins/with-nx/with-nx.d.ts

@@ -0,0 +1,4 @@
+import * as rollup from 'rollup';
+import { DependentBuildableProjectNode } from '@nx/js/src/utils/buildable-libs-utils';
+import { RollupWithNxPluginOptions } from './with-nx-options';
+export declare function withNx(rawOptions: RollupWithNxPluginOptions, rollupConfig?: rollup.RollupOptions, dependencies?: DependentBuildableProjectNode[]): rollup.RollupOptions;

package/src/plugins/with-nx/with-nx.js

@@ -0,0 +1,233 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withNx = void 0;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const ts = require("typescript");
+const plugin_babel_1 = require("@rollup/plugin-babel");
+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 analyze_1 = require("../analyze");
+const swc_1 = require("../swc");
+const generate_package_json_1 = require("../package-json/generate-package-json");
+const get_project_node_1 = require("./get-project-node");
+const delete_output_1 = require("../delete-output");
+const normalize_options_1 = require("./normalize-options");
+// 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'];
+function withNx(rawOptions, rollupConfig = {}, 
+// Passed by @nx/rollup:rollup executor to previous behavior of remapping tsconfig paths based on buildable dependencies remains intact.
+dependencies) {
+    const finalConfig = { ...rollupConfig };
+    // Since this is invoked by the executor, the graph has already been created and cached.
+    const projectNode = (0, get_project_node_1.getProjectNode)();
+    const projectRoot = (0, node_path_1.join)(devkit_1.workspaceRoot, projectNode.data.root);
+    // Cannot read in graph during construction, but we only need it during build time.
+    const projectGraph = global.NX_GRAPH_CREATION
+        ? null
+        : (0, devkit_1.readCachedProjectGraph)();
+    // If dependencies are not passed from executor, calculate them from project graph.
+    if (!dependencies && !global.NX_GRAPH_CREATION) {
+        const result = (0, buildable_libs_utils_1.calculateProjectBuildableDependencies)(undefined, projectGraph, devkit_1.workspaceRoot, projectNode.name, process.env.NX_TASK_TARGET_TARGET, process.env.NX_TASK_TARGET_CONFIGURATION, true);
+        dependencies = result.dependencies;
+    }
+    const options = (0, normalize_options_1.normalizeOptions)(projectNode.data.root, projectNode.data.sourceRoot, rawOptions);
+    const useBabel = options.compiler === 'babel';
+    const useSwc = options.compiler === 'swc';
+    const tsConfigPath = (0, devkit_1.joinPathFragments)(devkit_1.workspaceRoot, options.tsConfig);
+    const tsConfigFile = ts.readConfigFile(tsConfigPath, ts.sys.readFile);
+    const tsConfig = ts.parseJsonConfigFileContent(tsConfigFile.config, ts.sys, (0, node_path_1.dirname)(tsConfigPath));
+    if (!options.format || !options.format.length) {
+        options.format = readCompatibleFormats(tsConfig);
+    }
+    if (rollupConfig.input &&
+        (options.main || options.additionalEntryPoints.length > 0)) {
+        devkit_1.logger.warn(`Setting "input" in rollup config overrides "main" and "additionalEntryPoints" options.`);
+    }
+    // If user provides their own input, override our defaults.
+    finalConfig.input = rollupConfig.input || createInput(options);
+    if (options.format) {
+        if (Array.isArray(rollupConfig.output)) {
+            throw new Error(`Cannot use Rollup array output option and withNx format option together. Use an object instead.`);
+        }
+        if (rollupConfig.output?.format || rollupConfig.output?.dir) {
+            devkit_1.logger.warn(`"output.dir" and "output.format" are overridden by "withNx".`);
+        }
+        finalConfig.output = options.format.map((format) => ({
+            // These options could be overridden by the user, especially if they use a single format.
+            entryFileNames: `[name].${format}.js`,
+            chunkFileNames: `[name].${format}.js`,
+            ...rollupConfig.output,
+            // Format and dir cannot be overridden by user or else the behavior will break.
+            format,
+            dir: global.NX_GRAPH_CREATION
+                ? // Options are not normalized with project root during graph creation due to the lack of project and project root.
+                    // Cannot be joined with workspace root now, but will be handled by @nx/rollup/plugin.
+                    options.outputPath
+                : (0, node_path_1.join)(devkit_1.workspaceRoot, options.outputPath),
+        }));
+    }
+    let packageJson;
+    if (!global.NX_GRAPH_CREATION) {
+        const packageJsonPath = options.project
+            ? (0, node_path_1.join)(devkit_1.workspaceRoot, options.project)
+            : (0, node_path_1.join)(projectRoot, 'package.json');
+        if (!(0, node_fs_1.existsSync)(packageJsonPath)) {
+            throw new Error(`Cannot find ${packageJsonPath}.`);
+        }
+        packageJson = (0, devkit_1.readJsonFile)(packageJsonPath);
+        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'];
+        }
+    }
+    // User may wish to customize how external behaves by overriding our default.
+    if (!rollupConfig.external && !global.NX_GRAPH_CREATION) {
+        const npmDeps = (projectGraph.dependencies[projectNode.name] ?? [])
+            .filter((d) => d.target.startsWith('npm:'))
+            .map((d) => d.target.slice(4));
+        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(npmDeps);
+        }
+        else if (Array.isArray(options.external) && options.external.length > 0) {
+            externalPackages = externalPackages.concat(options.external);
+        }
+        externalPackages = [...new Set(externalPackages)];
+        finalConfig.external = (id) => {
+            return externalPackages.some((name) => id === name || id.startsWith(`${name}/`));
+        };
+    }
+    if (!global.NX_GRAPH_CREATION) {
+        finalConfig.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(projectRoot, tsConfig, options, dependencies),
+                },
+            }),
+            (0, type_definitions_1.typeDefinitions)({
+                projectRoot,
+            }),
+            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_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, node_path_1.join)(devkit_1.workspaceRoot, projectNode.data.sourceRoot ?? projectNode.data.root),
+                    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_1.analyze)(),
+            (0, generate_package_json_1.generatePackageJson)(options, packageJson),
+        ];
+        if (Array.isArray(rollupConfig.plugins)) {
+            finalConfig.plugins.push(...rollupConfig.plugins);
+        }
+        if (options.deleteOutputPath) {
+            finalConfig.plugins.push((0, delete_output_1.deleteOutput)({
+                dirs: Array.isArray(finalConfig.output)
+                    ? finalConfig.output.map((o) => o.dir)
+                    : [finalConfig.output.dir],
+            }));
+        }
+    }
+    return finalConfig;
+}
+exports.withNx = withNx;
+function createInput(options) {
+    const mainEntryFileName = options.outputFileName || options.main;
+    const input = {};
+    input[(0, node_path_1.parse)(mainEntryFileName).name] = (0, node_path_1.join)(devkit_1.workspaceRoot, options.main);
+    options.additionalEntryPoints?.forEach((entry) => {
+        input[(0, node_path_1.parse)(entry).name] = (0, node_path_1.join)(devkit_1.workspaceRoot, entry);
+    });
+    return input;
+}
+function createTsCompilerOptions(projectRoot, config, options, dependencies) {
+    const compilerOptionPaths = (0, buildable_libs_utils_1.computeCompilerOptionsPaths)(config, dependencies ?? []);
+    const compilerOptions = {
+        rootDir: 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, node_path_1.join)(a.input, a.glob).replace(/\\/g, '/'),
+            dest: (0, node_path_1.join)(devkit_1.workspaceRoot, 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'];
+    }
+}

package/src/utils/has-plugin.d.ts

@@ -0,0 +1,2 @@
+import { Tree } from '@nx/devkit';
+export declare function hasPlugin(tree: Tree): boolean;

package/src/utils/has-plugin.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasPlugin = void 0;
+const devkit_1 = require("@nx/devkit");
+function hasPlugin(tree) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    return !!nxJson.plugins?.some((p) => typeof p === 'string'
+        ? p === '@nx/rollup/plugin'
+        : p.plugin === '@nx/rollup/plugin');
+}
+exports.hasPlugin = hasPlugin;

package/src/utils/versions.d.ts

@@ -1,4 +1,5 @@
 export declare const nxVersion: any;
+export declare const coreJsVersion = "^3.36.1";
+export declare const rollupVersion = "^4.14.0";
 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,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.coreJsVersion = exports.tsLibVersion = exports.swcLoaderVersion = exports.nxVersion = void 0;
+exports.tsLibVersion = exports.swcLoaderVersion = exports.rollupVersion = exports.coreJsVersion = exports.nxVersion = void 0;
 exports.nxVersion = require('../../package.json').version;
+exports.coreJsVersion = '^3.36.1';
+exports.rollupVersion = '^4.14.0';
 exports.swcLoaderVersion = '0.1.15';
 exports.tsLibVersion = '^2.3.0';
-exports.coreJsVersion = '^3.36.1';

package/with-nx.d.ts

@@ -0,0 +1,2 @@
+export { withNx } from './src/plugins/with-nx/with-nx';
+export type { RollupWithNxPluginOptions } from './src/plugins/with-nx/with-nx-options';

package/with-nx.js

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

package/src/executors/rollup/lib/update-package-json.d.ts

@@ -1,3 +0,0 @@
-import { PackageJson } from 'nx/src/utils/package-json';
-import { NormalizedRollupExecutorOptions } from './normalize';
-export declare function updatePackageJson(options: NormalizedRollupExecutorOptions, packageJson: PackageJson): void;