@nx/rollup 23.0.0-beta.23 → 23.0.0-beta.24

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/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,8 +2,6 @@
 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");
@@ -14,6 +12,8 @@ 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);

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

@@ -10,9 +10,11 @@ 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' &&

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

@@ -5,7 +5,9 @@ const internal_1 = require("@nx/devkit/internal");
 const devkit_1 = require("@nx/devkit");
 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 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, internal_1.forEachExecutorOptions)(tree, '@nx/rollup:rollup', (_, projectName, targetName, configurationName) => {

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

@@ -6,18 +6,20 @@ const devkit_1 = require("@nx/devkit");
 const versions_1 = require("../../utils/versions");
 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, internal_1.addPlugin)(tree, await (0, devkit_1.createProjectGraphAsync)(), '@nx/rollup/plugin', plugin_1.createNodesV2, {

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,134 @@
+"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 = [];
+    for (const stmt of sourceFile.statements) {
+        if (ts.isImportDeclaration(stmt)) {
+            collectImportRewrite(sourceFile, stmt, specifiers, changes);
+        }
+        else if (ts.isExportDeclaration(stmt)) {
+            collectExportRewrite(sourceFile, stmt, specifiers, 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;
+    }
+    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;
+    }
+    rewriteNamedBindings(sourceFile, namedBindings, changes);
+}
+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}`;
+}

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/{src → dist/src}/migrations/update-23-0-0/remove-use-legacy-typescript-plugin.d.ts

@@ -1,3 +1,2 @@
 import { Tree } from '@nx/devkit';
 export default function (tree: Tree): Promise<void>;
-//# sourceMappingURL=remove-use-legacy-typescript-plugin.d.ts.map

package/dist/src/migrations/update-23-0-0/rewrite-internal-subpath-imports.d.ts

@@ -0,0 +1,3 @@
+import { type Tree } from '@nx/devkit';
+export default function rewriteInternalSubpathImports(tree: Tree): Promise<void>;
+export declare function rewriteSubpathImports(source: string): string;

package/dist/src/migrations/update-23-0-0/rewrite-internal-subpath-imports.js

@@ -0,0 +1,202 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = rewriteInternalSubpathImports;
+exports.rewriteSubpathImports = rewriteSubpathImports;
+const devkit_1 = require("@nx/devkit");
+const TS_EXTENSIONS = ['.ts', '.tsx', '.cts', '.mts'];
+const FROM_PREFIX = '@nx/rollup/src/';
+const TO_PUBLIC = '@nx/rollup';
+const TO_INTERNAL = '@nx/rollup/internal';
+// Symbols exported from `@nx/rollup`'s public entry (packages/rollup/index.ts).
+// A named import/export of one of these from `@nx/rollup/src/*` is routed to
+// the public `@nx/rollup` entry; everything else goes to `@nx/rollup/internal`.
+const PUBLIC_SYMBOLS = new Set([
+    'AssetGlobPattern',
+    'Globals',
+    'RollupExecutorOptions',
+    'configurationGenerator',
+    'createRollupOptions',
+    'rollupExecutor',
+    'rollupInitGenerator',
+    'rollupProjectGenerator',
+]);
+// Methods on `jest` and `vi` that take a module specifier as their first arg.
+const MOCK_HELPER_METHODS = new Set([
+    'mock',
+    'unmock',
+    'doMock',
+    'dontMock',
+    'requireActual',
+    'requireMock',
+    'importActual',
+    'importMock',
+]);
+let ts;
+async function rewriteInternalSubpathImports(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(FROM_PREFIX)) {
+            return;
+        }
+        const updated = rewriteSubpathImports(original);
+        if (updated !== original) {
+            tree.write(filePath, updated);
+            touchedCount += 1;
+        }
+    });
+    if (touchedCount > 0) {
+        devkit_1.logger.info(`Rewrote @nx/rollup/src/* imports in ${touchedCount} file(s) ` +
+            `(public symbols to @nx/rollup, internals to @nx/rollup/internal).`);
+    }
+    await (0, devkit_1.formatFiles)(tree);
+}
+function rewriteSubpathImports(source) {
+    ts ??= (0, devkit_1.ensurePackage)('typescript', '*');
+    const sourceFile = ts.createSourceFile('tmp.ts', source, ts.ScriptTarget.Latest, 
+    /* setParentNodes */ true, ts.ScriptKind.TSX);
+    const changes = [];
+    for (const stmt of sourceFile.statements) {
+        if (ts.isImportDeclaration(stmt)) {
+            collectImportRewrite(sourceFile, stmt, changes);
+        }
+        else if (ts.isExportDeclaration(stmt)) {
+            collectExportRewrite(sourceFile, stmt, changes);
+        }
+    }
+    collectCallExpressionRewrites(sourceFile, changes);
+    return changes.length > 0 ? (0, devkit_1.applyChangesToString)(source, changes) : source;
+}
+function isSubpathSpecifier(node) {
+    return ts.isStringLiteral(node) && node.text.startsWith(FROM_PREFIX);
+}
+function collectImportRewrite(sourceFile, stmt, changes) {
+    if (!isSubpathSpecifier(stmt.moduleSpecifier)) {
+        return;
+    }
+    const clause = stmt.importClause;
+    // Pure named imports (`import { a, b } from '...'`) can be split by symbol.
+    // A default or namespace import grabs the whole module, so it can't be
+    // split — route it wholesale to the internal entry.
+    if (clause &&
+        !clause.name &&
+        clause.namedBindings &&
+        ts.isNamedImports(clause.namedBindings)) {
+        rewriteNamedDeclaration(sourceFile, stmt, stmt.moduleSpecifier, clause.isTypeOnly, clause.namedBindings.elements, 'import', changes);
+        return;
+    }
+    replaceSpecifier(sourceFile, stmt.moduleSpecifier, TO_INTERNAL, changes);
+}
+function collectExportRewrite(sourceFile, stmt, changes) {
+    if (!stmt.moduleSpecifier || !isSubpathSpecifier(stmt.moduleSpecifier)) {
+        return;
+    }
+    // `export { a, b } from '...'` can be split; `export * from '...'` cannot.
+    if (stmt.exportClause && ts.isNamedExports(stmt.exportClause)) {
+        rewriteNamedDeclaration(sourceFile, stmt, stmt.moduleSpecifier, stmt.isTypeOnly, stmt.exportClause.elements, 'export', changes);
+        return;
+    }
+    replaceSpecifier(sourceFile, stmt.moduleSpecifier, TO_INTERNAL, changes);
+}
+/**
+ * Partition the named bindings of an import/export declaration into the ones
+ * that resolve to `@nx/rollup`'s public entry and the ones that don't. If both
+ * groups are non-empty, the single declaration is split into two.
+ */
+function rewriteNamedDeclaration(sourceFile, decl, specifier, isTypeOnly, elements, keyword, changes) {
+    const publicEls = [];
+    const internalEls = [];
+    for (const el of elements) {
+        // `propertyName` is the original name in `orig as alias`; fall back to
+        // `name` for the plain `orig` form.
+        const importedName = (el.propertyName ?? el.name).text;
+        (PUBLIC_SYMBOLS.has(importedName) ? publicEls : internalEls).push(el);
+    }
+    if (publicEls.length === 0) {
+        replaceSpecifier(sourceFile, specifier, TO_INTERNAL, changes);
+        return;
+    }
+    if (internalEls.length === 0) {
+        replaceSpecifier(sourceFile, specifier, TO_PUBLIC, changes);
+        return;
+    }
+    // Mixed — replace the whole declaration with one statement per target.
+    const quote = sourceFile.text.charAt(specifier.getStart(sourceFile));
+    const start = decl.getStart(sourceFile);
+    const end = decl.getEnd();
+    const semicolon = sourceFile.text.charAt(end - 1) === ';' ? ';' : '';
+    const prefix = isTypeOnly ? `${keyword} type` : keyword;
+    const render = (els, target) => `${prefix} { ${els
+        .map((el) => el.getText(sourceFile))
+        .join(', ')} } from ${quote}${target}${quote}${semicolon}`;
+    changes.push({ type: devkit_1.ChangeType.Delete, start, length: end - start }, {
+        type: devkit_1.ChangeType.Insert,
+        index: start,
+        text: `${render(publicEls, TO_PUBLIC)}\n${render(internalEls, TO_INTERNAL)}`,
+    });
+}
+function collectCallExpressionRewrites(sourceFile, changes) {
+    const visit = (node) => {
+        if (ts.isCallExpression(node) &&
+            shouldRewriteCallExpression(node) &&
+            node.arguments.length >= 1 &&
+            isSubpathSpecifier(node.arguments[0])) {
+            // `require(...)`, dynamic `import(...)` and `jest.mock(...)` reference
+            // the module as a whole and can't be symbol-split, so they go to the
+            // internal entry.
+            replaceSpecifier(sourceFile, node.arguments[0], TO_INTERNAL, changes);
+        }
+        else if (ts.isImportTypeNode(node)) {
+            // `typeof import('...')` parses as an `ImportTypeNode`, not a
+            // CallExpression — its argument is `LiteralTypeNode<StringLiteral>`.
+            // The whole module is referenced, so it can't be symbol-split.
+            const literal = getImportTypeStringLiteral(node);
+            if (literal && literal.text.startsWith(FROM_PREFIX)) {
+                replaceSpecifier(sourceFile, literal, TO_INTERNAL, changes);
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+}
+function getImportTypeStringLiteral(node) {
+    const arg = node.argument;
+    if (arg && ts.isLiteralTypeNode(arg) && ts.isStringLiteral(arg.literal)) {
+        return arg.literal;
+    }
+    return undefined;
+}
+function shouldRewriteCallExpression(call) {
+    const callee = call.expression;
+    // `require('...')`
+    if (ts.isIdentifier(callee) && callee.text === 'require')
+        return true;
+    // dynamic `import('...')` (runtime form parses as a CallExpression whose
+    // callee is the `import` keyword). The `typeof import('...')` type-position
+    // form is an `ImportTypeNode` (handled in `collectCallExpressionRewrites`).
+    if (callee.kind === ts.SyntaxKind.ImportKeyword)
+        return true;
+    // `jest.mock(...)` / `vi.mock(...)` and friends.
+    if (ts.isPropertyAccessExpression(callee)) {
+        const obj = callee.expression;
+        if (ts.isIdentifier(obj) &&
+            (obj.text === 'jest' || obj.text === 'vi') &&
+            MOCK_HELPER_METHODS.has(callee.name.text)) {
+            return true;
+        }
+    }
+    return false;
+}
+function replaceSpecifier(sourceFile, literal, target, changes) {
+    const start = literal.getStart(sourceFile);
+    const end = literal.getEnd();
+    const quote = sourceFile.text.charAt(start);
+    changes.push({ type: devkit_1.ChangeType.Delete, start, length: end - start }, {
+        type: devkit_1.ChangeType.Insert,
+        index: start,
+        text: `${quote}${target}${quote}`,
+    });
+}

package/{src → dist/src}/plugins/analyze.d.ts

@@ -2,4 +2,3 @@ export declare function analyze(): {
     name: string;
     renderChunk(source: any, chunk: any): void;
 };
-//# sourceMappingURL=analyze.d.ts.map

package/{src → dist/src}/plugins/delete-output.d.ts

@@ -3,4 +3,3 @@ export interface DeleteOutputOptions {
     dirs: string[];
 }
 export declare function deleteOutput(options: DeleteOutputOptions): Plugin;
-//# sourceMappingURL=delete-output.d.ts.map

package/{src → dist/src}/plugins/nx-copy-assets.plugin.d.ts

@@ -21,4 +21,3 @@ export declare function extractGlobLiteralPrefix(glob: string): {
     glob: string;
 };
 export declare function nxCopyAssetsPlugin(options: NxCopyAssetsPluginOptions): Plugin;
-//# sourceMappingURL=nx-copy-assets.plugin.d.ts.map

package/{src → dist/src}/plugins/package-json/generate-package-json.d.ts

@@ -11,4 +11,3 @@ export interface GeneratePackageJsonOptions {
 }
 export declare const pluginName = "rollup-plugin-nx-generate-package-json";
 export declare function generatePackageJson(options: GeneratePackageJsonOptions, packageJson: PackageJson): Plugin;
-//# sourceMappingURL=generate-package-json.d.ts.map

package/{src → dist/src}/plugins/package-json/update-package-json.d.ts

@@ -8,4 +8,3 @@ export declare function updatePackageJson(options: {
     outputFileName?: string;
     additionalEntryPoints?: string[];
 }, packageJson: PackageJson): void;
-//# sourceMappingURL=update-package-json.d.ts.map

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

@@ -10,4 +10,3 @@ export interface RollupPluginOptions {
 }
 export declare const createNodes: CreateNodes<RollupPluginOptions>;
 export declare const createNodesV2: CreateNodes<RollupPluginOptions>;
-//# sourceMappingURL=plugin.d.ts.map

package/{src → dist/src}/plugins/postcss/index.d.ts

@@ -13,4 +13,3 @@
 export { postcss } from './postcss-plugin';
 export { postcss as default } from './postcss-plugin';
 export type { PostCSSPluginOptions, PostCSSModulesOptions, FilterPattern, UseOptions, LessOptions, SassOptions, StylusOptions, } from './options';
-//# sourceMappingURL=index.d.ts.map

package/{src → dist/src}/plugins/postcss/loaders/index.d.ts

@@ -35,4 +35,3 @@ export declare class Loaders {
      */
     process(code: string, context: LoaderContext): Promise<LoaderResult>;
 }
-//# sourceMappingURL=index.d.ts.map

package/{src → dist/src}/plugins/postcss/loaders/less-loader.d.ts

@@ -4,4 +4,3 @@ import type { Loader, LessLoaderOptions } from './types';
  * Compiles .less files to CSS
  */
 export declare function createLessLoader(options?: LessLoaderOptions): Loader;
-//# sourceMappingURL=less-loader.d.ts.map

package/{src → dist/src}/plugins/postcss/loaders/postcss-loader.d.ts

@@ -4,4 +4,3 @@ import type { Loader, PostCSSLoaderOptions } from './types';
  * This loader always runs last in the chain
  */
 export declare function createPostCSSLoader(options: PostCSSLoaderOptions): Loader;
-//# sourceMappingURL=postcss-loader.d.ts.map

package/{src → dist/src}/plugins/postcss/loaders/sass-loader.d.ts

@@ -4,4 +4,3 @@ import type { Loader, SassLoaderOptions } from './types';
  * Compiles .sass and .scss files to CSS
  */
 export declare function createSassLoader(options?: SassLoaderOptions): Loader;
-//# sourceMappingURL=sass-loader.d.ts.map

package/{src → dist/src}/plugins/postcss/loaders/stylus-loader.d.ts

@@ -4,4 +4,3 @@ import type { Loader, StylusLoaderOptions } from './types';
  * Compiles .styl and .stylus files to CSS
  */
 export declare function createStylusLoader(options?: StylusLoaderOptions): Loader;
-//# sourceMappingURL=stylus-loader.d.ts.map

package/{src → dist/src}/plugins/postcss/loaders/types.d.ts

@@ -85,4 +85,3 @@ export interface StylusLoaderOptions {
     /** Additional Stylus options */
     [key: string]: unknown;
 }
-//# sourceMappingURL=types.d.ts.map

package/{src → dist/src}/plugins/postcss/options.d.ts

@@ -108,4 +108,3 @@ export interface NormalizedPostCSSOptions extends PostCSSPluginOptions {
  * Normalize plugin options with defaults
  */
 export declare function normalizeOptions(options?: PostCSSPluginOptions): NormalizedPostCSSOptions;
-//# sourceMappingURL=options.d.ts.map

package/{src → dist/src}/plugins/postcss/postcss-plugin.d.ts

@@ -7,4 +7,3 @@ import type { PostCSSPluginOptions } from './options';
  * Supports CSS injection into the DOM or extraction to separate files.
  */
 export declare function postcss(pluginOptions?: PostCSSPluginOptions): Plugin;
-//# sourceMappingURL=postcss-plugin.d.ts.map

package/{src → dist/src}/plugins/postcss/utils/index.d.ts

@@ -2,4 +2,3 @@ export { normalizePath, humanizePath } from './normalize-path';
 export { loadModule, requireModule } from './load-module';
 export { safeIdentifier, escapeClassNameDashes } from './safe-identifier';
 export { styleInjectCode, STYLE_INJECT_ID, STYLE_INJECT_PATH, } from './style-inject';
-//# sourceMappingURL=index.d.ts.map