@ohos-ports/nx 19.8.4-beta.0

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,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getImplementationFactory = getImplementationFactory;
+exports.resolveImplementation = resolveImplementation;
+exports.resolveSchema = resolveSchema;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const plugins_1 = require("../project-graph/plugins");
+/**
+ * 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, plugins_1.registerPluginTSTranspiler)();
+        }
+        const module = require(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) {
+    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}".`);
+}
+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],
+    });
+}

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

@@ -0,0 +1,104 @@
+/**
+ * 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;
+    /**
+     * Determines if a given task should be parallelizable.
+     */
+    parallelism: 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/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/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();
+}

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

@@ -0,0 +1,225 @@
+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'>;
+    };
+    /**
+     * Metadata about the project
+     */
+    metadata?: ProjectMetadata;
+}
+export interface ProjectMetadata {
+    description?: string;
+    technologies?: string[];
+    targetGroups?: Record<string, string[]>;
+}
+export interface TargetMetadata {
+    [k: string]: any;
+    description?: string;
+    technologies?: string[];
+    nonAtomizedTarget?: string;
+    help?: {
+        command: string;
+        example: {
+            options?: Record<string, unknown>;
+            args?: string[];
+        };
+    };
+}
+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;
+    /**
+     * Metadata about the target
+     */
+    metadata?: TargetMetadata;
+    /**
+     * Whether this target can be run in parallel with other tasks
+     * Default is true
+     */
+    parallelism?: boolean;
+    /**
+     * List of generators to run before the target to ensure the workspace
+     * is up to date.
+     */
+    syncGenerators?: string[];
+}

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

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

package/src/core/graph/environment.js

@@ -0,0 +1 @@
+window.exclude=[],window.watch=!1,window.environment="release",window.useXstateInspect=!1,window.appConfig={showDebugger:!1,showExperimentalFeatures:!1,workspaces:[{id:"local",label:"local",projectGraphUrl:"assets/project-graphs/e2e.json",taskGraphUrl:"assets/task-graphs/e2e.json",taskInputsUrl:"assets/task-inputs/e2e.json",sourceMapsUrl:"assets/source-maps/e2e.json"}],defaultWorkspaceId:"local"};

package/src/core/graph/index.html

@@ -0,0 +1,30 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <title>Nx Workspace Project Graph</title>
+    <base href="/">
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <link rel="icon" type="image/x-icon" href="favicon.ico" />
+
+    <script id="environment" src="environment.js"></script>
+
+    <!-- Theming -->
+    <script>
+      // On page load or when changing themes, best to add inline in `head` to avoid FOUC
+      if (
+        localStorage.getItem('nx-dep-graph-theme') === 'dark' ||
+        (localStorage.getItem('nx-dep-graph-theme') === null &&
+          window.matchMedia('(prefers-color-scheme: dark)').matches)
+      ) {
+        document.documentElement.classList.add('dark');
+      } else {
+        document.documentElement.classList.remove('dark');
+      }
+    </script>
+  <link rel="stylesheet" href="styles.css"></head>
+
+  <body class="bg-white text-slate-500 dark:bg-slate-900 dark:text-slate-400">
+    <div class="flex p-0" id="app"></div>
+  <script src="runtime.js" type="module"></script><script src="styles.js" type="module"></script><script src="main.js" type="module"></script></body>
+</html>