@ohos-ports/nx 17.3.2-beta.0

package/src/migrations/update-16-2-0/remove-run-commands-output-path.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("../../utils/path");
+const format_changed_files_with_prettier_if_available_1 = require("../../generators/internal-utils/format-changed-files-with-prettier-if-available");
+const json_1 = require("../../generators/utils/json");
+const project_configuration_1 = require("../../generators/utils/project-configuration");
+async function removeRunCommandsOutputPath(tree) {
+    for (const [project, configuration] of (0, project_configuration_1.getProjects)(tree).entries()) {
+        const targets = configuration.targets ?? {};
+        let changed = false;
+        for (const [, target] of Object.entries(targets)) {
+            changed ||= updateTargetBlock(target);
+        }
+        if (changed) {
+            (0, project_configuration_1.updateProjectConfiguration)(tree, project, configuration);
+        }
+    }
+    if (tree.exists('nx.json')) {
+        (0, json_1.updateJson)(tree, 'nx.json', (json) => {
+            for (const [, target] of Object.entries(json.targetDefaults ?? {})) {
+                updateTargetBlock(target);
+            }
+            return json;
+        });
+    }
+    await (0, format_changed_files_with_prettier_if_available_1.formatChangedFilesWithPrettierIfAvailable)(tree);
+}
+exports.default = removeRunCommandsOutputPath;
+function updateTargetBlock(target) {
+    let changed = false;
+    if (target.executor === 'nx:run-commands' && target.options?.outputPath) {
+        changed = true;
+        const outputs = new Set(target.outputs ?? []);
+        outputs.delete('{options.outputPath}');
+        const newOutputs = Array.isArray(target.options.outputPath)
+            ? target.options.outputPath.map((p) => (0, path_1.joinPathFragments)('{workspaceRoot}', p))
+            : [(0, path_1.joinPathFragments)('{workspaceRoot}', target.options.outputPath)];
+        for (const outputPath of newOutputs) {
+            outputs.add(outputPath);
+        }
+        delete target.options.outputPath;
+        target.outputs = Array.from(outputs);
+    }
+    return changed;
+}

package/src/migrations/update-16-8-0/escape-dollar-sign-env-variables.d.ts

@@ -0,0 +1,12 @@
+import { Tree } from '../../generators/tree';
+/**
+ * This function escapes dollar sign in env variables
+ * It will go through:
+ * - '.env', '.local.env', '.env.local'
+ * - .env.[target-name], .[target-name].env
+ * - .env.[target-name].[configuration-name], .[target-name].[configuration-name].env
+ * - .env.[configuration-name], .[configuration-name].env
+ * at each project root and workspace root
+ * @param tree
+ */
+export default function escapeDollarSignEnvVariables(tree: Tree): void;

package/src/migrations/update-16-8-0/escape-dollar-sign-env-variables.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const project_configuration_1 = require("../../generators/utils/project-configuration");
+/**
+ * This function escapes dollar sign in env variables
+ * It will go through:
+ * - '.env', '.local.env', '.env.local'
+ * - .env.[target-name], .[target-name].env
+ * - .env.[target-name].[configuration-name], .[target-name].[configuration-name].env
+ * - .env.[configuration-name], .[configuration-name].env
+ * at each project root and workspace root
+ * @param tree
+ */
+function escapeDollarSignEnvVariables(tree) {
+    const envFiles = ['.env', '.local.env', '.env.local'];
+    for (const [_, configuration] of (0, project_configuration_1.getProjects)(tree).entries()) {
+        envFiles.push(`${configuration.root}/.env`, `${configuration.root}/.local.env`, `${configuration.root}/.env.local`);
+        for (const targetName in configuration.targets) {
+            const task = configuration.targets[targetName];
+            envFiles.push(`.env.${targetName}`, `.${targetName}.env`, `${configuration.root}/.env.${targetName}`, `${configuration.root}/.${targetName}.env`);
+            if (task.configurations) {
+                for (const configurationName in task.configurations) {
+                    envFiles.push(`.env.${targetName}.${configurationName}`, `.${targetName}.${configurationName}.env`, `.env.${configurationName}`, `.${configurationName}.env`, `${configuration.root}/.env.${targetName}.${configurationName}`, `${configuration.root}/.${targetName}.${configurationName}.env`, `${configuration.root}/.env.${configurationName}`, `${configuration.root}/.${configurationName}.env`);
+                }
+            }
+        }
+    }
+    for (const envFile of new Set(envFiles)) {
+        parseEnvFile(tree, envFile);
+    }
+}
+exports.default = escapeDollarSignEnvVariables;
+/**
+ * This function parse the env file and escape dollar sign
+ * @param tree
+ * @param envFilePath
+ * @returns
+ */
+function parseEnvFile(tree, envFilePath) {
+    if (!tree.exists(envFilePath)) {
+        return;
+    }
+    let envFileContent = tree.read(envFilePath, 'utf-8');
+    envFileContent = envFileContent
+        .split('\n')
+        .map((line) => {
+        line = line.trim();
+        if (!line.includes('$')) {
+            return line;
+        }
+        const declarations = line.split('=');
+        if (declarations[1].includes('$') && !declarations[1].includes(`\\$`)) {
+            declarations[1] = declarations[1].replace('$', `\\$`);
+            line = declarations.join('=');
+        }
+        return line;
+    })
+        .join('\n');
+    tree.write(envFilePath, envFileContent);
+}

