@ohos-ports/nx 19.8.4-beta.0

package/src/utils/ab-testing.d.ts

@@ -0,0 +1,51 @@
+export type MessageOptionKey = 'yes' | 'skip';
+declare const messageOptions: {
+    readonly setupNxCloud: readonly [{
+        readonly code: "enable-caching";
+        readonly message: "Would you like remote caching to make your build faster?";
+        readonly initial: 0;
+        readonly choices: readonly [{
+            readonly value: "yes";
+            readonly name: "Yes";
+        }, {
+            readonly value: "skip";
+            readonly name: "Skip for now";
+        }];
+        readonly footer: "\nWatch a short video on Nx Cloud at https://nx.dev/ci/intro/why-nx-cloud";
+        readonly hint: "\n(it's free and can be disabled any time)";
+    }];
+    readonly setupViewLogs: readonly [{
+        readonly code: "connect-to-view-logs";
+        readonly message: "To view the logs, Nx needs to connect your workspace to Nx Cloud and upload the most recent run details";
+        readonly initial: 0;
+        readonly choices: readonly [{
+            readonly value: "yes";
+            readonly name: "Yes";
+            readonly hint: "Connect to Nx Cloud and upload the run details";
+        }, {
+            readonly value: "skip";
+            readonly name: "No";
+        }];
+        readonly footer: "\nRead more about remote cache at https://nx.dev/ci/features/remote-cache";
+        readonly hint: "\n(it's free and can be disabled any time)";
+    }];
+};
+export type MessageKey = keyof typeof messageOptions;
+export type MessageData = (typeof messageOptions)[MessageKey][number];
+export declare class PromptMessages {
+    private selectedMessages;
+    getPrompt(key: MessageKey): MessageData;
+    codeOfSelectedPromptMessage(key: string): string;
+}
+export declare const messages: PromptMessages;
+/**
+ * We are incrementing a counter to track how often create-nx-workspace is used in CI
+ * vs dev environments. No personal information is collected.
+ */
+export declare function recordStat(opts: {
+    command: string;
+    nxVersion: string;
+    useCloud: boolean;
+    meta?: string;
+}): Promise<void>;
+export {};

package/src/utils/ab-testing.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.messages = exports.PromptMessages = void 0;
+exports.recordStat = recordStat;
+const node_child_process_1 = require("node:child_process");
+const is_ci_1 = require("./is-ci");
+const package_manager_1 = require("./package-manager");
+const get_cloud_options_1 = require("../nx-cloud/utilities/get-cloud-options");
+const messageOptions = {
+    setupNxCloud: [
+        {
+            code: 'enable-caching',
+            message: `Would you like remote caching to make your build faster?`,
+            initial: 0,
+            choices: [
+                { value: 'yes', name: 'Yes' },
+                { value: 'skip', name: 'Skip for now' },
+            ],
+            footer: '\nWatch a short video on Nx Cloud at https://nx.dev/ci/intro/why-nx-cloud',
+            hint: `\n(it's free and can be disabled any time)`,
+        },
+    ],
+    setupViewLogs: [
+        {
+            code: 'connect-to-view-logs',
+            message: `To view the logs, Nx needs to connect your workspace to Nx Cloud and upload the most recent run details`,
+            initial: 0,
+            choices: [
+                {
+                    value: 'yes',
+                    name: 'Yes',
+                    hint: 'Connect to Nx Cloud and upload the run details',
+                },
+                { value: 'skip', name: 'No' },
+            ],
+            footer: '\nRead more about remote cache at https://nx.dev/ci/features/remote-cache',
+            hint: `\n(it's free and can be disabled any time)`,
+        },
+    ],
+};
+class PromptMessages {
+    constructor() {
+        this.selectedMessages = {};
+    }
+    getPrompt(key) {
+        if (this.selectedMessages[key] === undefined) {
+            if (process.env.NX_GENERATE_DOCS_PROCESS === 'true') {
+                this.selectedMessages[key] = 0;
+            }
+            else {
+                this.selectedMessages[key] = Math.floor(Math.random() * messageOptions[key].length);
+            }
+        }
+        return messageOptions[key][this.selectedMessages[key]];
+    }
+    codeOfSelectedPromptMessage(key) {
+        if (this.selectedMessages[key] === undefined)
+            return null;
+        return messageOptions[key][this.selectedMessages[key]].code;
+    }
+}
+exports.PromptMessages = PromptMessages;
+exports.messages = new PromptMessages();
+/**
+ * We are incrementing a counter to track how often create-nx-workspace is used in CI
+ * vs dev environments. No personal information is collected.
+ */
+async function recordStat(opts) {
+    try {
+        if (!shouldRecordStats()) {
+            return;
+        }
+        const axios = require('axios');
+        await (axios['default'] ?? axios)
+            .create({
+            baseURL: (0, get_cloud_options_1.getCloudUrl)(),
+            timeout: 400,
+        })
+            .post('/nx-cloud/stats', {
+            command: opts.command,
+            isCI: (0, is_ci_1.isCI)(),
+            useCloud: opts.useCloud,
+            meta: opts.meta,
+        });
+    }
+    catch (e) {
+        if (process.env.NX_VERBOSE_LOGGING === 'true') {
+            console.error(e);
+        }
+    }
+}
+function shouldRecordStats() {
+    const pmc = (0, package_manager_1.getPackageManagerCommand)();
+    if (!pmc.getRegistryUrl) {
+        // Fallback on true as Package management doesn't support reading config for registry.
+        // currently Bun doesn't support fetching config settings https://github.com/oven-sh/bun/issues/7140
+        return true;
+    }
+    try {
+        const stdout = (0, node_child_process_1.execSync)(pmc.getRegistryUrl, {
+            encoding: 'utf-8',
+            windowsHide: true,
+        });
+        const url = new URL(stdout.trim());
+        // don't record stats when testing locally
+        return url.hostname !== 'localhost';
+    }
+    catch {
+        // fallback to true if we can't detect the registry
+        return true;
+    }
+}

