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

package/dist/src/utils/require-nx-key.d.ts

@@ -0,0 +1 @@
+export declare function requireNxKey(): Promise<typeof import('@nx/key')>;

package/dist/src/utils/require-nx-key.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requireNxKey = requireNxKey;
+const child_process_1 = require("child_process");
+const package_manager_1 = require("./package-manager");
+const handle_import_1 = require("./handle-import");
+async function requireNxKey() {
+    // @ts-ignore
+    return (0, handle_import_1.handleImport)('@nx/key').catch(async (e) => {
+        if ('code' in e && e.code === 'MODULE_NOT_FOUND') {
+            try {
+                (0, child_process_1.execSync)(`${(0, package_manager_1.getPackageManagerCommand)().addDev} @nx/key@latest`, {
+                    windowsHide: true,
+                });
+                // @ts-ignore
+                return await (0, handle_import_1.handleImport)('@nx/key');
+            }
+            catch (e) {
+                throw new Error('Failed to install @nx/key. Please install @nx/key and try again.');
+            }
+        }
+    });
+}

package/dist/src/utils/safe-spawn.d.ts

@@ -0,0 +1,24 @@
+import { ChildProcess, ExecFileSyncOptions, SpawnOptions } from 'child_process';
+/**
+ * Spawn a binary that may be a Windows `.cmd`/`.bat` shim, without letting its
+ * arguments become shell syntax.
+ *
+ * Off Windows, and for a `.exe`, no shell is involved at all. Where one is —
+ * a shim or a bare name — the binary and every argument are quoted for cmd.exe.
+ *
+ * Not a complete guarantee: cmd.exe expands `%VAR%` in the binary or any
+ * argument whether or not it is quoted, so a caller with untrusted arguments
+ * inherits that gap (NXC-4798). See the note on `LINE_BREAK` above.
+ *
+ * @throws on Windows when the binary or an argument contains a line break, or a
+ * literal `"` (via `quoteShellArg`). Those are the only refusals — the `%`
+ * expansion above is not one of them.
+ */
+export declare function safeSpawn(binary: string, args: readonly string[], options?: Omit<SpawnOptions, 'shell'>): ChildProcess;
+/**
+ * Synchronous {@link safeSpawn}, returning the child's stdout.
+ *
+ * Carries the same Windows caveats: `%VAR%` is expanded quoted or not
+ * (NXC-4798), and a line break or literal `"` throws.
+ */
+export declare function safeExecFileSync(binary: string, args: readonly string[], options?: Omit<ExecFileSyncOptions, 'encoding' | 'shell'>): string;

