@nx/rollup 0.0.0-pr-31222-862e973 → 0.0.0-pr-31313-387cdca

package/LICENSE

@@ -1,6 +1,6 @@
 (The MIT License)
 
-Copyright (c) 2017-2024 Narwhal Technologies Inc.
+Copyright (c) 2017-2025 Narwhal Technologies Inc.
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

package/README.md

@@ -9,7 +9,7 @@
 
 [![CircleCI](https://circleci.com/gh/nrwl/nx.svg?style=svg)](https://circleci.com/gh/nrwl/nx)
 [![License](https://img.shields.io/npm/l/@nx/workspace.svg?style=flat-square)]()
-[![NPM Version](https://badge.fury.io/js/%40nrwl%2Fworkspace.svg)](https://www.npmjs.com/@nx/workspace)
+[![NPM Version](https://badge.fury.io/js/nx.svg)](https://www.npmjs.com/package/nx)
 [![Semantic Release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg?style=flat-square)]()
 [![Commitizen friendly](https://img.shields.io/badge/commitizen-friendly-brightgreen.svg)](http://commitizen.github.io/cz-cli/)
 [![Join the chat at https://gitter.im/nrwl-nx/community](https://badges.gitter.im/nrwl-nx/community.svg)](https://gitter.im/nrwl-nx/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)

package/migrations.json

@@ -1,34 +1,6 @@
 {
-  "generators": {
-    "update-16-0-0-add-nx-packages": {
-      "cli": "nx",
-      "version": "16.0.0-beta.1",
-      "description": "Replace @nrwl/rollup with @nx/rollup",
-      "implementation": "./src/migrations/update-16-0-0-add-nx-packages/update-16-0-0-add-nx-packages"
-    },
-    "update-16-3-3-add-babel-upward-root-mode-flag": {
-      "cli": "nx",
-      "version": "16.3.3-beta.0",
-      "description": "Add babelUpwardRootMode if not already defined",
-      "implementation": "./src/migrations/update-16-3-3-add-babel-upward-root-mode-flag/update-16-3-3-add-babel-upward-root-mode-flag"
-    },
-    "explicitly-set-projects-to-update-buildable-deps": {
-      "cli": "nx",
-      "version": "16.6.0-beta.0",
-      "description": "Explicitly set 'updateBuildableProjectDepsInPackageJson' to 'true' in targets that rely on that value as the default.",
-      "factory": "./src/migrations/update-16-6-0/explicitly-set-projects-to-update-buildable-deps"
-    }
-  },
+  "generators": {},
   "packageJsonUpdates": {
-    "18.2.0": {
-      "version": "18.2.0-beta.1",
-      "packages": {
-        "core-js": {
-          "version": "3.36.1",
-          "alwaysAddToPackageJson": false
-        }
-      }
-    },
     "19.0.0": {
       "version": "19.0.0-beta.0",
       "packages": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/rollup",
-  "version": "0.0.0-pr-31222-862e973",
+  "version": "0.0.0-pr-31313-387cdca",
   "private": false,
   "description": "The Nx Plugin for Rollup contains executors and generators that support building applications using Rollup.",
   "repository": {
@@ -29,27 +29,27 @@
     "migrations": "./migrations.json"
   },
   "dependencies": {
+    "@nx/devkit": "0.0.0-pr-31313-387cdca",
+    "@nx/js": "0.0.0-pr-31313-387cdca",
     "@rollup/plugin-babel": "^6.0.4",
     "@rollup/plugin-commonjs": "^25.0.7",
     "@rollup/plugin-image": "^3.0.3",
     "@rollup/plugin-json": "^6.1.0",
     "@rollup/plugin-node-resolve": "^15.2.3",
+    "@rollup/plugin-typescript": "^12.1.0",
     "autoprefixer": "^10.4.9",
-    "minimatch": "9.0.3",
     "picocolors": "^1.1.0",
+    "picomatch": "4.0.2",
     "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": "0.0.0-pr-31222-862e973",
-    "@nx/js": "0.0.0-pr-31222-862e973",
-    "@nrwl/rollup": "0.0.0-pr-31222-862e973"
+    "tslib": "^2.3.0"
   },
   "publishConfig": {
     "access": "public"
   },
-  "type": "commonjs",
-  "types": "./index.d.ts"
+  "types": "./index.d.ts",
+  "type": "commonjs"
 }

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/executors/rollup/lib/normalize.js

@@ -3,8 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizeRollupExecutorOptions = normalizeRollupExecutorOptions;
 exports.normalizePluginPath = normalizePluginPath;
 const path_1 = require("path");
+const ts_solution_setup_1 = require("@nx/js/src/utils/typescript/ts-solution-setup");
 function normalizeRollupExecutorOptions(options, context) {
     const { root } = context;
+    const skipTypeCheck = (0, ts_solution_setup_1.isUsingTsSolutionSetup)() ? true : options.skipTypeCheck;
     return {
         ...options,
         rollupConfig: []
@@ -12,7 +14,7 @@ function normalizeRollupExecutorOptions(options, context) {
             .filter(Boolean)
             .map((p) => normalizePluginPath(p, root)),
         projectRoot: context.projectGraph.nodes[context.projectName].data.root,
-        skipTypeCheck: options.skipTypeCheck || false,
+        skipTypeCheck: skipTypeCheck || false,
     };
 }
 function normalizePluginPath(pluginPath, root) {

package/src/executors/rollup/rollup.impl.d.ts

@@ -2,6 +2,6 @@ import * as rollup from 'rollup';
 import { type ExecutorContext } from '@nx/devkit';
 import { RollupExecutorOptions } from './schema';
 import { NormalizedRollupExecutorOptions } from './lib/normalize';
-export declare function rollupExecutor(rawOptions: RollupExecutorOptions, context: ExecutorContext): AsyncGenerator<unknown, any, undefined>;
+export declare function rollupExecutor(rawOptions: RollupExecutorOptions, context: ExecutorContext): AsyncGenerator<unknown, any, any>;
 export declare function createRollupOptions(options: NormalizedRollupExecutorOptions, context: ExecutorContext): Promise<rollup.RollupOptions | rollup.RollupOptions[]>;
 export default rollupExecutor;

package/src/executors/rollup/schema.d.ts

@@ -15,22 +15,23 @@ export interface Globals {
 export interface RollupExecutorOptions {
   outputPath: string;
   tsConfig: string;
-  allowJs?: boolean;
-  project: string;
   main: string;
-  outputFileName?: string;
-  extractCss?: boolean | string;
-  external?: string[] | 'all' | 'none';
-  rollupConfig?: string | string[];
-  watch?: boolean;
+  additionalEntryPoints?: string[];
+  allowJs?: boolean;
   assets?: any[];
+  babelUpwardRootMode?: boolean;
+  buildLibsFromSource?: boolean;
+  compiler?: 'babel' | 'tsc' | 'swc';
   deleteOutputPath?: boolean;
+  external?: string[] | 'all' | 'none';
+  extractCss?: boolean | string;
   format?: ('cjs' | 'esm')[];
-  compiler?: 'babel' | 'tsc' | 'swc';
-  javascriptEnabled?: boolean;
   generateExportsField?: boolean;
-  additionalEntryPoints?: string[];
+  javascriptEnabled?: boolean;
+  project?: string;
+  outputFileName?: string;
+  rollupConfig?: string | string[];
   skipTypeCheck?: boolean;
-  babelUpwardRootMode?: boolean;
   skipTypeField?: boolean;
+  watch?: boolean;
 }

package/src/executors/rollup/schema.json

@@ -1,15 +1,14 @@
 {
   "version": 2,
   "outputCapture": "direct-nodejs",
-  "title": "Web Library Rollup Target (Experimental)",
+  "title": "Web Library Rollup Target",
   "description": "Packages a library for different web usages (ESM, CommonJS).",
   "cli": "nx",
   "type": "object",
   "properties": {
     "project": {
       "type": "string",
-      "description": "The path to package.json file.",
-      "x-priority": "important"
+      "description": "The path to package.json file."
     },
     "main": {
       "type": "string",
@@ -138,6 +137,11 @@
       },
       "x-priority": "important"
     },
+    "buildLibsFromSource": {
+      "type": "boolean",
+      "description": "Read buildable libraries from source instead of building them separately.",
+      "default": true
+    },
     "skipTypeCheck": {
       "type": "boolean",
       "description": "Whether to skip TypeScript type checking.",

package/src/generators/configuration/configuration.js

@@ -2,11 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.configurationGenerator = configurationGenerator;
 const devkit_1 = require("@nx/devkit");
-const get_import_path_1 = require("@nx/js/src/utils/get-import-path");
-const init_1 = require("../init/init");
 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 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);
@@ -17,43 +23,65 @@ 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) {
+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: (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.cjs'), `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'])},${!isTsSolutionSetup
+        ? `
+    assets: [{ input: '{projectRoot}', output: '.', glob:'*.md' }],`
+        : ''}
+  },
+  {
+    // Provide additional rollup configuration here. See: https://rollupjs.org/configuration-options
+    // e.g.
+    // output: { sourcemap: true },
+  }
+);
+`);
+    return {
+        main: (0, devkit_1.joinPathFragments)(project.root, main),
+        outputPath: (0, devkit_1.joinPathFragments)(project.root, outputPath),
     };
-    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)
@@ -63,48 +91,102 @@ 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);
+        }
+        // the file must exist in the TS solution setup
+        const tsconfigBase = (0, devkit_1.readJson)(tree, 'tsconfig.base.json');
+        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',
+            skipDevelopmentExports: !tsconfigBase.compilerOptions?.customConditions?.includes('development'),
         });
+        // 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,
@@ -118,4 +200,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/generators/convert-to-inferred/convert-to-inferred.js

@@ -47,11 +47,11 @@ async function convertToInferred(tree, options) {
             // 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`.
+            // If only the default `options.outputPath` is set as output, remove it and use path inferred from `rollup.config.cjs`.
             delete target.outputs;
         }
         else {
-            // Otherwise, replace `options.outputPath` with what is inferred from `rollup.config.js`.
+            // Otherwise, replace `options.outputPath` with what is inferred from `rollup.config.cjs`.
             target.outputs = target.outputs.map((output) => 
             // Again, "{projectRoot}/{options.outputPath}" is an invalid output for Rollup.
             output === '{options.outputPath}' ||

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

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.addPluginRegistrations = addPluginRegistrations;
 const devkit_1 = require("@nx/devkit");
-const minimatch_1 = require("minimatch");
+const picomatch = require("picomatch");
 async function addPluginRegistrations(tree, projectTargets, projects, pluginPath) {
     const nxJson = (0, devkit_1.readNxJson)(tree);
     for (const [project, options] of projectTargets.entries()) {
@@ -20,7 +20,7 @@ async function addPluginRegistrations(tree, projectTargets, projects, pluginPath
             nxJson.plugins.push(plugin);
         }
         else if (existingPlugin.include) {
-            if (!existingPlugin.include.some((include) => (0, minimatch_1.minimatch)(projectIncludeGlob, include, { dot: true }))) {
+            if (!existingPlugin.include.some((include) => picomatch(include)(projectIncludeGlob))) {
                 existingPlugin.include.push(projectIncludeGlob);
             }
         }

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

@@ -17,9 +17,13 @@ function extractRollupConfigFromExecutorOptions(tree, options, configurations, p
             ? [options.rollupConfig]
             : [];
     delete options.rollupConfig;
-    // Resolve conflict with rollup.config.js if it exists.
+    // Resolve conflict with rollup.config.cjs or rollup.config.js if they exist.
     for (let i = 0; i < oldRollupConfig.length; i++) {
         const file = oldRollupConfig[i];
+        if (file === './rollup.config.cjs') {
+            tree.rename((0, devkit_1.joinPathFragments)(projectRoot, 'rollup.config.cjs'), (0, devkit_1.joinPathFragments)(projectRoot, `rollup.migrated.config.cjs`));
+            oldRollupConfig.splice(i, 1, './rollup.migrated.config.cjs');
+        }
         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');
@@ -82,7 +86,7 @@ function extractRollupConfigFromExecutorOptions(tree, options, configurations, p
             }
         }
     }
-    tree.write((0, devkit_1.joinPathFragments)(projectRoot, `rollup.config.js`), createNewRollupConfig(oldRollupConfig, defaultOptions, configurationOptions));
+    tree.write((0, devkit_1.joinPathFragments)(projectRoot, `rollup.config.cjs`), createNewRollupConfig(oldRollupConfig, defaultOptions, configurationOptions));
     return defaultOptions;
 }
 function createNewRollupConfig(oldRollupConfig, defaultOptions, configurationOptions, singleConfiguration = false) {

package/src/generators/init/init.js

@@ -20,8 +20,18 @@ async function rollupInitGenerator(tree, schema) {
         task = (0, devkit_1.addDependenciesToPackageJson)(tree, {}, devDependencies, undefined, schema.keepExistingVersions);
     }
     if (schema.addPlugin) {
-        await (0, add_plugin_1.addPluginV1)(tree, await (0, devkit_1.createProjectGraphAsync)(), '@nx/rollup/plugin', plugin_1.createNodes, {
+        await (0, add_plugin_1.addPlugin)(tree, await (0, devkit_1.createProjectGraphAsync)(), '@nx/rollup/plugin', plugin_1.createNodesV2, {
             buildTargetName: ['build', 'rollup:build', 'rollup-build'],
+            buildDepsTargetName: [
+                'build-deps',
+                'rollup:build-deps',
+                'rollup-build-deps',
+            ],
+            watchDepsTargetName: [
+                'watch-deps',
+                'rollup:watch-deps',
+                'rollup-watch-deps',
+            ],
         }, schema.updatePackageScripts);
     }
     if (!schema.skipFormat) {

package/src/plugins/plugin.d.ts

@@ -1,6 +1,12 @@
-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;
+    buildDepsTargetName?: string;
+    watchDepsTargetName?: 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,48 +8,68 @@ 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 ts_solution_setup_1 = require("@nx/js/src/utils/typescript/ts-solution-setup");
+const util_1 = require("@nx/js/src/plugins/typescript/util");
+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,ts,cts,mts}';
 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, {}, (0, ts_solution_setup_1.isUsingTsSolutionSetup)());
+    },
+];
+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);
+        const isTsSolutionSetup = (0, ts_solution_setup_1.isUsingTsSolutionSetup)();
+        try {
+            return await (0, devkit_1.createNodesFromFiles)((configFile, _, context) => createNodesInternal(configFile, normalizedOptions, context, targetsCache, isTsSolutionSetup), 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 buildRollupTarget(configFilePath, projectRoot, options, context) {
+async function createNodesInternal(configFilePath, options, context, targetsCache, isTsSolutionSetup) {
+    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, isTsSolutionSetup);
+    return {
+        projects: {
+            [projectRoot]: {
+                root: projectRoot,
+                targets: targetsCache[hash],
+            },
+        },
+    };
+}
+async function buildRollupTarget(configFilePath, projectRoot, options, context, isTsSolutionSetup) {
     let loadConfigFile;
     try {
         // Try to load the workspace version of rollup first (it should already exist).
@@ -66,13 +86,15 @@ async function buildRollupTarget(configFilePath, projectRoot, options, context)
         // Fallback to our own if needed.
         loadConfigFile = require('rollup/loadConfigFile').loadConfigFile;
     }
+    const isTsConfig = configFilePath.endsWith('ts');
+    const tsConfigPlugin = '@rollup/plugin-typescript';
     const namedInputs = (0, get_named_inputs_1.getNamedInputs)(projectRoot, context);
-    const rollupConfig = (await loadConfigFile((0, devkit_1.joinPathFragments)(context.workspaceRoot, configFilePath), {}, true // Enable watch mode so that rollup properly reloads config files without reusing a cached version
+    const rollupConfig = (await loadConfigFile((0, devkit_1.joinPathFragments)(context.workspaceRoot, configFilePath), isTsConfig ? { configPlugin: tsConfigPlugin } : {}, true // Enable watch mode so that rollup properly reloads config files without reusing a cached version
     )).options;
     const outputs = getOutputs(rollupConfig, projectRoot);
     const targets = {};
     targets[options.buildTargetName] = {
-        command: `rollup -c ${(0, path_1.basename)(configFilePath)}`,
+        command: `rollup -c ${(0, path_1.basename)(configFilePath)}${isTsConfig ? ` --configPlugin ${tsConfigPlugin}` : ''}`,
         options: { cwd: projectRoot },
         cache: true,
         dependsOn: [`^${options.buildTargetName}`],
@@ -83,7 +105,26 @@ 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,
+                    },
+                },
+            },
+        },
     };
+    if (isTsSolutionSetup) {
+        targets[options.buildTargetName].syncGenerators = [
+            '@nx/js:typescript-sync',
+        ];
+    }
+    (0, util_1.addBuildAndWatchDepsTargets)(context.workspaceRoot, projectRoot, targets, options, pmc);
     return targets;
 }
 function getOutputs(rollupConfigs, projectRoot) {
@@ -113,7 +154,9 @@ function getOutputs(rollupConfigs, projectRoot) {
     return Array.from(outputs);
 }
 function normalizeOptions(options) {
-    options ??= {};
-    options.buildTargetName ??= 'build';
-    return options;
+    return {
+        buildTargetName: options.buildTargetName ?? 'build',
+        buildDepsTargetName: options.buildDepsTargetName ?? 'build-deps',
+        watchDepsTargetName: options.watchDepsTargetName ?? 'watch-deps',
+    };
 }

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

@@ -5,10 +5,15 @@ 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");
+const ts_solution_setup_1 = require("@nx/js/src/utils/typescript/ts-solution-setup");
 function normalizeOptions(projectRoot, sourceRoot, options) {
     if (global.NX_GRAPH_CREATION)
         return options;
     normalizeRelativePaths(projectRoot, options);
+    // New TS Solution already has a typecheck target
+    if ((0, ts_solution_setup_1.isUsingTsSolutionSetup)()) {
+        options.skipTypeCheck = true;
+    }
     return {
         ...options,
         additionalEntryPoints: (0, js_1.createEntryPoints)(options.additionalEntryPoints, devkit_1.workspaceRoot),

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

@@ -15,6 +15,10 @@ export interface RollupWithNxPluginOptions {
      * Whether to set rootmode to upward. See https://babeljs.io/docs/en/options#rootmode
      */
     babelUpwardRootMode?: boolean;
+    /**
+     * Build the libraries from source. Default is `true`.
+     */
+    buildLibsFromSource?: boolean;
     /**
      * Which compiler to use.
      */
@@ -76,6 +80,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');
@@ -42,7 +43,9 @@ 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 tsConfigPath = options.buildLibsFromSource || global.NX_GRAPH_CREATION
+        ? (0, devkit_1.joinPathFragments)(devkit_1.workspaceRoot, options.tsConfig)
+        : (0, buildable_libs_utils_1.createTmpTsConfig)(options.tsConfig, devkit_1.workspaceRoot, projectRoot, dependencies);
     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) {
@@ -119,6 +122,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),
@@ -128,7 +143,7 @@ dependencies) {
             // Needed to generate type definitions, even if we're using babel or swc.
             require('rollup-plugin-typescript2')({
                 check: !options.skipTypeCheck,
-                tsconfig: options.tsConfig,
+                tsconfig: tsConfigPath,
                 tsconfigOverride: {
                     compilerOptions: createTsCompilerOptions(projectRoot, tsConfig, options, dependencies),
                 },
@@ -173,8 +188,8 @@ dependencies) {
                 }),
             commonjs(),
             (0, analyze_1.analyze)(),
-            (0, generate_package_json_1.generatePackageJson)(options, packageJson),
-        ];
+            options.generatePackageJson && (0, generate_package_json_1.generatePackageJson)(options, packageJson),
+        ].filter(Boolean);
         if (Array.isArray(rollupConfig.plugins)) {
             finalConfig.plugins.push(...rollupConfig.plugins);
         }

package/src/migrations/update-16-0-0-add-nx-packages/update-16-0-0-add-nx-packages.d.ts

@@ -1,2 +0,0 @@
-import { Tree } from '@nx/devkit';
-export default function replacePackage(tree: Tree): Promise<void>;

package/src/migrations/update-16-0-0-add-nx-packages/update-16-0-0-add-nx-packages.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = replacePackage;
-const devkit_1 = require("@nx/devkit");
-const replace_package_1 = require("@nx/devkit/src/utils/replace-package");
-async function replacePackage(tree) {
-    await (0, replace_package_1.replaceNrwlPackageWithNxPackage)(tree, '@nrwl/rollup', '@nx/rollup');
-    await (0, devkit_1.formatFiles)(tree);
-}

package/src/migrations/update-16-3-3-add-babel-upward-root-mode-flag/update-16-3-3-add-babel-upward-root-mode-flag.d.ts

@@ -1,2 +0,0 @@
-import { Tree } from '@nx/devkit';
-export default function (tree: Tree): Promise<void>;

package/src/migrations/update-16-3-3-add-babel-upward-root-mode-flag/update-16-3-3-add-babel-upward-root-mode-flag.js

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = default_1;
-const devkit_1 = require("@nx/devkit");
-const executor_options_utils_1 = require("@nx/devkit/src/generators/executor-options-utils");
-async function default_1(tree) {
-    (0, executor_options_utils_1.forEachExecutorOptions)(tree, '@nx/rollup:rollup', (options, projectName, targetName, _configurationName) => {
-        if (options.babelUpwardRootMode !== undefined) {
-            return;
-        }
-        const projectConfiguration = (0, devkit_1.readProjectConfiguration)(tree, projectName);
-        projectConfiguration.targets[targetName].options.babelUpwardRootMode =
-            true;
-        (0, devkit_1.updateProjectConfiguration)(tree, projectName, projectConfiguration);
-    });
-    await (0, devkit_1.formatFiles)(tree);
-}

package/src/migrations/update-16-6-0/explicitly-set-projects-to-update-buildable-deps.d.ts

@@ -1,2 +0,0 @@
-import { Tree } from '@nx/devkit';
-export default function (tree: Tree): Promise<void>;

package/src/migrations/update-16-6-0/explicitly-set-projects-to-update-buildable-deps.js

@@ -1,29 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = default_1;
-const devkit_1 = require("@nx/devkit");
-const executors = new Set(['@nx/rollup:rollup', '@nrwl/rollup:rollup']);
-async function default_1(tree) {
-    // use project graph to get the expanded target configurations
-    const projectGraph = await (0, devkit_1.createProjectGraphAsync)();
-    for (const [projectName, { data: projectData }] of Object.entries(projectGraph.nodes)) {
-        if (projectData.projectType !== 'library') {
-            continue;
-        }
-        for (const [targetName, target] of Object.entries(projectData.targets || {})) {
-            if (!executors.has(target.executor)) {
-                continue;
-            }
-            if (!target.options ||
-                target.options.updateBuildableProjectDepsInPackageJson === undefined) {
-                // read the project configuration to write the explicit project configuration
-                // and avoid writing the expanded target configuration
-                const project = (0, devkit_1.readProjectConfiguration)(tree, projectName);
-                project.targets[targetName].options ??= {};
-                project.targets[targetName].options.updateBuildableProjectDepsInPackageJson = true;
-                (0, devkit_1.updateProjectConfiguration)(tree, projectName, project);
-            }
-        }
-    }
-    await (0, devkit_1.formatFiles)(tree);
-}