@ohos-ports/nx 19.8.4-beta.0

package/src/utils/code-frames.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.codeFrameColumns = codeFrameColumns;
+// Adapted from https://raw.githubusercontent.com/babel/babel/4108524/packages/babel-code-frame/src/index.js
+const chalk = require("chalk");
+/**
+ * Chalk styles for code frame token types.
+ */
+function getDefs(chalk) {
+    return {
+        gutter: chalk.grey,
+        marker: chalk.red.bold,
+        message: chalk.red.bold,
+    };
+}
+/**
+ * RegExp to test for newlines in terminal.
+ */
+const NEWLINE = /\r\n|[\n\r\u2028\u2029]/;
+/**
+ * Extract what lines should be marked and highlighted.
+ */
+function getMarkerLines(loc, source, opts = {}) {
+    const startLoc = {
+        column: 0,
+        line: -1,
+        ...loc.start,
+    };
+    const endLoc = {
+        ...startLoc,
+        ...loc.end,
+    };
+    const { linesAbove = 2, linesBelow = 3 } = opts || {};
+    const startLine = startLoc.line;
+    const startColumn = startLoc.column;
+    const endLine = endLoc.line;
+    const endColumn = endLoc.column;
+    let start = Math.max(startLine - (linesAbove + 1), 0);
+    let end = Math.min(source.length, endLine + linesBelow);
+    if (startLine === -1) {
+        start = 0;
+    }
+    if (endLine === -1) {
+        end = source.length;
+    }
+    const lineDiff = endLine - startLine;
+    const markerLines = {};
+    if (lineDiff) {
+        for (let i = 0; i <= lineDiff; i++) {
+            const lineNumber = i + startLine;
+            if (!startColumn) {
+                markerLines[lineNumber] = true;
+            }
+            else if (i === 0) {
+                const sourceLength = source[lineNumber - 1].length;
+                markerLines[lineNumber] = [startColumn, sourceLength - startColumn + 1];
+            }
+            else if (i === lineDiff) {
+                markerLines[lineNumber] = [0, endColumn];
+            }
+            else {
+                const sourceLength = source[lineNumber - i].length;
+                markerLines[lineNumber] = [0, sourceLength];
+            }
+        }
+    }
+    else {
+        if (startColumn === endColumn) {
+            if (startColumn) {
+                markerLines[startLine] = [startColumn, 0];
+            }
+            else {
+                markerLines[startLine] = true;
+            }
+        }
+        else {
+            markerLines[startLine] = [startColumn, endColumn - startColumn];
+        }
+    }
+    return { start, end, markerLines };
+}
+function codeFrameColumns(rawLines, loc, opts = {}) {
+    const defs = getDefs(chalk);
+    const lines = rawLines.split(NEWLINE);
+    const { start, end, markerLines } = getMarkerLines(loc, lines, opts);
+    const numberMaxWidth = String(end).length;
+    const highlightedLines = opts.highlight ? opts.highlight(rawLines) : rawLines;
+    let frame = highlightedLines
+        .split(NEWLINE)
+        .slice(start, end)
+        .map((line, index) => {
+        const number = start + 1 + index;
+        const paddedNumber = ` ${number}`.slice(-numberMaxWidth);
+        const gutter = ` ${paddedNumber} | `;
+        const hasMarker = markerLines[number];
+        if (hasMarker) {
+            let markerLine = '';
+            if (Array.isArray(hasMarker)) {
+                const markerSpacing = line
+                    .slice(0, Math.max(hasMarker[0] - 1, 0))
+                    .replace(/[^\t]/g, ' ');
+                const numberOfMarkers = hasMarker[1] || 1;
+                markerLine = [
+                    '\n ',
+                    defs.gutter(gutter.replace(/\d/g, ' ')),
+                    markerSpacing,
+                    defs.marker('^').repeat(numberOfMarkers),
+                ].join('');
+            }
+            return [defs.marker('>'), defs.gutter(gutter), line, markerLine].join('');
+        }
+        else {
+            return ` ${defs.gutter(gutter)}${line}`;
+        }
+    })
+        .join('\n');
+    return chalk.reset(frame);
+}

package/src/utils/collapse-expanded-outputs.d.ts

@@ -0,0 +1 @@
+export declare function collapseExpandedOutputs(expandedOutputs: string[]): string[];

