@ohos-ports/nx 23.2.1-beta.0 → 23.3.0-beta.0

package/dist/src/command-line/init/implementation/dot-nx/add-nx-scripts.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nxWrapperPath = void 0;
+exports.getDotNxWrapperVersionCommand = getDotNxWrapperVersionCommand;
+exports.generateDotNxSetup = generateDotNxSetup;
+exports.normalizeVersionForNxJson = normalizeVersionForNxJson;
+exports.writeMinimalNxJson = writeMinimalNxJson;
+exports.updateGitIgnore = updateGitIgnore;
+exports.getNxWrapperContents = getNxWrapperContents;
+exports.getShellScriptContents = getShellScriptContents;
+exports.getBatchScriptContents = getBatchScriptContents;
+exports.sanitizeWrapperScript = sanitizeWrapperScript;
+const tslib_1 = require("tslib");
+const child_process_1 = require("child_process");
+const format_1 = require("../format");
+const fs_1 = require("fs");
+const path = tslib_1.__importStar(require("path"));
+const semver_1 = require("semver");
+const tree_1 = require("../../../../generators/tree");
+const json_1 = require("../../../../generators/utils/json");
+const nxWrapperPath = (p = path) => p.join('.nx', 'nxw.js');
+exports.nxWrapperPath = nxWrapperPath;
+const NODE_MISSING_ERR = 'Nx requires NodeJS to be available. To install NodeJS and NPM, see: https://nodejs.org/en/download/ .';
+const NPM_MISSING_ERR = 'Nx requires npm to be available. To install NodeJS and NPM, see: https://nodejs.org/en/download/ .';
+const BATCH_SCRIPT_CONTENTS = [
+    // don't log command to console
+    `@ECHO OFF`,
+    // Prevents path_to_root from being inherited by child processes
+    `SETLOCAL`,
+    `SET path_to_root=%~dp0`,
+    // Checks if node is available
+    `WHERE node >nul 2>nul`,
+    `IF %ERRORLEVEL% NEQ 0 (ECHO ${NODE_MISSING_ERR} & GOTO exit)`,
+    // Checks if npm is available
+    `WHERE npm >nul 2>nul`,
+    `IF %ERRORLEVEL% NEQ 0 (ECHO ${NPM_MISSING_ERR} & GOTO exit)`,
+    // Executes the nx wrapper script
+    `node ${path.win32.join('%path_to_root%', (0, exports.nxWrapperPath)(path.win32))} %*`,
+    // Exits with the same error code as the previous command
+    `:exit`,
+    `  cmd /c exit /b %ERRORLEVEL%`,
+].join('\r\n');
+const SHELL_SCRIPT_CONTENTS = [
+    // Execute in bash
+    `#!/bin/bash`,
+    // Checks if node is available
+    `command -v node >/dev/null 2>&1 || { echo >&2 "${NODE_MISSING_ERR}"; exit 1; }`,
+    // Checks if npm is available
+    `command -v npm >/dev/null 2>&1 || { echo >&2 "${NPM_MISSING_ERR}"; exit 1; }`,
+    // Gets the path to the root of the project
+    `path_to_root=$(dirname $BASH_SOURCE)`,
+    // Executes the nx wrapper script
+    `node ${path.posix.join('$path_to_root', (0, exports.nxWrapperPath)(path.posix))} "$@"`,
+].join('\n');
+// cmd.exe can't run the bash './nx' wrapper; use the generated nx.bat on Windows.
+function getDotNxWrapperVersionCommand(platform = process.platform) {
+    return platform === 'win32' ? '.\\nx.bat --version' : './nx --version';
+}
+function generateDotNxSetup(version) {
+    const host = new tree_1.FsTree(process.cwd(), false, '.nx setup');
+    writeMinimalNxJson(host, version);
+    updateGitIgnore(host);
+    host.write((0, exports.nxWrapperPath)(), getNxWrapperContents());
+    host.write('nx.bat', BATCH_SCRIPT_CONTENTS);
+    host.write('nx', SHELL_SCRIPT_CONTENTS, {
+        mode: fs_1.constants.S_IXUSR | fs_1.constants.S_IRUSR | fs_1.constants.S_IWUSR,
+    });
+    const changes = host.listChanges();
+    (0, tree_1.printChanges)(changes);
+    (0, tree_1.flushChanges)(host.root, changes);
+    // Ensure that the dot-nx installation is available.
+    // This is needed when using a global nx with dot-nx, otherwise running any nx command using global command will fail due to missing modules.
+    // Intentionally not runNxSync: when the repo has a package.json it would run
+    // `<pm> exec nx` instead of the wrapper, but this call must run the
+    // just-written wrapper itself so it bootstraps .nx/installation.
+    // Pipe stderr so failures surface in telemetry instead of bare "Command failed".
+    try {
+        (0, child_process_1.execSync)(getDotNxWrapperVersionCommand(), {
+            stdio: ['ignore', 'ignore', 'pipe'],
+            encoding: 'utf8',
+            windowsHide: true,
+        });
+    }
+    catch (e) {
+        if (e?.stderr)
+            process.stderr.write(e.stderr);
+        throw e;
+    }
+}
+function normalizeVersionForNxJson(pkg, version) {
+    if (!(0, semver_1.valid)(version)) {
+        version = (0, child_process_1.execSync)(`npm view ${pkg}@${version} version`, {
+            windowsHide: true,
+        }).toString();
+    }
+    return version.trimEnd();
+}
+function writeMinimalNxJson(host, version) {
+    if (!host.exists('nx.json')) {
+        (0, json_1.writeJson)(host, 'nx.json', {
+            installation: {
+                version: normalizeVersionForNxJson('nx', version),
+            },
+        });
+        (0, format_1.recordInitWrite)('nx.json');
+        // Only this file. The wrapper scripts written by `generateDotNxSetup`
+        // above (`.nx/nxw.js`, `nx`, `nx.bat`) are deliberately left out: they are
+        // vendored artifacts, and two of them have no formatter at all.
+    }
+}
+function updateGitIgnore(host) {
+    let contents = host.read('.gitignore', 'utf-8') ?? '';
+    [
+        '.nx/installation',
+        '.nx/cache',
+        '.nx/workspace-data',
+        '.nx/self-healing',
+        '.nx/migrate-runs',
+    ].forEach((file) => {
+        if (!contents.includes(file)) {
+            contents = [contents, file].join('\n');
+        }
+    });
+    host.write('.gitignore', contents);
+}
+// Gets the sanitized contents for nxw.js
+function getNxWrapperContents() {
+    return sanitizeWrapperScript((0, fs_1.readFileSync)(path.join(__dirname, 'nxw.js'), 'utf-8'));
+}
+// Gets the contents for the nx bash script
+function getShellScriptContents() {
+    return SHELL_SCRIPT_CONTENTS;
+}
+// Gets the contents for the nx.bat batch script
+function getBatchScriptContents() {
+    return BATCH_SCRIPT_CONTENTS;
+}
+// Remove any empty comments or comments that start with `//#: ` or eslint-disable comments.
+// This removes the sourceMapUrl since it is invalid, as well as any internal comments.
+function sanitizeWrapperScript(input) {
+    const linesToRemove = [
+        // Comments that start with //#
+        '\\/\\/# .*',
+        // Comments that are empty (often used for newlines between internal comments)
+        '\\s*\\/\\/\\s*',
+        // Comments that disable an eslint rule.
+        '\\/\\/ eslint-disable-next-line.*',
+    ];
+    const regex = `(${linesToRemove.join('|')})$`;
+    return input.replace(new RegExp(regex, 'gm'), '');
+}

