@ohos-ports/nx 17.3.2-beta.0

package/src/executors/run-commands/run-commands.impl.js

@@ -0,0 +1,247 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.interpolateArgsIntoCommand = exports.LARGE_BUFFER = void 0;
+const child_process_1 = require("child_process");
+const path = require("path");
+const yargsParser = require("yargs-parser");
+const npm_run_path_1 = require("npm-run-path");
+const chalk = require("chalk");
+const native_1 = require("../../native");
+const child_process_2 = require("../../utils/child-process");
+exports.LARGE_BUFFER = 1024 * 1000000;
+async function loadEnvVars(path) {
+    if (path) {
+        const result = (await Promise.resolve().then(() => require('dotenv'))).config({ path });
+        if (result.error) {
+            throw result.error;
+        }
+    }
+    else {
+        try {
+            (await Promise.resolve().then(() => require('dotenv'))).config();
+        }
+        catch { }
+    }
+}
+const propKeys = [
+    'command',
+    'commands',
+    'color',
+    'parallel',
+    'readyWhen',
+    'cwd',
+    'args',
+    'envFile',
+];
+async function default_1(options, context) {
+    await loadEnvVars(options.envFile);
+    const normalized = normalizeOptions(options);
+    if (options.readyWhen && !options.parallel) {
+        throw new Error('ERROR: Bad executor config for run-commands - "readyWhen" can only be used when "parallel=true".');
+    }
+    if (options.commands.find((c) => c.prefix || c.color || c.bgColor) &&
+        !options.parallel) {
+        throw new Error('ERROR: Bad executor config for run-commands - "prefix", "color" and "bgColor" can only be set when "parallel=true".');
+    }
+    try {
+        const success = options.parallel
+            ? await runInParallel(normalized, context)
+            : await runSerially(normalized, context);
+        return { success };
+    }
+    catch (e) {
+        if (process.env.NX_VERBOSE_LOGGING === 'true') {
+            console.error(e);
+        }
+        throw new Error(`ERROR: Something went wrong in run-commands - ${e.message}`);
+    }
+}
+exports.default = default_1;
+async function runInParallel(options, context) {
+    const procs = options.commands.map((c) => createProcess(c, options.readyWhen, options.color, calculateCwd(options.cwd, context), options.env ?? {}, true).then((result) => ({
+        result,
+        command: c.command,
+    })));
+    if (options.readyWhen) {
+        const r = await Promise.race(procs);
+        if (!r.result) {
+            process.stderr.write(`Warning: run-commands command "${r.command}" exited with non-zero status code`);
+            return false;
+        }
+        else {
+            return true;
+        }
+    }
+    else {
+        const r = await Promise.all(procs);
+        const failed = r.filter((v) => !v.result);
+        if (failed.length > 0) {
+            failed.forEach((f) => {
+                process.stderr.write(`Warning: run-commands command "${f.command}" exited with non-zero status code`);
+            });
+            return false;
+        }
+        else {
+            return true;
+        }
+    }
+}
+function normalizeOptions(options) {
+    if (options.command) {
+        options.commands = [{ command: options.command }];
+        options.parallel = !!options.readyWhen;
+    }
+    else {
+        options.commands = options.commands.map((c) => typeof c === 'string' ? { command: c } : c);
+    }
+    if (options.args && Array.isArray(options.args)) {
+        options.args = options.args.join(' ');
+    }
+    options.parsedArgs = parseArgs(options, options.args);
+    options.commands.forEach((c) => {
+        c.command = interpolateArgsIntoCommand(c.command, options, c.forwardAllArgs ?? true);
+    });
+    return options;
+}
+async function runSerially(options, context) {
+    for (const c of options.commands) {
+        const success = await createProcess(c, undefined, options.color, calculateCwd(options.cwd, context), options.env ?? {}, false);
+        if (!success) {
+            process.stderr.write(`Warning: run-commands command "${c.command}" exited with non-zero status code`);
+            return false;
+        }
+    }
+    return true;
+}
+async function createProcess(commandConfig, readyWhen, color, cwd, env, isParallel) {
+    env = processEnv(color, cwd, env);
+    // The rust runCommand is always a tty, so it will not look nice in parallel and if we need prefixes
+    // currently does not work properly in windows
+    if (process.env.NX_NATIVE_COMMAND_RUNNER !== 'false' &&
+        process.stdout.isTTY &&
+        !commandConfig.prefix &&
+        !isParallel) {
+        const cp = new child_process_2.PseudoTtyProcess((0, native_1.runCommand)(commandConfig.command, cwd, env));
+        return new Promise((res) => {
+            cp.onOutput((output) => {
+                if (readyWhen && output.indexOf(readyWhen) > -1) {
+                    res(true);
+                }
+            });
+            cp.onExit((code) => {
+                if (code === 0) {
+                    res(true);
+                }
+                else if (code >= 128) {
+                    process.exit(code);
+                }
+                else {
+                    res(false);
+                }
+            });
+        });
+    }
+    return nodeProcess(commandConfig, color, cwd, env, readyWhen);
+}
+function nodeProcess(commandConfig, color, cwd, env, readyWhen) {
+    return new Promise((res) => {
+        const childProcess = (0, child_process_1.exec)(commandConfig.command, {
+            maxBuffer: exports.LARGE_BUFFER,
+            env,
+            cwd,
+        });
+        /**
+         * Ensure the child process is killed when the parent exits
+         */
+        const processExitListener = (signal) => childProcess.kill(signal);
+        process.on('exit', processExitListener);
+        process.on('SIGTERM', processExitListener);
+        process.on('SIGINT', processExitListener);
+        process.on('SIGQUIT', processExitListener);
+        childProcess.stdout.on('data', (data) => {
+            process.stdout.write(addColorAndPrefix(data, commandConfig));
+            if (readyWhen && data.toString().indexOf(readyWhen) > -1) {
+                res(true);
+            }
+        });
+        childProcess.stderr.on('data', (err) => {
+            process.stderr.write(addColorAndPrefix(err, commandConfig));
+            if (readyWhen && err.toString().indexOf(readyWhen) > -1) {
+                res(true);
+            }
+        });
+        childProcess.on('error', (err) => {
+            process.stderr.write(addColorAndPrefix(err.toString(), commandConfig));
+            res(false);
+        });
+        childProcess.on('exit', (code) => {
+            if (!readyWhen) {
+                res(code === 0);
+            }
+        });
+    });
+}
+function addColorAndPrefix(out, config) {
+    if (config.prefix) {
+        out = out
+            .split('\n')
+            .map((l) => l.trim().length > 0 ? `${chalk.bold(config.prefix)} ${l}` : l)
+            .join('\n');
+    }
+    if (config.color && chalk[config.color]) {
+        out = chalk[config.color](out);
+    }
+    if (config.bgColor && chalk[config.bgColor]) {
+        out = chalk[config.bgColor](out);
+    }
+    return out;
+}
+function calculateCwd(cwd, context) {
+    if (!cwd)
+        return context.root;
+    if (path.isAbsolute(cwd))
+        return cwd;
+    return path.join(context.root, cwd);
+}
+function processEnv(color, cwd, env) {
+    const res = {
+        ...process.env,
+        ...(0, npm_run_path_1.env)({ cwd: cwd ?? process.cwd() }),
+        ...env,
+    };
+    if (color) {
+        res.FORCE_COLOR = `${color}`;
+    }
+    return res;
+}
+function interpolateArgsIntoCommand(command, opts, forwardAllArgs) {
+    if (command.indexOf('{args.') > -1) {
+        const regex = /{args\.([^}]+)}/g;
+        return command.replace(regex, (_, group) => opts.parsedArgs[group] !== undefined ? opts.parsedArgs[group] : '');
+    }
+    else if (forwardAllArgs) {
+        return `${command}${opts.args ? ' ' + opts.args : ''}${opts.__unparsed__.length > 0 ? ' ' + opts.__unparsed__.join(' ') : ''}`;
+    }
+    else {
+        return command;
+    }
+}
+exports.interpolateArgsIntoCommand = interpolateArgsIntoCommand;
+function parseArgs(options, args) {
+    if (!args) {
+        const unknownOptionsTreatedAsArgs = Object.keys(options)
+            .filter((p) => propKeys.indexOf(p) === -1)
+            .reduce((m, c) => ((m[c] = options[c]), m), {});
+        const unparsedCommandArgs = yargsParser(options.__unparsed__, {
+            configuration: {
+                'parse-numbers': false,
+                'parse-positional-numbers': false,
+                'dot-notation': false,
+            },
+        });
+        return { ...unknownOptionsTreatedAsArgs, ...unparsedCommandArgs };
+    }
+    return yargsParser(args.replace(/(^"|"$)/g, ''), {
+        configuration: { 'camel-case-expansion': false },
+    });
+}

