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

package/dist/src/project-graph/utils/normalize-project-nodes.js

@@ -1,117 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizeProjectNodes = normalizeProjectNodes;
-exports.normalizeImplicitDependencies = normalizeImplicitDependencies;
-const node_fs_1 = require("node:fs");
-const node_path_1 = require("node:path");
-const fileutils_1 = require("../../utils/fileutils");
-const find_matching_projects_1 = require("../../utils/find-matching-projects");
-async function normalizeProjectNodes({ projects, workspaceRoot }, builder) {
-    // Sorting projects by name to make sure that the order of projects in the graph is deterministic.
-    // This is important to ensure that expanded properties referencing projects (e.g. implicit dependencies)
-    // are also deterministic, and thus don't cause the calculated project configuration hash to shift.
-    const sortedProjectNames = Object.keys(projects).sort();
-    // Used for expanding implicit dependencies (e.g. `@proj/*` or `tag:foo`)
-    const partialProjectGraphNodes = sortedProjectNames.reduce((graph, project) => {
-        const projectConfiguration = projects[project];
-        graph[project] = {
-            name: project,
-            type: projectConfiguration.projectType === 'library' ? 'lib' : 'app', // missing fallback to `e2e`
-            data: {
-                ...projectConfiguration,
-            },
-        };
-        return graph;
-    }, {});
-    const toAdd = [];
-    for (const key of sortedProjectNames) {
-        const p = projects[key];
-        p.implicitDependencies = normalizeImplicitDependencies(key, p.implicitDependencies, partialProjectGraphNodes);
-        p.targets ??= {};
-        // TODO: remove in v16
-        const projectType = getProjectType(key, p.projectType, workspaceRoot, p.root);
-        const tags = p.tags || [];
-        toAdd.push({
-            name: key,
-            type: projectType,
-            data: {
-                ...p,
-                tags,
-            },
-        });
-    }
-    // Sort by root directory length (do we need this?)
-    toAdd.sort((a, b) => {
-        if (!a.data.root)
-            return -1;
-        if (!b.data.root)
-            return -1;
-        return a.data.root.length > b.data.root.length ? -1 : 1;
-    });
-    toAdd.forEach((n) => {
-        builder.addNode({
-            name: n.name,
-            type: n.type,
-            data: n.data,
-        });
-    });
-}
-function normalizeImplicitDependencies(source, implicitDependencies, projects) {
-    if (!implicitDependencies?.length) {
-        return implicitDependencies ?? [];
-    }
-    // Implicit dependencies handle negatives in a different
-    // way from most other `projects` fields. This is because
-    // they are used for multiple purposes.
-    const positivePatterns = [];
-    const negativePatterns = [];
-    for (const dep of implicitDependencies) {
-        if (dep.startsWith('!')) {
-            negativePatterns.push(dep);
-        }
-        else {
-            positivePatterns.push(dep);
-        }
-    }
-    // Finds all projects that match a positive pattern and are not excluded by a negative pattern
-    const deps = positivePatterns.length
-        ? (0, find_matching_projects_1.findMatchingProjects)(positivePatterns.concat(negativePatterns), projects).filter((x) => x !== source)
-        : [];
-    // Expands negative patterns to equal project names
-    const alwaysIgnoredDeps = (0, find_matching_projects_1.findMatchingProjects)(negativePatterns.map((x) => x.slice(1)), projects);
-    // We return the matching deps, but keep the negative patterns in the list
-    // so that they can be processed later by implicit-project-dependencies.ts
-    // This is what allows using a negative implicit dep to remove a dependency
-    // detected by createDependencies.
-    return deps.concat(alwaysIgnoredDeps.map((x) => '!' + x));
-}
-function getProjectType(projectName, projectType, workspaceRoot, projectRoot) {
-    if (projectType) {
-        if (projectType === 'library') {
-            return 'lib';
-        }
-        if (projectName.endsWith('-e2e') || projectName === 'e2e') {
-            return 'e2e';
-        }
-        return 'app';
-    }
-    if ((0, node_fs_1.existsSync)((0, node_path_1.join)(workspaceRoot, projectRoot, 'tsconfig.lib.json'))) {
-        return 'lib';
-    }
-    if ((0, node_fs_1.existsSync)((0, node_path_1.join)(workspaceRoot, projectRoot, 'tsconfig.app.json'))) {
-        return 'app';
-    }
-    // If it doesn't have any common library entry points, assume it is an application
-    const packageJsonPath = (0, node_path_1.join)(workspaceRoot, projectRoot, 'package.json');
-    try {
-        const packageJson = (0, fileutils_1.readJsonFile)(packageJsonPath);
-        if (!packageJson.exports &&
-            !packageJson.main &&
-            !packageJson.module &&
-            !packageJson.bin) {
-            return 'app';
-        }
-    }
-    catch { }
-    return 'lib';
-}

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

