@ohos-ports/nx 23.2.1-beta.0 → 23.3.0-beta.0

package/dist/src/project-graph/utils/project-configuration/target-merging.js

@@ -0,0 +1,574 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deepClone = deepClone;
+exports.resolveCommandSyntacticSugar = resolveCommandSyntacticSugar;
+exports.mergeMetadata = mergeMetadata;
+exports.mergeTargetConfigurations = mergeTargetConfigurations;
+exports.isCompatibleTarget = isCompatibleTarget;
+exports.resolveNxTokensInOptions = resolveNxTokensInOptions;
+const logger_1 = require("../../../utils/logger");
+const source_maps_1 = require("./source-maps");
+const utils_1 = require("./utils");
+function deepClone(obj) {
+    return structuredClone(obj);
+}
+function resolveCommandSyntacticSugar(target, key) {
+    const { command, ...config } = target ?? {};
+    if (!command) {
+        return target;
+    }
+    if (config.executor) {
+        throw new Error(`${logger_1.NX_PREFIX} Project at ${key} should not have executor and command both configured.`);
+    }
+    else {
+        return {
+            ...config,
+            executor: 'nx:run-commands',
+            options: {
+                ...config.options,
+                command: command,
+            },
+        };
+    }
+}
+function mergeMetadata(sourceMap, sourceInformation, baseSourceMapPath, metadata, matchingMetadata) {
+    const result = {
+        ...(matchingMetadata ?? {}),
+    };
+    for (const [metadataKey, value] of Object.entries(metadata)) {
+        const existingValue = matchingMetadata?.[metadataKey];
+        if (Array.isArray(value) && Array.isArray(existingValue)) {
+            const startIndex = result[metadataKey].length;
+            result[metadataKey].push(...value);
+            if (sourceMap) {
+                (0, source_maps_1.recordSourceMapKeysByIndex)(sourceMap, `${baseSourceMapPath}.${metadataKey}`, result[metadataKey], sourceInformation, startIndex);
+            }
+        }
+        else if (Array.isArray(value) && existingValue === undefined) {
+            result[metadataKey] ??= value;
+            if (sourceMap) {
+                sourceMap[`${baseSourceMapPath}.${metadataKey}`] = sourceInformation;
+                (0, source_maps_1.recordSourceMapKeysByIndex)(sourceMap, `${baseSourceMapPath}.${metadataKey}`, value, sourceInformation);
+            }
+        }
+        else if (typeof value === 'object' && typeof existingValue === 'object') {
+            for (const key in value) {
+                const existingValue = matchingMetadata?.[metadataKey]?.[key];
+                if (Array.isArray(value[key]) && Array.isArray(existingValue)) {
+                    const startIndex = result[metadataKey][key].length;
+                    result[metadataKey][key].push(...value[key]);
+                    if (sourceMap) {
+                        (0, source_maps_1.recordSourceMapKeysByIndex)(sourceMap, `${baseSourceMapPath}.${metadataKey}.${key}`, result[metadataKey][key], sourceInformation, startIndex);
+                    }
+                }
+                else {
+                    result[metadataKey][key] = value[key];
+                    if (sourceMap) {
+                        sourceMap[`${baseSourceMapPath}.${metadataKey}`] =
+                            sourceInformation;
+                    }
+                }
+            }
+        }
+        else {
+            result[metadataKey] = value;
+            if (sourceMap) {
+                sourceMap[`${baseSourceMapPath}.${metadataKey}`] = sourceInformation;
+                if (typeof value === 'object') {
+                    for (const k in value) {
+                        sourceMap[`${baseSourceMapPath}.${metadataKey}.${k}`] =
+                            sourceInformation;
+                        if (Array.isArray(value[k])) {
+                            (0, source_maps_1.recordSourceMapKeysByIndex)(sourceMap, `${baseSourceMapPath}.${metadataKey}.${k}`, value[k], sourceInformation);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return result;
+}
+function mergeOptions(newOptions, baseOptions, projectConfigSourceMap, sourceInformation, targetIdentifier, deferSpreadsWithoutBase) {
+    // `'...'` at the options level uses object-spread semantics.
+    if (newOptions?.[utils_1.NX_SPREAD_TOKEN] === true) {
+        return (0, utils_1.getMergeValueResult)(baseOptions, newOptions, projectConfigSourceMap
+            ? {
+                sourceMap: projectConfigSourceMap,
+                key: `${targetIdentifier}.options`,
+                sourceInformation,
+            }
+            : undefined, deferSpreadsWithoutBase);
+    }
+    const mergedOptionKeys = (0, utils_1.uniqueKeysInObjects)(baseOptions ?? {}, newOptions ?? {});
+    const mergedOptions = {};
+    for (const optionKey of mergedOptionKeys) {
+        mergedOptions[optionKey] = (0, utils_1.getMergeValueResult)(baseOptions ? baseOptions[optionKey] : undefined, newOptions ? newOptions[optionKey] : undefined, projectConfigSourceMap
+            ? {
+                sourceMap: projectConfigSourceMap,
+                key: `${targetIdentifier}.options.${optionKey}`,
+                sourceInformation,
+            }
+            : undefined, deferSpreadsWithoutBase);
+    }
+    return mergedOptions;
+}
+// Merges a single named configuration, keyed under its own identifier
+// (e.g. `targets.build.configurations.prod`) rather than under `.options`.
+// Source-map correctness for the spread case is handled inside
+// `getMergeValueResult`'s object-spread path — no post-merge fix-up needed.
+function mergeConfigurationValue(newConfig, baseConfig, projectConfigSourceMap, sourceInformation, configIdentifier, deferSpreadsWithoutBase) {
+    if (newConfig?.[utils_1.NX_SPREAD_TOKEN] === true) {
+        return (0, utils_1.getMergeValueResult)(baseConfig, newConfig, projectConfigSourceMap && configIdentifier
+            ? {
+                sourceMap: projectConfigSourceMap,
+                key: configIdentifier,
+                sourceInformation,
+            }
+            : undefined, deferSpreadsWithoutBase);
+    }
+    const mergedKeys = (0, utils_1.uniqueKeysInObjects)(baseConfig ?? {}, newConfig ?? {});
+    const merged = {};
+    for (const key of mergedKeys) {
+        merged[key] = (0, utils_1.getMergeValueResult)(baseConfig ? baseConfig[key] : undefined, newConfig ? newConfig[key] : undefined, projectConfigSourceMap && configIdentifier
+            ? {
+                sourceMap: projectConfigSourceMap,
+                key: `${configIdentifier}.${key}`,
+                sourceInformation,
+            }
+            : undefined, deferSpreadsWithoutBase);
+    }
+    return merged;
+}
+// `ultracache` keeps replace-unless-`'...'` semantics at the object level, but its
+// values still have to be merged per key: neither the wholesale replace nor
+// `mergeObjectWithSpread` recurses, so an `ignoredReads: ['...', 'tmp/**']`
+// would otherwise reach the task graph with `'...'` intact — a glob matching
+// nothing, silently dropping the inherited patterns.
+function mergeUltracache(newUltracache, baseUltracache, projectConfigSourceMap, sourceInformation, targetIdentifier, deferSpreadsWithoutBase) {
+    if (newUltracache === undefined) {
+        return baseUltracache;
+    }
+    const sourceMapContext = projectConfigSourceMap
+        ? {
+            sourceMap: projectConfigSourceMap,
+            key: `${targetIdentifier}.ultracache`,
+            sourceInformation,
+        }
+        : undefined;
+    // Object level first: this settles which keys survive, their order, and
+    // their source-map attribution.
+    const merged = (0, utils_1.getMergeValueResult)(baseUltracache, newUltracache, sourceMapContext, deferSpreadsWithoutBase);
+    if (!merged || typeof merged !== 'object' || Array.isArray(merged)) {
+        return merged;
+    }
+    // Copy before resolving: with no object-level spread `getMergeValueResult`
+    // returns `newUltracache` itself, and writing through it would edit the
+    // caller's target in place, corrupting later merge layers.
+    const resolved = { ...merged };
+    // Keys authored before `'...'` let the base win, exactly as they do at the
+    // target level. Re-resolving those would overwrite the object-level merge's
+    // decision and make authored position meaningless for array keys while
+    // still honouring it for scalar ones.
+    const authoredKeys = Object.keys(newUltracache);
+    const spreadPosition = authoredKeys.indexOf(utils_1.NX_SPREAD_TOKEN);
+    const keysBeforeSpread = spreadPosition >= 0
+        ? new Set(authoredKeys.slice(0, spreadPosition))
+        : new Set();
+    // Then re-resolve any key the target authored as an array, so a nested
+    // `'...'` expands against the inherited value rather than surviving as a
+    // literal element.
+    for (const key of Object.keys(resolved)) {
+        if (!Array.isArray(newUltracache[key]))
+            continue;
+        if (keysBeforeSpread.has(key) && baseUltracache && key in baseUltracache) {
+            continue;
+        }
+        resolved[key] = (0, utils_1.getMergeValueResult)(baseUltracache?.[key], newUltracache[key], projectConfigSourceMap
+            ? {
+                sourceMap: projectConfigSourceMap,
+                key: `${targetIdentifier}.ultracache.${key}`,
+                sourceInformation,
+            }
+            : undefined, deferSpreadsWithoutBase);
+    }
+    return resolved;
+}
+function mergeConfigurations(newConfigurations, baseConfigurations, projectConfigSourceMap, sourceInformation, targetIdentifier, deferSpreadsWithoutBase) {
+    const mergedConfigurations = {};
+    // Keys before '...' let base win for shared names; keys after '...'
+    // (or when there's no spread) merge normally with new winning.
+    const newKeys = Object.keys(newConfigurations ?? {});
+    const spreadPosInNew = newKeys.indexOf(utils_1.NX_SPREAD_TOKEN);
+    const hasSpread = spreadPosInNew >= 0;
+    const keysBeforeSpread = hasSpread
+        ? new Set(newKeys.slice(0, spreadPosInNew))
+        : new Set();
+    // Integer-like keys get hoisted to newKeys[0], making their position
+    // relative to '...' unrecoverable.
+    if (hasSpread && newKeys[0] && utils_1.INTEGER_LIKE_KEY_PATTERN.test(newKeys[0])) {
+        throw new utils_1.IntegerLikeSpreadKeyError(newKeys[0], targetIdentifier
+            ? `Configurations at "${targetIdentifier}.configurations"`
+            : 'Configurations');
+    }
+    // Preserving the unresolved `'...'` sentinel in authored position lets
+    // a later merge layer (which actually has a base) classify the keys as
+    // pre/post-spread correctly.
+    const preserveSpreadSentinel = hasSpread && deferSpreadsWithoutBase && baseConfigurations === undefined;
+    const processConfigName = (configName) => {
+        const configIdentifier = targetIdentifier
+            ? `${targetIdentifier}.configurations.${configName}`
+            : undefined;
+        const baseHasConfig = configName in (baseConfigurations ?? {});
+        const newHasConfig = !!newConfigurations && configName in newConfigurations;
+        if (hasSpread && keysBeforeSpread.has(configName)) {
+            // Before '...': base wins for shared names. Keep base's source-map
+            // entries when it owns the config.
+            if (baseHasConfig) {
+                // Base wins, so the incoming config is dropped without reaching
+                // `mergeConfigurationValue`. Validate its nested spread here so an
+                // integer-like-key ambiguity throws regardless of which side owns
+                // the config name (mirrors the base-independent target-level check).
+                (0, utils_1.assertNoIntegerLikeSpreadKey)(newConfigurations?.[configName], configIdentifier ? `Object at "${configIdentifier}"` : 'Object');
+                mergedConfigurations[configName] = baseConfigurations[configName];
+            }
+            else {
+                mergedConfigurations[configName] = mergeConfigurationValue(newConfigurations?.[configName], undefined, projectConfigSourceMap, sourceInformation, configIdentifier, deferSpreadsWithoutBase);
+                if (projectConfigSourceMap && configIdentifier) {
+                    projectConfigSourceMap[configIdentifier] = sourceInformation;
+                }
+            }
+            return;
+        }
+        mergedConfigurations[configName] = mergeConfigurationValue(newConfigurations?.[configName], baseConfigurations?.[configName], projectConfigSourceMap, sourceInformation, configIdentifier, deferSpreadsWithoutBase);
+        // Only reattribute the config name when the new plugin introduced it.
+        if (projectConfigSourceMap &&
+            configIdentifier &&
+            newHasConfig &&
+            !baseHasConfig) {
+            projectConfigSourceMap[configIdentifier] = sourceInformation;
+        }
+    };
+    if (hasSpread) {
+        // Authored positions of new's own keys relative to `'...'` drive
+        // pre/post-spread classification, so those keys go in authored order.
+        // Base-only keys land right before `'...'` — they weren't authored by
+        // the new layer, so default semantics places them with the pre-spread
+        // keys (the "base layer" slot).
+        const baseOnlyKeys = baseConfigurations
+            ? Object.keys(baseConfigurations).filter((k) => k !== utils_1.NX_SPREAD_TOKEN && !(k in (newConfigurations ?? {})))
+            : [];
+        let baseOnlyInserted = false;
+        const insertBaseOnlyKeys = () => {
+            if (baseOnlyInserted)
+                return;
+            baseOnlyInserted = true;
+            for (const configName of baseOnlyKeys)
+                processConfigName(configName);
+        };
+        for (const configName of newKeys) {
+            if (configName === utils_1.NX_SPREAD_TOKEN) {
+                insertBaseOnlyKeys();
+                if (preserveSpreadSentinel) {
+                    mergedConfigurations[utils_1.NX_SPREAD_TOKEN] =
+                        true;
+                }
+                continue;
+            }
+            processConfigName(configName);
+        }
+        insertBaseOnlyKeys();
+    }
+    else {
+        // No spread — classic `{ ...base, ...new }` ordering: base keys
+        // first, new-only keys after. Shared configs stay at base's position.
+        if (baseConfigurations) {
+            for (const configName of Object.keys(baseConfigurations)) {
+                if (configName === utils_1.NX_SPREAD_TOKEN)
+                    continue;
+                processConfigName(configName);
+            }
+        }
+        for (const configName of newKeys) {
+            if (configName === utils_1.NX_SPREAD_TOKEN)
+                continue;
+            if (configName in mergedConfigurations)
+                continue;
+            processConfigName(configName);
+        }
+    }
+    return mergedConfigurations;
+}
+/**
+ * Merges two targets.
+ *
+ * Most properties from `target` will overwrite any properties from `baseTarget`.
+ * Options and configurations are treated differently - they are merged together if the executor definition is compatible.
+ *
+ * @param target The target definition with higher priority
+ * @param baseTarget The target definition that should be overwritten. Can be undefined, in which case the target is returned as-is.
+ * @param projectConfigSourceMap The source map to be filled with metadata about where each property came from
+ * @param sourceInformation The metadata about where the new target was defined
+ * @param targetIdentifier The identifier for the target to merge, used for source map
+ * @param deferSpreadsWithoutBase Whether a `'...'` spread with no base value is preserved
+ * for a later merge layer to resolve (default), or expanded against the empty base and
+ * dropped. Pass `false` only for a final merge whose result is consumed directly rather
+ * than merged onto a lower-priority base.
+ * @returns A merged target configuration
+ */
+function mergeTargetConfigurations(target, baseTarget, projectConfigSourceMap, sourceInformation, targetIdentifier, deferSpreadsWithoutBase = true) {
+    const { configurations: defaultConfigurations, options: defaultOptions, ...baseTargetProperties } = baseTarget ?? {};
+    // Target is "compatible", e.g. executor is defined only once or is the same
+    // in both places. This means that it is likely safe to merge
+    const isCompatible = isCompatibleTarget(baseTarget ?? {}, target);
+    if (!isCompatible && projectConfigSourceMap) {
+        // if the target is not compatible, we will simply override the options
+        // we have to delete old entries from the source map
+        for (const key in projectConfigSourceMap) {
+            if (key.startsWith(`${targetIdentifier}`)) {
+                delete projectConfigSourceMap[key];
+            }
+        }
+    }
+    // merge top level properties if they're compatible
+    const result = {};
+    const mergeBase = isCompatible ? baseTargetProperties : {};
+    // Keys before '...' let base win; keys after '...' (or when there's no
+    // spread) merge normally with target winning.
+    const targetKeys = Object.keys(target);
+    const spreadPosInTarget = targetKeys.indexOf(utils_1.NX_SPREAD_TOKEN);
+    const hasSpread = isCompatible && spreadPosInTarget >= 0;
+    const keysBeforeSpread = hasSpread
+        ? new Set(targetKeys.slice(0, spreadPosInTarget))
+        : new Set();
+    // Integer-like keys get hoisted to targetKeys[0], making their position
+    // relative to '...' unrecoverable. This is a property of the authored
+    // config, not of the base, so it throws regardless of compatibility —
+    // which also keeps the error identical between the target-defaults staging
+    // merge and the real merge, whose bases differ.
+    if (spreadPosInTarget >= 0 &&
+        targetKeys[0] &&
+        utils_1.INTEGER_LIKE_KEY_PATTERN.test(targetKeys[0])) {
+        throw new utils_1.IntegerLikeSpreadKeyError(targetKeys[0], targetIdentifier ? `Target at "${targetIdentifier}"` : 'Target');
+    }
+    // Preserving the unresolved `'...'` sentinel in authored position lets a
+    // later merge layer (which actually has a base) classify sibling keys as
+    // pre/post-spread correctly.
+    const preserveSpreadSentinel = spreadPosInTarget >= 0 &&
+        deferSpreadsWithoutBase &&
+        baseTarget === undefined;
+    const skipForOwnMerge = new Set([
+        'options',
+        'configurations',
+        'ultracache',
+        utils_1.NX_SPREAD_TOKEN,
+    ]);
+    const processKey = (key) => {
+        if (skipForOwnMerge.has(key))
+            return;
+        if (hasSpread && keysBeforeSpread.has(key)) {
+            // Before '...': base wins; fall through to target only if base lacks it.
+            // When base wins, the incoming `target[key]` is dropped without ever
+            // reaching `getMergeValueResult`, so validate its nested spread here —
+            // the integer-like-key ambiguity is a property of the authored value,
+            // not of which side owns the key, and must throw either way.
+            (0, utils_1.assertNoIntegerLikeSpreadKey)(target[key], projectConfigSourceMap
+                ? `Object at "${targetIdentifier}.${key}"`
+                : 'Object');
+            result[key] =
+                key in mergeBase
+                    ? mergeBase[key]
+                    : (0, utils_1.getMergeValueResult)(undefined, target[key], projectConfigSourceMap
+                        ? {
+                            sourceMap: projectConfigSourceMap,
+                            key: `${targetIdentifier}.${key}`,
+                            sourceInformation,
+                        }
+                        : undefined, deferSpreadsWithoutBase);
+            return;
+        }
+        if (key in target) {
+            result[key] = (0, utils_1.getMergeValueResult)(mergeBase[key], target[key], projectConfigSourceMap
+                ? {
+                    sourceMap: projectConfigSourceMap,
+                    key: `${targetIdentifier}.${key}`,
+                    sourceInformation,
+                }
+                : undefined, deferSpreadsWithoutBase);
+        }
+        else {
+            result[key] = mergeBase[key];
+        }
+    };
+    if (isCompatible) {
+        if (hasSpread) {
+            // Authored positions of the target's own keys relative to `'...'`
+            // drive pre/post-spread classification, so those keys go in
+            // authored order. Base-only keys land right before `'...'` — they
+            // weren't authored, so default semantics ("base layer that yields
+            // to a higher-priority layer") places them with the rest of the
+            // pre-spread keys.
+            const baseOnlyKeys = Object.keys(baseTargetProperties).filter((k) => !skipForOwnMerge.has(k) && !(k in target));
+            let baseOnlyInserted = false;
+            const insertBaseOnlyKeys = () => {
+                if (baseOnlyInserted)
+                    return;
+                baseOnlyInserted = true;
+                for (const key of baseOnlyKeys)
+                    processKey(key);
+            };
+            for (const key of targetKeys) {
+                if (key === utils_1.NX_SPREAD_TOKEN) {
+                    insertBaseOnlyKeys();
+                    if (preserveSpreadSentinel) {
+                        result[utils_1.NX_SPREAD_TOKEN] = true;
+                    }
+                    continue;
+                }
+                if (skipForOwnMerge.has(key))
+                    continue;
+                processKey(key);
+            }
+            // Safety for a sentinel-less iteration (shouldn't happen when
+            // hasSpread is true, but keeps the base-only keys emitted).
+            insertBaseOnlyKeys();
+        }
+        else {
+            // No spread — classic `{ ...base, ...target }` ordering: base keys
+            // first (preserving their own-key order), target-only keys after.
+            // Shared keys stay at base's position with per-key merged value.
+            const mergedKeys = (0, utils_1.uniqueKeysInObjects)(baseTargetProperties, target);
+            for (const key of mergedKeys) {
+                if (skipForOwnMerge.has(key))
+                    continue;
+                processKey(key);
+            }
+        }
+    }
+    else {
+        for (const key of targetKeys) {
+            if (skipForOwnMerge.has(key))
+                continue;
+            processKey(key);
+        }
+    }
+    // Update the node key once after the loop. Ownership follows identity: this
+    // merge claims `targets.<name>` only when it changed the target's identity
+    // (a new/different executor or command, or an incompatible replace — whose
+    // key purge above empties the slot anyway). A plugin that only layers fields
+    // onto an existing target leaves the node with its creator; weak
+    // target-defaults stamps are always reclaimable.
+    if (projectConfigSourceMap) {
+        const identityChanged = !isCompatible ||
+            (target.executor !== undefined &&
+                target.executor !== baseTarget?.executor) ||
+            (target.command !== undefined &&
+                target.command !== baseTarget?.command) ||
+            suppliesNewOptionsIdentity(baseTarget, target);
+        (0, source_maps_1.recordTargetIdentitySourceMapInfo)(projectConfigSourceMap, targetIdentifier, sourceInformation, identityChanged);
+    }
+    // merge options if there are any
+    // if the targets aren't compatible, we simply discard the old options during the merge
+    if (target.options || defaultOptions) {
+        result.options = mergeOptions(target.options, isCompatible ? defaultOptions : undefined, projectConfigSourceMap, sourceInformation, targetIdentifier, deferSpreadsWithoutBase);
+        if (projectConfigSourceMap && target.options) {
+            projectConfigSourceMap[`${targetIdentifier}.options`] = sourceInformation;
+        }
+    }
+    // merge configurations if there are any
+    // if the targets aren't compatible, we simply discard the old configurations during the merge
+    if (target.configurations || defaultConfigurations) {
+        result.configurations = mergeConfigurations(target.configurations, isCompatible ? defaultConfigurations : undefined, projectConfigSourceMap, sourceInformation, targetIdentifier, deferSpreadsWithoutBase);
+        if (projectConfigSourceMap && target.configurations) {
+            projectConfigSourceMap[`${targetIdentifier}.configurations`] =
+                sourceInformation;
+        }
+    }
+    // merge ultracache if either side declares one
+    // as with options, an incompatible target discards the base.
+    // `ultracache` is in `skipForOwnMerge` so the key-by-key pass leaves it to
+    // this block; removing it from that set would change only the key's position
+    // in the result, since this overwrites whatever the generic pass produced.
+    if ('ultracache' in target ||
+        (isCompatible && baseTarget && 'ultracache' in baseTarget)) {
+        const mergedUltracache = mergeUltracache(target.ultracache, isCompatible ? baseTarget?.ultracache : undefined, projectConfigSourceMap, sourceInformation, targetIdentifier, deferSpreadsWithoutBase);
+        if (mergedUltracache !== undefined) {
+            result.ultracache = mergedUltracache;
+        }
+    }
+    if (target.metadata) {
+        result.metadata = mergeMetadata(projectConfigSourceMap, sourceInformation, `${targetIdentifier}.metadata`, target.metadata, baseTarget?.metadata);
+    }
+    return result;
+}
+/**
+ * Checks if targets options are compatible - used when merging configurations
+ * to avoid merging options for @nx/js:tsc into something like @nx/webpack:webpack.
+ *
+ * If the executors are both specified and don't match, the options aren't considered
+ * "compatible" and shouldn't be merged.
+ */
+function isCompatibleTarget(a, b) {
+    const oneHasNoExecutor = !a.executor || !b.executor;
+    const bothHaveSameExecutor = a.executor === b.executor;
+    if (oneHasNoExecutor)
+        return true;
+    if (!bothHaveSameExecutor)
+        return false;
+    const isRunCommands = a.executor === 'nx:run-commands';
+    if (isRunCommands) {
+        const aCommand = a.options?.command ?? a.options?.commands?.join(' && ');
+        const bCommand = b.options?.command ?? b.options?.commands?.join(' && ');
+        const oneHasNoCommand = !aCommand || !bCommand;
+        const hasSameCommand = aCommand === bCommand;
+        return oneHasNoCommand || hasSameCommand;
+    }
+    const isRunScript = a.executor === 'nx:run-script';
+    if (isRunScript) {
+        const aScript = a.options?.script;
+        const bScript = b.options?.script;
+        const oneHasNoScript = !aScript || !bScript;
+        const hasSameScript = aScript === bScript;
+        return oneHasNoScript || hasSameScript;
+    }
+    return true;
+}
+/**
+ * Run-commands and run-script targets carry their runnable identity in
+ * `options` (see {@link isCompatibleTarget}). A layer that supplies that
+ * identity where the base had none changed what the target runs — the same
+ * identity change as setting an executor on a target that had none.
+ */
+function suppliesNewOptionsIdentity(baseTarget, target) {
+    const executor = target.executor ?? baseTarget?.executor;
+    if (executor === 'nx:run-commands') {
+        const baseCommand = baseTarget?.options?.command ??
+            baseTarget?.options?.commands?.join(' && ');
+        const targetCommand = target.options?.command ?? target.options?.commands?.join(' && ');
+        return !!targetCommand && targetCommand !== baseCommand;
+    }
+    if (executor === 'nx:run-script') {
+        const targetScript = target.options?.script;
+        return !!targetScript && targetScript !== baseTarget?.options?.script;
+    }
+    return false;
+}
+function resolveNxTokensInOptions(object, project, key) {
+    const result = Array.isArray(object) ? [...object] : { ...object };
+    for (let [opt, value] of Object.entries(object ?? {})) {
+        if (typeof value === 'string') {
+            const workspaceRootMatch = /^(\{workspaceRoot\}\/?)/.exec(value);
+            if (workspaceRootMatch?.length) {
+                value = value.replace(workspaceRootMatch[0], '');
+            }
+            if (value.includes('{workspaceRoot}')) {
+                throw new Error(`${logger_1.NX_PREFIX} The {workspaceRoot} token is only valid at the beginning of an option. (${key})`);
+            }
+            value = value.replace(/\{projectRoot\}/g, project.root);
+            result[opt] = value.replace(/\{projectName\}/g, project.name);
+        }
+        else if (typeof value === 'object' && value) {
+            result[opt] = resolveNxTokensInOptions(value, project, [key, opt].join('.'));
+        }
+    }
+    return result;
+}

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

@@ -0,0 +1,12 @@
+import { NxJsonConfiguration } from '../../../config/nx-json';
+import { ProjectConfiguration, TargetConfiguration } from '../../../config/workspace-json-project-json';
+import type { ConfigurationSourceMaps } from './source-maps';
+export declare function validateProject(project: ProjectConfiguration, knownProjects: Record<string, ProjectConfiguration>): void;
+/**
+ * Expand's `command` syntactic sugar, replaces tokens in options, and adds information from executor schema.
+ * @param target The target to normalize
+ * @param project The project that the target belongs to
+ * @returns The normalized target configuration
+ */
+export declare function normalizeTarget(target: TargetConfiguration, project: ProjectConfiguration, workspaceRoot: string, projectsMap: Record<string, ProjectConfiguration>, errorMsgKey: string): TargetConfiguration<any>;
+export declare function validateAndNormalizeProjectRootMap(workspaceRoot: string, projectRootMap: Record<string, ProjectConfiguration>, nxJsonConfiguration: NxJsonConfiguration, sourceMaps?: ConfigurationSourceMaps): Record<string, ProjectConfiguration>;