@ohos-ports/nx 19.8.4-beta.0

package/src/command-line/yargs-utils/shared-options.js

@@ -0,0 +1,253 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultYargsParserConfiguration = void 0;
+exports.withExcludeOption = withExcludeOption;
+exports.withRunOptions = withRunOptions;
+exports.withTargetAndConfigurationOption = withTargetAndConfigurationOption;
+exports.withConfiguration = withConfiguration;
+exports.withVerbose = withVerbose;
+exports.withBatch = withBatch;
+exports.withAffectedOptions = withAffectedOptions;
+exports.withRunManyOptions = withRunManyOptions;
+exports.withOverrides = withOverrides;
+exports.withOutputStyleOption = withOutputStyleOption;
+exports.withRunOneOptions = withRunOneOptions;
+exports.parseCSV = parseCSV;
+exports.defaultYargsParserConfiguration = {
+    'strip-dashed': true,
+    'unknown-options-as-args': true,
+    'populate--': true,
+    'parse-numbers': false,
+    'parse-positional-numbers': false,
+};
+function withExcludeOption(yargs) {
+    return yargs.option('exclude', {
+        describe: 'Exclude certain projects from being processed.',
+        type: 'string',
+        coerce: parseCSV,
+    });
+}
+function withRunOptions(yargs) {
+    return withVerbose(withExcludeOption(yargs))
+        .option('parallel', {
+        describe: 'Max number of parallel processes [default is 3].',
+        type: 'string',
+    })
+        .option('maxParallel', {
+        type: 'number',
+        hidden: true,
+    })
+        .options('runner', {
+        describe: 'This is the name of the tasks runner configured in nx.json.',
+        type: 'string',
+    })
+        .option('prod', {
+        describe: 'Use the production configuration.',
+        type: 'boolean',
+        default: false,
+        hidden: true,
+    })
+        .option('graph', {
+        type: 'string',
+        describe: 'Show the task graph of the command. Pass a file path to save the graph data instead of viewing it in the browser. Pass "stdout" to print the results to the terminal.',
+        coerce: (value) => 
+        // when the type of an opt is "string", passing `--opt` comes through as having an empty string value.
+        // this coercion allows `--graph` to be passed through as a boolean directly, and also normalizes the
+        // `--graph=true` to produce the same behaviour as `--graph`.
+        value === '' || value === 'true' || value === true
+            ? true
+            : value === 'false' || value === false
+                ? false
+                : value,
+    })
+        .option('nxBail', {
+        describe: 'Stop command execution after the first failed task.',
+        type: 'boolean',
+        default: false,
+    })
+        .option('nxIgnoreCycles', {
+        describe: 'Ignore cycles in the task graph.',
+        type: 'boolean',
+        default: false,
+    })
+        .options('skipNxCache', {
+        describe: 'Rerun the tasks even when the results are available in the cache.',
+        type: 'boolean',
+        default: false,
+    })
+        .options('excludeTaskDependencies', {
+        describe: 'Skips running dependent tasks first.',
+        type: 'boolean',
+        default: false,
+    })
+        .option('skipSync', {
+        describe: 'Skips running the sync generators associated with the tasks.',
+        type: 'boolean',
+        default: false,
+    })
+        .options('cloud', {
+        type: 'boolean',
+        hidden: true,
+    })
+        .options('dte', {
+        type: 'boolean',
+        hidden: true,
+    })
+        .options('useAgents', {
+        type: 'boolean',
+        hidden: true,
+        alias: 'agents',
+    });
+}
+function withTargetAndConfigurationOption(yargs, demandOption = true) {
+    return withConfiguration(yargs).option('targets', {
+        describe: 'Tasks to run for affected projects.',
+        type: 'string',
+        alias: ['target', 't'],
+        requiresArg: true,
+        coerce: parseCSV,
+        demandOption,
+        global: false,
+    });
+}
+function withConfiguration(yargs) {
+    return yargs.options('configuration', {
+        describe: 'This is the configuration to use when performing tasks on projects.',
+        type: 'string',
+        alias: 'c',
+    });
+}
+function withVerbose(yargs) {
+    return yargs
+        .option('verbose', {
+        describe: 'Prints additional information about the commands (e.g., stack traces).',
+        type: 'boolean',
+    })
+        .middleware((args) => {
+        args.verbose ??= process.env.NX_VERBOSE_LOGGING === 'true';
+        // If NX_VERBOSE_LOGGING=false and --verbose is passed, we want to set it to true favoring the arg
+        process.env.NX_VERBOSE_LOGGING = args.verbose.toString();
+    });
+}
+function withBatch(yargs) {
+    return yargs.options('batch', {
+        type: 'boolean',
+        describe: 'Run task(s) in batches for executors which support batches.',
+        coerce: (v) => {
+            return v || process.env.NX_BATCH_MODE === 'true';
+        },
+        default: false,
+    });
+}
+function withAffectedOptions(yargs) {
+    return withExcludeOption(yargs)
+        .parserConfiguration(exports.defaultYargsParserConfiguration)
+        .option('files', {
+        describe: 'Change the way Nx is calculating the affected command by providing directly changed files, list of files delimited by commas or spaces.',
+        type: 'string',
+        requiresArg: true,
+        coerce: parseCSV,
+    })
+        .option('uncommitted', {
+        describe: 'Uncommitted changes.',
+        type: 'boolean',
+    })
+        .option('untracked', {
+        describe: 'Untracked changes.',
+        type: 'boolean',
+    })
+        .option('base', {
+        describe: 'Base of the current branch (usually main).',
+        type: 'string',
+        requiresArg: true,
+    })
+        .option('head', {
+        describe: 'Latest commit of the current branch (usually HEAD).',
+        type: 'string',
+        requiresArg: true,
+    })
+        .group(['base'], 'Run command using --base=[SHA1] (affected by the committed, uncommitted and untracked changes):')
+        .group(['base', 'head'], 'or using --base=[SHA1] --head=[SHA2] (affected by the committed changes):')
+        .group(['files', 'uncommitted', 'untracked'], 'or using:')
+        .implies('head', 'base')
+        .conflicts({
+        files: ['uncommitted', 'untracked', 'base', 'head'],
+        untracked: ['uncommitted', 'files', 'base', 'head'],
+        uncommitted: ['files', 'untracked', 'base', 'head'],
+    });
+}
+function withRunManyOptions(yargs) {
+    return withRunOptions(yargs)
+        .parserConfiguration(exports.defaultYargsParserConfiguration)
+        .option('projects', {
+        type: 'string',
+        alias: 'p',
+        coerce: parseCSV,
+        describe: 'Projects to run. (comma/space delimited project names and/or patterns).',
+    })
+        .option('all', {
+        describe: '[deprecated] `run-many` runs all targets on all projects in the workspace if no projects are provided. This option is no longer required.',
+        type: 'boolean',
+        default: true,
+    });
+}
+function withOverrides(args, commandLevel = 1) {
+    const unparsedArgs = (args['--'] ?? args._.slice(commandLevel)).map((v) => v.toString());
+    delete args['--'];
+    delete args._;
+    return {
+        ...args,
+        __overrides_unparsed__: unparsedArgs,
+    };
+}
+const allOutputStyles = [
+    'dynamic',
+    'static',
+    'stream',
+    'stream-without-prefixes',
+    'compact',
+];
+function withOutputStyleOption(yargs, choices = [
+    'dynamic',
+    'static',
+    'stream',
+    'stream-without-prefixes',
+]) {
+    return yargs.option('output-style', {
+        describe: `Defines how Nx emits outputs tasks logs. **dynamic**: use dynamic output life cycle, previous content is overwritten or modified as new outputs are added, display minimal logs by default, always show errors. This output format is recommended on your local development environments. **static**: uses static output life cycle, no previous content is rewritten or modified as new outputs are added. This output format is recommened for CI environments. **stream**: nx by default logs output to an internal output stream, enable this option to stream logs to stdout / stderr. **stream-without-prefixes**: nx prefixes the project name the target is running on, use this option remove the project name prefix from output.`,
+        type: 'string',
+        choices,
+    });
+}
+function withRunOneOptions(yargs) {
+    const executorShouldShowHelp = !(process.argv[2] === 'run' && process.argv[3] === '--help');
+    const res = withRunOptions(withOutputStyleOption(withConfiguration(yargs), allOutputStyles))
+        .parserConfiguration(exports.defaultYargsParserConfiguration)
+        .option('project', {
+        describe: 'Target project.',
+        type: 'string',
+    })
+        .option('help', {
+        describe: 'Show Help.',
+        type: 'boolean',
+    });
+    if (executorShouldShowHelp) {
+        return res.help(false);
+    }
+    else {
+        return res.epilog(`Run "nx run myapp:mytarget --help" to see information about the executor's schema.`);
+    }
+}
+function parseCSV(args) {
+    if (!args) {
+        return [];
+    }
+    if (Array.isArray(args)) {
+        // If parseCSV is used on `type: 'array'`, the first option may be something like ['a,b,c'].
+        return args.length === 1 && args[0].includes(',')
+            ? parseCSV(args[0])
+            : args;
+    }
+    const items = args.split(',');
+    return items.map((i) => i.startsWith('"') && i.endsWith('"') ? i.slice(1, -1) : i);
+}

