vinext 1.2.1 → 1.3.0

package/dist/utils/client-runtime-metadata.js

@@ -1,10 +1,20 @@
 import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import { isAbsoluteAssetPrefix, resolveAssetsDir } from "./asset-prefix.js";
-import { manifestFileWithAssetPrefix, manifestFileWithBase } from "./manifest-paths.js";
+import { isSharedClientChunkName, manifestFileWithAssetPrefix, manifestFileWithBase } from "./manifest-paths.js";
 import { findClientEntryFileFromVinextManifest, findPagesClientEntryFileFromVinextManifest, readClientEntryManifest } from "./client-entry-manifest.js";
 import { findClientEntryFile, findPagesClientEntryFile, readClientBuildManifest } from "./client-build-manifest.js";
 import { computeDynamicImportPreloads, computeLazyChunks, dynamicImportPreloadsWithBase } from "./lazy-chunks.js";
 //#region src/utils/client-runtime-metadata.ts
+/**
+* Shared Pages Router chunk files, keyed on Rolldown chunk names rather than
+* emitted file names so user-configured `chunkFileNames` (e.g. hash-only
+* patterns) keep their modulepreload/script tags.
+*/
+function collectSharedChunkFiles(buildManifest, applyBase) {
+	const files = /* @__PURE__ */ new Set();
+	for (const chunk of Object.values(buildManifest)) if (chunk.file.endsWith(".js") && isSharedClientChunkName(chunk.name)) files.add(applyBase(chunk.file));
+	return files.size > 0 ? [...files] : void 0;
+}
 function collectCssGraph(buildManifest, applyBase) {
 	const cssGraph = {};
 	for (const [key, chunk] of Object.entries(buildManifest)) {
@@ -74,7 +84,10 @@ function computeClientRuntimeMetadata(opts) {
 		if (entry) metadata.clientEntryFile = entry;
 	}
 	if (!buildManifest) return metadata;
-	if (opts.includeClientEntry) metadata.cssGraph = collectCssGraph(buildManifest, (file) => manifestFileWithBase(file, opts.assetBase));
+	if (opts.includeClientEntry) {
+		metadata.cssGraph = collectCssGraph(buildManifest, (file) => manifestFileWithBase(file, opts.assetBase));
+		metadata.sharedChunks = collectSharedChunkFiles(buildManifest, (file) => manifestFileWithBase(file, opts.assetBase));
+	}
 	metadata.appBootstrapPreinitModules = collectAppBootstrapPreinitModules(buildManifest, clientEntryManifest?.appBrowserEntry, (file) => {
 		const url = manifestFileWithAssetPrefix(file, opts.assetBase, opts.assetPrefix);
 		return isAbsoluteAssetPrefix(opts.assetPrefix) ? url : "/" + url;

package/dist/utils/lazy-chunks.d.ts

@@ -4,6 +4,10 @@
  */
 export type BuildManifestChunk = {
   file: string;
+  /** Source module id (or virtual id) of an entry chunk. */
+  src?: string;
+  /** Rolldown chunk name, independent of the configured output file name. */
+  name?: string;
   isEntry?: boolean;
   isDynamicEntry?: boolean;
   imports?: string[];

package/dist/utils/manifest-paths.d.ts

@@ -26,4 +26,18 @@ export declare function assetServingUrlFromBaseAnchored(value: string, basePath:
  * `<base>/<base>/` prefix is collapsed; a single prefix is left untouched.
  */
 export declare function collapseDuplicateBase(file: string, base: string): string;
+/**
+ * Whether a Rolldown chunk belongs to the shared Pages Router runtime, judged
+ * by its exact chunk name rather than its emitted file name so user-configured
+ * or hash-only `chunkFileNames` keep their modulepreload/script tags.
+ */
+export declare function isSharedClientChunkName(name: string | undefined): boolean;
+/**
+ * Reserved `ssr-manifest.json` key listing the shared runtime chunk files.
+ * Consumers that pass the on-disk manifest straight to `renderPage()` (the
+ * legacy two-call Pages build) have no registered build metadata, and file
+ * names alone can't identify these chunks. The `\0` prefix keeps it from
+ * matching any module id.
+ */
+export declare const SSR_MANIFEST_SHARED_CHUNKS_KEY = "\0vinext:shared-chunks";
 //#endregion

package/dist/utils/manifest-paths.js

@@ -62,5 +62,26 @@ function collapseDuplicateBase(file, base) {
 	const doubledPrefix = `${normalizedBase}/${normalizedBase}/`;
 	return normalizedFile.startsWith(doubledPrefix) ? normalizedFile.slice(normalizedBase.length + 1) : normalizedFile;
 }
+const SHARED_CHUNK_NAMES = /* @__PURE__ */ new Set([
+	"framework",
+	"vinext",
+	"vinext-client-entry"
+]);
+/**
+* Whether a Rolldown chunk belongs to the shared Pages Router runtime, judged
+* by its exact chunk name rather than its emitted file name so user-configured
+* or hash-only `chunkFileNames` keep their modulepreload/script tags.
+*/
+function isSharedClientChunkName(name) {
+	return name !== void 0 && SHARED_CHUNK_NAMES.has(name);
+}
+/**
+* Reserved `ssr-manifest.json` key listing the shared runtime chunk files.
+* Consumers that pass the on-disk manifest straight to `renderPage()` (the
+* legacy two-call Pages build) have no registered build metadata, and file
+* names alone can't identify these chunks. The `\0` prefix keeps it from
+* matching any module id.
+*/
+const SSR_MANIFEST_SHARED_CHUNKS_KEY = "\0vinext:shared-chunks";
 //#endregion
-export { assetServingUrlFromBaseAnchored, collapseDuplicateBase, manifestFileWithAssetPrefix, manifestFileWithBase };
+export { SSR_MANIFEST_SHARED_CHUNKS_KEY, assetServingUrlFromBaseAnchored, collapseDuplicateBase, isSharedClientChunkName, manifestFileWithAssetPrefix, manifestFileWithBase };

package/dist/utils/path-to-regexp.d.ts

@@ -0,0 +1,21 @@
+//#region src/utils/path-to-regexp.d.ts
+export type PathToken = string | PathKey;
+export type PathKey = {
+  name: string | number;
+  prefix: string;
+  suffix: string;
+  pattern: string;
+  modifier: string;
+};
+export type ParsePathPatternOptions = {
+  /** Characters a default param cannot contain. path-to-regexp defaults to `/#?`. */
+  delimiter?: string;
+};
+export declare function parsePathPattern(value: string, options?: ParsePathPatternOptions): PathToken[];
+export declare function normalizePathTokens(tokens: PathToken[]): PathToken[];
+/**
+ * path-to-regexp's `tokensToRegexp` with `strict: true`, without the closing
+ * `$`. Callers append the ending their Next.js matcher uses.
+ */
+export declare function pathTokensToRegExpSource(tokens: PathToken[]): string;
+//#endregion

package/dist/{server/middleware-path-to-regexp.js → utils/path-to-regexp.js}

@@ -1,4 +1,4 @@
-//#region src/server/middleware-path-to-regexp.ts
+//#region src/utils/path-to-regexp.ts
 function lexer(value) {
 	const tokens = [];
 	let index = 0;
@@ -101,11 +101,12 @@ function lexer(value) {
 	});
 	return tokens;
 }
-function parseMiddlewarePath(value) {
+function parsePathPattern(value, options = {}) {
 	const tokens = lexer(value);
 	const result = [];
 	const prefixes = "./";
-	const delimiter = "/#?";
+	const delimiter = options.delimiter ?? "/#?";
+	const delimiterClass = `[^${escapeRegex(delimiter)}]`;
 	let key = 0;
 	let index = 0;
 	let path = "";
@@ -135,8 +136,8 @@ function parseMiddlewarePath(value) {
 			const name = typeof previous === "string" ? previous : previous.name;
 			throw new TypeError(`Must have text between two parameters, missing text after "${name}"`);
 		}
-		if (!previousText || containsDelimiter(previousText)) return "[^\\/#\\?]+?";
-		return `(?:(?!${escapeRegex(previousText)})[^\\/#\\?])+?`;
+		if (!previousText || containsDelimiter(previousText)) return `${delimiterClass}+?`;
+		return `(?:(?!${escapeRegex(previousText)})${delimiterClass})+?`;
 	};
 	while (index < tokens.length) {
 		const character = tryConsume("CHAR");
@@ -192,7 +193,7 @@ function parseMiddlewarePath(value) {
 function escapeRegex(value) {
 	return value.replace(/([.+*?=^!:${}()[\]|/\\])/g, "\\$1");
 }
-function normalizeMiddlewarePathTokens(tokens) {
+function normalizePathTokens(tokens) {
 	return tokens.map((token) => {
 		if (typeof token === "object" && (token.modifier === "*" || token.modifier === "+") && token.prefix === "" && token.suffix === "") return {
 			...token,
@@ -201,8 +202,11 @@ function normalizeMiddlewarePathTokens(tokens) {
 		return token;
 	});
 }
-function middlewarePathTokensToRegExp(tokens) {
-	const delimiterRegex = `[${escapeRegex("/#?")}]`;
+/**
+* path-to-regexp's `tokensToRegexp` with `strict: true`, without the closing
+* `$`. Callers append the ending their Next.js matcher uses.
+*/
+function pathTokensToRegExpSource(tokens) {
 	let route = "^";
 	for (const token of tokens) {
 		if (typeof token === "string") {
@@ -223,8 +227,7 @@ function middlewarePathTokensToRegExp(tokens) {
 			}
 		} else route += `(?:${prefix}${suffix})${token.modifier}`;
 	}
-	route += `${delimiterRegex}?$`;
-	return new RegExp(route);
+	return route;
 }
 //#endregion
-export { middlewarePathTokensToRegExp, normalizeMiddlewarePathTokens, parseMiddlewarePath };
+export { normalizePathTokens, parsePathPattern, pathTokensToRegExpSource };

package/dist/utils/plugin-react-version.d.ts

@@ -0,0 +1,15 @@
+//#region src/utils/plugin-react-version.d.ts
+/**
+ * Resolve @vitejs/plugin-react from the project, falling back to vinext's own
+ * install when the project has none or reaches an unsupported version.
+ * Returns null when it is not installed, and throws when every copy found is
+ * unsupported.
+ */
+export declare function resolvePluginReactPath(projectRoot: string, fallbackFrom?: string): string | null;
+/**
+ * The @vitejs/plugin-react upgrade vinext init must install before vinext.
+ * A declared copy below the floor conflicts with vinext's peer range: npm stops
+ * with ERESOLVE, and pnpm installs but vinext refuses to start.
+ */
+export declare function getPluginReactUpgradeDeps(root: string): string[];
+//#endregion

package/dist/utils/plugin-react-version.js

@@ -0,0 +1,64 @@
+import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
+import { findPackageVersion, isVersionBelow } from "./react-version.js";
+import { createRequire } from "node:module";
+import fs from "node:fs";
+//#region src/utils/plugin-react-version.ts
+const MINIMUM_PLUGIN_REACT_VERSION = [
+	5,
+	1,
+	4
+];
+function resolveFrom(from) {
+	try {
+		const resolved = createRequire(from).resolve("@vitejs/plugin-react");
+		return {
+			path: resolved,
+			version: findPackageVersion(resolved, "@vitejs/plugin-react")
+		};
+	} catch {
+		return null;
+	}
+}
+function isSupported(plugin) {
+	return plugin.version !== null && !isVersionBelow(plugin.version, MINIMUM_PLUGIN_REACT_VERSION);
+}
+/**
+* Resolve @vitejs/plugin-react from the project, falling back to vinext's own
+* install when the project has none or reaches an unsupported version.
+* Returns null when it is not installed, and throws when every copy found is
+* unsupported.
+*/
+function resolvePluginReactPath(projectRoot, fallbackFrom = import.meta.url) {
+	const project = resolveFrom(path.join(projectRoot, "package.json"));
+	if (project && isSupported(project)) return project.path;
+	const fallback = resolveFrom(fallbackFrom);
+	if (fallback && isSupported(fallback)) {
+		if (project) console.warn(`[vinext] Ignoring @vitejs/plugin-react ${project.version ?? "(unknown version)"} at ${project.path}: vinext requires ${MINIMUM_PLUGIN_REACT_VERSION.join(".")} or newer. Using ${fallback.version} instead. Add @vitejs/plugin-react to your app's devDependencies to choose the version explicitly.`);
+		return fallback.path;
+	}
+	const found = project ?? fallback;
+	if (!found) return null;
+	throw new Error(`vinext: @vitejs/plugin-react ${MINIMUM_PLUGIN_REACT_VERSION.join(".")} or newer is required (found ${found.version ?? "an unknown version"} at ${found.path}). Add @vitejs/plugin-react@^6 to your app's devDependencies.`);
+}
+/**
+* The @vitejs/plugin-react upgrade vinext init must install before vinext.
+* A declared copy below the floor conflicts with vinext's peer range: npm stops
+* with ERESOLVE, and pnpm installs but vinext refuses to start.
+*/
+function getPluginReactUpgradeDeps(root) {
+	const manifest = path.join(root, "package.json");
+	let declared;
+	try {
+		const pkg = JSON.parse(fs.readFileSync(manifest, "utf-8"));
+		declared = pkg.dependencies?.["@vitejs/plugin-react"] ?? pkg.devDependencies?.["@vitejs/plugin-react"];
+	} catch {
+		return [];
+	}
+	if (typeof declared !== "string") return [];
+	const major = /^[~^]?(\d+)(?:\.(?:\d+|[x*])){0,2}$/.exec(declared.trim())?.[1];
+	if (major !== void 0 && Number(major) < MINIMUM_PLUGIN_REACT_VERSION[0]) return ["@vitejs/plugin-react@latest"];
+	const installed = resolveFrom(manifest);
+	return installed && (!isSupported(installed) || installed.version?.includes("-")) ? ["@vitejs/plugin-react@latest"] : [];
+}
+//#endregion
+export { getPluginReactUpgradeDeps, resolvePluginReactPath };

package/dist/utils/public-routes.d.ts

@@ -1,3 +1,5 @@
 //#region src/utils/public-routes.d.ts
 export declare function scanPublicFileRoutes(root: string, configuredPublicDir?: string | false): string[];
+/** List the files in the public directory as `/`-prefixed relative paths. */
+export declare function scanPublicFiles(root: string, configuredPublicDir?: string | false): string[];
 //#endregion

package/dist/utils/public-routes.js

@@ -3,10 +3,14 @@ import { publicFileRouteKey } from "./public-file-path.js";
 import fs from "node:fs";
 //#region src/utils/public-routes.ts
 function scanPublicFileRoutes(root, configuredPublicDir = "public") {
+	return [...new Set(scanPublicFiles(root, configuredPublicDir).map(publicFileRouteKey))].sort();
+}
+/** List the files in the public directory as `/`-prefixed relative paths. */
+function scanPublicFiles(root, configuredPublicDir = "public") {
 	if (configuredPublicDir === false || configuredPublicDir === "") return [];
 	const publicDir = path.resolve(root, configuredPublicDir);
-	const routes = [];
-	const visitedDirs = /* @__PURE__ */ new Set();
+	const files = [];
+	const ancestorDirs = /* @__PURE__ */ new Set();
 	function walk(dir) {
 		let realDir;
 		try {
@@ -14,8 +18,15 @@ function scanPublicFileRoutes(root, configuredPublicDir = "public") {
 		} catch {
 			return;
 		}
-		if (visitedDirs.has(realDir)) return;
-		visitedDirs.add(realDir);
+		if (ancestorDirs.has(realDir)) return;
+		ancestorDirs.add(realDir);
+		try {
+			walkEntries(dir);
+		} finally {
+			ancestorDirs.delete(realDir);
+		}
+	}
+	function walkEntries(dir) {
 		const entries = fs.readdirSync(dir, { withFileTypes: true });
 		for (const entry of entries) {
 			const fullPath = path.join(dir, entry.name);
@@ -37,13 +48,13 @@ function scanPublicFileRoutes(root, configuredPublicDir = "public") {
 				if (!stat.isFile()) continue;
 			} else if (!entry.isFile()) continue;
 			const relativePath = path.relative(publicDir, fullPath);
-			routes.push(publicFileRouteKey("/" + relativePath));
+			files.push("/" + relativePath);
 		}
 	}
 	if (fs.existsSync(publicDir)) try {
 		walk(publicDir);
 	} catch {}
-	return [...new Set(routes)].sort();
+	return files;
 }
 //#endregion
-export { scanPublicFileRoutes };
+export { scanPublicFileRoutes, scanPublicFiles };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vinext",
-  "version": "1.2.1",
+  "version": "1.3.0",
   "description": "Run Next.js apps on Vite. Drop-in replacement for the next CLI.",
   "homepage": "https://vinext.dev/",
   "license": "MIT",

package/dist/server/middleware-path-to-regexp.d.ts

@@ -1,13 +0,0 @@
-//#region src/server/middleware-path-to-regexp.d.ts
-export type MiddlewarePathToken = string | MiddlewarePathKey;
-export type MiddlewarePathKey = {
-  name: string | number;
-  prefix: string;
-  suffix: string;
-  pattern: string;
-  modifier: string;
-};
-export declare function parseMiddlewarePath(value: string): MiddlewarePathToken[];
-export declare function normalizeMiddlewarePathTokens(tokens: MiddlewarePathToken[]): MiddlewarePathToken[];
-export declare function middlewarePathTokensToRegExp(tokens: MiddlewarePathToken[]): RegExp;
-//#endregion

package/dist/utils/regex-safety.d.ts

@@ -1,17 +0,0 @@
-//#region src/utils/regex-safety.d.ts
-export type RegexSafetyIssue = "nested repetition" | "ambiguous alternatives under repetition" | "ambiguous sequence expansion" | "overlapping sequential repetition" | "analysis budget exceeded";
-/**
- * Whether a RegExp source declares a named group, which turns `\k<name>` into
- * a backreference. Escaped characters and character classes cannot open one.
- */
-export declare function mayHaveNamedGroups(pattern: string): boolean;
-/**
- * `namedGroups` must describe the whole compiled RegExp when `pattern` is only
- * a fragment of it. It defaults to scanning `pattern` itself.
- */
-export declare function analyzeRegexSafety(pattern: string, options?: {
-  ignoreCase?: boolean;
-  namedGroups?: boolean;
-}): RegexSafetyIssue | null;
-export declare function regexAtomsMayOverlap(left: string, right: string, ignoreCase?: boolean): boolean;
-//#endregion