package/src/migrations/update-16-9-0/remove-project-name-and-root-format.d.ts

@@ -0,0 +1,2 @@
+import { Tree } from '../../generators/tree';
+export default function removeProjectNameAndRootFormat(tree: Tree): Promise<void>;

package/src/migrations/update-16-9-0/remove-project-name-and-root-format.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const json_1 = require("../../generators/utils/json");
+const format_changed_files_with_prettier_if_available_1 = require("../../generators/internal-utils/format-changed-files-with-prettier-if-available");
+async function removeProjectNameAndRootFormat(tree) {
+    if (!tree.exists('nx.json')) {
+        return;
+    }
+    (0, json_1.updateJson)(tree, 'nx.json', (nxJson) => {
+        if (!nxJson.workspaceLayout) {
+            return nxJson;
+        }
+        delete nxJson.workspaceLayout.projectNameAndRootFormat;
+        if (Object.keys(nxJson.workspaceLayout).length === 0) {
+            delete nxJson.workspaceLayout;
+        }
+        return nxJson;
+    });
+    await (0, format_changed_files_with_prettier_if_available_1.formatChangedFilesWithPrettierIfAvailable)(tree);
+}
+exports.default = removeProjectNameAndRootFormat;

package/src/migrations/update-17-0-0/move-cache-directory.d.ts

@@ -0,0 +1,2 @@
+import { Tree } from '../../generators/tree';
+export default function moveCacheDirectory(tree: Tree): void;

package/src/migrations/update-17-0-0/move-cache-directory.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ignore_1 = require("ignore");
+function moveCacheDirectory(tree) {
+    // 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 (tree.exists('lerna.json') && !tree.exists('nx.json')) {
+        return;
+    }
+    updateGitIgnore(tree);
+    if (tree.exists('.prettierignore')) {
+        const ignored = tree.read('.prettierignore', 'utf-8');
+        if (!ignored.includes('.nx/cache')) {
+            tree.write('.prettierignore', [ignored, '/.nx/cache'].join('\n'));
+        }
+    }
+}
+exports.default = moveCacheDirectory;
+function updateGitIgnore(tree) {
+    const gitignore = tree.exists('.gitignore')
+        ? tree.read('.gitignore', 'utf-8')
+        : '';
+    const ig = (0, ignore_1.default)();
+    ig.add(gitignore);
+    if (!ig.ignores('.nx/cache')) {
+        const updatedLines = gitignore.length
+            ? [gitignore, '.nx/cache']
+            : ['.nx/cache'];
+        tree.write('.gitignore', updatedLines.join('\n'));
+    }
+}

package/src/migrations/update-17-0-0/rm-default-collection-npm-scope.d.ts

@@ -0,0 +1,2 @@
+import { Tree } from '../../generators/tree';
+export default function update(tree: Tree): Promise<void>;

