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

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

@@ -0,0 +1,296 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectNodesManager = exports.validateProject = void 0;
+exports.mergeProjectConfigurationIntoRootMap = mergeProjectConfigurationIntoRootMap;
+exports.findMatchingTargetNames = findMatchingTargetNames;
+exports.readProjectConfigurationsFromRootMap = readProjectConfigurationsFromRootMap;
+exports.createRootMap = createRootMap;
+const error_types_1 = require("../../error-types");
+const target_merging_1 = require("./target-merging");
+const target_normalization_1 = require("./target-normalization");
+const git_worktrees_1 = require("../../../utils/git-worktrees");
+const workspace_root_1 = require("../../../utils/workspace-root");
+const name_substitution_manager_1 = require("./name-substitution-manager");
+const source_maps_1 = require("./source-maps");
+const minimatch_1 = require("minimatch");
+const globs_1 = require("../../../utils/globs");
+var target_normalization_2 = require("./target-normalization");
+Object.defineProperty(exports, "validateProject", { enumerable: true, get: function () { return target_normalization_2.validateProject; } });
+function mergeProjectConfigurationIntoRootMap(projectRootMap, project, configurationSourceMaps, sourceInformation, 
+// This function is used when reading project configuration
+// in generators, where we don't want to do this.
+skipTargetNormalization, 
+// Preserve `'...'` spreads that have no base value (default) so a later
+// merge layer can resolve them; pass `false` only for a final merge.
+deferSpreadsWithoutBase = true) {
+    project.root = project.root === '' ? '.' : project.root;
+    if (configurationSourceMaps && !configurationSourceMaps[project.root]) {
+        configurationSourceMaps[project.root] = {};
+    }
+    const sourceMap = configurationSourceMaps?.[project.root];
+    let matchingProject = projectRootMap[project.root];
+    if (!matchingProject) {
+        projectRootMap[project.root] = {
+            root: project.root,
+        };
+        matchingProject = projectRootMap[project.root];
+        if (sourceMap) {
+            sourceMap[`root`] = sourceInformation;
+        }
+    }
+    // This handles top level properties that are overwritten.
+    // e.g. `srcRoot`, `projectType`, or other fields that shouldn't be extended
+    // Note: `name` is set specifically here to keep it from changing. The name is
+    // always determined by the first inference plugin to ID a project, unless it has
+    // a project.json in which case it was already updated above.
+    const updatedProjectConfiguration = {
+        ...matchingProject,
+    };
+    for (const k in project) {
+        if (![
+            'tags',
+            'implicitDependencies',
+            'generators',
+            'targets',
+            'metadata',
+            'namedInputs',
+        ].includes(k)) {
+            updatedProjectConfiguration[k] = project[k];
+            if (sourceMap) {
+                sourceMap[`${k}`] = sourceInformation;
+            }
+        }
+    }
+    // The next blocks handle properties that should be themselves merged (e.g. targets, tags, and implicit dependencies)
+    if (project.tags) {
+        updatedProjectConfiguration.tags = Array.from(new Set((matchingProject.tags ?? []).concat(project.tags)));
+        if (sourceMap) {
+            sourceMap['tags'] ??= sourceInformation;
+            project.tags.forEach((tag) => {
+                sourceMap[`tags.${tag}`] = sourceInformation;
+            });
+        }
+    }
+    if (project.implicitDependencies) {
+        updatedProjectConfiguration.implicitDependencies = (matchingProject.implicitDependencies ?? []).concat(project.implicitDependencies);
+        if (sourceMap) {
+            sourceMap['implicitDependencies'] ??= sourceInformation;
+            project.implicitDependencies.forEach((implicitDependency) => {
+                sourceMap[`implicitDependencies.${implicitDependency}`] =
+                    sourceInformation;
+            });
+        }
+    }
+    if (project.generators) {
+        // Start with generators config in new project.
+        updatedProjectConfiguration.generators = { ...project.generators };
+        if (sourceMap) {
+            sourceMap['generators'] ??= sourceInformation;
+            for (const generator in project.generators) {
+                sourceMap[`generators.${generator}`] = sourceInformation;
+                for (const property in project.generators[generator]) {
+                    sourceMap[`generators.${generator}.${property}`] = sourceInformation;
+                }
+            }
+        }
+        if (matchingProject.generators) {
+            // For each generator that was already defined, shallow merge the options.
+            // Project contains the new info, so it has higher priority.
+            for (const generator in matchingProject.generators) {
+                updatedProjectConfiguration.generators[generator] = {
+                    ...matchingProject.generators[generator],
+                    ...project.generators[generator],
+                };
+            }
+        }
+    }
+    if (project.namedInputs) {
+        updatedProjectConfiguration.namedInputs = {
+            ...matchingProject.namedInputs,
+            ...project.namedInputs,
+        };
+        if (sourceMap) {
+            sourceMap['namedInputs'] ??= sourceInformation;
+            for (const namedInput in project.namedInputs) {
+                sourceMap[`namedInputs.${namedInput}`] = sourceInformation;
+            }
+        }
+    }
+    if (project.metadata) {
+        updatedProjectConfiguration.metadata = (0, target_merging_1.mergeMetadata)(sourceMap, sourceInformation, 'metadata', project.metadata, matchingProject.metadata);
+    }
+    if (project.targets) {
+        // We merge the targets with special handling, so clear this back to the
+        // targets as defined originally before merging.
+        updatedProjectConfiguration.targets = matchingProject?.targets ?? {};
+        if (sourceMap) {
+            sourceMap['targets'] ??= sourceInformation;
+        }
+        // For each target defined in the new config
+        for (const targetName in project.targets) {
+            // Always set source map info for the target, but don't overwrite info already there
+            // if augmenting an existing target.
+            const target = project.targets?.[targetName];
+            if (sourceMap) {
+                // Claims the node key for a newly-created target (or reclaims it from
+                // a weak target-defaults stamp). Whether an *existing* target changes
+                // owners is decided inside `mergeTargetConfigurations`, which knows
+                // whether this merge changed the target's identity.
+                (0, source_maps_1.recordTargetIdentitySourceMapInfo)(sourceMap, (0, source_maps_1.targetSourceMapKey)(targetName), sourceInformation);
+            }
+            const normalizedTarget = skipTargetNormalization
+                ? target
+                : (0, target_merging_1.resolveCommandSyntacticSugar)(target, project.root);
+            let matchingTargets = findMatchingTargetNames(targetName, Object.keys(updatedProjectConfiguration.targets));
+            // If no matching targets were found, we can assume that the target name is not (meant to be) a glob pattern
+            if (!matchingTargets.length) {
+                matchingTargets = [targetName];
+            }
+            for (const matchingTargetName of matchingTargets) {
+                updatedProjectConfiguration.targets[matchingTargetName] =
+                    (0, target_merging_1.mergeTargetConfigurations)(normalizedTarget, matchingProject.targets?.[matchingTargetName], sourceMap, sourceInformation, `targets.${matchingTargetName}`, deferSpreadsWithoutBase);
+            }
+        }
+    }
+    projectRootMap[updatedProjectConfiguration.root] =
+        updatedProjectConfiguration;
+    const nameChanged = !!updatedProjectConfiguration.name &&
+        updatedProjectConfiguration.name !== matchingProject?.name;
+    return { nameChanged };
+}
+/**
+ * The existing target names a glob-pattern target key merges onto. This maps
+ * atomized targets to the glob pattern the same way targetDefaults does.
+ * Returns an empty array for a non-glob key or a pattern matching nothing;
+ * the merge treats those as literal target names.
+ */
+function findMatchingTargetNames(pattern, targetNames) {
+    if (!(0, globs_1.isGlobPattern)(pattern)) {
+        return [];
+    }
+    return targetNames.filter((name) => (0, minimatch_1.minimatch)(name, pattern));
+}
+function readProjectConfigurationsFromRootMap(projectRootMap) {
+    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 = [];
+    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'];
+        try {
+            (0, target_normalization_1.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;
+            }
+        }
+    }
+    if (conflicts.size > 0) {
+        // Only on the way to throwing, so a workspace without duplicates never
+        // pays for reading git's worktree registry.
+        throw new error_types_1.MultipleProjectsWithSameNameError(conflicts, projects, (0, git_worktrees_1.analyzeWorktreeConflicts)(workspace_root_1.workspaceRoot, conflicts) ?? undefined);
+    }
+    if (projectRootsWithNoName.length > 0) {
+        throw new error_types_1.ProjectsWithNoNameError(projectRootsWithNoName, projects);
+    }
+    return projects;
+}
+function createRootMap(projectRootMap) {
+    const map = {};
+    for (const projectRoot in projectRootMap) {
+        const projectName = projectRootMap[projectRoot].name;
+        map[projectRoot] = projectName;
+    }
+    return map;
+}
+/**
+ * Owns the rootMap (root → ProjectConfiguration) and nameMap
+ * (name → ProjectConfiguration), coordinating merges with the
+ * {@link ProjectNameInNodePropsManager} for deferred name substitutions.
+ *
+ * The nameMap entries are the *same object references* as the rootMap
+ * entries, so when a merge adds targets to a rootMap entry the nameMap
+ * entry automatically has them too — no copying, no staleness.
+ */
+class ProjectNodesManager {
+    constructor() {
+        // root → ProjectConfiguration (the merge target)
+        this.rootMap = {};
+        // name → ProjectConfiguration (same object references as rootMap)
+        this.nameMap = {};
+        // Pass a lazy accessor so the substitution manager always sees the
+        // current nameMap without manual synchronization.
+        this.nameSubstitutionManager = new name_substitution_manager_1.ProjectNameInNodePropsManager(() => this.nameMap);
+    }
+    getRootMap() {
+        return this.rootMap;
+    }
+    /**
+     * Merges a project into the rootMap, updates the nameMap, and notifies
+     * the substitution manager if the name changed at this root.
+     */
+    mergeProjectNode(project, configurationSourceMaps, sourceInformation) {
+        const previousName = this.rootMap[project.root]?.name;
+        // This is a final apply — dangling `'...'` spreads must resolve (expand
+        // against the empty base) so they never leak into the project graph.
+        mergeProjectConfigurationIntoRootMap(this.rootMap, project, configurationSourceMaps, sourceInformation, undefined, false);
+        const merged = this.rootMap[project.root];
+        const currentName = merged?.name;
+        if (currentName) {
+            // Remove old nameMap entry on rename
+            if (previousName && previousName !== currentName) {
+                delete this.nameMap[previousName];
+            }
+            // Point nameMap at the same object as rootMap
+            this.nameMap[currentName] = merged;
+            // Notify substitution manager of name change
+            if (currentName !== previousName) {
+                this.nameSubstitutionManager.identifyProjectWithRoot(project.root, currentName);
+            }
+        }
+    }
+    /**
+     * Inserts project-name sentinels into `inputs` and `dependsOn` on the
+     * merged objects in this manager's rootMap. Walking the merged entries —
+     * not the plugin results — matters because a spread-produced array is a
+     * fresh instance, and because sentinels written into plugin-result arrays
+     * would corrupt them for any later merge that re-reads the results.
+     */
+    registerNameRefs(pluginResultProjects) {
+        if (!pluginResultProjects)
+            return;
+        const scoped = {};
+        for (const root in pluginResultProjects) {
+            if (this.rootMap[root]) {
+                scoped[root] = this.rootMap[root];
+            }
+        }
+        this.nameSubstitutionManager.registerNameRefs(scoped);
+    }
+    /**
+     * Applies all pending name substitutions. Call once after all plugin
+     * results have been merged.
+     */
+    applySubstitutions() {
+        this.nameSubstitutionManager.applySubstitutions(this.rootMap);
+    }
+}
+exports.ProjectNodesManager = ProjectNodesManager;

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