package/dist/src/utils/safe-spawn.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.safeSpawn = safeSpawn;
+exports.safeExecFileSync = safeExecFileSync;
+const child_process_1 = require("child_process");
+const path_1 = require("path");
+const shell_quoting_1 = require("./shell-quoting");
+// Node refuses to launch a Windows `.cmd`/`.bat` shim without a shell
+// (CVE-2024-27980). A bare name takes the shell for the same reason, one step
+// removed: libuv walks PATH and PATHEXT itself, so no shell is needed to *find*
+// the binary — but the walk may land on a `.cmd`/`.bat`, and this cannot know
+// which in advance, so it is deliberately conservative. Everything else,
+// including a `.exe`, spawns directly, so the shell and the quoting below reach
+// only the invocations that cannot do without them.
+//
+// Deliberately a function: a module-level const is fixed at import time, which
+// would make the Windows branch untestable.
+function needsShell(binary) {
+    if (process.platform !== 'win32') {
+        return false;
+    }
+    // win32.extname, not the platform default: this branch only runs on Windows,
+    // where `path` is win32 anyway, and pinning it lets a test model the real
+    // parse rather than posix's (which reads `C:\ws\my.app\gradlew` as `.app\gradlew`).
+    const ext = path_1.win32.extname(binary).toLowerCase();
+    return ext === '' || ext === '.cmd' || ext === '.bat';
+}
+// A line break ends the command line whatever the quoting, so nothing can carry
+// one.
+//
+// `%` is deliberately NOT refused, and this is a known gap rather than a safe
+// case. cmd.exe expands `%VAR%` whether or not the value is quoted — see
+// `quoteShellArg`'s own docstring in ./shell-quoting, which says so and pins it
+// with a test — so quoting contains nothing here. It applies to the binary path
+// as much as to the arguments, and an expansion yielding a `"` defeats the
+// literal-quote refusal below, because that inspects the pre-expansion bytes.
+// `bin/nx.ts` loads the workspace's own `.env` before the graph is built, so a
+// repo can set the variable too.
+//
+// Refusing `%` is what an earlier revision did, and it made any workspace under
+// a `%` path — a legal Windows directory name — fail graph construction. The gap
+// is bounded by the argument that bounds this whole class: a repo that can reach
+// here already has `mvnw` / `pom.xml` executing on its behalf. Closing it
+// properly is tracked as NXC-4798.
+const LINE_BREAK = /[\r\n]/;
+/**
+ * Spawn a binary that may be a Windows `.cmd`/`.bat` shim, without letting its
+ * arguments become shell syntax.
+ *
+ * Off Windows, and for a `.exe`, no shell is involved at all. Where one is —
+ * a shim or a bare name — the binary and every argument are quoted for cmd.exe.
+ *
+ * Not a complete guarantee: cmd.exe expands `%VAR%` in the binary or any
+ * argument whether or not it is quoted, so a caller with untrusted arguments
+ * inherits that gap (NXC-4798). See the note on `LINE_BREAK` above.
+ *
+ * @throws on Windows when the binary or an argument contains a line break, or a
+ * literal `"` (via `quoteShellArg`). Those are the only refusals — the `%`
+ * expansion above is not one of them.
+ */
+function safeSpawn(binary, args, options = {}) {
+    const shell = needsShell(binary);
+    return (0, child_process_1.spawn)(quoteBinary(binary, shell), quoteArgs(args, shell), {
+        ...options,
+        windowsHide: true,
+        shell,
+    });
+}
+/**
+ * Synchronous {@link safeSpawn}, returning the child's stdout.
+ *
+ * Carries the same Windows caveats: `%VAR%` is expanded quoted or not
+ * (NXC-4798), and a line break or literal `"` throws.
+ */
+function safeExecFileSync(binary, args, options = {}) {
+    const shell = needsShell(binary);
+    return (0, child_process_1.execFileSync)(quoteBinary(binary, shell), quoteArgs(args, shell), {
+        stdio: 'pipe',
+        ...options,
+        windowsHide: true,
+        shell,
+        encoding: 'utf-8',
+    });
+}
+// The binary needs quoting too: Node joins it into the same command line, so a
+// path holding a space or an `&` would split there.
+function quoteBinary(binary, shell) {
+    if (!shell) {
+        return binary;
+    }
+    return quoteForCmd(binary, `the path ${JSON.stringify(binary)}`);
+}
+function quoteForCmd(value, described, remedy = '') {
+    if (LINE_BREAK.test(value)) {
+        throw new Error(`Cannot pass ${described} to cmd.exe: a line break inside it would end the command line before cmd.exe reached the rest of it.${remedy}`);
+    }
+    return (0, shell_quoting_1.quoteShellArg)(value);
+}
+function quoteArgs(args, shell) {
+    if (!shell) {
+        return [...args];
+    }
+    return args.map((arg) => quoteForCmd(arg, `the argument ${JSON.stringify(arg)}`, ' Remove it from your Nx configuration and try again.'));
+}

package/dist/src/utils/serializable-error.d.ts

@@ -0,0 +1,4 @@
+/**
+ * This function transforms an error into an object which can be properly serialized and deserialized to be sent between processes.
+ */
+export declare function createSerializableError<T extends Error>(error: T): T;

