@ohos-ports/nx 19.8.4-beta.0

package/src/hasher/task-hasher.js

@@ -0,0 +1,266 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InProcessTaskHasher = exports.DaemonBasedTaskHasher = void 0;
+exports.getNamedInputs = getNamedInputs;
+exports.getTargetInputs = getTargetInputs;
+exports.extractPatternsFromFileSets = extractPatternsFromFileSets;
+exports.getInputs = getInputs;
+exports.isSelfInput = isSelfInput;
+exports.isDepsOutput = isDepsOutput;
+exports.expandSingleProjectInputs = expandSingleProjectInputs;
+exports.expandNamedInput = expandNamedInput;
+exports.filterUsingGlobPatterns = filterUsingGlobPatterns;
+const file_hasher_1 = require("./file-hasher");
+const node_task_hasher_impl_1 = require("./node-task-hasher-impl");
+const minimatch_1 = require("minimatch");
+const native_task_hasher_impl_1 = require("./native-task-hasher-impl");
+const workspace_root_1 = require("../utils/workspace-root");
+class DaemonBasedTaskHasher {
+    constructor(daemonClient, runnerOptions) {
+        this.daemonClient = daemonClient;
+        this.runnerOptions = runnerOptions;
+    }
+    async hashTasks(tasks, taskGraph, env) {
+        return this.daemonClient.hashTasks(this.runnerOptions, tasks, taskGraph, env ?? process.env);
+    }
+    async hashTask(task, taskGraph, env) {
+        return (await this.daemonClient.hashTasks(this.runnerOptions, [task], taskGraph, env ?? process.env))[0];
+    }
+}
+exports.DaemonBasedTaskHasher = DaemonBasedTaskHasher;
+class InProcessTaskHasher {
+    constructor(projectFileMap, allWorkspaceFiles, projectGraph, nxJson, externalRustReferences, options) {
+        this.projectFileMap = projectFileMap;
+        this.allWorkspaceFiles = allWorkspaceFiles;
+        this.projectGraph = projectGraph;
+        this.nxJson = nxJson;
+        this.externalRustReferences = externalRustReferences;
+        this.options = options;
+        this.useNativeTaskHasher = process.env.NX_NATIVE_TASK_HASHER !== 'false';
+        const legacyRuntimeInputs = (this.options && this.options.runtimeCacheInputs
+            ? this.options.runtimeCacheInputs
+            : []).map((r) => ({ runtime: r }));
+        if (process.env.NX_CLOUD_ENCRYPTION_KEY) {
+            legacyRuntimeInputs.push({ env: 'NX_CLOUD_ENCRYPTION_KEY' });
+        }
+        const legacyFilesetInputs = [
+            'nx.json',
+            // ignore files will change the set of inputs to the hasher
+            '.gitignore',
+            '.nxignore',
+        ].map((d) => ({ fileset: `{workspaceRoot}/${d}` }));
+        this.taskHasher = !this.useNativeTaskHasher
+            ? new node_task_hasher_impl_1.NodeTaskHasherImpl(nxJson, legacyRuntimeInputs, legacyFilesetInputs, this.projectFileMap, this.allWorkspaceFiles, this.projectGraph, {
+                selectivelyHashTsConfig: this.options?.selectivelyHashTsConfig ?? false,
+            })
+            : new native_task_hasher_impl_1.NativeTaskHasherImpl(workspace_root_1.workspaceRoot, nxJson, this.projectGraph, this.externalRustReferences, {
+                selectivelyHashTsConfig: this.options?.selectivelyHashTsConfig ?? false,
+            });
+    }
+    async hashTasks(tasks, taskGraph, env) {
+        if (this.useNativeTaskHasher) {
+            const hashes = await this.taskHasher.hashTasks(tasks, taskGraph, env ?? process.env);
+            return tasks.map((task, index) => this.createHashDetails(task, hashes[index]));
+        }
+        else {
+            return await Promise.all(tasks.map((t) => this.hashTask(t, taskGraph, env)));
+        }
+    }
+    async hashTask(task, taskGraph, env) {
+        const res = await this.taskHasher.hashTask(task, taskGraph, env ?? process.env);
+        return this.createHashDetails(task, res);
+    }
+    createHashDetails(task, res) {
+        const command = this.hashCommand(task);
+        return {
+            value: (0, file_hasher_1.hashArray)([res.value, command]),
+            details: {
+                command,
+                nodes: res.details,
+                implicitDeps: {},
+                runtime: {},
+            },
+        };
+    }
+    hashCommand(task) {
+        const overrides = { ...task.overrides };
+        delete overrides['__overrides_unparsed__'];
+        const sortedOverrides = {};
+        for (let k of Object.keys(overrides).sort()) {
+            sortedOverrides[k] = overrides[k];
+        }
+        return (0, file_hasher_1.hashArray)([
+            task.target.project ?? '',
+            task.target.target ?? '',
+            task.target.configuration ?? '',
+            JSON.stringify(sortedOverrides),
+        ]);
+    }
+}
+exports.InProcessTaskHasher = InProcessTaskHasher;
+InProcessTaskHasher.version = '3.0';
+const DEFAULT_INPUTS = [
+    {
+        fileset: '{projectRoot}/**/*',
+    },
+    {
+        dependencies: true,
+        input: 'default',
+    },
+];
+function getNamedInputs(nxJson, project) {
+    return {
+        default: [{ fileset: '{projectRoot}/**/*' }],
+        ...nxJson.namedInputs,
+        ...project.data.namedInputs,
+    };
+}
+function getTargetInputs(nxJson, projectNode, target) {
+    const namedInputs = getNamedInputs(nxJson, projectNode);
+    const targetData = projectNode.data.targets[target];
+    const targetDefaults = (nxJson.targetDefaults || {})[target];
+    const inputs = splitInputsIntoSelfAndDependencies(targetData.inputs || targetDefaults?.inputs || DEFAULT_INPUTS, namedInputs);
+    const selfInputs = extractPatternsFromFileSets(inputs.selfInputs);
+    const dependencyInputs = extractPatternsFromFileSets(inputs.depsInputs.map((s) => expandNamedInput(s.input, namedInputs)).flat());
+    return { selfInputs, dependencyInputs };
+}
+function extractPatternsFromFileSets(inputs) {
+    return inputs
+        .filter((c) => !!c['fileset'])
+        .map((c) => c['fileset']);
+}
+function getInputs(task, projectGraph, nxJson) {
+    const projectNode = projectGraph.nodes[task.target.project];
+    const namedInputs = getNamedInputs(nxJson, projectNode);
+    const targetData = projectNode.data.targets[task.target.target];
+    const targetDefaults = (nxJson.targetDefaults || {})[task.target.target];
+    const { selfInputs, depsInputs, depsOutputs, projectInputs } = splitInputsIntoSelfAndDependencies(targetData.inputs || targetDefaults?.inputs || DEFAULT_INPUTS, namedInputs);
+    return { selfInputs, depsInputs, depsOutputs, projectInputs };
+}
+function splitInputsIntoSelfAndDependencies(inputs, namedInputs) {
+    const depsInputs = [];
+    const projectInputs = [];
+    const selfInputs = [];
+    for (const d of inputs) {
+        if (typeof d === 'string') {
+            if (d.startsWith('^')) {
+                depsInputs.push({ input: d.substring(1), dependencies: true });
+            }
+            else {
+                selfInputs.push(d);
+            }
+        }
+        else {
+            if (('dependencies' in d && d.dependencies) ||
+                // Todo(@AgentEnder): Remove check in v17
+                ('projects' in d &&
+                    typeof d.projects === 'string' &&
+                    d.projects === 'dependencies')) {
+                depsInputs.push({
+                    input: d.input,
+                    dependencies: true,
+                });
+            }
+            else if ('projects' in d &&
+                d.projects &&
+                // Todo(@AgentEnder): Remove check in v17
+                !(d.projects === 'self')) {
+                projectInputs.push({
+                    input: d.input,
+                    projects: Array.isArray(d.projects) ? d.projects : [d.projects],
+                });
+            }
+            else {
+                selfInputs.push(d);
+            }
+        }
+    }
+    const expandedInputs = expandSingleProjectInputs(selfInputs, namedInputs);
+    return {
+        depsInputs,
+        projectInputs,
+        selfInputs: expandedInputs.filter(isSelfInput),
+        depsOutputs: expandedInputs.filter(isDepsOutput),
+    };
+}
+function isSelfInput(input) {
+    return !('dependentTasksOutputFiles' in input);
+}
+function isDepsOutput(input) {
+    return 'dependentTasksOutputFiles' in input;
+}
+function expandSingleProjectInputs(inputs, namedInputs) {
+    const expanded = [];
+    for (const d of inputs) {
+        if (typeof d === 'string') {
+            if (d.startsWith('^'))
+                throw new Error(`namedInputs definitions cannot start with ^`);
+            if (namedInputs[d]) {
+                expanded.push(...expandNamedInput(d, namedInputs));
+            }
+            else {
+                expanded.push({ fileset: d });
+            }
+        }
+        else {
+            if (d.projects || d.dependencies) {
+                throw new Error(`namedInputs definitions can only refer to other namedInputs definitions within the same project.`);
+            }
+            if (d.fileset ||
+                d.env ||
+                d.runtime ||
+                d.externalDependencies ||
+                d.dependentTasksOutputFiles) {
+                expanded.push(d);
+            }
+            else {
+                expanded.push(...expandNamedInput(d.input, namedInputs));
+            }
+        }
+    }
+    return expanded;
+}
+function expandNamedInput(input, namedInputs) {
+    namedInputs ||= {};
+    if (!namedInputs[input])
+        throw new Error(`Input '${input}' is not defined`);
+    return expandSingleProjectInputs(namedInputs[input], namedInputs);
+}
+function filterUsingGlobPatterns(root, files, patterns) {
+    const filesetWithExpandedProjectRoot = patterns
+        .map((f) => f.replace('{projectRoot}', root))
+        .map((r) => {
+        // handling root level projects that create './' pattern that doesn't work with minimatch
+        if (r.startsWith('./'))
+            return r.substring(2);
+        if (r.startsWith('!./'))
+            return '!' + r.substring(3);
+        return r;
+    });
+    const positive = [];
+    const negative = [];
+    for (const p of filesetWithExpandedProjectRoot) {
+        if (p.startsWith('!')) {
+            negative.push(p);
+        }
+        else {
+            positive.push(p);
+        }
+    }
+    if (positive.length === 0 && negative.length === 0) {
+        return files;
+    }
+    return files.filter((f) => {
+        let matchedPositive = false;
+        if (positive.length === 0 ||
+            (positive.length === 1 && positive[0] === `${root}/**/*`)) {
+            matchedPositive = true;
+        }
+        else {
+            matchedPositive = positive.some((pattern) => (0, minimatch_1.minimatch)(f.file, pattern));
+        }
+        if (!matchedPositive)
+            return false;
+        return negative.every((pattern) => (0, minimatch_1.minimatch)(f.file, pattern));
+    });
+}