package/src/utils/collapse-expanded-outputs.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collapseExpandedOutputs = collapseExpandedOutputs;
+const path_1 = require("path");
+/**
+ * Heuristic to prevent writing too many hash files
+ */
+const MAX_OUTPUTS_TO_CHECK_HASHES = 3;
+function collapseExpandedOutputs(expandedOutputs) {
+    const tree = [];
+    // Create a Tree of directories/files
+    for (const output of expandedOutputs) {
+        const pathParts = [];
+        pathParts.unshift(output);
+        let dir = (0, path_1.dirname)(output);
+        while (dir !== (0, path_1.dirname)(dir)) {
+            pathParts.unshift(dir);
+            dir = (0, path_1.dirname)(dir);
+        }
+        for (let i = 0; i < pathParts.length; i++) {
+            tree[i] ??= new Set();
+            tree[i].add(pathParts[i]);
+        }
+    }
+    // Find a level in the tree that has too many outputs
+    if (tree.length === 0) {
+        return [];
+    }
+    let j = 0;
+    let level = tree[j];
+    for (j = 0; j < tree.length; j++) {
+        level = tree[j];
+        if (level.size > MAX_OUTPUTS_TO_CHECK_HASHES) {
+            break;
+        }
+    }
+    // Return the level before the level with too many outputs
+    // If the first level has too many outputs, return that one.
+    return Array.from(tree[Math.max(0, j - 1)]);
+}

package/src/utils/command-line-utils.d.ts

@@ -0,0 +1,54 @@
+import type { Arguments } from 'yargs';
+import { NxJsonConfiguration } from '../config/nx-json';
+import { ProjectGraph } from '../config/project-graph';
+export interface RawNxArgs extends NxArgs {
+    prod?: boolean;
+}
+export interface NxArgs {
+    targets?: string[];
+    configuration?: string;
+    runner?: string;
+    parallel?: number;
+    untracked?: boolean;
+    uncommitted?: boolean;
+    all?: boolean;
+    base?: string;
+    head?: string;
+    exclude?: string[];
+    files?: string[];
+    verbose?: boolean;
+    help?: boolean;
+    version?: boolean;
+    plain?: boolean;
+    projects?: string[];
+    select?: string;
+    graph?: string | boolean;
+    skipNxCache?: boolean;
+    outputStyle?: string;
+    nxBail?: boolean;
+    nxIgnoreCycles?: boolean;
+    type?: string;
+    batch?: boolean;
+    excludeTaskDependencies?: boolean;
+    skipSync?: boolean;
+}
+export declare function createOverrides(__overrides_unparsed__?: string[]): Record<string, any>;
+export declare function getBaseRef(nxJson: NxJsonConfiguration): string;
+export declare function splitArgsIntoNxArgsAndOverrides(args: {
+    [k: string]: any;
+}, mode: 'run-one' | 'run-many' | 'affected' | 'print-affected', options: {
+    printWarnings: boolean;
+}, nxJson: NxJsonConfiguration): {
+    nxArgs: NxArgs;
+    overrides: Arguments & {
+        __overrides_unparsed__: string[];
+    };
+};
+export declare function readParallelFromArgsAndEnv(args: {
+    [k: string]: any;
+}): number;
+export declare function parseFiles(options: NxArgs): {
+    files: string[];
+};
+export declare function getProjectRoots(projectNames: string[], { nodes }: ProjectGraph): string[];
+export declare function readGraphFileFromGraphArg({ graph }: Pick<NxArgs, 'graph'>): string;

package/src/utils/command-line-utils.js