package/src/migrations/update-17-0-0/rm-default-collection-npm-scope.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const format_changed_files_with_prettier_if_available_1 = require("../../generators/internal-utils/format-changed-files-with-prettier-if-available");
+const nx_json_1 = require("../../generators/utils/nx-json");
+const json_1 = require("../../generators/utils/json");
+const logger_1 = require("../../utils/logger");
+const path_1 = require("../../utils/path");
+async function update(tree) {
+    if (!tree.exists('nx.json')) {
+        return;
+    }
+    const nxJson = (0, nx_json_1.readNxJson)(tree);
+    delete nxJson.cli?.['defaultCollection'];
+    if (nxJson?.cli && Object.keys(nxJson.cli).length < 1) {
+        delete nxJson.cli;
+    }
+    warnNpmScopeHasChanged(tree, nxJson);
+    delete nxJson['npmScope'];
+    (0, nx_json_1.updateNxJson)(tree, nxJson);
+    await (0, format_changed_files_with_prettier_if_available_1.formatChangedFilesWithPrettierIfAvailable)(tree);
+}
+exports.default = update;
+function warnNpmScopeHasChanged(tree, nxJson) {
+    const originalScope = nxJson['npmScope'];
+    // There was no original scope
+    if (!originalScope) {
+        return false;
+    }
+    // package.json does not exist
+    if (!tree.exists('package.json')) {
+        return false;
+    }
+    const newScope = getNpmScopeFromPackageJson(tree);
+    // New and Original scope are the same.
+    if (originalScope === newScope) {
+        return false;
+    }
+    const packageJsonName = (0, json_1.readJson)(tree, 'package.json').name;
+    if (newScope) {
+        logger_1.logger.warn({
+            title: 'npmScope has been removed from nx.json',
+            bodyLines: [
+                'This will now be read from package.json',
+                `Old value which was in nx.json: ${originalScope}`,
+                `New value from package.json: ${newScope}`,
+                `Typescript path mappings for new libraries will now be generated as such: @${newScope}/new-lib instead of @${originalScope}/new-lib`,
+                `If you would like to change this back, change the name in package.json to ${packageJsonName.replace(newScope, originalScope)}`,
+            ],
+        });
+    }
+    else {
+        // There is no scope in package.json
+        logger_1.logger.warn({
+            title: 'npmScope has been removed from nx.json',
+            bodyLines: [
+                'This will now be read from package.json',
+                `Old value which was in nx.json: ${originalScope}`,
+                `New value from package.json: null`,
+                `Typescript path mappings for new libraries will now be generated as such: new-lib instead of @${originalScope}/new-lib`,
+                `If you would like to change this back, change the name in package.json to ${(0, path_1.joinPathFragments)(`@${originalScope}`, packageJsonName)}`,
+            ],
+        });
+    }
+}
+function getNpmScopeFromPackageJson(tree) {
+    const { name } = tree.exists('package.json')
+        ? (0, json_1.readJson)(tree, 'package.json')
+        : { name: null };
+    if (name?.startsWith('@')) {
+        return name.split('/')[0].substring(1);
+    }
+}

package/src/migrations/update-17-0-0/use-minimal-config-for-tasks-runner-options.d.ts

@@ -0,0 +1,2 @@
+import { Tree } from '../../generators/tree';
+export default function migrate(tree: Tree): Promise<void>;

