vinext 0.1.8 → 0.2.1

package/dist/shims/internal/pages-data-fetch-dedup.js

@@ -1,4 +1,5 @@
-import "../../utils/deployment-id.js";
+import "../../utils/protocol-headers.js";
+import { getDeploymentId } from "../../utils/deployment-id.js";
 //#region src/shims/internal/pages-data-fetch-dedup.ts
 /**
 * In-flight request dedup for the Pages Router `/_next/data/<id>/<page>.json`
@@ -25,16 +26,87 @@ import "../../utils/deployment-id.js";
 *   directly by anyone, which keeps subsequent clones legal even after one
 *   caller has consumed its copy.
 *
-* - Each caller owns one waiter. Cancelling a waiter leaves the shared request
-*   alive while another waiter remains; cancelling the final waiter aborts the
-*   underlying fetch and evicts the entry immediately so a replacement caller
-*   can retry without joining a doomed request.
+* - Each caller owns one waiter. Cancelling a waiter rejects only that caller;
+*   the shared request continues and self-evicts when it settles. This mirrors
+*   Next.js: a superseded data request may still reach the server, but its
+*   result is ignored by the cancelled navigation.
 *
 * - The map is module-scoped (one per realm). The Pages Router runs in the
 *   browser only, so a single `Map` is sufficient.
 */
 /** Inflight fetch entries keyed by the resolved data request identity. */
 const inflight = /* @__PURE__ */ new Map();