package/src/executors/run-commands/schema.json

@@ -0,0 +1,150 @@
+{
+  "version": 2,
+  "title": "Run Commands",
+  "description": "Run any custom commands with Nx.",
+  "type": "object",
+  "cli": "nx",
+  "outputCapture": "pipe",
+  "presets": [
+    {
+      "name": "Arguments forwarding",
+      "keys": ["commands"]
+    },
+    {
+      "name": "Custom done conditions",
+      "keys": ["commands", "readyWhen"]
+    },
+    {
+      "name": "Setting the cwd",
+      "keys": ["commands", "cwd"]
+    }
+  ],
+  "properties": {
+    "commands": {
+      "type": "array",
+      "description": "Commands to run in child process.",
+      "items": {
+        "oneOf": [
+          {
+            "type": "object",
+            "properties": {
+              "command": {
+                "type": "string",
+                "description": "Command to run in child process."
+              },
+              "forwardAllArgs": {
+                "type": "boolean",
+                "description": "Whether arguments should be forwarded when interpolation is not present."
+              },
+              "prefix": {
+                "type": "string",
+                "description": "Prefix in front of every line out of the output"
+              },
+              "color": {
+                "type": "string",
+                "description": "Color of the output",
+                "enum": [
+                  "black",
+                  "red",
+                  "green",
+                  "yellow",
+                  "blue",
+                  "magenta",
+                  "cyan",
+                  "white"
+                ]
+              },
+              "bgColor": {
+                "type": "string",
+                "description": "Background color of the output",
+                "enum": [
+                  "bgBlack",
+                  "bgRed",
+                  "bgGreen",
+                  "bgYellow",
+                  "bgBlue",
+                  "bgMagenta",
+                  "bgCyan",
+                  "bgWhite"
+                ]
+              },
+              "description": {
+                "type": "string",
+                "description": "An optional description useful for inline documentation purposes. It is not used as part of the execution of the command."
+              }
+            },
+            "additionalProperties": false,
+            "required": ["command"]
+          },
+          {
+            "type": "string"
+          }
+        ]
+      },
+      "x-priority": "important"
+    },
+    "command": {
+      "type": "string",
+      "description": "Command to run in child process.",
+      "x-priority": "important"
+    },
+    "parallel": {
+      "type": "boolean",
+      "description": "Run commands in parallel.",
+      "default": true,
+      "x-priority": "important"
+    },
+    "readyWhen": {
+      "type": "string",
+      "description": "String to appear in `stdout` or `stderr` that indicates that the task is done. When running multiple commands, this option can only be used when `parallel` is set to `true`. If not specified, the task is done when all the child processes complete."
+    },
+    "args": {
+      "oneOf": [
+        { "type": "array", "items": { "type": "string" } },
+        { "type": "string" }
+      ],
+      "description": "Extra arguments. You can pass them as follows: nx run project:target --args='--wait=100'. You can then use {args.wait} syntax to interpolate them in the workspace config file. See example [above](#chaining-commands-interpolating-args-and-setting-the-cwd)"
+    },
+    "envFile": {
+      "type": "string",
+      "description": "You may specify a custom .env file path."
+    },
+    "color": {
+      "type": "boolean",
+      "description": "Use colors when showing output of command.",
+      "default": false
+    },
+    "cwd": {
+      "type": "string",
+      "description": "Current working directory of the commands. If it's not specified the commands will run in the workspace root, if a relative path is specified the commands will run in that path relative to the workspace root and if it's an absolute path the commands will run in that path."
+    },
+    "env": {
+      "type": "object",
+      "description": "Environment variables that will be made available to the commands. This property has priority over the `.env` files.",
+      "additionalProperties": {
+        "type": "string"
+      }
+    },
+    "__unparsed__": {
+      "hidden": true,
+      "type": "array",
+      "items": {
+        "type": "string"
+      },
+      "$default": {
+        "$source": "unparsed"
+      },
+      "x-priority": "internal"
+    }
+  },
+  "additionalProperties": true,
+  "oneOf": [
+    {
+      "required": ["commands"]
+    },
+    {
+      "required": ["command"]
+    }
+  ],
+  "examplesFile": "../../../docs/run-commands-examples.md"
+}

