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

package/dist/src/config/nx-json.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readNxJson = readNxJson;
+exports.hasNxJson = hasNxJson;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const fileutils_1 = require("../utils/fileutils");
+const workspace_root_1 = require("../utils/workspace-root");
+const installation_directory_1 = require("../utils/installation-directory");
+function readNxJson(root = workspace_root_1.workspaceRoot) {
+    const nxJson = (0, node_path_1.join)(root, 'nx.json');
+    if ((0, node_fs_1.existsSync)(nxJson)) {
+        const nxJsonConfiguration = (0, fileutils_1.readJsonFile)(nxJson);
+        if (nxJsonConfiguration.extends) {
+            const extendedNxJsonPath = require.resolve(nxJsonConfiguration.extends, {
+                paths: (0, installation_directory_1.getNxRequirePaths)(root),
+            });
+            const baseNxJson = (0, fileutils_1.readJsonFile)(extendedNxJsonPath);
+            return {
+                ...baseNxJson,
+                ...nxJsonConfiguration,
+            };
+        }
+        else {
+            return nxJsonConfiguration;
+        }
+    }
+    else {
+        try {
+            return (0, fileutils_1.readJsonFile)((0, node_path_1.join)(__dirname, '..', '..', 'presets', 'core.json'));
+        }
+        catch (e) {
+            return {};
+        }
+    }
+}
+function hasNxJson(root) {
+    const nxJson = (0, node_path_1.join)(root, 'nx.json');
+    return (0, node_fs_1.existsSync)(nxJson);
+}

package/dist/src/config/project-graph.d.ts

