@ohos-ports/nx 17.3.2-beta.0

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

@@ -0,0 +1,254 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readGraphFileFromGraphArg = exports.getProjectRoots = exports.parseFiles = exports.splitArgsIntoNxArgsAndOverrides = exports.createOverrides = void 0;
+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;
+}
+exports.createOverrides = createOverrides;
+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 then 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 = nxJson.affected?.defaultBase || 'main';
+            // 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);
+    if (args['parallel'] === 'false' || args['parallel'] === false) {
+        nxArgs['parallel'] = 1;
+    }
+    else if (args['parallel'] === 'true' ||
+        args['parallel'] === true ||
+        args['parallel'] === '' ||
+        process.env.NX_PARALLEL // dont require passing --parallel if NX_PARALLEL is set
+    ) {
+        nxArgs['parallel'] = Number(nxArgs['maxParallel'] ||
+            nxArgs['max-parallel'] ||
+            process.env.NX_PARALLEL ||
+            3);
+    }
+    else if (args['parallel'] !== undefined) {
+        nxArgs['parallel'] = Number(args['parallel']);
+    }
+    return { nxArgs, overrides };
+}
+exports.splitArgsIntoNxArgsAndOverrides = splitArgsIntoNxArgsAndOverrides;
+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(),
+            ])),
+        };
+    }
+}
+exports.parseFiles = parseFiles;
+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',
+        })
+            .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',
+            })
+                .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 })
+        .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);
+}
+exports.getProjectRoots = getProjectRoots;
+function readGraphFileFromGraphArg({ graph }) {
+    return typeof graph === 'string' && graph !== 'true' && graph !== ''
+        ? graph
+        : undefined;
+}
+exports.readGraphFileFromGraphArg = readGraphFileFromGraphArg;

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,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.consumeMessagesFromSocket = void 0;
+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;
+        }
+    };
+}
+exports.consumeMessagesFromSocket = consumeMessagesFromSocket;

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

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

package/src/utils/default-base.js

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

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

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+/**
+ * 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,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signalToCode = void 0;
+/**
+ * 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;
+    }
+}
+exports.signalToCode = signalToCode;

package/src/utils/fileutils.d.ts

@@ -0,0 +1,69 @@
+/// <reference types="node" />
+/// <reference types="@types/node/ts4.8/fs" />
+import type { JsonParseOptions, JsonSerializeOptions } from './json';
+import { PathLike } from 'fs';
+export interface JsonReadOptions extends JsonParseOptions {
+    /**
+     * mutable field recording whether JSON ends with new line
+     * @default false
+     */
+    endsWithNewline?: boolean;
+}
+export interface JsonWriteOptions extends JsonSerializeOptions {
+    /**
+     * whether to append new line at the end of JSON file
+     * @default false
+     */
+    appendNewLine?: boolean;
+}
+/**
+ * Reads a JSON file and returns the object the JSON content represents.
+ *
+ * @param path A path to a file.
+ * @param options JSON parse options
+ * @returns Object the JSON content of the file represents
+ */
+export declare function readJsonFile<T extends object = any>(path: string, options?: JsonReadOptions): T;
+interface YamlReadOptions {
+    /**
+     * Compatibility with JSON.parse behaviour. If true, then duplicate keys in a mapping will override values rather than throwing an error.
+     */
+    json?: boolean;
+}
+/**
+ * Reads a YAML file and returns the object the YAML content represents.
+ *
+ * @param path A path to a file.
+ * @returns
+ */
+export declare function readYamlFile<T extends object = any>(path: string, options?: YamlReadOptions): T;
+/**
+ * Serializes the given data to JSON and writes it to a file.
+ *
+ * @param path A path to a file.
+ * @param data data which should be serialized to JSON and written to the file
+ * @param options JSON serialize options
+ */
+export declare function writeJsonFile<T extends object = object>(path: string, data: T, options?: JsonWriteOptions): void;
+/**
+ * Check if a directory exists
+ * @param path Path to directory
+ */
+export declare function directoryExists(path: PathLike): boolean;
+/**
+ * Check if a file exists.
+ * @param path Path to file
+ */
+export declare function fileExists(path: PathLike): boolean;
+export declare function createDirectory(path: PathLike): void;
+export declare function isRelativePath(path: string): boolean;
+/**
+ * Extracts a file from a given tarball to the specified destination.
+ * @param tarballPath The path to the tarball from where the file should be extracted.
+ * @param file The path to the file inside the tarball.
+ * @param destinationFilePath The destination file path.
+ * @returns True if the file was extracted successfully, false otherwise.
+ */
+export declare function extractFileFromTarball(tarballPath: string, file: string, destinationFilePath: string): Promise<string>;
+export declare function readFileIfExisting(path: string): string;
+export {};

