@nx/rollup 23.0.0-pr.35465.2bc2643 → 23.0.0-rc.0

package/{index.d.ts → dist/index.d.ts}

@@ -5,4 +5,3 @@ export declare const rollupProjectGenerator: typeof configurationGenerator;
 export * from './src/generators/init/init';
 export type { AssetGlobPattern, Globals, RollupExecutorOptions, } from './src/executors/rollup/schema';
 export * from './src/executors/rollup/rollup.impl';
-//# sourceMappingURL=index.d.ts.map

package/dist/internal.d.ts

@@ -0,0 +1 @@
+export { hasPlugin } from './src/utils/has-plugin';

package/dist/internal.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasPlugin = void 0;
+// Curated internal API surface for other first-party Nx plugins. Prefer this
+// over deep `@nx/rollup/src/*` imports — those are not part of the public API.
+var has_plugin_1 = require("./src/utils/has-plugin");
+Object.defineProperty(exports, "hasPlugin", { enumerable: true, get: function () { return has_plugin_1.hasPlugin; } });

package/{plugin.d.ts → dist/plugin.d.ts}

@@ -1,2 +1 @@
 export { createNodes, createNodesV2, RollupPluginOptions, } from './src/plugins/plugin';
-//# sourceMappingURL=plugin.d.ts.map

package/{src → dist/src}/executors/rollup/lib/normalize.d.ts

@@ -6,4 +6,3 @@ export interface NormalizedRollupExecutorOptions extends RollupExecutorOptions {
 }
 export declare function normalizeRollupExecutorOptions(options: RollupExecutorOptions, context: ExecutorContext): NormalizedRollupExecutorOptions;
 export declare function normalizePluginPath(pluginPath: void | string, root: string): string;
-//# sourceMappingURL=normalize.d.ts.map

package/{src → dist/src}/executors/rollup/lib/normalize.js

