@ohos-ports/nx 17.3.2-beta.0

package/src/utils/all-file-data.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.allFileData = void 0;
+const client_1 = require("../daemon/client/client");
+const workspace_context_1 = require("./workspace-context");
+const workspace_root_1 = require("./workspace-root");
+function allFileData() {
+    if (client_1.daemonClient.enabled()) {
+        return client_1.daemonClient.getAllFileData();
+    }
+    else {
+        return Promise.resolve((0, workspace_context_1.getAllFileDataInContext)(workspace_root_1.workspaceRoot));
+    }
+}
+exports.allFileData = allFileData;

package/src/utils/app-root.d.ts

@@ -0,0 +1,8 @@
+import { workspaceRoot } from './workspace-root';
+/**
+ * The root of the workspace.
+ *
+ * @deprecated use workspaceRoot instead
+ */
+export declare const appRootPath: string;
+export { workspaceRoot };

package/src/utils/app-root.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.workspaceRoot = exports.appRootPath = void 0;
+// TODO(v16): Remove this file
+const workspace_root_1 = require("./workspace-root");
+Object.defineProperty(exports, "workspaceRoot", { enumerable: true, get: function () { return workspace_root_1.workspaceRoot; } });
+/**
+ * The root of the workspace.
+ *
+ * @deprecated use workspaceRoot instead
+ */
+exports.appRootPath = workspace_root_1.workspaceRoot;

package/src/utils/assert-workspace-validity.d.ts

@@ -0,0 +1,3 @@
+import { ProjectConfiguration } from '../config/workspace-json-project-json';
+import { NxJsonConfiguration } from '../config/nx-json';
+export declare function assertWorkspaceValidity(projects: Record<string, ProjectConfiguration>, nxJson: NxJsonConfiguration): void;

package/src/utils/assert-workspace-validity.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertWorkspaceValidity = void 0;
+const find_matching_projects_1 = require("./find-matching-projects");
+const output_1 = require("./output");
+function assertWorkspaceValidity(projects, nxJson) {
+    const projectNames = Object.keys(projects);
+    const projectGraphNodes = projectNames.reduce((graph, project) => {
+        const projectConfiguration = projects[project];
+        graph[project] = {
+            name: project,
+            type: projectConfiguration.projectType === 'library' ? 'lib' : 'app', // missing fallback to `e2e`
+            data: {
+                ...projectConfiguration,
+            },
+        };
+        return graph;
+    }, {});
+    const invalidImplicitDependencies = new Map();
+    if (nxJson.implicitDependencies) {
+        output_1.output.warn({
+            title: 'Using `implicitDependencies` for global implicit dependencies configuration is no longer supported.',
+            bodyLines: [
+                'Use "namedInputs" instead. You can run "nx repair" to automatically migrate your configuration.',
+                'For more information about the usage of "namedInputs" see https://nx.dev/deprecated/global-implicit-dependencies#global-implicit-dependencies',
+            ],
+        });
+    }
+    const projectsWithNonArrayImplicitDependencies = new Map();
+    projectNames
+        .filter((projectName) => {
+        const project = projects[projectName];
+        // Report if for whatever reason, a project is configured to use implicitDependencies but it is not an array
+        if (!!project.implicitDependencies &&
+            !Array.isArray(project.implicitDependencies)) {
+            projectsWithNonArrayImplicitDependencies.set(projectName, project.implicitDependencies);
+        }
+        return (!!project.implicitDependencies &&
+            Array.isArray(project.implicitDependencies));
+    })
+        .reduce((map, projectName) => {
+        const project = projects[projectName];
+        detectAndSetInvalidProjectGlobValues(map, projectName, project.implicitDependencies, projects, projectGraphNodes);
+        return map;
+    }, invalidImplicitDependencies);
+    if (projectsWithNonArrayImplicitDependencies.size === 0 &&
+        invalidImplicitDependencies.size === 0) {
+        // No issues
+        return;
+    }
+    let message = '';
+    if (projectsWithNonArrayImplicitDependencies.size > 0) {
+        message += `The following implicitDependencies should be an array of strings:\n`;
+        projectsWithNonArrayImplicitDependencies.forEach((implicitDependencies, projectName) => {
+            message += `  ${projectName}.implicitDependencies: "${implicitDependencies}"\n`;
+        });
+        message += '\n';
+    }
+    if (invalidImplicitDependencies.size > 0) {
+        message += `The following implicitDependencies point to non-existent project(s):\n`;
+        message += [...invalidImplicitDependencies.keys()]
+            .map((key) => {
+            const projectNames = invalidImplicitDependencies.get(key);
+            return `  ${key}\n${projectNames
+                .map((projectName) => `    ${projectName}`)
+                .join('\n')}`;
+        })
+            .join('\n\n');
+    }
+    throw new Error(`Configuration Error\n${message}`);
+}
+exports.assertWorkspaceValidity = assertWorkspaceValidity;
+function detectAndSetInvalidProjectGlobValues(map, sourceName, desiredImplicitDeps, projectConfigurations, projects) {
+    const invalidProjectsOrGlobs = desiredImplicitDeps.filter((implicit) => {
+        const projectName = implicit.startsWith('!')
+            ? implicit.substring(1)
+            : implicit;
+        return !(projectConfigurations[projectName] ||
+            (0, find_matching_projects_1.findMatchingProjects)([implicit], projects).length);
+    });
+    if (invalidProjectsOrGlobs.length > 0) {
+        map.set(sourceName, invalidProjectsOrGlobs);
+    }
+}