@@ -0,0 +1,137 @@
+import type { ProjectConfiguration, ProjectsConfigurations, Workspace } from './workspace-json-project-json';
+import { NxJsonConfiguration } from './nx-json';
+/**
+ * Some metadata about a file
+ */
+export interface FileData {
+    file: string;
+    hash: string;
+    /**
+     * An array of dependencies. If an element is just a string,
+     * the dependency is assumed to be a static dependency targetting
+     * that string. If the element is a tuple with two elements, the first element
+     * inside of it is the target project, with the second element being the type of dependency.
+     * If the tuple has 3 elements, the first is preceded by a source.
+     */
+    deps?: FileDataDependency[];
+}
+/**
+ * A file data dependency, as stored in the cache. If just a string,
+ * the dependency is assumed to be a static dependency targetting
+ * that string. If it is a tuple with two elements, the first element
+ * inside of it is the target project, with the second element being the type of dependency.
+ * If the tuple has 3 elements, the first is preceded by a source.
+ */
+export type FileDataDependency = string | [target: string, type: DependencyType] | [source: string, target: string, type: DependencyType];
+export declare function fileDataDepTarget(dep: FileDataDependency): string;
+export declare function fileDataDepType(dep: FileDataDependency): "static" | DependencyType;
+export interface FileMap {
+    nonProjectFiles: FileData[];
+    projectFileMap: ProjectFileMap;
+}
+/**
+ * A list of files separated by the project they belong to
+ */
+export interface ProjectFileMap {
+    [projectName: string]: FileData[];
+}
+/**
+ * A Graph of projects in the workspace and dependencies between them
+ */
+export interface ProjectGraph {
+    nodes: Record<string, ProjectGraphProjectNode>;
+    externalNodes?: Record<string, ProjectGraphExternalNode>;
+    dependencies: Record<string, ProjectGraphDependency[]>;
+    version?: string;
+}
+/**
+ * Type of dependency between projects
+ */
+export declare enum DependencyType {
+    /**
+     * Static dependencies are tied to the loading of the module
+     */
+    static = "static",
+    /**
+     * Dynamic dependencies are brought in by the module at run time
+     */
+    dynamic = "dynamic",
+    /**
+     * Implicit dependencies are inferred
+     */
+    implicit = "implicit"
+}
+/**
+ * A node describing a project in a workspace
+ */
+export interface ProjectGraphProjectNode {
+    type: 'app' | 'e2e' | 'lib';
+    name: string;
+    /**
+     * Additional metadata about a project
+     */
+    data: ProjectConfiguration & {
+        description?: string;
+    };
+}
+export declare function isProjectGraphProjectNode(node: ProjectGraphProjectNode | ProjectGraphExternalNode): node is ProjectGraphProjectNode;
+/**
+ * A node describing an external dependency
+ * `name` has as form of:
+ * - `npm:packageName` for root dependencies or
+ * - `npm:packageName@version` for nested transitive dependencies
+ *
+ * This is vital for our node discovery to always point to root dependencies,
+ * while allowing tracking of the full tree of different nested versions
+ *
+ */
+export interface ProjectGraphExternalNode {
+    type: string;
+    name: string;
+    data: {
+        version: string;
+        packageName: string;
+        hash?: string;
+    };
+}
+export declare function isProjectGraphExternalNode(node: ProjectGraphProjectNode | ProjectGraphExternalNode): node is ProjectGraphExternalNode;
+/**
+ * A dependency between two projects
+ */
+export interface ProjectGraphDependency {
+    type: DependencyType | string;
+    /**
+     * The project being imported by the other
+     */
+    target: string;
+    /**
+     * The project importing the other
+     */
+    source: string;
+}
+/**
+ * Additional information to be used to process a project graph
+ * @deprecated The {@link ProjectGraphProcessor} is deprecated. This will be removed in Nx 20.
+ */
+export interface ProjectGraphProcessorContext {
+    /**
+     * Workspace information such as projects and configuration
+     * @deprecated use {@link projectsConfigurations} or {@link nxJsonConfiguration} instead
+     */
+    workspace: Workspace;
+    projectsConfigurations: ProjectsConfigurations;
+    nxJsonConfiguration: NxJsonConfiguration;
+    /**
+     * All files in the workspace
+     */
+    fileMap: ProjectFileMap;
+    /**
+     * Files changes since last invocation
+     */
+    filesToProcess: ProjectFileMap;
+}
+/**
+ * A function that produces an updated ProjectGraph
+ * @deprecated Use {@link CreateNodes} and {@link CreateDependencies} instead. This will be removed in Nx 20.
+ */
+export type ProjectGraphProcessor = (currentGraph: ProjectGraph, context: ProjectGraphProcessorContext) => ProjectGraph | Promise<ProjectGraph>;

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

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DependencyType = void 0;
+exports.fileDataDepTarget = fileDataDepTarget;
+exports.fileDataDepType = fileDataDepType;
+exports.isProjectGraphProjectNode = isProjectGraphProjectNode;
+exports.isProjectGraphExternalNode = isProjectGraphExternalNode;
+function fileDataDepTarget(dep) {
+    return typeof dep === 'string'
+        ? dep
+        : Array.isArray(dep) && dep.length === 2
+            ? dep[0]
+            : dep[1];
+}
+function fileDataDepType(dep) {
+    return typeof dep === 'string'
+        ? 'static'
+        : Array.isArray(dep) && dep.length === 2
+            ? dep[1]
+            : dep[2];
+}
+/**
+ * Type of dependency between projects
+ */
+var DependencyType;
+(function (DependencyType) {
+    /**
+     * Static dependencies are tied to the loading of the module
+     */
+    DependencyType["static"] = "static";
+    /**
+     * Dynamic dependencies are brought in by the module at run time
+     */
+    DependencyType["dynamic"] = "dynamic";
+    /**
+     * Implicit dependencies are inferred
+     */
+    DependencyType["implicit"] = "implicit";
+})(DependencyType || (exports.DependencyType = DependencyType = {}));
+function isProjectGraphProjectNode(node) {
+    return node.type === 'app' || node.type === 'e2e' || node.type === 'lib';
+}
+function isProjectGraphExternalNode(node) {
+    return isProjectGraphProjectNode(node) === false;
+}

package/dist/src/config/schema-utils.d.ts

