@nx/devkit 23.0.0-beta.5 → 23.0.0-beta.7

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

@@ -12,4 +12,3 @@
  */
 export * from 'nx/src/devkit-exports';
 export * from './public-api';
-//# sourceMappingURL=index.d.ts.map

package/dist/internal.d.ts

@@ -0,0 +1,21 @@
+export { signalToCode, createProjectRootMappingsFromProjectConfigurations, PluginCache, safeWriteFileCache, } from 'nx/src/devkit-internals';
+export { determineArtifactNameAndDirectoryOptions, getRelativeCwd, type FileExtensionType, } from './src/generators/artifact-name-and-directory-utils';
+export { getE2EWebServerInfo, type E2EWebServerDetails, } from './src/generators/e2e-web-server-info-utils';
+export { forEachExecutorOptions } from './src/generators/executor-options-utils';
+export { AggregatedLog } from './src/generators/plugin-migrations/aggregate-log-util';
+export { migrateProjectExecutorsToPlugin, migrateProjectExecutorsToPluginV1, NoTargetsToMigrateError, type InferredTargetConfiguration, } from './src/generators/plugin-migrations/executor-to-plugin-migrator';
+export { processTargetOutputs, deleteMatchingProperties, toProjectRelativePath, } from './src/generators/plugin-migrations/plugin-migration-utils';
+export { determineProjectNameAndRootOptions, ensureRootProjectName, resolveImportPath, } from './src/generators/project-name-and-root-utils';
+export { promptWhenInteractive } from './src/generators/prompt';
+export { addBuildTargetDefaults, addE2eCiTargetDefaults, } from './src/generators/target-defaults-utils';
+export { addPlugin } from './src/utils/add-plugin';
+export { createAsyncIterable, combineAsyncIterables, mapAsyncIterable, } from './src/utils/async-iterable';
+export { calculateHashForCreateNodes, calculateHashesForCreateNodes, } from './src/utils/calculate-hash-for-create-nodes';
+export { getCatalogManager } from './src/utils/catalog';
+export { loadConfigFile, clearRequireCache } from './src/utils/config-utils';
+export { findPluginForConfigFile } from './src/utils/find-plugin-for-config-file';
+export { getNamedInputs } from './src/utils/get-named-inputs';
+export { logShowProjectCommand } from './src/utils/log-show-project-command';
+export { eachValueFrom } from './src/utils/rxjs-for-await';
+export { checkAndCleanWithSemver } from './src/utils/semver';
+export { camelize, capitalize, classify, dasherize, } from './src/utils/string-utils';

