@nx/rollup 19.4.0-beta.0 → 19.4.0-beta.2

package/generators.json

@@ -5,7 +5,7 @@
     "init": {
       "factory": "./src/generators/init/init#rollupInitGenerator",
       "schema": "./src/generators/init/schema.json",
-      "description": "Initialize the `@nrwl/rollup` plugin.",
+      "description": "Initialize the `@nx/rollup` plugin.",
       "aliases": ["ng-add"],
       "hidden": true
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/rollup",
-  "version": "19.4.0-beta.0",
+  "version": "19.4.0-beta.2",
   "private": false,
   "description": "The Nx Plugin for Rollup contains executors and generators that support building applications using Rollup.",
   "repository": {
@@ -37,15 +37,16 @@
     "autoprefixer": "^10.4.9",
     "babel-plugin-transform-async-to-promises": "^0.8.15",
     "chalk": "^4.1.0",
+    "minimatch": "9.0.3",
     "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": "19.4.0-beta.0",
-    "@nx/js": "19.4.0-beta.0",
-    "@nrwl/rollup": "19.4.0-beta.0"
+    "@nx/devkit": "19.4.0-beta.2",
+    "@nx/js": "19.4.0-beta.2",
+    "@nrwl/rollup": "19.4.0-beta.2"
   },
   "publishConfig": {
     "access": "public"

package/src/generators/convert-to-inferred/convert-to-inferred.js

@@ -4,9 +4,10 @@ exports.convertToInferred = void 0;
 const devkit_1 = require("@nx/devkit");
 const executor_options_utils_1 = require("@nx/devkit/src/generators/executor-options-utils");
 const extract_rollup_config_from_executor_options_1 = require("./lib/extract-rollup-config-from-executor-options");
+const add_plugin_registrations_1 = require("./lib/add-plugin-registrations");
 async function convertToInferred(tree, options) {
-    let migrated = 0;
-    const projects = (0, devkit_1.getProjects)(tree);
+    const migratedProjects = new Map();
+    let projects = (0, devkit_1.getProjects)(tree);
     (0, executor_options_utils_1.forEachExecutorOptions)(tree, '@nx/rollup:rollup', (_, projectName, targetName, configurationName) => {
         if (options.project && projectName !== options.project)
             return;
@@ -62,23 +63,13 @@ async function convertToInferred(tree, options) {
         if (Object.keys(target).length === 0)
             delete project.targets[targetName];
         (0, devkit_1.updateProjectConfiguration)(tree, projectName, project);
-        nxJson.plugins ??= [];
-        if (!nxJson.plugins.some((p) => typeof p === 'string'
-            ? p === '@nx/rollup/plugin'
-            : p.plugin === '@nx/rollup/plugin')) {
-            nxJson.plugins.push({
-                plugin: '@nx/rollup/plugin',
-                options: {
-                    targetName: 'build',
-                },
-            });
-        }
-        (0, devkit_1.updateNxJson)(tree, nxJson);
-        migrated++;
+        migratedProjects.set(projectName, { buildTargetName: targetName });
     });
-    if (migrated === 0) {
+    if (migratedProjects.size === 0) {
         throw new Error('Could not find any targets to migrate.');
     }
+    projects = (0, devkit_1.getProjects)(tree);
+    await (0, add_plugin_registrations_1.addPluginRegistrations)(tree, migratedProjects, projects, '@nx/rollup/plugin');
     if (!options.skipFormat) {
         await (0, devkit_1.formatFiles)(tree);
     }

package/src/generators/convert-to-inferred/lib/add-plugin-registrations.d.ts

@@ -0,0 +1,2 @@
+import { type ProjectConfiguration, type Tree } from '@nx/devkit';
+export declare function addPluginRegistrations<T>(tree: Tree, projectTargets: Map<string, T>, projects: Map<string, ProjectConfiguration>, pluginPath: string): Promise<void>;

package/src/generators/convert-to-inferred/lib/add-plugin-registrations.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addPluginRegistrations = void 0;
+const devkit_1 = require("@nx/devkit");
+const minimatch_1 = require("minimatch");
+async function addPluginRegistrations(tree, projectTargets, projects, pluginPath) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    for (const [project, options] of projectTargets.entries()) {
+        const existingPlugin = nxJson.plugins?.find((plugin) => typeof plugin !== 'string' &&
+            plugin.plugin === pluginPath &&
+            Object.keys(options).every((key) => plugin.options[key] === options[key]));
+        const projectIncludeGlob = `${projects.get(project).root}/**/*`;
+        if (!existingPlugin) {
+            nxJson.plugins ??= [];
+            const plugin = {
+                plugin: pluginPath,
+                options,
+                include: [projectIncludeGlob],
+            };
+            nxJson.plugins.push(plugin);
+        }
+        else if (existingPlugin.include) {
+            if (!existingPlugin.include.some((include) => (0, minimatch_1.minimatch)(projectIncludeGlob, include, { dot: true }))) {
+                existingPlugin.include.push(projectIncludeGlob);
+            }
+        }
+    }
+    if (!areProjectsUsingTheExecutorLeft(projects)) {
+        // all projects have been migrated, if there's only one plugin registration
+        // left, remove its "include" property
+        const pluginRegistrations = nxJson.plugins?.filter((plugin) => typeof plugin !== 'string' && plugin.plugin === pluginPath);
+        if (pluginRegistrations?.length === 1) {
+            for (const plugin of pluginRegistrations) {
+                delete plugin.include;
+            }
+        }
+    }
+    (0, devkit_1.updateNxJson)(tree, nxJson);
+}
+exports.addPluginRegistrations = addPluginRegistrations;
+function areProjectsUsingTheExecutorLeft(projects) {
+    return Array.from(projects.values()).some((project) => Object.values(project.targets ?? {}).some((target) => target.executor === '@nx/rollup:rollup'));
+}

package/src/generators/convert-to-inferred/lib/extract-rollup-config-from-executor-options.js

@@ -3,9 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.extractRollupConfigFromExecutorOptions = void 0;
 const devkit_1 = require("@nx/devkit");
 const normalize_path_options_1 = require("./normalize-path-options");
+const aliases = {
+    entryFile: 'main',
+    exports: 'generateExportsField',
+    f: 'format',
+};
 function extractRollupConfigFromExecutorOptions(tree, options, configurations, projectRoot) {
     (0, normalize_path_options_1.normalizePathOptions)(projectRoot, options);
-    let newRollupConfigContent;
     const hasConfigurations = !!configurations && Object.keys(configurations).length > 0;
     const oldRollupConfig = Array.isArray(options.rollupConfig)
         ? options.rollupConfig
@@ -26,27 +30,77 @@ function extractRollupConfigFromExecutorOptions(tree, options, configurations, p
         if (key === 'watch')
             continue;
         delete options[key];
-        defaultOptions[key] = value;
+        if (aliases[key]) {
+            defaultOptions[aliases[key]] = value;
+        }
+        else {
+            defaultOptions[key] = value;
+        }
     }
+    let configurationOptions;
     if (hasConfigurations) {
-        const configurationOptions = {};
+        configurationOptions = {};
         for (const [key, value] of Object.entries(configurations)) {
+            let newConfigFileName;
+            let oldRollupConfigForConfiguration;
             for (const [optionKey, optionValue] of Object.entries(value)) {
                 if (optionKey === 'watch')
                     continue;
+                /**
+                 * If a configuration lists rollupConfig as an option
+                 * Collect the options and set up a new file to point to
+                 * Set the `--config` option to the new file
+                 */
+                if (optionKey === 'rollupConfig') {
+                    oldRollupConfigForConfiguration = Array.isArray(optionValue)
+                        ? optionValue
+                        : optionValue
+                            ? [optionValue]
+                            : [];
+                    newConfigFileName = `rollup.${key}.config.js`;
+                    for (let i = 0; i < oldRollupConfigForConfiguration.length; i++) {
+                        const file = oldRollupConfigForConfiguration[i];
+                        if (file === newConfigFileName) {
+                            tree.rename((0, devkit_1.joinPathFragments)(projectRoot, newConfigFileName), (0, devkit_1.joinPathFragments)(projectRoot, `rollup.${key}.migrated.config.js`));
+                            oldRollupConfigForConfiguration.splice(i, 1, `./rollup.${key}.migrated.config.js`);
+                        }
+                    }
+                    delete value[optionKey];
+                    value['config'] = newConfigFileName;
+                    continue;
+                }
                 delete value[optionKey];
                 configurationOptions[key] ??= {};
                 configurationOptions[key][optionKey] = optionValue;
             }
+            /**
+             * Only if we encountered a rollupConfig in the current configuration
+             * should we write a new config file, containing all the config values
+             */
+            if (newConfigFileName) {
+                tree.write((0, devkit_1.joinPathFragments)(projectRoot, newConfigFileName), createNewRollupConfig(oldRollupConfigForConfiguration, defaultOptions, configurationOptions[key], true));
+            }
         }
-        newRollupConfigContent = (0, devkit_1.stripIndents) `
+    }
+    tree.write((0, devkit_1.joinPathFragments)(projectRoot, `rollup.config.js`), createNewRollupConfig(oldRollupConfig, defaultOptions, configurationOptions));
+    return defaultOptions;
+}
+exports.extractRollupConfigFromExecutorOptions = extractRollupConfigFromExecutorOptions;
+function createNewRollupConfig(oldRollupConfig, defaultOptions, configurationOptions, singleConfiguration = false) {
+    if (configurationOptions) {
+        return (0, devkit_1.stripIndents) `
       const { withNx } = require('@nx/rollup/with-nx');
       
       // These options were migrated by @nx/rollup:convert-to-inferred from project.json
-      const configValues =  ${JSON.stringify({
-            default: defaultOptions,
-            ...configurationOptions,
-        }, null, 2)}; 
+      const configValues =  ${JSON.stringify(singleConfiguration
+            ? {
+                ...defaultOptions,
+                ...configurationOptions,
+            }
+            : {
+                default: defaultOptions,
+                ...configurationOptions,
+            }, null, 2)}; 
         
       // Determine the correct configValue to use based on the configuration
       const nxConfiguration = process.env.NX_TASK_TARGET_CONFIGURATION ?? 'default';
@@ -71,7 +125,7 @@ function extractRollupConfigFromExecutorOptions(tree, options, configurations, p
     `;
     }
     else {
-        newRollupConfigContent = (0, devkit_1.stripIndents) `
+        return (0, devkit_1.stripIndents) `
       const { withNx } = require('@nx/rollup/with-nx');
       
       // These options were migrated by @nx/rollup:convert-to-inferred from project.json
@@ -91,7 +145,4 @@ function extractRollupConfigFromExecutorOptions(tree, options, configurations, p
       module.exports = config;
     `;
     }
-    tree.write((0, devkit_1.joinPathFragments)(projectRoot, `rollup.config.js`), newRollupConfigContent);
-    return defaultOptions;
 }
-exports.extractRollupConfigFromExecutorOptions = extractRollupConfigFromExecutorOptions;

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

@@ -1,23 +1,76 @@
 export interface RollupWithNxPluginOptions {
+    /**
+     * Additional entry-points to add to exports field in the package.json file.
+     * */
     additionalEntryPoints?: string[];
+    /**
+     * Allow JavaScript files to be compiled.
+     */
     allowJs?: boolean;
+    /**
+     * List of static assets.
+     */
     assets?: any[];
+    /**
+     * Whether to set rootmode to upward. See https://babeljs.io/docs/en/options#rootmode
+     */
     babelUpwardRootMode?: boolean;
+    /**
+     * Which compiler to use.
+     */
     compiler?: 'babel' | 'tsc' | 'swc';
+    /**
+     * Delete the output path before building. Defaults to true.
+     */
     deleteOutputPath?: boolean;
+    /**
+     * A list of external modules that will not be bundled (`react`, `react-dom`, etc.). Can also be set to `all` (bundle nothing) or `none` (bundle everything).
+     */
     external?: string[] | 'all' | 'none';
+    /**
+     * CSS files will be extracted to the output folder. Alternatively custom filename can be provided (e.g. styles.css)
+     */
     extractCss?: boolean | string;
+    /**
+     * List of module formats to output. Defaults to matching format from tsconfig (e.g. CJS for CommonJS, and ESM otherwise).
+     */
     format?: ('cjs' | 'esm')[];
+    /**
+     * Update the output package.json file's 'exports' field. This field is used by Node and bundles.
+     */
     generateExportsField?: boolean;
+    /**
+     * Sets `javascriptEnabled` option for less loader
+     */
     javascriptEnabled?: boolean;
+    /**
+     * The path to the entry file, relative to project.
+     */
     main: string;
-    /** @deprecated Do not set this. The package.json file in project root is detected automatically. */
+    /**
+     * The path to package.json file.
+     * @deprecated Do not set this. The package.json file in project root is detected automatically.
+     */
     project?: string;
+    /**
+     * Name of the main output file. Defaults same basename as 'main' file.
+     */
     outputFileName?: string;
+    /**
+     * The output path of the generated files.
+     */
     outputPath: string;
-    rollupConfig?: string | string[];
+    /**
+     * Whether to skip TypeScript type checking.
+     */
     skipTypeCheck?: boolean;
+    /**
+     * Prevents 'type' field from being added to compiled package.json file. Use this if you are having an issue with this field.
+     */
     skipTypeField?: boolean;
+    /**
+     * The path to tsconfig file.
+     */
     tsConfig: string;
 }
 export interface AssetGlobPattern {