@ohos-ports/nx 17.3.2-beta.0

package/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"
+}
+/** @deprecated this type will be removed in v16. Use {@link ProjectGraphProjectNode} or {@link ProjectGraphExternalNode} instead */
+export type ProjectGraphNode = ProjectGraphProjectNode | ProjectGraphExternalNode;
+/**
+ * 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;
+    };
+}
+/**
+ * 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: 'npm';
+    name: `npm:${string}`;
+    data: {
+        version: string;
+        packageName: string;
+        hash?: string;
+    };
+}
+/**
+ * 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 19.
+ */
+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 19.
+ */
+export type ProjectGraphProcessor = (currentGraph: ProjectGraph, context: ProjectGraphProcessorContext) => ProjectGraph | Promise<ProjectGraph>;

package/src/config/project-graph.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DependencyType = exports.fileDataDepType = exports.fileDataDepTarget = void 0;
+function fileDataDepTarget(dep) {
+    return typeof dep === 'string'
+        ? dep
+        : Array.isArray(dep) && dep.length === 2
+            ? dep[0]
+            : dep[1];
+}
+exports.fileDataDepTarget = fileDataDepTarget;
+function fileDataDepType(dep) {
+    return typeof dep === 'string'
+        ? 'static'
+        : Array.isArray(dep) && dep.length === 2
+            ? dep[1]
+            : dep[2];
+}
+exports.fileDataDepType = fileDataDepType;
+/**
+ * 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 = {}));

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

@@ -0,0 +1,15 @@
+/**
+ * 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): () => 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): string;
+export declare function resolveSchema(schemaPath: string, directory: string): string;

package/src/config/schema-utils.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveSchema = exports.resolveImplementation = exports.getImplementationFactory = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const nx_plugin_1 = require("../utils/nx-plugin");
+/**
+ * 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) {
+    const [implementationModulePath, implementationExportName] = implementation.split('#');
+    return () => {
+        const modulePath = resolveImplementation(implementationModulePath, directory);
+        if ((0, path_1.extname)(modulePath) === '.ts') {
+            (0, nx_plugin_1.registerPluginTSTranspiler)();
+        }
+        const module = require(modulePath);
+        return implementationExportName
+            ? module[implementationExportName]
+            : module.default ?? module;
+    };
+}
+exports.getImplementationFactory = getImplementationFactory;
+/**
+ * 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) {
+    const validImplementations = ['', '.js', '.ts'].map((x) => implementationModulePath + x);
+    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 Error(`Could not resolve "${implementationModulePath}" from "${directory}".`);
+}
+exports.resolveImplementation = resolveImplementation;
+function resolveSchema(schemaPath, directory) {
+    const maybeSchemaPath = (0, path_1.join)(directory, schemaPath);
+    if ((0, fs_1.existsSync)(maybeSchemaPath)) {
+        return maybeSchemaPath;
+    }
+    return require.resolve(schemaPath, {
+        paths: [directory],
+    });
+}
+exports.resolveSchema = resolveSchema;

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

@@ -0,0 +1,100 @@
+/**
+ * A representation of the invocation of an Executor
+ */
+export interface Task {
+    /**
+     * Unique ID
+     */
+    id: string;
+    /**
+     * Details about which project, target, and configuration to run.
+     */
+    target: {
+        /**
+         * The project for which the task belongs to
+         */
+        project: string;
+        /**
+         * The target name which the task should invoke
+         */
+        target: string;
+        /**
+         * The configuration of the target which the task invokes
+         */
+        configuration?: string;
+    };
+    /**
+     * Overrides for the configured options of the target
+     */
+    overrides: any;
+    /**
+     * The outputs the task may produce
+     */
+    outputs: string[];
+    /**
+     * Root of the project the task belongs to
+     */
+    projectRoot?: string;
+    /**
+     * Hash of the task which is used for caching.
+     */
+    hash?: string;
+    /**
+     * Details about the composition of the hash
+     */
+    hashDetails?: {
+        /**
+         * Command of the task
+         */
+        command: string;
+        /**
+         * Hashes of inputs used in the hash
+         */
+        nodes: {
+            [name: string]: string;
+        };
+        /**
+         * Hashes of implicit dependencies which are included in the hash
+         */
+        implicitDeps?: {
+            [fileName: string]: string;
+        };
+        /**
+         * Hash of the runtime environment which the task was executed
+         */
+        runtime?: {
+            [input: string]: string;
+        };
+    };
+    /**
+     *
+     * Unix timestamp of when a Batch Task starts
+     **/
+    startTime?: number;
+    /**
+     *
+     * Unix timestamp of when a Batch Task ends
+     **/
+    endTime?: number;
+    /**
+     * Determines if a given task should be cacheable.
+     */
+    cache?: boolean;
+}
+/**
+ * Graph of Tasks to be executed
+ */
+export interface TaskGraph {
+    /**
+     * IDs of Tasks which do not have any dependencies and are thus ready to execute immediately
+     */
+    roots: string[];
+    /**
+     * Map of Task IDs to Tasks
+     */
+    tasks: Record<string, Task>;
+    /**
+     * Map of Task IDs to IDs of tasks which the task depends on
+     */
+    dependencies: Record<string, string[]>;
+}

