@nx/rollup 20.1.0-canary.20241025-1218502 → 20.1.0-canary.20241029-4b70d1b

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/rollup",
-  "version": "20.1.0-canary.20241025-1218502",
+  "version": "20.1.0-canary.20241029-4b70d1b",
   "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.1.0-canary.20241025-1218502",
-    "@nx/js": "20.1.0-canary.20241025-1218502"
+    "@nx/devkit": "20.1.0-canary.20241029-4b70d1b",
+    "@nx/js": "20.1.0-canary.20241029-4b70d1b"
   },
   "publishConfig": {
     "access": "public"

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/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);