@nx/rollup 20.0.10 → 20.1.0-beta.1

package/package.json

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

package/plugin.d.ts

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

package/plugin.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createNodes = void 0;
+exports.createNodesV2 = exports.createNodes = void 0;
 var plugin_1 = require("./src/plugins/plugin");
 Object.defineProperty(exports, "createNodes", { enumerable: true, get: function () { return plugin_1.createNodes; } });
+Object.defineProperty(exports, "createNodesV2", { enumerable: true, get: function () { return plugin_1.createNodesV2; } });

package/src/generators/configuration/configuration.js

@@ -2,12 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.configurationGenerator = configurationGenerator;
 const devkit_1 = require("@nx/devkit");
+const target_defaults_utils_1 = require("@nx/devkit/src/generators/target-defaults-utils");
+const js_1 = require("@nx/js");
 const get_import_path_1 = require("@nx/js/src/utils/get-import-path");
+const ensure_typescript_1 = require("@nx/js/src/utils/typescript/ensure-typescript");
 const ts_solution_setup_1 = require("@nx/js/src/utils/typescript/ts-solution-setup");
-const init_1 = require("../init/init");
-const target_defaults_utils_1 = require("@nx/devkit/src/generators/target-defaults-utils");
+const posix_1 = require("node:path/posix");
+const devkit_internals_1 = require("nx/src/devkit-internals");
 const ensure_dependencies_1 = require("../../utils/ensure-dependencies");
 const has_plugin_1 = require("../../utils/has-plugin");