package/src/utils/fileutils.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readFileIfExisting = exports.extractFileFromTarball = exports.isRelativePath = exports.createDirectory = exports.fileExists = exports.directoryExists = exports.writeJsonFile = exports.readYamlFile = exports.readJsonFile = void 0;
+const json_1 = require("./json");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const tar = require("tar-stream");
+const zlib_1 = require("zlib");
+/**
+ * Reads a JSON file and returns the object the JSON content represents.
+ *
+ * @param path A path to a file.
+ * @param options JSON parse options
+ * @returns Object the JSON content of the file represents
+ */
+function readJsonFile(path, options) {
+    const content = (0, fs_1.readFileSync)(path, 'utf-8');
+    if (options) {
+        options.endsWithNewline = content.charCodeAt(content.length - 1) === 10;
+    }
+    try {
+        return (0, json_1.parseJson)(content, options);
+    }
+    catch (e) {
+        e.message = e.message.replace('JSON', path);
+        throw e;
+    }
+}
+exports.readJsonFile = readJsonFile;
+/**
+ * Reads a YAML file and returns the object the YAML content represents.
+ *
+ * @param path A path to a file.
+ * @returns
+ */
+function readYamlFile(path, options) {
+    const content = (0, fs_1.readFileSync)(path, 'utf-8');
+    const { load } = require('js-yaml');
+    return load(content, { ...options, filename: path });
+}
+exports.readYamlFile = readYamlFile;
+/**
+ * Serializes the given data to JSON and writes it to a file.
+ *
+ * @param path A path to a file.
+ * @param data data which should be serialized to JSON and written to the file
+ * @param options JSON serialize options
+ */
+function writeJsonFile(path, data, options) {
+    (0, fs_1.mkdirSync)((0, path_1.dirname)(path), { recursive: true });
+    const serializedJson = (0, json_1.serializeJson)(data, options);
+    const content = options?.appendNewLine
+        ? `${serializedJson}\n`
+        : serializedJson;
+    (0, fs_1.writeFileSync)(path, content, { encoding: 'utf-8' });
+}
+exports.writeJsonFile = writeJsonFile;
+/**
+ * Check if a directory exists
+ * @param path Path to directory
+ */
+function directoryExists(path) {
+    try {
+        return (0, fs_1.statSync)(path).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+exports.directoryExists = directoryExists;
+/**
+ * Check if a file exists.
+ * @param path Path to file
+ */
+function fileExists(path) {
+    try {
+        return (0, fs_1.statSync)(path).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+exports.fileExists = fileExists;
+function createDirectory(path) {
+    (0, fs_1.mkdirSync)(path, { recursive: true });
+}
+exports.createDirectory = createDirectory;
+function isRelativePath(path) {
+    return (path === '.' ||
+        path === '..' ||
+        path.startsWith('./') ||
+        path.startsWith('../'));
+}
+exports.isRelativePath = isRelativePath;
+/**
+ * Extracts a file from a given tarball to the specified destination.
+ * @param tarballPath The path to the tarball from where the file should be extracted.
+ * @param file The path to the file inside the tarball.
+ * @param destinationFilePath The destination file path.
+ * @returns True if the file was extracted successfully, false otherwise.
+ */
+async function extractFileFromTarball(tarballPath, file, destinationFilePath) {
+    return new Promise((resolve, reject) => {
+        (0, fs_1.mkdirSync)((0, path_1.dirname)(destinationFilePath), { recursive: true });
+        var tarExtractStream = tar.extract();
+        const destinationFileStream = (0, fs_1.createWriteStream)(destinationFilePath);
+        let isFileExtracted = false;
+        tarExtractStream.on('entry', function (header, stream, next) {
+            if (header.name === file) {
+                stream.pipe(destinationFileStream);
+                stream.on('end', () => {
+                    isFileExtracted = true;
+                });
+                destinationFileStream.on('close', () => {
+                    resolve(destinationFilePath);
+                });
+            }
+            stream.on('end', function () {
+                next();
+            });
+            stream.resume();
+        });
+        tarExtractStream.on('finish', function () {
+            if (!isFileExtracted) {
+                reject();
+            }
+        });
+        (0, fs_1.createReadStream)(tarballPath).pipe((0, zlib_1.createGunzip)()).pipe(tarExtractStream);
+    });
+}
+exports.extractFileFromTarball = extractFileFromTarball;
+function readFileIfExisting(path) {
+    return (0, fs_1.existsSync)(path) ? (0, fs_1.readFileSync)(path, 'utf-8') : '';
+}
+exports.readFileIfExisting = readFileIfExisting;

package/src/utils/find-matching-projects.d.ts

@@ -0,0 +1,10 @@
+import type { ProjectGraphProjectNode } from '../config/project-graph';
+/**
+ * Find matching project names given a list of potential project names or globs.
+ *
+ * @param patterns A list of project names or globs to match against.
+ * @param projects A map of {@link ProjectGraphProjectNode} by project name.
+ * @returns
+ */
+export declare function findMatchingProjects(patterns: string[], projects: Record<string, ProjectGraphProjectNode>): string[];
+export declare const getMatchingStringsWithCache: (pattern: string, items: string[]) => string[];