package/src/config/task-graph.js

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

package/src/config/workspace-json-project-json.d.ts

@@ -0,0 +1,189 @@
+import type { NxJsonConfiguration, NxReleaseVersionConfiguration } from './nx-json';
+/**
+ * @deprecated use ProjectsConfigurations or NxJsonConfiguration
+ */
+export interface Workspace extends ProjectsConfigurations, NxJsonConfiguration {
+    projects: Record<string, ProjectConfiguration>;
+}
+/**
+ * @deprecated use ProjectsConfigurations
+ */
+export type WorkspaceJsonConfiguration = ProjectsConfigurations;
+/**
+ * Projects Configurations
+ * @note: when adding properties here add them to `allowedWorkspaceExtensions` in adapter/compat.ts
+ */
+export interface ProjectsConfigurations {
+    /**
+     * Version of the configuration format
+     */
+    version: number;
+    /**
+     * Projects' projects
+     */
+    projects: {
+        [projectName: string]: ProjectConfiguration;
+    };
+}
+/**
+ * Type of project supported
+ */
+export type ProjectType = 'library' | 'application';
+/**
+ * Project configuration
+ *
+ * @note: when adding properties here add them to `allowedProjectExtensions` in adapter/compat.ts
+ */
+export interface ProjectConfiguration {
+    /**
+     * Project's name. Optional if specified in workspace.json
+     */
+    name?: string;
+    /**
+     * Project's targets
+     */
+    targets?: {
+        [targetName: string]: TargetConfiguration;
+    };
+    /**
+     * Project's location relative to the root of the workspace
+     */
+    root: string;
+    /**
+     * The location of project's sources relative to the root of the workspace
+     */
+    sourceRoot?: string;
+    /**
+     * Project type
+     */
+    projectType?: ProjectType;
+    /**
+     * List of default values used by generators.
+     *
+     * These defaults are project specific.
+     *
+     * Example:
+     *
+     * ```
+     * {
+     *   "@nx/react": {
+     *     "library": {
+     *       "style": "scss"
+     *     }
+     *   }
+     * }
+     * ```
+     */
+    generators?: {
+        [collectionName: string]: {
+            [generatorName: string]: any;
+        };
+    };
+    /**
+     * List of projects which are added as a dependency
+     */
+    implicitDependencies?: string[];
+    /**
+     * Named inputs targets can refer to reduce duplication
+     */
+    namedInputs?: {
+        [inputName: string]: (string | InputDefinition)[];
+    };
+    /**
+     * List of tags used by enforce-module-boundaries / project graph
+     */
+    tags?: string[];
+    /**
+     * Project specific configuration for `nx release`
+     */
+    release?: {
+        version?: Pick<NxReleaseVersionConfiguration, 'generator' | 'generatorOptions'>;
+    };
+}
+export interface TargetDependencyConfig {
+    /**
+     * A list of projects that have `target`.
+     * Should not be specified together with `dependencies`.
+     */
+    projects?: string[] | string;
+    /**
+     * If true, the target will be executed for each project that this project depends on.
+     * Should not be specified together with `projects`.
+     */
+    dependencies?: boolean;
+    /**
+     * The name of the target to run. If `projects` and `dependencies` are not specified,
+     * the target will be executed for the same project the the current target is running on`.
+     */
+    target: string;
+    /**
+     * Configuration for params handling.
+     */
+    params?: 'ignore' | 'forward';
+}
+export type InputDefinition = {
+    input: string;
+    projects: string | string[];
+} | {
+    input: string;
+    dependencies: true;
+} | {
+    input: string;
+} | {
+    fileset: string;
+} | {
+    runtime: string;
+} | {
+    externalDependencies: string[];
+} | {
+    dependentTasksOutputFiles: string;
+    transitive?: boolean;
+} | {
+    env: string;
+};
+/**
+ * Target's configuration
+ */
+export interface TargetConfiguration<T = any> {
+    /**
+     * The executor/builder used to implement the target.
+     *
+     * Example: '@nx/rollup:rollup'
+     */
+    executor?: string;
+    /**
+     * Used as a shorthand for nx:run-commands, a command to run.
+     */
+    command?: string;
+    /**
+     * List of the target's outputs. The outputs will be cached by the Nx computation
+     * caching engine.
+     */
+    outputs?: string[];
+    /**
+     * This describes other targets that a target depends on.
+     */
+    dependsOn?: (TargetDependencyConfig | string)[];
+    /**
+     * This describes filesets, runtime dependencies and other inputs that a target depends on.
+     */
+    inputs?: (InputDefinition | string)[];
+    /**
+     * Target's options. They are passed in to the executor.
+     */
+    options?: T;
+    /**
+     * Sets of options
+     */
+    configurations?: {
+        [config: string]: any;
+    };
+    /**
+     * A default named configuration to use when a target configuration is not provided.
+     */
+    defaultConfiguration?: string;
+    /**
+     * Determines if Nx is able to cache a given target.
+     */
+    cache?: boolean;
+}

