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

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

@@ -1,198 +0,0 @@
-{
-    "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"
-                            },
-                            "prefixColor": {
-                                "type": "string",
-                                "description": "Color of the prefix",
-                                "enum": [
-                                    "black",
-                                    "red",
-                                    "green",
-                                    "yellow",
-                                    "blue",
-                                    "magenta",
-                                    "cyan",
-                                    "white"
-                                ]
-                            },
-                            "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": {
-            "oneOf": [
-                {
-                    "type": "array",
-                    "description": "Command to run in child process, but divided into parts.",
-                    "items": {
-                        "type": "string"
-                    },
-                    "x-priority": "important"
-                },
-                {
-                    "type": "string",
-                    "description": "Command to run in child process."
-                }
-            ],
-            "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": {
-            "description": "String or array of strings to appear in `stdout` or `stderr` that indicate 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.",
-            "oneOf": [
-                { "type": "string" },
-                { "type": "array", "items": { "type": "string" } }
-            ]
-        },
-        "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"
-        },
-        "forwardAllArgs": {
-            "type": "boolean",
-            "description": "Whether arguments should be forwarded when interpolation is not present.",
-            "default": true
-        },
-        "tty": {
-            "type": "boolean",
-            "description": "Whether commands should be run with a tty terminal",
-            "hidden": true
-        }
-    },
-    "additionalProperties": true,
-    "oneOf": [
-        {
-            "required": ["commands"]
-        },
-        {
-            "required": ["command"]
-        }
-    ],
-    "examplesFile": "../../../docs/run-commands-examples.md"
-}

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

@@ -1,8 +0,0 @@
-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/dist/src/executors/run-script/run-script.impl.js

@@ -1,86 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = default_1;
-const tslib_1 = require("tslib");
-const child_process_1 = require("child_process");
-const path = tslib_1.__importStar(require("path"));
-const native_1 = require("../../native");
-const pseudo_terminal_1 = require("../../tasks-runner/pseudo-terminal");
-const package_manager_1 = require("../../utils/package-manager");
-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 (pseudo_terminal_1.PseudoTerminal.isSupported()) {
-            await ptyProcess(command, cwd, env);
-        }
-        else {
-            await nodeProcess(command, cwd, env);
-        }
-        return { success: true };
-    }
-    catch (e) {
-        return { success: false };
-    }
-}
-function nodeProcess(command, cwd, env) {
-    return new Promise((res, rej) => {
-        let cp = (0, child_process_1.spawn)(command, [], {
-            shell: true,
-            cwd,
-            env,
-            windowsHide: true,
-        });
-        // Forward stdout/stderr to parent process
-        cp.stdout.pipe(process.stdout);
-        cp.stderr.pipe(process.stderr);
-        cp.on('error', (error) => {
-            rej(error);
-        });
-        cp.on('exit', (code) => {
-            if (code === 0) {
-                res();
-            }
-            else {
-                rej(new Error(`Command "${command}" exited with non-zero status code`));
-            }
-        });
-        const exitHandler = (signal) => {
-            if (cp && cp.pid && !cp.killed) {
-                (0, native_1.killProcessTreeGraceful)(cp.pid, signal).finally(() => {
-                    res();
-                });
-            }
-        };
-        process.on('SIGINT', () => exitHandler('SIGINT'));
-        process.on('SIGTERM', () => exitHandler('SIGTERM'));
-        process.on('SIGHUP', () => exitHandler('SIGHUP'));
-    });
-}
-async function ptyProcess(command, cwd, env) {
-    const terminal = (0, pseudo_terminal_1.createPseudoTerminal)();
-    await terminal.init();
-    return new Promise((res, rej) => {
-        let cp = terminal.runCommand(command, { cwd, jsEnv: env });
-        cp.onExit((code) => {
-            if (code === 0) {
-                res();
-            }
-            else if (code >= 128) {
-                process.exit(code);
-            }
-            else {
-                rej();
-            }
-        });
-    });
-}

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