@@ -1,48 +0,0 @@
-import { ProjectConfiguration } from '../../../config/workspace-json-project-json';
-/**
- * Sentinel placed in `inputs` / `dependsOn` for a pending project-name
- * reference. `RootRef` carries the referenced project's root (resolved
- * via nameMap lookup); `UsageRef` carries the raw written name (for
- * forward refs, promoted to `RootRef` in place when the name is
- * identified). `targetPart` preserves the `:target` suffix from
- * `dependsOn` strings.
- */
-export declare abstract class NameRef {
-    value: string;
-    targetPart: string | undefined;
-    constructor(value: string, targetPart: string | undefined);
-}
-export declare class RootRef extends NameRef {
-}
-export declare class UsageRef extends NameRef {
-}
-export declare function isNameRef(value: unknown): value is NameRef;
-export declare function isRootRef(value: unknown): value is RootRef;
-export declare function isUsageRef(value: unknown): value is UsageRef;
-/**
- * Replaces project-name refs in plugin results with in-place sentinels,
- * then resolves them after all merging is done.
- *
- * Tracking by array position breaks once `'...'` spreads shuffle indices,
- * so each ref becomes a sentinel object. Merges copy sentinels by
- * reference — one sentinel can end up in many arrays (e.g. a pattern
- * target's dependsOn applied to every matching target) — so the final
- * pass sweeps the merged rootMap and resolves every sentinel where it
- * actually sits. Sentinels in arrays dropped by a full-replace are never
- * visited and vanish with their array.
- */
-export declare class ProjectNameInNodePropsManager {
-    private getNameMap;
-    private pendingByName;
-    private nameHistory;
-    constructor(getNameMap?: () => Record<string, ProjectConfiguration>);
-    registerNameRefs(pluginResultProjects?: Record<string, Omit<ProjectConfiguration, 'root'> & Partial<ProjectConfiguration>>): void;
-    private processInputs;
-    private processDependsOn;
-    private processProjectsArray;
-    private createRef;
-    identifyProjectWithRoot(root: string, name: string): void;
-    applySubstitutions(rootMap: Record<string, ProjectConfiguration>): void;
-    private substituteInArray;
-    private resolveFinalName;
-}

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

