vinext 1.2.1 → 1.3.1

package/dist/shims/internal/client-reference-loader.js

@@ -0,0 +1,91 @@
+import { CLIENT_REFERENCE_CHUNK_KIND } from "../../utils/client-reference-chunks.js";
+//#region src/shims/internal/client-reference-loader.ts
+/**
+* Loads App Router client references in production builds from the chunks
+* their Flight rows name, as React's webpack binding does in Next.js. The
+* browser entry names none of those chunks, so its hash doesn't change when a
+* client reference is added or changes.
+*
+* React calls `__webpack_chunk_load__` for each chunk a reference's row names
+* (see server/app-client-reference-manifest.ts), and requires the reference
+* once they load. Its module chunk registers the reference as it evaluates
+* (see plugins/rsc-client-reference-loaders.ts). The other chunks load the way
+* Vite's preload helper loads a dynamic import's dependencies: JS chunks are
+* modulepreloaded, the module chunk evaluates once its stylesheets load, and
+* a failure dispatches `vite:preloadError`.
+*/
+const registered = /* @__PURE__ */ new Map();
+function registerClientReference(key, exports) {
+	registered.set(key, exports);
+}
+/** What @vitejs/plugin-rsc/browser calls as `clientReferences.default[key]()`. */
+const clientReferences = new Proxy({}, { get(_target, key) {
+	if (typeof key !== "string" || key === "then") return void 0;
+	return async () => {
+		const exports = registered.get(key);
+		if (!exports) throw new Error(`client reference not found '${key}'`);
+		return exports;
+	};
+} });
+function isLinked(href, stylesheet) {
+	for (const link of document.getElementsByTagName("link")) if (link.href === href && (!stylesheet || link.rel === "stylesheet")) return true;
+	return false;
+}
+function appendLink(url, stylesheet) {
+	const href = new URL(url, document.baseURI).href;
+	if (isLinked(href, stylesheet)) return null;
+	const link = document.createElement("link");
+	link.rel = stylesheet ? "stylesheet" : "modulepreload";
+	if (!stylesheet) link.as = "script";
+	link.crossOrigin = "";
+	link.href = href;
+	const nonceMeta = document.querySelector("meta[property=csp-nonce]");
+	const nonce = nonceMeta?.nonce || nonceMeta?.getAttribute("nonce");
+	if (nonce) link.setAttribute("nonce", nonce);
+	document.head.appendChild(link);
+	return link;
+}
+const stylesheets = /* @__PURE__ */ new Map();
+/**
+* Resolves once the stylesheet loads or fails. React keeps a failed chunk's
+* promise for the rest of the session, so rejecting would fail every client
+* reference that shares the stylesheet, even once the network recovers. As in
+* Next.js, a reference renders without a stylesheet that fails to load, and
+* `vite:preloadError` still lets the app reload the page.
+*/
+function loadStylesheet(url) {
+	const href = new URL(url, document.baseURI).href;
+	let loaded = stylesheets.get(href);
+	if (loaded) return loaded;
+	const link = appendLink(url, true);
+	loaded = link ? new Promise((resolve) => {
+		link.addEventListener("load", () => resolve());
+		link.addEventListener("error", () => {
+			const event = new Event("vite:preloadError", { cancelable: true });
+			event.payload = /* @__PURE__ */ new Error(`Unable to preload CSS for ${url}`);
+			window.dispatchEvent(event);
+			resolve();
+		});
+	}) : Promise.resolve();
+	stylesheets.set(href, loaded);
+	return loaded;
+}
+function loadChunk(chunkId) {
+	const url = chunkId.slice(1);
+	switch (chunkId[0]) {
+		case CLIENT_REFERENCE_CHUNK_KIND.module: {
+			const [file, ...css] = url.split("\n");
+			return Promise.all(css.map(loadStylesheet)).then(() => import(
+				/* @vite-ignore */
+				file
+));
+		}
+		case CLIENT_REFERENCE_CHUNK_KIND.preload:
+			appendLink(url, false);
+			return Promise.resolve();
+		default: return Promise.reject(/* @__PURE__ */ new Error(`[vinext] Unknown client reference chunk '${chunkId}'`));
+	}
+}
+globalThis["__webpack_chunk_load__"] = loadChunk;
+//#endregion
+export { clientReferences, registerClientReference };

package/dist/shims/internal/cookie-serialize.d.ts

@@ -44,4 +44,5 @@ export declare function validateCookieAttributeValue(value: string, attributeNam
  * mutating any internal state) via `validateCookieName`.
  */
 export declare function serializeSetCookie(name: string, value: string | null | undefined, options?: SerializeSetCookieOptions): string;