package/dist/src/utils/serializable-error.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSerializableError = createSerializableError;
+/**
+ * This function transforms an error into an object which can be properly serialized and deserialized to be sent between processes.
+ */
+function createSerializableError(error) {
+    const res = {};
+    Object.getOwnPropertyNames(error).forEach((k) => {
+        let value = error[k];
+        // If an error has an error as a property such as cause, it will be transformed into a serializable error
+        if (typeof value === 'object' && value instanceof Error) {
+            value = createSerializableError(value);
+        }
+        // If an error has an array of errors as a property, they will be transformed into serializable errors
+        if (Array.isArray(value)) {
+            value = value.map((v) => {
+                if (typeof v === 'object' && v instanceof Error) {
+                    return createSerializableError(v);
+                    // Support for AggregateCreateNodesError
+                }
+                else if (Array.isArray(v) &&
+                    v.length === 2 &&
+                    v[1] instanceof Error) {
+                    return [v[0], createSerializableError(v[1])];
+                }
+                return v;
+            });
+        }
+        res[k] = value;
+    });
+    return res;
+}

package/dist/src/utils/serialize-overrides-into-command-line.d.ts

@@ -0,0 +1,3 @@
+export declare function serializeOverridesIntoCommandLine(options: {
+    [k: string]: any;
+}): string[];