@@ -0,0 +1,34 @@
+/** [file, plugin] that contributed a configuration property. */
+export type SourceInformation = [file: string | null, plugin: string];
+/**
+ * The synthetic plugin name target-defaults results are attributed to. Shared
+ * so the merge can recognize a target-defaults stamp when reconciling
+ * provenance — target defaults never genuinely author a target's existence or
+ * its executor/command, so such a stamp must not overwrite a real plugin's
+ * attribution for those keys.
+ */
+export declare const TARGET_DEFAULTS_PLUGIN_NAME = "nx/target-defaults";
+/**
+ * Write the source for the target node key (`targets.<name>`). Ownership of a
+ * target follows its identity, not the last writer:
+ *
+ *  - An unowned key goes to whoever writes it first (the creator).
+ *  - A target-defaults stamp is weak — it never authors a target's existence,
+ *    so any real plugin reclaims the key from it, and it can never take the
+ *    key from a real plugin.
+ *  - Between real plugins, the key only changes hands when the merge changed
+ *    the target's identity (executor/command) — a plugin that merely layers
+ *    fields (dependsOn, options, …) onto an existing target does not become
+ *    its owner.
+ */
+export declare function recordTargetIdentitySourceMapInfo(sourceMap: Record<string, SourceInformation>, key: string, sourceInfo: SourceInformation, identityChanged?: boolean): void;
+/** Source map per project root. */
+export type ConfigurationSourceMaps = Record<string, Record<string, SourceInformation>>;
+export declare function forEachSourceMapKeyForArray(prefixKey: string, array: unknown[], callback: (key: string, index: number) => void, startIndex?: number): void;
+export declare function readArrayItemSourceInfo(sourceMap: Record<string, SourceInformation>, arrayKey: string, itemIndex: number): SourceInformation | undefined;
+export declare function readObjectPropertySourceInfo(sourceMap: Record<string, SourceInformation>, objectKey: string, propertyKey: string): SourceInformation | undefined;
+export declare function recordSourceMapInfo(sourceMap: Record<string, SourceInformation>, key: string, sourceInfo: SourceInformation): void;
+export declare function recordSourceMapKeysByIndex(sourceMap: Record<string, SourceInformation>, prefixKey: string, array: unknown[], sourceInfo: SourceInformation, startIndex?: number): void;
+export declare function targetSourceMapKey(targetName: string): string;
+export declare function targetOptionSourceMapKey(targetName: string, optionKey: string): string;
+export declare function targetConfigurationsSourceMapKey(targetName: string, configurationName?: string, configurationKey?: string): string;

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