@@ -1,270 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ProjectNameInNodePropsManager = exports.UsageRef = exports.RootRef = exports.NameRef = void 0;
-exports.isNameRef = isNameRef;
-exports.isRootRef = isRootRef;
-exports.isUsageRef = isUsageRef;
-const globs_1 = require("../../../utils/globs");
-const split_target_1 = require("../../../utils/split-target");
-/**
- * Sentinel placed in `inputs` / `dependsOn` for a pending project-name
- * reference. `RootRef` carries the referenced project's root (resolved
- * via nameMap lookup); `UsageRef` carries the raw written name (for
- * forward refs, promoted to `RootRef` in place when the name is
- * identified). `targetPart` preserves the `:target` suffix from
- * `dependsOn` strings.
- */
-class NameRef {
-    constructor(value, targetPart) {
-        this.value = value;
-        this.targetPart = targetPart;
-    }
-}
-exports.NameRef = NameRef;
-class RootRef extends NameRef {
-}
-exports.RootRef = RootRef;
-class UsageRef extends NameRef {
-}
-exports.UsageRef = UsageRef;
-function isNameRef(value) {
-    return value instanceof NameRef;
-}
-function isRootRef(value) {
-    return value instanceof RootRef;
-}
-function isUsageRef(value) {
-    return value instanceof UsageRef;
-}
-/**
- * Replaces project-name refs in plugin results with in-place sentinels,
- * then resolves them after all merging is done.
- *
- * Tracking by array position breaks once `'...'` spreads shuffle indices,
- * so each ref becomes a sentinel object. Merges copy sentinels by
- * reference — one sentinel can end up in many arrays (e.g. a pattern
- * target's dependsOn applied to every matching target) — so the final
- * pass sweeps the merged rootMap and resolves every sentinel where it
- * actually sits. Sentinels in arrays dropped by a full-replace are never
- * visited and vanish with their array.
- */
-class ProjectNameInNodePropsManager {
-    constructor(getNameMap) {
-        this.pendingByName = new Map();
-        // name → root for every name a project has ever been identified by, so refs
-        // to a since-renamed name still bind to the right root (see createRef).
-        this.nameHistory = new Map();
-        this.getNameMap = getNameMap ?? (() => ({}));
-    }
-    // Replaces each project-name ref in `inputs`/`dependsOn` with a sentinel.
-    // Call after `identifyProjectWithRoot` for the batch so same-batch forward
-    // refs resolve straight to RootRefs.
-    registerNameRefs(pluginResultProjects) {
-        if (!pluginResultProjects)
-            return;
-        for (const ownerRoot in pluginResultProjects) {
-            const project = pluginResultProjects[ownerRoot];
-            if (!project?.targets)
-                continue;
-            for (const targetName in project.targets) {
-                const targetConfig = project.targets[targetName];
-                if (!targetConfig || typeof targetConfig !== 'object')
-                    continue;
-                if (Array.isArray(targetConfig.inputs)) {
-                    this.processInputs(targetConfig.inputs);
-                }
-                if (Array.isArray(targetConfig.dependsOn)) {
-                    this.processDependsOn(targetConfig.dependsOn, project.targets, project.name);
-                }
-            }
-        }
-    }
-    processInputs(inputs) {
-        for (let i = 0; i < inputs.length; i++) {
-            const entry = inputs[i];
-            if (isNameRef(entry))
-                continue;
-            if (!entry || typeof entry !== 'object')
-                continue;
-            if (!('projects' in entry))
-                continue;
-            const element = entry;
-            const projects = element.projects;
-            if (isNameRef(projects))
-                continue;
-            if (typeof projects === 'string') {
-                if (projects === 'self' || projects === 'dependencies')
-                    continue;
-                element.projects = this.createRef(projects);
-            }
-            else if (Array.isArray(projects)) {
-                this.processProjectsArray(projects);
-            }
-        }
-    }
-    processDependsOn(dependsOn, ownerTargets, ownerName) {
-        for (let i = 0; i < dependsOn.length; i++) {
-            const dep = dependsOn[i];
-            if (isNameRef(dep))
-                continue;
-            if (typeof dep === 'string') {
-                // `^target` and same-project targets aren't cross-project refs.
-                if (dep.startsWith('^') || (ownerTargets && dep in ownerTargets)) {
-                    continue;
-                }
-                const [maybeProject, ...rest] = (0, split_target_1.splitTargetFromConfigurations)(dep, this.getNameMap(), { silent: true, currentProject: ownerName });
-                if (rest.length === 0)
-                    continue;
-                const targetPart = rest.join(':');
-                dependsOn[i] = this.createRef(maybeProject, targetPart);
-                continue;
-            }
-            if (!dep || typeof dep !== 'object' || !('projects' in dep))
-                continue;
-            const element = dep;
-            const projects = element.projects;
-            if (isNameRef(projects)) {
-                continue;
-            }
-            if (typeof projects === 'string') {
-                if (projects === '*' ||
-                    projects === 'self' ||
-                    projects === 'dependencies') {
-                    continue;
-                }
-                element.projects = this.createRef(projects);
-            }
-            else if (Array.isArray(projects)) {
-                this.processProjectsArray(projects);
-            }
-        }
-    }
-    processProjectsArray(projects) {
-        for (let j = 0; j < projects.length; j++) {
-            const name = projects[j];
-            if (isNameRef(name))
-                continue;
-            if (typeof name !== 'string')
-                continue;
-            if ((0, globs_1.isGlobPattern)(name))
-                continue;
-            projects[j] = this.createRef(name);
-        }
-    }
-    // Builds a sentinel and registers it. When `referencedName` isn't in the
-    // current name map, fall back to the rename history: a batch may reference a
-    // project by a name that a project earlier in the same batch already renamed
-    // (refs register after the whole batch merges), and the old name still
-    // identifies the same root.
-    createRef(referencedName, targetPart) {
-        const referencedRoot = this.getNameMap()[referencedName]?.root ??
-            this.nameHistory.get(referencedName);
-        const ref = referencedRoot !== undefined
-            ? new RootRef(referencedRoot, targetPart)
-            : new UsageRef(referencedName, targetPart);
-        if (ref instanceof UsageRef) {
-            let set = this.pendingByName.get(referencedName);
-            if (!set) {
-                set = new Set();
-                this.pendingByName.set(referencedName, set);
-            }
-            set.add(ref);
-        }
-        return ref;
-    }
-    // Records `name` → `root` and promotes any waiting UsageRef sentinels to
-    // RootRef by prototype swap. Sentinel identity across spread copies means
-    // one promotion updates every array the sentinel reached.
-    identifyProjectWithRoot(root, name) {
-        // Every name a root has ever gone by, including pre-rename names. A later
-        // ref to a stale name resolves to the root it identified at the time.
-        // (If two roots use the same name over a graph construction, the later
-        // one wins — matching how the live name map would have resolved it.)
-        this.nameHistory.set(name, root);
-        const pending = this.pendingByName.get(name);
-        if (!pending)
-            return;
-        this.pendingByName.delete(name);
-        for (const ref of pending) {
-            if (!(ref instanceof UsageRef))
-                continue;
-            Object.setPrototypeOf(ref, RootRef.prototype);
-            ref.value = root;
-        }
-    }
-    // Resolves every sentinel in the merged rootMap in place. Sweeping the
-    // final config (rather than writing through back-references held by the
-    // sentinels) covers sentinels that merges copied into arrays other than
-    // the one they were created in, e.g. a pattern target's dependsOn applied
-    // to every matching target. Called once after all plugin results have
-    // been merged.
-    applySubstitutions(rootMap) {
-        const nameByRoot = {};
-        for (const root in rootMap) {
-            nameByRoot[root] = rootMap[root]?.name;
-        }
-        for (const root in rootMap) {
-            const targets = rootMap[root]?.targets;
-            if (!targets)
-                continue;
-            for (const targetName in targets) {
-                const targetConfig = targets[targetName];
-                if (!targetConfig || typeof targetConfig !== 'object')
-                    continue;
-                if (Array.isArray(targetConfig.inputs)) {
-                    this.substituteInArray(targetConfig.inputs, nameByRoot);
-                }
-                if (Array.isArray(targetConfig.dependsOn)) {
-                    this.substituteInArray(targetConfig.dependsOn, nameByRoot);
-                }
-            }
-        }
-        this.pendingByName.clear();
-        this.nameHistory.clear();
-    }
-    substituteInArray(entries, nameByRoot) {
-        for (let i = 0; i < entries.length; i++) {
-            const entry = entries[i];
-            if (isNameRef(entry)) {
-                const finalName = this.resolveFinalName(entry, nameByRoot);
-                if (finalName !== undefined) {
-                    entries[i] =
-                        entry.targetPart !== undefined
-                            ? `${finalName}:${entry.targetPart}`
-                            : finalName;
-                }
-                continue;
-            }
-            if (!entry || typeof entry !== 'object' || !('projects' in entry)) {
-                continue;
-            }
-            const element = entry;
-            if (isNameRef(element.projects)) {
-                const finalName = this.resolveFinalName(element.projects, nameByRoot);
-                if (finalName !== undefined) {
-                    element.projects = finalName;
-                }
-            }
-            else if (Array.isArray(element.projects)) {
-                const projects = element.projects;
-                for (let j = 0; j < projects.length; j++) {
-                    const name = projects[j];
-                    if (!isNameRef(name))
-                        continue;
-                    const finalName = this.resolveFinalName(name, nameByRoot);
-                    if (finalName !== undefined) {
-                        projects[j] = finalName;
-                    }
-                }
-            }
-        }
-    }
-    resolveFinalName(ref, nameByRoot) {
-        if (ref instanceof RootRef) {
-            return nameByRoot[ref.value];
-        }
-        // Unpromoted forward ref — best effort, fall back to the written name.
-        return this.getNameMap()[ref.value]?.name ?? ref.value;
-    }
-}
-exports.ProjectNameInNodePropsManager = ProjectNameInNodePropsManager;

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