package/dist/src/command-line/init/implementation/dot-nx/nxw.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/command-line/init/implementation/dot-nx/nxw.js

@@ -0,0 +1,123 @@
+"use strict";
+// This file should be committed to your repository! It wraps Nx and ensures
+// that your local installation matches nx.json.
+// See: https://nx.dev/recipes/installation/install-non-javascript for more info.
+//
+//# The contents of this file are executed before packages are installed.
+//# As such, we should not import anything from nx, other @nrwl packages,
+//# or any other npm packages. Only import node builtins. Type Imports are
+//# fine, since they are removed by the typescript compiler.
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = require('fs');
+const path = require('path');
+const cp = require('child_process');
+const installationPath = path.join(__dirname, 'installation', 'package.json');
+function matchesCurrentNxInstall(currentInstallation, nxJsonInstallation) {
+    if (!currentInstallation.devDependencies ||
+        !Object.keys(currentInstallation.devDependencies).length) {
+        return false;
+    }
+    try {
+        if (currentInstallation.devDependencies['nx'] !==
+            nxJsonInstallation.version ||
+            require(path.join(path.dirname(installationPath), 'node_modules', 'nx', 'package.json')).version !== nxJsonInstallation.version) {
+            return false;
+        }
+        for (const [plugin, desiredVersion] of Object.entries(nxJsonInstallation.plugins || {})) {
+            if (currentInstallation.devDependencies[plugin] !== desiredVersion) {
+                return false;
+            }
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function ensureDir(p) {
+    if (!fs.existsSync(p)) {
+        fs.mkdirSync(p, { recursive: true });
+    }
+}
+function getCurrentInstallation() {
+    try {
+        return require(installationPath);
+    }
+    catch {
+        return {
+            name: 'nx-installation',
+            version: '0.0.0',
+            devDependencies: {},
+        };
+    }
+}
+function performInstallation(currentInstallation, nxJson) {
+    fs.writeFileSync(installationPath, JSON.stringify({
+        name: 'nx-installation',
+        devDependencies: {
+            nx: nxJson.installation.version,
+            ...nxJson.installation.plugins,
+        },
+    }));
+    try {
+        // --include=dev forces install even if consumer env sets NODE_ENV=production / omit=dev.
+        cp.execSync('npm i --include=dev', {
+            cwd: path.dirname(installationPath),
+            stdio: 'inherit',
+            windowsHide: true,
+        });
+    }
+    catch (e) {
+        // revert possible changes to the current installation
+        fs.writeFileSync(installationPath, JSON.stringify(currentInstallation));
+        // rethrow
+        throw e;
+    }
+}
+function ensureUpToDateInstallation() {
+    const nxJsonPath = path.join(__dirname, '..', 'nx.json');
+    let nxJson;
+    try {
+        nxJson = require(nxJsonPath);
+        if (!nxJson.installation) {
+            console.error('[NX]: The "installation" entry in the "nx.json" file is required when running the nx wrapper. See https://nx.dev/recipes/installation/install-non-javascript');
+            process.exit(1);
+        }
+    }
+    catch (e) {
+        if (e instanceof Error &&
+            e.code === 'MODULE_NOT_FOUND') {
+            console.error('[NX]: The "nx.json" file is required when running the nx wrapper. See https://nx.dev/recipes/installation/install-non-javascript');
+        }
+        else {
+            console.error(`[NX]: Failed to parse "nx.json": ${e instanceof Error ? e.message : e}. See https://nx.dev/recipes/installation/install-non-javascript`);
+        }
+        process.exit(1);
+    }
+    try {
+        ensureDir(path.join(__dirname, 'installation'));
+        const currentInstallation = getCurrentInstallation();
+        if (!matchesCurrentNxInstall(currentInstallation, nxJson.installation)) {
+            performInstallation(currentInstallation, nxJson);
+        }
+    }
+    catch (e) {
+        const messageLines = [
+            '[NX]: Nx wrapper failed to synchronize installation.',
+        ];
+        if (e instanceof Error) {
+            messageLines.push('');
+            messageLines.push(e.message);
+            messageLines.push(e.stack);
+        }
+        else {
+            messageLines.push(e.toString());
+        }
+        console.error(messageLines.join('\n'));
+        process.exit(1);
+    }
+}
+if (!process.env.NX_WRAPPER_SKIP_INSTALL) {
+    ensureUpToDateInstallation();
+}
+require('./installation/node_modules/nx/dist/bin/nx');

package/dist/src/command-line/init/implementation/format.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Records a file for `formatInitWrites`. Only for files a formatter handles -
+ * `.gitignore` and the vendored `.nx` scripts are left out rather than
+ * filtered later.
+ *
+ * Two recording helpers are shared with `nx import`, which drains before each
+ * commit amend; draining after one would leave the formatting uncommitted.
+ * The drain is a no-op when empty.
+ */
+export declare function recordInitWrite(filePath: string): void;
+/**
+ * Formats what init just wrote and nothing else: an existing repo's other
+ * files are not init's to reformat.
+ *
+ * Never fatal - the repo is already initialised, so a formatter that cannot
+ * run costs a `nx format` the user can run themselves, not their setup.
+ */
+export declare function formatInitWrites(repoRoot: string, command?: string): Promise<void>;

package/dist/src/command-line/init/implementation/format.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recordInitWrite = recordInitWrite;
+exports.formatInitWrites = formatInitWrites;
+const tslib_1 = require("tslib");
+const node_fs_1 = require("node:fs");
+const path = tslib_1.__importStar(require("node:path"));
+const chunkify_1 = require("../../../utils/chunkify");
+const formatters_1 = require("../../../utils/formatters");
+const oxfmt_1 = require("../../../utils/formatters/oxfmt");
+const prettier_1 = require("../../../utils/formatters/prettier");
+const output_1 = require("../../../utils/output");
+/**
+ * Paths `nx init` has created or modified.
+ *
+ * Module state because init's flows write from many call sites across
+ * several files, a number behind early returns; the alternative is threading
+ * a collector through every one.
+ */
+const writtenFiles = new Set();
+/**
+ * Records a file for `formatInitWrites`. Only for files a formatter handles -
+ * `.gitignore` and the vendored `.nx` scripts are left out rather than
+ * filtered later.
+ *
+ * Two recording helpers are shared with `nx import`, which drains before each
+ * commit amend; draining after one would leave the formatting uncommitted.
+ * The drain is a no-op when empty.
+ */
+function recordInitWrite(filePath) {
+    writtenFiles.add(filePath);
+}
+/**
+ * Formats what init just wrote and nothing else: an existing repo's other
+ * files are not init's to reformat.
+ *
+ * Never fatal - the repo is already initialised, so a formatter that cannot
+ * run costs a `nx format` the user can run themselves, not their setup.
+ */
+async function formatInitWrites(repoRoot, 
+// `nx import` drains this set too, and a user who never ran `nx init` should
+// not be told `nx init` failed.
+command = 'nx init') {
+    const recorded = [...writtenFiles];
+    // Cleared unconditionally: a second init in the same process must not
+    // reformat the first one's files.
+    writtenFiles.clear();
+    if (process.env.NX_SKIP_FORMAT === 'true' || recorded.length === 0) {
+        return;
+    }
+    // Repo-relative with `repoRoot` as cwd, so paths stay short and resolve
+    // against the repo. That also pins oxfmt's `.editorconfig` lookup, which it
+    // does once from the working directory; it does not pin config discovery.
+    //
+    // De-duplicated *after* normalising: the same file is routinely recorded
+    // both as `'nx.json'` and as `join(repoRoot, 'nx.json')`, which are two Set
+    // keys for one file.
+    const files = [
+        ...new Set(recorded.map((file) => path
+            .relative(repoRoot, path.resolve(repoRoot, file))
+            .split(path.sep)
+            .join('/'))),
+    ].filter((file) => file &&
+        !file.startsWith('../') &&
+        !path.isAbsolute(file) &&
+        (0, node_fs_1.existsSync)(path.join(repoRoot, file)));
+    if (files.length === 0) {
+        return;
+    }
+    // `detectFormatter` reads package.json, so it belongs inside the try - a
+    // workspace whose package.json cannot be parsed must not fail an init that
+    // already finished.
+    //
+    // Chunked as `nx format` chunks: the Angular flow records a `project.json`
+    // per project.
+    let formatter = null;
+    try {
+        formatter = (0, formatters_1.detectFormatter)(repoRoot);
+        if (!formatter) {
+            return;
+        }
+        if (formatter === 'oxfmt') {
+            for (const chunk of (0, chunkify_1.chunkify)(files)) {
+                if (chunk.length) {
+                    (0, oxfmt_1.writeWithOxfmt)(chunk, repoRoot);
+                }
+            }
+        }
+        else {
+            // oxfmt needs no equivalent filter - it silently skips file types it
+            // does not handle and exits 0. prettier still formats the rest of the
+            // batch, but exits 2 on one unsupported file, which would end a
+            // successful init with a spurious warning and prettier's own stderr.
+            const supported = await (0, prettier_1.filterToPrettierSupportedFiles)(files);
+            for (const chunk of (0, chunkify_1.chunkify)(supported)) {
+                if (chunk.length) {
+                    (0, prettier_1.writeWithPrettier)(chunk, repoRoot);
+                }
+            }
+        }
+    }
+    catch (e) {
+        output_1.output.warn({
+            title: formatter
+                ? `Could not format the files ${command} wrote with ${formatter}.`
+                : `Could not work out which formatter to use for the files ${command} wrote.`,
+            bodyLines: [
+                ...(e?.message ? [e.message] : []),
+                'Run "nx format:write" to format them.',
+            ],
+        });
+    }
+}

package/dist/src/command-line/init/implementation/utils.d.ts

@@ -0,0 +1,34 @@
+import { NxJsonConfiguration, TargetDefaultEntry, TargetDefaults } from '../../../config/nx-json';
+import { PackageJson } from '../../../utils/package-json';
+import { PackageManager, PackageManagerCommands } from '../../../utils/package-manager';
+export declare function createNxJsonFile(repoRoot: string, topologicalTargets: string[], cacheableOperations: string[], scriptOutputs: {
+    [name: string]: string;
+}): void;
+/**
+ * Locate-by-target upsert against an in-memory `targetDefaults` map. Merges
+ * `patch`'s config into the unfiltered (catch-all) default for `target`,
+ * promoting through the array form when one already exists. Used by `nx init`
+ * code paths that operate on raw JSON before a Tree exists — generators
+ * should use `upsertTargetDefault` from devkit instead.
+ */
+export declare function upsertTargetDefaultEntry(targetDefaults: TargetDefaults, target: string, patch: Partial<TargetDefaultEntry>): void;
+export declare function createNxJsonFromTurboJson(turboJson: Record<string, any>): NxJsonConfiguration;
+export declare function addDepsToPackageJson(repoRoot: string, packageManager: PackageManager, additionalPackages?: string[]): void;
+export declare function updateGitIgnore(root: string): void;
+export declare function runInstall(repoRoot: string, packageManager?: PackageManager, pmc?: PackageManagerCommands): void;
+/**
+ * Coerce any thrown value into a non-empty telemetry string. The naive
+ * `error.message || String(error)` yields "" for bare `new Error()`.
+ */
+export declare function toErrorString(error: unknown): string;
+export declare function readErrorStderr(error: unknown): string;
+export declare function extractErrorName(error: unknown, stderr: string): string;
+export declare function initCloud(installationSource: 'nx-init' | 'nx-init-angular' | 'nx-init-monorepo' | 'nx-init-nest' | 'nx-init-npm-repo' | 'nx-init-turborepo'): Promise<void>;
+export declare function addVsCodeRecommendedExtensions(repoRoot: string, extensions: string[]): void;
+export declare function markRootPackageJsonAsNxProjectLegacy(repoRoot: string, cacheableScripts: string[], pmc: PackageManagerCommands): void;
+export declare function markPackageJsonAsNxProject(packageJsonPath: string): void;
+export declare function printFinalMessage({ learnMoreLink, appendLines, }: {
+    learnMoreLink?: string;
+    appendLines?: string[];
+}): void;
+export declare function isMonorepo(packageJson: PackageJson): boolean;