@@ -0,0 +1,85 @@
+"use strict";
+// Source map keys are dot-delimited paths into a ProjectConfiguration,
+// e.g. `targets.build.inputs.0.projects`.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TARGET_DEFAULTS_PLUGIN_NAME = void 0;
+exports.recordTargetIdentitySourceMapInfo = recordTargetIdentitySourceMapInfo;
+exports.forEachSourceMapKeyForArray = forEachSourceMapKeyForArray;
+exports.readArrayItemSourceInfo = readArrayItemSourceInfo;
+exports.readObjectPropertySourceInfo = readObjectPropertySourceInfo;
+exports.recordSourceMapInfo = recordSourceMapInfo;
+exports.recordSourceMapKeysByIndex = recordSourceMapKeysByIndex;
+exports.targetSourceMapKey = targetSourceMapKey;
+exports.targetOptionSourceMapKey = targetOptionSourceMapKey;
+exports.targetConfigurationsSourceMapKey = targetConfigurationsSourceMapKey;
+/**
+ * The synthetic plugin name target-defaults results are attributed to. Shared
+ * so the merge can recognize a target-defaults stamp when reconciling
+ * provenance — target defaults never genuinely author a target's existence or
+ * its executor/command, so such a stamp must not overwrite a real plugin's
+ * attribution for those keys.
+ */
+exports.TARGET_DEFAULTS_PLUGIN_NAME = 'nx/target-defaults';
+/**
+ * Write the source for the target node key (`targets.<name>`). Ownership of a
+ * target follows its identity, not the last writer:
+ *
+ *  - An unowned key goes to whoever writes it first (the creator).
+ *  - A target-defaults stamp is weak — it never authors a target's existence,
+ *    so any real plugin reclaims the key from it, and it can never take the
+ *    key from a real plugin.
+ *  - Between real plugins, the key only changes hands when the merge changed
+ *    the target's identity (executor/command) — a plugin that merely layers
+ *    fields (dependsOn, options, …) onto an existing target does not become
+ *    its owner.
+ */
+function recordTargetIdentitySourceMapInfo(sourceMap, key, sourceInfo, identityChanged = false) {
+    const existing = sourceMap[key];
+    if (existing === undefined) {
+        sourceMap[key] = sourceInfo;
+        return;
+    }
+    if (sourceInfo[1] === exports.TARGET_DEFAULTS_PLUGIN_NAME) {
+        return;
+    }
+    if (existing[1] === exports.TARGET_DEFAULTS_PLUGIN_NAME || identityChanged) {
+        sourceMap[key] = sourceInfo;
+    }
+}
+// Iterates `${prefixKey}.0`, `${prefixKey}.1`, ... for each index of `array`.
+function forEachSourceMapKeyForArray(prefixKey, array, callback, startIndex = 0) {
+    for (let i = startIndex; i < array.length; i++) {
+        callback(`${prefixKey}.${i}`, i);
+    }
+}
+// Reads per-index source info, falling back to the array's top-level entry.
+function readArrayItemSourceInfo(sourceMap, arrayKey, itemIndex) {
+    return sourceMap[`${arrayKey}.${itemIndex}`] ?? sourceMap[arrayKey];
+}
+// Reads per-property source info, falling back to the object's top-level entry.
+function readObjectPropertySourceInfo(sourceMap, objectKey, propertyKey) {
+    return sourceMap[`${objectKey}.${propertyKey}`] ?? sourceMap[objectKey];
+}
+function recordSourceMapInfo(sourceMap, key, sourceInfo) {
+    sourceMap[key] = sourceInfo;
+}
+// Records the same source info under every `${prefixKey}.${i}` entry.
+function recordSourceMapKeysByIndex(sourceMap, prefixKey, array, sourceInfo, startIndex = 0) {
+    forEachSourceMapKeyForArray(prefixKey, array, (key) => recordSourceMapInfo(sourceMap, key, sourceInfo), startIndex);
+}
+function targetSourceMapKey(targetName) {
+    return `targets.${targetName}`;
+}
+function targetOptionSourceMapKey(targetName, optionKey) {
+    return `targets.${targetName}.options.${optionKey}`;
+}
+function targetConfigurationsSourceMapKey(targetName, configurationName, configurationKey) {
+    let key = `targets.${targetName}.configurations`;
+    if (configurationName) {
+        key += `.${configurationName}`;
+    }
+    if (configurationKey) {
+        key += `.${configurationKey}`;
+    }
+    return key;
+}

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

