@nx/js 23.0.0-beta.2 → 23.0.0-beta.21

package/dist/src/migrations/update-22-0-0/remove-external-options-from-js-executors.md

@@ -0,0 +1,79 @@
+#### Remove the `external` and `externalBuildTargets` Options from the `@nx/js:swc` and `@nx/js:tsc` Executors
+
+Remove the deprecated `external` and `externalBuildTargets` options from the `@nx/js:swc` and `@nx/js:tsc` executors. These options were used for inlining dependencies, which was an experimental feature and has been deprecated for a long time. The migration only removes the options from the project configuration and target defaults. If you rely on inlining dependencies, you need to make sure they are all buildable or use a different build tool that supports bundling.
+
+#### Sample Code Changes
+
+Remove `external` and `externalBuildTargets` from the `@nx/js:swc` or `@nx/js:tsc` executor options in project configuration.
+
+##### Before
+
+```json title="libs/my-lib/project.json" {9-10}
+{
+  "targets": {
+    "build": {
+      "executor": "@nx/js:swc",
+      "options": {
+        "main": "libs/my-lib/src/index.ts",
+        "outputPath": "dist/libs/my-lib",
+        "tsConfig": "libs/my-lib/tsconfig.lib.json",
+        "external": ["react", "react-dom"],
+        "externalBuildTargets": ["build"]
+      }
+    }
+  }
+}
+```
+
+##### After
+
+```json title="libs/my-lib/project.json"
+{
+  "targets": {
+    "build": {
+      "executor": "@nx/js:swc",
+      "options": {
+        "main": "libs/my-lib/src/index.ts",
+        "outputPath": "dist/libs/my-lib",
+        "tsConfig": "libs/my-lib/tsconfig.lib.json"
+      }
+    }
+  }
+}
+```
+
+Remove `external` and `externalBuildTargets` from the `@nx/js:swc` or `@nx/js:tsc` executor target defaults in `nx.json`.
+
+##### Before
+
+```json title="nx.json" {8-9}
+{
+  "targetDefaults": {
+    "@nx/js:swc": {
+      "options": {
+        "main": "{projectRoot}/src/index.ts",
+        "outputPath": "dist/{projectRoot}",
+        "tsConfig": "{projectRoot}/tsconfig.lib.json",
+        "external": "all",
+        "externalBuildTargets": ["build"]
+      }
+    }
+  }
+}
+```
+
+##### After
+
+```json title="nx.json"
+{
+  "targetDefaults": {
+    "@nx/js:swc": {
+      "options": {
+        "main": "{projectRoot}/src/index.ts",
+        "outputPath": "dist/{projectRoot}",
+        "tsConfig": "{projectRoot}/tsconfig.lib.json"
+      }
+    }
+  }
+}
+```

package/{src → dist/src}/migrations/update-22-1-0/remove-redundant-ts-project-references.d.ts

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

package/dist/src/migrations/update-22-1-0/remove-redundant-ts-project-references.md