package/src/utils/async-iterator.d.ts

@@ -0,0 +1,2 @@
+export declare function isAsyncIterator<T>(v: any): v is AsyncIterableIterator<T>;
+export declare function getLastValueFromAsyncIterableIterator<T>(i: AsyncIterableIterator<T>): Promise<T>;

package/src/utils/async-iterator.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLastValueFromAsyncIterableIterator = exports.isAsyncIterator = void 0;
+function isAsyncIterator(v) {
+    return typeof v?.[Symbol.asyncIterator] === 'function';
+}
+exports.isAsyncIterator = isAsyncIterator;
+async function getLastValueFromAsyncIterableIterator(i) {
+    let prev;
+    let current;
+    do {
+        prev = current;
+        current = await i.next();
+    } while (!current.done);
+    return current.value !== undefined || !prev ? current.value : prev.value;
+}
+exports.getLastValueFromAsyncIterableIterator = getLastValueFromAsyncIterableIterator;

package/src/utils/cache-directory.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Path to the directory where Nx stores its cache and daemon-related files.
+ */
+export declare const cacheDir: string;
+export declare function cacheDirectoryForWorkspace(workspaceRoot: string): string;
+export declare const projectGraphCacheDirectory: string;

package/src/utils/cache-directory.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.projectGraphCacheDirectory = exports.cacheDirectoryForWorkspace = exports.cacheDir = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const fileutils_1 = require("./fileutils");
+const workspace_root_1 = require("./workspace-root");
+function readCacheDirectoryProperty(root) {
+    try {
+        const nxJson = (0, fileutils_1.readJsonFile)((0, path_1.join)(root, 'nx.json'));
+        return (nxJson.cacheDirectory ??
+            nxJson.tasksRunnerOptions?.default.options.cacheDirectory);
+    }
+    catch {
+        return undefined;
+    }
+}
+function absolutePath(root, path) {
+    if ((0, path_1.isAbsolute)(path)) {
+        return path;
+    }
+    else {
+        return (0, path_1.join)(root, path);
+    }
+}
+function cacheDirectory(root, cacheDirectory) {
+    const cacheDirFromEnv = process.env.NX_CACHE_DIRECTORY;
+    if (cacheDirFromEnv) {
+        cacheDirectory = cacheDirFromEnv;
+    }
+    if (cacheDirectory) {
+        return absolutePath(root, cacheDirectory);
+    }
+    else {
+        return defaultCacheDirectory(root);
+    }
+}
+function defaultCacheDirectory(root) {
+    // If nx.json doesn't exist the repo can't utilize
+    // caching, so .nx/cache is less relevant. Lerna users
+    // that don't want to fully opt in to Nx at this time
+    // may also be caught off guard by the appearance of
+    // a .nx directory, so we are going to special case
+    // this for the time being.
+    if ((0, fs_1.existsSync)((0, path_1.join)(root, 'lerna.json')) &&
+        !(0, fs_1.existsSync)((0, path_1.join)(root, 'nx.json'))) {
+        return (0, path_1.join)(root, 'node_modules', '.cache', 'nx');
+    }
+    return (0, path_1.join)(root, '.nx', 'cache');
+}
+/**
+ * Path to the directory where Nx stores its cache and daemon-related files.
+ */
+exports.cacheDir = cacheDirectory(workspace_root_1.workspaceRoot, readCacheDirectoryProperty(workspace_root_1.workspaceRoot));
+function cacheDirectoryForWorkspace(workspaceRoot) {
+    return cacheDirectory(workspaceRoot, readCacheDirectoryProperty(workspaceRoot));
+}
+exports.cacheDirectoryForWorkspace = cacheDirectoryForWorkspace;
+exports.projectGraphCacheDirectory = absolutePath(workspace_root_1.workspaceRoot, process.env.NX_PROJECT_GRAPH_CACHE_DIRECTORY ??
+    defaultCacheDirectory(workspace_root_1.workspaceRoot));