@@ -0,0 +1,267 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createOverrides = createOverrides;
+exports.getBaseRef = getBaseRef;
+exports.splitArgsIntoNxArgsAndOverrides = splitArgsIntoNxArgsAndOverrides;
+exports.readParallelFromArgsAndEnv = readParallelFromArgsAndEnv;
+exports.parseFiles = parseFiles;
+exports.getProjectRoots = getProjectRoots;
+exports.readGraphFileFromGraphArg = readGraphFileFromGraphArg;
+const yargsParser = require("yargs-parser");
+const file_utils_1 = require("../project-graph/file-utils");
+const output_1 = require("./output");
+const child_process_1 = require("child_process");
+const workspace_root_1 = require("./workspace-root");
+function createOverrides(__overrides_unparsed__ = []) {
+    let overrides = yargsParser(__overrides_unparsed__, {
+        configuration: {
+            'camel-case-expansion': false,
+            'dot-notation': true,
+        },
+    }) || {};
+    if (!overrides._ || overrides._.length === 0) {
+        delete overrides._;
+    }
+    overrides.__overrides_unparsed__ = __overrides_unparsed__;
+    return overrides;
+}
+function getBaseRef(nxJson) {
+    return nxJson.defaultBase ?? nxJson.affected?.defaultBase ?? 'main';
+}
+function splitArgsIntoNxArgsAndOverrides(args, mode, options = { printWarnings: true }, nxJson) {
+    // this is to lerna case when this function is invoked imperatively
+    if (args['target'] && !args['targets']) {
+        args['targets'] = [args['target']];
+    }
+    delete args['target'];
+    delete args['t'];
+    if (!args.__overrides_unparsed__ && args._) {
+        // required for backwards compatibility
+        args.__overrides_unparsed__ = args._;
+        delete args._;
+    }
+    // This handles the way Lerna passes in overrides
+    if (!args.__overrides_unparsed__ && args.__overrides__) {
+        // required for backwards compatibility
+        args.__overrides_unparsed__ = args.__overrides__;
+        delete args._;
+    }
+    const nxArgs = args;
+    let overrides = createOverrides(args.__overrides_unparsed__);
+    delete nxArgs.$0;
+    delete nxArgs.__overrides_unparsed__;
+    if (mode === 'run-many') {
+        const args = nxArgs;
+        if (!args.projects) {
+            args.projects = [];
+        }
+        else if (typeof args.projects === 'string') {
+            args.projects = args.projects.split(',');
+        }
+    }
+    if (nxArgs.prod) {
+        delete nxArgs.prod;
+        nxArgs.configuration = 'production';
+    }
+    if (mode === 'affected') {
+        if (options.printWarnings && nxArgs.all) {
+            output_1.output.warn({
+                title: `Running affected:* commands with --all can result in very slow builds.`,
+                bodyLines: [
+                    `${output_1.output.bold('--all')} is not meant to be used for any sizable project or to be used in CI.`,
+                    '',
+                    `${output_1.output.dim('Learn more about checking only what is affected: https://nx.dev/nx/affected')}`,
+                ],
+            });
+        }
+        // Allow setting base and head via environment variables (lower priority than direct command arguments)
+        if (!nxArgs.base && process.env.NX_BASE) {
+            nxArgs.base = process.env.NX_BASE;
+            if (options.printWarnings) {
+                output_1.output.note({
+                    title: `No explicit --base argument provided, but found environment variable NX_BASE so using its value as the affected base: ${output_1.output.bold(`${nxArgs.base}`)}`,
+                });
+            }
+        }
+        if (!nxArgs.head && process.env.NX_HEAD) {
+            nxArgs.head = process.env.NX_HEAD;
+            if (options.printWarnings) {
+                output_1.output.note({
+                    title: `No explicit --head argument provided, but found environment variable NX_HEAD so using its value as the affected head: ${output_1.output.bold(`${nxArgs.head}`)}`,
+                });
+            }
+        }
+        if (!nxArgs.base) {
+            nxArgs.base = getBaseRef(nxJson);
+            // No user-provided arguments to set the affected criteria, so inform the user of the defaults being used
+            if (options.printWarnings &&
+                !nxArgs.head &&
+                !nxArgs.files &&
+                !nxArgs.uncommitted &&
+                !nxArgs.untracked &&
+                !nxArgs.all) {
+                output_1.output.note({
+                    title: `Affected criteria defaulted to --base=${output_1.output.bold(`${nxArgs.base}`)} --head=${output_1.output.bold('HEAD')}`,
+                });
+            }
+        }
+        if (nxArgs.base) {
+            nxArgs.base = getMergeBase(nxArgs.base, nxArgs.head);
+        }
+    }
+    if (typeof args.exclude === 'string') {
+        nxArgs.exclude = args.exclude.split(',');
+    }
+    if (!nxArgs.skipNxCache) {
+        nxArgs.skipNxCache = process.env.NX_SKIP_NX_CACHE === 'true';
+    }
+    normalizeNxArgsRunner(nxArgs, nxJson, options);
+    nxArgs['parallel'] = readParallelFromArgsAndEnv(args);
+    return { nxArgs, overrides };
+}
+function readParallelFromArgsAndEnv(args) {
+    if (args['parallel'] === 'false' || args['parallel'] === false) {
+        return 1;
+    }
+    else if (args['parallel'] === 'true' ||
+        args['parallel'] === true ||
+        args['parallel'] === '' ||
+        // dont require passing --parallel if NX_PARALLEL is set, but allow overriding it
+        (process.env.NX_PARALLEL && args['parallel'] === undefined)) {
+        return Number(args['maxParallel'] ||
+            args['max-parallel'] ||
+            process.env.NX_PARALLEL ||
+            3);
+    }
+    else if (args['parallel'] !== undefined) {
+        return Number(args['parallel']);
+    }
+}
+function normalizeNxArgsRunner(nxArgs, nxJson, options) {
+    if (!nxArgs.runner) {
+        // TODO: Remove NX_RUNNER environment variable support in Nx v17
+        for (const envKey of ['NX_TASKS_RUNNER', 'NX_RUNNER']) {
+            const runner = process.env[envKey];
+            if (runner) {
+                const runnerExists = nxJson.tasksRunnerOptions?.[runner];
+                if (options.printWarnings) {
+                    if (runnerExists) {
+                        output_1.output.note({
+                            title: `No explicit --runner argument provided, but found environment variable ${envKey} so using its value: ${output_1.output.bold(`${runner}`)}`,
+                        });
+                    }
+                    else if (nxArgs.verbose ||
+                        process.env.NX_VERBOSE_LOGGING === 'true') {
+                        output_1.output.warn({
+                            title: `Could not find ${output_1.output.bold(`${runner}`)} within \`nx.json\` tasksRunnerOptions.`,
+                            bodyLines: [
+                                `${output_1.output.bold(`${runner}`)} was set by ${envKey}`,
+                                ``,
+                                `To suppress this message, either:`,
+                                `  - provide a valid task runner with --runner`,
+                                `  - ensure NX_TASKS_RUNNER matches a task runner defined in nx.json`,
+                            ],
+                        });
+                    }
+                }
+                if (runnerExists) {
+                    // TODO: Remove in v17
+                    if (envKey === 'NX_RUNNER' && options.printWarnings) {
+                        output_1.output.warn({
+                            title: 'NX_RUNNER is deprecated, please use NX_TASKS_RUNNER instead.',
+                        });
+                    }
+                    nxArgs.runner = runner;
+                }
+                break;
+            }
+        }
+    }
+}
+function parseFiles(options) {
+    const { files, uncommitted, untracked, base, head } = options;
+    if (files) {
+        return {
+            files,
+        };
+    }
+    else if (uncommitted) {
+        return {
+            files: getUncommittedFiles(),
+        };
+    }
+    else if (untracked) {
+        return {
+            files: getUntrackedFiles(),
+        };
+    }
+    else if (base && head) {
+        return {
+            files: getFilesUsingBaseAndHead(base, head),
+        };
+    }
+    else if (base) {
+        return {
+            files: Array.from(new Set([
+                ...getFilesUsingBaseAndHead(base, 'HEAD'),
+                ...getUncommittedFiles(),
+                ...getUntrackedFiles(),
+            ])),
+        };
+    }
+}
+function getUncommittedFiles() {
+    return parseGitOutput(`git diff --name-only --no-renames --relative HEAD .`);
+}
+function getUntrackedFiles() {
+    return parseGitOutput(`git ls-files --others --exclude-standard`);
+}
+function getMergeBase(base, head = 'HEAD') {
+    try {
+        return (0, child_process_1.execSync)(`git merge-base "${base}" "${head}"`, {
+            maxBuffer: file_utils_1.TEN_MEGABYTES,
+            cwd: workspace_root_1.workspaceRoot,
+            stdio: 'pipe',
+            windowsHide: true,
+        })
+            .toString()
+            .trim();
+    }
+    catch {
+        try {
+            return (0, child_process_1.execSync)(`git merge-base --fork-point "${base}" "${head}"`, {
+                maxBuffer: file_utils_1.TEN_MEGABYTES,
+                cwd: workspace_root_1.workspaceRoot,
+                stdio: 'pipe',
+                windowsHide: true,
+            })
+                .toString()
+                .trim();
+        }
+        catch {
+            return base;
+        }
+    }
+}
+function getFilesUsingBaseAndHead(base, head) {
+    return parseGitOutput(`git diff --name-only --no-renames --relative "${base}" "${head}"`);
+}
+function parseGitOutput(command) {
+    return (0, child_process_1.execSync)(command, {
+        maxBuffer: file_utils_1.TEN_MEGABYTES,
+        cwd: workspace_root_1.workspaceRoot,
+        windowsHide: true,
+    })
+        .toString('utf-8')
+        .split('\n')
+        .map((a) => a.trim())
+        .filter((a) => a.length > 0);
+}
+function getProjectRoots(projectNames, { nodes }) {
+    return projectNames.map((name) => nodes[name].data.root);
+}
+function readGraphFileFromGraphArg({ graph }) {
+    return typeof graph === 'string' && graph !== 'true' && graph !== ''
+        ? graph
+        : undefined;
+}

