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

package/dist/src/migrations/update-22-7-0/add-polygraph-to-git-ignore.d.ts

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

package/dist/src/migrations/update-22-7-0/add-polygraph-to-git-ignore.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = addPolygraphToGitIgnore;
+const format_changed_files_1 = require("../../generators/internal-utils/format-changed-files");
+const ignore_1 = require("../../utils/ignore");
+async function addPolygraphToGitIgnore(tree) {
+    if (!tree.exists('.gitignore')) {
+        return;
+    }
+    // Lerna users that don't use nx.json may not expect .nx directory changes
+    if (tree.exists('lerna.json') && !tree.exists('nx.json')) {
+        return;
+    }
+    (0, ignore_1.addEntryToGitIgnore)(tree, '.gitignore', '.nx/polygraph');
+    await (0, format_changed_files_1.formatChangedFiles)(tree);
+}

package/dist/src/migrations/update-23-0-0/add-migrate-runs-to-git-ignore.d.ts

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

package/dist/src/migrations/update-23-0-0/add-migrate-runs-to-git-ignore.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = addMigrateRunsToGitIgnore;
+const format_changed_files_1 = require("../../generators/internal-utils/format-changed-files");
+const ignore_1 = require("../../utils/ignore");
+async function addMigrateRunsToGitIgnore(tree) {
+    if (!tree.exists('.gitignore')) {
+        return;
+    }
+    // Lerna users that don't use nx.json may not expect .nx directory changes
+    if (tree.exists('lerna.json') && !tree.exists('nx.json')) {
+        return;
+    }
+    (0, ignore_1.addEntryToGitIgnore)(tree, '.gitignore', '.nx/migrate-runs');
+    await (0, format_changed_files_1.formatChangedFiles)(tree);
+}

package/dist/src/migrations/update-23-0-0/consolidate-release-tag-config.d.ts

@@ -0,0 +1,9 @@
+import type { Tree } from '../../generators/tree';
+/**
+ * The deprecated releaseTag* flat properties were removed in Nx 23. Re-run the
+ * v22 consolidation for any workspaces that still have the legacy keys (e.g.,
+ * configs added manually after the v22 migration ran). Runs automatically as
+ * part of `nx migrate` and is also triggered by `nx repair` when the runtime
+ * detects legacy keys still present in `nx.json`.
+ */
+export default function (tree: Tree): Promise<void>;

package/dist/src/migrations/update-23-0-0/consolidate-release-tag-config.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+const tslib_1 = require("tslib");
+const consolidate_release_tag_config_1 = tslib_1.__importDefault(require("../update-22-0-0/consolidate-release-tag-config"));
+/**
+ * The deprecated releaseTag* flat properties were removed in Nx 23. Re-run the
+ * v22 consolidation for any workspaces that still have the legacy keys (e.g.,
+ * configs added manually after the v22 migration ran). Runs automatically as
+ * part of `nx migrate` and is also triggered by `nx repair` when the runtime
+ * detects legacy keys still present in `nx.json`.
+ */
+// TODO(v24): remove this migration (along with its registration in
+// migrations.json) and the LEGACY_RELEASE_TAG_PATTERN_PROPERTIES_DETECTED
+// runtime error path in packages/nx/src/command-line/release/config/config.ts.
+async function default_1(tree) {
+    return (0, consolidate_release_tag_config_1.default)(tree);
+}

package/dist/src/migrations/update-23-2-0/set-cache-on-executor-target-defaults.d.ts

@@ -0,0 +1,12 @@
+import { Tree } from '../../generators/tree';
+/**
+ * Target defaults resolve to a single key rather than merging, so an executor
+ * key hides the target name key entirely. Before Nx 23 a hidden `cache: true`
+ * still took effect, because cacheability was also derived from target *names*
+ * via `cacheableOperations`; Nx 23 removed that derivation and those targets
+ * silently stopped being cacheable.
+ *
+ * Write the intent into the executor key so it no longer depends on the
+ * deprecated fallback that restores the old behavior at run time.
+ */
+export default function update(tree: Tree): Promise<void>;

package/dist/src/migrations/update-23-2-0/set-cache-on-executor-target-defaults.js