@@ -0,0 +1,143 @@
+#### Removes Redundant TypeScript Project References from tsconfig.json Files
+
+Removes redundant TypeScript project references from `tsconfig.json` files when runtime tsconfig files (e.g., `tsconfig.lib.json`, `tsconfig.app.json`) exist. Previously, external project references were duplicated in both the project's `tsconfig.json` and runtime tsconfig files. This migration syncs the TypeScript project references to match the project graph, ensuring that external references only appear in runtime tsconfig files when they exist.
+
+#### Examples
+
+When a project has runtime tsconfig files like `tsconfig.lib.json`, the migration will remove external project references from the project's `tsconfig.json` file:
+
+##### Before
+
+```jsonc {7-9}
+// libs/my-lib/tsconfig.json
+{
+  "compilerOptions": {
+    "composite": true,
+  },
+  "references": [
+    {
+      "path": "../other-lib",
+    },
+  ],
+}
+```
+
+##### After
+
+```jsonc {6}
+// libs/my-lib/tsconfig.json
+{
+  "compilerOptions": {
+    "composite": true,
+  },
+  "references": [],
+}
+```
+
+The external references remain in the runtime tsconfig file where they belong:
+
+##### Before
+
+```jsonc {7-9}
+// libs/my-lib/tsconfig.lib.json
+{
+  "compilerOptions": {
+    "composite": true,
+  },
+  "references": [
+    {
+      "path": "../other-lib/tsconfig.lib.json",
+    },
+  ],
+}
+```
+
+##### After
+
+```jsonc {7-9}
+// libs/my-lib/tsconfig.lib.json
+{
+  "compilerOptions": {
+    "composite": true,
+  },
+  "references": [
+    {
+      "path": "../other-lib/tsconfig.lib.json",
+    },
+  ],
+}
+```
+
+For projects without runtime tsconfig files, the project's `tsconfig.json` file will continue to contain external project references:
+
+##### Before
+
+```jsonc {7-9}
+// libs/legacy-lib/tsconfig.json
+{
+  "compilerOptions": {
+    "composite": true,
+  },
+  "references": [
+    {
+      "path": "../other-lib",
+    },
+  ],
+}
+```
+
+##### After
+
+```jsonc {7-9}
+// libs/legacy-lib/tsconfig.json
+{
+  "compilerOptions": {
+    "composite": true,
+  },
+  "references": [
+    {
+      "path": "../other-lib",
+    },
+  ],
+}
+```
+
+Internal project references (references within the same project directory) are preserved in the project's `tsconfig.json`:
+
+##### Before
+
+```jsonc {7-12}
+// libs/my-lib/tsconfig.json
+{
+  "compilerOptions": {
+    "composite": true,
+  },
+  "references": [
+    {
+      "path": "./tsconfig.lib.json",
+    },
+    {
+      "path": "./tsconfig.spec.json",
+    },
+  ],
+}
+```
+
+##### After
+
+```jsonc {7-12}
+// libs/my-lib/tsconfig.json
+{
+  "compilerOptions": {
+    "composite": true,
+  },
+  "references": [
+    {
+      "path": "./tsconfig.lib.json",
+    },
+    {
+      "path": "./tsconfig.spec.json",
+    },
+  ],
+}
+```

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,144 @@
+"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/js/src/';
+const TO_SPECIFIER = '@nx/js/internal';
+// Subpaths kept as explicit (non-wildcard) exports entries on `@nx/js`, so
+// imports of them keep resolving. Don't rewrite these:
+// - `release/version-actions`: referenced by a runtime string default baked
+//   into existing user `nx.json` release configs.
+// - `utils/assets/copy-assets-handler`: consumed by project-graph plugins
+//   (e.g. nx's own `tools/workspace-plugin`) that load before any build and
+//   therefore can't resolve the source-only `@nx/js/internal` entry.
+const PRESERVED_SUBPATHS = new Set([
+    '@nx/js/src/release/version-actions',
+    '@nx/js/src/utils/assets/copy-assets-handler',
+]);
+// 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/js/src/* imports to @nx/js/internal in ${touchedCount} file(s).`);
+    }
+    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 = [];
+    collectImportRewrites(sourceFile, changes);
+    collectCallExpressionRewrites(sourceFile, changes);
+    return changes.length > 0 ? (0, devkit_1.applyChangesToString)(source, changes) : source;
+}
+function shouldRewriteSpecifier(specifier) {
+    if (!specifier.startsWith(FROM_PREFIX))
+        return false;
+    if (PRESERVED_SUBPATHS.has(specifier))
+        return false;
+    // Strip a trailing `.js` so e.g. `@nx/js/src/utils/foo.js` matches `@nx/js/src/utils/foo`
+    // for the preserved-subpath check.
+    const withoutJs = specifier.endsWith('.js')
+        ? specifier.slice(0, -3)
+        : specifier;
+    return !PRESERVED_SUBPATHS.has(withoutJs);
+}
+function collectImportRewrites(sourceFile, changes) {
+    for (const stmt of sourceFile.statements) {
+        if (!ts.isImportDeclaration(stmt))
+            continue;
+        if (!ts.isStringLiteral(stmt.moduleSpecifier))
+            continue;
+        if (!shouldRewriteSpecifier(stmt.moduleSpecifier.text))
+            continue;
+        replaceSpecifier(sourceFile, stmt.moduleSpecifier, changes);
+    }
+}
+function collectCallExpressionRewrites(sourceFile, changes) {
+    const visit = (node) => {
+        if (ts.isCallExpression(node) &&
+            shouldRewriteCallExpression(node) &&
+            node.arguments.length >= 1 &&
+            ts.isStringLiteral(node.arguments[0]) &&
+            shouldRewriteSpecifier(node.arguments[0].text)) {
+            replaceSpecifier(sourceFile, node.arguments[0], 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 && shouldRewriteSpecifier(literal.text)) {
+                replaceSpecifier(sourceFile, literal, 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, 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}${TO_SPECIFIER}${quote}`,
+    });
+}

package/{src → dist/src}/plugins/jest/start-local-registry.d.ts

@@ -14,4 +14,3 @@ export declare function startLocalRegistry({ localRegistryTarget, storage, verbo
     listenAddress?: string;
 }): Promise<() => void>;
 export default startLocalRegistry;
-//# sourceMappingURL=start-local-registry.d.ts.map

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

@@ -21,4 +21,3 @@ export declare const createDependencies: CreateDependencies;
 export declare const PLUGIN_NAME = "@nx/js/typescript";
 export declare const createNodesV2: CreateNodesV2<TscPluginOptions>;
 export declare const createNodes: CreateNodesV2<TscPluginOptions>;
-//# sourceMappingURL=plugin.d.ts.map

package/{src → dist/src}/plugins/typescript/plugin.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createNodes = exports.createNodesV2 = exports.PLUGIN_NAME = exports.createDependencies = void 0;
+const internal_1 = require("@nx/devkit/internal");
 const devkit_1 = require("@nx/devkit");
-const get_named_inputs_1 = require("@nx/devkit/src/utils/get-named-inputs");
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const file_hasher_1 = require("nx/src/hasher/file-hasher");
@@ -10,8 +10,20 @@ const picomatch = require("picomatch");
 // eslint-disable-next-line @typescript-eslint/no-restricted-imports
 const lock_file_1 = require("nx/src/plugins/js/lock-file/lock-file");
 const cache_directory_1 = require("nx/src/utils/cache-directory");
+const installation_directory_1 = require("nx/src/utils/installation-directory");
 const util_1 = require("./util");
 let ts;
+const resolvedTypescriptPaths = {};
+function resolveTypescriptPath(projectRoot, workspaceRoot) {
+    // Resolve from projectRoot first, then workspace paths, with __dirname as a
+    // last resort. Required so the lookup works under layouts where @nx/js's real
+    // path is outside the workspace tree (e.g. pnpm's enableGlobalVirtualStore),
+    // since typescript is not a declared dep.
+    resolvedTypescriptPaths[projectRoot] ??= require.resolve('typescript', {
+        paths: [projectRoot, ...(0, installation_directory_1.getNxRequirePaths)(workspaceRoot), __dirname],
+    });
+    return resolvedTypescriptPaths[projectRoot];
+}
 const TSCONFIG_CACHE_VERSION = 2;
 const TS_CONFIG_CACHE_PATH = (0, node_path_1.join)(cache_directory_1.workspaceDataDirectory, 'tsconfig-files.hash');
 // Module-level cache store — each invocation gets a unique Symbol key
@@ -122,8 +134,10 @@ exports.createNodesV2 = [
         const cache = cacheStore.get(cacheKey);
         initializeTsConfigCache(configFilePaths, context.workspaceRoot, cache);
         const normalizedOptions = normalizePluginOptions(options);
-        const pmc = (0, devkit_1.getPackageManagerCommand)((0, devkit_1.detectPackageManager)(context.workspaceRoot));
-        const { configFilePaths: validConfigFilePaths, hashes, projectRoots, } = await resolveValidConfigFilesAndHashes(configFilePaths, normalizedOptions, optionsHash, context, cache);
+        const packageManager = (0, devkit_1.detectPackageManager)(context.workspaceRoot);
+        const pmc = (0, devkit_1.getPackageManagerCommand)(packageManager);
+        const lockFileName = (0, lock_file_1.getLockFileName)(packageManager);
+        const { configFilePaths: validConfigFilePaths, hashes, projectRoots, } = await resolveValidConfigFilesAndHashes(configFilePaths, normalizedOptions, optionsHash, context, cache, lockFileName);
         try {
             return await (0, devkit_1.createNodesFromFiles)((configFilePath, options, context, idx) => {
                 const projectRoot = projectRoots[idx];
@@ -156,8 +170,8 @@ exports.createNodesV2 = [
     },
 ];
 exports.createNodes = exports.createNodesV2;
-async function resolveValidConfigFilesAndHashes(configFilePaths, options, optionsHash, context, cache) {
-    const lockFileHash = (0, file_hasher_1.hashFile)((0, node_path_1.join)(context.workspaceRoot, (0, lock_file_1.getLockFileName)((0, devkit_1.detectPackageManager)(context.workspaceRoot)))) ?? '';
+async function resolveValidConfigFilesAndHashes(configFilePaths, options, optionsHash, context, cache, lockFileName) {
+    const lockFileHash = (0, file_hasher_1.hashFile)((0, node_path_1.join)(context.workspaceRoot, lockFileName)) ?? '';
     const validConfigFilePaths = [];
     const hashes = [];
     const projectRoots = [];
@@ -246,7 +260,7 @@ function checkIfConfigFileShouldBeProject(config, cache) {
 }
 function buildTscTargets(config, options, context, configFiles, cache, pmc) {
     const targets = {};
-    const namedInputs = (0, get_named_inputs_1.getNamedInputs)(config.project.root, context);
+    const namedInputs = (0, internal_1.getNamedInputs)(config.project.root, context);
     const tsConfig = retrieveTsConfigFromCache(config.absolutePath, context.workspaceRoot, cache);
     let internalProjectReferences;
     if (options.typecheck &&
@@ -354,7 +368,7 @@ function getInputs(namedInputs, config, tsConfig, internalProjectReferences, wor
     ];
     const absoluteProjectRoot = config.project.absolute;
     if (!ts) {
-        ts = require('typescript');
+        ts = require(resolveTypescriptPath(absoluteProjectRoot, workspaceRoot));
     }
     // https://github.com/microsoft/TypeScript/blob/19b777260b26aac5707b1efd34202054164d4a9d/src/compiler/utilities.ts#L9869
     const supportedTSExtensions = [
@@ -819,7 +833,7 @@ function getExtendedFilesHash(extendedConfigFiles, workspaceRoot, cache) {
 }
 function readTsConfig(tsConfigPath, workspaceRoot, cache) {
     if (!ts) {
-        ts = require('typescript');
+        ts = require(resolveTypescriptPath(workspaceRoot, workspaceRoot));
     }
     // Normalize to forward slashes for TypeScript compatibility on Windows.
     // TypeScript's parser normalizes paths inconsistently — diagnostics use

package/{src → dist/src}/plugins/typescript/util.d.ts

@@ -16,4 +16,3 @@ export declare function addBuildAndWatchDepsTargets(workspaceRoot: string, proje
     watchDepsTargetName?: string;
 }, pmc: PackageManagerCommands): void;
 export declare function isValidPackageJsonBuildConfig(tsConfig: ParsedTsconfigData, workspaceRoot: string, projectRoot: string): boolean;
-//# sourceMappingURL=util.d.ts.map

package/{src → dist/src}/plugins/typescript/util.js

@@ -32,7 +32,7 @@ function addBuildAndWatchDepsTargets(workspaceRoot, projectRoot, targets, option
         targets[options.watchDepsTargetName ?? 'watch-deps'] = {
             continuous: true,
             dependsOn: [buildDepsTargetName],
-            command: `${pmc.exec} nx watch --projects ${projectName} --includeDependentProjects -- ${pmc.exec} nx ${buildDepsTargetName} ${projectName}`,
+            command: `${pmc.exec} nx watch --projects ${projectName} --includeDependencies -- ${pmc.exec} nx ${buildDepsTargetName} ${projectName}`,
         };
     }
 }

package/{src → dist/src}/release/utils/semver.d.ts

@@ -1,3 +1,2 @@
 export declare function isValidRange(range: string): boolean;
 export declare function isMatchingDependencyRange(version: string, range: string): boolean;
-//# sourceMappingURL=semver.d.ts.map

package/{src → dist/src}/release/utils/update-lock-file.d.ts

@@ -7,4 +7,3 @@ export declare function updateLockFile(cwd: string, { dryRun, verbose, options,
         installIgnoreScripts?: boolean;
     };
 }): Promise<string[]>;
-//# sourceMappingURL=update-lock-file.d.ts.map

package/{src → dist/src}/release/version-actions.d.ts

@@ -20,4 +20,3 @@ export default class JsVersionActions extends VersionActions {
     updateProjectDependencies(tree: Tree, projectGraph: ProjectGraph, dependenciesToUpdate: Record<string, string>): Promise<string[]>;
     private isLocalDependencyProtocol;
 }
-//# sourceMappingURL=version-actions.d.ts.map

package/{src → dist/src}/release/version-actions.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.afterAllProjectsVersioned = void 0;
+const internal_1 = require("@nx/devkit/internal");
 const devkit_1 = require("@nx/devkit");
-const catalog_1 = require("@nx/devkit/src/utils/catalog");
 const node_child_process_1 = require("node:child_process");
 const node_path_1 = require("node:path");
 const release_1 = require("nx/release");
@@ -109,7 +109,7 @@ class JsVersionActions extends release_1.VersionActions {
         }
         // Resolve catalog references if needed
         if (currentVersion) {
-            const catalogManager = (0, catalog_1.getCatalogManager)(tree.root);
+            const catalogManager = (0, internal_1.getCatalogManager)(tree.root);
             if (catalogManager?.isCatalogReference(currentVersion)) {
                 currentVersion = catalogManager.resolveCatalogReference(tree, dependencyPackageName, currentVersion);
             }
@@ -137,7 +137,7 @@ class JsVersionActions extends release_1.VersionActions {
         }
         const logMessages = [];
         const catalogUpdates = [];
-        const catalogManager = (0, catalog_1.getCatalogManager)(tree.root);
+        const catalogManager = (0, internal_1.getCatalogManager)(tree.root);
         for (const manifestToUpdate of this.manifestsToUpdate) {
             (0, devkit_1.updateJson)(tree, manifestToUpdate.manifestPath, (json) => {
                 const dependencyTypes = [

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

@@ -1,4 +1,3 @@
 import { Tree } from '@nx/devkit';
 /** @deprecated Do not use this function as the root babel.config.json file is no longer needed */
 export declare function addBabelInputs(tree: Tree): void;
-//# sourceMappingURL=add-babel-inputs.d.ts.map

package/{src → dist/src}/utils/add-local-registry-scripts.d.ts

@@ -3,4 +3,3 @@ export declare function addLocalRegistryScripts(tree: Tree): {
     startLocalRegistryPath: string;
     stopLocalRegistryPath: string;
 };
-//# sourceMappingURL=add-local-registry-scripts.d.ts.map

package/dist/src/utils/assert-supported-typescript-version.d.ts

@@ -0,0 +1,2 @@
+import { type Tree } from '@nx/devkit';
+export declare function assertSupportedTypescriptVersion(tree: Tree): void;

package/dist/src/utils/assert-supported-typescript-version.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertSupportedTypescriptVersion = assertSupportedTypescriptVersion;
+const internal_1 = require("@nx/devkit/internal");
+const versions_1 = require("./versions");
+function assertSupportedTypescriptVersion(tree) {
+    (0, internal_1.assertSupportedPackageVersion)(tree, 'typescript', versions_1.minSupportedTypescriptVersion);
+}

package/{src → dist/src}/utils/assets/assets.d.ts

@@ -9,4 +9,3 @@ export type AssetGlob = FileInputOutput & {
     includeIgnoredFiles?: boolean;
 };
 export declare function assetGlobsToFiles(assets: Array<AssetGlob | string>, rootDir: string, outDir: string): FileInputOutput[];
-//# sourceMappingURL=assets.d.ts.map

package/{src → dist/src}/utils/assets/copy-assets-handler.d.ts

@@ -35,4 +35,3 @@ export declare class CopyAssetsHandler {
     private filesToEvent;
     private normalizeAssetPattern;
 }
-//# sourceMappingURL=copy-assets-handler.d.ts.map

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

@@ -15,4 +15,3 @@ export interface WatchMode {
     onCopy?: (events: FileEvent[]) => void;
 }
 export declare function copyAssets(options: CopyAssetsOptions, context: ExecutorContext): Promise<CopyAssetsResult>;
-//# sourceMappingURL=index.d.ts.map

package/{src → dist/src}/utils/assets/normalize-assets.d.ts

@@ -23,4 +23,3 @@ export declare function normalizeAssets(assets: (string | AssetGlobInput)[], roo
  * matching the dest logic used during file copying.
  */
 export declare function getAssetOutputPath(src: string, assetEntry: NormalizedAssetEntry): string;
-//# sourceMappingURL=normalize-assets.d.ts.map

package/{src → dist/src}/utils/buildable-libs-utils.d.ts

@@ -39,4 +39,3 @@ export declare function updatePaths(dependencies: DependentBuildableProjectNode[
  * the proper dependency and version
  */
 export declare function updateBuildableProjectPackageJsonDependencies(root: string, projectName: string, targetName: string, configurationName: string, node: ProjectGraphProjectNode, dependencies: DependentBuildableProjectNode[], typeOfDependency?: 'dependencies' | 'peerDependencies'): void;
-//# sourceMappingURL=buildable-libs-utils.d.ts.map

package/{src → dist/src}/utils/check-dependencies.d.ts

@@ -6,4 +6,3 @@ export declare function checkDependencies(context: ExecutorContext, tsConfigPath
     target: ProjectGraphProjectNode;
     dependencies: DependentBuildableProjectNode[];
 };
-//# sourceMappingURL=check-dependencies.d.ts.map

package/{src → dist/src}/utils/code-frames/highlight.d.ts

@@ -1,2 +1 @@
 export declare function highlight(code: string): string;
-//# sourceMappingURL=highlight.d.ts.map

package/{src → dist/src}/utils/code-frames/identifiers.d.ts

@@ -3,4 +3,3 @@
  */
 export declare function isReservedWord(word: string, inModule?: boolean): boolean;
 export declare function isKeyword(word: string): boolean;
-//# sourceMappingURL=identifiers.d.ts.map

package/{src → dist/src}/utils/compiler-helper-dependency.d.ts

@@ -16,4 +16,3 @@ export declare enum HelperDependency {
  */
 export declare function getHelperDependency(helperDependency: HelperDependency, configPath: string, dependencies: DependentBuildableProjectNode[], projectGraph: ProjectGraph, returnDependencyIfFound?: boolean): DependentBuildableProjectNode | null;
 export declare function getHelperDependenciesFromProjectGraph(contextRoot: string, sourceProject: string, projectGraph: ProjectGraph): ProjectGraphDependency[];
-//# sourceMappingURL=compiler-helper-dependency.d.ts.map

package/{src → dist/src}/utils/find-npm-dependencies.d.ts

@@ -8,4 +8,3 @@ export declare function findNpmDependencies(workspaceRoot: string, sourceProject
     useLocalPathsForWorkspaceDependencies?: boolean;
     runtimeHelpers?: string[];
 }): Record<string, string>;
-//# sourceMappingURL=find-npm-dependencies.d.ts.map

package/{src → dist/src}/utils/generate-globs.d.ts

@@ -4,4 +4,3 @@
  * @param fileGlobPattern pass a custom glob pattern to be used
  */
 export declare function createGlobPatternsForDependencies(dirPath: string, fileGlobPattern: string): string[];
-//# sourceMappingURL=generate-globs.d.ts.map

package/{src → dist/src}/utils/generator-prompts.d.ts

@@ -1,4 +1,3 @@
 import type { Tree } from '@nx/devkit';
 export declare function normalizeLinterOption(tree: Tree, linter: undefined | 'none' | 'eslint'): Promise<'none' | 'eslint'>;
 export declare function normalizeUnitTestRunnerOption<T extends 'none' | 'jest' | 'vitest'>(tree: Tree, unitTestRunner: undefined | T, testRunners?: Array<'jest' | 'vitest'>): Promise<T>;
-//# sourceMappingURL=generator-prompts.d.ts.map

package/{src → dist/src}/utils/generator-prompts.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizeLinterOption = normalizeLinterOption;
 exports.normalizeUnitTestRunnerOption = normalizeUnitTestRunnerOption;
-const prompt_1 = require("@nx/devkit/src/generators/prompt");
+const internal_1 = require("@nx/devkit/internal");
 const ts_solution_setup_1 = require("./typescript/ts-solution-setup");
 async function normalizeLinterOption(tree, linter) {
     if (linter) {
@@ -13,7 +13,7 @@ async function normalizeLinterOption(tree, linter) {
         ? [{ name: 'none' }, { name: 'eslint' }]
         : [{ name: 'eslint' }, { name: 'none' }];
     const defaultValue = isTsSolutionSetup ? 'none' : 'eslint';
-    return await (0, prompt_1.promptWhenInteractive)({
+    return await (0, internal_1.promptWhenInteractive)({
         type: 'autocomplete',
         name: 'linter',
         message: `Which linter would you like to use?`,
@@ -30,7 +30,7 @@ async function normalizeUnitTestRunnerOption(tree, unitTestRunner, testRunners =
         ? [{ name: 'none' }, ...testRunners.map((runner) => ({ name: runner }))]
         : [...testRunners.map((runner) => ({ name: runner })), { name: 'none' }];
     const defaultValue = (isTsSolutionSetup ? 'none' : testRunners[0]);
-    return await (0, prompt_1.promptWhenInteractive)({
+    return await (0, internal_1.promptWhenInteractive)({
         type: 'autocomplete',
         name: 'unitTestRunner',
         message: `Which unit test runner would you like to use?`,