package/dist/src/utils/serialize-overrides-into-command-line.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeOverridesIntoCommandLine = serializeOverridesIntoCommandLine;
+const shell_quoting_1 = require("./shell-quoting");
+function serializeOverridesIntoCommandLine(options) {
+    const unparsed = options._ ? [...options._] : [];
+    for (const key of Object.keys(options)) {
+        const value = options[key];
+        if (key !== '_') {
+            serializeOption(key, value, unparsed);
+        }
+    }
+    return unparsed;
+}
+function serializeOption(key, value, unparsed) {
+    if (value === true) {
+        unparsed.push(`--${key}`);
+    }
+    else if (value === false) {
+        unparsed.push(`--no-${key}`);
+    }
+    else if (Array.isArray(value)) {
+        value.forEach((item) => serializeOption(key, item, unparsed));
+    }
+    else if (Object.prototype.toString.call(value) === '[object Object]') {
+        for (const nestedKey of Object.keys(value)) {
+            serializeOption(`${key}.${nestedKey}`, value[nestedKey], unparsed);
+        }
+    }
+    else if (typeof value === 'string' &&
+        (0, shell_quoting_1.needsShellQuoting)(value) &&
+        !(0, shell_quoting_1.isAlreadyQuoted)(value)) {
+        const sanitized = value.replace(/"/g, String.raw `\"`);
+        unparsed.push(`--${key}="${sanitized}"`);
+    }
+    else if (value != null) {
+        unparsed.push(`--${key}=${value}`);
+    }
+}

package/dist/src/utils/serialize-target.d.ts

@@ -0,0 +1 @@
+export declare function serializeTarget(project: any, target: any, configuration: any): string;

package/dist/src/utils/serialize-target.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeTarget = serializeTarget;
+function serializeTarget(project, target, configuration) {
+    return [project, target, configuration].filter((part) => !!part).join(':');
+}

package/dist/src/utils/shell-quoting.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Check if a string contains shell metacharacters that require quoting.
+ * These characters have special meaning in shell and would be interpreted
+ * incorrectly if not quoted (e.g., | for pipe, & for background, etc.)
+ */
+export declare function needsShellQuoting(str: string): boolean;
+/**
+ * Check if a string is already wrapped in matching quotes (single or double).
+ */
+export declare function isAlreadyQuoted(str: string): boolean;
+/**
+ * Quote a string so it survives being interpolated into a shell command line
+ * as a single argument.
+ *
+ * On Windows the safety boundary is one unbroken double-quoted run: it keeps
+ * `^`, `&`, `|`, `<` and `>` literal through cmd.exe's parse and a `.cmd`
+ * shim's re-parse of `%*`, but not `%`, which cmd.exe expands inside double
+ * quotes too.
+ *
+ * @throws on Windows when the argument contains a double quote, which ends that
+ * run, since cmd.exe recognizes no backslash escape. Carrying one means
+ * caret-escaping every metacharacter instead, doubled for a `.cmd` shim, which
+ * this path does not implement.
+ */
+export declare function quoteShellArg(arg: string): string;

package/dist/src/utils/shell-quoting.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.needsShellQuoting = needsShellQuoting;
+exports.isAlreadyQuoted = isAlreadyQuoted;
+exports.quoteShellArg = quoteShellArg;
+/**
+ * Shell metacharacters that have special meaning and require quoting.
+ *
+ * Characters included:
+ * - | - pipe
+ * - & - background/AND
+ * - ; - command separator
+ * - < > - redirections
+ * - ( ) - subshell
+ * - $ - variable expansion
+ * - ` - command substitution
+ * - \ - escape
+ * - " ' - quotes
+ * - * ? [ ] - globbing
+ * - { } - brace expansion
+ * - ~ - home directory
+ * - # - comment
+ * - ! - history expansion
+ * - \s - whitespace (spaces, tabs, newlines)
+ */
+const SHELL_META_CHARS = /[|&;<>()$`\\!"'*?[\]{}~#\s]/;
+/**
+ * Check if a string contains shell metacharacters that require quoting.
+ * These characters have special meaning in shell and would be interpreted
+ * incorrectly if not quoted (e.g., | for pipe, & for background, etc.)
+ */
+function needsShellQuoting(str) {
+    return SHELL_META_CHARS.test(str);
+}
+/**
+ * Check if a string is already wrapped in matching quotes (single or double).
+ */
+function isAlreadyQuoted(str) {
+    return (str.length >= 2 &&
+        ((str[0] === "'" && str[str.length - 1] === "'") ||
+            (str[0] === '"' && str[str.length - 1] === '"')));
+}
+/**
+ * Quote a string so it survives being interpolated into a shell command line
+ * as a single argument.
+ *
+ * On Windows the safety boundary is one unbroken double-quoted run: it keeps
+ * `^`, `&`, `|`, `<` and `>` literal through cmd.exe's parse and a `.cmd`
+ * shim's re-parse of `%*`, but not `%`, which cmd.exe expands inside double
+ * quotes too.
+ *
+ * @throws on Windows when the argument contains a double quote, which ends that
+ * run, since cmd.exe recognizes no backslash escape. Carrying one means
+ * caret-escaping every metacharacter instead, doubled for a `.cmd` shim, which
+ * this path does not implement.
+ */
+function quoteShellArg(arg) {
+    const isWindows = process.platform === 'win32';
+    if (isWindows && arg.includes('"')) {
+        throw new Error(`Cannot safely pass ${arg} to cmd.exe as a single argument: a double quote inside it would end the quoting and leave the rest of the argument to be read as commands. Remove the double quote and run the command again.`);
+    }
+    if (arg === '') {
+        // an unquoted empty string would vanish when joined into a command line
+        return isWindows ? '""' : "''";
+    }
+    // `^` is cmd.exe syntax rather than shell syntax, so it earns quoting only
+    // where cmd.exe parses the command line.
+    if (!needsShellQuoting(arg) && !(isWindows && arg.includes('^'))) {
+        return arg;
+    }
+    return isWindows
+        ? // MSVCRT reads the backslashes that precede the closing quote as escapes,
+            // so they have to be doubled to survive as themselves.
+            `"${arg.replace(/(\\+)$/, '$1$1')}"`
+        : `'${arg.replace(/'/g, `'\\''`)}'`;
+}

package/dist/src/utils/socket-refused-exit-code.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Exit code a process uses when the operating system refused the unix socket it
+ * tried to bind, as distinct from every other way it can die.
+ *
+ * A process that cannot bind leaves its parent holding only "it exited", which
+ * an OOM kill and a broken install produce just as well, and the errno itself
+ * never crosses the process boundary. Both the Nx daemon and the plugin worker
+ * bind in a child whose stderr the parent may never see, so this code is how
+ * each one's parent learns it was a refusal and can degrade on proof rather than
+ * on an environment guess. 78 is sysexits' EX_CONFIG, outside the range Node
+ * uses for its own fatal exits.
+ *
+ * Deliberately import-free: both producers read it on their startup path.
+ */
+export declare const SOCKET_REFUSED_EXIT_CODE = 78;

