@ohos-ports/nx 17.3.2-beta.0

package/src/utils/output.js

@@ -0,0 +1,239 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.output = void 0;
+const chalk = require("chalk");
+const os_1 = require("os");
+const readline = require("readline");
+const is_ci_1 = require("./is-ci");
+const GH_GROUP_PREFIX = '::group::';
+const GH_GROUP_SUFFIX = '::endgroup::';
+/**
+ * Automatically disable styling applied by chalk if CI=true
+ */
+const forceColor = process.env.FORCE_COLOR === '' || process.env.FORCE_COLOR === 'true';
+if ((0, is_ci_1.isCI)() && !forceColor) {
+    chalk.level = 0;
+}
+class CLIOutput {
+    constructor() {
+        this.X_PADDING = ' ';
+        this.cliName = 'NX';
+        this.formatCommand = (taskId) => `${chalk.dim('nx run')} ${taskId}`;
+        /**
+         * Expose some color and other utility functions so that other parts of the codebase that need
+         * more fine-grained control of message bodies are still using a centralized
+         * implementation.
+         */
+        this.colors = {
+            gray: chalk.gray,
+            green: chalk.green,
+            red: chalk.red,
+            cyan: chalk.cyan,
+            white: chalk.white,
+        };
+        this.bold = chalk.bold;
+        this.underline = chalk.underline;
+        this.dim = chalk.dim;
+    }
+    /**
+     * Longer dash character which forms more of a continuous line when place side to side
+     * with itself, unlike the standard dash character
+     */
+    get VERTICAL_SEPARATOR() {
+        let divider = '';
+        for (let i = 0; i < process.stdout.columns - this.X_PADDING.length * 2; i++) {
+            divider += '\u2014';
+        }
+        return divider;
+    }
+    writeToStdOut(str) {
+        process.stdout.write(str);
+    }
+    overwriteLine(lineText = '') {
+        // this replaces the existing text up to the new line length
+        process.stdout.write(lineText);
+        // clear whatever text might be left to the right of the cursor (happens
+        // when existing text was longer than new one)
+        readline.clearLine(process.stdout, 1);
+        process.stdout.write(os_1.EOL);
+    }
+    writeOutputTitle({ color, title, }) {
+        this.writeToStdOut(` ${this.applyNxPrefix(color, title)}${os_1.EOL}`);
+    }
+    writeOptionalOutputBody(bodyLines) {
+        if (!bodyLines) {
+            return;
+        }
+        this.addNewline();
+        bodyLines.forEach((bodyLine) => this.writeToStdOut(`   ${bodyLine}${os_1.EOL}`));
+    }
+    applyNxPrefix(color = 'cyan', text) {
+        let nxPrefix = '';
+        if (chalk[color]) {
+            nxPrefix = `${chalk[color]('>')} ${chalk.reset.inverse.bold[color](` ${this.cliName} `)}`;
+        }
+        else {
+            nxPrefix = `${chalk.keyword(color)('>')} ${chalk.reset.inverse.bold.keyword(color)(` ${this.cliName} `)}`;
+        }
+        return `${nxPrefix}  ${text}`;
+    }
+    addNewline() {
+        this.writeToStdOut(os_1.EOL);
+    }
+    addVerticalSeparator(color = 'gray') {
+        this.addNewline();
+        this.addVerticalSeparatorWithoutNewLines(color);
+        this.addNewline();
+    }
+    addVerticalSeparatorWithoutNewLines(color = 'gray') {
+        this.writeToStdOut(`${this.getVerticalSeparator(color)}${os_1.EOL}`);
+    }
+    getVerticalSeparatorLines(color = 'gray') {
+        return ['', this.getVerticalSeparator(color), ''];
+    }
+    getVerticalSeparator(color) {
+        return `${this.X_PADDING}${chalk.dim[color](this.VERTICAL_SEPARATOR)}`;
+    }
+    error({ title, slug, bodyLines }) {
+        this.addNewline();
+        this.writeOutputTitle({
+            color: 'red',
+            title: chalk.red(title),
+        });
+        this.writeOptionalOutputBody(bodyLines);
+        /**
+         * Optional slug to be used in an Nx error message redirect URL
+         */
+        if (slug && typeof slug === 'string') {
+            this.addNewline();
+            this.writeToStdOut(`${chalk.grey('  Learn more about this error: ')}https://errors.nx.dev/${slug}${os_1.EOL}`);
+        }
+        this.addNewline();
+    }
+    warn({ title, slug, bodyLines }) {
+        this.addNewline();
+        this.writeOutputTitle({
+            color: 'yellow',
+            title: chalk.yellow(title),
+        });
+        this.writeOptionalOutputBody(bodyLines);
+        /**
+         * Optional slug to be used in an Nx warning message redirect URL
+         */
+        if (slug && typeof slug === 'string') {
+            this.addNewline();
+            this.writeToStdOut(`${chalk.grey('  Learn more about this warning: ')}https://errors.nx.dev/${slug}${os_1.EOL}`);
+        }
+        this.addNewline();
+    }
+    note({ title, bodyLines }) {
+        this.addNewline();
+        this.writeOutputTitle({
+            color: 'orange',
+            title: chalk.keyword('orange')(title),
+        });
+        this.writeOptionalOutputBody(bodyLines);
+        this.addNewline();
+    }
+    success({ title, bodyLines }) {
+        this.addNewline();
+        this.writeOutputTitle({
+            color: 'green',
+            title: chalk.green(title),
+        });
+        this.writeOptionalOutputBody(bodyLines);
+        this.addNewline();
+    }
+    logSingleLine(message) {
+        this.addNewline();
+        this.writeOutputTitle({
+            color: 'gray',
+            title: message,
+        });
+        this.addNewline();
+    }
+    logCommand(message, taskStatus) {
+        this.addNewline();
+        this.writeToStdOut(this.getCommandWithStatus(message, taskStatus));
+        this.addNewline();
+        this.addNewline();
+    }
+    logCommandOutput(message, taskStatus, output) {
+        let commandOutputWithStatus = this.getCommandWithStatus(message, taskStatus);
+        if (process.env.GITHUB_ACTIONS) {
+            const icon = this.getStatusIcon(taskStatus);
+            commandOutputWithStatus = `${GH_GROUP_PREFIX}${icon} ${commandOutputWithStatus}`;
+        }
+        this.addNewline();
+        this.writeToStdOut(commandOutputWithStatus);
+        this.addNewline();
+        this.addNewline();
+        this.writeToStdOut(output);
+        if (process.env.GITHUB_ACTIONS) {
+            this.writeToStdOut(GH_GROUP_SUFFIX);
+        }
+    }
+    getCommandWithStatus(message, taskStatus) {
+        const commandOutput = chalk.dim('> ') + this.formatCommand(this.normalizeMessage(message));
+        return this.addTaskStatus(taskStatus, commandOutput);
+    }
+    getStatusIcon(taskStatus) {
+        switch (taskStatus) {
+            case 'success':
+                return '✔️';
+            case 'failure':
+                return '❌';
+            case 'skipped':
+            case 'local-cache-kept-existing':
+                return '⏩';
+            case 'local-cache':
+            case 'remote-cache':
+                return '🔁';
+        }
+    }
+    normalizeMessage(message) {
+        if (message.startsWith('nx run ')) {
+            return message.substring('nx run '.length);
+        }
+        else if (message.startsWith('run ')) {
+            return message.substring('run '.length);
+        }
+        else {
+            return message;
+        }
+    }
+    addTaskStatus(taskStatus, commandOutput) {
+        if (taskStatus === 'local-cache') {
+            return `${commandOutput}  ${chalk.dim('[local cache]')}`;
+        }
+        else if (taskStatus === 'remote-cache') {
+            return `${commandOutput}  ${chalk.dim('[remote cache]')}`;
+        }
+        else if (taskStatus === 'local-cache-kept-existing') {
+            return `${commandOutput}  ${chalk.dim('[existing outputs match the cache, left as is]')}`;
+        }
+        else {
+            return commandOutput;
+        }
+    }
+    log({ title, bodyLines, color }) {
+        this.addNewline();
+        this.writeOutputTitle({
+            color: 'cyan',
+            title: color ? chalk[color](title) : title,
+        });
+        this.writeOptionalOutputBody(bodyLines);
+        this.addNewline();
+    }
+    drain() {
+        return new Promise((resolve) => {
+            if (process.stdout.writableNeedDrain) {
+                process.stdout.once('drain', resolve);
+            }
+            else {
+                resolve();
+            }
+        });
+    }
+}
+exports.output = new CLIOutput();

