@nx/js 23.2.0-beta.1 → 23.2.0-beta.11

package/dist/src/utils/pnpm-deploy-output-cache-inputs.d.ts

@@ -0,0 +1,29 @@
+import type { TargetDefaults } from '@nx/devkit';
+import { type MatchedTargetRef } from './target-defaults-matching';
+/**
+ * Adds the missing `PNPM_INSTALL_SETTINGS_INPUTS` to the layer whose `inputs`
+ * array the runtime actually uses for this target: the target's own `inputs`
+ * when it declares them (its array replaces the defaults' rather than merging
+ * with it), otherwise the matching `targetDefaults` entry supplying the array
+ * it inherits, and otherwise the target itself with nx's own default spelled
+ * out first, so nothing that was hashed stops being hashed. Sources the
+ * effective inputs already hash, including via a whole-file root package.json
+ * fileset or a `json` input covering the settings fields, are left alone; no
+ * `'...'` is ever authored. Returns which layer was mutated, or null when
+ * nothing was missing.
+ */
+export declare function addPnpmDeployOutputCacheInputs(ref: MatchedTargetRef, targetDefaults: TargetDefaults | undefined, executor: string): 'target' | 'defaults' | null;
+/**
+ * Variant for a plugin-inferred target, whose generated `inputs` already carry
+ * the settings sources (the runtime probe only while the root manifest has no
+ * valid pnpm pin): a repair is only needed when an overlay (a project-level
+ * target entry, exact or glob key, or a matching `targetDefaults` entry)
+ * supplies a replacing `inputs` array that discards them. The repair appends
+ * the full set, probe included, because it runs once and the pin can be
+ * removed later. The inferred layer is modeled as an array of exactly the
+ * settings inputs: enough for the missing check, and it makes an overlay-less
+ * target come back as nothing missing, so the fallback that would narrow the
+ * plugin's richer array to `DEFAULT_INPUTS` can never be reached: with no
+ * replacing supplier there is nothing to mutate.
+ */
+export declare function addPnpmDeployOutputCacheInputsToInferredTargetOverlay(ref: MatchedTargetRef, targetDefaults: TargetDefaults | undefined): 'target' | 'defaults' | null;

