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

package/dist/src/release/version-actions.js

@@ -5,11 +5,13 @@ const internal_1 = require("@nx/devkit/internal");
 const devkit_1 = require("@nx/devkit");
 const node_child_process_1 = require("node:child_process");
 const node_path_1 = require("node:path");
+const jsonc_parser_1 = require("jsonc-parser");
+const semver_1 = require("semver");
 const release_1 = require("nx/release");
 const npm_config_1 = require("../utils/npm-config");
 const update_lock_file_1 = require("./utils/update-lock-file");
 const chalk = require("chalk");
-const semver_1 = require("./utils/semver");
+const semver_2 = require("./utils/semver");
 const afterAllProjectsVersioned = async (cwd, { rootVersionActionsOptions, ...opts }) => {
     return {
         changedFiles: await (0, update_lock_file_1.updateLockFile)(cwd, {
@@ -22,10 +24,14 @@ const afterAllProjectsVersioned = async (cwd, { rootVersionActionsOptions, ...op
 exports.afterAllProjectsVersioned = afterAllProjectsVersioned;
 // Cache at the module level to avoid re-detecting the package manager for each instance
 let pm;
+// Every project in a release receives the same ProjectGraph. Building these
+// indexes once avoids turning dependency updates into quadratic graph scans.
+const localDependencyProjectsByGraph = new WeakMap();
 class JsVersionActions extends release_1.VersionActions {
     constructor() {
         super(...arguments);
         this.validManifestFilenames = ['package.json'];
+        this.excludeManifestsFromFormatting = true;
     }
     async readCurrentVersionFromSourceManifest(tree) {
         const sourcePackageJsonPath = (0, node_path_1.join)(this.projectGraphNode.data.root, 'package.json');
@@ -90,25 +96,26 @@ class JsVersionActions extends release_1.VersionActions {
     async readCurrentVersionOfDependency(tree, projectGraph, dependencyProjectName) {
         const sourcePackageJsonPath = (0, node_path_1.join)(this.projectGraphNode.data.root, 'package.json');
         const json = (0, devkit_1.readJson)(tree, sourcePackageJsonPath);
-        // Resolve the package name from the project graph metadata, as it may not match the project name
-        const dependencyPackageName = projectGraph.nodes[dependencyProjectName].data.metadata?.js?.packageName;
         const dependencyTypes = [
             'dependencies',
             'devDependencies',
             'peerDependencies',
             'optionalDependencies',
         ];
+        const dependencyPackageName = projectGraph.nodes[dependencyProjectName]?.data.metadata?.js?.packageName;
         let currentVersion = null;
         let dependencyCollection = null;
-        for (const depType of dependencyTypes) {
-            if (json[depType] && json[depType][dependencyPackageName]) {
-                currentVersion = json[depType][dependencyPackageName];
-                dependencyCollection = depType;
-                break;
+        if (dependencyPackageName) {
+            for (const depType of dependencyTypes) {
+                if (json[depType]?.[dependencyPackageName]) {
+                    currentVersion = json[depType][dependencyPackageName];
+                    dependencyCollection = depType;
+                    break;
+                }
             }
         }
         // Resolve catalog references if needed
-        if (currentVersion) {
+        if (currentVersion && dependencyPackageName) {
             const catalogManager = (0, internal_1.getCatalogManager)(tree.root);
             if (catalogManager?.isCatalogReference(currentVersion)) {
                 currentVersion = catalogManager.resolveCatalogReference(tree, dependencyPackageName, currentVersion);
@@ -122,100 +129,253 @@ class JsVersionActions extends release_1.VersionActions {
     async updateProjectVersion(tree, newVersion) {
         const logMessages = [];
         for (const manifestToUpdate of this.manifestsToUpdate) {
-            (0, devkit_1.updateJson)(tree, manifestToUpdate.manifestPath, (json) => {
-                json.version = newVersion;
-                return json;
-            });
+            this.updateManifestValues(tree, manifestToUpdate.manifestPath, [
+                { path: ['version'], value: newVersion },
+            ]);
             logMessages.push(`✍️  New version ${newVersion} written to manifest: ${manifestToUpdate.manifestPath}`);
         }
         return logMessages;
     }
-    async updateProjectDependencies(tree, projectGraph, dependenciesToUpdate) {
-        let numDependenciesToUpdate = Object.keys(dependenciesToUpdate).length;
-        if (numDependenciesToUpdate === 0) {
+    async updateProjectDependencies(tree, projectGraph, dependenciesToUpdate, resolveVersionForDependency) {
+        if (Object.keys(dependenciesToUpdate).length === 0 &&
+            !resolveVersionForDependency) {
             return [];
         }
-        const logMessages = [];
+        const dependencyTypes = [
+            'dependencies',
+            'devDependencies',
+            'peerDependencies',
+            'optionalDependencies',
+        ];
+        const localDependencyProjects = this.getLocalDependencyProjectLookup(projectGraph);
+        for (const projectName of Object.keys(dependenciesToUpdate)) {
+            if (!projectGraph.nodes[projectName]?.data.metadata?.js?.packageName) {
+                throw new Error(`Unable to determine the package name for project "${projectName}" from the project graph metadata, please ensure that the "@nx/js" plugin is installed and the project graph has been built. If the issue persists, please report this issue on https://github.com/nrwl/nx/issues`);
+            }
+        }
+        const resolvedVersions = new Map();
+        const resolveVersion = (projectName) => {
+            let resolution = resolvedVersions.get(projectName);
+            if (!resolution) {
+                if (!resolveVersionForDependency) {
+                    throw new Error(`No version resolver was provided for dependency project "${projectName}".`);
+                }
+                resolution = resolveVersionForDependency(projectName);
+                resolvedVersions.set(projectName, resolution);
+            }
+            return resolution;
+        };
+        const manifestUpdates = [];
         const catalogUpdates = [];
         const catalogManager = (0, internal_1.getCatalogManager)(tree.root);
         for (const manifestToUpdate of this.manifestsToUpdate) {
-            (0, devkit_1.updateJson)(tree, manifestToUpdate.manifestPath, (json) => {
-                const dependencyTypes = [
-                    'dependencies',
-                    'devDependencies',
-                    'peerDependencies',
-                    'optionalDependencies',
-                ];
-                const preserveMatchingDependencyRanges = this.finalConfigForProject.preserveMatchingDependencyRanges === true
-                    ? dependencyTypes
-                    : this.finalConfigForProject.preserveMatchingDependencyRanges ===
-                        false
-                        ? []
-                        : this.finalConfigForProject.preserveMatchingDependencyRanges ||
-                            dependencyTypes;
-                for (const depType of dependencyTypes) {
-                    if (json[depType]) {
-                        for (const [dep, version] of Object.entries(dependenciesToUpdate)) {
-                            // Resolve the package name from the project graph metadata, as it may not match the project name
-                            const packageName = projectGraph.nodes[dep].data.metadata?.js?.packageName;
-                            if (!packageName) {
-                                throw new Error(`Unable to determine the package name for project "${dep}" from the project graph metadata, please ensure that the "@nx/js" plugin is installed and the project graph has been built. If the issue persists, please report this issue on https://github.com/nrwl/nx/issues`);
+            const json = (0, devkit_1.readJson)(tree, manifestToUpdate.manifestPath);
+            const updates = [];
+            const preserveMatchingDependencyRanges = this.finalConfigForProject.preserveMatchingDependencyRanges === true
+                ? dependencyTypes
+                : this.finalConfigForProject.preserveMatchingDependencyRanges ===
+                    false
+                    ? []
+                    : this.finalConfigForProject.preserveMatchingDependencyRanges ||
+                        dependencyTypes;
+            for (const depType of dependencyTypes) {
+                if (json[depType]) {
+                    for (const [dependencyName, currentVersion] of Object.entries(json[depType])) {
+                        const targetProject = localDependencyProjects.get(dependencyName);
+                        if (!targetProject) {
+                            continue;
+                        }
+                        let version = dependenciesToUpdate[targetProject.projectName];
+                        if (version !== undefined) {
+                            if (catalogManager?.isCatalogReference(currentVersion)) {
+                                // collect the catalog updates so we can update the catalog definitions later
+                                const catalogRef = catalogManager.parseCatalogReference(currentVersion);
+                                catalogUpdates.push({
+                                    packageName: dependencyName,
+                                    version,
+                                    catalogName: catalogRef.catalogName,
+                                });
+                                continue;
                             }
-                            const currentVersion = json[depType][packageName];
-                            if (currentVersion) {
-                                if (catalogManager?.isCatalogReference(currentVersion)) {
-                                    // collect the catalog updates so we can update the catalog definitions later
-                                    const catalogRef = catalogManager.parseCatalogReference(currentVersion);
-                                    catalogUpdates.push({
-                                        packageName,
-                                        version,
-                                        catalogName: catalogRef.catalogName,
-                                    });
-                                    numDependenciesToUpdate--;
-                                    continue;
+                            if (manifestToUpdate.preserveLocalDependencyProtocols &&
+                                this.isLocalDependencyProtocol(currentVersion)) {
+                                continue;
+                            }
+                            if (this.isLocalDependencyProtocol(currentVersion)) {
+                                version = this.applyVersionPrefix(currentVersion, version);
+                            }
+                            if (preserveMatchingDependencyRanges.includes(depType) &&
+                                !this.isLocalDependencyProtocol(currentVersion)) {
+                                // If the dependency is specified using a range, do some additional processing to determine whether to update the version
+                                if ((0, semver_2.isValidRange)(currentVersion) &&
+                                    !(0, semver_2.isMatchingDependencyRange)(version, currentVersion)) {
+                                    throw new Error(`"preserveMatchingDependencyRanges" is enabled for "${depType}" and the new version "${version}" is outside the current range for "${dependencyName}" in manifest "${manifestToUpdate.manifestPath}". Please update the range before releasing.`);
                                 }
-                                // Check if other local dependency protocols should be preserved
-                                else if (manifestToUpdate.preserveLocalDependencyProtocols &&
-                                    this.isLocalDependencyProtocol(currentVersion)) {
-                                    // Reduce the count appropriately to avoid confusing user-facing logs
-                                    numDependenciesToUpdate--;
+                                else if ((0, semver_2.isValidRange)(currentVersion)) {
                                     continue;
                                 }
-                                else if (preserveMatchingDependencyRanges.includes(depType) &&
-                                    !this.isLocalDependencyProtocol(currentVersion)) {
-                                    // If the dependency is specified using a range, do some additional processing to determine whether to update the version
-                                    if ((0, semver_1.isValidRange)(currentVersion) &&
-                                        !(0, semver_1.isMatchingDependencyRange)(version, currentVersion)) {
-                                        throw new Error(`"preserveMatchingDependencyRanges" is enabled for "${depType}" and the new version "${version}" is outside the current range for "${packageName}" in manifest "${manifestToUpdate.manifestPath}". Please update the range before releasing.`);
-                                    }
-                                    else if ((0, semver_1.isValidRange)(currentVersion)) {
-                                        // it is a range, but it is valid
-                                        continue;
-                                    }
-                                }
-                                json[depType][packageName] = version;
                             }
                         }
+                        else if (resolveVersionForDependency &&
+                            !manifestToUpdate.preserveLocalDependencyProtocols &&
+                            this.isLocalDependencyProtocol(currentVersion)) {
+                            try {
+                                version = await this.resolveLocalDependencySpecifier(dependencyName, currentVersion, targetProject, resolveVersion);
+                            }
+                            catch (error) {
+                                const message = error instanceof Error ? error.message : String(error);
+                                throw new Error(`Unable to replace local dependency protocol "${currentVersion}" for "${dependencyName}" in manifest "${manifestToUpdate.manifestPath}". ${message}`);
+                            }
+                        }
+                        if (version !== undefined) {
+                            updates.push({
+                                path: [depType, dependencyName],
+                                value: version,
+                            });
+                        }
                     }
                 }
-                return json;
+            }
+            manifestUpdates.push({
+                manifestPath: manifestToUpdate.manifestPath,
+                updates,
             });
-            // If we ignored local dependecy protocols, then we could have dynamically ended up with zero here and we should not log anything related to dependencies
-            if (numDependenciesToUpdate === 0) {
-                return [];
+        }
+        // Resolve every requested version before writing any manifest so one
+        // failed resolver cannot leave a partially updated set of manifests.
+        const logMessages = [];
+        for (const manifestUpdate of manifestUpdates) {
+            this.updateManifestValues(tree, manifestUpdate.manifestPath, manifestUpdate.updates);
+            if (manifestUpdate.updates.length > 0) {
+                const depText = manifestUpdate.updates.length === 1 ? 'dependency' : 'dependencies';
+                logMessages.push(`✍️  Updated ${manifestUpdate.updates.length} ${depText} in manifest: ${manifestUpdate.manifestPath}`);
             }
-            const depText = numDependenciesToUpdate === 1 ? 'dependency' : 'dependencies';
-            logMessages.push(`✍️  Updated ${numDependenciesToUpdate} ${depText} in manifest: ${manifestToUpdate.manifestPath}`);
         }
-        // Update catalog definitions in pnpm-workspace.yaml
+        // Update catalog definitions in the package manager's catalog file
         if (catalogUpdates.length > 0) {
             // catalogManager is guaranteed to be defined when there are catalog updates
             catalogManager.updateCatalogVersions(tree, catalogUpdates);
             const catalogText = catalogUpdates.length === 1 ? 'entry' : 'entries';
-            logMessages.push(`✍️  Updated ${catalogUpdates.length} catalog ${catalogText} in pnpm-workspace.yaml`);
+            logMessages.push(`✍️  Updated ${catalogUpdates.length} catalog ${catalogText} in ${catalogManager
+                .getCatalogDefinitionFilePaths()
+                .join(', ')}`);
         }
         return logMessages;
     }
+    getLocalDependencyProjectLookup(projectGraph) {
+        let lookup = localDependencyProjectsByGraph.get(projectGraph);
+        if (lookup) {
+            return lookup;
+        }
+        // This lookup requires the dependency key to match the package name.
+        // Package aliases need relationship-specific manifest data that the
+        // project graph does not retain. Support is tracked in
+        // https://github.com/nrwl/nx/issues/36630.
+        lookup = new Map();
+        for (const [projectName, node] of Object.entries(projectGraph.nodes)) {
+            const packageName = node.data.metadata?.js?.packageName;
+            if (!packageName) {
+                continue;
+            }
+            lookup.set(packageName, { projectName });
+        }
+        localDependencyProjectsByGraph.set(projectGraph, lookup);
+        return lookup;
+    }
+    async resolveLocalDependencySpecifier(dependencyName, versionSpecifier, targetProject, resolveVersion) {
+        if (versionSpecifier.startsWith('file:')) {
+            const resolvedVersion = await resolveVersion(targetProject.projectName);
+            return this.applyVersionPrefix(versionSpecifier, resolvedVersion);
+        }
+        const range = versionSpecifier.slice('workspace:'.length);
+        if (range !== '' &&
+            range !== '*' &&
+            range !== '^' &&
+            range !== '~' &&
+            (0, semver_1.validRange)(range) !== null) {
+            return range;
+        }
+        const isRelativePath = range.startsWith('.');
+        if (!isRelativePath &&
+            range !== '' &&
+            range !== '*' &&
+            range !== '^' &&
+            range !== '~') {
+            throw new Error(`The workspace protocol used by "${dependencyName}" is not a supported range or relative workspace path.`);
+        }
+        const resolvedVersion = await resolveVersion(targetProject.projectName);
+        return this.applyVersionPrefix(isRelativePath ? 'workspace:*' : `workspace:${range}`, resolvedVersion);
+    }
+    applyVersionPrefix(versionSpecifier, resolvedVersion) {
+        const configuredPrefix = this.finalConfigForProject.versionPrefix;
+        let prefix = '';
+        if (configuredPrefix === '~' ||
+            configuredPrefix === '^' ||
+            configuredPrefix === '=') {
+            prefix = configuredPrefix;
+        }
+        else if (configuredPrefix === 'auto' &&
+            versionSpecifier.startsWith('workspace:')) {
+            const range = versionSpecifier.slice('workspace:'.length);
+            if (range.startsWith('^')) {
+                prefix = '^';
+            }
+            else if (range.startsWith('~')) {
+                prefix = '~';
+            }
+        }
+        return `${prefix}${resolvedVersion.replace(/^[~^=]/, '')}`;
+    }
+    updateManifestValues(tree, manifestPath, updates) {
+        if (updates.length === 0) {
+            return;
+        }
+        let content = this.readAndValidateManifest(tree, manifestPath);
+        const formattingOptions = this.detectFormattingOptions(content);
+        for (const update of updates) {
+            content = (0, jsonc_parser_1.applyEdits)(content, (0, jsonc_parser_1.modify)(content, update.path, update.value, { formattingOptions }));
+        }
+        this.validateManifestUpdates(content, manifestPath, updates);
+        tree.write(manifestPath, content);
+    }
+    readAndValidateManifest(tree, manifestPath) {
+        const content = tree.read(manifestPath, 'utf-8');
+        try {
+            // Match readJson's support for comments and trailing commas while
+            // retaining the original text for targeted edits.
+            (0, devkit_1.parseJson)(content);
+        }
+        catch (error) {
+            throw new Error(`Cannot parse ${manifestPath}: ${error.message}`);
+        }
+        return content;
+    }
+    validateManifestUpdates(content, manifestPath, updates) {
+        const manifest = (0, devkit_1.parseJson)(content);
+        for (const update of updates) {
+            let actualValue = manifest;
+            for (const pathSegment of update.path) {
+                if (actualValue === null ||
+                    typeof actualValue !== 'object' ||
+                    !(pathSegment in actualValue)) {
+                    actualValue = undefined;
+                    break;
+                }
+                actualValue = actualValue[pathSegment];
+            }
+            if (actualValue !== update.value) {
+                throw new Error(`Cannot update ${manifestPath}: "${update.path.join('.')}" resolves to ${JSON.stringify(actualValue)} instead of ${JSON.stringify(update.value)} after editing. The manifest may contain duplicate keys.`);
+            }
+        }
+    }
+    detectFormattingOptions(content) {
+        const indentation = content.match(/^[\t ]+(?=")/m)?.[0] ?? '  ';
+        const insertSpaces = !indentation.includes('\t');
+        return {
+            insertSpaces,
+            tabSize: insertSpaces ? indentation.length : 1,
+        };
+    }
     // NOTE: The TODOs were carried over from the original implementation, they are not yet implemented
     isLocalDependencyProtocol(versionSpecifier) {
         const localPackageProtocols = [

package/dist/src/utils/add-linting-to-project.d.ts

@@ -0,0 +1,46 @@
+import { GeneratorCallback, Tree } from '@nx/devkit';
+import { type LinterType } from './linter';
+export interface AddLintingToProjectOptions {
+    /** Required, but `undefined` still reaches here — see the normalization below. */
+    linter: LinterType | undefined;
+    project: string;
+    skipPackageJson?: boolean;
+    keepExistingVersions?: boolean;
+    addPlugin?: boolean;
+    /** ESLint-only. Ignored by other linters. */
+    tsConfigPaths?: string[];
+    unitTestRunner?: string;
+    /** ESLint-only. Ignored by other linters. */
+    rootProject?: boolean;
+    /** ESLint-only. Ignored by other linters. */
+    enableTypedLinting?: boolean;
+    /** ESLint-only. Oxlint is inference-only, so it writes no explicit target. */
+    addExplicitTargets?: boolean;
+    /**
+     * ESLint-only. The `@nx/dependency-checks` rule lints `package.json`, which
+     * Oxlint cannot read.
+     */
+    addPackageJsonDependencyChecks?: boolean;
+    /**
+     * Oxlint plugins to enable for this project, e.g. `['react', 'jsx-a11y']`.
+     * Ignored by other linters, which express framework presets differently.
+     */
+    oxlintPlugins?: string[];
+}
+/**
+ * Sets a project's linter up, dispatching to whichever linter the workspace
+ * asked for. Consumers call this instead of importing `lintProjectGenerator`
+ * from `@nx/eslint` directly, so adding a linter does not mean editing every
+ * generator. The two arms name different generators on purpose: `@nx/eslint`
+ * writes a lint target, while `@nx/oxlint` is inference-only and only
+ * configures the project.
+ *
+ * Scope is deliberately narrow: registering the linter and its project target.
+ * Linter-specific config shaping — ESLint framework presets, `extends`, ignore
+ * entries — stays at the call site guarded on `linter`, because none of it has
+ * a cross-linter equivalent.
+ *
+ * Both plugins are loaded through `ensurePackage`; a static import would be
+ * circular, since both depend on `@nx/js`.
+ */
+export declare function addLintingToProject(tree: Tree, options: AddLintingToProjectOptions): Promise<GeneratorCallback>;

package/dist/src/utils/add-linting-to-project.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addLintingToProject = addLintingToProject;
+const devkit_1 = require("@nx/devkit");
+const internal_1 = require("@nx/devkit/internal");
+const versions_1 = require("./versions");
+const linter_1 = require("./linter");
+/**
+ * Sets a project's linter up, dispatching to whichever linter the workspace
+ * asked for. Consumers call this instead of importing `lintProjectGenerator`
+ * from `@nx/eslint` directly, so adding a linter does not mean editing every
+ * generator. The two arms name different generators on purpose: `@nx/eslint`
+ * writes a lint target, while `@nx/oxlint` is inference-only and only
+ * configures the project.
+ *
+ * Scope is deliberately narrow: registering the linter and its project target.
+ * Linter-specific config shaping — ESLint framework presets, `extends`, ignore
+ * entries — stays at the call site guarded on `linter`, because none of it has
+ * a cross-linter equivalent.
+ *
+ * Both plugins are loaded through `ensurePackage`; a static import would be
+ * circular, since both depend on `@nx/js`.
+ */
+async function addLintingToProject(tree, options) {
+    // Callers should resolve this themselves, since their own guards need a
+    // concrete value. Resolving again here keeps a caller that forgets from
+    // silently getting ESLint in a workspace that uses something else.
+    const linter = options.linter ?? (0, linter_1.detectLinters)(tree)[0] ?? 'none';
+    if (linter === 'none') {
+        return () => { };
+    }
+    if (linter === 'oxlint') {
+        // `ensurePackage` installs by package name, so the subpath is required
+        // separately. `nx-ignore-next-line` keeps this out of the import graph, so
+        // the dependency stays a devDependency of this package rather than a runtime
+        // one. That devDependency is what makes the `js` <-> `@nx/oxlint` cycle,
+        // which is deliberate and recorded in `ignoredCircularDependencies` in the
+        // root eslint config.
+        (0, devkit_1.ensurePackage)('@nx/oxlint', versions_1.nxVersion);
+        // `@nx/oxlint` is the only ESM package under `packages/` and its
+        // `./generators` subpath has no `require` condition, so a bare `require()`
+        // throws ERR_REQUIRE_ESM below Node 20.19 / 22.12.
+        //
+        // Resolve to an absolute path before importing. `ensurePackage` exposes an
+        // on-demand install by adding a temp dir to NODE_PATH, which `require.resolve`
+        // honours and the ESM loader does not — so handing `import()` a bare specifier
+        // fails with ERR_MODULE_NOT_FOUND on exactly the Node band this indirection
+        // exists for. `load-resolved-plugin.ts` calls `handleImport` the same way.
+        // nx-ignore-next-line
+        const generatorsPath = require.resolve('@nx/oxlint/generators', {
+            paths: [devkit_1.workspaceRoot, __dirname],
+        });
+        const { configurationGenerator } = await (0, internal_1.handleImport)(generatorsPath);
+        return configurationGenerator(tree, {
+            project: options.project,
+            plugins: [
+                ...(options.oxlintPlugins ?? []),
+                ...oxlintTestPlugins(options.unitTestRunner),
+            ],
+            skipFormat: true,
+            skipPackageJson: options.skipPackageJson,
+            keepExistingVersions: options.keepExistingVersions,
+            // No `addPlugin`: `@nx/oxlint` is inference-only, so it always registers.
+        });
+    }
+    if (linter === 'eslint') {
+        const { lintProjectGenerator } = (0, devkit_1.ensurePackage)('@nx/eslint', versions_1.nxVersion);
+        return lintProjectGenerator(tree, {
+            linter,
+            project: options.project,
+            tsConfigPaths: options.tsConfigPaths,
+            unitTestRunner: options.unitTestRunner,
+            rootProject: options.rootProject,
+            enableTypedLinting: options.enableTypedLinting,
+            addExplicitTargets: options.addExplicitTargets,
+            addPackageJsonDependencyChecks: options.addPackageJsonDependencyChecks,
+            skipFormat: true,
+            skipPackageJson: options.skipPackageJson,
+            keepExistingVersions: options.keepExistingVersions,
+            addPlugin: options.addPlugin,
+        });
+    }
+    // Spelling ESLint out as its own branch rather than letting it be the
+    // fallthrough: a new `LinterType` member then fails to compile here instead of
+    // silently getting an ESLint setup.
+    const unhandled = linter;
+    throw new Error(`Unsupported linter: ${unhandled}`);
+}
+/**
+ * Which Oxlint plugins a test runner needs is the runner package's knowledge,
+ * so it is read from there rather than hardcoded here — this only maps the
+ * runner name to its package. Matched loosely because runners arrive with
+ * suffixes, e.g. Angular's `vitest-analog`. Both packages are already installed
+ * by the time the runner's own generator runs; `ensurePackage` keeps them out
+ * of the import graph, since both depend on `@nx/js`.
+ */
+function oxlintTestPlugins(unitTestRunner) {
+    const pkg = unitTestRunner?.includes('vitest')
+        ? '@nx/vitest'
+        : unitTestRunner?.includes('jest')
+            ? '@nx/jest'
+            : undefined;
+    if (!pkg) {
+        return [];
+    }
+    // `ensurePackage` installs by package name, so the `internal` subpath is
+    // required separately. Plain `require` holds only while both runners are CJS;
+    // `@nx/oxlint` is ESM, which is why the arm above needs `handleImport`.
+    (0, devkit_1.ensurePackage)(pkg, versions_1.nxVersion);
+    const { oxlintPlugins } = require(`${pkg}/internal`);
+    return oxlintPlugins ?? [];
+}

package/dist/src/utils/assets/copy-assets-handler.d.ts

@@ -1,6 +1,6 @@
 import { AssetGlob } from './assets';
 import { normalizeAssets, getAssetOutputPath, NormalizedAssetEntry as AssetEntry } from './normalize-assets';
-import { ChangedFile } from 'nx/src/daemon/client/client';
+import { ChangedFile } from '@nx/devkit/internal';
 export type { AssetEntry };
 export { normalizeAssets, getAssetOutputPath };
 export type FileEventType = 'create' | 'update' | 'delete';

package/dist/src/utils/assets/copy-assets-handler.js

@@ -12,7 +12,7 @@ const normalize_assets_1 = require("./normalize-assets");
 Object.defineProperty(exports, "normalizeAssets", { enumerable: true, get: function () { return normalize_assets_1.normalizeAssets; } });
 Object.defineProperty(exports, "getAssetOutputPath", { enumerable: true, get: function () { return normalize_assets_1.getAssetOutputPath; } });
 const devkit_1 = require("@nx/devkit");
-const client_1 = require("nx/src/daemon/client/client");
+const internal_1 = require("@nx/devkit/internal");
 const picocolors_1 = require("picocolors");
 const defaultFileEventHandler = (events) => {
     const dirs = new Set(events.map((event) => path.dirname(event.dest)));
@@ -93,7 +93,7 @@ class CopyAssetsHandler {
         return ['**/node_modules/**', '**/.git/**'];
     }
     async watchAndProcessOnAssetChange() {
-        const unregisterFileWatcher = await client_1.daemonClient.registerFileWatcher({
+        const unregisterFileWatcher = await internal_1.daemonClient.registerFileWatcher({
             watchProjects: 'all',
             includeGlobalWorkspaceFiles: true,
         }, (err, data) => {