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

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

@@ -0,0 +1,396 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateProject = validateProject;
+exports.normalizeTarget = normalizeTarget;
+exports.validateAndNormalizeProjectRootMap = validateAndNormalizeProjectRootMap;
+const executor_utils_1 = require("../../../command-line/run/executor-utils");
+const fileutils_1 = require("../../../utils/fileutils");
+const long_running_target_1 = require("../../../utils/long-running-target");
+const output_1 = require("../../../utils/output");
+const to_project_name_1 = require("../../../config/to-project-name");
+const error_types_1 = require("../../error-types");
+const target_merging_1 = require("./target-merging");
+const utils_1 = require("./utils");
+const node_fs_1 = require("node:fs");
+const git_worktrees_1 = require("../../../utils/git-worktrees");
+const path_1 = require("path");
+function validateProject(project, 
+// name -> project
+knownProjects) {
+    if (!project.name) {
+        try {
+            const { name } = (0, fileutils_1.readJsonFile)((0, path_1.join)(project.root, 'package.json'));
+            if (!name) {
+                throw new Error(`Project at ${project.root} has no name provided.`);
+            }
+            project.name = name;
+        }
+        catch {
+            throw new error_types_1.ProjectWithNoNameError(project.root);
+        }
+    }
+    else if (knownProjects[project.name] &&
+        knownProjects[project.name].root !== project.root) {
+        throw new error_types_1.ProjectWithExistingNameError(project.name, project.root);
+    }
+}
+/**
+ * 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
+ */
+function normalizeTarget(target, project, workspaceRoot, projectsMap, errorMsgKey) {
+    target = {
+        ...target,
+        configurations: {
+            ...target.configurations,
+        },
+    };
+    target = (0, target_merging_1.resolveCommandSyntacticSugar)(target, project.root);
+    target.options = (0, target_merging_1.resolveNxTokensInOptions)(target.options, project, errorMsgKey);
+    for (const configuration in target.configurations) {
+        target.configurations[configuration] = (0, target_merging_1.resolveNxTokensInOptions)(target.configurations[configuration], project, `${project.root}:${target}:${configuration}`);
+    }
+    target.parallelism ??= true;
+    if (target.executor && !('continuous' in target)) {
+        try {
+            const [executorNodeModule, executorName] = (0, executor_utils_1.parseExecutor)(target.executor);
+            const { schema } = (0, executor_utils_1.getExecutorInformation)(executorNodeModule, executorName, workspaceRoot, projectsMap);
+            if (schema.continuous) {
+                target.continuous ??= schema.continuous;
+            }
+        }
+        catch (e) {
+            // If the executor is not found, we assume that it is not a valid executor.
+            // This means that we should not set the continuous property.
+            // We could throw an error here, but it would be better to just ignore it.
+        }
+    }
+    return target;
+}
+// TODO(v24): remove the legacy target-name cache fallback and its warning.
+// Removal needs a second mechanism for plugin-inferred targets, which the
+// accompanying migration cannot reach.
+/**
+ * Whether `target` is cacheable only by way of the legacy name-based fallback:
+ * the exact target-name key of `targetDefaults` declares `cache: true`, but an
+ * executor key won target-default resolution instead, so the merged target never
+ * received it.
+ *
+ * A `true` result means the user's `cache: true` silently lost, so this doubles
+ * as the condition for warning them that the name key is being shadowed.
+ */
+function isLegacyCachedTarget(targetName, targetDefaults, target) {
+    // Resolution already decided `cache`, so the name key isn't shadowed.
+    if (target.cache !== undefined) {
+        return false;
+    }
+    if (isLongRunningTarget(targetName, target)) {
+        return false;
+    }
+    // Restricted to shadowing, which is narrower than what pre-23 restored: that
+    // derivation matched on target name alone, so a name key dropped as
+    // incompatible (its entry declared a foreign executor) was cacheable too.
+    // Restoring that as well would mean writing `cache` with no key to name in
+    // the warning, and no migration able to retire it. Deliberately not covered.
+    if (!findShadowingTargetDefaultKey(targetDefaults, target)) {
+        return false;
+    }
+    return declaresCacheTrue(targetDefaults?.[targetName]);
+}
+/**
+ * Whether the name key declares `cache: true` on an entry that always applies.
+ *
+ * Filters are deliberately not evaluated. They cannot express a pre-23 config
+ * (the filtered array shape postdates the behavior being restored), and a
+ * filtered entry declaring `cache` may or may not apply to this project — so
+ * rather than guess, a filtered `cache` declares the value unknowable and
+ * nothing is restored. Among unfiltered entries the last wins, matching the
+ * in-key merge order.
+ */
+function declaresCacheTrue(value) {
+    if (!value) {
+        return false;
+    }
+    const entries = Array.isArray(value) ? value : [value];
+    let declared;
+    for (const entry of entries) {
+        // `nx.json` is hand-edited; a null or scalar entry would throw here.
+        if (!entry || typeof entry !== 'object')
+            continue;
+        if (entry.cache === undefined)
+            continue;
+        if (entry.filter)
+            return false;
+        declared = entry.cache;
+    }
+    return declared === true;
+}
+/**
+ * The normalization-time half of the pre-23 `longRunningTask` guard, which kept
+ * `cacheableOperations` from ever making these cacheable. Its remaining clause
+ * — `task.overrides['watch']` — is a runtime invocation override with no target
+ * equivalent, so it has no counterpart here.
+ */
+function isLongRunningTarget(targetName, target) {
+    return !!target.continuous || (0, long_running_target_1.isLongRunningTargetName)(targetName);
+}
+/**
+ * The `targetDefaults` key that beat the target-name key for `target`. Only an
+ * executor key can: key precedence puts the exact target name ahead of every
+ * glob, so nothing else outranks it. Undefined when the name key lost for
+ * another reason (e.g. its entry declared a foreign executor and was dropped as
+ * incompatible) — see {@link isLegacyCachedTarget} for why that case is left
+ * alone even though pre-23 restored it.
+ *
+ * `hasOwnProperty` rather than a lookup: an executor named `__proto__` resolves
+ * through the prototype chain to a truthy object, which would report a key the
+ * user never wrote.
+ */
+function findShadowingTargetDefaultKey(targetDefaults, target) {
+    return target.executor &&
+        targetDefaults &&
+        Object.prototype.hasOwnProperty.call(targetDefaults, target.executor)
+        ? target.executor
+        : undefined;
+}
+/**
+ * Emits a single grouped warning for every (shadowing key, target-name key)
+ * pair that relied on the deprecated fallback. Grouping matters because the
+ * same pair recurs in every affected project — a per-target warning would
+ * print hundreds of identical lines in a large workspace.
+ */
+function warnAboutLegacyCachedTargets(legacyCacheReads) {
+    if (legacyCacheReads.size === 0) {
+        return;
+    }
+    const bodyLines = [];
+    for (const [shadowingKey, targetKeys] of legacyCacheReads) {
+        for (const targetKey of targetKeys) {
+            bodyLines.push(`  - "${shadowingKey}" does not set "cache", so it was read from "${targetKey}"`);
+        }
+    }
+    bodyLines.push('', 'An executor key applies to every target that resolves through it, so exclude any continuous target before setting "cache" on one — a target that is both cacheable and continuous is rejected.', 'Target defaults resolve to a single key rather than merging, so an executor key hides the target name key entirely.', 'Set "cache" on the executor key to keep these targets cacheable — reading it from the target name key is deprecated and will be removed in Nx 24.');
+    output_1.output.warn({
+        title: 'Some targets are only cacheable through a deprecated fallback.',
+        bodyLines,
+    });
+}
+/**
+ * Nothing downstream rejects a key it does not know — the Rust hasher drops it,
+ * the Cloud runner reads only the keys it reads, and the Kotlin API decodes with
+ * `ignoreUnknownKeys`. So a typo is silent everywhere else, and this is the only
+ * place a misspelled option can be reported at all. `'...'` is listed because a
+ * spread with no base to resolve against survives merging.
+ */
+const KNOWN_ULTRACACHE_KEYS = new Set([
+    'mode',
+    'ignoredReads',
+    'ignoredWrites',
+    utils_1.NX_SPREAD_TOKEN,
+]);
+const ULTRACACHE_MODES = ['on', 'warn', 'error', 'off'];
+function describeUltracacheValue(value) {
+    if (Array.isArray(value))
+        return 'an array';
+    if (value === null)
+        return 'null';
+    return `a ${typeof value}`;
+}
+/**
+ * Describes every way an `ultracache` violates the shape the schema forbids.
+ *
+ * The schema is editor-only, and everything downstream — the Rust task hasher,
+ * the cloud runner's Go and Kotlin deserializers — is strict. A bad value that
+ * gets this far is reported far from its source, or silently drops the task's
+ * tracking, so it is worth reporting here where the project, target and file
+ * are all still in hand.
+ *
+ * Returns messages rather than throwing: only a WorkspaceValidityError is
+ * collected by `validateAndNormalizeProjectRootMap`, and anything else escapes
+ * as far as the daemon, which exits on an error it cannot classify.
+ */
+function validateTargetUltracache(ultracache, projectName, projectRoot, targetName, sourceMaps) {
+    if (ultracache === undefined) {
+        return [];
+    }
+    const targetSourceMaps = sourceMaps?.[projectRoot];
+    const [file, plugin] = targetSourceMaps?.[`targets.${targetName}.ultracache`] ??
+        targetSourceMaps?.[`targets.${targetName}`] ??
+        [];
+    const origin = file
+        ? ` (defined in ${file})`
+        : plugin
+            ? ` (defined by ${plugin})`
+            : '';
+    const where = `"${targetName}" in project "${projectName}"${origin}`;
+    if (!(0, utils_1.isObject)(ultracache)) {
+        return [
+            `The "ultracache" configuration for target ${where} must be an object, but it is ${describeUltracacheValue(ultracache)}.`,
+        ];
+    }
+    const errors = [];
+    for (const key of Object.keys(ultracache)) {
+        if (!KNOWN_ULTRACACHE_KEYS.has(key)) {
+            errors.push(`"ultracache.${key}" for target ${where} is not an ultracache option. Supported options are "mode", "ignoredReads" and "ignoredWrites".`);
+        }
+    }
+    if (ultracache.mode !== undefined &&
+        !ULTRACACHE_MODES.includes(ultracache.mode)) {
+        const supported = ULTRACACHE_MODES.map((mode) => `"${mode}"`).join(', ');
+        errors.push(`"ultracache.mode" for target ${where} must be one of ${supported}, but it is ${typeof ultracache.mode === 'string'
+            ? `"${ultracache.mode}"`
+            : describeUltracacheValue(ultracache.mode)}.`);
+    }
+    for (const key of ['ignoredReads', 'ignoredWrites']) {
+        const value = ultracache[key];
+        if (value === undefined)
+            continue;
+        if (!Array.isArray(value)) {
+            errors.push(`"ultracache.${key}" for target ${where} must be an array of glob patterns, but it is ${describeUltracacheValue(value)}.`);
+            continue;
+        }
+        const badIndex = value.findIndex((glob) => typeof glob !== 'string');
+        if (badIndex !== -1) {
+            errors.push(`"ultracache.${key}[${badIndex}]" for target ${where} must be a glob pattern string, but it is ${describeUltracacheValue(value[badIndex])}.`);
+        }
+    }
+    return errors;
+}
+function normalizeTargets(project, sourceMaps, nxJsonConfiguration, workspaceRoot, 
+/**
+ * Project configurations keyed by project name
+ */
+projects, 
+/**
+ * Shadowing `targetDefaults` key -> target name keys its `cache` was read
+ * from. Accumulated across projects so the deprecation warns once per pair.
+ */
+legacyCacheReads) {
+    const targetErrorMessage = [];
+    for (const targetName in project.targets) {
+        project.targets[targetName] = normalizeTarget(project.targets[targetName], project, workspaceRoot, projects, [project.root, targetName].join(':'));
+        const target = project.targets[targetName];
+        targetErrorMessage.push(...validateTargetUltracache(target.ultracache, project.name ?? project.root, project.root, targetName, sourceMaps).map((message) => `- ${message}`));
+        const targetDefaults = nxJsonConfiguration.targetDefaults;
+        if (isLegacyCachedTarget(targetName, targetDefaults, target)) {
+            target.cache = true;
+            // Always defined: `isLegacyCachedTarget` returns false without it.
+            const shadowingKey = findShadowingTargetDefaultKey(targetDefaults, target);
+            const targetKeys = legacyCacheReads.get(shadowingKey) ?? new Set();
+            targetKeys.add(targetName);
+            legacyCacheReads.set(shadowingKey, targetKeys);
+        }
+        if (
+        // If the target has no executor or command, it doesn't do anything
+        !target.executor &&
+            !target.command) {
+            // But it may have dependencies that do something
+            if (target.dependsOn && target.dependsOn.length > 0) {
+                target.executor = 'nx:noop';
+            }
+            else {
+                // If it does nothing, and has no depenencies,
+                // we can remove it.
+                delete project.targets[targetName];
+            }
+        }
+        if (target.cache && target.continuous) {
+            targetErrorMessage.push(`- "${targetName}" has both "cache" and "continuous" set to true. Continuous targets cannot be cached. Please remove the "cache" property.`);
+        }
+    }
+    if (targetErrorMessage.length > 0) {
+        targetErrorMessage.unshift(`Errors detected in targets of project "${project.name}":`);
+        throw new error_types_1.WorkspaceValidityError(targetErrorMessage.join('\n'));
+    }
+}
+function validateAndNormalizeProjectRootMap(workspaceRoot, projectRootMap, nxJsonConfiguration, sourceMaps = {}) {
+    // Name -> Project, used to validate that all projects have unique names
+    const projects = {};
+    // If there are projects that have the same name, that is an error.
+    // This object tracks name -> (all roots of projects with that name)
+    // to provide better error messaging.
+    const conflicts = new Map();
+    const projectRootsWithNoName = [];
+    const validityErrors = [];
+    const legacyCacheReads = new Map();
+    for (const root in projectRootMap) {
+        const project = projectRootMap[root];
+        // We're setting `// targets` as a comment `targets` is empty due to Project Crystal.
+        // Strip it before returning configuration for usage.
+        if (project['// targets'])
+            delete project['// targets'];
+        // We initially did this in the project.json plugin, but
+        // that resulted in project.json files without names causing
+        // the resulting project to change names from earlier plugins...
+        if (!project.name) {
+            const projectJsonPath = (0, path_1.join)(workspaceRoot, project.root, 'project.json');
+            if ((0, node_fs_1.existsSync)(projectJsonPath)) {
+                // The project.json plugin may not have run (e.g. when a single
+                // plugin is run in isolation via `addPlugin` from a generator), so
+                // prefer the name declared in project.json before deriving one from
+                // the directory name.
+                let nameFromProjectJson;
+                try {
+                    nameFromProjectJson =
+                        (0, fileutils_1.readJsonFile)(projectJsonPath).name;
+                }
+                catch { }
+                project.name =
+                    nameFromProjectJson ?? (0, to_project_name_1.toProjectName)((0, path_1.join)(root, 'project.json'));
+            }
+        }
+        try {
+            validateProject(project, projects);
+            projects[project.name] = project;
+        }
+        catch (e) {
+            if ((0, error_types_1.isProjectWithNoNameError)(e)) {
+                projectRootsWithNoName.push(e.projectRoot);
+            }
+            else if ((0, error_types_1.isProjectWithExistingNameError)(e)) {
+                const rootErrors = conflicts.get(e.projectName) ?? [
+                    projects[e.projectName].root,
+                ];
+                rootErrors.push(e.projectRoot);
+                conflicts.set(e.projectName, rootErrors);
+            }
+            else {
+                throw e;
+            }
+        }
+    }
+    for (const root in projectRootMap) {
+        const project = projectRootMap[root];
+        try {
+            normalizeTargets(project, sourceMaps, nxJsonConfiguration, workspaceRoot, projects, legacyCacheReads);
+        }
+        catch (e) {
+            if (e instanceof error_types_1.WorkspaceValidityError) {
+                validityErrors.push(e);
+            }
+            else {
+                throw e;
+            }
+        }
+    }
+    warnAboutLegacyCachedTargets(legacyCacheReads);
+    const errors = [];
+    if (conflicts.size > 0) {
+        // Only on the way to throwing, so a workspace without duplicates never
+        // pays for reading git's worktree registry.
+        const worktreeAdvice = (0, git_worktrees_1.analyzeWorktreeConflicts)(workspaceRoot, conflicts);
+        errors.push(new error_types_1.MultipleProjectsWithSameNameError(conflicts, projects, worktreeAdvice ?? undefined));
+    }
+    if (projectRootsWithNoName.length > 0) {
+        errors.push(new error_types_1.ProjectsWithNoNameError(projectRootsWithNoName, projects));
+    }
+    if (validityErrors.length > 0) {
+        errors.push(...validityErrors);
+    }
+    if (errors.length > 0) {
+        throw new AggregateError(errors);
+    }
+    return projectRootMap;
+}

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