package/src/migrations/update-17-0-0/use-minimal-config-for-tasks-runner-options.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const json_1 = require("../../generators/utils/json");
+const format_changed_files_with_prettier_if_available_1 = require("../../generators/internal-utils/format-changed-files-with-prettier-if-available");
+const nx_json_1 = require("../../generators/utils/nx-json");
+const update_manager_1 = require("../../nx-cloud/update-manager");
+const run_command_1 = require("../../tasks-runner/run-command");
+const output_1 = require("../../utils/output");
+async function migrate(tree) {
+    if (!tree.exists('nx.json')) {
+        return;
+    }
+    const nxJson = (0, nx_json_1.readNxJson)(tree);
+    // Already migrated
+    if (!nxJson.tasksRunnerOptions?.default) {
+        return;
+    }
+    const nxCloudClientSupported = await isNxCloudClientSupported(nxJson);
+    (0, json_1.updateJson)(tree, 'nx.json', (nxJson) => {
+        const { runner, options } = nxJson.tasksRunnerOptions.default;
+        // This property shouldn't ever be part of tasks runner options.
+        if (options.useDaemonProcess !== undefined) {
+            nxJson.useDaemonProcess = options.useDaemonProcess;
+            delete options.useDaemonProcess;
+        }
+        // Remaining keys may be specific to a given runner, so leave them alone if there are multiple runners.
+        if (Object.keys(nxJson.tasksRunnerOptions ?? {}).length > 1) {
+            return nxJson;
+        }
+        // These options can only be moved for nx-cloud.
+        if (runner === 'nx-cloud' || runner === '@nrwl/nx-cloud') {
+            nxJson.nxCloudAccessToken = options.accessToken;
+            delete options.accessToken;
+            if (options.url) {
+                nxJson.nxCloudUrl = options.url;
+                delete options.url;
+            }
+            if (nxCloudClientSupported) {
+                removeNxCloudDependency(tree);
+            }
+            else {
+                options.useLightClient = false;
+            }
+            if (options.encryptionKey) {
+                nxJson.nxCloudEncryptionKey = options.encryptionKey;
+                delete options.encryptionKey;
+            }
+        }
+        // These options should be safe to move for all tasks runners:
+        if (options.parallel !== undefined) {
+            nxJson.parallel = options.parallel;
+            delete options.parallel;
+        }
+        if (options.cacheDirectory !== undefined) {
+            nxJson.cacheDirectory = options.cacheDirectory;
+            delete options.cacheDirectory;
+        }
+        if (Array.isArray(options.cacheableOperations)) {
+            nxJson.targetDefaults ??= {};
+            for (const target of options.cacheableOperations) {
+                nxJson.targetDefaults[target] ??= {};
+                nxJson.targetDefaults[target].cache ??= true;
+            }
+            delete options.cacheableOperations;
+        }
+        if (['nx-cloud', '@nrwl/nx-cloud', 'nx/tasks-runners/default'].includes(runner)) {
+            delete nxJson.tasksRunnerOptions.default.runner;
+            if (Object.values(options).length === 0) {
+                delete nxJson.tasksRunnerOptions;
+            }
+        }
+        return nxJson;
+    });
+    await (0, format_changed_files_with_prettier_if_available_1.formatChangedFilesWithPrettierIfAvailable)(tree);
+}
+exports.default = migrate;
+async function isNxCloudClientSupported(nxJson) {
+    const nxCloudOptions = (0, run_command_1.getRunnerOptions)('default', nxJson, {}, true);
+    // Non enterprise workspaces support the Nx Cloud Client
+    if (!isNxCloudEnterpriseWorkspace(nxJson)) {
+        return true;
+    }
+    // If we can get the nx cloud client, it's supported
+    try {
+        await (0, update_manager_1.verifyOrUpdateNxCloudClient)(nxCloudOptions);
+        return true;
+    }
+    catch (e) {
+        if (e instanceof update_manager_1.NxCloudEnterpriseOutdatedError) {
+            output_1.output.warn({
+                title: 'Nx Cloud Instance is outdated.',
+                bodyLines: [
+                    'If you are an Nx Enterprise customer, please reach out to your assigned Developer Productivity Engineer.',
+                    'If you are NOT an Nx Enterprise customer but are seeing this message, please reach out to cloud-support@nrwl.io.',
+                ],
+            });
+        }
+        return false;
+    }
+}
+function isNxCloudEnterpriseWorkspace(nxJson) {
+    const { runner, options } = nxJson.tasksRunnerOptions.default;
+    return ((runner === 'nx-cloud' || runner === '@nrwl/nx-cloud') &&
+        options.url &&
+        ![
+            'https://nx.app',
+            'https://cloud.nx.app',
+            'https://staging.nx.app',
+            'https://snapshot.nx.app',
+        ].includes(options.url));
+}
+function removeNxCloudDependency(tree) {
+    if (tree.exists('package.json')) {
+        (0, json_1.updateJson)(tree, 'package.json', (packageJson) => {
+            delete packageJson.dependencies?.['nx-cloud'];
+            delete packageJson.devDependencies?.['nx-cloud'];
+            delete packageJson.dependencies?.['@nrwl/nx-cloud'];
+            delete packageJson.devDependencies?.['@nrwl/nx-cloud'];
+            return packageJson;
+        });
+    }
+}

package/src/migrations/update-17-3-0/nx-release-path.d.ts