package/src/utils/package-json.d.ts

@@ -0,0 +1,98 @@
+import { InputDefinition, TargetConfiguration } from '../config/workspace-json-project-json';
+export interface NxProjectPackageJsonConfiguration {
+    implicitDependencies?: string[];
+    tags?: string[];
+    namedInputs?: {
+        [inputName: string]: (string | InputDefinition)[];
+    };
+    targets?: Record<string, TargetConfiguration>;
+    includedScripts?: string[];
+}
+export type ArrayPackageGroup = {
+    package: string;
+    version: string;
+}[];
+export type MixedPackageGroup = (string | {
+    package: string;
+    version: string;
+})[] | Record<string, string>;
+export type PackageGroup = MixedPackageGroup | ArrayPackageGroup;
+export interface NxMigrationsConfiguration {
+    migrations?: string;
+    packageGroup?: PackageGroup;
+}
+type PackageOverride = {
+    [key: string]: string | PackageOverride;
+};
+export interface PackageJson {
+    name: string;
+    version: string;
+    license?: string;
+    private?: boolean;
+    scripts?: Record<string, string>;
+    type?: 'module' | 'commonjs';
+    main?: string;
+    types?: string;
+    module?: string;
+    exports?: string | Record<string, string | {
+        types?: string;
+        require?: string;
+        import?: string;
+    }>;
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+    optionalDependencies?: Record<string, string>;
+    peerDependencies?: Record<string, string>;
+    peerDependenciesMeta?: Record<string, {
+        optional: boolean;
+    }>;
+    resolutions?: Record<string, string>;
+    overrides?: PackageOverride;
+    bin?: Record<string, string> | string;
+    workspaces?: string[] | {
+        packages: string[];
+    };
+    nx?: NxProjectPackageJsonConfiguration;
+    generators?: string;
+    schematics?: string;
+    builders?: string;
+    executors?: string;
+    'nx-migrations'?: string | NxMigrationsConfiguration;
+    'ng-update'?: string | NxMigrationsConfiguration;
+}
+export declare function normalizePackageGroup(packageGroup: PackageGroup): ArrayPackageGroup;
+export declare function readNxMigrateConfig(json: Partial<PackageJson>): NxMigrationsConfiguration & {
+    packageGroup?: ArrayPackageGroup;
+};
+export declare function buildTargetFromScript(script: string, nx: NxProjectPackageJsonConfiguration): TargetConfiguration;
+export declare function readTargetsFromPackageJson(packageJson: PackageJson): Record<string, TargetConfiguration<any>>;
+/**
+ * Uses `require.resolve` to read the package.json for a module.
+ *
+ * This will fail if the module doesn't export package.json
+ *
+ * @returns package json contents and path
+ */
+export declare function readModulePackageJsonWithoutFallbacks(moduleSpecifier: string, requirePaths?: string[]): {
+    packageJson: PackageJson;
+    path: string;
+};
+/**
+ * Reads the package.json file for a specified module.
+ *
+ * Includes a fallback that accounts for modules that don't export package.json
+ *
+ * @param {string} moduleSpecifier The module to look up
+ * @param {string[]} requirePaths List of paths look in. Pass `module.paths` to ensure non-hoisted dependencies are found.
+ *
+ * @example
+ * // Use the caller's lookup paths for non-hoisted dependencies
+ * readModulePackageJson('http-server', module.paths);
+ *
+ * @returns package json contents and path
+ */
+export declare function readModulePackageJson(moduleSpecifier: string, requirePaths?: string[]): {
+    packageJson: PackageJson;
+    path: string;
+};
+export {};