@@ -3,10 +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");
+const internal_1 = require("@nx/js/internal");
 function normalizeRollupExecutorOptions(options, context) {
     const { root } = context;
-    const skipTypeCheck = (0, ts_solution_setup_1.isUsingTsSolutionSetup)() ? true : options.skipTypeCheck;
+    const skipTypeCheck = (0, internal_1.isUsingTsSolutionSetup)() ? true : options.skipTypeCheck;
     return {
         ...options,
         rollupConfig: []

package/{src → dist/src}/executors/rollup/rollup.impl.d.ts

@@ -1,8 +1,7 @@
-import * as rollup from 'rollup';
+import type * 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, any>;
-export declare function createRollupOptions(options: NormalizedRollupExecutorOptions, context: ExecutorContext): Promise<rollup.RollupOptions | rollup.RollupOptions[]>;
+export declare function createRollupOptions(options: NormalizedRollupExecutorOptions, context: ExecutorContext): Promise<Rollup.RollupOptions | Rollup.RollupOptions[]>;
 export default rollupExecutor;
-//# sourceMappingURL=rollup.impl.d.ts.map

package/{src → dist/src}/executors/rollup/rollup.impl.js

@@ -2,24 +2,25 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.rollupExecutor = rollupExecutor;
 exports.createRollupOptions = createRollupOptions;
-const tslib_1 = require("tslib");
-const rollup = tslib_1.__importStar(require("rollup"));
 const path_1 = require("path");
 const devkit_1 = require("@nx/devkit");
+const internal_1 = require("@nx/devkit/internal");
 const normalize_1 = require("./lib/normalize");
-const config_utils_1 = require("@nx/devkit/src/utils/config-utils");
-const async_iterable_1 = require("@nx/devkit/src/utils/async-iterable");
 const with_nx_1 = require("../../plugins/with-nx/with-nx");
 const generate_package_json_1 = require("../../plugins/package-json/generate-package-json");
-const buildable_libs_utils_1 = require("@nx/js/src/utils/buildable-libs-utils");
+const internal_2 = require("@nx/js/internal");
+const deprecation_1 = require("../../utils/deprecation");
 async function* rollupExecutor(rawOptions, context) {
+    (0, deprecation_1.warnRollupExecutorDeprecation)();
+    // Lazy-loaded: `rollup` is an optional peer, absent at project-graph discovery time.
+    const rollup = require('rollup');
     process.env.NODE_ENV ??= 'production';
     const options = (0, normalize_1.normalizeRollupExecutorOptions)(rawOptions, context);
     const rollupOptions = await createRollupOptions(options, context);
     const outfile = resolveOutfile(context, options);
     if (options.watch) {
         // region Watch build
-        return yield* (0, async_iterable_1.createAsyncIterable)(({ next }) => {
+        return yield* (0, internal_1.createAsyncIterable)(({ next }) => {
             const watcher = rollup.watch(rollupOptions);
             watcher.on('event', (data) => {
                 if (data.code === 'START') {
@@ -79,14 +80,14 @@ async function* rollupExecutor(rawOptions, context) {
 }
 // -----------------------------------------------------------------------------
 async function createRollupOptions(options, context) {
-    const { dependencies } = (0, buildable_libs_utils_1.calculateProjectBuildableDependencies)(context.taskGraph, context.projectGraph, context.root, context.projectName, context.targetName, context.configurationName, true);
+    const { dependencies } = (0, internal_2.calculateProjectBuildableDependencies)(context.taskGraph, context.projectGraph, context.root, context.projectName, context.targetName, context.configurationName, true);
     const rollupConfig = (0, with_nx_1.withNx)(options, {}, dependencies);
     // `generatePackageJson` is a plugin rather than being embedded into @nx/rollup:rollup.
     // Make sure the plugin is always present to keep the previous before of Nx < 19.4, where it was not a plugin.
     const generatePackageJsonPlugin = Array.isArray(rollupConfig.plugins)
         ? rollupConfig.plugins.find((p) => p['name'] === generate_package_json_1.pluginName)
         : null;
-    const userDefinedRollupConfigs = options.rollupConfig.map((plugin) => (0, config_utils_1.loadConfigFile)(plugin));
+    const userDefinedRollupConfigs = options.rollupConfig.map((plugin) => (0, internal_1.loadConfigFile)(plugin));
     let finalConfig = rollupConfig;
     for (const _config of userDefinedRollupConfigs) {
         const config = await _config;

package/{src → dist/src}/executors/rollup/schema.d.ts

@@ -33,6 +33,5 @@ export interface RollupExecutorOptions {
   rollupConfig?: string | string[];
   skipTypeCheck?: boolean;
   skipTypeField?: boolean;
-  useLegacyTypescriptPlugin?: boolean;
   watch?: boolean;
 }

package/{src → dist/src}/executors/rollup/schema.json

@@ -5,6 +5,7 @@
   "description": "Packages a library for different web usages (ESM, CommonJS).",
   "cli": "nx",
   "type": "object",
+  "x-deprecated": "The `@nx/rollup:rollup` executor is deprecated and will be removed in Nx v24. Run `nx g @nx/rollup:convert-to-inferred` to migrate to the `@nx/rollup/plugin` inferred plugin. See https://nx.dev/docs/guides/tasks--caching/convert-to-inferred for details.",
   "properties": {
     "project": {
       "type": "string",
@@ -155,11 +156,6 @@
     "sourceMap": {
       "description": "Output sourcemaps.",
       "type": "boolean"
-    },
-    "useLegacyTypescriptPlugin": {
-      "type": "boolean",
-      "description": "Use rollup-plugin-typescript2 instead of @rollup/plugin-typescript.",
-      "default": false
     }
   },
   "required": ["tsConfig", "main", "outputPath"],
@@ -191,5 +187,5 @@
       ]
     }
   },
-  "examplesFile": "../../docs/rollup-examples.md"
+  "examplesFile": "../../../docs/rollup-examples.md"
 }

package/{src → dist/src}/generators/configuration/configuration.d.ts

@@ -2,4 +2,3 @@ import { GeneratorCallback, Tree } from '@nx/devkit';
 import { RollupProjectSchema } from './schema';
 export declare function configurationGenerator(tree: Tree, options: RollupProjectSchema): Promise<GeneratorCallback>;
 export default configurationGenerator;
-//# sourceMappingURL=configuration.d.ts.map

package/{src → dist/src}/generators/configuration/configuration.js

@@ -1,19 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.configurationGenerator = configurationGenerator;
+const internal_1 = require("@nx/devkit/internal");
 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 internal_2 = require("@nx/js/internal");
 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 deprecation_1 = require("../../utils/deprecation");
+const versions_1 = require("../../utils/versions");
 const init_1 = require("../init/init");
 let ts;
 async function configurationGenerator(tree, options) {
+    (0, versions_1.assertSupportedRollupVersion)(tree);
     const tasks = [];
     const nxJson = (0, devkit_1.readNxJson)(tree);
     const addPluginDefault = process.env.NX_ADD_PLUGINS !== 'false' &&
@@ -23,12 +24,13 @@ 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);
+    const isTsSolutionSetup = (0, internal_2.isUsingTsSolutionSetup)(tree);
     let outputConfig;
     if ((0, has_plugin_1.hasPlugin)(tree)) {
         outputConfig = createRollupConfig(tree, options, isTsSolutionSetup);
     }
     else {
+        (0, deprecation_1.warnRollupExecutorGenerating)();
         options.buildTarget ??= 'build';
         checkForTargetConflicts(tree, options);
         addBuildTarget(tree, options, isTsSolutionSetup);
@@ -103,7 +105,7 @@ function updatePackageJson(tree, options, outputConfig, isTsSolutionSetup) {
     }
     else {
         packageJson = {
-            name: options.importPath || (0, get_import_path_1.getImportPath)(tree, options.project),
+            name: options.importPath || (0, internal_2.getImportPath)(tree, options.project),
             version: '0.0.1',
         };
     }
@@ -117,9 +119,7 @@ function updatePackageJson(tree, options, outputConfig, isTsSolutionSetup) {
             // 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]);
+            const mergedTarget = (0, devkit_internals_1.mergeTargetConfigurations)(projectTarget, (0, internal_1.readTargetDefaultsForTarget)(options.buildTarget, nxJson.targetDefaults, projectTarget.executor));
             ({ main, outputPath } = mergedTarget.options);
         }
         packageJson = (0, js_1.getUpdatedPackageJsonContent)(packageJson, {
@@ -132,7 +132,7 @@ function updatePackageJson(tree, options, outputConfig, isTsSolutionSetup) {
             format: options.format ?? ['esm'],
             outputFileExtensionForCjs: '.cjs.js',
             outputFileExtensionForEsm: '.esm.js',
-            developmentConditionName: (0, ts_solution_setup_1.getDefinedCustomConditionName)(tree),
+            developmentConditionName: (0, internal_2.getDefinedCustomConditionName)(tree),
         });
         // rollup has a specific declaration file generation not handled by the util above,
         // adjust accordingly
@@ -143,7 +143,9 @@ function updatePackageJson(tree, options, outputConfig, isTsSolutionSetup) {
     (0, devkit_1.writeJson)(tree, packageJsonPath, packageJson);
 }
 function addBuildTarget(tree, options, isTsSolutionSetup) {
-    (0, target_defaults_utils_1.addBuildTargetDefaults)(tree, '@nx/rollup:rollup', options.buildTarget);
+    (0, internal_1.addBuildTargetDefaults)(tree, '@nx/rollup:rollup', options.buildTarget, [
+        internal_2.TS_SOLUTION_SETUP_TSCONFIG_INPUT,
+    ]);
     const project = (0, devkit_1.readProjectConfiguration)(tree, options.project);
     const prevBuildOptions = project.targets?.[options.buildTarget]?.options;
     options.tsConfig ??=
@@ -205,7 +207,7 @@ function updateTsConfig(tree, options) {
         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)();
+        ts = (0, internal_2.ensureTypescript)();
     }
     const parsedTsConfig = (0, js_1.readTsConfig)(tsconfigPath, {
         ...ts.sys,

package/{src → dist/src}/generators/convert-to-inferred/convert-to-inferred.d.ts

@@ -5,4 +5,3 @@ interface Schema {
 }
 export declare function convertToInferred(tree: Tree, options: Schema): Promise<void>;
 export default convertToInferred;
-//# sourceMappingURL=convert-to-inferred.d.ts.map

package/{src → dist/src}/generators/convert-to-inferred/convert-to-inferred.js

@@ -1,15 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.convertToInferred = convertToInferred;
+const internal_1 = require("@nx/devkit/internal");
 const devkit_1 = require("@nx/devkit");
-const executor_options_utils_1 = require("@nx/devkit/src/generators/executor-options-utils");
 const extract_rollup_config_from_executor_options_1 = require("./lib/extract-rollup-config-from-executor-options");
 const add_plugin_registrations_1 = require("./lib/add-plugin-registrations");
-const executor_to_plugin_migrator_1 = require("@nx/devkit/src/generators/plugin-migrations/executor-to-plugin-migrator");
+const versions_1 = require("../../utils/versions");
 async function convertToInferred(tree, options) {
+    (0, versions_1.assertSupportedRollupVersion)(tree);
     const migratedProjects = new Map();
     let projects = (0, devkit_1.getProjects)(tree);
-    (0, executor_options_utils_1.forEachExecutorOptions)(tree, '@nx/rollup:rollup', (_, projectName, targetName, configurationName) => {
+    (0, internal_1.forEachExecutorOptions)(tree, '@nx/rollup:rollup', (_, projectName, targetName, configurationName) => {
         if (options.project && projectName !== options.project)
             return;
         const project = projects.get(projectName);
@@ -19,9 +20,13 @@ async function convertToInferred(tree, options) {
             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'];
+        const defaults = (0, internal_1.normalizeTargetDefaults)(nxJson?.targetDefaults).find((e) => e.executor === '@nx/rollup:rollup' &&
+            e.target === undefined &&
+            e.projects === undefined &&
+            e.plugin === undefined);
         if (defaults) {
-            for (const [key, value] of Object.entries(defaults)) {
+            const { target: _t, executor: _e, projects: _p, plugin: _pl, ...rest } = defaults;
+            for (const [key, value] of Object.entries(rest)) {
                 target[key] ??= value;
             }
         }
@@ -67,7 +72,7 @@ async function convertToInferred(tree, options) {
         migratedProjects.set(projectName, { buildTargetName: targetName });
     });
     if (migratedProjects.size === 0) {
-        throw new executor_to_plugin_migrator_1.NoTargetsToMigrateError();
+        throw new internal_1.NoTargetsToMigrateError();
     }
     projects = (0, devkit_1.getProjects)(tree);
     await (0, add_plugin_registrations_1.addPluginRegistrations)(tree, migratedProjects, projects, '@nx/rollup/plugin');

package/{src → dist/src}/generators/convert-to-inferred/lib/add-plugin-registrations.d.ts

@@ -1,3 +1,2 @@
 import { type ProjectConfiguration, type Tree } from '@nx/devkit';
 export declare function addPluginRegistrations<T>(tree: Tree, projectTargets: Map<string, T>, projects: Map<string, ProjectConfiguration>, pluginPath: string): Promise<void>;
-//# sourceMappingURL=add-plugin-registrations.d.ts.map

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

@@ -1,4 +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>;
-//# sourceMappingURL=extract-rollup-config-from-executor-options.d.ts.map

package/{src → dist/src}/generators/convert-to-inferred/lib/normalize-path-options.d.ts

@@ -1,3 +1,2 @@
 import { RollupExecutorOptions } from '../../../executors/rollup/schema';
 export declare function normalizePathOptions(projectRoot: string, options: RollupExecutorOptions): void;
-//# sourceMappingURL=normalize-path-options.d.ts.map

package/{src → dist/src}/generators/init/init.d.ts

@@ -2,4 +2,3 @@ import { GeneratorCallback, Tree } from '@nx/devkit';
 import { Schema } from './schema';
 export declare function rollupInitGenerator(tree: Tree, schema: Schema): Promise<GeneratorCallback>;
 export default rollupInitGenerator;
-//# sourceMappingURL=init.d.ts.map

package/{src → dist/src}/generators/init/init.js

@@ -1,26 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.rollupInitGenerator = rollupInitGenerator;
+const internal_1 = require("@nx/devkit/internal");
 const devkit_1 = require("@nx/devkit");
 const versions_1 = require("../../utils/versions");
-const add_plugin_1 = require("@nx/devkit/src/utils/add-plugin");
 const plugin_1 = require("../../plugins/plugin");
 async function rollupInitGenerator(tree, schema) {
+    (0, versions_1.assertSupportedRollupVersion)(tree);
     let task = () => { };
     const nxJson = (0, devkit_1.readNxJson)(tree);
     schema.addPlugin ??=
         process.env.NX_ADD_PLUGINS !== 'false' &&
             nxJson.useInferencePlugins !== false;
     if (!schema.skipPackageJson) {
-        const devDependencies = { '@nx/rollup': versions_1.nxVersion };
-        if (schema.addPlugin) {
-            // Ensure user can run Rollup CLI.
-            devDependencies['rollup'] = versions_1.rollupVersion;
-        }
-        task = (0, devkit_1.addDependenciesToPackageJson)(tree, {}, devDependencies, undefined, schema.keepExistingVersions);
+        // Rollup is a peer dependency, so ensure it is installed for both the
+        // inferred-plugin (CLI) path and the executor (programmatic) path.
+        const devDependencies = {
+            '@nx/rollup': versions_1.nxVersion,
+            rollup: versions_1.rollupVersion,
+        };
+        task = (0, devkit_1.addDependenciesToPackageJson)(tree, {}, devDependencies, undefined, schema.keepExistingVersions ?? true);
     }
     if (schema.addPlugin) {
-        await (0, add_plugin_1.addPlugin)(tree, await (0, devkit_1.createProjectGraphAsync)(), '@nx/rollup/plugin', plugin_1.createNodesV2, {
+        await (0, internal_1.addPlugin)(tree, await (0, devkit_1.createProjectGraphAsync)(), '@nx/rollup/plugin', plugin_1.createNodesV2, {
             buildTargetName: ['build', 'rollup:build', 'rollup-build'],
             buildDepsTargetName: [
                 'build-deps',

package/{src → dist/src}/generators/init/schema.json

@@ -20,7 +20,7 @@
       "type": "boolean",
       "x-priority": "internal",
       "description": "Keep existing dependencies versions",
-      "default": false
+      "default": true
     },
     "updatePackageScripts": {
       "type": "boolean",

package/dist/src/migrations/update-23-0-0/migrate-create-nodes-v2-to-create-nodes.d.ts

@@ -0,0 +1,9 @@
+import { type Tree } from '@nx/devkit';
+export default function migrateCreateNodesV2ToCreateNodes(tree: Tree): Promise<void>;
+/**
+ * Rewrites named imports and re-exports of `createNodesV2` to `createNodes`
+ * when they come from one of the given module specifiers. Only the named
+ * bindings are touched — the module specifier, the `import`/`export` keyword,
+ * any `type` modifier, and any default import are left untouched.
+ */
+export declare function rewriteCreateNodesV2Imports(source: string, specifiers: ReadonlySet<string>): string;

package/dist/src/migrations/update-23-0-0/migrate-create-nodes-v2-to-create-nodes.js

@@ -0,0 +1,223 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = migrateCreateNodesV2ToCreateNodes;
+exports.rewriteCreateNodesV2Imports = rewriteCreateNodesV2Imports;
+const devkit_1 = require("@nx/devkit");
+const TS_EXTENSIONS = ['.ts', '.tsx', '.cts', '.mts'];
+const DEPRECATED_NAME = 'createNodesV2';
+const CANONICAL_NAME = 'createNodes';
+// Module specifiers from which `@nx/rollup` publicly exposes `createNodesV2`.
+// A named import or re-export of `createNodesV2` from one of these is rewritten
+// to the canonical `createNodes` export.
+const TARGET_SPECIFIERS = new Set(['@nx/rollup/plugin']);
+let ts;
+async function migrateCreateNodesV2ToCreateNodes(tree) {
+    let touchedCount = 0;
+    (0, devkit_1.visitNotIgnoredFiles)(tree, '.', (filePath) => {
+        if (!TS_EXTENSIONS.some((ext) => filePath.endsWith(ext))) {
+            return;
+        }
+        const original = tree.read(filePath, 'utf-8');
+        if (!original || !original.includes(DEPRECATED_NAME)) {
+            return;
+        }
+        const updated = rewriteCreateNodesV2Imports(original, TARGET_SPECIFIERS);
+        if (updated !== original) {
+            tree.write(filePath, updated);
+            touchedCount += 1;
+        }
+    });
+    if (touchedCount > 0) {
+        devkit_1.logger.info(`Renamed \`${DEPRECATED_NAME}\` imports to \`${CANONICAL_NAME}\` in ${touchedCount} file(s).`);
+    }
+    await (0, devkit_1.formatFiles)(tree);
+}
+/**
+ * Rewrites named imports and re-exports of `createNodesV2` to `createNodes`
+ * when they come from one of the given module specifiers. Only the named
+ * bindings are touched — the module specifier, the `import`/`export` keyword,
+ * any `type` modifier, and any default import are left untouched.
+ */
+function rewriteCreateNodesV2Imports(source, specifiers) {
+    ts ??= (0, devkit_1.ensurePackage)('typescript', '*');
+    const sourceFile = ts.createSourceFile('tmp.ts', source, ts.ScriptTarget.Latest, 
+    /* setParentNodes */ true, ts.ScriptKind.TSX);
+    const changes = [];
+    let renameLocalUsages = false;
+    for (const stmt of sourceFile.statements) {
+        if (ts.isImportDeclaration(stmt)) {
+            renameLocalUsages =
+                collectImportRewrite(sourceFile, stmt, specifiers, changes) ||
+                    renameLocalUsages;
+        }
+        else if (ts.isExportDeclaration(stmt)) {
+            collectExportRewrite(sourceFile, stmt, specifiers, changes);
+        }
+    }
+    // Renaming a local `createNodesV2` import binding to `createNodes` (a lone
+    // `{ createNodesV2 }`, or one deduped against an existing `createNodes`)
+    // changes the name in scope, so value references to `createNodesV2` in the
+    // file body must be renamed too — otherwise they dangle. Aliased imports and
+    // re-exports keep their local name, so they never trigger this.
+    if (renameLocalUsages) {
+        collectValueUsageRewrites(sourceFile, changes);
+    }
+    return changes.length > 0 ? (0, devkit_1.applyChangesToString)(source, changes) : source;
+}
+function isTargetSpecifier(node, specifiers) {
+    return ts.isStringLiteral(node) && specifiers.has(node.text);
+}
+function collectImportRewrite(sourceFile, stmt, specifiers, changes) {
+    if (!isTargetSpecifier(stmt.moduleSpecifier, specifiers)) {
+        return false;
+    }
+    const namedBindings = stmt.importClause?.namedBindings;
+    // Only `import { ... }` carries renameable named bindings. `import x`,
+    // `import * as ns`, and side-effect imports reference the module wholesale
+    // and keep working through the `createNodesV2` runtime alias, so we leave
+    // them be. A mixed `import def, { createNodesV2 }` still has its named
+    // bindings rewritten below — the default binding is untouched.
+    if (!namedBindings || !ts.isNamedImports(namedBindings)) {
+        return false;
+    }
+    // The local `createNodesV2` binding only disappears when it is imported
+    // without an alias — a lone `{ createNodesV2 }` or one deduped against an
+    // existing `createNodes`. `{ createNodesV2 as x }` keeps the local `x`, so
+    // its in-file usages are unaffected and must not be rewritten.
+    const localBindingRenamed = namedBindings.elements.some((el) => el.name.text === DEPRECATED_NAME &&
+        (el.propertyName ?? el.name).text === DEPRECATED_NAME);
+    rewriteNamedBindings(sourceFile, namedBindings, changes);
+    return localBindingRenamed;
+}
+function collectExportRewrite(sourceFile, stmt, specifiers, changes) {
+    if (!stmt.moduleSpecifier ||
+        !isTargetSpecifier(stmt.moduleSpecifier, specifiers)) {
+        return;
+    }
+    // `export { ... } from '...'` can be rewritten; `export * from '...'` has no
+    // named bindings to rename.
+    if (!stmt.exportClause || !ts.isNamedExports(stmt.exportClause)) {
+        return;
+    }
+    rewriteNamedBindings(sourceFile, stmt.exportClause, changes);
+}
+/**
+ * Re-renders the `{ ... }` of a named import/export, renaming any
+ * `createNodesV2` specifier to `createNodes`. If renaming would collide with a
+ * `createNodes` that is already present (e.g. `{ createNodes, createNodesV2 }`),
+ * the duplicate is dropped. Returns without recording a change when the binding
+ * list contains no `createNodesV2`.
+ */
+function rewriteNamedBindings(sourceFile, namedBindings, changes) {
+    const elements = namedBindings.elements;
+    const hasDeprecated = elements.some((el) => (el.propertyName ?? el.name).text === DEPRECATED_NAME);
+    if (!hasDeprecated) {
+        return;
+    }
+    const seen = new Set();
+    const rendered = [];
+    for (const el of elements) {
+        const text = renderSpecifier(el);
+        if (!seen.has(text)) {
+            seen.add(text);
+            rendered.push(text);
+        }
+    }
+    const start = namedBindings.getStart(sourceFile);
+    changes.push({
+        type: devkit_1.ChangeType.Delete,
+        start,
+        length: namedBindings.getEnd() - start,
+    }, {
+        type: devkit_1.ChangeType.Insert,
+        index: start,
+        text: `{ ${rendered.join(', ')} }`,
+    });
+}
+function renderSpecifier(el) {
+    const typePrefix = el.isTypeOnly ? 'type ' : '';
+    const rename = (name) => name === DEPRECATED_NAME ? CANONICAL_NAME : name;
+    // `{ name }` — no alias, so the local binding follows the rename.
+    if (!el.propertyName) {
+        return `${typePrefix}${rename(el.name.text)}`;
+    }
+    // `{ propertyName as name }` — only the imported (left) side is renamed; the
+    // local alias is preserved. A now-redundant alias such as
+    // `createNodesV2 as createNodes` collapses to `createNodes`.
+    const canonicalImported = rename(el.propertyName.text);
+    const localName = el.name.text;
+    return canonicalImported === localName
+        ? `${typePrefix}${localName}`
+        : `${typePrefix}${canonicalImported} as ${localName}`;
+}
+/**
+ * Renames value references of `createNodesV2` to `createNodes` in the file
+ * body. Only called once a local `createNodesV2` import binding has actually
+ * been renamed, so these references would otherwise dangle. Occurrences that
+ * are not references to that binding are skipped: the import/export
+ * declarations themselves, property accesses (`x.createNodesV2`), qualified
+ * type names, object-literal keys, and declaration names that shadow the
+ * import. A shorthand property (`{ createNodesV2 }`) is expanded to
+ * `{ createNodesV2: createNodes }` so the property key is preserved. Strings
+ * and comments are never `Identifier` nodes, so they are left alone.
+ */
+function collectValueUsageRewrites(sourceFile, changes) {
+    const visit = (node) => {
+        if (ts.isIdentifier(node) &&
+            node.text === DEPRECATED_NAME &&
+            isRenamableValueUsage(node)) {
+            const start = node.getStart(sourceFile);
+            changes.push({
+                type: devkit_1.ChangeType.Delete,
+                start,
+                length: node.getEnd() - start,
+            }, {
+                type: devkit_1.ChangeType.Insert,
+                index: start,
+                text: ts.isShorthandPropertyAssignment(node.parent)
+                    ? `${DEPRECATED_NAME}: ${CANONICAL_NAME}`
+                    : CANONICAL_NAME,
+            });
+        }
+        node.forEachChild(visit);
+    };
+    sourceFile.forEachChild(visit);
+}
+/**
+ * Whether a `createNodesV2` identifier is a value reference to the renamed
+ * import binding, as opposed to a position that must be left untouched.
+ */
+function isRenamableValueUsage(node) {
+    const parent = node.parent;
+    if (!parent) {
+        return false;
+    }
+    // Import/export bindings — already handled by the declaration rewrite.
+    if (ts.isImportSpecifier(parent) ||
+        ts.isExportSpecifier(parent) ||
+        ts.isImportClause(parent) ||
+        ts.isNamespaceImport(parent)) {
+        return false;
+    }
+    // `x.createNodesV2` / `X.createNodesV2` — a member name, not the binding.
+    if (ts.isPropertyAccessExpression(parent) && parent.name === node) {
+        return false;
+    }
+    if (ts.isQualifiedName(parent) && parent.right === node) {
+        return false;
+    }
+    // `{ createNodesV2: ... }` — an object-literal key, not the binding.
+    if (ts.isPropertyAssignment(parent) && parent.name === node) {
+        return false;
+    }
+    // A declaration whose name shadows the import (variable, param, etc.).
+    if ((ts.isVariableDeclaration(parent) ||
+        ts.isParameter(parent) ||
+        ts.isBindingElement(parent) ||
+        ts.isFunctionDeclaration(parent) ||
+        ts.isClassDeclaration(parent)) &&
+        parent.name === node) {
+        return false;
+    }
+    return true;
+}

package/dist/src/migrations/update-23-0-0/migrate-create-nodes-v2-to-create-nodes.md

@@ -0,0 +1,25 @@
+#### Rename `createNodesV2` imports to `createNodes`
+
+`@nx/rollup` renamed its primary inferred-plugin export from `createNodesV2` to `createNodes`. The `createNodesV2` name is preserved as a deprecated alias for now, but new code should use `createNodes`.
+
+This migration scans every `.ts`, `.tsx`, `.cts`, and `.mts` file in your workspace and rewrites named imports and re-exports of `createNodesV2` from `@nx/rollup/plugin` to `createNodes`.
+
+#### Sample Code Changes
+
+##### Before
+
+```ts
+import { createNodesV2 } from '@nx/rollup/plugin';
+```
+
+##### After
+
+```ts
+import { createNodes } from '@nx/rollup/plugin';
+```
+
+Aliases are preserved (`createNodesV2 as cn` becomes `createNodes as cn`), and if a file already imports both names (`{ createNodes, createNodesV2 }`) the redundant binding is dropped.
+
+#### What is not rewritten
+
+Only static `import`/`export` named bindings from `@nx/rollup/plugin` are rewritten. Namespace imports, dynamic `import(...)`, `require(...)` destructuring, and property access such as `plugin.createNodesV2` are left untouched — they keep working through the `createNodesV2` runtime alias. Update those by hand if you want to drop the deprecated name everywhere.

package/dist/src/migrations/update-23-0-0/remove-use-legacy-typescript-plugin.d.ts

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