@@ -0,0 +1,250 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = update;
+const executor_utils_1 = require("../../command-line/run/executor-utils");
+const format_changed_files_1 = require("../../generators/internal-utils/format-changed-files");
+const json_1 = require("../../generators/utils/json");
+const project_configuration_1 = require("../../generators/utils/project-configuration");
+const path_1 = require("../../utils/path");
+// TODO(v24): remove this migration alongside the runtime fallback it exists to
+// retire (`isLegacyCachedTarget` in `target-normalization.ts`), along with its
+// registration in `packages/nx/migrations.json`.
+/**
+ * Target defaults resolve to a single key rather than merging, so an executor
+ * key hides the target name key entirely. Before Nx 23 a hidden `cache: true`
+ * still took effect, because cacheability was also derived from target *names*
+ * via `cacheableOperations`; Nx 23 removed that derivation and those targets
+ * silently stopped being cacheable.
+ *
+ * Write the intent into the executor key so it no longer depends on the
+ * deprecated fallback that restores the old behavior at run time.
+ */
+async function update(tree) {
+    const nxJson = (0, project_configuration_1.readNxJson)(tree);
+    const targetDefaults = nxJson?.targetDefaults;
+    if (!targetDefaults) {
+        return;
+    }
+    const projects = (0, project_configuration_1.getProjects)(tree);
+    const projectsMap = {};
+    // `cache` on an executor key reaches every target that resolves through it,
+    // not just the one whose target name key enables caching. Collect them all
+    // per key so the decision below can be made for the key as a whole. The
+    // collection is a list rather than a map keyed by target name: two projects
+    // routinely declare the same target name through the same executor, and only
+    // one of them may be continuous.
+    const targetsByExecutorKey = new Map();
+    const collect = (targetName, target) => {
+        // `hasOwnProperty` rather than a lookup: an executor named `__proto__` or
+        // `constructor` resolves through the prototype chain to a truthy object, so
+        // a plain lookup would collect the target and stamp `Object.prototype`.
+        if (!target?.executor ||
+            !Object.prototype.hasOwnProperty.call(targetDefaults, target.executor)) {
+            return;
+        }
+        const targets = targetsByExecutorKey.get(target.executor) ?? [];
+        targets.push([targetName, target]);
+        targetsByExecutorKey.set(target.executor, targets);
+    };
+    for (const [projectName, project] of projects) {
+        projectsMap[projectName] = project;
+        for (const [targetName, target] of Object.entries(project.targets ?? {})) {
+            collect(targetName, target);
+        }
+        for (const [targetName, target] of Object.entries(packageJsonTargets(tree, project.root))) {
+            collect(targetName, target);
+        }
+    }
+    let changed = false;
+    for (const [key, targets] of targetsByExecutorKey) {
+        if (!canEnableCache(targetDefaults, key, targets, tree.root, projectsMap)) {
+            continue;
+        }
+        catchAllConfig(targetDefaults[key]).cache = true;
+        changed = true;
+    }
+    if (!changed) {
+        return;
+    }
+    (0, project_configuration_1.updateNxJson)(tree, nxJson);
+    await (0, format_changed_files_1.formatChangedFiles)(tree);
+}
+/**
+ * Whether `cache: true` can be written onto `key` without changing behavior for
+ * any target that resolves through it.
+ *
+ * The executor key outranks every target name key, so stamping it caches all of
+ * `targets` — including any that is continuous, which makes `nx.json` fail graph
+ * construction outright. The key is only safe when every target through it
+ * independently wants caching and none of them can be continuous. Anything else
+ * is left to the runtime fallback, which decides per target after normalization
+ * and can therefore see continuity this migration cannot.
+ */
+function canEnableCache(targetDefaults, key, targets, workspaceRoot, projectsMap) {
+    // Targets written with `command` are rewritten to `nx:run-commands` and
+    // `package.json` scripts to `nx:run-script` before key selection, so neither
+    // names the key it resolves through. Plugins also infer continuous targets
+    // (`watch-deps`, dev servers) into projects whose config never mentions them.
+    // The target list here can never be trusted to be complete for these keys.
+    if (key === 'nx:run-commands' || key === 'nx:run-script') {
+        return false;
+    }
+    // Already decided; never override the user's value. A filtered entry counts
+    // as decided because its value can't be evaluated without project context.
+    if (declaresAnyCache(targetDefaults[key])) {
+        return false;
+    }
+    // `continuous` is a valid field on a target default, and this key applies it
+    // to every target that resolves through it. Adding `cache` would make each of
+    // them both cacheable and continuous, which fails graph construction — so no
+    // target list can make this key safe.
+    if (declaresAnyContinuous(targetDefaults[key])) {
+        return false;
+    }
+    // Only an unfiltered entry can be amended. Appending a catch-all to an
+    // all-filtered key would make it match targets that previously fell through
+    // to the target name key, silently dropping that key's `dependsOn`/`inputs`.
+    if (!catchAllConfig(targetDefaults[key])) {
+        return false;
+    }
+    // Continuity declared by the executor's schema is resolved at graph
+    // construction for every target through this key, so one lookup covers them
+    // all. For what an executor that cannot be resolved here costs, see
+    // {@link executorDeclaresContinuous}.
+    if (executorDeclaresContinuous(key, workspaceRoot, projectsMap)) {
+        return false;
+    }
+    for (const [targetName, target] of targets) {
+        if (!declaresCacheTrue(targetDefaults[targetName])) {
+            return false;
+        }
+        if (target.continuous || isLongRunningTargetName(targetName)) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Whether the target name key declares `cache: true` on an entry that always
+ * applies. Mirrors `declaresCacheTrue` in `target-normalization.ts`: a filtered
+ * entry declaring `cache` makes the value unknowable without project context,
+ * so nothing is claimed. Among unfiltered entries the last wins.
+ */
+function declaresCacheTrue(value) {
+    if (!value) {
+        return false;
+    }
+    let declared;
+    for (const entry of configEntries(value)) {
+        if (entry.cache === undefined)
+            continue;
+        if (entry.filter)
+            return false;
+        declared = entry.cache;
+    }
+    return declared === true;
+}
+/**
+ * Whether any entry declares `cache`, filtered or not — i.e. whether the value
+ * is already decided and must be left alone. Deliberately broader than
+ * {@link declaresCacheTrue}: a filtered `cache` blocks here rather than being
+ * read past, so the two never disagree about a filtered entry.
+ */
+function declaresAnyCache(value) {
+    if (!value) {
+        return false;
+    }
+    return configEntries(value).some((entry) => entry.cache !== undefined);
+}
+/**
+ * Whether any entry declares `continuous: true`. Filtered entries count: which
+ * projects the filter matches is unknowable here, and the only case that
+ * matters is the one where it matches.
+ */
+function declaresAnyContinuous(value) {
+    if (!value) {
+        return false;
+    }
+    return configEntries(value).some((entry) => entry.continuous === true);
+}
+/**
+ * The config blocks of a `targetDefaults` value. Entries that are not config
+ * objects are dropped rather than inspected: `nx.json` is hand-edited, and a
+ * `null` or scalar entry would otherwise throw while reading `.cache` off it.
+ */
+function configEntries(value) {
+    const entries = Array.isArray(value) ? value : [value];
+    return entries.filter((entry) => !!entry && typeof entry === 'object');
+}
+/**
+ * The targets a project's `package.json` contributes to the graph.
+ *
+ * {@link getProjects} builds a root's configuration from its `project.json`
+ * alone whenever one exists, but the package.json plugin still creates the
+ * sibling `package.json`'s targets — it accepts any `package.json` that is
+ * either in the package manager workspaces or next to a `project.json`
+ * (`plugins/package-json/create-nodes.ts`). Those targets resolve through the
+ * same executor keys, so they belong in this decision.
+ *
+ * Targets derived from `scripts` are still not covered; they resolve through
+ * `nx:run-script`, which is never stamped for exactly that reason.
+ */
+function packageJsonTargets(tree, projectRoot) {
+    const packageJsonPath = (0, path_1.joinPathFragments)(projectRoot, 'package.json');
+    if (!tree.exists(packageJsonPath)) {
+        return {};
+    }
+    // A parse failure is left to throw: `readJson` names the offending file,
+    // which is the one thing a user can act on. Shapes that parse but aren't the
+    // one this reads contribute no targets rather than crashing the run.
+    const targets = (0, json_1.readJson)(tree, packageJsonPath)?.nx?.targets;
+    if (!targets || typeof targets !== 'object' || Array.isArray(targets)) {
+        return {};
+    }
+    return targets;
+}
+/**
+ * The unfiltered config block of a `targetDefaults` value, or undefined when the
+ * array form carries only filtered entries and when the value is not a config
+ * object at all. Never creates one — see {@link canEnableCache}.
+ */
+function catchAllConfig(value) {
+    // The filter check applies to both spellings: the object and single-element
+    // array forms of the same config have to reach the same verdict.
+    return configEntries(value).find((entry) => entry.filter === undefined);
+}
+/**
+ * Whether the executor's schema marks its targets continuous, resolved through
+ * the same `getExecutorInformation` call `normalizeTarget` makes at graph
+ * construction, so the two cannot drift on what continuous means.
+ *
+ * An executor that cannot be resolved is read as not continuous. That is the
+ * same answer `normalizeTarget` gives, but not the same trade: its lookup is
+ * repeated on every graph construction, so a failure there corrects itself,
+ * whereas this one decides a permanent edit to `nx.json`. An executor that is
+ * unresolvable while the migration runs and resolvable afterwards therefore
+ * keeps its stamped `cache` while the runtime starts marking its targets
+ * continuous — which `normalizeTargets` rejects with a `WorkspaceValidityError`,
+ * failing graph construction until `nx.json` is edited by hand.
+ */
+function executorDeclaresContinuous(executor, workspaceRoot, projectsMap) {
+    try {
+        const [nodeModule, name] = (0, executor_utils_1.parseExecutor)(executor);
+        const { schema } = (0, executor_utils_1.getExecutorInformation)(nodeModule, name, workspaceRoot, projectsMap);
+        return !!schema.continuous;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Target names the pre-23 `longRunningTask` guard excluded from caching.
+ * Mirrors `isLongRunningTarget` in `target-normalization.ts`.
+ */
+function isLongRunningTargetName(targetName) {
+    return (targetName.endsWith(':watch') ||
+        targetName.endsWith('-watch') ||
+        targetName === 'serve' ||
+        targetName === 'dev' ||
+        targetName === 'start');
+}

package/dist/src/migrations/update-23-2-0/set-cache-on-executor-target-defaults.md

@@ -0,0 +1,50 @@
+#### Set cache on executor-based target defaults
+
+Maintains compatibility with how cacheability was resolved before Nx 23.
+
+Target defaults resolve to a single key rather than merging them. When a target matches both a target name key and an executor key, the executor key is the one that applies, and the target name key is not read at all. Earlier versions of Nx also derived cacheability from target names, so `"cache": true` on the target name key still took effect even when an executor key applied. Nx 23 reads cacheability from the resolved target only.
+
+This migration copies `cache` onto each executor key that applies to a target whose target name key enables it, so those targets remain cacheable.
+
+An executor key applies to every target that resolves through it, so the migration updates a key only when it can establish that caching is right for all of them. It leaves the key unchanged when the key already declares `cache`, when it declares `continuous: true`, when every entry on the key is filtered so none of them always applies, when a target through it is continuous or is a long-running target such as `serve`, `dev`, or `start`, when the executor's own schema marks its targets continuous, or when a target through it has no target name key enabling `cache`. It never updates the `nx:run-commands` or `nx:run-script` keys, because targets written with `command` and targets derived from `package.json` scripts resolve through those keys without naming them.
+
+Where the migration makes no change, Nx still decides at run time, per target rather than per key: a target whose target name key enables `cache`, and whose resolved configuration still leaves `cache` undefined, gets it back and is reported as a deprecated fallback. Because that test is applied to the resolved target rather than to the key, it also covers the cases where a key looks decided but is not for this project — an executor key whose entries are all filtered, or whose only `cache` declaration is filtered out here. It equally covers the targets left behind because a sibling target through the same key does not opt in, and the targets reaching the `nx:run-commands` and `nx:run-script` keys. Three cases get no fallback and no warning. A continuous or long-running target, because caching it is invalid. A target whose resolved configuration already sets `cache`. And a target whose target name key was discarded as incompatible, because its entry named an executor the target does not use — before Nx 23 that target was cacheable, since cacheability was matched on target name alone and the entry's `executor` was never read. Restoring it here would mean setting `cache` with no executor key to point the user at and no migration able to retire the behavior, so it is deliberately left alone. Set `cache` on those targets directly.
+
+Targets are read from each project's `project.json` and from the `nx.targets` block of its `package.json`. Targets inferred by a plugin, and targets derived from `package.json` scripts, are not visible to the migration — the latter is why the `nx:run-script` key is never updated. A key that looks safe here may still serve an inferred target. Set `cache` on the executor key by hand only after checking that no target reaching it is continuous; Nx rejects a target that is both cacheable and continuous. Nx names both keys in a run-time warning. That warning is emitted during project graph construction, so while the daemon is running it goes to `.nx/workspace-data/d/daemon.log` rather than the terminal; CI runs, where the daemon is disabled, print it normally.
+
+#### Sample code changes
+
+Given a project with a `build` target that uses the `@nx/angular:webpack-browser` executor:
+
+##### Before
+
+```json title="nx.json"
+{
+  "targetDefaults": {
+    "build": {
+      "cache": true,
+      "dependsOn": ["^build"]
+    },
+    "@nx/angular:webpack-browser": {
+      "inputs": ["production", "^production"]
+    }
+  }
+}
+```
+
+##### After
+
+```json title="nx.json"
+{
+  "targetDefaults": {
+    "build": {
+      "cache": true,
+      "dependsOn": ["^build"]
+    },
+    "@nx/angular:webpack-browser": {
+      "inputs": ["production", "^production"],
+      "cache": true
+    }
+  }
+}
+```

package/dist/src/migrations/utils/target-defaults.d.ts

@@ -0,0 +1,28 @@
+import type { TargetDefaultValue } from '../../config/nx-json';
+import type { TargetConfiguration } from '../../config/workspace-json-project-json';
+/**
+ * The config blocks of a single `targetDefaults` value, regardless of whether
+ * it is stored as the plain object form (`{ cache: true }`) or the filtered
+ * array form (`[{ filter, ...config }, ...]`).
+ *
+ * Migrations in `packages/nx` run as part of `nx repair` against arbitrary user
+ * workspaces and can't assume migration order, so they must handle both shapes.
+ * Each returned block is the live entry — mutating it edits `nx.json` in place,
+ * and any `filter` on an array entry is left untouched.
+ */
+export declare function targetDefaultConfigs(value: TargetDefaultValue | undefined): TargetConfiguration[];
+/**
+ * The unfiltered "catch-all" config block of a `targetDefaults` value — the
+ * workspace-wide baseline a migration should edit when it wants to apply a
+ * default to every variant of a target (not a filtered subset). Creates the
+ * block when absent and returns the value to store back, normalizing across the
+ * object and array forms:
+ *
+ * - No value yet → a fresh object-form block.
+ * - Object form → that object is the catch-all.
+ * - Array form → the entry without a `filter`, appended if none exists.
+ */
+export declare function ensureCatchAllTargetDefaultConfig(value: TargetDefaultValue | undefined): {
+    config: TargetConfiguration;
+    value: TargetDefaultValue;
+};

package/dist/src/migrations/utils/target-defaults.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.targetDefaultConfigs = targetDefaultConfigs;
+exports.ensureCatchAllTargetDefaultConfig = ensureCatchAllTargetDefaultConfig;
+/**
+ * The config blocks of a single `targetDefaults` value, regardless of whether
+ * it is stored as the plain object form (`{ cache: true }`) or the filtered
+ * array form (`[{ filter, ...config }, ...]`).
+ *
+ * Migrations in `packages/nx` run as part of `nx repair` against arbitrary user
+ * workspaces and can't assume migration order, so they must handle both shapes.
+ * Each returned block is the live entry — mutating it edits `nx.json` in place,
+ * and any `filter` on an array entry is left untouched.
+ */
+function targetDefaultConfigs(value) {
+    if (value === undefined) {
+        return [];
+    }
+    return (Array.isArray(value) ? value : [value]);
+}
+/**
+ * The unfiltered "catch-all" config block of a `targetDefaults` value — the
+ * workspace-wide baseline a migration should edit when it wants to apply a
+ * default to every variant of a target (not a filtered subset). Creates the
+ * block when absent and returns the value to store back, normalizing across the
+ * object and array forms:
+ *
+ * - No value yet → a fresh object-form block.
+ * - Object form → that object is the catch-all.
+ * - Array form → the entry without a `filter`, appended if none exists.
+ */
+function ensureCatchAllTargetDefaultConfig(value) {
+    if (value === undefined) {
+        const config = {};
+        return { config, value: config };
+    }
+    if (Array.isArray(value)) {
+        let catchAll = value.find((entry) => entry.filter === undefined);
+        if (!catchAll) {
+            catchAll = {};
+            value.push(catchAll);
+        }
+        return { config: catchAll, value };
+    }
+    return { config: value, value };
+}

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

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

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

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertSupportedPlatform = assertSupportedPlatform;
+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/troubleshooting/troubleshoot-nx-install-issues');
+        output_1.output.error({
+            title,
+            bodyLines,
+        });
+        process.exit(1);
+    }
+}

package/dist/src/native/browser.js

@@ -0,0 +1 @@
+export * from '@nx/nx-wasm32-wasi'