vinext 1.3.0 → 1.3.1

package/dist/shims/internal/app-route-prefetch-policy.js

@@ -1,5 +1,7 @@
 import { stripBasePath } from "../../utils/base-path.js";
-import { createRouteTrieCache, matchRouteWithTrie } from "../../routing/route-matching.js";
+import { splitPathSegments } from "../../routing/utils.js";
+import { createRouteTrieCache, matchRouteWithTrie, matchRouteWithTrieRawPathname } from "../../routing/route-matching.js";
+import { matchRoutePatternPrefix, matchRoutePatternRaw } from "../../routing/route-pattern.js";
 //#region src/shims/internal/app-route-prefetch-policy.ts
 /** basePath from next.config.js, injected by the plugin at build time */
 const __basePath = process.env.__NEXT_ROUTER_BASEPATH ?? "";
@@ -27,7 +29,28 @@ const NO_APP_ROUTE_PREFETCH = {
 function canAutoPrefetchFullAppRoute(href) {
 	return resolveAutoAppRoutePrefetch(href).cacheForNavigation;
 }
-function resolveAutoAppRoutePrefetch(href) {
+/**
+* Whether the page the href renders is dynamic. Under an interception context
+* that one of the route's intercepting pages matches, that page renders
+* instead, and Next.js classifies it as its own route. When several match,
+* any dynamic one counts. The intercepted response also renders the route the
+* context resolves to, which can be a dynamic descendant of the intercept's
+* source, so that route counts too.
+*/
+function resolveRendersDynamically(routes, route, interceptionContext, pathname) {
+	if (interceptionContext !== null && route.intercepts) {
+		const pathParts = splitPathSegments(pathname);
+		const contextParts = splitPathSegments(interceptionContext);
+		const matching = route.intercepts.filter((intercept) => matchRoutePatternRaw(pathParts, intercept.targetPatternParts) !== null && matchRoutePatternPrefix(contextParts, intercept.sourcePatternParts));
+		if (matching.length > 0) return matching.some((intercept) => intercept.rendersDynamically === true) || matchRouteWithTrieRawPathname(interceptionContext, routes, linkPrefetchRouteTrieCache)?.route.rendersDynamically === true;
+	}
+	return route.rendersDynamically === true;
+}
+/**
+* `interceptionContext` is the prefetch's interception context
+* (`getPrefetchInterceptionContext`).
+*/
+function resolveAutoAppRoutePrefetch(href, interceptionContext = null) {
 	if (typeof window === "undefined") return NO_APP_ROUTE_PREFETCH;
 	const routes = window.__VINEXT_LINK_PREFETCH_ROUTES__;
 	if (!routes) return NO_APP_ROUTE_PREFETCH;
@@ -42,12 +65,14 @@ function resolveAutoAppRoutePrefetch(href) {
 	const hasSearchParams = routeUrl.search !== "";
 	const isFullyDynamicRootRoute = route.patternParts.length === 1 && route.patternParts[0]?.startsWith(":");
 	const hasCacheComponentsLearningOnlyDynamicPath = route.isDynamic && String(process.env.__NEXT_CACHE_COMPONENTS) === "true" && (ENCODED_PATH_DELIMITER_RE.test(routeUrl.pathname) || isFullyDynamicRootRoute && !requiresRouteTreePrefetch);
-	const cacheForNavigation = !hasSearchParams && !hasCacheComponentsLearningOnlyDynamicPath && (requiresRouteTreePrefetch || !route.canPrefetchLoadingShell && route.requiresDynamicNavigationRequest !== true);
+	const rendersDynamically = resolveRendersDynamically(routes, route, interceptionContext, routeUrl.pathname);
+	const cacheForNavigation = !hasSearchParams && !hasCacheComponentsLearningOnlyDynamicPath && (requiresRouteTreePrefetch || !route.canPrefetchLoadingShell && route.requiresDynamicNavigationRequest !== true && !rendersDynamically);
 	return {
 		cacheForNavigation,
-		dynamicStaleTime: cacheForNavigation ? "verbatim" : "ignore",
+		dynamicStaleTime: !cacheForNavigation ? "ignore" : String(process.env.__NEXT_CACHE_COMPONENTS) === "true" ? "verbatim" : "learning-only",
 		fallbackTtl: "static",
 		prefetchShellFirst: requiresRouteTreePrefetch || hasSearchParams || !route.isDynamic,
+		...rendersDynamically ? { rendersDynamically: true } : {},
 		...requiresRouteTreePrefetch ? { requiresRouteTreePrefetch: true } : {},
 		shouldPrefetch: true
 	};

package/dist/shims/internal/cache-context-accessor.d.ts

@@ -13,4 +13,5 @@ export declare function _registerCacheContextAccessor(fn: () => CacheContextLike
 export declare function getRegisteredCacheContext(): CacheContextLike | null;
 /** Record a root-param dependency on the active public `"use cache"` scope. */
 export declare function _recordUseCacheRootParamRead(name: string): void;
-//#endregion
+//#endregion
+export {};

package/dist/shims/internal/client-reference-loader.d.ts

@@ -0,0 +1,7 @@
+//#region src/shims/internal/client-reference-loader.d.ts
+type ClientReferenceExports = Record<string, unknown>;
+export declare function registerClientReference(key: string, exports: ClientReferenceExports): void;
+/** What @vitejs/plugin-rsc/browser calls as `clientReferences.default[key]()`. */
+export declare const clientReferences: Record<string, () => Promise<ClientReferenceExports>>;
+//#endregion
+export {};

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

@@ -64,6 +64,8 @@ export declare function onRenderDynamicLatched(listener: () => void): () => void
 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". */

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

@@ -102,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 */
@@ -166,4 +171,4 @@ function getHeadersAccessPhase() {
 	return getHeadersShimState().phase;
 }
 //#endregion
-export { createRenderDynamicLatch, createUseCacheAccessError, getHeadersAccessPhase, getHeadersShimState, headersShimAls, isInsideAnyCacheScope, isRenderDynamicLatched, markDynamicUsage, markRenderRequestApiUsage, onRenderDynamicLatched, recordInvalidDynamicUsageError, 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

@@ -18,4 +18,5 @@ export declare function resolveSameOriginAppPathname(href: string, basePath: str
 export declare function matchDirectHybridClientRoutes(href: string, basePath: string): HybridClientRouteMatches;
 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/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 {};