package/src/utils/package-json.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readModulePackageJson = exports.readModulePackageJsonWithoutFallbacks = exports.readTargetsFromPackageJson = exports.buildTargetFromScript = exports.readNxMigrateConfig = exports.normalizePackageGroup = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const fileutils_1 = require("./fileutils");
+const installation_directory_1 = require("./installation-directory");
+function normalizePackageGroup(packageGroup) {
+    return Array.isArray(packageGroup)
+        ? packageGroup.map((x) => typeof x === 'string' ? { package: x, version: '*' } : x)
+        : Object.entries(packageGroup).map(([pkg, version]) => ({
+            package: pkg,
+            version,
+        }));
+}
+exports.normalizePackageGroup = normalizePackageGroup;
+function readNxMigrateConfig(json) {
+    const parseNxMigrationsConfig = (fromJson) => {
+        if (!fromJson) {
+            return {};
+        }
+        if (typeof fromJson === 'string') {
+            return { migrations: fromJson, packageGroup: [] };
+        }
+        return {
+            ...(fromJson.migrations ? { migrations: fromJson.migrations } : {}),
+            ...(fromJson.packageGroup
+                ? { packageGroup: normalizePackageGroup(fromJson.packageGroup) }
+                : {}),
+        };
+    };
+    return {
+        ...parseNxMigrationsConfig(json['ng-update']),
+        ...parseNxMigrationsConfig(json['nx-migrations']),
+        // In case there's a `migrations` field in `package.json`
+        ...parseNxMigrationsConfig(json),
+    };
+}
+exports.readNxMigrateConfig = readNxMigrateConfig;
+function buildTargetFromScript(script, nx) {
+    const nxTargetConfiguration = nx?.targets?.[script] || {};
+    return {
+        ...nxTargetConfiguration,
+        executor: 'nx:run-script',
+        options: {
+            ...(nxTargetConfiguration.options || {}),
+            script,
+        },
+    };
+}
+exports.buildTargetFromScript = buildTargetFromScript;
+function readTargetsFromPackageJson(packageJson) {
+    const { scripts, nx } = packageJson;
+    const res = {};
+    Object.keys(scripts || {}).forEach((script) => {
+        if (!nx?.includedScripts || nx?.includedScripts.includes(script)) {
+            res[script] = buildTargetFromScript(script, nx);
+        }
+    });
+    /**
+     * Add implicit nx-release-publish target for all package.json files that are
+     * not marked as `"private": true` to allow for lightweight configuration for
+     * package based repos.
+     */
+    if (!packageJson.private && !res['nx-release-publish']) {
+        res['nx-release-publish'] = {
+            dependsOn: ['^nx-release-publish'],
+            executor: '@nx/js:release-publish',
+            options: {},
+        };
+    }
+    return res;
+}
+exports.readTargetsFromPackageJson = readTargetsFromPackageJson;
+/**
+ * Uses `require.resolve` to read the package.json for a module.
+ *
+ * This will fail if the module doesn't export package.json
+ *
+ * @returns package json contents and path
+ */
+function readModulePackageJsonWithoutFallbacks(moduleSpecifier, requirePaths = (0, installation_directory_1.getNxRequirePaths)()) {
+    const packageJsonPath = require.resolve(`${moduleSpecifier}/package.json`, {
+        paths: requirePaths,
+    });
+    const packageJson = (0, fileutils_1.readJsonFile)(packageJsonPath);
+    return {
+        path: packageJsonPath,
+        packageJson,
+    };
+}
+exports.readModulePackageJsonWithoutFallbacks = readModulePackageJsonWithoutFallbacks;
+/**
+ * Reads the package.json file for a specified module.
+ *
+ * Includes a fallback that accounts for modules that don't export package.json
+ *
+ * @param {string} moduleSpecifier The module to look up
+ * @param {string[]} requirePaths List of paths look in. Pass `module.paths` to ensure non-hoisted dependencies are found.
+ *
+ * @example
+ * // Use the caller's lookup paths for non-hoisted dependencies
+ * readModulePackageJson('http-server', module.paths);
+ *
+ * @returns package json contents and path
+ */
+function readModulePackageJson(moduleSpecifier, requirePaths = (0, installation_directory_1.getNxRequirePaths)()) {
+    let packageJsonPath;
+    let packageJson;
+    try {
+        ({ path: packageJsonPath, packageJson } =
+            readModulePackageJsonWithoutFallbacks(moduleSpecifier, requirePaths));
+    }
+    catch {
+        const entryPoint = require.resolve(moduleSpecifier, {
+            paths: requirePaths,
+        });
+        let moduleRootPath = (0, path_1.dirname)(entryPoint);
+        packageJsonPath = (0, path_1.join)(moduleRootPath, 'package.json');
+        while (!(0, fs_1.existsSync)(packageJsonPath)) {
+            moduleRootPath = (0, path_1.dirname)(moduleRootPath);
+            packageJsonPath = (0, path_1.join)(moduleRootPath, 'package.json');
+        }
+        packageJson = (0, fileutils_1.readJsonFile)(packageJsonPath);
+        if (packageJson.name && packageJson.name !== moduleSpecifier) {
+            throw new Error(`Found module ${packageJson.name} while trying to locate ${moduleSpecifier}/package.json`);
+        }
+    }
+    return {
+        packageJson,
+        path: packageJsonPath,
+    };
+}
+exports.readModulePackageJson = readModulePackageJson;