package/dist/src/utils/pnpm-deploy-output-cache-inputs.js

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addPnpmDeployOutputCacheInputs = addPnpmDeployOutputCacheInputs;
+exports.addPnpmDeployOutputCacheInputsToInferredTargetOverlay = addPnpmDeployOutputCacheInputsToInferredTargetOverlay;
+const internal_1 = require("@nx/devkit/internal");
+const pnpm_install_settings_inputs_1 = require("./pnpm-install-settings-inputs");
+const target_defaults_matching_1 = require("./target-defaults-matching");
+const ROOT_MANIFEST = '{workspaceRoot}/package.json';
+const MANIFEST_SETTINGS_FIELDS = new Set(pnpm_install_settings_inputs_1.PNPM_INSTALL_SETTINGS_INPUTS.filter((input) => typeof input !== 'string' && 'json' in input).flatMap((input) => input.fields ?? []));
+/**
+ * Adds the missing `PNPM_INSTALL_SETTINGS_INPUTS` to the layer whose `inputs`
+ * array the runtime actually uses for this target: the target's own `inputs`
+ * when it declares them (its array replaces the defaults' rather than merging
+ * with it), otherwise the matching `targetDefaults` entry supplying the array
+ * it inherits, and otherwise the target itself with nx's own default spelled
+ * out first, so nothing that was hashed stops being hashed. Sources the
+ * effective inputs already hash, including via a whole-file root package.json
+ * fileset or a `json` input covering the settings fields, are left alone; no
+ * `'...'` is ever authored. Returns which layer was mutated, or null when
+ * nothing was missing.
+ */
+function addPnpmDeployOutputCacheInputs(ref, targetDefaults, executor) {
+    const selectedKey = targetDefaults
+        ? (0, target_defaults_matching_1.selectDefaultsKey)(ref, targetDefaults, executor)
+        : null;
+    const entries = (0, target_defaults_matching_1.compatibleDefaultsEntries)(ref, selectedKey, targetDefaults);
+    const defaults = entries.length
+        ? (0, internal_1.readTargetDefaultsForTarget)(ref.targetName, { [selectedKey]: entries }, ref.matcherExecutor, {
+            projectName: ref.projectName,
+            projectNode: ref.projectNode,
+            sourcePlugin: ref.sourcePlugin,
+        })
+        : null;
+    const effective = (0, internal_1.mergeTargetConfigurations)(ref.target, defaults ?? {});
+    const missing = missingSettingsInputs(effective.inputs);
+    if (missing.length === 0) {
+        return null;
+    }
+    if (ref.target.inputs !== undefined) {
+        appendInputs(ref.target, missing);
+        return 'target';
+    }
+    const supplier = (0, target_defaults_matching_1.lastMatchingInputsSupplier)(ref, selectedKey, entries);
+    if (supplier) {
+        appendInputs(supplier, missing);
+        return 'defaults';
+    }
+    appendInputs(ref.target, missing);
+    return 'target';
+}
+/**
+ * Variant for a plugin-inferred target, whose generated `inputs` already carry
+ * the settings sources (the runtime probe only while the root manifest has no
+ * valid pnpm pin): a repair is only needed when an overlay (a project-level
+ * target entry, exact or glob key, or a matching `targetDefaults` entry)
+ * supplies a replacing `inputs` array that discards them. The repair appends
+ * the full set, probe included, because it runs once and the pin can be
+ * removed later. The inferred layer is modeled as an array of exactly the
+ * settings inputs: enough for the missing check, and it makes an overlay-less
+ * target come back as nothing missing, so the fallback that would narrow the
+ * plugin's richer array to `DEFAULT_INPUTS` can never be reached: with no
+ * replacing supplier there is nothing to mutate.
+ */
+function addPnpmDeployOutputCacheInputsToInferredTargetOverlay(ref, targetDefaults) {
+    const selectedKey = targetDefaults
+        ? (0, target_defaults_matching_1.selectDefaultsKey)(ref, targetDefaults, ref.matcherExecutor)
+        : null;
+    const entries = (0, target_defaults_matching_1.compatibleDefaultsEntries)(ref, selectedKey, targetDefaults);
+    const defaults = entries.length
+        ? (0, internal_1.readTargetDefaultsForTarget)(ref.targetName, { [selectedKey]: entries }, ref.matcherExecutor, {
+            projectName: ref.projectName,
+            projectNode: ref.projectNode,
+            sourcePlugin: ref.sourcePlugin,
+        })
+        : null;
+    const inferredLayer = {
+        inputs: [...pnpm_install_settings_inputs_1.PNPM_INSTALL_SETTINGS_INPUTS],
+    };
+    const effective = (0, internal_1.mergeTargetConfigurations)(ref.target, (0, internal_1.mergeTargetConfigurations)(defaults ?? {}, inferredLayer));
+    const missing = missingSettingsInputs(effective.inputs);
+    if (missing.length === 0) {
+        return null;
+    }
+    if (ref.target.inputs !== undefined) {
+        appendInputs(ref.target, missing);
+        return 'target';
+    }
+    const supplier = (0, target_defaults_matching_1.lastMatchingInputsSupplier)(ref, selectedKey, entries);
+    if (supplier) {
+        appendInputs(supplier, missing);
+        return 'defaults';
+    }
+    return null;
+}
+/**
+ * The settings sources the effective inputs do not hash yet. The manifest
+ * counts as covered by a whole-file fileset no negative pattern can cancel,
+ * or by an existing `json` input that hashes all the settings fields (`json`
+ * inputs are immune to fileset negations); the workspace yaml by its fileset
+ * (a negative pattern cancelling that fileset has no input-level counter, so
+ * it is left to the author who wrote it); the runtime probe by an identical
+ * `runtime` entry.
+ */
+function missingSettingsInputs(inputs) {
+    const filesets = (0, target_defaults_matching_1.namedFilesets)(inputs);
+    const missing = [];
+    for (const input of pnpm_install_settings_inputs_1.PNPM_INSTALL_SETTINGS_INPUTS) {
+        if (typeof input === 'string') {
+            if (!filesets.has(input)) {
+                missing.push(input);
+            }
+        }
+        else if ('runtime' in input) {
+            if (!(inputs ?? []).some((existing) => typeof existing === 'object' &&
+                existing !== null &&
+                'runtime' in existing &&
+                existing.runtime === input.runtime)) {
+                missing.push(input);
+            }
+        }
+        else if (!(filesets.has(ROOT_MANIFEST) && !negationMayCancel(inputs)) &&
+            !(inputs ?? []).some((existing) => typeof existing === 'object' &&
+                existing !== null &&
+                'json' in existing &&
+                existing.json === ROOT_MANIFEST &&
+                [...MANIFEST_SETTINGS_FIELDS].every((field) => jsonInputCoversField(existing, field)))) {
+            missing.push(input);
+        }
+    }
+    return missing;
+}
+/**
+ * Whether a negative fileset entry could remove the source from the hash. Any
+ * workspace-root-scoped negation counts, in the string or `{ fileset }` form:
+ * nx's pattern syntax (globs, extglobs) is not re-evaluated here, and an
+ * extra input for a source the negation does not actually touch is harmless.
+ * Project-relative negations never match a workspace-root file.
+ */
+function negationMayCancel(inputs) {
+    return (inputs ?? []).some((existing) => {
+        const pattern = typeof existing === 'string'
+            ? existing
+            : typeof existing === 'object' &&
+                existing !== null &&
+                'fileset' in existing
+                ? existing.fileset
+                : undefined;
+        return (typeof pattern === 'string' &&
+            pattern.startsWith('!') &&
+            pattern.includes('{workspaceRoot}'));
+    });
+}
+/**
+ * Whether an existing `json` input hashes `field`: selected by the allowlist
+ * (an entry covers its whole subtree) and not touched by the denylist, which
+ * the hasher applies after selection. A denylist entry below the field only
+ * removes part of its subtree, but that part is then unhashed, so it
+ * disqualifies coverage too.
+ */
+function jsonInputCoversField(input, field) {
+    const selected = input.fields === undefined ||
+        input.fields.some((path) => path === field || field.startsWith(`${path}.`));
+    if (!selected) {
+        return false;
+    }
+    return !(input.excludeFields ?? []).some((path) => path === field ||
+        field.startsWith(`${path}.`) ||
+        path.startsWith(`${field}.`));
+}
+/**
+ * Appends to an array that already exists, or writes nx's default as the base
+ * when no layer declares one, so the configuration is never narrowed to the
+ * settings sources alone.
+ */
+function appendInputs(config, missing) {
+    config.inputs = [...(config.inputs ?? target_defaults_matching_1.DEFAULT_INPUTS), ...missing];
+}

