@nx/js 23.0.1 → 23.0.2

package/dist/src/executors/node/node.impl.js

@@ -11,7 +11,7 @@ const crypto_1 = require("crypto");
 const path = tslib_1.__importStar(require("path"));
 const path_1 = require("path");
 const buildable_libs_utils_1 = require("../../utils/buildable-libs-utils");
-const kill_tree_1 = require("./lib/kill-tree");
+const native_1 = require("nx/src/native");
 const line_aware_writer_1 = require("./lib/line-aware-writer");
 const coalescing_debounce_1 = require("./lib/coalescing-debounce");
 const fileutils_1 = require("nx/src/utils/fileutils");
@@ -67,23 +67,26 @@ async function* nodeExecutor(options, context) {
             const previousTask = currentTask;
             const task = tasks.shift();
             if (previousTask && !previousTask.killed) {
-                previousTask.killed = true;
-                if (previousTask.childProcess?.connected) {
-                    previousTask.childProcess.disconnect();
-                }
-                previousTask.childProcess?.removeAllListeners();
+                // stop() marks the task killed, detaches listeners, and waits for the
+                // process tree to exit.
                 await previousTask.stop('SIGTERM');
                 await new Promise((resolve) => setImmediate(resolve));
             }
             currentTask = task;
             globalLineAwareWriter.setActiveProcess(task.id);
             await task.start();
+            // A file change may have queued another task while we waited for the
+            // previous process to stop. Its debounce trigger piggybacked on this
+            // in-flight run, so drain the queue now or it would sit unprocessed
+            // until the next change.
+            if (tasks.length > 0) {
+                await processQueue();
+            }
         };
         const debouncedProcessQueue = (0, coalescing_debounce_1.createCoalescingDebounce)(processQueue, options.debounce ?? 1_000);
         const addToQueue = async (childProcess, buildResult) => {
             for (const task of tasks) {
                 if (!task.killed) {
-                    task.killed = true;
                     await task.stop('SIGTERM');
                 }
             }
@@ -156,7 +159,7 @@ async function* nodeExecutor(options, context) {
                 },
                 stop: async (signal = 'SIGTERM') => {
                     task.killed = true;
-                    if (task.childProcess) {
+                    if (task.childProcess?.pid) {
                         if (task.childProcess.stdout) {
                             task.childProcess.stdout.pause();
                         }
@@ -167,7 +170,12 @@ async function* nodeExecutor(options, context) {
                             task.childProcess.disconnect();
                         }
                         task.childProcess.removeAllListeners();
-                        await (0, kill_tree_1.killTree)(task.childProcess.pid, signal);
+                        // Wait for the process tree to fully exit so the port is released
+                        // before a watch-mode restart boots the next server (EADDRINUSE).
+                        // Windows cannot deliver graceful signals through this API, so
+                        // skip the grace period and force-kill immediately (matching the
+                        // previous taskkill /F behavior).
+                        await (0, native_1.killProcessTreeGraceful)(task.childProcess.pid, signal, process.platform === 'win32' ? 0 : undefined);
                     }
                     if (task.id === globalLineAwareWriter.currentProcessId) {
                         globalLineAwareWriter.setActiveProcess(null);

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/executors/tsc/tsc.impl.js

@@ -55,8 +55,12 @@ function createTypeScriptCompilationOptions(normalizedOptions, context) {
         outputPath: (0, devkit_1.joinPathFragments)(normalizedOptions.outputPath),
         projectName: context.projectName,
         projectRoot: normalizedOptions.projectRoot,
-        rootDir: (0, devkit_1.joinPathFragments)(normalizedOptions.rootDir),
-        tsConfig: (0, devkit_1.joinPathFragments)(normalizedOptions.tsConfig),
+        // Keep the Windows drive letter on rootDir/tsConfig (only forward-slash them).
+        // joinPathFragments strips it via normalizePath, leaving them drive-less while
+        // the generated path mappings stay absolute drive-full, so alias-resolved files
+        // fail TypeScript's rootDir containment check (TS6059) on Windows.
+        rootDir: normalizedOptions.rootDir.replace(/\\/g, '/'),
+        tsConfig: normalizedOptions.tsConfig.replace(/\\/g, '/'),
         watch: normalizedOptions.watch,
         deleteOutputPath: normalizedOptions.clean,
         getCustomTransformers: (0, lib_1.getCustomTrasformersFactory)(normalizedOptions.transformers),

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/js",
-  "version": "23.0.1",
+  "version": "23.0.2",
   "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.0.1",
-    "@nx/workspace": "23.0.1"
+    "@nx/devkit": "23.0.2",
+    "@nx/workspace": "23.0.2"
   },
   "devDependencies": {
-    "nx": "23.0.1"
+    "nx": "23.0.2"
   },
   "peerDependencies": {
     "@swc/cli": ">=0.6.0 <0.9.0",

package/dist/src/executors/node/lib/kill-tree.d.ts

@@ -1 +0,0 @@
-export declare function killTree(pid: number, signal: NodeJS.Signals): Promise<void>;

package/dist/src/executors/node/lib/kill-tree.js

@@ -1,113 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.killTree = killTree;
-// Adapted from https://raw.githubusercontent.com/pkrumins/node-tree-kill/deee138/index.js
-const child_process_1 = require("child_process");
-async function killTree(pid, signal) {
-    const tree = {};
-    const pidsToProcess = {};
-    tree[pid] = [];
-    pidsToProcess[pid] = 1;
-    return new Promise((resolve, reject) => {
-        const callback = (error) => {
-            if (error) {
-                reject(error);
-            }
-            else {
-                resolve();
-            }
-        };
-        switch (process.platform) {
-            case 'win32':
-                (0, child_process_1.exec)('taskkill /pid ' + pid + ' /T /F', {
-                    windowsHide: true,
-                }, (error) => {
-                    // Ignore Fatal errors (128) because it might be due to the process already being killed.
-                    // On Linux/Mac we can check ESRCH (no such process), but on Windows we can't.
-                    callback(error?.code !== 128 ? error : null);
-                });
-                break;
-            case 'darwin':
-                buildProcessTree(pid, tree, pidsToProcess, function (parentPid) {
-                    return (0, child_process_1.spawn)('pgrep', ['-P', parentPid], {
-                        windowsHide: true,
-                    });
-                }, function () {
-                    killAll(tree, signal, callback);
-                });
-                break;
-            default: // Linux
-                buildProcessTree(pid, tree, pidsToProcess, function (parentPid) {
-                    return (0, child_process_1.spawn)('ps', ['-o', 'pid', '--no-headers', '--ppid', parentPid], {
-                        windowsHide: true,
-                    });
-                }, function () {
-                    killAll(tree, signal, callback);
-                });
-                break;
-        }
-    });
-}
-function killAll(tree, signal, callback) {
-    const killed = {};
-    try {
-        Object.keys(tree).forEach(function (pid) {
-            tree[pid].forEach(function (pidpid) {
-                if (!killed[pidpid]) {
-                    killPid(pidpid, signal);
-                    killed[pidpid] = 1;
-                }
-            });
-            if (!killed[pid]) {
-                killPid(pid, signal);
-                killed[pid] = 1;
-            }
-        });
-    }
-    catch (err) {
-        if (callback) {
-            return callback(err);
-        }
-        else {
-            throw err;
-        }
-    }
-    if (callback) {
-        return callback();
-    }
-}
-function killPid(pid, signal) {
-    try {
-        process.kill(parseInt(pid, 10), signal);
-    }
-    catch (err) {
-        if (err.code !== 'ESRCH')
-            throw err;
-    }
-}
-function buildProcessTree(parentPid, tree, pidsToProcess, spawnChildProcessesList, cb) {
-    const ps = spawnChildProcessesList(parentPid);
-    let allData = '';
-    ps.stdout.on('data', (data) => {
-        data = data.toString('ascii');
-        allData += data;
-    });
-    const onClose = function (code) {
-        delete pidsToProcess[parentPid];
-        if (code != 0) {
-            // no more parent processes
-            if (Object.keys(pidsToProcess).length == 0) {
-                cb();
-            }
-            return;
-        }
-        allData.match(/\d+/g).forEach((_pid) => {
-            const pid = parseInt(_pid, 10);
-            tree[parentPid].push(pid);
-            tree[pid] = [];
-            pidsToProcess[pid] = 1;
-            buildProcessTree(pid, tree, pidsToProcess, spawnChildProcessesList, cb);
-        });
-    };
-    ps.on('close', onClose);
-}