package/src/executors/run-script/run-script.impl.d.ts

@@ -0,0 +1,8 @@
+import type { ExecutorContext } from '../../config/misc-interfaces';
+export interface RunScriptOptions {
+    script: string;
+    __unparsed__: string[];
+}
+export default function (options: RunScriptOptions, context: ExecutorContext): Promise<{
+    success: boolean;
+}>;

package/src/executors/run-script/run-script.impl.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = require("path");
+const native_1 = require("../../native");
+const child_process_1 = require("../../utils/child-process");
+const package_manager_1 = require("../../utils/package-manager");
+const child_process_2 = require("child_process");
+async function default_1(options, context) {
+    const pm = (0, package_manager_1.getPackageManagerCommand)();
+    try {
+        let command = pm.run(options.script, options.__unparsed__.join(' '));
+        let cwd = path.join(context.root, context.projectsConfigurations.projects[context.projectName].root);
+        let env = process.env;
+        // when running nx through npx with node_modules installed with npm, the path gets modified to include the full workspace path with the node_modules folder
+        // This causes issues when running in a pty process, so we filter out the node_modules paths from the PATH
+        // Since the command here will be run with the package manager script command, the path will be modified again within the PTY process itself.
+        let filteredPath = env.PATH?.split(path.delimiter)
+            .filter((p) => !p.startsWith(path.join(context.root, 'node_modules')))
+            .join(path.delimiter) ?? '';
+        env.PATH = filteredPath;
+        if (process.stdout.isTTY) {
+            await ptyProcess(command, cwd, env);
+        }
+        else {
+            nodeProcess(command, cwd, env);
+        }
+        return { success: true };
+    }
+    catch (e) {
+        return { success: false };
+    }
+}
+exports.default = default_1;
+function nodeProcess(command, cwd, env) {
+    (0, child_process_2.execSync)(command, {
+        stdio: ['inherit', 'inherit', 'inherit'],
+        cwd,
+        env,
+    });
+}
+async function ptyProcess(command, cwd, env) {
+    return new Promise((res, rej) => {
+        const cp = new child_process_1.PseudoTtyProcess((0, native_1.runCommand)(command, cwd, env));
+        cp.onExit((code) => {
+            if (code === 0) {
+                res();
+            }
+            else if (code >= 128) {
+                process.exit(code);
+            }
+            else {
+                rej();
+            }
+        });
+    });
+}