package/src/index.d.ts

@@ -0,0 +1 @@
+export { initTasksRunner } from './tasks-runner/init-tasks-runner';

package/src/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initTasksRunner = void 0;
+var init_tasks_runner_1 = require("./tasks-runner/init-tasks-runner");
+Object.defineProperty(exports, "initTasksRunner", { enumerable: true, get: function () { return init_tasks_runner_1.initTasksRunner; } });

package/src/migrations/update-15-0-0/migrate-to-inputs.d.ts

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

package/src/migrations/update-15-0-0/migrate-to-inputs.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+const format_changed_files_with_prettier_if_available_1 = require("../../generators/internal-utils/format-changed-files-with-prettier-if-available");
+const project_configuration_1 = require("../../generators/utils/project-configuration");
+const nx_json_1 = require("../../generators/utils/nx-json");
+const path_1 = require("../../utils/path");
+const path_2 = require("path");
+const json_1 = require("../../generators/utils/json");
+const skippedFiles = [
+    'package.json', // Not to be added to filesets
+    'babel.config.json', // Will be handled by various plugins
+    'karma.conf.js', // Will be handled by @nx/angular
+    'jest.preset.js', // Will be handled by @nx/jest
+    '.storybook', // Will be handled by @nx/storybook
+    // Will be handled by @nx/eslint
+    '.eslintrc.json',
+    '.eslintrc.js',
+];
+async function default_1(tree) {
+    // If the workspace doesn't have a nx.json, don't make any changes
+    if (!tree.exists('nx.json')) {
+        return;
+    }
+    const nxJson = (0, nx_json_1.readNxJson)(tree);
+    // If this is a npm workspace, don't make any changes
+    if (nxJson.extends === 'nx/presets/npm.json') {
+        return;
+    }
+    nxJson.namedInputs ??= {
+        default: ['{projectRoot}/**/*', 'sharedGlobals'],
+        sharedGlobals: [],
+        production: ['default'],
+    };
+    if (nxJson.namedInputs.default) {
+        if (!nxJson.namedInputs.production) {
+            nxJson.namedInputs.production = ['default'];
+        }
+        else if (!nxJson.namedInputs.production.includes('default')) {
+            nxJson.namedInputs.production = [
+                'default',
+                ...nxJson.namedInputs.production,
+            ];
+        }
+    }
+    if (isBuildATarget(tree)) {
+        nxJson.targetDefaults ??= {};
+        nxJson.targetDefaults.build ??= {};
+        nxJson.targetDefaults.build.inputs ??= ['production', '^production'];
+    }
+    if (nxJson.implicitDependencies) {
+        const projects = (0, project_configuration_1.getProjects)(tree);
+        for (const [files, dependents] of Object.entries(nxJson.implicitDependencies)) {
+            // Skip these because other plugins take care of them
+            if (skippedFiles.includes(files)) {
+                continue;
+            }
+            else if (Array.isArray(dependents)) {
+                nxJson.namedInputs.projectSpecificFiles = [];
+                const defaultFileset = new Set(nxJson.namedInputs.default ?? ['{projectRoot}/**/*', 'sharedGlobals']);
+                defaultFileset.add('projectSpecificFiles');
+                nxJson.namedInputs.default = Array.from(defaultFileset);
+                for (const dependent of dependents) {
+                    const project = projects.get(dependent);
+                    project.namedInputs ??= {};
+                    const projectSpecificFileset = new Set(project.namedInputs.projectSpecificFiles ?? []);
+                    projectSpecificFileset.add((0, path_1.joinPathFragments)('{workspaceRoot}', files));
+                    project.namedInputs.projectSpecificFiles = Array.from(projectSpecificFileset);
+                    try {
+                        (0, project_configuration_1.updateProjectConfiguration)(tree, dependent, project);
+                    }
+                    catch {
+                        if (tree.exists((0, path_2.join)(project.root, 'package.json'))) {
+                            (0, json_1.updateJson)(tree, (0, path_2.join)(project.root, 'package.json'), (json) => {
+                                json.nx ??= {};
+                                json.nx.namedInputs ??= {};
+                                json.nx.namedInputs.projectSpecificFiles ??=
+                                    project.namedInputs.projectSpecificFiles;
+                                return json;
+                            });
+                        }
+                    }
+                }
+            }
+            else {
+                nxJson.namedInputs.sharedGlobals.push((0, path_1.joinPathFragments)('{workspaceRoot}', files));
+            }
+        }
+        delete nxJson.implicitDependencies;
+    }
+    (0, nx_json_1.updateNxJson)(tree, nxJson);
+    await (0, format_changed_files_with_prettier_if_available_1.formatChangedFilesWithPrettierIfAvailable)(tree);
+}
+function isBuildATarget(tree) {
+    const projects = (0, project_configuration_1.getProjects)(tree);
+    for (const [_, project] of projects) {
+        if (project.targets?.build) {
+            return true;
+        }
+    }
+    return false;
+}