+const init_1 = require("../init/init");
+let ts;
 async function configurationGenerator(tree, options) {
     const tasks = [];
     const nxJson = (0, devkit_1.readNxJson)(tree);
@@ -18,30 +23,40 @@ async function configurationGenerator(tree, options) {
     if (!options.skipPackageJson) {
         tasks.push((0, ensure_dependencies_1.ensureDependencies)(tree, options));
     }
+    const isTsSolutionSetup = (0, ts_solution_setup_1.isUsingTsSolutionSetup)(tree);
+    let outputConfig;
     if ((0, has_plugin_1.hasPlugin)(tree)) {
-        createRollupConfig(tree, options);
+        outputConfig = createRollupConfig(tree, options, isTsSolutionSetup);
     }
     else {
         options.buildTarget ??= 'build';
         checkForTargetConflicts(tree, options);
-        addBuildTarget(tree, options);
+        addBuildTarget(tree, options, isTsSolutionSetup);
+    }
+    updatePackageJson(tree, options, outputConfig, isTsSolutionSetup);
+    if (isTsSolutionSetup) {
+        updateTsConfig(tree, options);
     }
-    addPackageJson(tree, options);
     if (!options.skipFormat) {
         await (0, devkit_1.formatFiles)(tree);
     }
     return (0, devkit_1.runTasksInSerial)(...tasks);
 }
-function createRollupConfig(tree, options) {
-    const isUsingTsPlugin = (0, ts_solution_setup_1.isUsingTsSolutionSetup)(tree);
+function createRollupConfig(tree, options, isTsSolutionSetup) {
     const project = (0, devkit_1.readProjectConfiguration)(tree, options.project);
+    const main = options.main
+        ? `./${(0, posix_1.relative)(project.root, options.main)}`
+        : './src/index.ts';
+    const outputPath = isTsSolutionSetup
+        ? './dist'
+        : (0, devkit_1.joinPathFragments)((0, devkit_1.offsetFromRoot)(project.root), 'dist', project.root === '.' ? project.name : project.root);
     const buildOptions = {
-        outputPath: isUsingTsPlugin
-            ? './dist'
-            : (0, devkit_1.joinPathFragments)((0, devkit_1.offsetFromRoot)(project.root), 'dist', project.root === '.' ? project.name : project.root),
+        outputPath,
         compiler: options.compiler ?? 'babel',
-        main: options.main ?? './src/index.ts',
-        tsConfig: options.tsConfig ?? './tsconfig.lib.json',
+        main,
+        tsConfig: options.tsConfig
+            ? `./${(0, posix_1.relative)(project.root, options.tsConfig)}`
+            : './tsconfig.lib.json',
     };
     tree.write((0, devkit_1.joinPathFragments)(project.root, 'rollup.config.js'), `const { withNx } = require('@nx/rollup/with-nx');
 
@@ -51,8 +66,10 @@ module.exports = withNx(
     outputPath: '${buildOptions.outputPath}',
     tsConfig: '${buildOptions.tsConfig}',
     compiler: '${buildOptions.compiler}',
-    format: ${JSON.stringify(options.format ?? ['esm'])},
-    assets: [{ input: '.', output: '.', glob:'*.md' }],
+    format: ${JSON.stringify(options.format ?? ['esm'])},${!isTsSolutionSetup
+        ? `
+    assets: [{ input: '.', output: '.', glob:'*.md' }],`
+        : ''}
   },
   {
     // Provide additional rollup configuration here. See: https://rollupjs.org/configuration-options
@@ -61,6 +78,10 @@ module.exports = withNx(
   }
 );
 `);
+    return {
+        main: (0, devkit_1.joinPathFragments)(project.root, main),
+        outputPath: (0, devkit_1.joinPathFragments)(project.root, outputPath),
+    };
 }
 function checkForTargetConflicts(tree, options) {
     if (options.skipValidation)
@@ -70,48 +91,99 @@ function checkForTargetConflicts(tree, options) {
         throw new Error(`Project "${options.project}" already has a ${options.buildTarget} target. Pass --skipValidation to ignore this error.`);
     }
 }
-function addPackageJson(tree, options) {
+function updatePackageJson(tree, options, outputConfig, isTsSolutionSetup) {
     const project = (0, devkit_1.readProjectConfiguration)(tree, options.project);
-    const packageJsonPath = (0, devkit_1.joinPathFragments)(project.root, 'package.json');
-    if (!tree.exists(packageJsonPath)) {
-        const importPath = options.importPath || (0, get_import_path_1.getImportPath)(tree, options.project);
-        (0, devkit_1.writeJson)(tree, packageJsonPath, {
-            name: importPath,
+    const packageJsonPath = (0, posix_1.join)(project.root, 'package.json');
+    let packageJson;
+    if (tree.exists(packageJsonPath)) {
+        if (!isTsSolutionSetup) {
+            return;
+        }
+        packageJson = (0, devkit_1.readJson)(tree, packageJsonPath);
+    }
+    else {
+        packageJson = {
+            name: options.importPath || (0, get_import_path_1.getImportPath)(tree, options.project),
             version: '0.0.1',
+        };
+    }
+    if (isTsSolutionSetup) {
+        let main;
+        let outputPath;
+        if (outputConfig) {
+            ({ main, outputPath } = outputConfig);
+        }
+        else {
+            // target must exist if we don't receive an outputConfig
+            const projectTarget = project.targets[options.buildTarget];
+            const nxJson = (0, devkit_1.readNxJson)(tree);
+            const mergedTarget = (0, devkit_internals_1.mergeTargetConfigurations)(projectTarget, (projectTarget.executor
+                ? nxJson.targetDefaults?.[projectTarget.executor]
+                : undefined) ?? nxJson.targetDefaults?.[options.buildTarget]);
+            ({ main, outputPath } = mergedTarget.options);
+        }
+        packageJson = (0, js_1.getUpdatedPackageJsonContent)(packageJson, {
+            main,
+            outputPath,
+            projectRoot: project.root,
+            rootDir: (0, posix_1.dirname)(main),
+            generateExportsField: true,
+            packageJsonPath,
+            format: options.format ?? ['esm'],
+            outputFileExtensionForCjs: '.cjs.js',
+            outputFileExtensionForEsm: '.esm.js',
         });
+        // rollup has a specific declaration file generation not handled by the util above,
+        // adjust accordingly
+        const typingsFile = (packageJson.module ?? packageJson.main).replace(/\.js$/, '.d.ts');
+        packageJson.types = typingsFile;
+        packageJson.exports['.'].types = typingsFile;
     }
+    (0, devkit_1.writeJson)(tree, packageJsonPath, packageJson);
 }
-function addBuildTarget(tree, options) {
+function addBuildTarget(tree, options, isTsSolutionSetup) {
     (0, target_defaults_utils_1.addBuildTargetDefaults)(tree, '@nx/rollup:rollup', options.buildTarget);
     const project = (0, devkit_1.readProjectConfiguration)(tree, options.project);
     const prevBuildOptions = project.targets?.[options.buildTarget]?.options;
+    options.tsConfig ??=
+        prevBuildOptions?.tsConfig ??
+            (0, devkit_1.joinPathFragments)(project.root, 'tsconfig.lib.json');
+    let outputPath = prevBuildOptions?.outputPath;
+    if (!outputPath) {
+        outputPath = isTsSolutionSetup
+            ? (0, devkit_1.joinPathFragments)(project.root, 'dist')
+            : (0, devkit_1.joinPathFragments)('dist', project.root === '.' ? project.name : project.root);
+    }
     const buildOptions = {
         main: options.main ??
             prevBuildOptions?.main ??
             (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 ??
-            prevBuildOptions?.tsConfig ??
-            (0, devkit_1.joinPathFragments)(project.root, 'tsconfig.lib.json'),
-        additionalEntryPoints: prevBuildOptions?.additionalEntryPoints,
-        generateExportsField: prevBuildOptions?.generateExportsField,
+        outputPath,
+        tsConfig: options.tsConfig,
+        // TODO(leo): see if we can use this when updating the package.json for the new setup
+        // additionalEntryPoints: prevBuildOptions?.additionalEntryPoints,
+        // generateExportsField: prevBuildOptions?.generateExportsField,
         compiler: options.compiler ?? 'babel',
         project: `${project.root}/package.json`,
         external: options.external,
-        format: options.format,
+        format: options.format ?? isTsSolutionSetup ? ['esm'] : undefined,
     };
     if (options.rollupConfig) {
         buildOptions.rollupConfig = options.rollupConfig;
     }
-    if (tree.exists((0, devkit_1.joinPathFragments)(project.root, 'README.md'))) {
-        buildOptions.assets = [
-            {
-                glob: `${project.root}/README.md`,
-                input: '.',
-                output: '.',
-            },
-        ];
+    if (!isTsSolutionSetup) {
+        buildOptions.additionalEntryPoints =
+            prevBuildOptions?.additionalEntryPoints;
+        buildOptions.generateExportsField = prevBuildOptions?.generateExportsField;
+        if (tree.exists((0, devkit_1.joinPathFragments)(project.root, 'README.md'))) {
+            buildOptions.assets = [
+                {
+                    glob: `${project.root}/README.md`,
+                    input: '.',
+                    output: '.',
+                },
+            ];
+        }
     }
     (0, devkit_1.updateProjectConfiguration)(tree, options.project, {
         ...project,
@@ -125,4 +197,27 @@ function addBuildTarget(tree, options) {
         },
     });
 }
+function updateTsConfig(tree, options) {
+    const project = (0, devkit_1.readProjectConfiguration)(tree, options.project);
+    const tsconfigPath = options.tsConfig ?? (0, devkit_1.joinPathFragments)(project.root, 'tsconfig.lib.json');
+    if (!tree.exists(tsconfigPath)) {
+        throw new Error(`The '${tsconfigPath}' file doesn't exist. Provide the 'tsConfig' option with the correct path pointing to the tsconfig file to use for builds.`);
+    }
+    if (!ts) {
+        ts = (0, ensure_typescript_1.ensureTypescript)();
+    }
+    const parsedTsConfig = (0, js_1.readTsConfig)(tsconfigPath, {
+        ...ts.sys,
+        readFile: (p) => tree.read(p, 'utf-8'),
+        fileExists: (p) => tree.exists(p),
+    });
+    (0, devkit_1.updateJson)(tree, tsconfigPath, (json) => {
+        if (parsedTsConfig.options.module === ts.ModuleKind.NodeNext) {
+            json.compilerOptions ??= {};
+            json.compilerOptions.module = 'esnext';
+            json.compilerOptions.moduleResolution = 'bundler';
+        }
+        return json;
+    });
+}
 exports.default = configurationGenerator;

package/src/generators/configuration/schema.json

@@ -25,13 +25,13 @@
     },
     "main": {
       "type": "string",
-      "description": "Path relative to the workspace root for the main entry file. Defaults to '<projectRoot>/src/main.ts'.",
+      "description": "Path relative to the workspace root for the main entry file. Defaults to '<projectRoot>/src/index.ts'.",
       "alias": "entryFile",
       "x-priority": "important"
     },
     "tsConfig": {
       "type": "string",
-      "description": "Path relative to the workspace root for the tsconfig file to build with. Defaults to '<projectRoot>/tsconfig.app.json'.",
+      "description": "Path relative to the workspace root for the tsconfig file to build with. Defaults to '<projectRoot>/tsconfig.lib.json'.",
       "x-priority": "important"
     },
     "skipFormat": {

package/src/plugins/plugin.d.ts

@@ -1,6 +1,10 @@
-import { type CreateDependencies, type CreateNodes } from '@nx/devkit';
+import { type CreateDependencies, type CreateNodes, CreateNodesV2 } from '@nx/devkit';
+/**
+ * @deprecated The 'createDependencies' function is now a no-op. This functionality is included in 'createNodesV2'.
+ */
 export declare const createDependencies: CreateDependencies;
 export interface RollupPluginOptions {
     buildTargetName?: string;
 }
 export declare const createNodes: CreateNodes<RollupPluginOptions>;
+export declare const createNodesV2: CreateNodesV2<RollupPluginOptions>;

package/src/plugins/plugin.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createNodes = exports.createDependencies = void 0;
+exports.createNodesV2 = exports.createNodes = exports.createDependencies = void 0;
 const cache_directory_1 = require("nx/src/utils/cache-directory");
 const path_1 = require("path");
 const fs_1 = require("fs");
@@ -8,47 +8,64 @@ const devkit_1 = require("@nx/devkit");
 const calculate_hash_for_create_nodes_1 = require("@nx/devkit/src/utils/calculate-hash-for-create-nodes");
 const js_1 = require("@nx/js");
 const get_named_inputs_1 = require("@nx/devkit/src/utils/get-named-inputs");
-const cachePath = (0, path_1.join)(cache_directory_1.workspaceDataDirectory, 'rollup.hash');
-const targetsCache = readTargetsCache();
-function readTargetsCache() {
+const file_hasher_1 = require("nx/src/hasher/file-hasher");
+const pmc = (0, devkit_1.getPackageManagerCommand)();
+function readTargetsCache(cachePath) {
     return (0, fs_1.existsSync)(cachePath) ? (0, devkit_1.readJsonFile)(cachePath) : {};
 }
-function writeTargetsToCache() {
-    const oldCache = readTargetsCache();
-    (0, devkit_1.writeJsonFile)(cachePath, {
-        ...oldCache,
-        ...targetsCache,
-    });
+function writeTargetsToCache(cachePath, results) {
+    (0, devkit_1.writeJsonFile)(cachePath, results);
 }
+/**
+ * @deprecated The 'createDependencies' function is now a no-op. This functionality is included in 'createNodesV2'.
+ */
 const createDependencies = () => {
-    writeTargetsToCache();
     return [];
 };
 exports.createDependencies = createDependencies;
+const rollupConfigGlob = '**/rollup.config.{js,cjs,mjs}';
 exports.createNodes = [
-    '**/rollup.config.{js,cjs,mjs}',
+    rollupConfigGlob,
     async (configFilePath, options, context) => {
-        const projectRoot = (0, path_1.dirname)(configFilePath);
-        const fullyQualifiedProjectRoot = (0, path_1.join)(context.workspaceRoot, projectRoot);
-        // Do not create a project if package.json and project.json do not exist
-        const siblingFiles = (0, fs_1.readdirSync)(fullyQualifiedProjectRoot);
-        if (!siblingFiles.includes('package.json') &&
-            !siblingFiles.includes('project.json')) {
-            return {};
+        devkit_1.logger.warn('`createNodes` is deprecated. Update your plugin to utilize createNodesV2 instead. In Nx 20, this will change to the createNodesV2 API.');
+        return createNodesInternal(configFilePath, normalizeOptions(options), context, {});
+    },
+];
+exports.createNodesV2 = [
+    rollupConfigGlob,
+    async (configFilePaths, options, context) => {
+        const normalizedOptions = normalizeOptions(options);
+        const optionsHash = (0, file_hasher_1.hashObject)(normalizedOptions);
+        const cachePath = (0, path_1.join)(cache_directory_1.workspaceDataDirectory, `rollup-${optionsHash}.hash`);
+        const targetsCache = readTargetsCache(cachePath);
+        try {
+            return await (0, devkit_1.createNodesFromFiles)((configFile, _, context) => createNodesInternal(configFile, normalizedOptions, context, targetsCache), configFilePaths, normalizedOptions, context);
+        }
+        finally {
+            writeTargetsToCache(cachePath, targetsCache);
         }
-        options = normalizeOptions(options);
-        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: {
-                [projectRoot]: {
-                    root: projectRoot,
-                    targets: targetsCache[hash],
-                },
-            },
-        };
     },
 ];
+async function createNodesInternal(configFilePath, options, context, targetsCache) {
+    const projectRoot = (0, path_1.dirname)(configFilePath);
+    const fullyQualifiedProjectRoot = (0, path_1.join)(context.workspaceRoot, projectRoot);
+    // Do not create a project if package.json and project.json do not exist
+    const siblingFiles = (0, fs_1.readdirSync)(fullyQualifiedProjectRoot);
+    if (!siblingFiles.includes('package.json') &&
+        !siblingFiles.includes('project.json')) {
+        return {};
+    }
+    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: {
+            [projectRoot]: {
+                root: projectRoot,
+                targets: targetsCache[hash],
+            },
+        },
+    };
+}
 async function buildRollupTarget(configFilePath, projectRoot, options, context) {
     let loadConfigFile;
     try {
@@ -83,6 +100,19 @@ async function buildRollupTarget(configFilePath, projectRoot, options, context)
             { externalDependencies: ['rollup'] },
         ],
         outputs,
+        metadata: {
+            technologies: ['rollup'],
+            description: 'Run Rollup',
+            help: {
+                command: `${pmc.exec} rollup --help`,
+                example: {
+                    options: {
+                        sourcemap: true,
+                        watch: true,
+                    },
+                },
+            },
+        },
     };
     return targets;
 }
@@ -113,7 +143,7 @@ function getOutputs(rollupConfigs, projectRoot) {
     return Array.from(outputs);
 }
 function normalizeOptions(options) {
-    options ??= {};
-    options.buildTargetName ??= 'build';
-    return options;
+    return {
+        buildTargetName: options.buildTargetName ?? 'build',
+    };
 }

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

@@ -76,6 +76,12 @@ export interface RollupWithNxPluginOptions {
      * The path to tsconfig file.
      */
     tsConfig: string;
+    /**
+     * Whether to generate a package.json file in the output path. It's not supported when the workspace is
+     * set up with TypeScript Project References along with the package managers' Workspaces feature. Otherwise,
+     * it defaults to `true`.
+     */
+    generatePackageJson?: boolean;
 }
 export interface AssetGlobPattern {
     glob: string;

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

@@ -16,6 +16,7 @@ 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");
+const ts_solution_setup_1 = require("@nx/js/src/utils/typescript/ts-solution-setup");
 // These use require because the ES import isn't correct.
 const commonjs = require('@rollup/plugin-commonjs');
 const image = require('@rollup/plugin-image');
@@ -119,6 +120,18 @@ dependencies) {
         };
     }
     if (!global.NX_GRAPH_CREATION) {
+        const isTsSolutionSetup = (0, ts_solution_setup_1.isUsingTsSolutionSetup)();
+        if (isTsSolutionSetup) {
+            if (options.generatePackageJson) {
+                throw new Error(`Setting 'generatePackageJson: true' is not supported with the current TypeScript setup. Update the 'package.json' file at the project root as needed and unset the 'generatePackageJson' option.`);
+            }
+            if (options.generateExportsField) {
+                throw new Error(`Setting 'generateExportsField: true' is not supported with the current TypeScript setup. Set 'exports' field in the 'package.json' file at the project root and unset the 'generateExportsField' option.`);
+            }
+        }
+        else {
+            options.generatePackageJson ??= true;
+        }
         finalConfig.plugins = [
             copy({
                 targets: convertCopyAssetsToRollupOptions(options.outputPath, options.assets),
@@ -173,7 +186,7 @@ dependencies) {
                 }),
             commonjs(),
             (0, analyze_1.analyze)(),
-            (0, generate_package_json_1.generatePackageJson)(options, packageJson),
+            options.generatePackageJson && (0, generate_package_json_1.generatePackageJson)(options, packageJson),
         ];
         if (Array.isArray(rollupConfig.plugins)) {
             finalConfig.plugins.push(...rollupConfig.plugins);