package/dist/src/utils/socket-refused-exit-code.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SOCKET_REFUSED_EXIT_CODE = void 0;
+/**
+ * Exit code a process uses when the operating system refused the unix socket it
+ * tried to bind, as distinct from every other way it can die.
+ *
+ * A process that cannot bind leaves its parent holding only "it exited", which
+ * an OOM kill and a broken install produce just as well, and the errno itself
+ * never crosses the process boundary. Both the Nx daemon and the plugin worker
+ * bind in a child whose stderr the parent may never see, so this code is how
+ * each one's parent learns it was a refusal and can degrade on proof rather than
+ * on an environment guess. 78 is sysexits' EX_CONFIG, outside the range Node
+ * uses for its own fatal exits.
+ *
+ * Deliberately import-free: both producers read it on their startup path.
+ */
+exports.SOCKET_REFUSED_EXIT_CODE = 78;

package/dist/src/utils/spinner.d.ts

@@ -0,0 +1,24 @@
+export declare const SHOULD_SHOW_SPINNERS: boolean;
+export interface StartSpinnerOptions {
+    /**
+     * When `true`, the text passed to `start`, `succeed`, and `fail` is NOT
+     * emitted in non-TTY environments. By default (`false`), the text is logged
+     * via `console.warn` so progress information isn't lost in non-interactive
+     * environments. Set to `true` when completion is reported through a
+     * different mechanism (e.g. a batched logger).
+     *
+     * Defaults to `false`.
+     */
+    skipNonTtyLogging?: boolean;
+}
+declare class SpinnerManager {
+    #private;
+    start(text?: string, prefix?: string, opts?: StartSpinnerOptions): SpinnerManager;
+    succeed(text?: string): void;
+    stop(): void;
+    fail(text?: string): void;
+    updateText(text?: string): void;
+    isSpinning(): boolean;
+}
+export declare const globalSpinner: SpinnerManager;
+export {};

package/dist/src/utils/spinner.js