package/dist/src/utils/pnpm-install-settings-inputs.d.ts

@@ -0,0 +1,45 @@
+import { type PackageManager } from '@nx/devkit';
+import { type JsonInput } from '@nx/devkit/internal';
+/**
+ * Task inputs covering the sources of the pnpm install settings a pruned
+ * deploy output carries (build-script approvals, `supportedArchitectures`,
+ * `patchedDependencies`). Nothing else in a build target's default hash moves
+ * when an approval is revoked, so a target that emits the deploy output must
+ * hash these or a cached run replays an output that still grants it. The
+ * manifest is narrowed to the fields the output is built from so dependency
+ * bumps in the root package.json do not invalidate every build.
+ *
+ * The pnpm major selects which emitted file carries the settings (pnpm 11+
+ * reads them from pnpm-workspace.yaml, pnpm <=10 from the emitted
+ * package.json). The manifest's `packageManager` field pins it when it
+ * parses to a pnpm version; the runtime probe covers the ambient binary that
+ * decides it otherwise, printing only the major so pnpm patch and minor
+ * releases do not move the hash, and a sentinel when the binary is missing
+ * (the hasher records the probe's output without checking its exit status,
+ * so a missing binary does not fail the hash). The full set keeps the probe
+ * even under a valid pin: the generator and the migrations write inputs
+ * once, and the pin can be removed later. Plugins re-infer on every graph
+ * build, so they use {@link pnpmInstallSettingsInputsForInferredTarget} to
+ * add the probe only while no valid pin exists.
+ *
+ * The contents of vendored non-workspace local-path dependencies also ship in
+ * the deploy output but are not covered: their set is derived from the
+ * lockfile at build time, so no static input list stays correct as
+ * dependencies change. Covering them needs content hashing at the graph level
+ * (the pnpm parser's directory/link external nodes hash only name and path).
+ */
+export declare const PNPM_MAJOR_RUNTIME_INPUT: {
+    runtime: string;
+};
+export declare const PNPM_INSTALL_SETTINGS_INPUTS: (string | JsonInput | {
+    runtime: string;
+})[];
+export declare function pnpmInstallSettingsInputsForInferredTarget(includePnpmMajorRuntimeInput: boolean): (string | JsonInput | {
+    runtime: string;
+})[];
+/**
+ * Whether an inferred build target needs the runtime probe: the workspace uses
+ * pnpm and the root `packageManager` field does not pin a pnpm version. A
+ * missing or unreadable root manifest cannot pin one, so it counts as no pin.
+ */
+export declare function shouldIncludePnpmMajorRuntimeInput(packageManager: PackageManager, workspaceRoot: string): boolean;