@@ -0,0 +1,3 @@
+import { Tree } from '../../generators/tree';
+export default function nxReleasePath(tree: Tree): void;
+export declare function visitNotIgnoredFiles(tree: Tree, dirPath: string, visitor: (path: string) => void): void;

package/src/migrations/update-17-3-0/nx-release-path.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.visitNotIgnoredFiles = void 0;
+const node_path_1 = require("node:path");
+const ignore_1 = require("../../utils/ignore");
+function nxReleasePath(tree) {
+    visitNotIgnoredFiles(tree, '', (file) => {
+        console.log({ file });
+        const contents = tree.read(file).toString('utf-8');
+        if (
+        // the deep import usage should be replaced by the new location
+        contents.includes('nx/src/command-line/release') ||
+            // changelog-renderer has moved into nx/release
+            contents.includes('nx/changelog-renderer')) {
+            const finalContents = contents
+                // replace instances of old changelog renderer location
+                .replace(/nx\/changelog-renderer/g, 'nx/release/changelog-renderer')
+                // replace instances of deep import for programmatic API (only perform the replacement if an actual import by checking for trailing ' or ")
+                .replace(/nx\/src\/command-line\/release(['"])/g, 'nx/release$1');
+            tree.write(file, finalContents);
+        }
+    });
+}
+exports.default = nxReleasePath;
+// Adapted from devkit
+function visitNotIgnoredFiles(tree, dirPath = tree.root, visitor) {
+    const ig = (0, ignore_1.getIgnoreObject)();
+    dirPath = normalizePathRelativeToRoot(dirPath, tree.root);
+    if (dirPath !== '' && ig?.ignores(dirPath)) {
+        return;
+    }
+    for (const child of tree.children(dirPath)) {
+        const fullPath = (0, node_path_1.join)(dirPath, child);
+        if (ig?.ignores(fullPath)) {
+            continue;
+        }
+        if (tree.isFile(fullPath)) {
+            visitor(fullPath);
+        }
+        else {
+            visitNotIgnoredFiles(tree, fullPath, visitor);
+        }
+    }
+}
+exports.visitNotIgnoredFiles = visitNotIgnoredFiles;
+// Copied from devkit
+function normalizePathRelativeToRoot(path, root) {
+    return (0, node_path_1.relative)(root, (0, node_path_1.join)(root, path)).split(node_path_1.sep).join('/');
+}

package/src/migrations/update-17-3-0/update-nxw.d.ts

@@ -0,0 +1,2 @@
+import type { Tree } from '../../generators/tree';
+export default function (tree: Tree): Promise<void>;

package/src/migrations/update-17-3-0/update-nxw.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const update_nxw_1 = require("../../utils/update-nxw");
+async function default_1(tree) {
+    (0, update_nxw_1.updateNxw)(tree);
+}
+exports.default = default_1;

package/src/native/assert-supported-platform.d.ts

@@ -0,0 +1 @@
+export declare function assertSupportedPlatform(): void;

package/src/native/assert-supported-platform.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertSupportedPlatform = void 0;
+const output_1 = require("../utils/output");
+function assertSupportedPlatform() {
+    try {
+        require('./index.js');
+    }
+    catch (e) {
+        let title = '';
+        let bodyLines = [];
+        if (process.platform == 'win32' ||
+            process.platform == 'darwin' ||
+            process.platform == 'linux' ||
+            process.platform == 'freebsd') {
+            title = 'Missing Platform Dependency';
+            bodyLines = [
+                `The Nx CLI could not find or load the native binary for your supported platform (${process.platform}-${process.arch}).`,
+                'This likely means that optional dependencies were not installed correctly, or your system is missing some system dependencies.',
+            ];
+            if (process.env.NX_VERBOSE_LOGGING == 'true') {
+                bodyLines.push('', 'Additional error information:', e.message);
+            }
+        }
+        else {
+            title = 'Platform not supported';
+            bodyLines = [
+                `This platform (${process.platform}-${process.arch}) is currently not supported by Nx.`,
+            ];
+        }
+        bodyLines.push('For more information please see https://nx.dev/recipes/troubleshooting/troubleshoot-nx-install-issues');
+        output_1.output.error({
+            title,
+            bodyLines,
+        });
+        process.exit(1);
+    }
+}
+exports.assertSupportedPlatform = assertSupportedPlatform;