package/src/utils/package-manager.d.ts

@@ -0,0 +1,93 @@
+export type PackageManager = 'yarn' | 'pnpm' | 'npm';
+export interface PackageManagerCommands {
+    preInstall?: string;
+    install: string;
+    ciInstall: string;
+    updateLockFile: string;
+    add: string;
+    addDev: string;
+    rm: string;
+    exec: string;
+    dlx: string;
+    list: string;
+    run: (script: string, args: string) => string;
+}
+/**
+ * Detects which package manager is used in the workspace based on the lock file.
+ */
+export declare function detectPackageManager(dir?: string): PackageManager;
+/**
+ * Returns commands for the package manager used in the workspace.
+ * By default, the package manager is derived based on the lock file,
+ * but it can also be passed in explicitly.
+ *
+ * Example:
+ *
+ * ```javascript
+ * execSync(`${getPackageManagerCommand().addDev} my-dev-package`);
+ * ```
+ *
+ * @param packageManager The package manager to use. If not provided, it will be detected based on the lock file.
+ * @param root The directory the commands will be ran inside of. Defaults to the current workspace's root.
+ */
+export declare function getPackageManagerCommand(packageManager?: PackageManager, root?: string): PackageManagerCommands;
+/**
+ * Returns the version of the package manager used in the workspace.
+ * By default, the package manager is derived based on the lock file,
+ * but it can also be passed in explicitly.
+ */
+export declare function getPackageManagerVersion(packageManager?: PackageManager, cwd?: string): string;
+/**
+ * Checks for a project level npmrc file by crawling up the file tree until
+ * hitting a package.json file, as this is how npm finds them as well.
+ */
+export declare function findFileInPackageJsonDirectory(file: string, directory?: string): string | null;
+/**
+ * We copy yarnrc.yml to the temporary directory to ensure things like the specified
+ * package registry are still used. However, there are a few relative paths that can
+ * cause issues, so we modify them to fit the new directory.
+ *
+ * Exported for testing - not meant to be used outside of this file.
+ *
+ * @param contents The string contents of the yarnrc.yml file
+ * @returns Updated string contents of the yarnrc.yml file
+ */
+export declare function modifyYarnRcYmlToFitNewDirectory(contents: string): string;
+/**
+ * We copy .yarnrc to the temporary directory to ensure things like the specified
+ * package registry are still used. However, there are a few relative paths that can
+ * cause issues, so we modify them to fit the new directory.
+ *
+ * Exported for testing - not meant to be used outside of this file.
+ *
+ * @param contents The string contents of the yarnrc.yml file
+ * @returns Updated string contents of the yarnrc.yml file
+ */
+export declare function modifyYarnRcToFitNewDirectory(contents: string): string;
+export declare function copyPackageManagerConfigurationFiles(root: string, destination: string): void;
+/**
+ * Creates a temporary directory where you can run package manager commands safely.
+ *
+ * For cases where you'd want to install packages that require an `.npmrc` set up,
+ * this function looks up for the nearest `.npmrc` (if exists) and copies it over to the
+ * temp directory.
+ */
+export declare function createTempNpmDirectory(): {
+    dir: string;
+    cleanup: () => Promise<void>;
+};
+/**
+ * Returns the resolved version for a given package and version tag using the
+ * NPM registry (when using Yarn it will fall back to NPM to fetch the info).
+ */
+export declare function resolvePackageVersionUsingRegistry(packageName: string, version: string): Promise<string>;
+/**
+ * Return the resolved version for a given package and version tag using by
+ * installing it in a temporary directory and fetching the version from the
+ * package.json.
+ */
+export declare function resolvePackageVersionUsingInstallation(packageName: string, version: string): Promise<string>;
+export declare function packageRegistryView(pkg: string, version: string, args: string): Promise<string>;
+export declare function packageRegistryPack(cwd: string, pkg: string, version: string): Promise<{
+    tarballPath: string;
+}>;