package/src/commands-runner/command-graph.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Graph of Tasks to be executed
+ */
+export interface CommandGraph {
+    /**
+     * Projects that do not have any dependencies and are thus ready to execute immediately
+     */
+    roots: string[];
+    /**
+     * Map of projects to projects which the task depends on
+     */
+    dependencies: Record<string, string[]>;
+}

package/src/commands-runner/command-graph.js

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

package/src/commands-runner/create-command-graph.d.ts

@@ -0,0 +1,4 @@
+import { ProjectGraph } from '../config/project-graph';
+import { NxArgs } from '../utils/command-line-utils';
+import { CommandGraph } from './command-graph';
+export declare function createCommandGraph(projectGraph: ProjectGraph, projectNames: string[], nxArgs: NxArgs): CommandGraph;

package/src/commands-runner/create-command-graph.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCommandGraph = createCommandGraph;
+const task_graph_utils_1 = require("../tasks-runner/task-graph-utils");
+const output_1 = require("../utils/output");
+/**
+ * Make structure { lib: [dep], dep: [dep1], dep1: [] } from projectName lib and projectGraph
+ * @param projectGraph
+ * @param projectName
+ * @param resolved reference to an object that will contain resolved dependencies
+ * @returns
+ */
+const recursiveResolveDeps = (projectGraph, projectName, resolved) => {
+    if (projectGraph.dependencies[projectName].length === 0) {
+        // no deps - no resolve
+        resolved[projectName] = [];
+        return;
+    }
+    // if already resolved - just skip
+    if (resolved[projectName]) {
+        return resolved[projectName];
+    }
+    // deps string list
+    const projectDeps = [
+        ...new Set(projectGraph.dependencies[projectName]
+            .map((projectDep) => projectDep.target)
+            .filter((projectDep) => projectGraph.nodes[projectDep])).values(),
+    ];
+    // define
+    resolved[projectName] = projectDeps;
+    if (projectDeps.length > 0) {
+        for (const dep of projectDeps) {
+            recursiveResolveDeps(projectGraph, dep, resolved);
+        }
+    }
+};
+function createCommandGraph(projectGraph, projectNames, nxArgs) {
+    const dependencies = {};
+    if (!nxArgs.excludeTaskDependencies) {
+        for (const projectName of projectNames) {
+            recursiveResolveDeps(projectGraph, projectName, dependencies);
+        }
+    }
+    const roots = Object.keys(dependencies).filter((d) => dependencies[d].length === 0);
+    const commandGraph = {
+        dependencies,
+        roots,
+    };
+    const cycle = (0, task_graph_utils_1.findCycle)(commandGraph);
+    if (cycle) {
+        if (process.env.NX_IGNORE_CYCLES === 'true' || nxArgs.nxIgnoreCycles) {
+            output_1.output.warn({
+                title: `The command graph has a circular dependency`,
+                bodyLines: [`${cycle.join(' --> ')}`],
+            });
+            (0, task_graph_utils_1.makeAcyclic)(commandGraph);
+        }
+        else {
+            output_1.output.error({
+                title: `Could not execute command because the project graph has a circular dependency`,
+                bodyLines: [`${cycle.join(' --> ')}`],
+            });
+            process.exit(1);
+        }
+    }
+    return commandGraph;
+}