package/src/executors/run-script/schema.json

@@ -0,0 +1,28 @@
+{
+  "version": 2,
+  "title": "Run Script",
+  "description": "Run any NPM script of a project in the project's root directory.",
+  "type": "object",
+  "cli": "nx",
+  "outputCapture": "pipe",
+  "properties": {
+    "script": {
+      "type": "string",
+      "description": "An npm script name in the `package.json` file of the project (e.g., `build`)."
+    },
+    "__unparsed__": {
+      "hidden": true,
+      "type": "array",
+      "items": {
+        "type": "string"
+      },
+      "$default": {
+        "$source": "unparsed"
+      },
+      "x-priority": "internal"
+    }
+  },
+  "additionalProperties": true,
+  "required": ["script"],
+  "examplesFile": "../../../docs/run-script-examples.md"
+}

package/src/executors/utils/convert-nx-executor.d.ts

@@ -0,0 +1,10 @@
+/**
+ * This is a copy of the @nx/devkit utility but this should not be used outside of the nx package
+ */
+import { Executor } from '../../config/misc-interfaces';
+/**
+ * Convert an Nx Executor into an Angular Devkit Builder
+ *
+ * Use this to expose a compatible Angular Builder
+ */
+export declare function convertNxExecutor(executor: Executor): any;

package/src/executors/utils/convert-nx-executor.js