-//#endregion
+//#endregion
+export {};

package/dist/shims/internal/cookies.js

@@ -1,2 +1 @@
-import { RequestCookies, ResponseCookies } from "../server.js";
-export { RequestCookies, ResponseCookies };
+export { RequestCookies, ResponseCookies } from "../server.js";

package/dist/shims/internal/headers-state.d.ts

@@ -57,10 +57,19 @@ export declare function isRenderDynamicLatched(): boolean;
  * already latched; check `isRenderDynamicLatched()` first.
  */
 export declare function onRenderDynamicLatched(listener: () => void): () => void;
+/**
+ * Record an invalid dynamic API use on `state`, keeping the first one, like
+ * Next.js's `workStore.invalidDynamicUsageError ??= error`.
+ */
+export declare function recordInvalidDynamicUsageError(state: VinextHeadersShimState, error: unknown): void;
 export declare function markRenderRequestApiUsage(kind: RenderRequestApiKind): void;
 export declare function throwIfStaticGenerationAccessError(): void;
+/** Whether `error` is the error a `dynamic = "error"` render throws on a dynamic API read. */
+export declare function isStaticGenerationAccessError(error: unknown): error is Error;
 /** Whether work is executing inside a cache boundary that owns its reuse. */
 export declare function isInsideAnyCacheScope(): boolean;
+/** The error a dynamic request API throws inside a public "use cache". */
+export declare function createUseCacheAccessError(apiName: string): Error;
 /**
  * Throw if the current execution is inside a "use cache" or unstable_cache()
  * scope. Called by dynamic request APIs (headers, cookies, connection) to

package/dist/shims/internal/headers-state.js

@@ -87,6 +87,14 @@ function propagateInvalidDynamicUsageError(state, error) {
 		if (target.invalidDynamicUsageError == null) target.invalidDynamicUsageError = error;
 	});
 }
+/**
+* Record an invalid dynamic API use on `state`, keeping the first one, like
+* Next.js's `workStore.invalidDynamicUsageError ??= error`.
+*/
+function recordInvalidDynamicUsageError(state, error) {
+	state.invalidDynamicUsageError ??= error;
+	propagateInvalidDynamicUsageError(state, error);
+}
 function markRenderRequestApiUsage(kind) {
 	getHeadersShimState().renderRequestApiUsage.add(kind);
 }
@@ -94,6 +102,11 @@ function throwIfStaticGenerationAccessError() {
 	const accessError = getHeadersShimState().headersContext?.accessError;
 	if (accessError) throw accessError;
 }
+/** Whether `error` is the error a `dynamic = "error"` render throws on a dynamic API read. */
+function isStaticGenerationAccessError(error) {
+	const accessError = getHeadersShimState().headersContext?.accessError;
+	return accessError !== void 0 && error === accessError;
+}
 /** Symbol used by cache-runtime.ts to store the "use cache" ALS on globalThis */
 const _USE_CACHE_ALS_KEY = Symbol.for("vinext.cacheRuntime.contextAls");
 /** Symbol used by cache.ts to store the unstable_cache ALS on globalThis */
