vinext 0.1.8 → 0.2.1

package/dist/server/app-route-tree-prefetch.js

@@ -0,0 +1,187 @@
+import { NEXTJS_DEPLOYMENT_ID_HEADER } from "./headers.js";
+import { getDeploymentId } from "../utils/deployment-id.js";
+import { VINEXT_RSC_CONTENT_TYPE, VINEXT_RSC_VARY_HEADER, applyRscCompatibilityIdHeader } from "./app-rsc-cache-busting.js";
+//#region src/server/app-route-tree-prefetch.ts
+const PARENT_INLINED_INTO_SELF = 32;
+const INLINED_INTO_CHILD = 64;
+const HEAD_INLINED_INTO_SELF = 128;
+const PAGE_SEGMENT = "__PAGE__";
+const SLOT_SEGMENT = "(__SLOT__)";
+const SEGMENT_INLINE_SIZE = 1;
+const SEGMENT_OUTLINE_SIZE = 4096;
+const DEFAULT_SEGMENT_INLINE_THRESHOLD = 2048;
+const HEAD_INLINE_SIZE = 1;
+const DEFAULT_MAX_INLINE_BUNDLE_SIZE = 10240;
+const NEXT_DID_POSTPONE_HEADER = "x-nextjs-postponed";
+function isRouteTreePrefetchRequest(request) {
+	return request.headers.get("RSC") === "1" && request.headers.get("Next-Router-Prefetch") === "1" && request.headers.get("Next-Router-Segment-Prefetch") === "/_tree";
+}
+function createNode(segment, module) {
+	const { name, param } = routeTreeSegment(segment);
+	return {
+		name,
+		param,
+		prefetchSize: estimatePrefetchSize(module) ?? ((module === null || module === void 0) && segment !== PAGE_SEGMENT ? SEGMENT_INLINE_SIZE : null),
+		prefetchHints: 0,
+		slots: null
+	};
+}
+function ensureSlots(node) {
+	if (node.slots === null) node.slots = {};
+	return node.slots;
+}
+function addChild(node, key, child) {
+	ensureSlots(node)[key] = child;
+}
+function routeTreeSegment(segment) {
+	if (segment.startsWith(":")) {
+		const rest = segment.slice(1);
+		if (rest.endsWith("+")) return dynamicRouteTreeSegment(rest.slice(0, -1), "c");
+		if (rest.endsWith("*")) return dynamicRouteTreeSegment(rest.slice(0, -1), "oc");
+		return dynamicRouteTreeSegment(rest, "d");
+	}
+	if (segment.startsWith("[[...") && segment.endsWith("]]")) return dynamicRouteTreeSegment(segment.slice(5, -2), "oc");
+	if (segment.startsWith("[...") && segment.endsWith("]")) return dynamicRouteTreeSegment(segment.slice(4, -1), "c");
+	if (segment.startsWith("[") && segment.endsWith("]")) return dynamicRouteTreeSegment(segment.slice(1, -1), "d");
+	return {
+		name: segment,
+		param: null
+	};
+}
+function dynamicRouteTreeSegment(name, type) {
+	return {
+		name,
+		param: {
+			key: null,
+			siblings: null,
+			type
+		}
+	};
+}
+function explicitPrefetchSize(module) {
+	if (typeof module !== "object" || module === null) return null;
+	const value = module.prefetchSize;
+	if (value === "large") return SEGMENT_OUTLINE_SIZE;
+	if (value === "small") return SEGMENT_INLINE_SIZE;
+	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : null;
+}
+function estimatePrefetchSize(module) {
+	const explicitSize = explicitPrefetchSize(module);
+	if (explicitSize !== null) return explicitSize;
+	if (typeof module !== "object" || module === null) return null;
+	return typeof module.default === "function" ? SEGMENT_INLINE_SIZE : null;
+}
+function layoutModuleByTreePosition(route) {
+	const layouts = route.layouts ?? [];
+	const positions = route.layoutTreePositions ?? [];
+	const byPosition = /* @__PURE__ */ new Map();
+	for (const [index, position] of positions.entries()) byPosition.set(position, layouts[index]);
+	return byPosition;
+}
+function modulesByTreePosition(modules, positions) {
+	const byPosition = /* @__PURE__ */ new Map();
+	for (const [index, position] of (positions ?? []).entries()) byPosition.set(position, modules?.[index]);
+	return byPosition;
+}
+async function buildTree(route) {
+	const layoutsByPosition = layoutModuleByTreePosition(route);
+	const root = createNode("", layoutsByPosition.get(0));
+	const nodesByPosition = new Map([[0, root]]);
+	let current = root;
+	for (const [index, segment] of route.routeSegments.entries()) {
+		const position = index + 1;
+		const child = createNode(segment, layoutsByPosition.get(position));
+		addChild(current, "children", child);
+		nodesByPosition.set(position, child);
+		current = child;
+	}
+	addChild(current, "children", createNode(PAGE_SEGMENT, route.page));
+	for (const slot of Object.values(route.slots ?? {})) {
+		const ownerPosition = slot.layoutIndex === void 0 || slot.layoutIndex < 0 ? route.routeSegments.length : route.layoutTreePositions?.[slot.layoutIndex] ?? route.routeSegments.length;
+		const owner = nodesByPosition.get(ownerPosition) ?? current;
+		const slotRoot = createNode(SLOT_SEGMENT, slot.layout);
+		let slotCurrent = slotRoot;
+		const slotConfigLayoutsByPosition = modulesByTreePosition(slot.configLayouts, slot.configLayoutTreePositions);
+		const slotRouteSegments = slot.routeSegments ?? [];
+		for (const [index, segment] of slotRouteSegments.entries()) {
+			const position = index + 1;
+			const child = createNode(segment, slotConfigLayoutsByPosition.get(position));
+			addChild(slotCurrent, "children", child);
+			slotCurrent = child;
+		}
+		addChild(slotCurrent, "children", createNode(PAGE_SEGMENT, slot.page ?? slot.default));
+		addChild(owner, slot.name, slotRoot);
+	}
+	return root;
+}
+function computePrefetchHints(node, parentGzipSize, headInlineState, config) {
+	const currentGzipSize = node.prefetchSize;
+	const sizeToInline = currentGzipSize !== null && currentGzipSize < config.maxSize ? currentGzipSize : null;
+	let didInlineIntoChild = false;
+	let acceptingChildInlinedBytes = 0;
+	let smallestChildInlinedBytes = Number.POSITIVE_INFINITY;
+	let hasChildren = false;
+	for (const child of Object.values(node.slots ?? {})) {
+		hasChildren = true;
+		const childInlinedBytes = computePrefetchHints(child, didInlineIntoChild ? null : sizeToInline, headInlineState, config);
+		if ((child.prefetchHints & PARENT_INLINED_INTO_SELF) !== 0) {
+			didInlineIntoChild = true;
+			acceptingChildInlinedBytes = childInlinedBytes;
+		} else if (!didInlineIntoChild && childInlinedBytes < smallestChildInlinedBytes) smallestChildInlinedBytes = childInlinedBytes;
+	}
+	if (!hasChildren) smallestChildInlinedBytes = 0;
+	let hints = node.prefetchHints;
+	if (didInlineIntoChild) hints |= INLINED_INTO_CHILD;
+	let inlinedBytes = didInlineIntoChild ? acceptingChildInlinedBytes : smallestChildInlinedBytes;
+	const isBundleTerminal = !didInlineIntoChild;
+	if (!headInlineState.inlined && isBundleTerminal && node.name === PAGE_SEGMENT && inlinedBytes + HEAD_INLINE_SIZE < config.maxBundleSize) {
+		hints |= HEAD_INLINED_INTO_SELF;
+		inlinedBytes += HEAD_INLINE_SIZE;
+		headInlineState.inlined = true;
+	}
+	if (parentGzipSize !== null) {
+		if (inlinedBytes + parentGzipSize < config.maxBundleSize) {
+			hints |= PARENT_INLINED_INTO_SELF;
+			inlinedBytes += parentGzipSize;
+		}
+	}
+	node.prefetchHints = hints;
+	return inlinedBytes;
+}
+function stripMutableFields(node) {
+	const slots = node.slots === null ? null : Object.fromEntries(Object.entries(node.slots).map(([key, child]) => [key, stripMutableFields(child)]));
+	return {
+		name: node.name,
+		param: node.param,
+		prefetchHints: node.prefetchHints,
+		slots
+	};
+}
+function resolvePrefetchInliningConfig(config) {
+	if (config) return config;
+	return {
+		maxBundleSize: DEFAULT_MAX_INLINE_BUNDLE_SIZE,
+		maxSize: DEFAULT_SEGMENT_INLINE_THRESHOLD
+	};
+}
+async function createRouteTreePrefetchResponse(route, options = {}) {
+	const tree = await buildTree(route);
+	computePrefetchHints(tree, null, { inlined: false }, resolvePrefetchInliningConfig(options.prefetchInlining));
+	const headers = new Headers({
+		"Cache-Control": "no-store",
+		"Content-Type": VINEXT_RSC_CONTENT_TYPE,
+		[NEXT_DID_POSTPONE_HEADER]: "2",
+		Vary: VINEXT_RSC_VARY_HEADER
+	});
+	applyRscCompatibilityIdHeader(headers);
+	const deploymentId = options.deploymentId ?? getDeploymentId();
+	if (deploymentId) headers.set(NEXTJS_DEPLOYMENT_ID_HEADER, deploymentId);
+	const payload = {
+		tree: stripMutableFields(tree),
+		staleTime: -1
+	};
+	if (options.buildId) payload.buildId = options.buildId;
+	return new Response(`0:${JSON.stringify(payload)}\n`, { headers });
+}
+//#endregion
+export { createRouteTreePrefetchResponse, isRouteTreePrefetchRequest };

