vinext 1.3.0 → 1.4.0

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/navigation-untracked.js

@@ -1,5 +1,5 @@
-import { getNavigationContext } from "../navigation-context-state.js";
 import { getPagesNavigationContext } from "./pages-router-accessor.js";
+import { getNavigationContext } from "../navigation-context-state.js";
 import { getClientNavigationState, useClientNavigationRenderSnapshot } from "../navigation.js";
 //#region src/shims/internal/navigation-untracked.ts
 /**

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 {};