package/src/migrations/update-15-0-0/prefix-outputs.d.ts

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

package/src/migrations/update-15-0-0/prefix-outputs.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+const format_changed_files_with_prettier_if_available_1 = require("../../generators/internal-utils/format-changed-files-with-prettier-if-available");
+const project_configuration_1 = require("../../generators/utils/project-configuration");
+const nx_json_1 = require("../../generators/utils/nx-json");
+const path_1 = require("path");
+const utils_1 = require("../../tasks-runner/utils");
+const json_1 = require("../../generators/utils/json");
+async function default_1(tree) {
+    // If the workspace doesn't have a nx.json, don't make any changes
+    if (!tree.exists('nx.json')) {
+        return;
+    }
+    const nxJson = (0, nx_json_1.readNxJson)(tree);
+    for (const [projectName, project] of (0, project_configuration_1.getProjects)(tree)) {
+        for (const [_, target] of Object.entries(project.targets ?? {})) {
+            if (!target.outputs) {
+                continue;
+            }
+            target.outputs = (0, utils_1.transformLegacyOutputs)(project.root, target.outputs);
+        }
+        try {
+            (0, project_configuration_1.updateProjectConfiguration)(tree, projectName, project);
+        }
+        catch {
+            if (tree.exists((0, path_1.join)(project.root, 'package.json'))) {
+                (0, json_1.updateJson)(tree, (0, path_1.join)(project.root, 'package.json'), (json) => {
+                    for (const target of Object.values(json.nx?.targets ?? {})) {
+                        if (target.outputs) {
+                            target.outputs = (0, utils_1.transformLegacyOutputs)(project.root, target.outputs);
+                        }
+                    }
+                    return json;
+                });
+            }
+        }
+    }
+    if (nxJson.targetDefaults) {
+        for (const [_, target] of Object.entries(nxJson.targetDefaults)) {
+            if (!target.outputs) {
+                continue;
+            }
+            target.outputs = (0, utils_1.transformLegacyOutputs)('{projectRoot}', target.outputs);
+        }
+        (0, nx_json_1.updateNxJson)(tree, nxJson);
+    }
+    await (0, format_changed_files_with_prettier_if_available_1.formatChangedFilesWithPrettierIfAvailable)(tree);
+}