package/src/config/workspace-json-project-json.js

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

package/src/config/workspaces.d.ts

@@ -0,0 +1,18 @@
+import type { NxJsonConfiguration } from './nx-json';
+import { ProjectsConfigurations } from './workspace-json-project-json';
+/**
+ * @deprecated This will be removed in v19. Use {@link readProjectsConfigurationFromProjectGraph} instead.
+ */
+export declare class Workspaces {
+    private root;
+    constructor(root: string);
+    /**
+     * @deprecated Use {@link readProjectsConfigurationFromProjectGraph} instead.
+     */
+    readWorkspaceConfiguration(): ProjectsConfigurations & NxJsonConfiguration;
+}
+/**
+ * Pulled from toFileName in names from @nx/devkit.
+ * Todo: Should refactor, not duplicate.
+ */
+export declare function toProjectName(fileName: string): string;

package/src/config/workspaces.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toProjectName = exports.Workspaces = void 0;
+const path_1 = require("path");
+const project_graph_1 = require("../project-graph/project-graph");
+const nx_json_1 = require("./nx-json");
+// TODO(v19): remove this class
+/**
+ * @deprecated This will be removed in v19. Use {@link readProjectsConfigurationFromProjectGraph} instead.
+ */
+class Workspaces {
+    constructor(root) {
+        this.root = root;
+    }
+    /**
+     * @deprecated Use {@link readProjectsConfigurationFromProjectGraph} instead.
+     */
+    readWorkspaceConfiguration() {
+        const nxJson = (0, nx_json_1.readNxJson)(this.root);
+        return {
+            ...(0, project_graph_1.readProjectsConfigurationFromProjectGraph)((0, project_graph_1.readCachedProjectGraph)()),
+            ...nxJson,
+        };
+    }
+}
+exports.Workspaces = Workspaces;
+/**
+ * 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();
+}
+exports.toProjectName = toProjectName;