package/src/utils/child-process.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="node" />
+import { type ExecOptions, type ExecSyncOptions } from 'child_process';
+import { ChildProcess } from '../native';
+export declare function runNxSync(cmd: string, options?: ExecSyncOptions & {
+    cwd?: string;
+}): void;
+export declare function runNxAsync(cmd: string, options?: ExecOptions & {
+    cwd?: string;
+    silent?: boolean;
+}): Promise<void>;
+export declare class PseudoTtyProcess {
+    private childProcess;
+    isAlive: boolean;
+    exitCallbacks: any[];
+    constructor(childProcess: ChildProcess);
+    onExit(callback: (code: number) => void): void;
+    onOutput(callback: (message: string) => void): void;
+    kill(): void;
+}

package/src/utils/child-process.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PseudoTtyProcess = exports.runNxAsync = exports.runNxSync = void 0;
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const package_manager_1 = require("./package-manager");
+const workspace_root_1 = require("./workspace-root");
+function runNxSync(cmd, options) {
+    let baseCmd;
+    if ((0, fs_1.existsSync)((0, path_1.join)(workspace_root_1.workspaceRoot, 'package.json'))) {
+        baseCmd = `${(0, package_manager_1.getPackageManagerCommand)().exec} nx`;
+    }
+    else {
+        options ??= {};
+        options.cwd ??= process.cwd();
+        const offsetFromRoot = (0, path_1.relative)(options.cwd, (0, workspace_root_1.workspaceRootInner)(options.cwd, null));
+        if (process.platform === 'win32') {
+            baseCmd = '.\\' + (0, path_1.join)(`${offsetFromRoot}`, 'nx.bat');
+        }
+        else {
+            baseCmd = './' + (0, path_1.join)(`${offsetFromRoot}`, 'nx');
+        }
+    }
+    (0, child_process_1.execSync)(`${baseCmd} ${cmd}`, options);
+}
+exports.runNxSync = runNxSync;
+async function runNxAsync(cmd, options) {
+    let baseCmd;
+    if ((0, fs_1.existsSync)((0, path_1.join)(workspace_root_1.workspaceRoot, 'package.json'))) {
+        baseCmd = `${(0, package_manager_1.getPackageManagerCommand)().exec} nx`;
+    }
+    else {
+        options ??= {};
+        options.cwd ??= process.cwd();
+        const offsetFromRoot = (0, path_1.relative)(options.cwd, (0, workspace_root_1.workspaceRootInner)(options.cwd, null));
+        if (process.platform === 'win32') {
+            baseCmd = '.\\' + (0, path_1.join)(`${offsetFromRoot}`, 'nx.bat');
+        }
+        else {
+            baseCmd = './' + (0, path_1.join)(`${offsetFromRoot}`, 'nx');
+        }
+    }
+    const silent = options?.silent ?? true;
+    if (options?.silent) {
+        delete options.silent;
+    }
+    await new Promise((resolve, reject) => {
+        const child = (0, child_process_1.exec)(`${baseCmd} ${cmd}`, options, (error, stdout, stderr) => {
+            if (error) {
+                reject(error);
+            }
+            else {
+                resolve(stdout);
+            }
+        });
+        if (!silent) {
+            child.stdout?.pipe(process.stdout);
+            child.stderr?.pipe(process.stderr);
+        }
+    });
+}
+exports.runNxAsync = runNxAsync;
+function messageToCode(message) {
+    if (message.startsWith('Terminated by ')) {
+        switch (message.replace('Terminated by ', '').trim()) {
+            case 'Termination':
+                return 143;
+            case 'Interrupt':
+                return 130;
+            default:
+                return 128;
+        }
+    }
+    else if (message.startsWith('Exited with code ')) {
+        return parseInt(message.replace('Exited with code ', '').trim());
+    }
+    else if (message === 'Success') {
+        return 0;
+    }
+    else {
+        return 1;
+    }
+}
+class PseudoTtyProcess {
+    constructor(childProcess) {
+        this.childProcess = childProcess;
+        this.isAlive = true;
+        this.exitCallbacks = [];
+        childProcess.onExit((message) => {
+            this.isAlive = false;
+            const exitCode = messageToCode(message);
+            this.exitCallbacks.forEach((cb) => cb(exitCode));
+        });
+    }
+    onExit(callback) {
+        this.exitCallbacks.push(callback);
+    }
+    onOutput(callback) {
+        this.childProcess.onOutput(callback);
+    }
+    kill() {
+        try {
+            this.childProcess.kill();
+        }
+        catch {
+            // when the child process completes before we explicitly call kill, this will throw
+            // do nothing
+        }
+        finally {
+            if (this.isAlive == true) {
+                this.isAlive = false;
+            }
+        }
+    }
+}
+exports.PseudoTtyProcess = PseudoTtyProcess;