@@ -121,6 +134,10 @@ function _isInsideUnstableCache() {
 function isInsideAnyCacheScope() {
 	return _getUseCacheGuardContext() !== null || _isInsideUnstableCache();
 }
+/** The error a dynamic request API throws inside a public "use cache". */
+function createUseCacheAccessError(apiName) {
+	return /* @__PURE__ */ new Error(`\`${apiName}\` cannot be called inside "use cache". If you need this data inside a cached function, call \`${apiName}\` outside and pass the required data as an argument.`);
+}
 /**
 * Throw if the current execution is inside a "use cache" or unstable_cache()
 * scope. Called by dynamic request APIs (headers, cookies, connection) to
@@ -130,7 +147,7 @@ function isInsideAnyCacheScope() {
 */
 function throwIfInsideCacheScope(apiName) {
 	if (_isInsidePublicUseCache()) {
-		const error = /* @__PURE__ */ new Error(`\`${apiName}\` cannot be called inside "use cache". If you need this data inside a cached function, call \`${apiName}\` outside and pass the required data as an argument.`);
+		const error = createUseCacheAccessError(apiName);
 		try {
 			const cacheCtx = _getUseCacheGuardContext();
 			if (cacheCtx) cacheCtx.invalidDynamicUsageError = error;
@@ -154,4 +171,4 @@ function getHeadersAccessPhase() {
 	return getHeadersShimState().phase;
 }
 //#endregion
-export { createRenderDynamicLatch, getHeadersAccessPhase, getHeadersShimState, headersShimAls, isInsideAnyCacheScope, isRenderDynamicLatched, markDynamicUsage, markRenderRequestApiUsage, onRenderDynamicLatched, throwIfInsideCacheScope, throwIfStaticGenerationAccessError };
+export { createRenderDynamicLatch, createUseCacheAccessError, getHeadersAccessPhase, getHeadersShimState, headersShimAls, isInsideAnyCacheScope, isRenderDynamicLatched, isStaticGenerationAccessError, markDynamicUsage, markRenderRequestApiUsage, onRenderDynamicLatched, recordInvalidDynamicUsageError, throwIfInsideCacheScope, throwIfStaticGenerationAccessError };

package/dist/shims/internal/hybrid-client-route-owner-direct.d.ts

@@ -3,16 +3,20 @@ import { VinextLinkPrefetchRoute, VinextPagesLinkPrefetchRoute } from "../../cli
 export type HybridClientOwner = "app" | "document" | "pages";
 type HybridClientRouteMatches = {
   appMatch: VinextLinkPrefetchRoute | null;
+  /** A Pages Router URL under `/api`, which only API routes serve. */
+  pagesApiRequest: boolean;
   pagesMatch: VinextPagesLinkPrefetchRoute | null;
 };
 declare global {
   interface Window {
+    __VINEXT_APP_ROUTE_HANDLERS__?: VinextLinkPrefetchRoute[];
     __VINEXT_LINK_PREFETCH_ROUTES__?: VinextLinkPrefetchRoute[];
     __VINEXT_PAGES_LINK_PREFETCH_ROUTES__?: VinextPagesLinkPrefetchRoute[];
   }
 }
 export declare function resolveSameOriginAppPathname(href: string, basePath: string): string | null;
 export declare function matchDirectHybridClientRoutes(href: string, basePath: string): HybridClientRouteMatches;
-export declare function resolveMatchedHybridClientRouteOwner({ appMatch, pagesMatch }: HybridClientRouteMatches): HybridClientOwner | null;
+export declare function resolveMatchedHybridClientRouteOwner({ appMatch, pagesApiRequest, pagesMatch }: HybridClientRouteMatches): HybridClientOwner | null;
 export declare function resolveDirectHybridClientRouteOwner(href: string, basePath: string): HybridClientOwner | null;
-//#endregion
+//#endregion
+export {};

package/dist/shims/internal/hybrid-client-route-owner-direct.js

@@ -2,11 +2,11 @@ import { stripBasePath } from "../../utils/base-path.js";
 import { compareHybridRoutePatterns } from "../../routing/utils.js";
 import { createRouteTrieCache, matchRouteWithTrie } from "../../routing/route-matching.js";
 import { getLocalePathPrefix } from "../../utils/domain-locale.js";
+import { hashRoutePathname } from "../../routing/hashed-route-patterns.js";
 //#region src/shims/internal/hybrid-client-route-owner-direct.ts
 const appRouteTrieCache = createRouteTrieCache();
+const appRouteHandlerTrieCache = createRouteTrieCache();
 const pagesRouteTrieCache = createRouteTrieCache();
-const pagesPageRoutesCache = /* @__PURE__ */ new WeakMap();
-const pagesApiRoutesCache = /* @__PURE__ */ new WeakMap();
 function patternFromParts(parts) {
 	return "/" + parts.join("/");
 }
@@ -32,34 +32,51 @@ function resolveSameOriginPathnames(href, basePath) {
 function resolveSameOriginAppPathname(href, basePath) {
 	return resolveSameOriginPathnames(href, basePath)?.appPathname ?? null;
 }
-function selectPagesRoutes(routes, apiRequest) {
-	const cache = apiRequest ? pagesApiRoutesCache : pagesPageRoutesCache;
-	let selected = cache.get(routes);
-	if (!selected) {
-		selected = routes.filter((route) => Boolean(route.documentOnly) === apiRequest);
-		cache.set(routes, selected);
+function patternPartRank(part) {
+	if (part === void 0) return 0;
+	if (!part.startsWith(":")) return 1;
+	if (part.endsWith("+")) return 3;
+	if (part.endsWith("*")) return 4;
+	return 2;
+}
+/**
+* The route the App router picks when both match the same URL: the first part
+* whose kind differs decides, static > dynamic > catch-all > optional
+* catch-all, as in `routing/route-trie.ts`.
+*/
+function preferredAppRoute(page, handler) {
+	if (page === null || handler === null) return page ?? handler;
+	const length = Math.max(page.patternParts.length, handler.patternParts.length);
+	for (let index = 0; index < length; index++) {
+		const pageRank = patternPartRank(page.patternParts[index]);
+		const handlerRank = patternPartRank(handler.patternParts[index]);
+		if (pageRank !== handlerRank) return pageRank < handlerRank ? page : handler;
 	}
-	return selected;
+	return page;
 }
 function matchDirectHybridClientRoutes(href, basePath) {
 	const pathnames = resolveSameOriginPathnames(href, basePath);
 	if (pathnames === null) return {
 		appMatch: null,
+		pagesApiRequest: false,
 		pagesMatch: null
 	};
 	const appRoutes = window.__VINEXT_LINK_PREFETCH_ROUTES__;
+	const appRouteHandlers = window.__VINEXT_APP_ROUTE_HANDLERS__;
 	const pagesRoutes = window.__VINEXT_PAGES_LINK_PREFETCH_ROUTES__;
 	return {
-		appMatch: appRoutes ? matchRouteWithTrie(pathnames.appPathname, appRoutes, appRouteTrieCache)?.route ?? null : null,
-		pagesMatch: pagesRoutes ? matchRouteWithTrie(pathnames.pagesPathname, selectPagesRoutes(pagesRoutes, pathnames.pagesApiRequest), pagesRouteTrieCache)?.route ?? null : null
+		appMatch: preferredAppRoute(appRoutes ? matchRouteWithTrie(pathnames.appPathname, appRoutes, appRouteTrieCache)?.route ?? null : null, appRouteHandlers?.length ? matchRouteWithTrie(hashRoutePathname(pathnames.appPathname), appRouteHandlers, appRouteHandlerTrieCache)?.route ?? null : null),
+		pagesApiRequest: pathnames.pagesApiRequest,
+		pagesMatch: pagesRoutes && !pathnames.pagesApiRequest ? matchRouteWithTrie(pathnames.pagesPathname, pagesRoutes, pagesRouteTrieCache)?.route ?? null : null
 	};
 }
-function resolveMatchedHybridClientRouteOwner({ appMatch, pagesMatch }) {
+function resolveMatchedHybridClientRouteOwner({ appMatch, pagesApiRequest, pagesMatch }) {
+	if (pagesApiRequest) return appMatch?.isDynamic === false && !appMatch.documentOnly ? "app" : "document";
 	if (appMatch === null && pagesMatch === null) return null;
 	if (pagesMatch === null) return appMatch.documentOnly ? "document" : "app";
-	if (appMatch === null) return pagesMatch.documentOnly ? "document" : "pages";
+	if (appMatch === null) return "pages";
 	const owner = compareHybridRoutePatterns(patternFromParts(pagesMatch.patternParts), pagesMatch.isDynamic, patternFromParts(appMatch.patternParts), appMatch.isDynamic);
-	return (owner === "app" ? appMatch : pagesMatch).documentOnly ? "document" : owner;
+	return owner === "app" && appMatch.documentOnly ? "document" : owner;
 }
 function resolveDirectHybridClientRouteOwner(href, basePath) {
 	if (typeof window === "undefined") return null;

package/dist/shims/internal/hybrid-client-route-owner.js

@@ -64,23 +64,23 @@ function resolveHybridClientRewriteHref(href, basePath) {
 		didRewrite = true;
 	}
 	let matches = matchDirectHybridClientRoutes(currentHref, basePath);
-	if ((matches.appMatch === null || matches.appMatch.isDynamic) && (matches.pagesMatch === null || matches.pagesMatch.isDynamic)) for (const rewrite of rewrites.afterFiles) {
+	if (!matches.pagesApiRequest && (matches.appMatch === null || matches.appMatch.isDynamic) && (matches.pagesMatch === null || matches.pagesMatch.isDynamic)) for (const rewrite of rewrites.afterFiles) {
 		const afterFilesRewrite = resolveClientRewrite(currentHref, basePath, [rewrite]);
 		if (afterFilesRewrite?.kind === "document") return didRewrite ? currentHref : null;
 		if (afterFilesRewrite?.kind !== "rewrite") continue;
 		currentHref = afterFilesRewrite.href;
 		didRewrite = true;
 		matches = matchDirectHybridClientRoutes(currentHref, basePath);
-		if (matches.appMatch || matches.pagesMatch) break;
+		if (matches.pagesApiRequest || matches.appMatch || matches.pagesMatch) break;
 	}
-	if (matches.appMatch === null && matches.pagesMatch === null) for (const rewrite of rewrites.fallback) {
+	if (!matches.pagesApiRequest && matches.appMatch === null && matches.pagesMatch === null) for (const rewrite of rewrites.fallback) {
 		const fallbackRewrite = resolveClientRewrite(currentHref, basePath, [rewrite]);
 		if (fallbackRewrite?.kind === "document") return didRewrite ? currentHref : null;
 		if (fallbackRewrite?.kind !== "rewrite") continue;
 		currentHref = fallbackRewrite.href;
 		didRewrite = true;
 		matches = matchDirectHybridClientRoutes(currentHref, basePath);
-		if (matches.appMatch || matches.pagesMatch) break;
+		if (matches.pagesApiRequest || matches.appMatch || matches.pagesMatch) break;
 	}
 	return didRewrite ? currentHref : null;
 }
@@ -105,21 +105,21 @@ function resolveHybridClientRouteOwner(href, basePath) {
 		if (beforeFilesRewrite?.kind === "rewrite") href = beforeFilesRewrite.href;
 	}
 	let matches = matchDirectHybridClientRoutes(href, basePath);
-	if (rewrites && (matches.appMatch === null || matches.appMatch.isDynamic) && (matches.pagesMatch === null || matches.pagesMatch.isDynamic)) for (const rewrite of rewrites.afterFiles) {
+	if (rewrites && !matches.pagesApiRequest && (matches.appMatch === null || matches.appMatch.isDynamic) && (matches.pagesMatch === null || matches.pagesMatch.isDynamic)) for (const rewrite of rewrites.afterFiles) {
 		const afterFilesRewrite = resolveClientRewrite(href, basePath, [rewrite]);
 		if (afterFilesRewrite?.kind === "document") return "document";
 		if (afterFilesRewrite?.kind !== "rewrite") continue;
 		href = afterFilesRewrite.href;
 		matches = matchDirectHybridClientRoutes(href, basePath);
-		if (matches.appMatch || matches.pagesMatch) break;
+		if (matches.pagesApiRequest || matches.appMatch || matches.pagesMatch) break;
 	}
-	if (rewrites && matches.appMatch === null && matches.pagesMatch === null) for (const rewrite of rewrites.fallback) {
+	if (rewrites && !matches.pagesApiRequest && matches.appMatch === null && matches.pagesMatch === null) for (const rewrite of rewrites.fallback) {
 		const fallbackRewrite = resolveClientRewrite(href, basePath, [rewrite]);
 		if (fallbackRewrite?.kind === "document") return "document";
 		if (fallbackRewrite?.kind !== "rewrite") continue;
 		href = fallbackRewrite.href;
 		matches = matchDirectHybridClientRoutes(href, basePath);
-		if (matches.appMatch || matches.pagesMatch) break;
+		if (matches.pagesApiRequest || matches.appMatch || matches.pagesMatch) break;
 	}
 	return resolveMatchedHybridClientRouteOwner(matches);
 }

package/dist/shims/internal/interpolate-as.d.ts

@@ -36,4 +36,5 @@ export declare function interpolateDynamicRouteHref(routeHref: string, asHref: s
  * packages/next/src/client/resolve-href.ts.
  */
 export declare function resolveDynamicRouteHref(routeHref: string): DynamicRouteHrefResolution | null;
-//#endregion
+//#endregion
+export {};

package/dist/shims/internal/pages-data-target.d.ts

@@ -78,4 +78,5 @@ export declare function resolvePagesDataNavigationTarget(browserUrl: string, bas
  * best-effort and must never break the page.
  */
 export declare function prefetchPagesData(target: PagesDataTarget): void;
-//#endregion
+//#endregion
+export {};

package/dist/shims/internal/pages-data-url.d.ts

@@ -39,4 +39,5 @@ type PagesPatternMatch = {
  * client-side loader map, e.g. dev-only pages).
  */
 export declare function matchPagesPattern(pathname: string, patterns: readonly string[]): PagesPatternMatch | null;
-//#endregion
+//#endregion
+export {};

package/dist/shims/internal/thenable-well-known-properties.d.ts

@@ -7,4 +7,5 @@ export declare function isWellKnownProperty(prop: PropertyKey): boolean;
  * proxy, not the underlying promise, so they see the param keys.
  */
 export declare function isOwnPropertyCheck(prop: PropertyKey): boolean;
-//#endregion
+//#endregion
+export {};