package/src/commands-runner/get-command-projects.d.ts

@@ -0,0 +1,3 @@
+import { ProjectGraph, ProjectGraphProjectNode } from '../config/project-graph';
+import { NxArgs } from '../utils/command-line-utils';
+export declare function getCommandProjects(projectGraph: ProjectGraph, projects: ProjectGraphProjectNode[], nxArgs: NxArgs): string[];

package/src/commands-runner/get-command-projects.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCommandProjects = getCommandProjects;
+const utils_1 = require("../tasks-runner/utils");
+const create_command_graph_1 = require("./create-command-graph");
+function getCommandProjects(projectGraph, projects, nxArgs) {
+    const commandGraph = (0, create_command_graph_1.createCommandGraph)(projectGraph, projects.map((project) => project.name), nxArgs);
+    return getSortedProjects(commandGraph);
+}
+function getSortedProjects(commandGraph, sortedProjects = []) {
+    const roots = commandGraph.roots;
+    if (!roots.length) {
+        return sortedProjects;
+    }
+    sortedProjects.push(...roots);
+    const newGraph = (0, utils_1.removeIdsFromGraph)(commandGraph, roots, commandGraph.dependencies);
+    return getSortedProjects(newGraph, sortedProjects);
+}

package/src/config/calculate-default-project-name.d.ts