package/src/utils/consume-messages-from-socket.d.ts

@@ -0,0 +1 @@
+export declare function consumeMessagesFromSocket(callback: (message: string) => void): (data: any) => void;

package/src/utils/consume-messages-from-socket.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.consumeMessagesFromSocket = consumeMessagesFromSocket;
+function consumeMessagesFromSocket(callback) {
+    let message = '';
+    return (data) => {
+        const chunk = data.toString();
+        if (chunk.codePointAt(chunk.length - 1) === 4) {
+            message += chunk.substring(0, chunk.length - 1);
+            // Server may send multiple messages in one chunk, so splitting by 0x4
+            const messages = message.split('');
+            for (const splitMessage of messages) {
+                callback(splitMessage);
+            }
+            message = '';
+        }
+        else {
+            message += chunk;
+        }
+    };
+}

package/src/utils/db-connection.d.ts

@@ -0,0 +1,5 @@
+import { ExternalObject } from '../native';
+export declare function getDbConnection(opts?: {
+    directory?: string;
+    dbName?: string;
+}): ExternalObject<Connection>;

package/src/utils/db-connection.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDbConnection = getDbConnection;
+const native_1 = require("../native");
+const cache_directory_1 = require("./cache-directory");
+const package_json_1 = require("../../package.json");
+const dbConnectionMap = new Map();
+function getDbConnection(opts = {}) {
+    opts.directory ??= cache_directory_1.workspaceDataDirectory;
+    const key = `${opts.directory}:${opts.dbName ?? 'default'}`;
+    const connection = getEntryOrSet(dbConnectionMap, key, () => (0, native_1.connectToNxDb)(opts.directory, package_json_1.version, opts.dbName));
+    return connection;
+}
+function getEntryOrSet(map, key, defaultValue) {
+    const existing = map.get(key);
+    if (existing) {
+        return existing;
+    }
+    const val = defaultValue();
+    map.set(key, val);
+    return val;
+}