package/dist/server/app-router-entry.js

@@ -1,14 +1,16 @@
 import "./server-globals.js";
 import { runWithExecutionContext } from "../shims/request-context.js";
-import { VINEXT_PRERENDER_ROUTE_PARAMS_HEADER } from "./headers.js";
+import { VINEXT_PRERENDER_ROUTE_PARAMS_HEADER } from "../utils/protocol-headers.js";
 import { badRequestResponse, notFoundResponse, notFoundStaticAssetResponse } from "./http-error-responses.js";
 import { isOpenRedirectShaped } from "./open-redirect.js";
 import { cloneRequestWithHeaders, filterInternalHeaders } from "./request-pipeline.js";
 import { assetPrefixPathname, isNextStaticPath } from "../utils/asset-prefix.js";
+import { getImageOptimizer, handleConfiguredImageOptimization, isImageOptimizationPath } from "./image-optimization.js";
 import { finalizeMissingStaticAssetResponse, resolveStaticAssetSignal } from "./worker-utils.js";
 import { readTrustedPrerenderRouteParams, serializePrerenderRouteParamsHeader } from "./prerender-route-params.js";
-import rscHandler, { __assetPrefix, __basePath } from "virtual:vinext-rsc-entry";
+import rscHandler, { __assetPrefix, __basePath, __imageAllowedWidths, __imageConfig } from "virtual:vinext-rsc-entry";
 import { registerConfiguredCacheAdapters } from "virtual:vinext-cache-adapters";