+const staticDataCache = Object.create(null);
+const staticDataSources = /* @__PURE__ */ new Map();
+function getStaticDataKey(dataHref) {
+	if (typeof window === "undefined") return dataHref;
+	try {
+		return new URL(dataHref, window.location.href).href;
+	} catch {
+		return dataHref;
+	}
+}
+function cloneStaticResponse(cached, signal) {
+	if (signal?.aborted) return Promise.reject(new DOMException("Aborted", "AbortError"));
+	if (!signal) return cached.then((response) => response.clone());
+	return new Promise((resolve, reject) => {
+		const abort = () => reject(new DOMException("Aborted", "AbortError"));
+		signal.addEventListener("abort", abort, { once: true });
+		cached.then((response) => {
+			signal.removeEventListener("abort", abort);
+			resolve(response.clone());
+		}, (error) => {
+			signal.removeEventListener("abort", abort);
+			reject(error);
+		});
+	});
+}
+function getPagesStaticDataCache() {
+	return staticDataCache;
+}
+function fetchCachedPagesData(dataHref, init) {
+	const key = getStaticDataKey(dataHref);
+	let cached = staticDataSources.get(key);
+	if (cached === void 0) {
+		const { signal: _signal, ...sharedInit } = init ?? {};
+		cached = dedupedPagesDataFetch(dataHref, sharedInit).then((response) => {
+			const expectedDeploymentId = getDeploymentId() ?? null;
+			const responseDeploymentId = response.headers.get("x-nextjs-deployment-id");
+			if (!response.ok || response.headers.get("x-middleware-cache") === "no-cache" || response.headers.get("x-middleware-skip") !== null || responseDeploymentId !== null && responseDeploymentId !== expectedDeploymentId) {
+				delete staticDataCache[key];
+				staticDataSources.delete(key);
+			}
+			return response;
+		}).catch((error) => {
+			delete staticDataCache[key];
+			staticDataSources.delete(key);
+			throw error;
+		});
+		staticDataSources.set(key, cached);
+		const publicCached = cached.then((response) => response.clone());
+		publicCached.catch(() => {});
+		staticDataCache[key] = publicCached;
+	}
+	return cloneStaticResponse(cached, init?.signal ?? void 0);
+}
+function fetchStaticPagesData(dataHref, init) {
+	return fetchCachedPagesData(dataHref, init);
+}
+function fetchUncachedPagesData(dataHref, init) {
+	return fetch(dataHref, init).then(async (response) => {
+		const body = await response.arrayBuffer();
+		return new Response(body, {
+			headers: response.headers,
+			status: response.status,
+			statusText: response.statusText
+		});
+	});
+}
+function evictPagesDataCache(dataHref) {
+	const key = getStaticDataKey(dataHref);
+	delete staticDataCache[key];
+	staticDataSources.delete(key);
+}
 function getInflightKey(dataHref, init) {
 	let resolvedHref = dataHref;
 	if (typeof window !== "undefined") try {
@@ -47,27 +119,23 @@ function cloneSharedResponse(key, entry, signal) {
 	entry.waiters += 1;
 	return new Promise((resolve, reject) => {
 		let released = false;
-		const release = (cancelled) => {
+		const release = () => {
 			if (released) return;
 			released = true;
 			entry.waiters -= 1;
-			if (cancelled && entry.waiters === 0 && !entry.settled) {
-				if (inflight.get(key) === entry) inflight.delete(key);
-				entry.controller.abort();
-			}
 		};
 		const abort = () => {
-			release(true);
+			release();
 			reject(new DOMException("Aborted", "AbortError"));
 		};
 		signal?.addEventListener("abort", abort, { once: true });
 		entry.promise.then((response) => {
 			signal?.removeEventListener("abort", abort);
-			release(false);
+			release();
 			resolve(response.clone());
 		}, (error) => {
 			signal?.removeEventListener("abort", abort);
-			release(false);
+			release();
 			reject(error);
 		});
 	});
@@ -116,6 +184,8 @@ function dedupedPagesDataFetch(dataHref, init) {
 function clearPagesDataInflight() {
 	for (const entry of inflight.values()) entry.controller.abort();
 	inflight.clear();
+	staticDataSources.clear();
+	for (const key of Object.keys(staticDataCache)) delete staticDataCache[key];
 }
 //#endregion
-export { clearPagesDataInflight, dedupedPagesDataFetch };
+export { clearPagesDataInflight, dedupedPagesDataFetch, evictPagesDataCache, fetchCachedPagesData, fetchStaticPagesData, fetchUncachedPagesData, getPagesStaticDataCache };

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

@@ -1,15 +1,19 @@
 //#region src/shims/internal/pages-data-target.d.ts
 type PagesDataTarget = {
-  /** Final fetch URL for the data endpoint, including basePath and search. */dataHref: string; /** Matched route pattern (e.g. `/blog/[slug]`). */
+  /** Final fetch URL for the data endpoint, including basePath and search. */dataHref: string; /** Locale-qualified data endpoint used by Pages Router prefetch. */
+  prefetchDataHref?: string; /** Matched route pattern (e.g. `/blog/[slug]`). */
   pattern: string; /** Dynamic params extracted from the URL by the pattern matcher. */
   params: Record<string, string | string[]>; /** Code-split loader thunk for the matched route's page module. */
   loader: () => Promise<{
     default?: unknown;
     [key: string]: unknown;
-  }>; /** Current buildId snapshot, used by the data URL and consistency checks. */
+  }>; /** Next.js data-fetch mode for this route. Plain pages are component-only. */
+  dataKind: "none" | "server" | "static"; /** Middleware-effect data URL to prefetch when the static matcher includes this route. */
+  middlewareDataHref?: string; /** Current buildId snapshot, used by the data URL and consistency checks. */
   buildId: string; /** Locale-prefixed (server-routable) page path. */
   pagePath: string; /** URL search string including the leading `?`. */
-  search: string;
+  search: string; /** Locale selected for middleware-prefetch data URLs when the visible URL is unprefixed. */
+  prefetchLocale?: string;
   /**
    * Locale prefix detected on the URL, or `undefined` when the URL is
    * unprefixed (default locale, or no i18n configured). Lets the caller refresh
@@ -18,6 +22,10 @@ type PagesDataTarget = {
    */
   locale: string | undefined;
 };
+type PagesDataNavigationTargetOptions = {
+  locale?: string | false;
+};
+declare function getPagesMiddlewareDataHref(browserUrl: string, basePath: string): string | null;
 /**
  * Decide whether the JSON data-endpoint navigation path is usable for this
  * browser URL. We require:
@@ -41,16 +49,14 @@ type PagesDataTarget = {
  * (`getDataHref`). vinext's equivalent uses an in-memory loader map instead
  * of Next.js' `_buildManifest.js`.
  */
-declare function resolvePagesDataNavigationTarget(browserUrl: string, basePath: string): PagesDataTarget | null;
+declare function resolvePagesDataNavigationTarget(browserUrl: string, basePath: string, options?: PagesDataNavigationTargetOptions): PagesDataTarget | null;
 /**
- * Prefetch the data JSON and kick off the code-split loader so the chunk is
- * warm by the time the user clicks.
+ * Kick off the code-split loader and, for SSG pages, prefetch the data JSON so
+ * the chunk and payload are warm by the time the user clicks.
  *
- * Used by both `Router.prefetch()` and `<Link>` hover/viewport prefetch. The
- * JSON request uses `fetch()` rather than `<link rel="prefetch">` so it can
- * carry Next.js's `x-deployment-id` skew-protection header. The in-flight
- * request is shared with a racing navigation; after it settles, the browser's
- * normal HTTP cache remains responsible for reuse.
+ * Used by both `Router.prefetch()` and `<Link>` hover/viewport prefetch.
+ * Matches Next.js Pages Router prefetch: non-SSG routes only warm the page
+ * chunk, while `getStaticProps` routes also fetch `/_next/data`.
  *
  * loader's returned Promise is intentionally discarded — `import()` caches the
  * result, so a subsequent navigation re-invocation hits the cache without
@@ -59,4 +65,4 @@ declare function resolvePagesDataNavigationTarget(browserUrl: string, basePath:
  */
 declare function prefetchPagesData(target: PagesDataTarget): void;
 //#endregion
-export { PagesDataTarget, prefetchPagesData, resolvePagesDataNavigationTarget };
+export { PagesDataTarget, getPagesMiddlewareDataHref, prefetchPagesData, resolvePagesDataNavigationTarget };

package/dist/shims/internal/pages-data-target.js

@@ -1,8 +1,9 @@
-import { stripBasePath } from "../../utils/base-path.js";
+import { removeTrailingSlash, stripBasePath } from "../../utils/base-path.js";
+import { isUnknownRecord } from "../../utils/record.js";
 import { getLocalePathPrefix } from "../../utils/domain-locale.js";
 import { buildPagesDataHref, matchPagesPattern } from "./pages-data-url.js";
 import { NEXT_DEPLOYMENT_ID_HEADER, getDeploymentId } from "../../utils/deployment-id.js";
-import { dedupedPagesDataFetch } from "./pages-data-fetch-dedup.js";
+import { fetchStaticPagesData, fetchUncachedPagesData } from "./pages-data-fetch-dedup.js";
 //#region src/shims/internal/pages-data-target.ts
 /**
 * Shared decision helper for the Pages Router `/_next/data/<id>/<page>.json`
@@ -13,6 +14,75 @@ import { dedupedPagesDataFetch } from "./pages-data-fetch-dedup.js";
 * module init time — link.tsx and router.ts must remain free of circular
 * imports and SSR-side router-init side effects.
 */
+function hasVinextMiddleware(nextData) {
+	if (!isUnknownRecord(nextData)) return false;
+	const vinext = nextData.__vinext;
+	return isUnknownRecord(vinext) && vinext.hasMiddleware === true;
+}
+function isClientMiddlewareMatcherObject(value) {
+	if (!isUnknownRecord(value)) return false;
+	if (typeof value.source !== "string") return false;
+	if (value.locale !== void 0 && value.locale !== false) return false;
+	if (value.has !== void 0 && !Array.isArray(value.has)) return false;
+	if (value.missing !== void 0 && !Array.isArray(value.missing)) return false;
+	return true;
+}
+function stripLocaleForMiddlewareMatcher(pathname) {
+	const locales = window.__VINEXT_LOCALES__;
+	if (!locales || locales.length === 0 || pathname === "/") return pathname;
+	const firstSegment = pathname.split("/")[1];
+	if (!firstSegment || !locales.includes(firstSegment)) return pathname;
+	return "/" + pathname.split("/").slice(2).join("/");
+}
+function clientMiddlewareSourceMatches(pathname, source) {
+	if (!/[\\():*+?]/.test(source)) return removeTrailingSlash(pathname) === removeTrailingSlash(source);
+	if (source.includes("(") || source.includes("\\")) return true;
+	const sourceParts = source.split("/").filter(Boolean);
+	const pathParts = pathname.split("/").filter(Boolean);
+	let pathIndex = 0;
+	for (const sourcePart of sourceParts) {
+		if (sourcePart.startsWith(":")) {
+			if (sourcePart.endsWith("*")) return true;
+			if (sourcePart.endsWith("+")) return pathIndex < pathParts.length;
+			if (pathIndex >= pathParts.length) return false;
+			pathIndex++;
+			continue;
+		}
+		if (pathParts[pathIndex] !== sourcePart) return false;
+		pathIndex++;
+	}
+	return pathIndex === pathParts.length;
+}
+function clientMiddlewareMatcherMatches(pathname, matcher) {
+	if (matcher === void 0) return true;
+	if (typeof matcher === "string") return clientMiddlewareSourceMatches(stripLocaleForMiddlewareMatcher(pathname), matcher);
+	if (!Array.isArray(matcher)) return true;
+	for (const item of matcher) {
+		if (typeof item === "string") {
+			if (clientMiddlewareSourceMatches(stripLocaleForMiddlewareMatcher(pathname), item)) return true;
+			continue;
+		}
+		if (!isClientMiddlewareMatcherObject(item)) return true;
+		if (clientMiddlewareSourceMatches(item.locale === false ? pathname : stripLocaleForMiddlewareMatcher(pathname), item.source)) return true;
+	}
+	return false;
+}
+function getPagesMiddlewareDataHref(browserUrl, basePath) {
+	const nextData = window.__NEXT_DATA__;
+	if (!nextData || !hasVinextMiddleware(nextData)) return null;
+	const buildId = nextData.buildId;
+	if (typeof buildId !== "string" || buildId.length === 0) return null;
+	let parsed;
+	try {
+		parsed = new URL(browserUrl, window.location.href);
+	} catch {
+		return null;
+	}
+	if (parsed.origin !== window.location.origin) return null;
+	const pathname = stripBasePath(parsed.pathname, basePath);
+	if (!clientMiddlewareMatcherMatches(pathname, window.__VINEXT_MIDDLEWARE_MATCHER__)) return null;
+	return buildPagesDataHref(basePath, buildId, pathname, parsed.search);
+}
 /**
 * Decide whether the JSON data-endpoint navigation path is usable for this
 * browser URL. We require:
@@ -36,7 +106,7 @@ import { dedupedPagesDataFetch } from "./pages-data-fetch-dedup.js";
 * (`getDataHref`). vinext's equivalent uses an in-memory loader map instead
 * of Next.js' `_buildManifest.js`.
 */
-function resolvePagesDataNavigationTarget(browserUrl, basePath) {
+function resolvePagesDataNavigationTarget(browserUrl, basePath, options = {}) {
 	if (typeof window === "undefined") return null;
 	const loaders = window.__VINEXT_PAGE_LOADERS__;
 	const patterns = window.__VINEXT_PAGE_PATTERNS__;
@@ -56,26 +126,34 @@ function resolvePagesDataNavigationTarget(browserUrl, basePath) {
 	if (!match) return null;
 	const loader = loaders[match.pattern];
 	if (!loader) return null;
+	const ssgPatterns = window.__VINEXT_PAGES_SSG_PATTERNS__;
+	const sspPatterns = window.__VINEXT_PAGES_SSP_PATTERNS__;
+	const dataKind = ssgPatterns?.includes(match.pattern) ? "static" : sspPatterns?.includes(match.pattern) ? "server" : ssgPatterns === void 0 || sspPatterns === void 0 ? "server" : "none";
+	const explicitLocale = options.locale === false ? window.__VINEXT_DEFAULT_LOCALE__ : options.locale;
+	const currentLocale = locale ?? explicitLocale ?? window.__VINEXT_LOCALE__;
+	const prefetchPagePath = locale || !currentLocale || !window.__VINEXT_LOCALES__?.includes(currentLocale) ? pagePath : `/${currentLocale}${pagePath === "/" ? "" : pagePath}`;
 	return {
 		dataHref: buildPagesDataHref(basePath, buildId, pagePath, parsed.search),
+		prefetchDataHref: buildPagesDataHref(basePath, buildId, prefetchPagePath, parsed.search),
 		pattern: match.pattern,
 		params: match.params,
 		loader,
+		dataKind,
+		middlewareDataHref: getPagesMiddlewareDataHref(browserUrl, basePath) ?? void 0,
 		buildId,
 		pagePath,
 		search: parsed.search,
+		prefetchLocale: currentLocale,
 		locale
 	};
 }
 /**
-* Prefetch the data JSON and kick off the code-split loader so the chunk is
-* warm by the time the user clicks.
+* Kick off the code-split loader and, for SSG pages, prefetch the data JSON so
+* the chunk and payload are warm by the time the user clicks.
 *
-* Used by both `Router.prefetch()` and `<Link>` hover/viewport prefetch. The
-* JSON request uses `fetch()` rather than `<link rel="prefetch">` so it can
-* carry Next.js's `x-deployment-id` skew-protection header. The in-flight
-* request is shared with a racing navigation; after it settles, the browser's
-* normal HTTP cache remains responsible for reuse.
+* Used by both `Router.prefetch()` and `<Link>` hover/viewport prefetch.
+* Matches Next.js Pages Router prefetch: non-SSG routes only warm the page
+* chunk, while `getStaticProps` routes also fetch `/_next/data`.
 *
 * loader's returned Promise is intentionally discarded — `import()` caches the
 * result, so a subsequent navigation re-invocation hits the cache without
@@ -84,15 +162,21 @@ function resolvePagesDataNavigationTarget(browserUrl, basePath) {
 */
 function prefetchPagesData(target) {
 	if (typeof document === "undefined") return;
+	target.loader().catch(() => {});
+	if (target.dataKind !== "static" && !target.middlewareDataHref) return;
 	const headers = {
 		Accept: "application/json",
 		purpose: "prefetch",
 		"x-nextjs-data": "1"
 	};
+	if (target.middlewareDataHref) headers["x-middleware-prefetch"] = "1";
 	const deploymentId = getDeploymentId();
 	if (deploymentId) headers[NEXT_DEPLOYMENT_ID_HEADER] = deploymentId;
-	dedupedPagesDataFetch(target.dataHref, { headers }).catch(() => {});
-	target.loader().catch(() => {});
+	if (target.dataKind === "static") {
+		fetchStaticPagesData(target.middlewareDataHref && target.middlewareDataHref !== target.dataHref ? target.middlewareDataHref : target.prefetchDataHref ?? target.middlewareDataHref ?? target.dataHref, { headers }).then((response) => response.arrayBuffer()).catch(() => {});
+		return;
+	}
+	if (target.middlewareDataHref) fetchUncachedPagesData(target.middlewareDataHref, { headers }).catch(() => {});
 }
 //#endregion
-export { prefetchPagesData, resolvePagesDataNavigationTarget };
+export { getPagesMiddlewareDataHref, prefetchPagesData, resolvePagesDataNavigationTarget };

package/dist/shims/internal/pages-router-components.d.ts

@@ -0,0 +1,7 @@
+//#region src/shims/internal/pages-router-components.d.ts
+type PagesRouterComponentsMap = Record<string, {
+  __appRouter: true;
+} | Record<string, unknown>>;
+declare function getPagesRouterComponentsMap(): PagesRouterComponentsMap;
+//#endregion
+export { PagesRouterComponentsMap, getPagesRouterComponentsMap };

package/dist/shims/internal/pages-router-components.js

@@ -0,0 +1,13 @@
+//#region src/shims/internal/pages-router-components.ts
+const COMPONENTS_KEY = Symbol.for("vinext.pagesRouter.components");
+function getPagesRouterComponentsMap() {
+	const globalState = globalThis;
+	let components = globalState[COMPONENTS_KEY];
+	if (!components) {
+		components = {};
+		globalState[COMPONENTS_KEY] = components;
+	}
+	return components;
+}
+//#endregion
+export { getPagesRouterComponentsMap };

package/dist/shims/layout-segment-context.d.ts

@@ -2,6 +2,7 @@ import { SegmentMap } from "./navigation-context-state.js";
 import { ReactNode } from "react";
 
 //#region src/shims/layout-segment-context.d.ts
+declare function mergeLayoutSegmentMap(previous: SegmentMap | null, next: SegmentMap): SegmentMap;
 /**
  * Wraps children with the layout segment context.
  *
@@ -14,11 +15,13 @@ import { ReactNode } from "react";
  * to read the segments for a specific parallel route.
  */
 declare function LayoutSegmentProvider({
+  providerId,
   segmentMap,
   children
 }: {
+  providerId?: string;
   segmentMap: SegmentMap;
   children: ReactNode;
 }): string | number | bigint | boolean | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | import("react").FunctionComponentElement<import("react").ProviderProps<SegmentMap>> | null | undefined;
 //#endregion
-export { LayoutSegmentProvider };
+export { LayoutSegmentProvider, mergeLayoutSegmentMap };

package/dist/shims/layout-segment-context.js

@@ -1,7 +1,7 @@
 "use client";
 import { getLayoutSegmentContext } from "./navigation-context-state.js";
 import "./navigation-server.js";
-import { createElement } from "react";
+import { createElement, useEffect, useRef } from "react";
 //#region src/shims/layout-segment-context.tsx
 /**
 * Layout segment context provider.
@@ -19,6 +19,14 @@ import { createElement } from "react";
 * The context is shared with navigation.ts via getLayoutSegmentContext()
 * to avoid creating separate contexts in different modules.
 */
+const committedSegmentMapsByProviderId = /* @__PURE__ */ new Map();
+function mergeLayoutSegmentMap(previous, next) {
+	if (!previous) return next;
+	return {
+		...previous,
+		...next
+	};
+}
 /**
 * Wraps children with the layout segment context.
 *
@@ -30,10 +38,16 @@ import { createElement } from "react";
 * Components inside the provider call useSelectedLayoutSegments(parallelRoutesKey)
 * to read the segments for a specific parallel route.
 */
-function LayoutSegmentProvider({ segmentMap, children }) {
+function LayoutSegmentProvider({ providerId, segmentMap, children }) {
+	const previousSegmentMap = useRef(null);
 	const ctx = getLayoutSegmentContext();
+	const mergedSegmentMap = mergeLayoutSegmentMap(previousSegmentMap.current ?? (providerId ? committedSegmentMapsByProviderId.get(providerId) ?? null : null), segmentMap);
+	useEffect(() => {
+		previousSegmentMap.current = mergedSegmentMap;
+		if (providerId) committedSegmentMapsByProviderId.set(providerId, mergedSegmentMap);
+	}, [mergedSegmentMap, providerId]);
 	if (!ctx) return children;
-	return createElement(ctx.Provider, { value: segmentMap }, children);
+	return createElement(ctx.Provider, { value: mergedSegmentMap }, children);
 }
 //#endregion
-export { LayoutSegmentProvider };
+export { LayoutSegmentProvider, mergeLayoutSegmentMap };

package/dist/shims/link.d.ts

@@ -42,7 +42,7 @@ type LinkProps = {
   onNavigate?: (event: NavigateEvent) => void;
   children?: React.ReactNode;
 } & Omit<AnchorHTMLAttributes<HTMLAnchorElement>, "href">;
-type LinkPrefetchMode = "disabled" | "auto" | "full";
+type LinkPrefetchMode = "disabled" | "auto" | "full" | "full-after-shell";
 declare global {
   interface Window {
     __VINEXT_LINK_PREFETCH_ROUTES__?: VinextLinkPrefetchRoute[];