@nx/js 23.1.0-beta.4 → 23.1.0-beta.6

package/dist/src/executors/prune-lockfile/prune-lockfile.d.ts

@@ -1,5 +1,7 @@
 import { type ExecutorContext } from '@nx/devkit';
+import { type PackageJson } from 'nx/src/utils/package-json';
 import { type PruneLockfileOptions } from './schema';
 export default function pruneLockfileExecutor(schema: PruneLockfileOptions, context: ExecutorContext): Promise<{
     success: boolean;
 }>;
+export declare function resolveCatalogReferences(packageJson: PackageJson): PackageJson;

package/dist/src/executors/prune-lockfile/prune-lockfile.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = pruneLockfileExecutor;
+exports.resolveCatalogReferences = resolveCatalogReferences;
 const devkit_1 = require("@nx/devkit");
+const internal_1 = require("@nx/devkit/internal");
 const fs_1 = require("fs");
 const path_1 = require("path");
 const utils_1 = require("nx/src/tasks-runner/utils");
@@ -13,7 +15,8 @@ const strip_glob_to_base_dir_1 = require("../../utils/strip-glob-to-base-dir");
 async function pruneLockfileExecutor(schema, context) {
     devkit_1.logger.log('Pruning lockfile...');
     const outputDirectory = getOutputDir(schema, context);
-    const packageJson = getPackageJson(schema, context);
+    const packageJson = resolveCatalogReferences(getPackageJson(schema, context));
+    mergeAllowScripts(packageJson);
     const packageManager = (0, devkit_1.detectPackageManager)(devkit_1.workspaceRoot);
     if (packageManager === 'bun') {
         devkit_1.logger.warn('Bun lockfile generation is not supported. Only package.json will be generated. Run "bun install" in the output directory if needed.');
@@ -48,6 +51,55 @@ function createPrunedLockfile(packageJson, graph) {
         lockFile,
     };
 }
+/**
+ * npm reads the `allowScripts` install-script allowlist only from the install
+ * root, but `npm approve-scripts` writes it to the workspace root, so it never
+ * lives in the project package.json the prune output is built from. Carry the
+ * root allowlist over, with project-level entries preserved and winning on
+ * conflict. Mirrors the `pnpm.allowBuilds` handling in createPackageJson.
+ */
+function mergeAllowScripts(packageJson) {
+    const rootPackageJson = (0, devkit_1.readJsonFile)((0, path_1.join)(devkit_1.workspaceRoot, 'package.json'));
+    if (!rootPackageJson.allowScripts) {
+        return;
+    }
+    packageJson.allowScripts = {
+        ...rootPackageJson.allowScripts,
+        ...packageJson.allowScripts,
+    };
+}
+function resolveCatalogReferences(packageJson) {
+    const manager = (0, internal_1.getCatalogManager)(devkit_1.workspaceRoot);
+    if (!manager) {
+        return packageJson;
+    }
+    const sections = [
+        'dependencies',
+        'optionalDependencies',
+        'devDependencies',
+        'peerDependencies',
+    ];
+    const resolved = { ...packageJson };
+    for (const section of sections) {
+        const deps = packageJson[section];
+        if (!deps) {
+            continue;
+        }
+        const resolvedDeps = { ...deps };
+        for (const [packageName, version] of Object.entries(deps)) {
+            if (!manager.isCatalogReference(version)) {
+                continue;
+            }
+            const resolvedVersion = manager.resolveCatalogReference(devkit_1.workspaceRoot, packageName, version);
+            if (!resolvedVersion) {
+                throw new Error(`Could not resolve catalog reference for package ${packageName}@${version}.`);
+            }
+            resolvedDeps[packageName] = resolvedVersion;
+        }
+        resolved[section] = resolvedDeps;
+    }
+    return resolved;
+}
 function getPackageJson(schema, context) {
     const target = (0, devkit_1.parseTargetString)(schema.buildTarget, context);
     const project = context.projectGraph.nodes[target.project].data;

package/dist/src/generators/setup-build/generator.js

@@ -249,7 +249,5 @@ function updatePackageJson(tree, projectName, projectRoot, main, outputPath, roo
 function mergeTargetDefaults(tree, project, buildTarget) {
     const nxJson = (0, devkit_1.readNxJson)(tree);
     const projectTarget = project.targets[buildTarget];
-    return (0, devkit_internals_1.mergeTargetConfigurations)(projectTarget, (projectTarget.executor
-        ? nxJson.targetDefaults?.[projectTarget.executor]
-        : undefined) ?? nxJson.targetDefaults?.[buildTarget]);
+    return (0, devkit_internals_1.mergeTargetConfigurations)(projectTarget, (0, internal_1.readTargetDefaultsForTarget)(buildTarget, nxJson.targetDefaults, projectTarget.executor));
 }

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

@@ -35,30 +35,50 @@ async function default_1(tree) {
     if (!nxJson.targetDefaults) {
         return;
     }
-    for (const [targetOrExecutor, targetConfig] of Object.entries(nxJson.targetDefaults)) {
-        if (!exports.executors.includes(targetOrExecutor) &&
-            !exports.executors.includes(targetConfig.executor)) {
-            continue;
-        }
-        if (targetConfig.options) {
-            delete targetConfig.options.external;
-            delete targetConfig.options.externalBuildTargets;
-            if (!Object.keys(targetConfig.options).length) {
-                delete targetConfig.options;
+    const cleanEntry = (entry) => {
+        if (entry.options) {
+            delete entry.options.external;
+            delete entry.options.externalBuildTargets;
+            if (!Object.keys(entry.options).length) {
+                delete entry.options;
             }
         }
-        Object.entries(targetConfig.configurations ?? {}).forEach(([, config]) => {
+        Object.values(entry.configurations ?? {}).forEach((config) => {
             delete config.external;
             delete config.externalBuildTargets;
         });
-        if (!Object.keys(targetConfig).length ||
-            (Object.keys(targetConfig).length === 1 &&
-                Object.keys(targetConfig)[0] === 'executor')) {
-            delete nxJson.targetDefaults[targetOrExecutor];
+    };
+    const targetDefaults = nxJson.targetDefaults;
+    for (const key of Object.keys(targetDefaults)) {
+        const value = targetDefaults[key];
+        const entries = Array.isArray(value)
+            ? value
+            : [value];
+        const usesExecutor = (entry) => exports.executors.includes(key) ||
+            exports.executors.includes(entry.executor) ||
+            exports.executors.includes(entry.filter?.executor);
+        const kept = entries.filter((entry) => {
+            if (usesExecutor(entry)) {
+                cleanEntry(entry);
+            }
+            // Drop entries left with nothing but their `filter`/`executor` locator.
+            return Object.keys(entry).some((k) => k !== 'filter' && k !== 'executor');
+        });
+        if (kept.length === 0) {
+            delete targetDefaults[key];
         }
-        if (!Object.keys(nxJson.targetDefaults).length) {
-            delete nxJson.targetDefaults;
+        else if (kept.length === 1 && kept[0].filter === undefined) {
+            // A lone unfiltered entry is stored as the plain object form (which
+            // omits `filter`).
+            const { filter: _filter, ...config } = kept[0];
+            targetDefaults[key] = config;
         }
+        else {
+            targetDefaults[key] = kept;
+        }
+    }
+    if (Object.keys(targetDefaults).length === 0) {
+        delete nxJson.targetDefaults;
     }
     (0, devkit_1.updateNxJson)(tree, nxJson);
     await (0, devkit_1.formatFiles)(tree);

package/dist/src/migrations/update-23-1-0/add-ignore-deprecations-for-ts6.d.ts

@@ -10,14 +10,19 @@ import { type Tree } from '@nx/devkit';
  *    false, downlevelIteration set to any value).
  *
  * 2. default-preserving pass - for every chain root (no "extends" key), pins
- *    the TS6 compiler-option defaults that flipped to a stricter value back to
- *    their pre-TS6 value, but only when the root does not set them explicitly:
+ *    the TS6 compiler-option defaults that changed in a way that breaks existing
+ *    workspaces back to their pre-TS6 value, but only when the root does not set
+ *    them explicitly:
  *      - "strict": false - TS6 treats an absent "strict" as true; TS5 as false.
  *      - "noUncheckedSideEffectImports": false - TS6 defaults it to true, which
  *        turns a bare side-effect import of an asset lacking an ambient
  *        declaration (e.g. `import './styles.css'`) into a hard TS2882 error; it
  *        is a semantic diagnostic, not a deprecation, so `ignoreDeprecations`
  *        cannot silence it.
+ *      - "types": ["*"]. TS6 loads no @types packages when `types` is unset,
+ *        whereas TS5 loaded them all; the "*" wildcard restores that default so
+ *        a config relying on it (e.g. ts-node type-checking jest.config.ts)
+ *        keeps finding @types/node.
  *    Files with "extends" inherit from their chain root and are left untouched.
  *    Pure solution-style containers (root has `"files": []` and no "include")
  *    select no source files, so pinning there is noise and they are skipped.

package/dist/src/migrations/update-23-1-0/add-ignore-deprecations-for-ts6.js

@@ -18,14 +18,19 @@ const FORMATTING_OPTIONS = {
  *    false, downlevelIteration set to any value).
  *
  * 2. default-preserving pass - for every chain root (no "extends" key), pins
- *    the TS6 compiler-option defaults that flipped to a stricter value back to
- *    their pre-TS6 value, but only when the root does not set them explicitly:
+ *    the TS6 compiler-option defaults that changed in a way that breaks existing
+ *    workspaces back to their pre-TS6 value, but only when the root does not set
+ *    them explicitly:
  *      - "strict": false - TS6 treats an absent "strict" as true; TS5 as false.
  *      - "noUncheckedSideEffectImports": false - TS6 defaults it to true, which
  *        turns a bare side-effect import of an asset lacking an ambient
  *        declaration (e.g. `import './styles.css'`) into a hard TS2882 error; it
  *        is a semantic diagnostic, not a deprecation, so `ignoreDeprecations`
  *        cannot silence it.
+ *      - "types": ["*"]. TS6 loads no @types packages when `types` is unset,
+ *        whereas TS5 loaded them all; the "*" wildcard restores that default so
+ *        a config relying on it (e.g. ts-node type-checking jest.config.ts)
+ *        keeps finding @types/node.
  *    Files with "extends" inherit from their chain root and are left untouched.
  *    Pure solution-style containers (root has `"files": []` and no "include")
  *    select no source files, so pinning there is noise and they are skipped.
@@ -52,7 +57,7 @@ async function default_1(tree) {
         devkit_1.logger.info(`Added "ignoreDeprecations": "6.0" to ${deprecationCount} tsconfig file(s) carrying TS6-deprecated options.`);
     }
     if (defaultsPinCount > 0) {
-        devkit_1.logger.info(`Pinned pre-TS6 compiler option defaults ("strict", "noUncheckedSideEffectImports") on ${defaultsPinCount} tsconfig chain root(s) to preserve existing behavior.`);
+        devkit_1.logger.info(`Pinned pre-TS6 compiler option defaults ("strict", "noUncheckedSideEffectImports", "types") on ${defaultsPinCount} tsconfig chain root(s) to preserve existing behavior.`);
     }
     await (0, devkit_1.formatFiles)(tree);
 }
@@ -137,12 +142,15 @@ function hasDeprecatedValue(compilerOptions) {
     }
     return false;
 }
-// TS6 compiler-option defaults that flipped to a stricter value. We pin each
-// back to its pre-TS6 value on chain roots that don't set it, so existing
-// workspaces keep building without adopting a legit TS6 setup.
+// TS6 compiler-option defaults that changed in a way that breaks existing
+// workspaces. We pin each back to its pre-TS6 value on chain roots that don't
+// set it, so existing workspaces keep building without adopting a legit TS6
+// setup.
 const DEFAULT_PRESERVING_PINS = [
     ['strict', false],
     ['noUncheckedSideEffectImports', false],
+    // TS6 loads no @types when `types` is unset (TS5 loaded all); "*" restores it.
+    ['types', ['*']],
 ];
 function pinPreTs6Defaults(tree, tsconfigPath) {
     const original = tree.read(tsconfigPath, 'utf-8');
@@ -177,7 +185,7 @@ function pinPreTs6Defaults(tree, tsconfigPath) {
     let contents = original;
     let changed = false;
     for (const [key, value] of DEFAULT_PRESERVING_PINS) {
-        // An explicit value (true or false) means the user opted in - leave it.
+        // An explicit value means the user opted in; leave it.
         if (key in compilerOptions) {
             continue;
         }

package/dist/src/migrations/update-23-1-0/add-ignore-deprecations-for-ts6.md

@@ -3,7 +3,7 @@
 TypeScript 6 turns several long-deprecated compiler options into hard errors and flips a few option defaults to stricter values. So that an existing workspace keeps compiling on TypeScript 6 without being migrated to a full TypeScript 6 setup, this migration makes two edits to the `tsconfig*.json` files in the workspace:
 
 - Adds `"ignoreDeprecations": "6.0"` to any `compilerOptions` (or `ts-node.compilerOptions`) block that directly sets a TypeScript 6 deprecated option - for example `moduleResolution` set to `node`/`node10`/`classic`, `baseUrl`, `target` set to `es5`, `esModuleInterop: false`, `outFile`, `module` set to `amd`/`umd`/`system`/`none`, `alwaysStrict: false`, `allowSyntheticDefaultImports: false`, or `downlevelIteration`.
-- Pins `"strict": false` and `"noUncheckedSideEffectImports": false` on every chain-root tsconfig (one without an `extends`) that does not already set them. TypeScript 6 treats an absent `strict` as `true` (it was `false` when unset before) and defaults `noUncheckedSideEffectImports` to `true`, which turns a bare side-effect import such as `import './styles.css'` without an ambient module declaration into an error. Pinning both preserves the pre-TypeScript 6 behavior.
+- Pins `"strict": false`, `"noUncheckedSideEffectImports": false`, and `"types": ["*"]` on every chain-root tsconfig (one without an `extends`) that does not already set them. TypeScript 6 treats an absent `strict` as `true` (it was `false` when unset before), defaults `noUncheckedSideEffectImports` to `true` (which turns a bare side-effect import such as `import './styles.css'` without an ambient module declaration into an error), and no longer auto-loads every `@types` package when `types` is unset the way TypeScript 5 did. The `"*"` wildcard restores that last default. Pinning all three preserves the pre-TypeScript 6 behavior.
 
 Files that use `extends` inherit these settings from their chain root and are left untouched, and pure solution-style tsconfigs (`"files": []` with no `include`) are skipped. The migration only runs when the workspace is on TypeScript 6.
 
@@ -23,7 +23,7 @@ Files that use `extends` inherit these settings from their chain root and are le
 
 ##### After
 
-```json title="tsconfig.json" {6-8}
+```json title="tsconfig.json" {6-9}
 {
   "compilerOptions": {
     "target": "es5",
@@ -31,7 +31,8 @@ Files that use `extends` inherit these settings from their chain root and are le
     "moduleResolution": "bundler",
     "ignoreDeprecations": "6.0",
     "strict": false,
-    "noUncheckedSideEffectImports": false
+    "noUncheckedSideEffectImports": false,
+    "types": ["*"]
   }
 }
 ```

package/dist/src/utils/buildable-libs-utils.js

@@ -282,7 +282,15 @@ function updatePaths(dependencies, paths) {
                     const { root } = dep.node.data;
                     // Update nested mappings to point to the dependency's output paths
                     mappedPaths = mappedPaths.concat(paths[path].flatMap((p) => dep.outputs.flatMap((output) => {
-                        const basePath = p.replace(root, output);
+                        // Re-map the root prefix to the output. Match root only as a
+                        // leading segment (after an optional `./`) so a root that
+                        // also appears later in the value (e.g. output `dist/libs/base`
+                        // for root `base`) isn't doubled.
+                        const dotPrefix = p.startsWith('./') ? './' : '';
+                        const value = dotPrefix ? p.slice(2) : p;
+                        const basePath = value === root || value.startsWith(`${root}/`)
+                            ? `${dotPrefix}${output}${value.slice(root.length)}`
+                            : p;
                         return [
                             // extension-less path to support compiled output
                             basePath.replace(new RegExp(`${(0, path_1.extname)(basePath)}$`, 'gi'), ''),

package/dist/src/utils/prettier.js

@@ -5,14 +5,23 @@ exports.generatePrettierSetup = generatePrettierSetup;
 exports.resolvePrettierConfigPath = resolvePrettierConfigPath;
 const devkit_1 = require("@nx/devkit");
 const versions_1 = require("./versions");
-async function resolveUserExistingPrettierConfig() {
-    let prettier;
+// Prettier v3 (ESM) exposes its API as named exports; v2 (CJS) exposes it under
+// `.default` when loaded via `import()`. Return whichever carries the API, or
+// null if prettier isn't installed.
+async function importPrettier() {
     try {
-        prettier = await import('prettier');
+        const imported = await import('prettier');
+        return (imported.resolveConfig ? imported : imported.default);
     }
     catch {
         return null;
     }
+}
+async function resolveUserExistingPrettierConfig() {
+    const prettier = await importPrettier();
+    if (!prettier) {
+        return null;
+    }
     try {
         const filepath = await prettier.resolveConfigFile();
         if (!filepath) {
@@ -76,18 +85,13 @@ function generatePrettierSetup(tree, options) {
         : (0, devkit_1.addDependenciesToPackageJson)(tree, {}, { prettier: versions_1.prettierVersion });
 }
 async function resolvePrettierConfigPath(tree) {
-    let prettier;
-    try {
-        prettier = await import('prettier');
-    }
-    catch {
+    const prettier = await importPrettier();
+    if (!prettier) {
         return null;
     }
-    if (prettier) {
-        const filePath = await prettier.resolveConfigFile();
-        if (filePath) {
-            return filePath;
-        }
+    const configFilePath = await prettier.resolveConfigFile();
+    if (configFilePath) {
+        return configFilePath;
     }
     if (!tree) {
         return null;

package/dist/src/utils/swc/compile-swc.js

@@ -44,7 +44,10 @@ function getTypeCheckOptions(normalizedOptions) {
     };
     if (watch) {
         typeCheckOptions.incremental = true;
-        typeCheckOptions.cacheDir = devkit_1.cacheDir;
+        // Scope the incremental .tsbuildinfo per project (in its own subdir, not
+        // alongside Nx's cache files) so concurrent watch type-checks don't collide
+        // on a single file.
+        typeCheckOptions.cacheDir = (0, node_path_1.join)(devkit_1.cacheDir, 'swc', projectRoot);
     }
     if (normalizedOptions.isTsSolutionSetup && normalizedOptions.skipTypeCheck) {
         typeCheckOptions.ignoreDiagnostics = true;

package/dist/src/utils/typescript/run-type-check.js

@@ -43,6 +43,10 @@ async function runTypeCheck(options) {
             options: {
                 ...compilerOptions,
                 incremental: true,
+                // Set after the spread so it overrides any user-set tsBuildInfoFile.
+                // This is a dedicated type-check program with Nx-injected options that
+                // differ from the real build, so its build info must not share a file
+                // with the build, or it corrupts the build's incremental cache.
                 tsBuildInfoFile: path.join(cacheDir, '.tsbuildinfo'),
             },
         });

package/migrations.json

@@ -31,7 +31,7 @@
     },
     "23-1-0-add-ignore-deprecations-for-ts6": {
       "version": "23.1.0-beta.0",
-      "description": "Adds `\"ignoreDeprecations\": \"6.0\"` to tsconfig files whose compilerOptions (or ts-node.compilerOptions) directly carry a TypeScript 6 deprecated option value (e.g. moduleResolution node/node10/classic, baseUrl, target es5, esModuleInterop false, outFile, module amd/umd/system/none, alwaysStrict false, allowSyntheticDefaultImports false, downlevelIteration set). Also pins `\"strict\": false` and `\"noUncheckedSideEffectImports\": false` in chain-root tsconfigs (no \"extends\") that lack each key, preserving pre-TS6 behavior where their defaults were less strict.",
+      "description": "Adds `\"ignoreDeprecations\": \"6.0\"` to tsconfig files whose compilerOptions (or ts-node.compilerOptions) directly carry a TypeScript 6 deprecated option value (e.g. moduleResolution node/node10/classic, baseUrl, target es5, esModuleInterop false, outFile, module amd/umd/system/none, alwaysStrict false, allowSyntheticDefaultImports false, downlevelIteration set). Also pins `\"strict\": false`, `\"noUncheckedSideEffectImports\": false`, and `\"types\": [\"*\"]` in chain-root tsconfigs (no \"extends\") that lack each key, preserving pre-TS6 behavior where these defaults were stricter or, for `types`, stopped auto-loading all @types packages.",
       "requires": {
         "typescript": ">=6.0.0"
       },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/js",
-  "version": "23.1.0-beta.4",
+  "version": "23.1.0-beta.6",
   "private": false,
   "type": "commonjs",
   "files": [
@@ -144,11 +144,11 @@
     "source-map-support": "0.5.19",
     "tinyglobby": "^0.2.12",
     "tslib": "^2.3.0",
-    "@nx/devkit": "23.1.0-beta.4",
-    "@nx/workspace": "23.1.0-beta.4"
+    "@nx/devkit": "23.1.0-beta.6",
+    "@nx/workspace": "23.1.0-beta.6"
   },
   "devDependencies": {
-    "nx": "23.1.0-beta.4"
+    "nx": "23.1.0-beta.6"
   },
   "peerDependencies": {
     "@swc/cli": ">=0.6.0 <0.9.0",