package/src/utils/chunkify.d.ts

@@ -0,0 +1 @@
+export declare function chunkify(target: string[], maxChunkLength?: number): string[][];

package/src/utils/chunkify.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chunkify = void 0;
+const child_process_1 = require("child_process");
+const TERMINAL_SIZE = process.platform === 'win32' ? 8192 : getUnixTerminalSize();
+function chunkify(target, maxChunkLength = TERMINAL_SIZE - 500) {
+    const chunks = [];
+    let currentChunk = [];
+    let currentChunkLength = 0;
+    for (const file of target) {
+        if (
+        // Prevent empty chunk if first file path is longer than maxChunkLength
+        currentChunk.length &&
+            // +1 accounts for the space between file names
+            currentChunkLength + file.length + 1 >= maxChunkLength) {
+            chunks.push(currentChunk);
+            currentChunk = [];
+            currentChunkLength = 0;
+        }
+        currentChunk.push(file);
+        currentChunkLength += file.length + 1;
+    }
+    chunks.push(currentChunk);
+    return chunks;
+}
+exports.chunkify = chunkify;
+function getUnixTerminalSize() {
+    try {
+        const argMax = (0, child_process_1.execSync)('getconf ARG_MAX').toString().trim();
+        return Number.parseInt(argMax);
+    }
+    catch {
+        // This number varies by system, but 100k seems like a safe
+        // number from some research...
+        // https://stackoverflow.com/questions/19354870/bash-command-line-and-input-limit
+        return 100000;
+    }
+}

package/src/utils/code-frames.d.ts

@@ -0,0 +1,14 @@
+type Location = {
+    column: number;
+    line: number;
+};
+type NodeLocation = {
+    end?: Location;
+    start?: Location;
+};
+export declare function codeFrameColumns(rawLines: string, loc: NodeLocation, opts?: {
+    linesAbove?: number;
+    linesBelow?: number;
+    highlight?: (rawLines: string) => string;
+}): string;
+export {};

package/src/utils/code-frames.js

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

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

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

@@ -0,0 +1,48 @@
+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;
+}
+export declare function createOverrides(__overrides_unparsed__?: string[]): any;
+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 parseFiles(options: NxArgs): {
+    files: string[];
+};
+export declare function getProjectRoots(projectNames: string[], { nodes }: ProjectGraph): string[];
+export declare function readGraphFileFromGraphArg({ graph }: Pick<NxArgs, 'graph'>): string;