@@ -0,0 +1,4 @@
+import type { NxJsonConfiguration } from './nx-json';
+import { ProjectConfiguration, ProjectsConfigurations } from './workspace-json-project-json';
+export declare function calculateDefaultProjectName(cwd: string, root: string, { projects }: ProjectsConfigurations, nxJson: NxJsonConfiguration): string;
+export declare function findMatchingProjectInCwd(projects: Record<string, ProjectConfiguration>, relativeCwd: string): string | undefined;

package/src/config/calculate-default-project-name.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateDefaultProjectName = calculateDefaultProjectName;
+exports.findMatchingProjectInCwd = findMatchingProjectInCwd;
+const find_project_for_path_1 = require("../project-graph/utils/find-project-for-path");
+const path_1 = require("path");
+function calculateDefaultProjectName(cwd, root, { projects }, nxJson) {
+    const relativeCwd = (0, path_1.relative)(root, cwd).replace(/\\/g, '/') ?? null;
+    if (relativeCwd !== null) {
+        const matchingProject = findMatchingProjectInCwd(projects, relativeCwd);
+        // We have found a project
+        if (matchingProject) {
+            // That is not at the root
+            if (projects[matchingProject].root !== '.' &&
+                projects[matchingProject].root !== '') {
+                return matchingProject;
+                // But its at the root, and NX_DEFAULT_PROJECT is set
+            }
+            else if (process.env.NX_DEFAULT_PROJECT) {
+                return process.env.NX_DEFAULT_PROJECT;
+                // Its root, and NX_DEFAULT_PROJECT is not set
+            }
+            else {
+                return matchingProject;
+            }
+        }
+    }
+    // There was no matching project in cwd.
+    return (process.env.NX_DEFAULT_PROJECT ??
+        nxJson.cli?.defaultProjectName ??
+        nxJson?.defaultProject);
+}
+function findMatchingProjectInCwd(projects, relativeCwd) {
+    const projectRootMappings = new Map();
+    for (const projectName of Object.keys(projects)) {
+        const { root } = projects[projectName];
+        projectRootMappings.set((0, find_project_for_path_1.normalizeProjectRoot)(root), projectName);
+    }
+    const matchingProject = (0, find_project_for_path_1.findProjectForPath)(relativeCwd, projectRootMappings);
+    return matchingProject;
+}