@@ -0,0 +1,39 @@
+import { type SourceInformation } from './source-maps';
+export declare const NX_SPREAD_TOKEN = "...";
+/**
+ * Returns the union of keys across every provided object.
+ */
+export declare function uniqueKeysInObjects(...objs: Array<object | null | undefined>): Set<string>;
+export declare const INTEGER_LIKE_KEY_PATTERN: RegExp;
+export declare class IntegerLikeSpreadKeyError extends Error {
+    constructor(key: string, context: string);
+}
+/**
+ * Throws `IntegerLikeSpreadKeyError` when `value` is a `'...'` spread object
+ * whose enumeration hoists an integer-like key ahead of the spread, making its
+ * authored position ambiguous.
+ *
+ * The ambiguity is a property of the authored value alone, not of any merge
+ * base. `mergeObjectWithSpread` runs this the moment it merges such a value —
+ * but a merge layer that lets the base win a key drops the incoming value
+ * without merging it, so the check must also be run eagerly at those
+ * base-owns-key shortcuts. Otherwise the error would surface or vanish
+ * depending on which side owns the key (e.g. it fires in the target-defaults
+ * staging merge but not the real merge), which is exactly the divergence that
+ * makes discarding staging errors unsafe.
+ */
+export declare function assertNoIntegerLikeSpreadKey(value: unknown, errorContext: string): void;
+type SourceMapContext = {
+    sourceMap: Record<string, SourceInformation>;
+    key: string;
+    sourceInformation: SourceInformation;
+};
+/**
+ * `"..."` in `newValue` (as an array element or a key set to `true`)
+ * expands the base at that position; otherwise `newValue` replaces
+ * `baseValue`. With `deferSpreadsWithoutBase`, an unresolvable spread is
+ * preserved so a later merge layer can expand it.
+ */
+export declare function getMergeValueResult<T>(baseValue: unknown, newValue: T | undefined, sourceMapContext?: SourceMapContext, deferSpreadsWithoutBase?: boolean): T | undefined;
+export declare function isObject(value: unknown): value is Record<string, unknown>;
+export {};

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