+import { registerConfiguredImageOptimizer } from "virtual:vinext-image-adapters";
 //#region src/server/app-router-entry.ts
 const __workerBasePath = typeof __basePath === "string" ? __basePath : "";
 const __workerAssetPathPrefix = assetPrefixPathname(typeof __assetPrefix === "string" ? __assetPrefix : "");
@@ -17,7 +19,12 @@ var app_router_entry_default = { async fetch(request, env, ctx) {
 } };
 async function handleRequest(request, env, ctx) {
 	registerConfiguredCacheAdapters(env);
+	registerConfiguredImageOptimizer(env);
 	const url = new URL(request.url);
+	if (isImageOptimizationPath(url.pathname) && env?.ASSETS && getImageOptimizer()) {
+		const assetFetcher = env.ASSETS;
+		return handleConfiguredImageOptimization(request, (assetPath) => Promise.resolve(assetFetcher.fetch(new Request(new URL(assetPath, request.url)))), __imageAllowedWidths, __imageConfig);
+	}
 	if (isOpenRedirectShaped(url.pathname)) return notFoundResponse();
 	try {
 		decodeURIComponent(url.pathname);

package/dist/server/app-rsc-cache-busting.d.ts

@@ -24,6 +24,7 @@ type ResolveInvalidRscCacheBustingRequestOptions = {
 };
 declare function getVinextRscCompatibilityId(): string | null;
 declare function applyRscCompatibilityIdHeader(headers: Headers, compatibilityId?: string | null | undefined): void;
+declare function applyRscDeploymentIdHeader(headers: Headers): void;
 declare function isRscCompatibilityIdCompatible(responseCompatibilityId: string | null | undefined, clientCompatibilityId?: string | null | undefined): boolean;
 type RscCompatibilityNavigationDecision = {
   kind: "compatible";
@@ -61,4 +62,4 @@ declare function createServerActionRequestUrl(href: string): string;
 declare function createRscRedirectLocation(location: string, request: Request): Promise<string>;
 declare function resolveInvalidRscCacheBustingRequest(options: ResolveInvalidRscCacheBustingRequestOptions): Promise<Response | null>;
 //#endregion
-export { VINEXT_RSC_CACHE_BUSTING_SEARCH_PARAM, VINEXT_RSC_COMPATIBILITY_ID_HEADER, VINEXT_RSC_CONTENT_TYPE, VINEXT_RSC_RENDER_MODE_HEADER, VINEXT_RSC_VARY_HEADER, applyRscCompatibilityIdHeader, computeRscCacheBustingSearchParam, createRscRedirectLocation, createRscRequestHeaders, createRscRequestUrl, createServerActionRequestUrl, getVinextRscCompatibilityId, hasRscCacheBustingSearchParam, isRscCompatibilityIdCompatible, resolveHardNavigationTargetFromRscResponse, resolveInvalidRscCacheBustingRequest, resolveRscCompatibilityNavigationDecision, setRscCacheBustingSearchParam, stripRscCacheBustingSearchParam, stripRscSuffix };
+export { VINEXT_RSC_CACHE_BUSTING_SEARCH_PARAM, VINEXT_RSC_COMPATIBILITY_ID_HEADER, VINEXT_RSC_CONTENT_TYPE, VINEXT_RSC_RENDER_MODE_HEADER, VINEXT_RSC_VARY_HEADER, applyRscCompatibilityIdHeader, applyRscDeploymentIdHeader, computeRscCacheBustingSearchParam, createRscRedirectLocation, createRscRequestHeaders, createRscRequestUrl, createServerActionRequestUrl, getVinextRscCompatibilityId, hasRscCacheBustingSearchParam, isRscCompatibilityIdCompatible, resolveHardNavigationTargetFromRscResponse, resolveInvalidRscCacheBustingRequest, resolveRscCompatibilityNavigationDecision, setRscCacheBustingSearchParam, stripRscCacheBustingSearchParam, stripRscSuffix };

package/dist/server/app-rsc-cache-busting.js

@@ -1,7 +1,7 @@
-import { NEXT_ROUTER_PREFETCH_HEADER, NEXT_ROUTER_SEGMENT_PREFETCH_HEADER, NEXT_ROUTER_STATE_TREE_HEADER, NEXT_URL_HEADER, VINEXT_CLIENT_REUSE_MANIFEST_HEADER, VINEXT_INTERCEPTION_CONTEXT_HEADER, VINEXT_MOUNTED_SLOTS_HEADER, VINEXT_RSC_RENDER_MODE_HEADER } from "./headers.js";
+import { NEXTJS_DEPLOYMENT_ID_HEADER, NEXT_ROUTER_PREFETCH_HEADER, NEXT_ROUTER_SEGMENT_PREFETCH_HEADER, NEXT_ROUTER_STATE_TREE_HEADER, NEXT_URL_HEADER, VINEXT_CLIENT_REUSE_MANIFEST_HEADER, VINEXT_INTERCEPTION_CONTEXT_HEADER, VINEXT_MOUNTED_SLOTS_HEADER, VINEXT_RSC_RENDER_MODE_HEADER } from "./headers.js";
 import { fnv1a64 } from "../utils/hash.js";
 import { parseAppRscRenderMode } from "./app-rsc-render-mode.js";
-import { applyDeploymentIdHeader } from "../utils/deployment-id.js";
+import { applyDeploymentIdHeader, getDeploymentId } from "../utils/deployment-id.js";
 //#region src/server/app-rsc-cache-busting.ts
 /**
 * RSC cache-busting hashes cover the headers that make an RSC payload vary.
@@ -44,6 +44,11 @@ function applyRscCompatibilityIdHeader(headers, compatibilityId = getVinextRscCo
 	if (normalized) headers.set(VINEXT_RSC_COMPATIBILITY_ID_HEADER, normalized);
 	else headers.delete(VINEXT_RSC_COMPATIBILITY_ID_HEADER);
 }
+function applyRscDeploymentIdHeader(headers) {
+	const deploymentId = getDeploymentId();
+	if (deploymentId) headers.set(NEXTJS_DEPLOYMENT_ID_HEADER, deploymentId);
+	else headers.delete(NEXTJS_DEPLOYMENT_ID_HEADER);
+}
 function isRscCompatibilityIdCompatible(responseCompatibilityId, clientCompatibilityId = getVinextRscCompatibilityId()) {
 	const normalizedResponseCompatibilityId = normalizeCompatibilityId(responseCompatibilityId);
 	const normalizedClientCompatibilityId = normalizeCompatibilityId(clientCompatibilityId);
@@ -184,7 +189,7 @@ async function resolveInvalidRscCacheBustingRequest(options) {
 	const url = new URL(options.request.url);
 	const actualHash = url.searchParams.get(VINEXT_RSC_CACHE_BUSTING_SEARCH_PARAM);
 	const expectedHash = await computeRscCacheBustingSearchParam(options.request.headers);
-	if (actualHash === null && expectedHash === "") return null;
+	if (actualHash === null && expectedHash === "" && url.pathname.endsWith(".rsc")) return null;
 	const acceptedHashes = new Set([expectedHash]);
 	if (actualHash !== null && actualHash !== expectedHash) {
 		acceptedHashes.add(computeLegacyRscCacheBustingSearchParam(options.request.headers));
@@ -203,4 +208,4 @@ async function resolveInvalidRscCacheBustingRequest(options) {
 	});
 }
 //#endregion
-export { VINEXT_RSC_CACHE_BUSTING_SEARCH_PARAM, VINEXT_RSC_COMPATIBILITY_ID_HEADER, VINEXT_RSC_CONTENT_TYPE, VINEXT_RSC_RENDER_MODE_HEADER, VINEXT_RSC_VARY_HEADER, applyRscCompatibilityIdHeader, computeRscCacheBustingSearchParam, createRscRedirectLocation, createRscRequestHeaders, createRscRequestUrl, createServerActionRequestUrl, getVinextRscCompatibilityId, hasRscCacheBustingSearchParam, isRscCompatibilityIdCompatible, resolveHardNavigationTargetFromRscResponse, resolveInvalidRscCacheBustingRequest, resolveRscCompatibilityNavigationDecision, setRscCacheBustingSearchParam, stripRscCacheBustingSearchParam, stripRscSuffix };
+export { VINEXT_RSC_CACHE_BUSTING_SEARCH_PARAM, VINEXT_RSC_COMPATIBILITY_ID_HEADER, VINEXT_RSC_CONTENT_TYPE, VINEXT_RSC_RENDER_MODE_HEADER, VINEXT_RSC_VARY_HEADER, applyRscCompatibilityIdHeader, applyRscDeploymentIdHeader, computeRscCacheBustingSearchParam, createRscRedirectLocation, createRscRequestHeaders, createRscRequestUrl, createServerActionRequestUrl, getVinextRscCompatibilityId, hasRscCacheBustingSearchParam, isRscCompatibilityIdCompatible, resolveHardNavigationTargetFromRscResponse, resolveInvalidRscCacheBustingRequest, resolveRscCompatibilityNavigationDecision, setRscCacheBustingSearchParam, stripRscCacheBustingSearchParam, stripRscSuffix };

package/dist/server/app-rsc-handler.d.ts

@@ -6,6 +6,7 @@ import { AppMiddlewareContext, ApplyAppMiddlewareResult } from "./app-middleware
 import { AppRscRenderMode } from "./app-rsc-render-mode.js";
 import { AppPagePprFallbackCacheShell } from "./app-ppr-fallback-shell.js";
 import { AppPrerenderRootParamNamesMap, AppPrerenderStaticParamsMap } from "./app-prerender-endpoints.js";
+import { AppRouteTreePrefetchRoute, PrefetchInliningConfig } from "./app-route-tree-prefetch.js";
 import { ReactFormState } from "react-dom/client";
 
 //#region src/server/app-rsc-handler.d.ts
@@ -16,6 +17,7 @@ type AppRscMiddlewareContext = AppMiddlewareContext;
 type RunAppMiddlewareOptions = {
   cleanPathname: string;
   context: AppRscMiddlewareContext;
+  hadBasePath: boolean;
   isDataRequest: boolean;
   request: Request;
 };
@@ -23,12 +25,15 @@ type AppRscHandlerRoute = {
   __loadPage?: unknown;
   __loadRouteHandler?: unknown;
   isDynamic: boolean;
+  layouts?: readonly unknown[];
+  layoutTreePositions?: readonly number[];
   params?: readonly string[];
   page?: unknown;
   pattern: string;
   rootParamNames?: readonly string[];
   routeHandler?: unknown;
   routeSegments: readonly string[];
+  slots?: AppRouteTreePrefetchRoute["slots"];
 };
 type AppRscRouteMatch<TRoute> = {
   params: AppPageParams;
@@ -62,6 +67,7 @@ type DispatchMatchedPageOptions<TRoute> = {
   staticParamsValidationParams?: AppPageParams;
   rootParams?: RootParams;
   request: Request;
+  renderedPathAndSearch?: string | null;
   route: TRoute;
   scriptNonce?: string;
   searchParams: URLSearchParams;
@@ -188,6 +194,7 @@ type CreateAppRscHandlerOptions<TRoute extends AppRscHandlerRoute> = {
   matchRoute: (pathname: string) => AppRscRouteMatch<TRoute> | null;
   runMiddleware?: (options: RunAppMiddlewareOptions) => Promise<ApplyAppMiddlewareResult>;
   publicFiles: ReadonlySet<string>;
+  prefetchInlining?: PrefetchInliningConfig;
   renderNotFound: (options: RenderNotFoundOptions<TRoute>) => Promise<Response | null>;
   renderPagesFallback?: (options: RenderPagesFallbackOptions) => Promise<Response | null>;
   rootParamNamesByPattern?: RootParamNamesMap;