@@ -0,0 +1,82 @@
+"use strict";
+/**
+ * This is a copy of the @nx/devkit utility but this should not be used outside of the nx package
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertNxExecutor = void 0;
+const nx_json_1 = require("../../config/nx-json");
+const retrieve_workspace_files_1 = require("../../project-graph/utils/retrieve-workspace-files");
+/**
+ * Convert an Nx Executor into an Angular Devkit Builder
+ *
+ * Use this to expose a compatible Angular Builder
+ */
+function convertNxExecutor(executor) {
+    const builderFunction = (options, builderContext) => {
+        const promise = async () => {
+            const nxJsonConfiguration = (0, nx_json_1.readNxJson)(builderContext.workspaceRoot);
+            const projectsConfigurations = {
+                version: 2,
+                projects: (await (0, retrieve_workspace_files_1.retrieveProjectConfigurations)(builderContext.workspaceRoot, nxJsonConfiguration)).projects,
+            };
+            const context = {
+                root: builderContext.workspaceRoot,
+                projectName: builderContext.target.project,
+                targetName: builderContext.target.target,
+                target: builderContext.target.target,
+                configurationName: builderContext.target.configuration,
+                workspace: { ...nxJsonConfiguration, ...projectsConfigurations },
+                projectsConfigurations,
+                nxJsonConfiguration,
+                cwd: process.cwd(),
+                projectGraph: null,
+                taskGraph: null,
+                isVerbose: false,
+            };
+            return executor(options, context);
+        };
+        return toObservable(promise());
+    };
+    return require('@angular-devkit/architect').createBuilder(builderFunction);
+}
+exports.convertNxExecutor = convertNxExecutor;
+function toObservable(promiseOrAsyncIterator) {
+    return new (require('rxjs').Observable)((subscriber) => {
+        promiseOrAsyncIterator
+            .then((value) => {
+            if (!value.next) {
+                subscriber.next(value);
+                subscriber.complete();
+            }
+            else {
+                let asyncIterator = value;
+                function recurse(iterator) {
+                    iterator
+                        .next()
+                        .then((result) => {
+                        if (!result.done) {
+                            subscriber.next(result.value);
+                            recurse(iterator);
+                        }
+                        else {
+                            if (result.value) {
+                                subscriber.next(result.value);
+                            }
+                            subscriber.complete();
+                        }
+                    })
+                        .catch((e) => {
+                        subscriber.error(e);
+                    });
+                }
+                recurse(asyncIterator);
+                return () => {
+                    asyncIterator.return();
+                };
+            }
+        })
+            .catch((err) => {
+            subscriber.error(err);
+        });
+    });
+}

package/src/generators/internal-utils/format-changed-files-with-prettier-if-available.d.ts

@@ -0,0 +1,8 @@
+import type { Tree } from '../tree';
+/**
+ * Formats all the created or updated files using Prettier
+ * @param tree - the file system tree
+ */
+export declare function formatChangedFilesWithPrettierIfAvailable(tree: Tree, options?: {
+    silent?: boolean;
+}): Promise<void>;

package/src/generators/internal-utils/format-changed-files-with-prettier-if-available.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatChangedFilesWithPrettierIfAvailable = void 0;
+const path = require("path");
+/**
+ * Formats all the created or updated files using Prettier
+ * @param tree - the file system tree
+ */
+async function formatChangedFilesWithPrettierIfAvailable(tree, options) {
+    let prettier;
+    try {
+        prettier = await Promise.resolve().then(() => require('prettier'));
+    }
+    catch { }
+    if (!prettier)
+        return;
+    const files = new Set(tree.listChanges().filter((file) => file.type !== 'DELETE'));
+    await Promise.all(Array.from(files).map(async (file) => {
+        try {
+            const systemPath = path.join(tree.root, file.path);
+            let options = {
+                filepath: systemPath,
+            };
+            const resolvedOptions = await prettier.resolveConfig(systemPath, {
+                editorconfig: true,
+            });
+            if (!resolvedOptions) {
+                return;
+            }
+            options = {
+                ...options,
+                ...resolvedOptions,
+            };
+            const support = await prettier.getFileInfo(systemPath, options);
+            if (support.ignored || !support.inferredParser) {
+                return;
+            }
+            tree.write(file.path, 
+            // In prettier v3 the format result is a promise
+            await prettier.format(file.content.toString('utf-8'), options));
+        }
+        catch (e) {
+            if (!options?.silent) {
+                console.warn(`Could not format ${file.path}. Error: "${e.message}"`);
+            }
+        }
+    }));
+}
+exports.formatChangedFilesWithPrettierIfAvailable = formatChangedFilesWithPrettierIfAvailable;

package/src/generators/testing-utils/create-tree-with-empty-workspace.d.ts

@@ -0,0 +1,11 @@
+import type { Tree } from '../tree';
+/**
+ * Creates a host for testing.
+ */
+export declare function createTreeWithEmptyWorkspace(opts?: {
+    layout?: 'apps-libs';
+}): Tree;
+/**
+ * @deprecated use createTreeWithEmptyWorkspace instead
+ */
+export declare function createTreeWithEmptyV1Workspace(): Tree;