@@ -1,49 +0,0 @@
-import { ProjectConfiguration } from '../../../config/workspace-json-project-json';
-import type { ConfigurationSourceMaps, SourceInformation } from './source-maps';
-export { validateProject } from './target-normalization';
-export declare function mergeProjectConfigurationIntoRootMap(projectRootMap: Record<string, ProjectConfiguration>, project: ProjectConfiguration, configurationSourceMaps?: ConfigurationSourceMaps, sourceInformation?: SourceInformation, skipTargetNormalization?: boolean, deferSpreadsWithoutBase?: boolean): {
-    nameChanged: boolean;
-};
-/**
- * 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.
- */
-export declare function findMatchingTargetNames(pattern: string, targetNames: string[]): string[];
-export declare function readProjectConfigurationsFromRootMap(projectRootMap: Record<string, ProjectConfiguration>): Record<string, ProjectConfiguration>;
-export declare function createRootMap(projectRootMap: Record<string, ProjectConfiguration>): Record<string, string>;
-/**
- * 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.
- */
-export declare class ProjectNodesManager {
-    private rootMap;
-    private nameMap;
-    private nameSubstitutionManager;
-    constructor();
-    getRootMap(): Record<string, ProjectConfiguration>;
-    /**
-     * Merges a project into the rootMap, updates the nameMap, and notifies
-     * the substitution manager if the name changed at this root.
-     */
-    mergeProjectNode(project: ProjectConfiguration, configurationSourceMaps?: ConfigurationSourceMaps, sourceInformation?: SourceInformation): void;
-    /**
-     * 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?: Record<string, Omit<ProjectConfiguration, 'root'> & Partial<ProjectConfiguration>>): void;
-    /**
-     * Applies all pending name substitutions. Call once after all plugin
-     * results have been merged.
-     */
-    applySubstitutions(): void;
-}