@@ -0,0 +1,50 @@
+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,
+    result: CreateNodesResult,
+    pluginIndex?: number
+];
+/**
+ * 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, specifiedSourceMaps?: ConfigurationSourceMaps): CreateNodesResultEntry[];
+/**
+ * Public reader that resolves the target defaults applying to a given
+ * target. Accepts the nested map shape (a value is either a plain config
+ * object or an array of filtered entries).
+ *
+ * When called without project/plugin context, filtered entries that require
+ * a `projects` or `plugin` filter cannot match and are skipped — only
+ * catch-all entries (and `executor`-filtered entries when an executor is
+ * supplied) contribute.
+ *
+ * Normalization runs per call. It is just an array-wrap of each key's value
+ * (cheap relative to graph construction), and `targetDefaults` is mutable and
+ * read through this exported entry point — caching by object identity would
+ * return stale matches when a caller edits a key between reads.
+ */
+export declare function readTargetDefaultsForTarget(targetName: string, targetDefaults: TargetDefaults | undefined, executor?: string, opts?: {
+    projectName?: string;
+    projectNode?: ProjectGraphProjectNode;
+    sourcePlugin?: string;
+    command?: string;
+}): Partial<TargetConfiguration> | null;
+/**
+ * Normalize the public `targetDefaults` map to the internal shape: every
+ * key's value becomes an array of entries (a bare object → a single catch-all
+ * entry).
+ */
+export declare function normalizeTargetDefaults(raw: TargetDefaults | undefined): NormalizedTargetDefaults;
+export {};