package/src/config/configuration.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Returns information about where apps and libs will be created.
+ */
+export declare function workspaceLayout(): {
+    appsDir: string;
+    libsDir: string;
+};
+export { readNxJson } from './nx-json';

package/src/config/configuration.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readNxJson = void 0;
+exports.workspaceLayout = workspaceLayout;
+const nx_json_1 = require("./nx-json");
+/**
+ * Returns information about where apps and libs will be created.
+ */
+function workspaceLayout() {
+    const nxJson = (0, nx_json_1.readNxJson)();
+    return {
+        appsDir: nxJson.workspaceLayout?.appsDir ?? 'apps',
+        libsDir: nxJson.workspaceLayout?.libsDir ?? 'libs',
+    };
+}
+var nx_json_2 = require("./nx-json");
+Object.defineProperty(exports, "readNxJson", { enumerable: true, get: function () { return nx_json_2.readNxJson; } });

package/src/config/misc-interfaces.d.ts

@@ -0,0 +1,212 @@
+import { Hash, TaskHasher } from '../hasher/task-hasher';
+import { ProjectGraph } from './project-graph';
+import { Task, TaskGraph } from './task-graph';
+import { TargetConfiguration, ProjectsConfigurations } from './workspace-json-project-json';
+import type { NxJsonConfiguration } from './nx-json';
+import { Schema } from '../utils/params';
+/**
+ * A callback function that is executed after changes are made to the file system
+ */
+export type GeneratorCallback = () => void | Promise<void>;
+/**
+ * A function that schedules updates to the filesystem to be done atomically
+ */
+export type Generator<T = unknown> = (tree: any, schema: T) => void | GeneratorCallback | Promise<void | GeneratorCallback>;
+export interface GeneratorsJsonEntry {
+    hidden?: boolean;
+    schema: string;
+    implementation?: string;
+    factory?: string;
+    description?: string;
+    aliases?: string[];
+    cli?: 'nx';
+    'x-type'?: 'library' | 'application';
+    'x-deprecated'?: string;
+    'x-use-standalone-layout'?: boolean;
+}
+export type OutputCaptureMethod = 'direct-nodejs' | 'pipe';
+export interface ExecutorJsonEntryConfig {
+    schema: string;
+    implementation: string;
+    batchImplementation?: string;
+    description?: string;
+    hasher?: string;
+}
+export type ExecutorsJsonEntry = string | ExecutorJsonEntryConfig;
+export type Dependencies = 'dependencies' | 'devDependencies';
+export interface PackageJsonUpdateForPackage {
+    version: string;
+    ifPackageInstalled?: string;
+    alwaysAddToPackageJson?: boolean | Dependencies;
+    addToPackageJson?: boolean | Dependencies;
+}
+export type PackageJsonUpdates = {
+    [name: string]: {
+        version: string;
+        packages: {
+            [packageName: string]: PackageJsonUpdateForPackage;
+        };
+        'x-prompt'?: string;
+        requires?: Record<string, string>;
+    };
+};
+export interface MigrationsJsonEntry {
+    version: string;
+    description?: string;
+    cli?: string;
+    implementation?: string;
+    factory?: string;
+    requires?: Record<string, string>;
+}
+export interface MigrationsJson {
+    name?: string;
+    version?: string;
+    collection?: string;
+    generators?: {
+        [name: string]: MigrationsJsonEntry;
+    };
+    schematics?: {
+        [name: string]: MigrationsJsonEntry;
+    };
+    packageJsonUpdates?: PackageJsonUpdates;
+}
+export interface GeneratorsJson {
+    extends?: string;
+    schematics?: Record<string, GeneratorsJsonEntry>;
+    generators?: Record<string, GeneratorsJsonEntry>;
+}
+export interface ExecutorsJson {
+    executors?: Record<string, ExecutorsJsonEntry>;
+    builders?: Record<string, ExecutorsJsonEntry>;
+}
+export interface ExecutorConfig {
+    schema: {
+        version?: number;
+        outputCapture?: OutputCaptureMethod;
+    } & Schema;
+    hasherFactory?: () => CustomHasher;
+    implementationFactory: () => Executor;
+    batchImplementationFactory?: () => TaskGraphExecutor;
+}
+/**
+ * An executor implementation that returns a promise
+ */
+export type PromiseExecutor<T = any> = (
+/**
+ * Options that users configure or pass via the command line
+ */
+options: T, context: ExecutorContext) => Promise<{
+    success: boolean;
+}>;
+/**
+ * An executor implementation that returns an async iterator
+ */
+export type AsyncIteratorExecutor<T = any> = (
+/**
+ * Options that users configure or pass via the command line
+ */
+options: T, context: ExecutorContext) => AsyncIterableIterator<{
+    success: boolean;
+}>;
+/**
+ * Implementation of a target of a project
+ */
+export type Executor<T = any> = PromiseExecutor<T> | AsyncIteratorExecutor<T>;
+export interface HasherContext {
+    hasher: TaskHasher;
+    projectGraph: ProjectGraph;
+    taskGraph: TaskGraph;
+    projectsConfigurations: ProjectsConfigurations;
+    nxJsonConfiguration: NxJsonConfiguration;
+}
+export type CustomHasher = (task: Task, context: HasherContext) => Promise<Hash>;
+export type TaskResult = {
+    success: boolean;
+    terminalOutput: string;
+    startTime?: number;
+    endTime?: number;
+};
+export type BatchExecutorResult = Record<string, TaskResult>;
+export type BatchExecutorTaskResult = {
+    task: string;
+    result: TaskResult;
+};
+/**
+ * Implementation of a target of a project that handles multiple projects to be batched
+ */
+export type TaskGraphExecutor<T = any> = (
+/**
+ * Graph of Tasks to be executed
+ */
+taskGraph: TaskGraph, 
+/**
+ * Map of Task IDs to options for the task
+ */
+options: Record<string, T>, 
+/**
+ * Set of overrides for the overall execution
+ */
+overrides: T, context: ExecutorContext) => Promise<BatchExecutorResult | AsyncIterableIterator<BatchExecutorTaskResult>>;
+/**
+ * Context that is passed into an executor
+ */
+export interface ExecutorContext {
+    /**
+     * The root of the workspace
+     */
+    root: string;
+    /**
+     * The name of the project being executed on
+     */
+    projectName?: string;
+    /**
+     * The name of the target being executed
+     */
+    targetName?: string;
+    /**
+     * The name of the configuration being executed
+     */
+    configurationName?: string;
+    /**
+     * The configuration of the target being executed
+     */
+    target?: TargetConfiguration;
+    /**
+     * Projects config
+     *
+     * @todo(vsavkin): mark this as required for v17
+     */
+    projectsConfigurations?: ProjectsConfigurations;
+    /**
+     * The contents of nx.json.
+     *
+     * @todo(vsavkin): mark this as required for v17
+     */
+    nxJsonConfiguration?: NxJsonConfiguration;
+    /**
+     * The current working directory
+     */
+    cwd: string;
+    /**
+     * Enable verbose logging
+     */
+    isVerbose: boolean;
+    /**
+     * A snapshot of the project graph as
+     * it existed when the Nx command was kicked off
+     *
+     * @todo(vsavkin) mark this required for v17
+     */
+    projectGraph?: ProjectGraph;
+    /**
+     * A snapshot of the task graph as
+     * it existed when the Nx command was kicked off
+     */
+    taskGraph?: TaskGraph;
+    /**
+     * Deprecated. Use projectsConfigurations or nxJsonConfiguration
+     * The full workspace configuration
+     * @todo(vsavkin): remove after v17
+     */
+    workspace?: ProjectsConfigurations & NxJsonConfiguration;
+}

package/src/config/misc-interfaces.js

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