package/src/migrations/update-16-0-0/remove-nrwl-cli.d.ts

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

package/src/migrations/update-16-0-0/remove-nrwl-cli.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+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");
+async function default_1(tree) {
+    (0, json_1.updateJson)(tree, 'package.json', (json) => {
+        for (const deps of [json.dependencies, json.devDependencies]) {
+            if (deps) {
+                delete deps['@nrwl/cli'];
+            }
+        }
+        return json;
+    });
+    await (0, format_changed_files_with_prettier_if_available_1.formatChangedFilesWithPrettierIfAvailable)(tree);
+}

package/src/migrations/update-16-0-0/update-depends-on-to-tokens.d.ts

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

package/src/migrations/update-16-0-0/update-depends-on-to-tokens.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+const project_configuration_1 = require("../../generators/utils/project-configuration");
+const format_changed_files_with_prettier_if_available_1 = require("../../generators/internal-utils/format-changed-files-with-prettier-if-available");
+async function default_1(tree) {
+    updateDependsOnAndInputsInsideNxJson(tree);
+    const projectsConfigurations = (0, project_configuration_1.getProjects)(tree);
+    for (const [projectName, projectConfiguration] of projectsConfigurations) {
+        let projectChanged = false;
+        for (const [targetName, targetConfiguration] of Object.entries(projectConfiguration.targets ?? {})) {
+            for (const dependency of targetConfiguration.dependsOn ?? []) {
+                if (typeof dependency !== 'string') {
+                    if (dependency.projects === 'self' ||
+                        dependency.projects === '{self}') {
+                        delete dependency.projects;
+                        projectChanged = true;
+                    }
+                    else if (dependency.projects === 'dependencies' ||
+                        dependency.projects === '{dependencies}') {
+                        delete dependency.projects;
+                        dependency.dependencies = true;
+                        projectChanged = true;
+                    }
+                }
+            }
+            for (let i = 0; i < targetConfiguration.inputs?.length ?? 0; i++) {
+                const input = targetConfiguration.inputs[i];
+                if (typeof input !== 'string') {
+                    if ('projects' in input &&
+                        (input.projects === 'self' || input.projects === '{self}')) {
+                        delete input.projects;
+                        projectChanged = true;
+                    }
+                    else if ('projects' in input &&
+                        (input.projects === 'dependencies' ||
+                            input.projects === '{dependencies}')) {
+                        delete input.projects;
+                        targetConfiguration.inputs[i] = {
+                            ...input,
+                            dependencies: true,
+                        };
+                        projectChanged = true;
+                    }
+                }
+            }
+        }
+        if (projectChanged) {
+            (0, project_configuration_1.updateProjectConfiguration)(tree, projectName, projectConfiguration);
+        }
+    }
+    await (0, format_changed_files_with_prettier_if_available_1.formatChangedFilesWithPrettierIfAvailable)(tree);
+}
+function updateDependsOnAndInputsInsideNxJson(tree) {
+    const nxJson = (0, project_configuration_1.readNxJson)(tree);
+    let nxJsonChanged = false;
+    for (const [target, defaults] of Object.entries(nxJson?.targetDefaults ?? {})) {
+        for (const dependency of defaults.dependsOn ?? []) {
+            if (typeof dependency !== 'string') {
+                if (dependency.projects === 'self' ||
+                    dependency.projects === '{self}') {
+                    delete dependency.projects;
+                    nxJsonChanged = true;
+                }
+                else if (dependency.projects === 'dependencies' ||
+                    dependency.projects === '{dependencies}') {
+                    delete dependency.projects;
+                    dependency.dependencies = true;
+                    nxJsonChanged = true;
+                }
+            }
+        }
+        for (let i = 0; i < defaults.inputs?.length ?? 0; i++) {
+            const input = defaults.inputs[i];
+            if (typeof input !== 'string') {
+                if ('projects' in input &&
+                    (input.projects === 'self' || input.projects === '{self}')) {
+                    delete input.projects;
+                    nxJsonChanged = true;
+                }
+                else if ('projects' in input &&
+                    (input.projects === 'dependencies' ||
+                        input.projects === '{dependencies}')) {
+                    delete input.projects;
+                    defaults.inputs[i] = {
+                        ...input,
+                        dependencies: true,
+                    };
+                    nxJsonChanged = true;
+                }
+            }
+        }
+    }
+    if (nxJsonChanged) {
+        (0, project_configuration_1.updateNxJson)(tree, nxJson);
+    }
+}

