vinext 1.1.0 → 1.2.0

package/dist/plugins/dynamic-preload-metadata.js

@@ -3,7 +3,8 @@ import { collectBindingNames, forEachAstChild, stringLiteralValue, walkAst } fro
 import { hasTrailingComma } from "../utils/has-trailing-comma.js";
 import { magicStringTransformResult } from "./transform-result.js";
 import { stripViteModuleQuery } from "../utils/path.js";
-import { relativeWithinRoot, tryRealpathSync } from "../build/ssr-manifest.js";
+import { isForeignNodeModule } from "../utils/package-name.js";
+import { relativeToRoot, relativeWithinRoot, tryRealpathSync } from "../build/ssr-manifest.js";
 import { parseAst } from "vite";
 import MagicString from "magic-string";
 //#region src/plugins/dynamic-preload-metadata.ts
@@ -204,7 +205,7 @@ function toManifestModuleId(root, resolvedId) {
 		const relative = relativeWithinRoot(rootCandidate, moduleCandidate);
 		if (relative) return relative;
 	}
-	return null;
+	return relativeToRoot(root, cleaned) || null;
 }
 async function resolveManifestModuleIds(specifiers, importer, root, resolveDynamicImport) {
 	const resolvedIds = [];
@@ -262,24 +263,24 @@ async function transformNextDynamicPreloadMetadata(code, id, root, resolveDynami
 	if (!changed) return null;
 	return magicStringTransformResult(output);
 }
-function createDynamicPreloadMetadataPlugin() {
+function createDynamicPreloadMetadataPlugin(getTranspiledPackages) {
 	let root = toSlash(process.cwd());
+	let isBuild = false;
 	return {
 		name: "vinext:dynamic-preload-metadata",
 		configResolved(config) {
 			root = config.root;
+			isBuild = config.command === "build";
 		},
 		transform: {
 			filter: {
-				id: {
-					include: /\.(tsx?|jsx?|mjs)$/,
-					exclude: /node_modules/
-				},
+				id: /\.(tsx?|jsx?|mjs)$/,
 				code: "next/dynamic"
 			},
 			async handler(code, id) {
-				if (id.includes("node_modules") || id.startsWith("\0")) return null;
+				if (id.startsWith("\0")) return null;
 				if (!/\.(tsx?|jsx?|mjs)$/.test(id)) return null;
+				if (id.includes("node_modules") && (!isBuild || isForeignNodeModule(id, getTranspiledPackages()))) return null;
 				const result = await transformNextDynamicPreloadMetadata(code, id, root, async (specifier, importer) => {
 					return (await this.resolve(specifier, importer, { skipSelf: true }))?.id ?? null;
 				});

package/dist/plugins/ignore-dynamic-requests.d.ts

@@ -11,7 +11,7 @@ import { Plugin } from "vite";
  * identifiers, falls through to the AST pass.
  */
 declare function mayContainVeryDynamicRequest(code: string): boolean;
-declare function transformVeryDynamicRequests(code: string, id: string): MagicStringTransformResult | null;
+declare function transformVeryDynamicRequests(code: string, id: string): MagicStringTransformResult<import("magic-string").SourceMap> | null;
 export declare function createIgnoreDynamicRequestsPlugin(getTranspiledPackages?: () => readonly string[]): Plugin;
 export declare const _transformVeryDynamicRequests: typeof transformVeryDynamicRequests;
 export declare const _mayContainVeryDynamicRequest: typeof mayContainVeryDynamicRequest;

package/dist/plugins/ignore-dynamic-requests.js

@@ -1,7 +1,8 @@
-import path, { toSlash } from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
+import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import { DYNAMIC_IMPORT_PRESCAN, SCRIPT_MODULE_ID_RE, collectBindingNames, forEachAstChild, isIdentifierNamed, mayContainDynamicImport, scriptParserLanguage, stringLiteralValue, unwrapExpression } from "./ast-utils.js";
 import { magicStringTransformResult, omitUnusedBuildSourcemap } from "./transform-result.js";
 import { stripViteModuleQuery } from "../utils/path.js";
+import { isForeignNodeModule } from "../utils/package-name.js";
 import { collectDirectScopeBindings, collectLoopScopeBindings, collectSwitchScopeBindings, collectVarScopeBindings, hasAstBinding, isFunctionNode } from "./ast-scope.js";
 import { createTransformCache } from "./transform-cache.js";
 import { fileURLToPath } from "node:url";
@@ -543,9 +544,7 @@ function createIgnoreDynamicRequestsPlugin(getTranspiledPackages = () => []) {
 }
 function shouldTransformVeryDynamicRequests(environment, id, transpiledPackages) {
 	if (environment.config.consumer === "server") return true;
-	const normalizedId = toSlash(id);
-	if (!normalizedId.includes("/node_modules/")) return false;
-	return !transpiledPackages.some((packageName) => normalizedId.includes(`/node_modules/${packageName}/`));
+	return isForeignNodeModule(id, transpiledPackages);
 }
 const _transformVeryDynamicRequests = transformVeryDynamicRequests;
 const _mayContainVeryDynamicRequest = mayContainVeryDynamicRequest;

package/dist/plugins/middleware-server-only.d.ts

@@ -29,10 +29,11 @@ import { Plugin } from "vite";
  *      to the tainted set. This propagates the taint along the import graph
  *      synchronously, before plugin-rsc's `order: "pre"` validate-imports
  *      handler sees the next `server-only` request.
- *   3. When a tainted module imports `server-only` in a non-RSC environment,
- *      short-circuit to the no-op shim path so plugin-rsc's filter (which
- *      matches the bare `^server-only$` specifier) never fires for that
- *      import.
+ *   3. When a tainted module imports `server-only` in a non-RSC server
+ *      environment, short-circuit to the no-op shim path so plugin-rsc's
+ *      filter (which matches the bare `^server-only$` specifier) never fires
+ *      for that import. Browser environments are skipped entirely, so the
+ *      client `server-only` validators still see every import there.
  *
  * The taint set is scoped to the middleware chain only — `server-only`
  * imports from anywhere else (including client component code traversing

package/dist/plugins/middleware-server-only.js

@@ -1,5 +1,6 @@
 import { toSlash } from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import { stripViteModuleQuery } from "../utils/path.js";
+import { isServerEnvironment } from "./environment.js";
 //#region src/plugins/middleware-server-only.ts
 /**
 * Allow `import 'server-only'` from neutral server targets (and any module
@@ -30,10 +31,11 @@ import { stripViteModuleQuery } from "../utils/path.js";
 *      to the tainted set. This propagates the taint along the import graph
 *      synchronously, before plugin-rsc's `order: "pre"` validate-imports
 *      handler sees the next `server-only` request.
-*   3. When a tainted module imports `server-only` in a non-RSC environment,
-*      short-circuit to the no-op shim path so plugin-rsc's filter (which
-*      matches the bare `^server-only$` specifier) never fires for that
-*      import.
+*   3. When a tainted module imports `server-only` in a non-RSC server
+*      environment, short-circuit to the no-op shim path so plugin-rsc's
+*      filter (which matches the bare `^server-only$` specifier) never fires
+*      for that import. Browser environments are skipped entirely, so the
+*      client `server-only` validators still see every import there.
 *
 * The taint set is scoped to the middleware chain only — `server-only`
 * imports from anywhere else (including client component code traversing
@@ -71,7 +73,8 @@ function createMiddlewareServerOnlyPlugin(options) {
 		resolveId: {
 			order: "pre",
 			async handler(id, importer, opts) {
-				if (this.environment?.name === "rsc") return;
+				const environment = this.environment;
+				if (!environment || !isServerEnvironment(environment) || environment.name === "rsc") return;
 				if (!importer) return;
 				if (!isTainted(importer) && !options.isNeutralServerModule?.(canonicalizeId(importer))) return;
 				if (id === "server-only") return {

package/dist/plugins/pages-node-externals.js

@@ -1,8 +1,8 @@
 import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import { SCRIPT_MODULE_ID_RE, mayContainDynamicImport, scriptParserLanguage, staticStringValue, walkAst } from "./ast-utils.js";
 import { canonicalizeFilePath, isPathInsideOrEqual, stripViteModuleQuery } from "../utils/path.js";
-import { packageNameFromSpecifier } from "../utils/package-name.js";
 import { isServerEnvironment } from "./environment.js";
+import { packageNameFromSpecifier } from "../utils/package-name.js";
 import fs from "node:fs";
 import { parseAst } from "vite";
 //#region src/plugins/pages-node-externals.ts

package/dist/plugins/rsc-scan-glob-imports.d.ts

@@ -0,0 +1,19 @@
+import { Plugin, ResolvedConfig } from "vite";
+import { RscPluginManager } from "@vitejs/plugin-rsc";
+//#region src/plugins/rsc-scan-glob-imports.d.ts
+/**
+ * @vitejs/plugin-rsc 0.5.36 and 0.5.37 reduce scan-build modules to their
+ * import specifiers with es-module-lexer v3, which reports template-literal
+ * dynamic imports as glob patterns (``import(`file://${p}`)`` becomes
+ * `"file://*"`). The scan then emits them as plain imports, which fail to
+ * resolve (e.g. in @module-federation/vite). Other versions skip these
+ * specifiers (0.5.38 via vitejs/vite-plugin-react#1506), so for the affected
+ * ones keep the specifiers that don't resolve external during the scan. A real
+ * module whose specifier contains `*` still resolves and stays in the scan
+ * graph. The scan's output is discarded, so nothing else changes.
+ */
+export declare function isRscScanGlobImportsAffected(version: string): boolean;
+export declare function createRscScanGlobImportsPlugin(options: {
+  getManager: (config: ResolvedConfig) => Promise<RscPluginManager | undefined>;
+}): Plugin;
+//#endregion

package/dist/plugins/rsc-scan-glob-imports.js

@@ -0,0 +1,50 @@
+import { isVersionBelow } from "../utils/react-version.js";
+//#region src/plugins/rsc-scan-glob-imports.ts
+/**
+* @vitejs/plugin-rsc 0.5.36 and 0.5.37 reduce scan-build modules to their
+* import specifiers with es-module-lexer v3, which reports template-literal
+* dynamic imports as glob patterns (``import(`file://${p}`)`` becomes
+* `"file://*"`). The scan then emits them as plain imports, which fail to
+* resolve (e.g. in @module-federation/vite). Other versions skip these
+* specifiers (0.5.38 via vitejs/vite-plugin-react#1506), so for the affected
+* ones keep the specifiers that don't resolve external during the scan. A real
+* module whose specifier contains `*` still resolves and stays in the scan
+* graph. The scan's output is discarded, so nothing else changes.
+*/
+function isRscScanGlobImportsAffected(version) {
+	return !isVersionBelow(version, [
+		0,
+		5,
+		36
+	]) && isVersionBelow(version, [
+		0,
+		5,
+		38
+	]);
+}
+function createRscScanGlobImportsPlugin(options) {
+	return {
+		name: "vinext:rsc-scan-glob-imports",
+		apply: "build",
+		enforce: "pre",
+		resolveId: {
+			filter: { id: /\*/ },
+			async handler(source, importer, resolveOptions) {
+				if (!(await options.getManager(this.environment.config))?.isScanBuild) return;
+				try {
+					const resolved = await this.resolve(source, importer, {
+						...resolveOptions,
+						skipSelf: true
+					});
+					if (resolved) return resolved;
+				} catch {}
+				return {
+					id: source,
+					external: true
+				};
+			}
+		}
+	};
+}
+//#endregion
+export { createRscScanGlobImportsPlugin, isRscScanGlobImportsAffected };