@@ -0,0 +1,77 @@
+"use strict";
+var _SpinnerManager_instances, _SpinnerManager_ora, _SpinnerManager_prefix, _SpinnerManager_skipNonTtyLogging, _SpinnerManager_createOra, _SpinnerManager_handleNonTty;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.globalSpinner = exports.SHOULD_SHOW_SPINNERS = void 0;
+const tslib_1 = require("tslib");
+const ora_1 = tslib_1.__importDefault(require("ora"));
+const is_ci_1 = require("./is-ci");
+exports.SHOULD_SHOW_SPINNERS = process.stdout.isTTY && !(0, is_ci_1.isCI)();
+class SpinnerManager {
+    constructor() {
+        _SpinnerManager_instances.add(this);
+        _SpinnerManager_ora.set(this, void 0);
+        _SpinnerManager_prefix.set(this, void 0);
+        _SpinnerManager_skipNonTtyLogging.set(this, false);
+    }
+    start(text, prefix, opts) {
+        tslib_1.__classPrivateFieldSet(this, _SpinnerManager_skipNonTtyLogging, opts?.skipNonTtyLogging ?? false, "f");
+        if (tslib_1.__classPrivateFieldGet(this, _SpinnerManager_instances, "m", _SpinnerManager_handleNonTty).call(this, text)) {
+            return this;
+        }
+        if (prefix !== undefined) {
+            tslib_1.__classPrivateFieldSet(this, _SpinnerManager_prefix, prefix, "f");
+        }
+        if (tslib_1.__classPrivateFieldGet(this, _SpinnerManager_ora, "f")) {
+            tslib_1.__classPrivateFieldGet(this, _SpinnerManager_ora, "f").text = text;
+            tslib_1.__classPrivateFieldGet(this, _SpinnerManager_ora, "f").prefixText = tslib_1.__classPrivateFieldGet(this, _SpinnerManager_prefix, "f");
+        }
+        else {
+            tslib_1.__classPrivateFieldGet(this, _SpinnerManager_instances, "m", _SpinnerManager_createOra).call(this, text);
+        }
+        tslib_1.__classPrivateFieldGet(this, _SpinnerManager_ora, "f").start();
+        return this;
+    }
+    succeed(text) {
+        if (tslib_1.__classPrivateFieldGet(this, _SpinnerManager_instances, "m", _SpinnerManager_handleNonTty).call(this, text)) {
+            return;
+        }
+        tslib_1.__classPrivateFieldGet(this, _SpinnerManager_ora, "f")?.succeed(text);
+    }
+    stop() {
+        tslib_1.__classPrivateFieldGet(this, _SpinnerManager_ora, "f")?.stop();
+    }
+    fail(text) {
+        if (tslib_1.__classPrivateFieldGet(this, _SpinnerManager_instances, "m", _SpinnerManager_handleNonTty).call(this, text)) {
+            return;
+        }
+        tslib_1.__classPrivateFieldGet(this, _SpinnerManager_ora, "f")?.fail(text);
+    }
+    updateText(text) {
+        if (tslib_1.__classPrivateFieldGet(this, _SpinnerManager_ora, "f")) {
+            tslib_1.__classPrivateFieldGet(this, _SpinnerManager_ora, "f").text = text;
+        }
+        else if (exports.SHOULD_SHOW_SPINNERS) {
+            tslib_1.__classPrivateFieldGet(this, _SpinnerManager_instances, "m", _SpinnerManager_createOra).call(this, text);
+        }
+    }
+    isSpinning() {
+        return tslib_1.__classPrivateFieldGet(this, _SpinnerManager_ora, "f")?.isSpinning ?? false;
+    }
+}
+_SpinnerManager_ora = new WeakMap(), _SpinnerManager_prefix = new WeakMap(), _SpinnerManager_skipNonTtyLogging = new WeakMap(), _SpinnerManager_instances = new WeakSet(), _SpinnerManager_createOra = function _SpinnerManager_createOra(text) {
+    tslib_1.__classPrivateFieldSet(this, _SpinnerManager_ora, (0, ora_1.default)({
+        text: text,
+        prefixText: tslib_1.__classPrivateFieldGet(this, _SpinnerManager_prefix, "f"),
+        hideCursor: false,
+        discardStdin: false,
+    }), "f");
+}, _SpinnerManager_handleNonTty = function _SpinnerManager_handleNonTty(text) {
+    if (exports.SHOULD_SHOW_SPINNERS) {
+        return false;
+    }
+    if (!tslib_1.__classPrivateFieldGet(this, _SpinnerManager_skipNonTtyLogging, "f") && text) {
+        console.warn(text);
+    }
+    return true;
+};
+exports.globalSpinner = new SpinnerManager();

package/dist/src/utils/split-target.d.ts

@@ -0,0 +1,15 @@
+import { ProjectGraph, ProjectGraphProjectNode } from '../config/project-graph';
+import { ProjectConfiguration } from '../config/workspace-json-project-json';
+export interface SplitTargetOptions {
+    silent?: boolean;
+    currentProject?: string;
+}
+export declare function splitTargetFromNodes(s: string, nodes: Record<string, ProjectGraphProjectNode>, options?: SplitTargetOptions): [project: string, target?: string, configuration?: string];
+/**
+ * Splits a colon-delimited target specifier using a name-keyed
+ * `Record<string, ProjectConfiguration>` — the format used during
+ * the merge phase before the full project graph is available.
+ */
+export declare function splitTargetFromConfigurations(s: string, configs: Record<string, ProjectConfiguration>, options?: SplitTargetOptions): [project: string, target?: string, configuration?: string];
+export declare function splitTarget(s: string, projectGraph: ProjectGraph, options?: SplitTargetOptions): [project: string, target?: string, configuration?: string];
+export declare function splitByColons(s: string): [string, ...string[]];