package/src/migrations/update-16-0-0/update-nx-cloud-runner.d.ts

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

package/src/migrations/update-16-0-0/update-nx-cloud-runner.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+const project_configuration_1 = require("../../generators/utils/project-configuration");
+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 default_1(tree) {
+    (0, json_1.updateJson)(tree, 'package.json', (json) => {
+        if (json.dependencies && json.dependencies['@nrwl/nx-cloud']) {
+            json.dependencies['nx-cloud'] = json.dependencies['@nrwl/nx-cloud'];
+            delete json.dependencies['@nrwl/nx-cloud'];
+        }
+        if (json.devDependencies && json.devDependencies['@nrwl/nx-cloud']) {
+            json.devDependencies['nx-cloud'] = json.devDependencies['@nrwl/nx-cloud'];
+            delete json.devDependencies['@nrwl/nx-cloud'];
+        }
+        return json;
+    });
+    const nxJson = (0, project_configuration_1.readNxJson)(tree);
+    if (!nxJson)
+        return;
+    for (let opts of Object.values(nxJson.tasksRunnerOptions ?? {})) {
+        if (opts.runner === '@nrwl/nx-cloud') {
+            opts.runner = 'nx-cloud';
+        }
+    }
+    (0, project_configuration_1.updateNxJson)(tree, nxJson);
+    await (0, format_changed_files_with_prettier_if_available_1.formatChangedFilesWithPrettierIfAvailable)(tree);
+}

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

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

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 });
+exports.default = removeRunCommandsOutputPath;
+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);
+}
+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;