@@ -0,0 +1,37 @@
+import type { ProjectConfiguration } from './workspace-json-project-json';
+/**
+ * Thrown when the schema file of an executor or generator cannot be resolved.
+ */
+export declare class SchemaResolutionError extends Error {
+    readonly schemaPath: string;
+    readonly directory: string;
+    constructor(schemaPath: string, directory: string, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * Thrown when the implementation module of an executor or generator cannot be
+ * resolved.
+ */
+export declare class ImplementationResolutionError extends Error {
+    readonly implementationModulePath: string;
+    readonly directory: string;
+    constructor(implementationModulePath: string, directory: string, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * This function is used to get the implementation factory of an executor or generator.
+ * @param implementation path to the implementation
+ * @param directory path to the directory
+ * @returns a function that returns the implementation
+ */
+export declare function getImplementationFactory<T>(implementation: string, directory: string, packageName: string, projects: Record<string, ProjectConfiguration>): () => T;
+/**
+ * This function is used to resolve the implementation of an executor or generator.
+ * @param implementationModulePath
+ * @param directory
+ * @returns path to the implementation
+ */
+export declare function resolveImplementation(implementationModulePath: string, directory: string, packageName: string, projects: Record<string, ProjectConfiguration>): string;
+export declare function resolveSchema(schemaPath: string, directory: string, packageName: string, projects: Record<string, ProjectConfiguration>): string;

package/dist/src/config/schema-utils.js

@@ -0,0 +1,199 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImplementationResolutionError = exports.SchemaResolutionError = void 0;
+exports.getImplementationFactory = getImplementationFactory;
+exports.resolveImplementation = resolveImplementation;
+exports.resolveSchema = resolveSchema;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const resolve_exports_1 = require("resolve.exports");
+const register_1 = require("../plugins/js/utils/register");
+const packages_1 = require("../plugins/js/utils/packages");
+const typescript_1 = require("../plugins/js/utils/typescript");
+const find_project_for_path_1 = require("../project-graph/utils/find-project-for-path");
+const fileutils_1 = require("../utils/fileutils");
+const package_json_1 = require("../utils/package-json");
+const path_2 = require("../utils/path");
+const workspace_root_1 = require("../utils/workspace-root");
+/**
+ * Thrown when the schema file of an executor or generator cannot be resolved.
+ */
+class SchemaResolutionError extends Error {
+    constructor(schemaPath, directory, options) {
+        super(`Could not resolve schema "${schemaPath}" from "${directory}".`, options);
+        this.schemaPath = schemaPath;
+        this.directory = directory;
+        this.name = 'SchemaResolutionError';
+    }
+}
+exports.SchemaResolutionError = SchemaResolutionError;
+/**
+ * Thrown when the implementation module of an executor or generator cannot be
+ * resolved.
+ */
+class ImplementationResolutionError extends Error {
+    constructor(implementationModulePath, directory, options) {
+        super(`Could not resolve "${implementationModulePath}" from "${directory}".`, options);
+        this.implementationModulePath = implementationModulePath;
+        this.directory = directory;
+        this.name = 'ImplementationResolutionError';
+    }
+}
+exports.ImplementationResolutionError = ImplementationResolutionError;
+/**
+ * This function is used to get the implementation factory of an executor or generator.
+ * @param implementation path to the implementation
+ * @param directory path to the directory
+ * @returns a function that returns the implementation
+ */
+function getImplementationFactory(implementation, directory, packageName, projects) {
+    const [implementationModulePath, implementationExportName] = implementation.split('#');
+    return () => {
+        const modulePath = resolveImplementation(implementationModulePath, directory, packageName, projects);
+        // Route .ts entrypoints through loadTsFile so the native-strip ->
+        // swc/ts-node fallback chain runs. Plain require() bypasses the matcher
+        // set and bubbles errors like extensionless `./schema` imports (strict
+        // ESM resolution failures) straight to the CLI. JS entrypoints use
+        // requireWithTsconfigFallback so workspace-alias imports still resolve.
+        const module = /\.[cm]?ts$/.test(modulePath)
+            ? (0, register_1.loadTsFile)(modulePath)
+            : (0, register_1.requireWithTsconfigFallback)(modulePath);
+        return implementationExportName
+            ? module[implementationExportName]
+            : (module.default ?? module);
+    };
+}
+/**
+ * This function is used to resolve the implementation of an executor or generator.
+ * @param implementationModulePath
+ * @param directory
+ * @returns path to the implementation
+ */
+function resolveImplementation(implementationModulePath, directory, packageName, projects) {
+    const validImplementations = ['', '.js', '.ts'].map((x) => implementationModulePath + x);
+    if (!directory.includes('node_modules')) {
+        // It might be a local plugin where the implementation path points to the
+        // outputs which might not exist or can be stale. We prioritize finding
+        // the implementation from the source over the outputs.
+        for (const maybeImplementation of validImplementations) {
+            const maybeImplementationFromSource = tryResolveFromSource(maybeImplementation, directory, packageName, projects);
+            if (maybeImplementationFromSource) {
+                return maybeImplementationFromSource;
+            }
+        }
+    }
+    for (const maybeImplementation of validImplementations) {
+        const maybeImplementationPath = (0, path_1.join)(directory, maybeImplementation);
+        if ((0, fs_1.existsSync)(maybeImplementationPath)) {
+            return maybeImplementationPath;
+        }
+        try {
+            return require.resolve(maybeImplementation, {
+                paths: [directory],
+            });
+        }
+        catch { }
+    }
+    throw new ImplementationResolutionError(implementationModulePath, directory);
+}
+function resolveSchema(schemaPath, directory, packageName, projects) {
+    if (!directory.includes('node_modules')) {
+        // It might be a local plugin where the schema path points to the outputs
+        // which might not exist or can be stale. We prioritize finding the schema
+        // from the source over the outputs.
+        const schemaPathFromSource = tryResolveFromSource(schemaPath, directory, packageName, projects);
+        if (schemaPathFromSource) {
+            return schemaPathFromSource;
+        }
+    }
+    const maybeSchemaPath = (0, path_1.join)(directory, schemaPath);
+    if ((0, fs_1.existsSync)(maybeSchemaPath)) {
+        return maybeSchemaPath;
+    }
+    try {
+        return require.resolve(schemaPath, {
+            paths: [directory],
+        });
+    }
+    catch (e) {
+        throw new SchemaResolutionError(schemaPath, directory, { cause: e });
+    }
+}
+let projectRootMappings;
+function getProjectForDirectory(directory, projects) {
+    projectRootMappings ??=
+        (0, find_project_for_path_1.createProjectRootMappingsFromProjectConfigurations)(projects);
+    const projectName = (0, find_project_for_path_1.findProjectForPath)((0, path_1.relative)(workspace_root_1.workspaceRoot, directory), projectRootMappings);
+    return projectName ? projects[projectName] : null;
+}
+/**
+ * Reads the JS package metadata (package name and exports) for a project
+ * directly from its `package.json`. Used as a fallback when a project's graph
+ * metadata doesn't include the JS metadata.
+ */
+function readJsPackageMetadata(project) {
+    const packageJsonPath = (0, path_1.join)(workspace_root_1.workspaceRoot, project.root, 'package.json');
+    if (!(0, fs_1.existsSync)(packageJsonPath)) {
+        return null;
+    }
+    try {
+        const packageJson = (0, fileutils_1.readJsonFile)(packageJsonPath);
+        return (0, package_json_1.getMetadataFromPackageJson)(packageJson, false).js;
+    }
+    catch {
+        return null;
+    }
+}
+let packageMetadata;
+function tryResolveFromSource(path, directory, packageName, projects) {
+    packageMetadata ??= (0, packages_1.getWorkspacePackagesMetadata)(projects);
+    let localProject = packageMetadata.packageToProjectMap[packageName];
+    // The `packageName` might be a path to the collection rather than an actual
+    // package name (e.g. when a generator/executor collection is referenced by
+    // path). In that case, `directory` points inside the local project, so we
+    // find the project that contains it.
+    localProject ??= getProjectForDirectory(directory, projects);
+    if (!localProject) {
+        return null;
+    }
+    const js = localProject.metadata?.js ??
+        readJsPackageMetadata(localProject);
+    if (!js) {
+        return null;
+    }
+    const name = js.packageName;
+    const exports = js.packageExports;
+    try {
+        const fromExports = (0, resolve_exports_1.resolve)({ name, exports }, path, {
+            conditions: (0, typescript_1.getRootTsConfigResolveExportsConditions)(),
+        });
+        if (fromExports && fromExports.length) {
+            for (const exportPath of fromExports) {
+                if ((0, fs_1.existsSync)((0, path_1.join)(directory, exportPath))) {
+                    return (0, path_1.join)(directory, exportPath);
+                }
+            }
+        }
+    }
+    catch { }
+    /**
+     * Fall back to try to "guess" the source by checking the path in some common directories:
+     * - the root of the project
+     * - the src directory
+     * - the src/lib directory
+     */
+    const segments = (0, path_2.normalizePath)(path).replace(/^\.\//, '').split('/');
+    for (let i = 1; i < segments.length; i++) {
+        const possiblePaths = [
+            (0, path_1.join)(directory, ...segments.slice(i)),
+            (0, path_1.join)(directory, 'src', ...segments.slice(i)),
+            (0, path_1.join)(directory, 'src', 'lib', ...segments.slice(i)),
+        ];
+        for (const possiblePath of possiblePaths) {
+            if ((0, fs_1.existsSync)(possiblePath)) {
+                return possiblePath;
+            }
+        }
+    }
+    return null;
+}

package/dist/src/config/task-graph.d.ts

@@ -0,0 +1,6 @@
+/**
+ * `Task` and `TaskGraph` are defined as Rust structs in
+ * `packages/nx/src/native/tasks/types.rs` and exposed to TypeScript via NAPI.
+ * This file re-exports them so existing imports keep working.
+ */
+export type { Task, TaskGraph, TaskTarget, TaskHashDetails, TaskUltracacheSettings, } from '../native';

package/dist/src/config/task-graph.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/config/to-project-name.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Pulled from toFileName in names from @nx/devkit.
+ * Todo: Should refactor, not duplicate.
+ */
+export declare function toProjectName(fileName: string): string;

package/dist/src/config/to-project-name.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toProjectName = toProjectName;
+const path_1 = require("path");
+/**
+ * Pulled from toFileName in names from @nx/devkit.
+ * Todo: Should refactor, not duplicate.
+ */
+function toProjectName(fileName) {
+    const parts = (0, path_1.dirname)(fileName).split(/[\/\\]/g);
+    return parts[parts.length - 1].toLowerCase();
+}