@@ -0,0 +1,216 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntegerLikeSpreadKeyError = exports.INTEGER_LIKE_KEY_PATTERN = exports.NX_SPREAD_TOKEN = void 0;
+exports.uniqueKeysInObjects = uniqueKeysInObjects;
+exports.assertNoIntegerLikeSpreadKey = assertNoIntegerLikeSpreadKey;
+exports.getMergeValueResult = getMergeValueResult;
+exports.isObject = isObject;
+const source_maps_1 = require("./source-maps");
+exports.NX_SPREAD_TOKEN = '...';
+/**
+ * Returns the union of keys across every provided object.
+ */
+function uniqueKeysInObjects(...objs) {
+    const keys = new Set();
+    for (const obj of objs) {
+        if (obj) {
+            for (const key of Object.keys(obj)) {
+                keys.add(key);
+            }
+        }
+    }
+    return keys;
+}
+// Integer-like string keys (`"0"`, `"42"`) are enumerated before
+// insertion-order keys, so we can't tell if they were authored before or
+// after `'...'`. Spread sites reject them instead of guessing.
+exports.INTEGER_LIKE_KEY_PATTERN = /^(0|[1-9]\d*)$/;
+class IntegerLikeSpreadKeyError extends Error {
+    constructor(key, context) {
+        super(`${context} uses an integer-like key (${JSON.stringify(key)}) alongside the '...' spread token. Integer-like keys are enumerated before other keys regardless of authored order, so their position relative to '...' is ambiguous. Rename the key (e.g. add a non-numeric prefix) or restructure the object.`);
+        this.name = 'IntegerLikeSpreadKeyError';
+    }
+}
+exports.IntegerLikeSpreadKeyError = IntegerLikeSpreadKeyError;
+/**
+ * Throws `IntegerLikeSpreadKeyError` when `value` is a `'...'` spread object
+ * whose enumeration hoists an integer-like key ahead of the spread, making its
+ * authored position ambiguous.
+ *
+ * The ambiguity is a property of the authored value alone, not of any merge
+ * base. `mergeObjectWithSpread` runs this the moment it merges such a value —
+ * but a merge layer that lets the base win a key drops the incoming value
+ * without merging it, so the check must also be run eagerly at those
+ * base-owns-key shortcuts. Otherwise the error would surface or vanish
+ * depending on which side owns the key (e.g. it fires in the target-defaults
+ * staging merge but not the real merge), which is exactly the divergence that
+ * makes discarding staging errors unsafe.
+ */
+function assertNoIntegerLikeSpreadKey(value, errorContext) {
+    if (!isObject(value) || value[exports.NX_SPREAD_TOKEN] !== true) {
+        return;
+    }
+    const keys = Object.keys(value);
+    if (keys[0] && exports.INTEGER_LIKE_KEY_PATTERN.test(keys[0])) {
+        throw new IntegerLikeSpreadKeyError(keys[0], errorContext);
+    }
+}
+/**
+ * `"..."` in `newValue` (as an array element or a key set to `true`)
+ * expands the base at that position; otherwise `newValue` replaces
+ * `baseValue`. With `deferSpreadsWithoutBase`, an unresolvable spread is
+ * preserved so a later merge layer can expand it.
+ */
+function getMergeValueResult(baseValue, newValue, sourceMapContext, deferSpreadsWithoutBase) {
+    if (newValue === undefined && baseValue !== undefined) {
+        return baseValue;
+    }
+    if (Array.isArray(newValue)) {
+        return mergeArrayValue(baseValue, newValue, sourceMapContext, deferSpreadsWithoutBase);
+    }
+    if (isObject(newValue) && newValue[exports.NX_SPREAD_TOKEN] === true) {
+        return mergeObjectWithSpread(baseValue, newValue, sourceMapContext, deferSpreadsWithoutBase);
+    }
+    // Scalar / null / plain object replace — newValue fully wins.
+    // Only (re)attribute when the value actually changes. A no-op primitive
+    // replace — e.g. a target default that re-stamps the `executor`/`command` a
+    // plugin already set, purely as a merge guard — must not steal provenance
+    // from the layer that introduced the value. A genuinely new value (no base,
+    // or a different one) still attributes to the new layer.
+    //
+    // The exception cuts the other way too: when the *existing* attribution is a
+    // target-defaults stamp (TD merges before the plugin whose value it
+    // predicted, so its stamp lands first), a real plugin re-stating that value
+    // is the genuine author and reclaims the key.
+    if (!isUnchangedPrimitive(newValue, baseValue) ||
+        isReclaimableTargetDefaultsStamp(sourceMapContext)) {
+        writeTopLevelSourceMap(sourceMapContext);
+    }
+    return newValue;
+}
+// Whether the key's current attribution is a weak target-defaults stamp that
+// the (non-target-defaults) writer should reclaim despite the value being
+// unchanged.
+function isReclaimableTargetDefaultsStamp(ctx) {
+    return (!!ctx &&
+        ctx.sourceMap[ctx.key]?.[1] === source_maps_1.TARGET_DEFAULTS_PLUGIN_NAME &&
+        ctx.sourceInformation[1] !== source_maps_1.TARGET_DEFAULTS_PLUGIN_NAME);
+}
+// Whether `newValue` leaves a defined primitive base untouched. Objects fall
+// through (always re-attributed) to preserve the existing replace semantics —
+// the regression this guards is scalar executor/command re-stamping.
+function isUnchangedPrimitive(newValue, baseValue) {
+    return (baseValue !== undefined &&
+        (typeof newValue !== 'object' || newValue === null) &&
+        Object.is(newValue, baseValue));
+}
+function mergeArrayValue(baseValue, newValue, sourceMapContext, deferSpreadsWithoutBase) {
+    const newSpreadIndex = newValue.findIndex((v) => v === exports.NX_SPREAD_TOKEN);
+    if (newSpreadIndex === -1) {
+        // No spread: newValue replaces baseValue entirely.
+        if (sourceMapContext) {
+            for (let i = 0; i < newValue.length; i++) {
+                sourceMapContext.sourceMap[`${sourceMapContext.key}.${i}`] =
+                    sourceMapContext.sourceInformation;
+            }
+        }
+        writeTopLevelSourceMap(sourceMapContext);
+        return newValue;
+    }
+    const baseArray = Array.isArray(baseValue) ? baseValue : [];
+    // Snapshot per-index base sources before we start writing — the loop
+    // writes into the same `${key}.${i}` entries it needs to read back when
+    // the spread expands. Unlike object spread, array spreads can overwrite
+    // indices during their own expansion (when new authors a prefix before
+    // `'...'`), so lazy capture isn't sufficient here.
+    const basePerIndexSources = sourceMapContext
+        ? baseArray.map((_, i) => (0, source_maps_1.readArrayItemSourceInfo)(sourceMapContext.sourceMap, sourceMapContext.key, i))
+        : [];
+    const result = [];
+    const recordAt = (resultIdx, info) => {
+        if (sourceMapContext && info) {
+            sourceMapContext.sourceMap[`${sourceMapContext.key}.${resultIdx}`] = info;
+        }
+    };
+    for (let newValueIndex = 0; newValueIndex < newValue.length; newValueIndex++) {
+        const element = newValue[newValueIndex];
+        if (element === exports.NX_SPREAD_TOKEN) {
+            if (deferSpreadsWithoutBase && baseValue === undefined) {
+                recordAt(result.length, sourceMapContext?.sourceInformation);
+                result.push(exports.NX_SPREAD_TOKEN);
+            }
+            else {
+                for (let baseIndex = 0; baseIndex < baseArray.length; baseIndex++) {
+                    recordAt(result.length, basePerIndexSources[baseIndex]);
+                    result.push(baseArray[baseIndex]);
+                }
+            }
+            continue;
+        }
+        recordAt(result.length, sourceMapContext?.sourceInformation);
+        result.push(element);
+    }
+    writeTopLevelSourceMap(sourceMapContext);
+    return result;
+}
+function mergeObjectWithSpread(baseValue, newValue, sourceMapContext, deferSpreadsWithoutBase) {
+    const baseObj = isObject(baseValue) ? baseValue : {};
+    const result = {};
+    const errorContext = sourceMapContext?.key
+        ? `Object at "${sourceMapContext.key}"`
+        : 'Object';
+    // Integer-like keys are hoisted to the front of enumeration, so one
+    // alongside `'...'` makes its authored position ambiguous.
+    assertNoIntegerLikeSpreadKey(newValue, errorContext);
+    const newKeys = Object.keys(newValue);
+    // Base per-key sources captured lazily — only for shared keys the new
+    // object overwrites before `'...'`, since writing their new source
+    // clobbers the base entry the spread will need to restore.
+    const capturedBaseSources = {};
+    for (const newKey of newKeys) {
+        if (newKey === exports.NX_SPREAD_TOKEN) {
+            if (deferSpreadsWithoutBase && baseValue === undefined) {
+                // Keep the sentinel for a later merge layer to resolve.
+                result[exports.NX_SPREAD_TOKEN] = true;
+                continue;
+            }
+            for (const baseKey of Object.keys(baseObj)) {
+                result[baseKey] = baseObj[baseKey];
+                if (sourceMapContext) {
+                    // If we captured a shared key pre-spread, use that; otherwise
+                    // the source map still holds the base entry untouched.
+                    const baseSource = Object.prototype.hasOwnProperty.call(capturedBaseSources, baseKey)
+                        ? capturedBaseSources[baseKey]
+                        : (0, source_maps_1.readObjectPropertySourceInfo)(sourceMapContext.sourceMap, sourceMapContext.key, baseKey);
+                    if (baseSource) {
+                        sourceMapContext.sourceMap[`${sourceMapContext.key}.${baseKey}`] =
+                            baseSource;
+                    }
+                }
+            }
+            continue;
+        }
+        // About to overwrite a base key's source — capture it first so the
+        // spread can restore it.
+        if (sourceMapContext &&
+            newKey in baseObj &&
+            !Object.prototype.hasOwnProperty.call(capturedBaseSources, newKey)) {
+            capturedBaseSources[newKey] = (0, source_maps_1.readObjectPropertySourceInfo)(sourceMapContext.sourceMap, sourceMapContext.key, newKey);
+        }
+        result[newKey] = newValue[newKey];
+        if (sourceMapContext) {
+            sourceMapContext.sourceMap[`${sourceMapContext.key}.${newKey}`] =
+                sourceMapContext.sourceInformation;
+        }
+    }
+    writeTopLevelSourceMap(sourceMapContext);
+    return result;
+}
+function writeTopLevelSourceMap(ctx) {
+    if (ctx) {
+        ctx.sourceMap[ctx.key] = ctx.sourceInformation;
+    }
+}
+function isObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}