@@ -1,28 +0,0 @@
-{
-    "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/dist/src/executors/utils/convert-nx-executor.d.ts

@@ -1,10 +0,0 @@
-/**
- * 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/dist/src/executors/utils/convert-nx-executor.js

@@ -1,83 +0,0 @@
-"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 = convertNxExecutor;
-const nx_json_1 = require("../../config/nx-json");
-const retrieve_workspace_files_1 = require("../../project-graph/utils/retrieve-workspace-files");
-const project_nodes_manager_1 = require("../../project-graph/utils/project-configuration/project-nodes-manager");
-const get_plugins_1 = require("../../project-graph/plugins/get-plugins");
-/**
- * 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 separatedPlugins = await (0, get_plugins_1.getPluginsSeparated)(nxJsonConfiguration);
-            const projectsConfigurations = {
-                version: 2,
-                projects: (0, project_nodes_manager_1.readProjectConfigurationsFromRootMap)((await (0, retrieve_workspace_files_1.retrieveProjectConfigurations)(separatedPlugins, 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,
-                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);
-}
-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/dist/src/generators/internal-utils/format-changed-files.d.ts

@@ -1,24 +0,0 @@
-import type { Tree } from '../tree';
-/**
- * Formats all the created or updated files using the configured formatter
- * @param tree - the file system tree
- *
- * @remarks
- * Set the environment variable `NX_SKIP_FORMAT` to `true` to skip
- * formatting. This is useful for repositories that format with a tool Nx does
- * not drive (Biome, dprint) or that have custom formatting requirements.
- */
-export declare function formatChangedFiles(tree: Tree, options?: {
-    silent?: boolean;
-    /**
-     * Tree-relative paths to leave untouched. Both platform-native and
-     * forward-slash separators are accepted.
-     */
-    excludePaths?: Set<string>;
-}): Promise<void>;
-export declare function formatFileContents(files: {
-    path: string;
-    content: string | Buffer;
-}[], root: string, options?: {
-    silent?: boolean;
-}): Promise<Map<string, string>>;

package/dist/src/generators/internal-utils/format-changed-files.js

@@ -1,163 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.formatChangedFiles = formatChangedFiles;
-exports.formatFileContents = formatFileContents;
-const tslib_1 = require("tslib");
-const path = tslib_1.__importStar(require("path"));
-const path_1 = require("../../utils/path");
-const formatters_1 = require("../../utils/formatters");
-const oxfmt_1 = require("../../utils/formatters/oxfmt");
-const installation_directory_1 = require("../../utils/installation-directory");
-const output_1 = require("../../utils/output");
-/**
- * Formats all the created or updated files using the configured formatter
- * @param tree - the file system tree
- *
- * @remarks
- * Set the environment variable `NX_SKIP_FORMAT` to `true` to skip
- * formatting. This is useful for repositories that format with a tool Nx does
- * not drive (Biome, dprint) or that have custom formatting requirements.
- */
-async function formatChangedFiles(tree, options) {
-    if (process.env.NX_SKIP_FORMAT === 'true') {
-        return;
-    }
-    const excludedPaths = options?.excludePaths
-        ? new Set(Array.from(options.excludePaths, path_1.normalizePath))
-        : undefined;
-    const files = new Set(tree
-        .listChanges()
-        .filter((file) => file.type !== 'DELETE' &&
-        !excludedPaths?.has((0, path_1.normalizePath)(file.path))));
-    // Detect from the tree, not disk: the tree is the source of truth and may
-    // hold a config the generator just created but hasn't flushed. Probing disk
-    // would also read the real workspace config in tests.
-    //
-    // No `seedConfig` is threaded through, unlike devkit's `formatFiles`:
-    // `formatFilesWithOxfmt` falls back to a JSON config carried in the batch.
-    const formatterType = (0, formatters_1.detectFormatterInTree)(tree);
-    if (!formatterType) {
-        return;
-    }
-    const results = await formatDetectedFiles(formatterType, Array.from(files), tree.root, options, 
-    // The post-flush root, which disk cannot see: a config staged here is not
-    // written yet, and one the tree deletes still is.
-    oxfmt_1.oxfmtConfigFiles.filter((name) => tree.exists(name)), 
-    // Same reason, for the ignore files and the root .editorconfig: the batch
-    // is selected against the tree, so the backend has to re-check against the
-    // tree and not against disk.
-    (relativePath) => tree.read(relativePath, 'utf-8'));
-    for (const [path, content] of results) {
-        tree.write(path, content);
-    }
-}
-async function formatFileContents(files, root, options) {
-    // Check here as well for direct callers of this function
-    if (process.env.NX_SKIP_FORMAT === 'true' || files.length === 0) {
-        return new Map();
-    }
-    // Direct callers have no tree, so detection falls back to disk.
-    const formatterType = (0, formatters_1.detectFormatter)(root);
-    if (!formatterType) {
-        return new Map();
-    }
-    return formatDetectedFiles(formatterType, files, root, options);
-}
-function formatDetectedFiles(formatterType, files, root, options, rootConfigNames, read) {
-    switch (formatterType) {
-        case 'prettier':
-            return formatFilesWithPrettier(files, root, options);
-        case 'oxfmt':
-            return runOxfmtBatch(files, root, options, rootConfigNames, read);
-        default: {
-            // Without this arm an unhandled formatter returns undefined into
-            // callers that iterate it.
-            const unhandled = formatterType;
-            throw new Error(`Unhandled formatter: ${unhandled}`);
-        }
-    }
-}
-async function formatFilesWithPrettier(files, root, options) {
-    const results = new Map();
-    let prettier;
-    try {
-        const prettierPath = require.resolve('prettier', {
-            paths: [...(0, installation_directory_1.getNxRequirePaths)(root), __dirname],
-        });
-        prettier = require(prettierPath);
-    }
-    catch { }
-    if (!prettier) {
-        // Detection said prettier, so this is "configured but not installed" -
-        // the oxfmt path reports it, and silence here just leaves files
-        // unformatted with no reason given.
-        if (!options?.silent) {
-            output_1.output.warn({
-                title: 'prettier is configured for this workspace but is not installed.',
-                bodyLines: ['Install "prettier" to format generated files.'],
-            });
-        }
-        return results;
-    }
-    await Promise.all(Array.from(files).map(async (file) => {
-        try {
-            const systemPath = path.join(root, file.path);
-            let resolvedOptions = {
-                filepath: systemPath,
-            };
-            // No early return when this is null: detection accepts a formatter
-            // declared in the root package.json, so a workspace can select prettier
-            // without configuring it. Skipping here would leave `nx release` and
-            // migrations unformatted while devkit's `formatFiles` - which has never
-            // had this guard - formats the same workspace on prettier's defaults.
-            const config = await prettier.resolveConfig(systemPath, {
-                editorconfig: true,
-            });
-            resolvedOptions = {
-                ...resolvedOptions,
-                ...config,
-            };
-            const support = await prettier.getFileInfo(systemPath, resolvedOptions);
-            if (support.ignored || !support.inferredParser) {
-                return;
-            }
-            results.set(file.path, await prettier.format(file.content.toString('utf-8'), resolvedOptions));
-        }
-        catch (e) {
-            if (!options?.silent) {
-                output_1.output.warn({
-                    title: `Could not format ${file.path}`,
-                    bodyLines: [e.message],
-                });
-            }
-        }
-    }));
-    return results;
-}
-async function runOxfmtBatch(files, root, options, rootConfigNames, read) {
-    try {
-        // The whole batch goes through one call: oxfmt's ESM API is loaded once and
-        // each file is formatted in memory, so no process is spawned per file and a
-        // file oxfmt cannot parse costs only itself.
-        const { formatted, errors } = await (0, oxfmt_1.formatFilesWithOxfmt)(files.map((file) => ({
-            path: file.path,
-            content: file.content.toString('utf-8'),
-        })), root, undefined, rootConfigNames, read);
-        if (errors?.length && !options?.silent) {
-            output_1.output.warn({
-                title: 'Could not format some files with oxfmt',
-                bodyLines: errors,
-            });
-        }
-        return formatted;
-    }
-    catch (e) {
-        if (!options?.silent) {
-            output_1.output.warn({
-                title: 'Could not format files with oxfmt',
-                bodyLines: [e.message],
-            });
-        }
-        return new Map();
-    }
-}

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

@@ -1,26 +0,0 @@
-import type { Tree } from '../tree';
-import type { FormatterType } from '../../utils/formatters';
-/**
- * A formatter choice rather than a dispatch target, so `'none'` is composed in
- * here instead of living in `FormatterType`.
- */
-type TestFormatter = FormatterType | 'none';
-/**
- * Creates a host for testing.
- *
- * Defaults to oxfmt deliberately, so generator tests exercise the oxfmt path
- * rather than the create-nx-workspace default. oxfmt formats
- * JS, TS, JSON, YAML and Markdown - nothing filters by extension on the way in
- * - so any spec asserting on generated file *content* is affected. Pass `none`
- * to assert exactly what the generator wrote, or `prettier` only for a test
- * that is about prettier itself.
- */
-export declare function createTreeWithEmptyWorkspace(opts?: {
-    layout?: 'apps-libs';
-    formatter?: TestFormatter;
-}): Tree;
-/**
- * @deprecated use createTreeWithEmptyWorkspace instead
- */
-export declare function createTreeWithEmptyV1Workspace(): Tree;
-export {};