@nx/js 23.2.1 → 23.3.0-beta.1

package/dist/src/executors/release-publish/release-publish.impl.js

@@ -171,7 +171,10 @@ Please update the local dependency on "${depName}" to be a valid semantic versio
                 stdio: ['ignore', 'pipe', 'pipe'],
                 windowsHide: true,
             });
-            const resultJson = JSON.parse(result.toString());
+            // `npm view`/`bun info` can exit 0 with empty stdout when the package exists in the registry but has
+            // no published versions or dist-tags yet (e.g. GitHub packages). Treat empty output the samme as
+            // package not existing yet and continue to the publish step.
+            const resultJson = JSON.parse(result.toString().trim() || '{}');
             const distTags = resultJson['dist-tags'] || {};
             if (distTags[tag] === currentVersion) {
                 console.warn(`Skipped ${packageTxt} because v${currentVersion} already exists in ${registry} with tag "${tag}"`);

package/dist/src/plugins/typescript/plugin.js

@@ -125,6 +125,7 @@ exports.createNodesV2 = [
             configOwners: new Map(),
             projectContexts: new Map(),
             configContexts: new Map(),
+            referenceExpansionCache: new Map(),
         });
         const cache = cacheStore.get(cacheKey);
         initializeTsConfigCache(configFilePaths, context.workspaceRoot, cache);
@@ -701,62 +702,100 @@ function getExternalProjectReferenceTsconfigPatterns(tsConfig, internalProjectRe
             continue;
         }
         visited.add(configPath);