package/src/utils/default-base.d.ts

@@ -0,0 +1 @@
+export declare function deduceDefaultBase(): string;

package/src/utils/default-base.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deduceDefaultBase = deduceDefaultBase;
+const child_process_1 = require("child_process");
+function deduceDefaultBase() {
+    const nxDefaultBase = 'main';
+    try {
+        return ((0, child_process_1.execSync)('git config --get init.defaultBranch', {
+            windowsHide: true,
+        })
+            .toString()
+            .trim() || nxDefaultBase);
+    }
+    catch {
+        return nxDefaultBase;
+    }
+}

package/src/utils/dotenv.d.ts

@@ -0,0 +1,7 @@
+/**
+ * This loads dotenv files from:
+ * - .env
+ * - .local.env
+ * - .env.local
+ */
+export declare function loadRootEnvFiles(root?: string): void;

package/src/utils/dotenv.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadRootEnvFiles = loadRootEnvFiles;
+const dotenv_1 = require("dotenv");
+const dotenv_expand_1 = require("dotenv-expand");
+const workspace_root_1 = require("./workspace-root");
+const path_1 = require("path");
+/**
+ * This loads dotenv files from:
+ * - .env
+ * - .local.env
+ * - .env.local
+ */
+function loadRootEnvFiles(root = workspace_root_1.workspaceRoot) {
+    for (const file of ['.local.env', '.env.local', '.env']) {
+        const myEnv = (0, dotenv_1.config)({
+            path: (0, path_1.join)(root, file),
+        });
+        (0, dotenv_expand_1.expand)(myEnv);
+    }
+}

package/src/utils/exit-codes.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Translates NodeJS signals to numeric exit code
+ * @param signal
+ */
+export declare function signalToCode(signal: NodeJS.Signals): number;

package/src/utils/exit-codes.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signalToCode = signalToCode;
+/**
+ * Translates NodeJS signals to numeric exit code
+ * @param signal
+ */
+function signalToCode(signal) {
+    switch (signal) {
+        case 'SIGHUP':
+            return 128 + 1;
+        case 'SIGINT':
+            return 128 + 2;
+        case 'SIGTERM':
+            return 128 + 15;
+        default:
+            return 128;
+    }
+}