package/src/utils/all-file-data.d.ts

@@ -0,0 +1,2 @@
+import { FileData } from '../config/project-graph';
+export declare function allFileData(): Promise<FileData[]>;

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

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.allFileData = allFileData;
+const workspace_context_1 = require("./workspace-context");
+const workspace_root_1 = require("./workspace-root");
+function allFileData() {
+    return (0, workspace_context_1.getAllFileDataInContext)(workspace_root_1.workspaceRoot);
+}

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 = assertWorkspaceValidity;
+const find_matching_projects_1 = require("./find-matching-projects");
+const output_1 = require("./output");
+const devkit_internals_1 = require("../devkit-internals");
+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 devkit_internals_1.WorkspaceValidityError(message);
+}
+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: AsyncIterable<T> | AsyncIterableIterator<T>): Promise<T>;

package/src/utils/async-iterator.js

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

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

@@ -0,0 +1,7 @@
+/**
+ * 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 workspaceDataDirectory: string;
+export declare function workspaceDataDirectoryForWorkspace(workspaceRoot: string): string;

package/src/utils/cache-directory.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.workspaceDataDirectory = exports.cacheDir = void 0;
+exports.cacheDirectoryForWorkspace = cacheDirectoryForWorkspace;
+exports.workspaceDataDirectoryForWorkspace = workspaceDataDirectoryForWorkspace;
+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 pickCacheDirectory(root, nonNxCacheDirectory, nxCacheDirectory) {
+    // 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', nonNxCacheDirectory);
+    }
+    return (0, path_1.join)(root, '.nx', nxCacheDirectory);
+}
+function defaultCacheDirectory(root) {
+    return pickCacheDirectory(root, 'nx', 'cache');
+}
+function defaultWorkspaceDataDirectory(root) {
+    return pickCacheDirectory(root, 'nx-workspace-data', 'workspace-data');
+}
+/**
+ * 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.workspaceDataDirectory = workspaceDataDirectoryForWorkspace(workspace_root_1.workspaceRoot);
+function workspaceDataDirectoryForWorkspace(workspaceRoot) {
+    return absolutePath(workspaceRoot, process.env.NX_WORKSPACE_DATA_DIRECTORY ??
+        process.env.NX_PROJECT_GRAPH_CACHE_DIRECTORY ??
+        defaultWorkspaceDataDirectory(workspaceRoot));
+}

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

@@ -0,0 +1,18 @@
+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,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PseudoTtyProcess = void 0;
+exports.runNxSync = runNxSync;
+exports.runNxAsync = runNxAsync;
+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();
+        options.windowsHide ??= true;
+        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);
+}
+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();
+        options.windowsHide ??= true;
+        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;
+    }
+    return new Promise((resolve, reject) => {
+        const child = (0, child_process_1.exec)(`${baseCmd} ${cmd}`, options, (error, stdout, stderr) => {
+            if (error) {
+                reject(stderr || stdout || error.message);
+            }
+            else {
+                resolve();
+            }
+        });
+        if (!silent) {
+            child.stdout?.pipe(process.stdout);
+            child.stderr?.pipe(process.stderr);
+        }
+    });
+}
+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,11 @@
+export declare function chunkify(target: string[], maxChunkLength?: number): string[][];
+/**
+ * Get the maximum length of a command-line argument string based on current platform
+ *
+ * https://serverfault.com/questions/69430/what-is-the-maximum-length-of-a-command-line-in-mac-os-x
+ * https://support.microsoft.com/en-us/help/830473/command-prompt-cmd-exe-command-line-string-limitation
+ * https://unix.stackexchange.com/a/120652
+ *
+ * Taken from: https://github.com/lint-staged/lint-staged/blob/adf50b00669f6aac2eeca25dd28ff86a9a3c2a48/lib/index.js#L21-L37
+ */
+export declare function getMaxArgLength(): 262144 | 8191 | 131072;

package/src/utils/chunkify.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chunkify = chunkify;
+exports.getMaxArgLength = getMaxArgLength;
+const TERMINAL_SIZE = getMaxArgLength();
+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;
+}
+/**
+ * Get the maximum length of a command-line argument string based on current platform
+ *
+ * https://serverfault.com/questions/69430/what-is-the-maximum-length-of-a-command-line-in-mac-os-x
+ * https://support.microsoft.com/en-us/help/830473/command-prompt-cmd-exe-command-line-string-limitation
+ * https://unix.stackexchange.com/a/120652
+ *
+ * Taken from: https://github.com/lint-staged/lint-staged/blob/adf50b00669f6aac2eeca25dd28ff86a9a3c2a48/lib/index.js#L21-L37
+ */
+function getMaxArgLength() {
+    switch (process.platform) {
+        case 'darwin':
+            return 262144;
+        case 'win32':
+            return 8191;
+        default:
+            return 131072;
+    }
+}

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 {};