@nx/rollup 19.3.0 → 19.4.0-beta.1

package/generators.json

@@ -14,6 +14,11 @@
       "factory": "./src/generators/configuration/configuration",
       "schema": "./src/generators/configuration/schema.json",
       "description": "Add rollup configuration to a project."
+    },
+    "convert-to-inferred": {
+      "factory": "./src/generators/convert-to-inferred/convert-to-inferred",
+      "schema": "./src/generators/convert-to-inferred/schema.json",
+      "description": "Convert existing Rollup project(s) using `@nx/rollup:*` executors to use `@nx/rollup/plugin`."
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/rollup",
-  "version": "19.3.0",
+  "version": "19.4.0-beta.1",
   "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.3.0",
-    "@nx/js": "19.3.0",
-    "@nrwl/rollup": "19.3.0"
+    "@nx/devkit": "19.4.0-beta.1",
+    "@nx/js": "19.4.0-beta.1",
+    "@nrwl/rollup": "19.4.0-beta.1"
   },
   "publishConfig": {
     "access": "public"

package/src/generators/convert-to-inferred/convert-to-inferred.d.ts

@@ -0,0 +1,7 @@
+import { type Tree } from '@nx/devkit';
+interface Schema {
+    project?: string;
+    skipFormat?: boolean;
+}
+export declare function convertToInferred(tree: Tree, options: Schema): Promise<void>;
+export default convertToInferred;

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

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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");
+async function convertToInferred(tree, options) {
+    let migrated = 0;
+    const 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;
+        const project = projects.get(projectName);
+        const target = project.targets[targetName];
+        // We'll handle configurations when dealing with default options.
+        if (configurationName)
+            return;
+        // Since targetDefaults for '@nx/rollup:rollup' will no longer apply, we want to copy them to the target options.
+        const nxJson = (0, devkit_1.readNxJson)(tree);
+        const defaults = nxJson.targetDefaults['@nx/rollup:rollup'];
+        if (defaults) {
+            for (const [key, value] of Object.entries(defaults)) {
+                target[key] ??= value;
+            }
+        }
+        const extractedPluginOptions = (0, extract_rollup_config_from_executor_options_1.extractRollupConfigFromExecutorOptions)(tree, target.options, target.configurations, project.root);
+        // If rollup is not an external dependency, add it
+        if (target.inputs &&
+            !target.inputs.some((i) => Array.isArray(i['externalDependencies']) &&
+                i['externalDependencies'].includes('rollup'))) {
+            const idx = target.inputs.findIndex((i) => Array.isArray(i['externalDependencies']));
+            if (idx === -1) {
+                target.inputs.push({ externalDependencies: ['rollup'] });
+            }
+            else {
+                target.inputs[idx]['externalDependencies'].push('rollup');
+            }
+        }
+        // Clean up the target now that it is inferred
+        delete target.executor;
+        if (target.outputs &&
+            target.outputs.length === 1 &&
+            // "{projectRoot}/{options.outputPath}" is an invalid output for Rollup since
+            // there would be a mismatch between where the executor outputs to and where Nx caches.
+            // If users have this set erroneously, then it will continue to not work.
+            (target.outputs[0] === '{options.outputPath}' ||
+                target.outputs[0] === '{workspaceRoot}/{options.outputPath}')) {
+            // If only the default `options.outputPath` is set as output, remove it and use path inferred from `rollup.config.js`.
+            delete target.outputs;
+        }
+        else {
+            // Otherwise, replace `options.outputPath` with what is inferred from `rollup.config.js`.
+            target.outputs = target.outputs.map((output) => 
+            // Again, "{projectRoot}/{options.outputPath}" is an invalid output for Rollup.
+            output === '{options.outputPath}' ||
+                output === '{workspaceRoot}/{options.outputPath}'
+                ? `{projectRoot}/${extractedPluginOptions.outputPath}`
+                : output);
+        }
+        if (Object.keys(target.options).length === 0)
+            delete target.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++;
+    });
+    if (migrated === 0) {
+        throw new Error('Could not find any targets to migrate.');
+    }
+    if (!options.skipFormat) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+}
+exports.convertToInferred = convertToInferred;
+exports.default = convertToInferred;

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

@@ -0,0 +1,3 @@
+import { Tree } from '@nx/devkit';
+import { RollupExecutorOptions } from '../../../executors/rollup/schema';
+export declare function extractRollupConfigFromExecutorOptions(tree: Tree, options: RollupExecutorOptions, configurations: Record<string, Partial<RollupExecutorOptions>>, projectRoot: string): Record<string, unknown>;

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