package/dist/src/utils/pnpm-install-settings-inputs.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PNPM_INSTALL_SETTINGS_INPUTS = exports.PNPM_MAJOR_RUNTIME_INPUT = void 0;
+exports.pnpmInstallSettingsInputsForInferredTarget = pnpmInstallSettingsInputsForInferredTarget;
+exports.shouldIncludePnpmMajorRuntimeInput = shouldIncludePnpmMajorRuntimeInput;
+const devkit_1 = require("@nx/devkit");
+const internal_1 = require("@nx/devkit/internal");
+const path_1 = require("path");
+/**
+ * Task inputs covering the sources of the pnpm install settings a pruned
+ * deploy output carries (build-script approvals, `supportedArchitectures`,
+ * `patchedDependencies`). Nothing else in a build target's default hash moves
+ * when an approval is revoked, so a target that emits the deploy output must
+ * hash these or a cached run replays an output that still grants it. The
+ * manifest is narrowed to the fields the output is built from so dependency
+ * bumps in the root package.json do not invalidate every build.
+ *
+ * The pnpm major selects which emitted file carries the settings (pnpm 11+
+ * reads them from pnpm-workspace.yaml, pnpm <=10 from the emitted
+ * package.json). The manifest's `packageManager` field pins it when it
+ * parses to a pnpm version; the runtime probe covers the ambient binary that
+ * decides it otherwise, printing only the major so pnpm patch and minor
+ * releases do not move the hash, and a sentinel when the binary is missing
+ * (the hasher records the probe's output without checking its exit status,
+ * so a missing binary does not fail the hash). The full set keeps the probe
+ * even under a valid pin: the generator and the migrations write inputs
+ * once, and the pin can be removed later. Plugins re-infer on every graph
+ * build, so they use {@link pnpmInstallSettingsInputsForInferredTarget} to
+ * add the probe only while no valid pin exists.
+ *
+ * The contents of vendored non-workspace local-path dependencies also ship in
+ * the deploy output but are not covered: their set is derived from the
+ * lockfile at build time, so no static input list stays correct as
+ * dependencies change. Covering them needs content hashing at the graph level
+ * (the pnpm parser's directory/link external nodes hash only name and path).
+ */
+exports.PNPM_MAJOR_RUNTIME_INPUT = {
+    runtime: `node -e "try{console.log('pnpm major '+require('child_process').execSync('pnpm --version',{stdio:['ignore','pipe','ignore']}).toString().trim().split('.')[0])}catch{console.log('pnpm major unavailable')}"`,
+};
+const PNPM_INSTALL_SETTINGS_FILE_INPUTS = [
+    '{workspaceRoot}/pnpm-workspace.yaml',
+    {
+        json: '{workspaceRoot}/package.json',
+        fields: [
+            'packageManager',
+            'pnpm.onlyBuiltDependencies',
+            'pnpm.neverBuiltDependencies',
+            'pnpm.allowBuilds',
+            'pnpm.supportedArchitectures',
+            'pnpm.patchedDependencies',
+        ],
+    },
+];
+exports.PNPM_INSTALL_SETTINGS_INPUTS = [...PNPM_INSTALL_SETTINGS_FILE_INPUTS, exports.PNPM_MAJOR_RUNTIME_INPUT];
+function pnpmInstallSettingsInputsForInferredTarget(includePnpmMajorRuntimeInput) {
+    return includePnpmMajorRuntimeInput
+        ? [...PNPM_INSTALL_SETTINGS_FILE_INPUTS, exports.PNPM_MAJOR_RUNTIME_INPUT]
+        : [...PNPM_INSTALL_SETTINGS_FILE_INPUTS];
+}
+/**
+ * Whether an inferred build target needs the runtime probe: the workspace uses
+ * pnpm and the root `packageManager` field does not pin a pnpm version. A
+ * missing or unreadable root manifest cannot pin one, so it counts as no pin.
+ */
+function shouldIncludePnpmMajorRuntimeInput(packageManager, workspaceRoot) {
+    if (packageManager !== 'pnpm') {
+        return false;
+    }
+    let field;
+    try {
+        field = (0, devkit_1.readJsonFile)((0, path_1.join)(workspaceRoot, 'package.json'))?.packageManager;
+    }
+    catch {
+        field = undefined;
+    }
+    return ((0, internal_1.parseVersionFromPackageManagerField)('pnpm', typeof field === 'string' ? field : undefined) === null);
+}

