@nx/vite 23.3.0-pr.37068.f95e11e → 23.3.0-rc.0

package/README.md

@@ -12,7 +12,7 @@
 [![Semantic Release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg?style=flat-square)](<>)
 [![Commitizen friendly](https://img.shields.io/badge/commitizen-friendly-brightgreen.svg)](http://commitizen.github.io/cz-cli/)
 [![Join us on the Official Nx Discord Server](https://img.shields.io/discord/1143497901675401286?label=discord)](https://go.nx.dev/community)
-[![Nx Sandboxing](https://staging.nx.app/workspaces/62d013ea0852fe0a2df74438/sandbox-badge.svg)](https://nx.dev/docs/features/ci-features/sandboxing)
+[![Hours saved](https://img.shields.io/endpoint?url=https%3A%2F%2Fstaging.nx.app%2Fnx-cloud%2Fbadge%2F62d013ea0852fe0a2df74438%2Fhours-saved.json)](https://nx.dev/nx-cloud)
 
 </div>
 

package/dist/plugins/nx-tsconfig-paths.plugin.d.ts

@@ -15,7 +15,7 @@ export interface nxViteTsPathsOptions {
     mainFields?: (string | string[])[];
     /**
      * extensions to check when resolving files when package.json resolution fails
-     * @default ['.ts', '.tsx', '.js', '.jsx', '.json', '.mjs', '.cjs']
+     * @default ['.ts', '.tsx', '.js', '.jsx', '.json', '.mts', '.mjs', '.cts', '.cjs', '.css', '.scss', '.less']
      **/
     extensions?: string[];
     /**

package/dist/plugins/nx-tsconfig-paths.plugin.js

@@ -8,7 +8,7 @@ const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const tsconfig_paths_1 = require("tsconfig-paths");
 const deprecation_1 = require("../src/utils/deprecation");
-const nx_tsconfig_paths_find_file_1 = require("../src/utils/nx-tsconfig-paths-find-file");
+const nx_tsconfig_paths_load_file_1 = require("../src/utils/nx-tsconfig-paths-load-file");
 const options_utils_1 = require("../src/utils/options-utils");
 const nx_vite_build_coordination_plugin_1 = require("./nx-vite-build-coordination.plugin");
 /**
@@ -21,8 +21,11 @@ const nx_vite_build_coordination_plugin_1 = require("./nx-vite-build-coordinatio
 function nxViteTsPaths(options = {}) {
     (0, deprecation_1.warnNxViteTsPathsDeprecation)();
     let foundTsConfigPath;
+    let tsConfigPathsLoaded = false;
     let matchTsPathEsm;
+    let matchTsPathEsmExact;
     let matchTsPathFallback;
+    let matchTsPathFallbackExact;
     let tsConfigPathsEsm;
     let tsConfigPathsFallback;
     options.extensions ??= [
@@ -53,6 +56,7 @@ function nxViteTsPaths(options = {}) {
         async configResolved(config) {
             projectRoot = config.root;
             projectRootFromWorkspaceRoot = (0, node_path_1.relative)(devkit_1.workspaceRoot, projectRoot);
+            tsConfigPathsLoaded = false;
             foundTsConfigPath = getTsConfig(process.env.NX_TSCONFIG_PATH ??
                 (0, node_path_1.join)(devkit_1.workspaceRoot, 'tmp', projectRootFromWorkspaceRoot, process.env.NX_TASK_TARGET_TARGET ?? 'build', 'tsconfig.generated.json'));
             if (!foundTsConfigPath)
@@ -89,20 +93,10 @@ function nxViteTsPaths(options = {}) {
                     }
                 }
             }
-            const parsed = (0, tsconfig_paths_1.loadConfig)(foundTsConfigPath);
-            logIt('first parsed tsconfig: ', parsed);
-            if (parsed.resultType === 'failed') {
-                throw new Error(`Failed loading tsconfig at ${foundTsConfigPath}`);
-            }
-            tsConfigPathsEsm = parsed;
-            matchTsPathEsm = (0, tsconfig_paths_1.createMatchPath)((0, js_1.resolvePathsBaseUrl)(foundTsConfigPath), parsed.paths, options.mainFields);
-            const rootLevelTsConfig = getTsConfig((0, node_path_1.join)(devkit_1.workspaceRoot, 'tsconfig.base.json'));
-            const rootLevelParsed = (0, tsconfig_paths_1.loadConfig)(rootLevelTsConfig);
-            logIt('fallback parsed tsconfig: ', rootLevelParsed);
-            if (rootLevelParsed.resultType === 'success') {
-                tsConfigPathsFallback = rootLevelParsed;
-                matchTsPathFallback = (0, tsconfig_paths_1.createMatchPath)((0, js_1.resolvePathsBaseUrl)(rootLevelTsConfig), rootLevelParsed.paths, ['main', 'module']);
-            }
+            // Graph construction resolves every config and never a module, so the
+            // parsing waits for the first `resolveId` there.
+            if (!global.NX_GRAPH_CREATION)
+                loadTsConfigPaths();
         },
         resolveId(importPath) {
             // Let other resolvers handle this path.
@@ -114,20 +108,31 @@ function nxViteTsPaths(options = {}) {
             // by tsconfig path mapping (which would incorrectly use baseUrl).
             if (importPath.startsWith('/'))
                 return null;
+            if (!tsConfigPathsLoaded)
+                loadTsConfigPaths();
             let resolvedFile;
             try {
-                resolvedFile = matchTsPathEsm(importPath);
+                resolvedFile =
+                    matchTsPathEsmExact(importPath) ??
+                        loadFileFromExactAlias(tsConfigPathsEsm, importPath) ??
+                        matchTsPathEsm(importPath);
             }
             catch (e) {
                 logIt('Using fallback path matching.');
-                resolvedFile = matchTsPathFallback?.(importPath);
+                resolvedFile =
+                    matchTsPathFallbackExact?.(importPath) ??
+                        loadFileFromExactAlias(tsConfigPathsFallback, importPath) ??
+                        matchTsPathFallback?.(importPath);
             }
             if (!resolvedFile || !(0, node_fs_1.existsSync)(resolvedFile)) {
                 if (tsConfigPathsEsm || tsConfigPathsFallback) {
                     logIt(`Unable to resolve ${importPath} with tsconfig paths. Using fallback file matching.`);
+                    // The tsconfig the project builds with need not extend the
+                    // root-level one, so the second pass covers aliases only the
+                    // root-level config declares.
                     resolvedFile =
-                        loadFileFromPaths(tsConfigPathsEsm, importPath) ||
-                            loadFileFromPaths(tsConfigPathsFallback, importPath);
+                        loadFileFromPathsWithLogging(tsConfigPathsEsm, importPath) ||
+                            loadFileFromPathsWithLogging(tsConfigPathsFallback, importPath);
                 }
                 else {
                     logIt(`Unable to resolve ${importPath} with tsconfig paths`);
@@ -154,6 +159,37 @@ function nxViteTsPaths(options = {}) {
             }
         },
     };
+    function loadTsConfigPaths() {
+        const parsed = (0, tsconfig_paths_1.loadConfig)(foundTsConfigPath);
+        logIt('first parsed tsconfig: ', parsed);
+        if (parsed.resultType === 'failed') {
+            throw new Error(`Failed loading tsconfig at ${foundTsConfigPath}`);
+        }
+        // `loadConfig` derives `absoluteBaseUrl` from the leaf tsconfig, but
+        // `paths` resolve against the config that declared them.
+        const pathsBaseUrl = (0, js_1.resolvePathsBaseUrl)(foundTsConfigPath);
+        tsConfigPathsEsm = { ...parsed, absoluteBaseUrl: pathsBaseUrl };
+        matchTsPathEsm = (0, tsconfig_paths_1.createMatchPath)(pathsBaseUrl, parsed.paths, options.mainFields);
+        matchTsPathEsmExact = createExactMatchPath(pathsBaseUrl, parsed.paths, options.mainFields);
+        const rootLevelTsConfig = getTsConfig((0, node_path_1.join)(devkit_1.workspaceRoot, 'tsconfig.base.json'));
+        // A workspace may have no root-level tsconfig at all. Passing no path to
+        // `loadConfig` makes it search upwards from the cwd instead, which finds
+        // an unrelated tsconfig whose directory is not this workspace.
+        if (rootLevelTsConfig) {
+            const rootLevelParsed = (0, tsconfig_paths_1.loadConfig)(rootLevelTsConfig);
+            logIt('fallback parsed tsconfig: ', rootLevelParsed);
+            if (rootLevelParsed.resultType === 'success') {
+                const rootLevelPathsBaseUrl = (0, js_1.resolvePathsBaseUrl)(rootLevelTsConfig);
+                tsConfigPathsFallback = {
+                    ...rootLevelParsed,
+                    absoluteBaseUrl: rootLevelPathsBaseUrl,
+                };
+                matchTsPathFallback = (0, tsconfig_paths_1.createMatchPath)(rootLevelPathsBaseUrl, rootLevelParsed.paths, ['main', 'module']);
+                matchTsPathFallbackExact = createExactMatchPath(rootLevelPathsBaseUrl, rootLevelParsed.paths, ['main', 'module']);
+            }
+        }
+        tsConfigPathsLoaded = true;
+    }
     function getTsConfig(preferredTsConfigPath) {
         const projectTsConfigPath = (0, options_utils_1.getProjectTsConfigPath)(projectRootFromWorkspaceRoot);
         return [
@@ -178,31 +214,42 @@ function nxViteTsPaths(options = {}) {
             console.debug('\n[Nx Vite TsPaths]', ...msg);
         }
     }
-    function loadFileFromPaths(tsconfig, importPath) {
-        logIt(`Trying to resolve file from config in ${tsconfig.configFileAbsolutePath}`);
-        let resolvedFile;
-        for (const alias in tsconfig.paths) {
-            const paths = tsconfig.paths[alias];
-            const normalizedImport = alias.replace(/\/\*$/, '');
-            if (importPath === normalizedImport ||
-                importPath.startsWith(normalizedImport + '/')) {
-                for (const path of paths) {
-                    const joinedPath = (0, devkit_1.joinPathFragments)(tsconfig.absoluteBaseUrl, path.replace(/\/\*$/, ''));
-                    resolvedFile = (0, nx_tsconfig_paths_find_file_1.findFile)(importPath.replace(normalizedImport, joinedPath), options.extensions);
-                    if (resolvedFile === undefined &&
-                        options.extensions.some((ext) => importPath.endsWith(ext))) {
-                        const foundExtension = options.extensions.find((ext) => importPath.endsWith(ext));
-                        const pathWithoutExtension = importPath
-                            .replace(normalizedImport, joinedPath)
-                            .slice(0, -foundExtension.length);
-                        resolvedFile = (0, nx_tsconfig_paths_find_file_1.findFile)(pathWithoutExtension, options.extensions);
-                    }
-                    if (resolvedFile !== undefined) {
-                        return resolvedFile;
-                    }
-                }
-            }
+    /**
+     * Resolves an import that names an alias exactly, through that alias alone.
+     *
+     * The matcher above already covers a mapped path that names a file or a
+     * package entry, so this is what finds an `index` or supplies the extension.
+     * Restricting it to the one alias keeps it from answering with a wildcard,
+     * which is the last resort's job.
+     */
+    function loadFileFromExactAlias(tsconfig, importPath) {
+        // An own-property check, because an import named after an `Object`
+        // prototype member (`constructor`, `toString`) would otherwise read the
+        // inherited value and hand a non-array on to the resolver.
+        if (!tsconfig || !Object.hasOwn(tsconfig.paths, importPath)) {
+            return undefined;
         }
-        return resolvedFile;
+        return (0, nx_tsconfig_paths_load_file_1.loadFileFromPaths)({ ...tsconfig, paths: { [importPath]: tsconfig.paths[importPath] } }, importPath, options.extensions);
     }
+    function loadFileFromPathsWithLogging(tsconfig, importPath) {
+        // The root-level tsconfig is optional: a workspace without one leaves
+        // `tsConfigPathsFallback` unset, and the import has to defer to Vite.
+        if (!tsconfig)
+            return undefined;
+        logIt(`Trying to resolve file from config in ${tsconfig.configFileAbsolutePath}`);
+        return (0, nx_tsconfig_paths_load_file_1.loadFileFromPaths)(tsconfig, importPath, options.extensions);
+    }
+}
+/**
+ * Matcher over the non-wildcard aliases alone, to run before the full one.
+ *
+ * `tsconfig-paths` ranks an alias by the length of the text before its `*`,
+ * counting one without a `*` as zero, so an exact alias sorts no higher than
+ * any wildcard. TypeScript matches an exact alias first.
+ */
+function createExactMatchPath(absoluteBaseUrl, paths, mainFields) {
+    const exactPaths = Object.fromEntries(Object.entries(paths).filter(([alias]) => !alias.includes('*')));
+    // The match-all `*` entry would resolve any import against `baseUrl` before
+    // the wildcard aliases of the full matcher get their turn.
+    return (0, tsconfig_paths_1.createMatchPath)(absoluteBaseUrl, exactPaths, mainFields, false);
 }

package/dist/src/plugins/plugin.js

@@ -95,24 +95,12 @@ async function buildViteTargets(configFilePath, projectRoot, options, tsConfigFi
     catch {
         // do nothing
     }
-    // Workaround for race condition with ESM-only Vite plugins (e.g. @vitejs/plugin-vue@6+)
-    // If vite.config.ts is compiled as CJS, then when both require('@vitejs/plugin-vue') and import('@vitejs/plugin-vue')
-    // are pending in the same process, Node will throw an error:
-    // Error [ERR_INTERNAL_ASSERTION]: Cannot require() ES Module @vitejs/plugin-vue/dist/index.js because it is not yet fully loaded.
-    // This may be caused by a race condition if the module is simultaneously dynamically import()-ed via Promise.all().
-    try {
-        const importVuePlugin = () => new Function('return import("@vitejs/plugin-vue")')();
-        await importVuePlugin();
-    }
-    catch {
-        // Plugin not installed or not needed, ignore
-    }
     const { resolveConfig } = await (0, executor_utils_1.loadViteDynamicImport)();
-    const viteBuildConfig = await resolveConfig({
+    const viteBuildConfig = await (0, internal_1.retryOnRequireEsmRace)(() => resolveConfig({
         configFile: absoluteConfigFilePath,
         mode: 'development',
         root: projectRoot,
-    }, 'build');
+    }, 'build'));
     const metadata = {};
     const { buildOutputs, isBuildable, hasServeConfig } = getOutputs(viteBuildConfig, projectRoot, context.workspaceRoot);
     const namedInputs = (0, internal_1.getNamedInputs)(projectRoot, context);
@@ -326,7 +314,7 @@ function normalizeOutputPath(outputPath, projectRoot, workspaceRoot, path) {
     }
     else {
         if ((0, node_path_1.isAbsolute)(outputPath)) {
-            return `{workspaceRoot}/${(0, node_path_1.relative)(workspaceRoot, outputPath)}`;
+            return `{workspaceRoot}/${(0, devkit_1.normalizePath)((0, node_path_1.relative)(workspaceRoot, outputPath))}`;
         }
         else {
             if (outputPath.startsWith('..')) {

package/dist/src/utils/ensure-dependencies.js

@@ -2,12 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ensureDependencies = ensureDependencies;
 const devkit_1 = require("@nx/devkit");
+const internal_1 = require("@nx/js/internal");
 const semver_1 = require("semver");
 const versions_1 = require("./versions");
 function ensureDependencies(host, schema) {
     const devDependencies = {};
     if (schema.uiFramework === 'react') {
         if (schema.compiler === 'swc') {
+            // @vitejs/plugin-react-swc depends on @swc/core.
+            (0, internal_1.acknowledgeSwcBuildScripts)(host);
             devDependencies['@vitejs/plugin-react-swc'] = versions_1.vitePluginReactSwcVersion;
         }
         else {

package/dist/src/utils/nx-tsconfig-paths-load-file.d.ts

@@ -0,0 +1,12 @@
+import { existsSync } from 'node:fs';
+import type { ConfigLoaderSuccessResult } from 'tsconfig-paths';
+/**
+ * Fallback resolver used when `tsconfig-paths` produces nothing that exists on
+ * disk, whether because no alias matched or because the match pointed at a
+ * missing file.
+ *
+ * A wildcard alias captures the suffix of the import and substitutes it into
+ * the `*` of each mapped path. The `*` is not always trailing, so the suffix
+ * cannot simply be appended.
+ */
+export declare function loadFileFromPaths(tsconfig: ConfigLoaderSuccessResult, importPath: string, extensions: string[], existsSyncImpl?: typeof existsSync): string;

package/dist/src/utils/nx-tsconfig-paths-load-file.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadFileFromPaths = loadFileFromPaths;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const nx_tsconfig_paths_find_file_1 = require("./nx-tsconfig-paths-find-file");
+/**
+ * Fallback resolver used when `tsconfig-paths` produces nothing that exists on
+ * disk, whether because no alias matched or because the match pointed at a
+ * missing file.
+ *
+ * A wildcard alias captures the suffix of the import and substitutes it into
+ * the `*` of each mapped path. The `*` is not always trailing, so the suffix
+ * cannot simply be appended.
+ */
+function loadFileFromPaths(tsconfig, importPath, extensions, existsSyncImpl = node_fs_1.existsSync) {
+    let resolvedFile;
+    for (const alias of sortAliasesBySpecificity(Object.keys(tsconfig.paths), importPath)) {
+        const paths = tsconfig.paths[alias];
+        const isWildcard = alias.endsWith('/*');
+        const normalizedImport = alias.replace(/\/\*$/, '');
+        if (importPath === normalizedImport ||
+            importPath.startsWith(normalizedImport + '/')) {
+            const suffix = importPath.slice(normalizedImport.length + 1);
+            for (const path of paths) {
+                // The replacements go through a function because a string replacement
+                // would expand `$&` and friends as substitution patterns.
+                const joinedPath = (0, node_path_1.join)(tsconfig.absoluteBaseUrl, isWildcard
+                    ? path.replace('*', () => suffix)
+                    : path.replace(/\/\*$/, ''));
+                const candidate = isWildcard
+                    ? joinedPath
+                    : importPath.replace(normalizedImport, () => joinedPath);
+                resolvedFile = (0, nx_tsconfig_paths_find_file_1.findFile)(candidate, extensions, existsSyncImpl);
+                // The candidate ends with the import's own tail only when the wildcard
+                // is last. Anything the mapped path appends after the `*`
+                // (`packages/foo/*.ts`) is the tail instead, so dropping an extension
+                // from it would resolve a sibling the mapping never pointed at.
+                const endsWithImportTail = !isWildcard || path.endsWith('*');
+                if (resolvedFile === undefined && endsWithImportTail) {
+                    const foundExtension = extensions.find((ext) => importPath.endsWith(ext));
+                    if (foundExtension) {
+                        resolvedFile = (0, nx_tsconfig_paths_find_file_1.findFile)(candidate.slice(0, -foundExtension.length), extensions, existsSyncImpl);
+                    }
+                }
+                if (resolvedFile !== undefined) {
+                    return resolvedFile;
+                }
+            }
+        }
+    }
+    return resolvedFile;
+}
+/**
+ * TypeScript picks between competing aliases by specificity, never by
+ * declaration order: an exact hit on a non-wildcard alias first, then the
+ * longest wildcard prefix.
+ */
+function sortAliasesBySpecificity(aliases, importPath) {
+    const isWildcard = (alias) => alias.endsWith('/*');
+    const rank = (alias) => isWildcard(alias) ? 1 : importPath === alias ? 2 : 0;
+    const prefixLength = (alias) => alias.replace(/\/\*$/, '').length;
+    return [...aliases].sort((a, b) => {
+        const byRank = rank(b) - rank(a);
+        if (byRank !== 0)
+            return byRank;
+        // Prefix length only separates wildcards. Reordering two aliases
+        // TypeScript matches neither way would change resolution for no gain.
+        return isWildcard(a) ? prefixLength(b) - prefixLength(a) : 0;
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/vite",
-  "version": "23.3.0-pr.37068.f95e11e",
+  "version": "23.3.0-rc.0",
   "private": false,
   "type": "commonjs",
   "files": [
@@ -94,19 +94,19 @@
     "supportsOptionalMigrations": true
   },
   "dependencies": {
+    "@nx/devkit": "23.3.0-rc.0",
     "@phenomnomnominal/tsquery": "~6.2.0",
+    "@nx/js": "23.3.0-rc.0",
+    "@nx/vitest": "23.3.0-rc.0",
     "picomatch": "4.0.4",
     "tsconfig-paths": "^4.1.2",
     "semver": "^7.6.3",
     "tslib": "^2.3.0",
-    "ajv": "^8.0.0",
-    "@nx/devkit": "23.3.0-pr.37068.f95e11e",
-    "@nx/js": "23.3.0-pr.37068.f95e11e",
-    "@nx/vitest": "23.3.0-pr.37068.f95e11e"
+    "ajv": "^8.0.0"
   },
   "devDependencies": {
-    "@nx/eslint": "23.3.0-pr.37068.f95e11e",
-    "nx": "23.3.0-pr.37068.f95e11e"
+    "@nx/eslint": "23.3.0-rc.0",
+    "nx": "23.3.0-rc.0"
   },
   "peerDependencies": {
     "vite": "^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0"

package/readme-template.md

@@ -0,0 +1,18 @@
+<p style="text-align: center;">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/nrwl/nx/master/images/nx-dark.svg">
+    <img alt="Nx - Smart Monorepos · Fast Builds" src="https://raw.githubusercontent.com/nrwl/nx/master/images/nx-light.svg" width="100%">
+  </picture>
+</p>
+
+{{links}}
+
+<hr>
+
+# Nx: Smart Monorepos · Fast Builds
+
+Get to green PRs in half the time. Nx optimizes your builds, scales your CI, and fixes failed PRs. Built for developers and AI agents.
+
+This package is a [Vite plugin for Nx](https://nx.dev/nx-api/vite).
+
+{{content}}