package/dist/internal.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dasherize = exports.classify = exports.capitalize = exports.camelize = exports.checkAndCleanWithSemver = exports.eachValueFrom = exports.logShowProjectCommand = exports.getNamedInputs = exports.findPluginForConfigFile = exports.clearRequireCache = exports.loadConfigFile = exports.getCatalogManager = exports.calculateHashesForCreateNodes = exports.calculateHashForCreateNodes = exports.mapAsyncIterable = exports.combineAsyncIterables = exports.createAsyncIterable = exports.addPlugin = exports.addE2eCiTargetDefaults = exports.addBuildTargetDefaults = exports.promptWhenInteractive = exports.resolveImportPath = exports.ensureRootProjectName = exports.determineProjectNameAndRootOptions = exports.toProjectRelativePath = exports.deleteMatchingProperties = exports.processTargetOutputs = exports.NoTargetsToMigrateError = exports.migrateProjectExecutorsToPluginV1 = exports.migrateProjectExecutorsToPlugin = exports.AggregatedLog = exports.forEachExecutorOptions = exports.getE2EWebServerInfo = exports.getRelativeCwd = exports.determineArtifactNameAndDirectoryOptions = exports.safeWriteFileCache = exports.PluginCache = exports.createProjectRootMappingsFromProjectConfigurations = exports.signalToCode = void 0;
+var devkit_internals_1 = require("nx/src/devkit-internals");
+Object.defineProperty(exports, "signalToCode", { enumerable: true, get: function () { return devkit_internals_1.signalToCode; } });
+Object.defineProperty(exports, "createProjectRootMappingsFromProjectConfigurations", { enumerable: true, get: function () { return devkit_internals_1.createProjectRootMappingsFromProjectConfigurations; } });
+Object.defineProperty(exports, "PluginCache", { enumerable: true, get: function () { return devkit_internals_1.PluginCache; } });
+Object.defineProperty(exports, "safeWriteFileCache", { enumerable: true, get: function () { return devkit_internals_1.safeWriteFileCache; } });
+// Generators
+var artifact_name_and_directory_utils_1 = require("./src/generators/artifact-name-and-directory-utils");
+Object.defineProperty(exports, "determineArtifactNameAndDirectoryOptions", { enumerable: true, get: function () { return artifact_name_and_directory_utils_1.determineArtifactNameAndDirectoryOptions; } });
+Object.defineProperty(exports, "getRelativeCwd", { enumerable: true, get: function () { return artifact_name_and_directory_utils_1.getRelativeCwd; } });
+var e2e_web_server_info_utils_1 = require("./src/generators/e2e-web-server-info-utils");
+Object.defineProperty(exports, "getE2EWebServerInfo", { enumerable: true, get: function () { return e2e_web_server_info_utils_1.getE2EWebServerInfo; } });
+var executor_options_utils_1 = require("./src/generators/executor-options-utils");
+Object.defineProperty(exports, "forEachExecutorOptions", { enumerable: true, get: function () { return executor_options_utils_1.forEachExecutorOptions; } });
+var aggregate_log_util_1 = require("./src/generators/plugin-migrations/aggregate-log-util");
+Object.defineProperty(exports, "AggregatedLog", { enumerable: true, get: function () { return aggregate_log_util_1.AggregatedLog; } });
+var executor_to_plugin_migrator_1 = require("./src/generators/plugin-migrations/executor-to-plugin-migrator");
+Object.defineProperty(exports, "migrateProjectExecutorsToPlugin", { enumerable: true, get: function () { return executor_to_plugin_migrator_1.migrateProjectExecutorsToPlugin; } });
+Object.defineProperty(exports, "migrateProjectExecutorsToPluginV1", { enumerable: true, get: function () { return executor_to_plugin_migrator_1.migrateProjectExecutorsToPluginV1; } });
+Object.defineProperty(exports, "NoTargetsToMigrateError", { enumerable: true, get: function () { return executor_to_plugin_migrator_1.NoTargetsToMigrateError; } });
+var plugin_migration_utils_1 = require("./src/generators/plugin-migrations/plugin-migration-utils");
+Object.defineProperty(exports, "processTargetOutputs", { enumerable: true, get: function () { return plugin_migration_utils_1.processTargetOutputs; } });
+Object.defineProperty(exports, "deleteMatchingProperties", { enumerable: true, get: function () { return plugin_migration_utils_1.deleteMatchingProperties; } });
+Object.defineProperty(exports, "toProjectRelativePath", { enumerable: true, get: function () { return plugin_migration_utils_1.toProjectRelativePath; } });
+var project_name_and_root_utils_1 = require("./src/generators/project-name-and-root-utils");
+Object.defineProperty(exports, "determineProjectNameAndRootOptions", { enumerable: true, get: function () { return project_name_and_root_utils_1.determineProjectNameAndRootOptions; } });
+Object.defineProperty(exports, "ensureRootProjectName", { enumerable: true, get: function () { return project_name_and_root_utils_1.ensureRootProjectName; } });
+Object.defineProperty(exports, "resolveImportPath", { enumerable: true, get: function () { return project_name_and_root_utils_1.resolveImportPath; } });
+var prompt_1 = require("./src/generators/prompt");
+Object.defineProperty(exports, "promptWhenInteractive", { enumerable: true, get: function () { return prompt_1.promptWhenInteractive; } });
+var target_defaults_utils_1 = require("./src/generators/target-defaults-utils");
+Object.defineProperty(exports, "addBuildTargetDefaults", { enumerable: true, get: function () { return target_defaults_utils_1.addBuildTargetDefaults; } });
+Object.defineProperty(exports, "addE2eCiTargetDefaults", { enumerable: true, get: function () { return target_defaults_utils_1.addE2eCiTargetDefaults; } });
+// Utils
+var add_plugin_1 = require("./src/utils/add-plugin");
+Object.defineProperty(exports, "addPlugin", { enumerable: true, get: function () { return add_plugin_1.addPlugin; } });
+var async_iterable_1 = require("./src/utils/async-iterable");
+Object.defineProperty(exports, "createAsyncIterable", { enumerable: true, get: function () { return async_iterable_1.createAsyncIterable; } });
+Object.defineProperty(exports, "combineAsyncIterables", { enumerable: true, get: function () { return async_iterable_1.combineAsyncIterables; } });
+Object.defineProperty(exports, "mapAsyncIterable", { enumerable: true, get: function () { return async_iterable_1.mapAsyncIterable; } });
+var calculate_hash_for_create_nodes_1 = require("./src/utils/calculate-hash-for-create-nodes");
+Object.defineProperty(exports, "calculateHashForCreateNodes", { enumerable: true, get: function () { return calculate_hash_for_create_nodes_1.calculateHashForCreateNodes; } });
+Object.defineProperty(exports, "calculateHashesForCreateNodes", { enumerable: true, get: function () { return calculate_hash_for_create_nodes_1.calculateHashesForCreateNodes; } });
+var catalog_1 = require("./src/utils/catalog");
+Object.defineProperty(exports, "getCatalogManager", { enumerable: true, get: function () { return catalog_1.getCatalogManager; } });
+var config_utils_1 = require("./src/utils/config-utils");
+Object.defineProperty(exports, "loadConfigFile", { enumerable: true, get: function () { return config_utils_1.loadConfigFile; } });
+Object.defineProperty(exports, "clearRequireCache", { enumerable: true, get: function () { return config_utils_1.clearRequireCache; } });
+var find_plugin_for_config_file_1 = require("./src/utils/find-plugin-for-config-file");
+Object.defineProperty(exports, "findPluginForConfigFile", { enumerable: true, get: function () { return find_plugin_for_config_file_1.findPluginForConfigFile; } });
+var get_named_inputs_1 = require("./src/utils/get-named-inputs");
+Object.defineProperty(exports, "getNamedInputs", { enumerable: true, get: function () { return get_named_inputs_1.getNamedInputs; } });
+var log_show_project_command_1 = require("./src/utils/log-show-project-command");
+Object.defineProperty(exports, "logShowProjectCommand", { enumerable: true, get: function () { return log_show_project_command_1.logShowProjectCommand; } });
+var rxjs_for_await_1 = require("./src/utils/rxjs-for-await");
+Object.defineProperty(exports, "eachValueFrom", { enumerable: true, get: function () { return rxjs_for_await_1.eachValueFrom; } });
+var semver_1 = require("./src/utils/semver");
+Object.defineProperty(exports, "checkAndCleanWithSemver", { enumerable: true, get: function () { return semver_1.checkAndCleanWithSemver; } });
+var string_utils_1 = require("./src/utils/string-utils");
+Object.defineProperty(exports, "camelize", { enumerable: true, get: function () { return string_utils_1.camelize; } });
+Object.defineProperty(exports, "capitalize", { enumerable: true, get: function () { return string_utils_1.capitalize; } });
+Object.defineProperty(exports, "classify", { enumerable: true, get: function () { return string_utils_1.classify; } });
+Object.defineProperty(exports, "dasherize", { enumerable: true, get: function () { return string_utils_1.dasherize; } });