-        const wsRelPath = posixRelative(workspaceRoot, configPath);
-        const tsConfigData = tsConfigCacheData[wsRelPath]?.data;
-        if (!tsConfigData) {
-            continue;
+        const expansion = getReferenceExpansion(configPath, ownerProject, workspaceRoot, cache);
+        // Extended-config patterns follow the traversal's first-visit semantics.
+        for (const extended of expansion.extendedConfigs) {
+            if (visited.has(extended.configPath)) {
+                continue;
+            }
+            uniqueRelPaths.add(extended.pattern);
+            worklist.push({
+                configPath: extended.configPath,
+                ownerProject: extended.ownerProject,
+            });
+        }
+        // Reference patterns are collected even when traversal already visited them.
+        for (const ref of expansion.projectReferences) {
+            if (ref.pattern !== undefined) {
+                uniqueRelPaths.add(ref.pattern);
+            }
+            if (!visited.has(ref.configPath)) {
+                worklist.push({
+                    configPath: ref.configPath,
+                    ownerProject: ref.ownerProject,
+                });
+            }
         }
+    }
+    return Array.from(uniqueRelPaths).map((relPath) => `^{projectRoot}/${relPath}`);
+}
+/**
+ * Returns a config's immediate `extends` and project-reference expansion for
+ * the current owner, caching it for reuse within this invocation. Transitive
+ * traversal, ordering, and visited checks remain with the caller.
+ */
+function getReferenceExpansion(configPath, ownerProject, workspaceRoot, cache) {
+    const configKey = posixRelative(workspaceRoot, configPath);
+    // Reference classification and relative patterns depend on the owner.
+    const ownerKey = ownerProject.normalized;
+    let ownerCache = cache.referenceExpansionCache.get(configKey);
+    const cached = ownerCache?.get(ownerKey);
+    if (cached) {
+        return cached;
+    }
+    const expansion = {
+        extendedConfigs: [],
+        projectReferences: [],
+    };
+    const tsConfigData = tsConfigCacheData[configKey]?.data;
+    if (tsConfigData) {
         // Walk `extends` chains for the visited tsconfig. tsc reads extended
         // configs while resolving project references, so the rel paths must be
         // emitted as inputs. Workspace-root files (no owning project) are skipped
         // — those are covered by the local project's own extends walk.
-        if (tsConfigData.extendedConfigFiles?.length) {
-            for (const extended of tsConfigData.extendedConfigFiles) {
-                if (!extended.filePath || visited.has(extended.filePath)) {
-                    continue;
-                }
-                const extendedWsRelPath = posixRelative(workspaceRoot, extended.filePath);
-                if (!tsConfigCacheData[extendedWsRelPath]) {
-                    continue;
-                }
-                const extendedContext = getConfigContext(extended.filePath, workspaceRoot, cache);
-                if (extendedContext.project.root &&
-                    extendedContext.project.root !== '.') {
-                    uniqueRelPaths.add(posixRelative(extendedContext.project.absolute, extended.filePath));
-                    worklist.push({
-                        configPath: extended.filePath,
-                        ownerProject: extendedContext.project,
-                    });
-                }
+        for (const extended of tsConfigData.extendedConfigFiles ?? []) {
+            if (!extended.filePath) {
+                continue;
+            }
+            const extendedWsRelPath = posixRelative(workspaceRoot, extended.filePath);
+            if (!tsConfigCacheData[extendedWsRelPath]) {
+                continue;
+            }
+            const extendedContext = getConfigContext(extended.filePath, workspaceRoot, cache);
+            if (extendedContext.project.root &&
+                extendedContext.project.root !== '.') {
+                expansion.extendedConfigs.push({
+                    configPath: extended.filePath,
+                    ownerProject: extendedContext.project,
+                    pattern: posixRelative(extendedContext.project.absolute, extended.filePath),
+                });
             }
         }
-        if (!tsConfigData.projectReferences?.length) {
-            continue;
-        }
-        for (const ref of tsConfigData.projectReferences) {
+        for (const ref of tsConfigData.projectReferences ?? []) {
             let refPath = ref.path;
             if (!refPath.endsWith('.json')) {
                 refPath = (0, node_path_1.join)(refPath, 'tsconfig.json');
             }
-            // Skip references not found in the tsconfig cache
+            // References absent from the invocation's tsconfig data remain ignored.
             const refWsRelPath = posixRelative(workspaceRoot, refPath);
             if (!tsConfigCacheData[refWsRelPath]) {
                 continue;
             }
             const refContext = getConfigContext(refPath, workspaceRoot, cache);
-            // Collect paths for references within the same project
-            if (!isExternalProjectReference(refContext, ownerProject, workspaceRoot, cache)) {
-                uniqueRelPaths.add(posixRelative(ownerProject.absolute, refPath));
-            }
-            if (!visited.has(refPath)) {
-                worklist.push({
-                    configPath: refPath,
-                    ownerProject: refContext.project,
-                });
-            }
+            expansion.projectReferences.push({
+                configPath: refPath,
+                ownerProject: refContext.project,
+                // Only references owned by this project contribute input patterns.
+                pattern: isExternalProjectReference(refContext, ownerProject, workspaceRoot, cache)
+                    ? undefined
+                    : posixRelative(ownerProject.absolute, refPath),
+            });
         }
     }
-    return Array.from(uniqueRelPaths).map((relPath) => `^{projectRoot}/${relPath}`);
+    ownerCache ??= new Map();
+    ownerCache.set(ownerKey, expansion);
+    cache.referenceExpansionCache.set(configKey, ownerCache);
+    return expansion;
 }
 function isExternalProjectReference(refConfig, project, workspaceRoot, cache) {
     const owner = cache.configOwners.get(refConfig.relativePath);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/js",
-  "version": "23.2.1",
+  "version": "23.3.0-beta.1",
   "private": false,
   "type": "commonjs",
   "files": [
@@ -147,18 +147,18 @@
     "source-map-support": "0.5.19",
     "tinyglobby": "^0.2.12",
     "tslib": "^2.3.0",
-    "@nx/devkit": "23.2.1",
-    "@nx/workspace": "23.2.1"
+    "@nx/devkit": "23.3.0-beta.1",
+    "@nx/workspace": "23.3.0-beta.1"
   },
   "devDependencies": {
-    "@nx/eslint": "23.2.1",
-    "@nx/esbuild": "23.2.1",
-    "@nx/jest": "23.2.1",
-    "@nx/oxlint": "23.2.1",
-    "@nx/rollup": "23.2.1",
-    "@nx/vite": "23.2.1",
-    "@nx/vitest": "23.2.1",
-    "nx": "23.2.1"
+    "@nx/jest": "23.3.0-beta.1",
+    "@nx/esbuild": "23.3.0-beta.1",
+    "@nx/eslint": "23.3.0-beta.1",
+    "@nx/oxlint": "23.3.0-beta.1",
+    "@nx/rollup": "23.3.0-beta.1",
+    "@nx/vite": "23.3.0-beta.1",
+    "@nx/vitest": "23.3.0-beta.1",
+    "nx": "23.3.0-beta.1"
   },
   "peerDependencies": {
     "@swc/cli": ">=0.6.0 <0.9.0",