nx 23.0.0-beta.2 → 23.0.0-beta.21

package/dist/src/project-graph/plugins/utils.js

@@ -3,22 +3,28 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createNodesFromFiles = createNodesFromFiles;
 const error_types_1 = require("../error-types");
 async function createNodesFromFiles(createNodes, configFiles, options, context) {
-    const results = [];
-    const errors = [];
-    await Promise.all(configFiles.map(async (file, idx) => {
+    const settled = await Promise.all(configFiles.map(async (file, idx) => {
         try {
             const value = await createNodes(file, options, {
                 ...context,
                 configFiles,
             }, idx);
-            if (value) {
-                results.push([file, value]);
-            }
+            return value ? { kind: 'value', file, value } : { kind: 'empty' };
         }
         catch (e) {
-            errors.push([file, e]);
+            return { kind: 'error', file, error: e };
         }
     }));
+    const results = [];
+    const errors = [];
+    for (const entry of settled) {
+        if (entry.kind === 'value') {
+            results.push([entry.file, entry.value]);
+        }
+        else if (entry.kind === 'error') {
+            errors.push([entry.file, entry.error]);
+        }
+    }
     if (errors.length > 0) {
         throw new error_types_1.AggregateCreateNodesError(errors, results);
     }

package/dist/src/project-graph/project-graph.js

@@ -88,7 +88,7 @@ async function buildProjectGraphAndSourceMapsWithoutDaemon() {
     perf_hooks_1.performance.mark('retrieve-project-configurations:start');
     let configurationResult;
     let projectConfigurationsError;
-    const separatedPlugins = await (0, get_plugins_1.getPluginsSeparated)();
+    const separatedPlugins = await (0, get_plugins_1.getPluginsSeparated)(nxJson);
     const plugins = separatedPlugins.specifiedPlugins.concat(separatedPlugins.defaultPlugins);
     try {
         configurationResult = await (0, retrieve_workspace_files_1.retrieveProjectConfigurations)(separatedPlugins, workspace_root_1.workspaceRoot, nxJson);

package/dist/src/project-graph/utils/project-configuration/target-defaults.d.ts

@@ -1,6 +1,8 @@
-import { NxJsonConfiguration, TargetDefaults } from '../../../config/nx-json';
-import { ProjectConfiguration } from '../../../config/workspace-json-project-json';
+import { NormalizedTargetDefaults, NxJsonConfiguration, TargetDefaults } from '../../../config/nx-json';
+import { ProjectConfiguration, TargetConfiguration } from '../../../config/workspace-json-project-json';
+import type { ProjectGraphProjectNode } from '../../../config/project-graph';
 import type { CreateNodesResult } from '../../plugins/public-api';
+import { ConfigurationSourceMaps } from './source-maps';
 type CreateNodesResultEntry = readonly [
     plugin: string,
     file: string,
@@ -10,7 +12,96 @@ type CreateNodesResultEntry = readonly [
 /**
  * Builds a synthetic plugin result from nx.json's `targetDefaults`, layered
  * between specified-plugin and default-plugin results during merging.
+ *
+ * Synthesis sees the two layers separately to avoid re-merging specified
+ * results into a parallel rootMap — for each (root, target) where both
+ * layers contribute, it computes the eventual executor/command on the
+ * fly. That's all the matcher needs; the full target merge happens
+ * downstream in the real merge.
  */
-export declare function createTargetDefaultsResults(specifiedPluginRootMap: Record<string, ProjectConfiguration>, defaultPluginRootMap: Record<string, ProjectConfiguration>, nxJsonConfiguration: NxJsonConfiguration): CreateNodesResultEntry[];
-export declare function readTargetDefaultsForTarget(targetName: string, targetDefaults: TargetDefaults, executor?: string): TargetDefaults[string];
+export declare function createTargetDefaultsResults(specifiedPluginRootMap: Record<string, ProjectConfiguration>, defaultPluginRootMap: Record<string, ProjectConfiguration>, nxJsonConfiguration: NxJsonConfiguration, specifiedSourceMaps?: ConfigurationSourceMaps, defaultSourceMaps?: ConfigurationSourceMaps): CreateNodesResultEntry[];
+/**
+ * Public, backwards-compatible reader that looks up the most-specific
+ * target default for a given target. Accepts either the new array shape
+ * or the legacy record shape (devkit support).
+ *
+ * When called without project context, entries that require a `projects`
+ * filter or a `plugin` filter are skipped.
+ *
+ * The normalized entries are cached per `targetDefaults` reference so
+ * repeated reads against the same nx.json don't re-normalize (and don't
+ * re-fire the legacy-record-shape warning).
+ */
+export declare function readTargetDefaultsForTarget(targetName: string, targetDefaults: TargetDefaults | undefined, executor?: string, opts?: {
+    projectName?: string;
+    projectNode?: ProjectGraphProjectNode;
+    sourcePlugin?: string;
+    command?: string;
+}): Partial<TargetConfiguration> | null;
+/**
+ * Find the highest-specificity `targetDefaults` entry that applies to the
+ * given (target, project, sourcePlugin) tuple. Ties are broken by match
+ * kind, then by later array index. Returns the config slice with filter
+ * keys (`target`, `projects`, `plugin`) stripped.
+ *
+ * Tier = (1 if a target/executor locator matched, else 0) + 1 per
+ * applied filter (`projects`, `plugin`). So locator-bearing entries:
+ *   - tier 3: target/executor + projects + plugin
+ *   - tier 2: target/executor + projects, or target/executor + plugin
+ *   - tier 1: target/executor alone
+ * And filter-only entries (no `target` and no `executor`):
+ *   - tier 2: projects + plugin
+ *   - tier 1: projects alone, or plugin alone
+ *
+ * `executor` matching contributes to matchKind only, not to tier — it's
+ * not a filter, it's a refinement of the match. Within the same tier,
+ * tie-break order (highest first):
+ *   targetAndExecutor > executorOnly > exactTarget > globTarget > filterOnly
+ *
+ * `filterOnly` ranks below every locator-bearing kind, so a filter-only
+ * entry can never tie-break ahead of one that names a target or executor
+ * at the same tier.
+ *
+ * `executor` only acts as an "injector" (matches a target with neither
+ * executor nor command) when the entry also sets `target`. Executor-only
+ * entries require the workspace target to actually have an executor.
+ *
+ * When `predicate` is provided, ranked candidates are iterated and the
+ * first one that satisfies the predicate is returned. This lets synthesis
+ * fall back to a less-specific compatible default when the most-specific
+ * match would be incompatible with the target it's being applied to.
+ * Without a predicate, the highest-ranked candidate is returned directly.
+ */
+export declare function findBestTargetDefault(targetName: string, executor: string | undefined, projectName: string | undefined, projectNode: (Pick<ProjectGraphProjectNode, 'name'> & {
+    data: Pick<ProjectConfiguration, 'root' | 'tags'>;
+}) | undefined, sourcePlugin: string | undefined, entries: NormalizedTargetDefaults, targetCommand?: string | undefined, predicate?: (config: Partial<TargetConfiguration>) => boolean): Partial<TargetConfiguration> | null;
+/**
+ * Accept either the new array shape or the legacy record shape and return
+ * a normalized array. Record entries become `{ target: key, ...value }`
+ * — except executor-shaped keys (e.g. `@nx/vite:test`, `nx:run-commands`)
+ * which become `{ executor: key, ...value }` so the matcher treats them
+ * as executor matches rather than target-name matches.
+ *
+ * Disambiguation here is purely syntactic — `:` in a record key is
+ * genuinely ambiguous (target names can contain `:`). Callers that have
+ * access to the workspace's targets (the graph-construction path, the
+ * v23 migration) should prefer
+ * {@link normalizeTargetDefaultsAgainstRootMaps} or the migration's
+ * graph-based classifier so that ambiguous keys get classified by what
+ * the workspace actually contains. The warning below points end-users
+ * at `nx repair`, which runs the migration that durably resolves the
+ * ambiguity in nx.json on disk.
+ */
+export declare function normalizeTargetDefaults(raw: TargetDefaults | undefined): NormalizedTargetDefaults;
+/**
+ * Same shape contract as {@link normalizeTargetDefaults}, but classifies
+ * `:`-shaped record keys against the targets and executors actually
+ * present in the supplied rootMaps. When a key matches a target name in
+ * the workspace, it becomes a `target:` entry; when it matches an
+ * executor, an `executor:` entry; when it matches both, both entries are
+ * emitted (matching the v23 migration's "duplicate rather than guess"
+ * behavior so neither side of the match silently drops). Falls back to
+ * the syntactic heuristic when there's no evidence either way.
+ */
+export declare function normalizeTargetDefaultsAgainstRootMaps(raw: TargetDefaults | undefined, ...rootMaps: Record<string, ProjectConfiguration>[]): NormalizedTargetDefaults;
 export {};