package/dist/src/utils/prettier.js

@@ -4,6 +4,8 @@ exports.resolveUserExistingPrettierConfig = resolveUserExistingPrettierConfig;
 exports.generatePrettierSetup = generatePrettierSetup;
 exports.resolvePrettierConfigPath = resolvePrettierConfigPath;
 const devkit_1 = require("@nx/devkit");
+const internal_1 = require("@nx/devkit/internal");
+const nx_formatter_internals_1 = require("./nx-formatter-internals");
 const versions_1 = require("./versions");
 // Prettier v3 (ESM) exposes its API as named exports; v2 (CJS) exposes it under
 // `.default` when loaded via `import()`. Return whichever carries the API, or
@@ -44,22 +46,11 @@ async function resolveUserExistingPrettierConfig() {
     }
 }
 function generatePrettierSetup(tree, options) {
-    // https://prettier.io/docs/en/configuration.html
-    const prettierrcNameOptions = [
-        '.prettierrc',
-        '.prettierrc.json',
-        '.prettierrc.yml',
-        '.prettierrc.yaml',
-        '.prettierrc.json5',
-        '.prettierrc.js',
-        '.prettierrc.cjs',
-        '.prettierrc.mjs',
-        '.prettierrc.toml',
-        'prettier.config.js',
-        'prettier.config.cjs',
-        'prettier.config.mjs',
-    ];
-    if (prettierrcNameOptions.every((name) => !tree.exists(name))) {
+    (0, nx_formatter_internals_1.assertNxSupportsFormatters)();
+    // Imported rather than copied: detection and setup have to agree on this
+    // list, or a workspace whose config format is missing from one side gets a
+    // second, redundant `.prettierrc` written beside the one it already has.
+    if (internal_1.prettierConfigFiles.every((name) => !tree.exists(name))) {
         (0, devkit_1.writeJson)(tree, '.prettierrc', { singleQuote: true });
     }
     if (!tree.exists('.prettierignore')) {
@@ -68,6 +59,7 @@ function generatePrettierSetup(tree, options) {
         /coverage
         /.nx/cache
         /.nx/workspace-data
+        ${(0, internal_1.getLockFileName)((0, devkit_1.detectPackageManager)(tree.root))}
       `);
     }
     if (tree.exists('.vscode/extensions.json')) {
@@ -85,6 +77,7 @@ function generatePrettierSetup(tree, options) {
         : (0, devkit_1.addDependenciesToPackageJson)(tree, {}, { prettier: versions_1.prettierVersion });
 }
 async function resolvePrettierConfigPath(tree) {
+    (0, nx_formatter_internals_1.assertNxSupportsFormatters)();
     const prettier = await importPrettier();
     if (!prettier) {
         return null;
@@ -96,23 +89,11 @@ async function resolvePrettierConfigPath(tree) {
     if (!tree) {
         return null;
     }
-    // if we haven't find a config file in the file system, we try to find it in the virtual tree
-    // https://prettier.io/docs/en/configuration.html
-    const prettierrcNameOptions = [
-        '.prettierrc',
-        '.prettierrc.json',
-        '.prettierrc.yml',
-        '.prettierrc.yaml',
-        '.prettierrc.json5',
-        '.prettierrc.js',
-        '.prettierrc.cjs',
-        '.prettierrc.mjs',
-        '.prettierrc.toml',
-        'prettier.config.js',
-        'prettier.config.cjs',
-        'prettier.config.mjs',
-    ];
-    const filePath = prettierrcNameOptions.find((file) => tree.exists(file));
+    // Same shared list as the setup above, so a config this can't see is one the
+    // setup would overwrite. The copy this replaced was missing the `.ts`,
+    // `.mts` and `.cts` forms.
+    // https://prettier.io/docs/configuration
+    const filePath = internal_1.prettierConfigFiles.find((file) => tree.exists(file));
     if (filePath) {
         return filePath;
     }

package/dist/src/utils/schema.d.ts

@@ -47,8 +47,7 @@ export interface SwcCliOptions {
   stripLeadingPaths: boolean;
 }
 
-export interface NormalizedSwcExecutorOptions
-  extends NormalizedExecutorOptions {
+export interface NormalizedSwcExecutorOptions extends NormalizedExecutorOptions {
   originalProjectRoot: string;
   swcExclude: string[];
   skipTypeCheck: boolean;

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

@@ -0,0 +1,57 @@
+import type { ProjectGraphProjectNode, TargetConfiguration, TargetDefaultArrayEntry, TargetDefaults } from '@nx/devkit';
+export declare const DEFAULT_INPUTS: string[];
+/** Everything the runtime's `targetDefaults` matcher needs to resolve a target. */
+export interface DefaultsMatchContext {
+    targetName: string;
+    projectName: string;
+    projectNode: ProjectGraphProjectNode;
+    matcherExecutor: string | undefined;
+    sourcePlugin?: string;
+}
+export interface MatchedTargetRef extends DefaultsMatchContext {
+    target: TargetConfiguration;
+}
+/**
+ * A matched target with the `targetDefaults` key the runtime would resolve for
+ * it, carried together so the two cannot fall out of step.
+ */
+export interface KeyedTargetRef {
+    ref: MatchedTargetRef;
+    selectedKey: string | null;
+}
+/**
+ * The `targetDefaults` entries under the selected key that survive nx's own
+ * per-entry compatibility guard. Graph construction selects the key, then drops
+ * each entry whose identity is incompatible with the target's *original* one and
+ * keeps the compatible siblings (`createTargetDefaultsResults` in nx's
+ * target-defaults). Reading the key unfiltered instead would let a
+ * foreign-executor entry contribute outputs the target never gets.
+ */
+export declare function compatibleDefaultsEntries(ref: MatchedTargetRef, selectedKey: string | null, targetDefaults: TargetDefaults | undefined): TargetDefaultArrayEntry[];
+/**
+ * The last entry under the selected key that both matches the target (the
+ * entry's own filter included) and declares `inputs`: the runtime merge makes
+ * that entry's array the one the target inherits. A later entry that declares
+ * `inputs` behind a filter not matching this target supplies some other
+ * target's array, so it cannot be the layer to mutate.
+ */
+export declare function lastMatchingInputsSupplier(ref: MatchedTargetRef, selectedKey: string, entries: TargetDefaultArrayEntry[]): TargetDefaultArrayEntry | undefined;
+/** The plain filesets an inputs array names, for a containment check. */
+export declare function namedFilesets(inputs: TargetConfiguration['inputs']): ReadonlySet<string>;
+/**
+ * The executor an executor-less target ends up with after its selected
+ * defaults key applies. Each matching entry's identity is resolved like the
+ * runtime does at merge time: a `command` payload means nx:run-commands, and
+ * a later entry's identity replaces an earlier, incompatible one (the reader's
+ * merged view keeps the first executor instead, so it cannot be used here).
+ */
+export declare function resolveDefaultsExecutor(targetName: string, projectName: string, projectNode: ProjectGraphProjectNode, targetDefaults: TargetDefaults | undefined, executorKeyCandidate?: string): string | undefined;
+/**
+ * The `targetDefaults` key nx's runtime would select for this target: keys
+ * are tried as the executor key, the exact-name key, then glob keys longest
+ * first, and the first whose entries produce a match wins; the rest are
+ * shadowed. Resolution per key goes through nx's own reader. Non-matching
+ * keys never resolve, so sorting all remaining keys by length stands in for
+ * the runtime's glob-only ordering.
+ */
+export declare function selectDefaultsKey(ref: DefaultsMatchContext, targetDefaults: TargetDefaults, executorKeyCandidate?: string): string | null;

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

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_INPUTS = void 0;
+exports.compatibleDefaultsEntries = compatibleDefaultsEntries;
+exports.lastMatchingInputsSupplier = lastMatchingInputsSupplier;
+exports.namedFilesets = namedFilesets;
+exports.resolveDefaultsExecutor = resolveDefaultsExecutor;
+exports.selectDefaultsKey = selectDefaultsKey;
+const internal_1 = require("@nx/devkit/internal");
+// what nx hashes for a target that declares no `inputs`
+exports.DEFAULT_INPUTS = ['default', '^default'];
+/**
+ * The `targetDefaults` entries under the selected key that survive nx's own
+ * per-entry compatibility guard. Graph construction selects the key, then drops
+ * each entry whose identity is incompatible with the target's *original* one and
+ * keeps the compatible siblings (`createTargetDefaultsResults` in nx's
+ * target-defaults). Reading the key unfiltered instead would let a
+ * foreign-executor entry contribute outputs the target never gets.
+ */
+function compatibleDefaultsEntries(ref, selectedKey, targetDefaults) {
+    if (!targetDefaults || selectedKey === null) {
+        return [];
+    }
+    const value = targetDefaults[selectedKey];
+    return (Array.isArray(value) ? value : [value]).filter((entry) => 
+    // `isCompatibleTarget` against the target's own executor. Falsy rather than
+    // nullish, matching `resolveCommandSyntacticSugar` and `isCompatibleTarget`,
+    // which read an empty string as no identity at all; an executor-less target
+    // has no identity to clash with, so every entry survives, as it does there.
+    !ref.matcherExecutor
+        ? true
+        : !entry.command &&
+            (!entry.executor || entry.executor === ref.matcherExecutor));
+}
+/**
+ * The last entry under the selected key that both matches the target (the
+ * entry's own filter included) and declares `inputs`: the runtime merge makes
+ * that entry's array the one the target inherits. A later entry that declares
+ * `inputs` behind a filter not matching this target supplies some other
+ * target's array, so it cannot be the layer to mutate.
+ */
+function lastMatchingInputsSupplier(ref, selectedKey, entries) {
+    return [...entries].reverse().find((entry) => entry.inputs !== undefined &&
+        (0, internal_1.readTargetDefaultsForTarget)(ref.targetName, { [selectedKey]: [entry] }, ref.matcherExecutor, {
+            projectName: ref.projectName,
+            projectNode: ref.projectNode,
+            sourcePlugin: ref.sourcePlugin,
+        }) !== null);
+}
+/** The plain filesets an inputs array names, for a containment check. */
+function namedFilesets(inputs) {
+    return new Set((inputs ?? []).filter((input) => typeof input === 'string'));
+}
+/**
+ * The executor an executor-less target ends up with after its selected
+ * defaults key applies. Each matching entry's identity is resolved like the
+ * runtime does at merge time: a `command` payload means nx:run-commands, and
+ * a later entry's identity replaces an earlier, incompatible one (the reader's
+ * merged view keeps the first executor instead, so it cannot be used here).
+ */
+function resolveDefaultsExecutor(targetName, projectName, projectNode, targetDefaults, executorKeyCandidate) {
+    if (!targetDefaults) {
+        return undefined;
+    }
+    const ref = {
+        targetName,
+        projectName,
+        projectNode,
+        matcherExecutor: undefined,
+    };
+    const key = selectDefaultsKey(ref, targetDefaults, executorKeyCandidate);
+    if (key === null) {
+        return undefined;
+    }
+    // like the runtime merge, a later matching entry's identity (a `command`
+    // payload means nx:run-commands) replaces an earlier, incompatible one
+    const value = targetDefaults[key];
+    let executor;
+    for (const entry of Array.isArray(value) ? value : [value]) {
+        if ((0, internal_1.readTargetDefaultsForTarget)(targetName, { [key]: [entry] }, undefined, {
+            projectName,
+            projectNode,
+        }) === null) {
+            continue;
+        }
+        const identity = entry.command ? 'nx:run-commands' : entry.executor;
+        if (identity) {
+            executor = identity;
+        }
+    }
+    return executor;
+}
+/**
+ * The `targetDefaults` key nx's runtime would select for this target: keys
+ * are tried as the executor key, the exact-name key, then glob keys longest
+ * first, and the first whose entries produce a match wins; the rest are
+ * shadowed. Resolution per key goes through nx's own reader. Non-matching
+ * keys never resolve, so sorting all remaining keys by length stands in for
+ * the runtime's glob-only ordering.
+ */
+function selectDefaultsKey(ref, targetDefaults, executorKeyCandidate) {
+    const resolves = (key) => (0, internal_1.readTargetDefaultsForTarget)(ref.targetName, { [key]: targetDefaults[key] }, ref.matcherExecutor, {
+        projectName: ref.projectName,
+        projectNode: ref.projectNode,
+        sourcePlugin: ref.sourcePlugin,
+    }) !== null;
+    if (executorKeyCandidate &&
+        targetDefaults[executorKeyCandidate] &&
+        resolves(executorKeyCandidate)) {
+        return executorKeyCandidate;
+    }
+    if (targetDefaults[ref.targetName] &&
+        ref.targetName !== executorKeyCandidate &&
+        resolves(ref.targetName)) {
+        return ref.targetName;
+    }
+    const globCandidates = Object.keys(targetDefaults)
+        .filter((key) => key !== executorKeyCandidate && key !== ref.targetName)
+        .sort((a, b) => b.length - a.length);
+    for (const key of globCandidates) {
+        if (resolves(key)) {
+            return key;
+        }
+    }
+    return null;
+}

package/dist/src/utils/typescript/configuration.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getNeededCompilerOptionOverrides = getNeededCompilerOptionOverrides;
 const path_1 = require("path");
 const ensure_typescript_1 = require("./ensure-typescript");
+const ts_config_1 = require("./ts-config");
 const optionEnumTypeMap = {
     importsNotUsedAsValues: 'ImportsNotUsedAsValues',
     jsx: 'JsxEmit',
@@ -21,11 +22,8 @@ function getNeededCompilerOptionOverrides(tree, compilerOptions, tsConfigPath) {
     if (!ts) {
         ts = (0, ensure_typescript_1.ensureTypescript)();
     }
-    const tsSysFromTree = {
-        ...ts.sys,
-        readFile: (path) => tree.read(path, 'utf-8'),
-    };
-    const parsed = ts.parseJsonConfigFileContent(ts.readConfigFile(tsConfigPath, tsSysFromTree.readFile).config, tsSysFromTree, (0, path_1.dirname)(tsConfigPath));
+    const host = (0, ts_config_1.createTreeParseConfigHost)(tree);
+    const parsed = ts.parseJsonConfigFileContent(ts.readConfigFile(tsConfigPath, host.readFile).config, host, (0, path_1.dirname)(tsConfigPath));
     // ModuleKind: { CommonJS: 'commonjs', ... } => ModuleKind: { commonjs: 'CommonJS', ... }
     const reversedCompilerOptionsEnumValues = {
         JsxEmit: reverseEnum(ts.server.protocol.JsxEmit),

package/dist/src/utils/typescript/create-ts-config.d.ts

@@ -1,4 +1,4 @@
-import { Tree } from 'nx/src/generators/tree';
+import { Tree } from '@nx/devkit';
 export declare const tsConfigBaseOptions: {
     rootDir: string;
     sourceMap: boolean;