package/{ngcli-adapter.d.ts → dist/ngcli-adapter.d.ts}

@@ -2,4 +2,3 @@
  * @category Ng CLI Adapter
  */
 export { wrapAngularDevkitSchematic, mockSchematicsForTesting, NxScopedHost, } from 'nx/src/adapter/ngcli-adapter';
-//# sourceMappingURL=ngcli-adapter.d.ts.map

package/{public-api.d.ts → dist/public-api.d.ts}

@@ -76,4 +76,3 @@ export { convertNxExecutor } from './src/utils/convert-nx-executor';
  * @category Utils
  */
 export { moveFilesToNewDirectory } from './src/utils/move-dir';
-//# sourceMappingURL=public-api.d.ts.map

package/{src → dist/src}/executors/parse-target-string.d.ts

@@ -36,4 +36,3 @@ export declare function parseTargetString(targetString: string, ctx: ExecutorCon
  * ```
  */
 export declare function targetToTargetString({ project, target, configuration, }: Target): string;
-//# sourceMappingURL=parse-target-string.d.ts.map

package/{src → dist/src}/executors/read-target-options.d.ts

@@ -5,4 +5,3 @@ import type { ExecutorContext, Target } from 'nx/src/devkit-exports';
  * Works as if you invoked the target yourself without passing any command lint overrides.
  */
 export declare function readTargetOptions<T = any>({ project, target, configuration }: Target, context: ExecutorContext): T;
-//# sourceMappingURL=read-target-options.d.ts.map

package/{src → dist/src}/generators/artifact-name-and-directory-utils.d.ts

@@ -52,4 +52,3 @@ export declare function getRelativeCwd(): string;
  * Function for setting cwd during testing
  */
 export declare function setCwd(path: string): void;
-//# sourceMappingURL=artifact-name-and-directory-utils.d.ts.map

package/{src → dist/src}/generators/e2e-web-server-info-utils.d.ts

@@ -21,4 +21,3 @@ export interface E2EWebServerDetails {
 }
 export declare function getE2EWebServerInfo(tree: Tree, projectName: string, pluginOptions: E2EWebServerPluginOptions, defaultValues: E2EWebServerDefaultValues, isPluginBeingAdded: boolean): Promise<E2EWebServerDetails>;
 export {};
-//# sourceMappingURL=e2e-web-server-info-utils.d.ts.map

package/{src → dist/src}/generators/executor-options-utils.d.ts

@@ -18,4 +18,3 @@ callback: CallBack<Options>): void;
  **/
 export declare function forEachExecutorOptionsInGraph<Options>(graph: ProjectGraph, executorName: string, callback: CallBack<Options>): void;
 export {};
-//# sourceMappingURL=executor-options-utils.d.ts.map

package/{src → dist/src}/generators/format-files.d.ts

@@ -16,4 +16,3 @@ import { Tree } from 'nx/src/devkit-exports';
 export declare function formatFiles(tree: Tree, options?: {
     sortRootTsconfigPaths?: boolean;
 }): Promise<void>;
-//# sourceMappingURL=format-files.d.ts.map

package/{src → dist/src}/generators/format-files.js

@@ -32,7 +32,7 @@ async function formatFiles(tree, options = {}) {
     }
     let prettier;
     try {
-        prettier = await Promise.resolve().then(() => tslib_1.__importStar(require('prettier')));
+        prettier = await import('prettier');
         /**
          * Even after we discovered prettier in node_modules, we need to be sure that the user is intentionally using prettier
          * before proceeding to format with it.

package/{src → dist/src}/generators/generate-files.d.ts

@@ -42,4 +42,3 @@ export interface GenerateFilesOptions {
 export declare function generateFiles(tree: Tree, srcFolder: string, target: string, substitutions: {
     [k: string]: any;
 }, options?: GenerateFilesOptions): void;
-//# sourceMappingURL=generate-files.d.ts.map

package/{src → dist/src}/generators/plugin-migrations/aggregate-log-util.d.ts

@@ -25,4 +25,3 @@ export declare class AggregatedLog {
     flushLogs(): void;
 }
 export {};
-//# sourceMappingURL=aggregate-log-util.d.ts.map

package/{src → dist/src}/generators/plugin-migrations/executor-to-plugin-migrator.d.ts

@@ -28,4 +28,3 @@ export declare function migrateProjectExecutorsToPluginV1<T>(tree: Tree, project
     skipTargetFilter?: SkipTargetFilter;
 }>, specificProjectToMigrate?: string): Promise<Map<string, Record<string, string>>>;
 export {};
-//# sourceMappingURL=executor-to-plugin-migrator.d.ts.map

package/{src → dist/src}/generators/plugin-migrations/plugin-migration-utils.d.ts

@@ -61,4 +61,3 @@ export declare function processTargetOutputs(target: TargetConfiguration, rename
     projectRoot: string;
 }): void;
 export declare function toProjectRelativePath(path: string, projectRoot: string): string;
-//# sourceMappingURL=plugin-migration-utils.d.ts.map

package/{src → dist/src}/generators/project-name-and-root-utils.d.ts

@@ -39,4 +39,3 @@ export declare function ensureRootProjectName(options: {
     directory: string;
     name?: string;
 }, projectType: 'application' | 'library'): Promise<void>;
-//# sourceMappingURL=project-name-and-root-utils.d.ts.map

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

@@ -1,3 +1,2 @@
 import { prompt } from 'enquirer';
 export declare function promptWhenInteractive<T>(questions: Parameters<typeof prompt>[0], defaultValue: T): Promise<T>;
-//# sourceMappingURL=prompt.d.ts.map

package/{src → dist/src}/generators/run-tasks-in-serial.d.ts

@@ -5,4 +5,3 @@ import type { GeneratorCallback } from 'nx/src/devkit-exports';
  * @param tasks The tasks to run in serial.
  */
 export declare function runTasksInSerial(...tasks: GeneratorCallback[]): GeneratorCallback;
-//# sourceMappingURL=run-tasks-in-serial.d.ts.map

package/{src → dist/src}/generators/target-defaults-utils.d.ts

@@ -1,4 +1,3 @@
 import { type TargetConfiguration, type Tree } from 'nx/src/devkit-exports';
 export declare function addBuildTargetDefaults(tree: Tree, executorName: string, buildTargetName?: string, extraInputs?: TargetConfiguration['inputs']): void;
 export declare function addE2eCiTargetDefaults(tree: Tree, e2ePlugin: string, buildTarget: string, pathToE2EConfigFile: string): Promise<void>;
-//# sourceMappingURL=target-defaults-utils.d.ts.map

package/{src → dist/src}/generators/target-defaults-utils.js

@@ -1,37 +1,4 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.addBuildTargetDefaults = addBuildTargetDefaults;
 exports.addE2eCiTargetDefaults = addE2eCiTargetDefaults;
@@ -61,7 +28,7 @@ async function addE2eCiTargetDefaults(tree, e2ePlugin, buildTarget, pathToE2ECon
     if (!e2ePluginRegistrations.length) {
         return;
     }
-    const resolvedE2ePlugin = await Promise.resolve(`${e2ePlugin}`).then(s => __importStar(require(s)));
+    const resolvedE2ePlugin = await import(e2ePlugin);
     const e2ePluginGlob = resolvedE2ePlugin.createNodesV2?.[0] ?? resolvedE2ePlugin.createNodes?.[0];
     let foundPluginForApplication;
     for (let i = 0; i < e2ePluginRegistrations.length; i++) {

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

@@ -10,4 +10,3 @@ export type ToJSOptions = {
  * Rename and transpile any new typescript files created to javascript files
  */
 export declare function toJS(tree: Tree, options?: ToJSOptions): void;
-//# sourceMappingURL=to-js.d.ts.map

package/{src → dist/src}/generators/typescript/insert-import.d.ts

@@ -1,2 +1 @@
 export declare function insertImport(): void;
-//# sourceMappingURL=insert-import.d.ts.map

package/{src → dist/src}/generators/typescript/insert-statement.d.ts

@@ -1,2 +1 @@
 export declare function insertImport(): void;
-//# sourceMappingURL=insert-statement.d.ts.map

package/{src → dist/src}/generators/update-ts-configs-to-js.d.ts

@@ -2,4 +2,3 @@ import { Tree } from 'nx/src/devkit-exports';
 export declare function updateTsConfigsToJs(tree: Tree, options: {
     projectRoot: string;
 }): void;
-//# sourceMappingURL=update-ts-configs-to-js.d.ts.map

package/{src → dist/src}/generators/visit-not-ignored-files.d.ts

@@ -3,4 +3,3 @@ import type { Tree } from 'nx/src/devkit-exports';
  * Utility to act on all files in a tree that are not ignored by git.
  */
 export declare function visitNotIgnoredFiles(tree: Tree, dirPath: string, visitor: (path: string) => void): void;
-//# sourceMappingURL=visit-not-ignored-files.d.ts.map

package/dist/src/migrations/update-23-0-0/update-deep-imports.d.ts

@@ -0,0 +1,4 @@
+import { type Tree } from 'nx/src/devkit-exports';
+export declare const DEVKIT_INTERNAL_SYMBOLS: ReadonlySet<string>;
+export default function updateDevkitDeepImports(tree: Tree): Promise<void>;
+export declare function rewriteDevkitDeepImports(source: string): string;

package/dist/src/migrations/update-23-0-0/update-deep-imports.js

@@ -0,0 +1,321 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEVKIT_INTERNAL_SYMBOLS = void 0;
+exports.default = updateDevkitDeepImports;
+exports.rewriteDevkitDeepImports = rewriteDevkitDeepImports;
+const devkit_exports_1 = require("nx/src/devkit-exports");
+const format_files_1 = require("../../generators/format-files");
+const visit_not_ignored_files_1 = require("../../generators/visit-not-ignored-files");
+const package_json_1 = require("../../utils/package-json");
+const string_change_1 = require("../../utils/string-change");
+const versions_1 = require("../../utils/versions");
+const TS_EXTENSIONS = ['.ts', '.tsx', '.cts', '.mts'];
+const DEEP_IMPORT_PREFIX = '@nx/devkit/src/';
+const PUBLIC_SPECIFIER = '@nx/devkit';
+const INTERNAL_SPECIFIER = '@nx/devkit/internal';
+// Names re-exported from `@nx/devkit/internal` (see packages/devkit/internal.ts
+// at the time this migration was authored). Anything imported from a
+// `@nx/devkit/src/...` path whose name is NOT in this set is assumed to be
+// part of the stable public `@nx/devkit` API.
+exports.DEVKIT_INTERNAL_SYMBOLS = new Set([
+    'signalToCode',
+    'createProjectRootMappingsFromProjectConfigurations',
+    'PluginCache',
+    'safeWriteFileCache',
+    'determineArtifactNameAndDirectoryOptions',
+    'getRelativeCwd',
+    'FileExtensionType',
+    'getE2EWebServerInfo',
+    'E2EWebServerDetails',
+    'forEachExecutorOptions',
+    'AggregatedLog',
+    'migrateProjectExecutorsToPlugin',
+    'migrateProjectExecutorsToPluginV1',
+    'NoTargetsToMigrateError',
+    'InferredTargetConfiguration',
+    'processTargetOutputs',
+    'deleteMatchingProperties',
+    'toProjectRelativePath',
+    'determineProjectNameAndRootOptions',
+    'ensureRootProjectName',
+    'resolveImportPath',
+    'promptWhenInteractive',
+    'addBuildTargetDefaults',
+    'addE2eCiTargetDefaults',
+    'addPlugin',
+    'createAsyncIterable',
+    'combineAsyncIterables',
+    'mapAsyncIterable',
+    'calculateHashForCreateNodes',
+    'calculateHashesForCreateNodes',
+    'getCatalogManager',
+    'loadConfigFile',
+    'clearRequireCache',
+    'findPluginForConfigFile',
+    'getNamedInputs',
+    'logShowProjectCommand',
+    'eachValueFrom',
+    'checkAndCleanWithSemver',
+    'camelize',
+    'capitalize',
+    'classify',
+    'dasherize',
+]);
+// Methods on `jest` and `vi` that take a module specifier as their first
+// argument. Calls like `jest.mock('@nx/devkit/src/...')` are rewritten so the
+// mock target lines up with the rewritten import.
+const MOCK_HELPER_METHODS = new Set([
+    'mock',
+    'unmock',
+    'doMock',
+    'dontMock',
+    'requireActual',
+    'requireMock',
+    'importActual',
+    'importMock',
+]);
+let ts;
+async function updateDevkitDeepImports(tree) {
+    let touchedCount = 0;
+    (0, visit_not_ignored_files_1.visitNotIgnoredFiles)(tree, '.', (filePath) => {
+        if (!TS_EXTENSIONS.some((ext) => filePath.endsWith(ext))) {
+            return;
+        }
+        const original = tree.read(filePath, 'utf-8');
+        if (!original || !original.includes(DEEP_IMPORT_PREFIX)) {
+            return;
+        }
+        const updated = rewriteDevkitDeepImports(original);
+        if (updated !== original) {
+            tree.write(filePath, updated);
+            touchedCount += 1;
+        }
+    });
+    if (touchedCount > 0) {
+        devkit_exports_1.logger.info(`Rewrote @nx/devkit deep imports in ${touchedCount} file(s).`);
+    }
+    await (0, format_files_1.formatFiles)(tree);
+}
+function rewriteDevkitDeepImports(source) {
+    ts ??= (0, package_json_1.ensurePackage)('typescript', versions_1.typescriptVersion);
+    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))
+            continue;
+        if (!ts.isStringLiteral(stmt.moduleSpecifier))
+            continue;
+        if (!stmt.moduleSpecifier.text.startsWith(DEEP_IMPORT_PREFIX))
+            continue;
+        const replacement = buildReplacement(stmt, sourceFile);
+        changes.push({
+            type: string_change_1.ChangeType.Delete,
+            start: stmt.getStart(sourceFile),
+            length: stmt.getEnd() - stmt.getStart(sourceFile),
+        }, {
+            type: string_change_1.ChangeType.Insert,
+            index: stmt.getStart(sourceFile),
+            text: replacement,
+        });
+    }
+    // Pass 2: rewrite `require('@nx/devkit/src/...')`, dynamic
+    // `import('@nx/devkit/src/...')`, and `jest.mock(...)` / `vi.mock(...)`-style
+    // calls. We can't bucket these by symbol (no named binding to inspect), so
+    // we route them at `/internal` as a best guess. Walking the AST instead of
+    // string-replacing keeps us out of unrelated string literals — template
+    // strings, `typeof import('...')` type queries, comments, etc.
+    collectCallExpressionRewrites(sourceFile, changes);
+    let updated = changes.length > 0 ? (0, string_change_1.applyChangesToString)(source, changes) : source;
+    // Final pass: collapse any duplicate `@nx/devkit` and `@nx/devkit/internal`
+    // named-only imports into a single declaration. This handles both the
+    // imports we just emitted AND any that the user already had, so we never
+    // leave the file with two `from '@nx/devkit'` lines.
+    updated = collapseDevkitImports(updated);
+    return updated;
+}
+function collapseDevkitImports(source) {
+    const sourceFile = ts.createSourceFile('tmp.ts', source, ts.ScriptTarget.Latest, 
+    /* setParentNodes */ true, ts.ScriptKind.TSX);
+    const groups = new Map();
+    for (const stmt of sourceFile.statements) {
+        if (!ts.isImportDeclaration(stmt))
+            continue;
+        if (!ts.isStringLiteral(stmt.moduleSpecifier))
+            continue;
+        const specifier = stmt.moduleSpecifier.text;
+        if (specifier !== PUBLIC_SPECIFIER && specifier !== INTERNAL_SPECIFIER) {
+            continue;
+        }
+        const importClause = stmt.importClause;
+        if (!importClause)
+            continue; // skip side-effect imports
+        if (importClause.name)
+            continue; // skip default imports
+        const namedBindings = importClause.namedBindings;
+        if (!namedBindings || !ts.isNamedImports(namedBindings))
+            continue;
+        const typeOnly = !!importClause.isTypeOnly;
+        const key = `${specifier}\x00${typeOnly ? 'type' : 'value'}`;
+        if (!groups.has(key)) {
+            groups.set(key, { decls: [], specifier, typeOnly });
+        }
+        groups.get(key).decls.push(stmt);
+    }
+    const changes = [];
+    for (const { decls, specifier, typeOnly } of groups.values()) {
+        if (decls.length < 2)
+            continue;
+        const seen = new Set();
+        const merged = [];
+        for (const decl of decls) {
+            const named = decl.importClause.namedBindings;
+            for (const el of named.elements) {
+                const text = renderSpecifierFromNode(el, typeOnly);
+                if (!seen.has(text)) {
+                    seen.add(text);
+                    merged.push(text);
+                }
+            }
+        }
+        // Replace the first declaration with the merged one in place.
+        const first = decls[0];
+        changes.push({
+            type: string_change_1.ChangeType.Delete,
+            start: first.getStart(sourceFile),
+            length: first.getEnd() - first.getStart(sourceFile),
+        }, {
+            type: string_change_1.ChangeType.Insert,
+            index: first.getStart(sourceFile),
+            text: renderImport(merged, specifier, typeOnly),
+        });
+        // Delete every other declaration in this group (and consume one trailing
+        // newline so we don't leave behind a blank line that prettier has to clean
+        // up later).
+        for (let i = 1; i < decls.length; i++) {
+            const decl = decls[i];
+            const start = decl.getStart(sourceFile);
+            let end = decl.getEnd();
+            if (source[end] === '\n') {
+                end += 1;
+            }
+            else if (source[end] === '\r' && source[end + 1] === '\n') {
+                end += 2;
+            }
+            changes.push({
+                type: string_change_1.ChangeType.Delete,
+                start,
+                length: end - start,
+            });
+        }
+    }
+    return changes.length > 0 ? (0, string_change_1.applyChangesToString)(source, changes) : source;
+}
+function renderSpecifierFromNode(el, parentIsTypeOnly) {
+    const aliasText = el.propertyName ? ` as ${el.name.text}` : '';
+    const typePrefix = !parentIsTypeOnly && el.isTypeOnly ? 'type ' : '';
+    return `${typePrefix}${(el.propertyName ?? el.name).text}${aliasText}`;
+}
+function buildReplacement(decl, sourceFile) {
+    const importClause = decl.importClause;
+    // `import '@nx/devkit/src/...';` (side-effect) — no clause to bucket.
+    if (!importClause) {
+        return `import '${INTERNAL_SPECIFIER}';`;
+    }
+    const namedBindings = importClause.namedBindings;
+    const isNamedImport = namedBindings && ts.isNamedImports(namedBindings) && !importClause.name;
+    // Default / namespace / mixed-default-and-named — can't bucket reliably.
+    // Preserve the import shape, swap the specifier.
+    if (!isNamedImport) {
+        const before = source(decl, sourceFile).slice(0, decl.moduleSpecifier.getStart(sourceFile) - decl.getStart(sourceFile));
+        const after = source(decl, sourceFile).slice(decl.moduleSpecifier.getEnd() - decl.getStart(sourceFile));
+        return `${before}'${INTERNAL_SPECIFIER}'${after}`;
+    }
+    const isTypeOnlyImport = importClause.isTypeOnly;
+    const elements = namedBindings.elements;
+    const publik = [];
+    const internal = [];
+    for (const el of elements) {
+        bucketSpecifier(el, isTypeOnlyImport, publik, internal);
+    }
+    const lines = [];
+    if (publik.length > 0) {
+        lines.push(renderImport(publik, PUBLIC_SPECIFIER, isTypeOnlyImport));
+    }
+    if (internal.length > 0) {
+        lines.push(renderImport(internal, INTERNAL_SPECIFIER, isTypeOnlyImport));
+    }
+    if (lines.length === 0) {
+        // Defensive: empty `import {} from '...'` — point at /internal.
+        lines.push(`import {} from '${INTERNAL_SPECIFIER}';`);
+    }
+    return lines.join('\n');
+}
+function bucketSpecifier(el, parentIsTypeOnly, publik, internal) {
+    const lookupName = (el.propertyName ?? el.name).text;
+    const elementIsTypeOnly = el.isTypeOnly;
+    const aliasText = el.propertyName ? ` as ${el.name.text}` : '';
+    // Inline `type` is illegal when the parent import is already `import type`.
+    const typePrefix = !parentIsTypeOnly && elementIsTypeOnly ? 'type ' : '';
+    const text = `${typePrefix}${(el.propertyName ?? el.name).text}${aliasText}`;
+    if (exports.DEVKIT_INTERNAL_SYMBOLS.has(lookupName)) {
+        internal.push(text);
+    }
+    else {
+        publik.push(text);
+    }
+}
+function renderImport(specifiers, from, typeOnly) {
+    const prefix = typeOnly ? 'import type' : 'import';
+    return `${prefix} { ${specifiers.join(', ')} } from '${from}';`;
+}
+function source(decl, sourceFile) {
+    return sourceFile.text.slice(decl.getStart(sourceFile), decl.getEnd());
+}
+function collectCallExpressionRewrites(sourceFile, changes) {
+    const visit = (node) => {
+        if (ts.isCallExpression(node) &&
+            shouldRewriteCallExpression(node) &&
+            node.arguments.length >= 1 &&
+            ts.isStringLiteral(node.arguments[0]) &&
+            node.arguments[0].text.startsWith(DEEP_IMPORT_PREFIX)) {
+            const arg = node.arguments[0];
+            const start = arg.getStart(sourceFile);
+            const end = arg.getEnd();
+            const quote = sourceFile.text.charAt(start);
+            changes.push({
+                type: string_change_1.ChangeType.Delete,
+                start,
+                length: end - start,
+            }, {
+                type: string_change_1.ChangeType.Insert,
+                index: start,
+                text: `${quote}${INTERNAL_SPECIFIER}${quote}`,
+            });
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+}
+function shouldRewriteCallExpression(call) {
+    const callee = call.expression;
+    // `require('...')`
+    if (ts.isIdentifier(callee) && callee.text === 'require')
+        return true;
+    // dynamic `import('...')` — the runtime form parses as a CallExpression
+    // whose callee is the `import` keyword. The type-position form
+    // (`typeof import('...')`) parses as `ImportTypeNode`, not a CallExpression,
+    // so we don't touch it.
+    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;
+}

package/{src → dist/src}/tasks/install-packages-task.d.ts

@@ -8,4 +8,3 @@ import { PackageManager, Tree } from 'nx/src/devkit-exports';
  * unless install already ran this generator cycle.
  */
 export declare function installPackagesTask(tree: Tree, ensureInstall?: boolean, cwd?: string, packageManager?: PackageManager): void;
-//# sourceMappingURL=install-packages-task.d.ts.map

package/{src → dist/src}/utils/add-plugin.d.ts

@@ -11,4 +11,3 @@ export declare function addPlugin<PluginOptions>(tree: Tree, graph: ProjectGraph
  */
 export declare function addPluginV1<PluginOptions>(tree: Tree, graph: ProjectGraph, pluginName: string, createNodesTuple: CreateNodesV2<PluginOptions>, options: Partial<Record<keyof PluginOptions, PluginOptions[keyof PluginOptions][]>>, shouldUpdatePackageJsonScripts: boolean): Promise<void>;
 export declare function generateCombinations<T>(input: Record<string, T[]>): Record<string, T>[];
-//# sourceMappingURL=add-plugin.d.ts.map

package/{src → dist/src}/utils/async-iterable/combine-async-iterables.d.ts

@@ -1,4 +1,3 @@
 export declare function combineAsyncIterables<T = any>(..._iterators: {
     0: AsyncIterable<T>;
 } & AsyncIterable<T>[]): AsyncGenerator<T>;
-//# sourceMappingURL=combine-async-iterables.d.ts.map

package/{src → dist/src}/utils/async-iterable/create-async-iterable.d.ts

@@ -5,4 +5,3 @@ export interface AsyncPushCallbacks<T> {
     registerCleanup?: (cb: () => void | Promise<void>) => void;
 }
 export declare function createAsyncIterable<T = unknown>(listener: (ls: AsyncPushCallbacks<T>) => void): AsyncIterable<T>;
-//# sourceMappingURL=create-async-iterable.d.ts.map