@@ -0,0 +1,97 @@
+"use strict";
+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");
+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
+        : options.rollupConfig
+            ? [options.rollupConfig]
+            : [];
+    delete options.rollupConfig;
+    // Resolve conflict with rollup.config.js if it exists.
+    for (let i = 0; i < oldRollupConfig.length; i++) {
+        const file = oldRollupConfig[i];
+        if (file === './rollup.config.js') {
+            tree.rename((0, devkit_1.joinPathFragments)(projectRoot, 'rollup.config.js'), (0, devkit_1.joinPathFragments)(projectRoot, `rollup.migrated.config.js`));
+            oldRollupConfig.splice(i, 1, './rollup.migrated.config.js');
+        }
+    }
+    const defaultOptions = {};
+    for (const [key, value] of Object.entries(options)) {
+        if (key === 'watch')
+            continue;
+        delete options[key];
+        defaultOptions[key] = value;
+    }
+    if (hasConfigurations) {
+        const configurationOptions = {};
+        for (const [key, value] of Object.entries(configurations)) {
+            for (const [optionKey, optionValue] of Object.entries(value)) {
+                if (optionKey === 'watch')
+                    continue;
+                delete value[optionKey];
+                configurationOptions[key] ??= {};
+                configurationOptions[key][optionKey] = optionValue;
+            }
+        }
+        newRollupConfigContent = (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)}; 
+        
+      // Determine the correct configValue to use based on the configuration
+      const nxConfiguration = process.env.NX_TASK_TARGET_CONFIGURATION ?? 'default';
+      
+      const options = {
+        ...configValues.default,
+        ...configValues[nxConfiguration],
+      };
+      
+      ${oldRollupConfig.length > 0 ? 'let' : 'const'} config = withNx(options, {
+        // Provide additional rollup configuration here. See: https://rollupjs.org/configuration-options
+        // e.g. 
+        // output: { sourcemap: true },
+      });
+      
+      ${oldRollupConfig
+            // Normalize path
+            .map((s) => `config = require('${s}')(config, options);`)
+            .join('\n')}
+      
+      module.exports = config;
+    `;
+    }
+    else {
+        newRollupConfigContent = (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 options = ${JSON.stringify(defaultOptions, null, 2)};
+      
+      ${oldRollupConfig.length > 0 ? 'let' : 'const'} config = withNx(options, {
+        // Provide additional rollup configuration here. See: https://rollupjs.org/configuration-options
+        // e.g. 
+        // output: { sourcemap: true },
+      });
+      
+      ${oldRollupConfig
+            // Normalize path
+            .map((s) => `config = require('${s}')(config, options);`)
+            .join('\n')}
+      
+      module.exports = config;
+    `;
+    }
+    tree.write((0, devkit_1.joinPathFragments)(projectRoot, `rollup.config.js`), newRollupConfigContent);
+    return defaultOptions;
+}
+exports.extractRollupConfigFromExecutorOptions = extractRollupConfigFromExecutorOptions;

package/src/generators/convert-to-inferred/lib/normalize-path-options.d.ts

@@ -0,0 +1,2 @@
+import { RollupExecutorOptions } from '../../../executors/rollup/schema';
+export declare function normalizePathOptions(projectRoot: string, options: RollupExecutorOptions): void;

package/src/generators/convert-to-inferred/lib/normalize-path-options.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizePathOptions = void 0;
+const devkit_1 = require("@nx/devkit");
+const executorPathFieldsToMigrate = [
+    'tsConfig',
+    'project',
+    'main',
+    'outputPath',
+    'rollupConfig',
+    'additionalEntryPoints',
+];
+function normalizePathOptions(projectRoot, options) {
+    for (const [key, value] of Object.entries(options)) {
+        if (!executorPathFieldsToMigrate.includes(key))
+            continue;
+        if (Array.isArray(value)) {
+            options[key] = value.map((v) => normalizeValue(projectRoot, key, v));
+        }
+        else {
+            options[key] = normalizeValue(projectRoot, key, value);
+        }
+    }
+}
+exports.normalizePathOptions = normalizePathOptions;
+function normalizeValue(projectRoot, key, value) {
+    // Logic matches `@nx/rollup:rollup` in `normalizePluginPath` function.
+    if (!value)
+        return value;
+    if (key === 'rollupConfig') {
+        try {
+            // If this can load as npm module, keep as is.
+            require.resolve(value);
+            return value;
+        }
+        catch {
+            // Otherwise continue below convert to relative path from project.
+        }
+    }
+    if (value.startsWith(`${projectRoot}/`)) {
+        return value.replace(new RegExp(`^${projectRoot}/`), './');
+    }
+    else {
+        return (0, devkit_1.joinPathFragments)((0, devkit_1.offsetFromRoot)(projectRoot), value);
+    }
+}

package/src/generators/convert-to-inferred/schema.json

@@ -0,0 +1,19 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "NxRollupConvertToInferred",
+  "description": "Convert existing Rollup project(s) using `@nx/rollup:rollup` executor to use `@nx/rollup/plugin`. Defaults to migrating all projects. Pass '--project' to migrate only one target.",
+  "title": "Convert Rollup project from executor to plugin",
+  "type": "object",
+  "properties": {
+    "project": {
+      "type": "string",
+      "description": "The project to convert from using the `@nx/rollup:rollup` executor to use `@nx/rollup/plugin`.",
+      "x-priority": "important"
+    },
+    "skipFormat": {
+      "type": "boolean",
+      "description": "Whether to format files at the end of the migration.",
+      "default": false
+    }
+  }
+}

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

@@ -189,6 +189,10 @@ dependencies) {
 }
 exports.withNx = withNx;
 function createInput(options) {
+    // During graph creation, these input entries don't affect target configuration, so we can skip them.
+    // If convert-to-inferred generator is used, and project uses configurations, some options like main might be missing from default options.
+    if (global.NX_GRAPH_CREATION)
+        return {};
     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);