@qzsy/vinext 0.1.7

package/dist/server/app-browser-rsc-redirect.js

@@ -0,0 +1,64 @@
+import { isDangerousScheme, reportBlockedDangerousNavigation } from "../shims/url-safety.js";
+import { resolveHardNavigationTargetFromRscResponse, stripRscCacheBustingSearchParam, stripRscSuffix } from "./app-rsc-cache-busting.js";
+//#region src/server/app-browser-rsc-redirect.ts
+const MAX_RSC_REDIRECT_DEPTH = 10;
+function blockDangerousStreamedRscRedirect(response, streamedRedirectTarget) {
+	if (streamedRedirectTarget === null || !isDangerousScheme(streamedRedirectTarget)) return false;
+	response.body?.cancel().catch(() => {});
+	reportBlockedDangerousNavigation();
+	return true;
+}
+function toVisibleAppHref(href, origin) {
+	const url = new URL(href, origin);
+	stripRscCacheBustingSearchParam(url);
+	return `${stripRscSuffix(url.pathname)}${url.search}${url.hash}`;
+}
+function toStreamedRedirectVisibleAppHref(href, origin) {
+	const url = new URL(href, origin);
+	return `${url.pathname}${url.search}${url.hash}`;
+}
+function resolveRedirectLifecycleHopFromTarget(options) {
+	if (options.targetUrl.origin !== options.origin) return {
+		href: options.targetUrl.href,
+		kind: "terminal-hard-navigation",
+		reason: "externalRedirect",
+		redirectDepth: options.redirectDepth
+	};
+	const redirectedHref = options.redirectedHref;
+	if (redirectedHref === toVisibleAppHref(options.currentHref, options.origin)) return {
+		href: redirectedHref,
+		kind: "no-redirect"
+	};
+	const maxRedirectDepth = options.maxRedirectDepth ?? MAX_RSC_REDIRECT_DEPTH;
+	if (options.redirectDepth >= maxRedirectDepth) return {
+		href: redirectedHref,
+		kind: "terminal-hard-navigation",
+		reason: "maxRedirectsExceeded",
+		redirectDepth: options.redirectDepth
+	};
+	return {
+		href: redirectedHref,
+		historyUpdateMode: options.historyUpdateMode,
+		kind: "follow",
+		previousNextUrl: options.requestPreviousNextUrl,
+		redirectDepth: options.redirectDepth + 1
+	};
+}
+function resolveRscRedirectLifecycleHop(options) {
+	const responseUrl = new URL(options.responseUrl, options.origin);
+	return resolveRedirectLifecycleHopFromTarget({
+		...options,
+		redirectedHref: resolveHardNavigationTargetFromRscResponse(responseUrl.href, options.currentHref, options.origin),
+		targetUrl: responseUrl
+	});
+}
+function resolveStreamedRscRedirectLifecycleHop(options) {
+	const streamedRedirectUrl = new URL(options.streamedRedirectTarget, options.origin);
+	return resolveRedirectLifecycleHopFromTarget({
+		...options,
+		redirectedHref: toStreamedRedirectVisibleAppHref(options.streamedRedirectTarget, options.origin),
+		targetUrl: streamedRedirectUrl
+	});
+}
+//#endregion
+export { blockDangerousStreamedRscRedirect, resolveRscRedirectLifecycleHop, resolveStreamedRscRedirectLifecycleHop };

package/dist/server/app-browser-server-action-client.d.ts

@@ -0,0 +1,32 @@
+import { AppElements, AppWireElements } from "./app-elements-wire.js";
+import { navigationPlanner } from "./navigation-planner.js";
+import { AppBrowserServerActionResult, ServerActionRevalidationKind } from "./app-browser-action-result.js";
+import { AppRouterState } from "./app-browser-state.js";
+
+//#region src/server/app-browser-server-action-client.d.ts
+type ServerActionResult = AppBrowserServerActionResult<AppWireElements>;
+type ClientServerActionInitiation = {
+  href: string;
+  navigationId: number;
+  path: string;
+  routerState: AppRouterState;
+};
+type ActionRedirectTarget = {
+  href: string;
+  type: string;
+  status: number;
+};
+type ClientServerActionDeps = {
+  basePath: string;
+  clearClientNavigationCaches(): void;
+  clientRscCompatibilityId: string | null;
+  commitSameUrlNavigatePayload(elements: Promise<AppElements>, actionInitiation: ClientServerActionInitiation, returnValue: ServerActionResult["returnValue"] | undefined, revalidation: ServerActionRevalidationKind): Promise<unknown>;
+  navigationPlanner: typeof navigationPlanner;
+  performHardNavigation(url: string, historyMode?: "assign" | "replace"): void;
+  renderRedirectPayload(elements: AppElements, target: ActionRedirectTarget, actionInitiation: ClientServerActionInitiation): void;
+  syncCurrentHistoryState(previousNextUrl: string | null, bfcacheIds: Readonly<Record<string, string>>): void;
+  syncServerActionHttpFallbackHead(status: number | null): void;
+};
+declare function invokeClientServerAction(id: string, args: unknown[], actionInitiation: ClientServerActionInitiation, deps: ClientServerActionDeps): Promise<unknown>;
+//#endregion
+export { ClientServerActionDeps, ClientServerActionInitiation, invokeClientServerAction };

package/dist/server/app-browser-server-action-client.js

@@ -0,0 +1,128 @@
+import { ACTION_REDIRECT_HEADER, ACTION_REDIRECT_STATUS_HEADER } from "./headers.js";
+import { DANGEROUS_URL_BLOCK_MESSAGE, isDangerousScheme } from "../shims/url-safety.js";
+import { AppElementsWire } from "./app-elements-wire.js";
+import "./app-elements.js";
+import { VINEXT_RSC_COMPATIBILITY_ID_HEADER, createServerActionRequestUrl } from "./app-rsc-cache-busting.js";
+import { createServerActionResultFacts, isServerActionResult, normalizeServerActionThrownValue, parseServerActionRevalidationHeader, readInvalidServerActionResponseError, shouldClearClientNavigationCachesForServerActionResult } from "./app-browser-action-result.js";
+import { resolveServerActionRequestState } from "./app-browser-state.js";
+import { applyServerActionResultDecision } from "./app-browser-server-action-navigation.js";
+import { throwOnServerActionNotFound } from "./server-action-not-found.js";
+import { createFromFetch, createTemporaryReferenceSet, encodeReply } from "@vitejs/plugin-rsc/browser";
+//#region src/server/app-browser-server-action-client.ts
+function resolveActionRedirectTarget(response, performHardNavigation) {
+	const actionRedirect = response.headers.get(ACTION_REDIRECT_HEADER);
+	if (!actionRedirect) return null;
+	if (isDangerousScheme(actionRedirect)) {
+		console.error(DANGEROUS_URL_BLOCK_MESSAGE);
+		return null;
+	}
+	try {
+		let redirectUrl;
+		if (actionRedirect.startsWith("/") || /^[a-z]+:/i.test(actionRedirect)) redirectUrl = new URL(actionRedirect, window.location.href);
+		else {
+			const baseParsed = new URL(window.location.href);
+			let baseDir = baseParsed.pathname;
+			if (!baseDir.endsWith("/")) baseDir += "/";
+			redirectUrl = new URL(actionRedirect, `${baseParsed.origin}${baseDir}${baseParsed.search}`);
+		}
+		if (redirectUrl.origin !== window.location.origin) {
+			performHardNavigation(actionRedirect);
+			return null;
+		}
+		const statusHeader = response.headers.get(ACTION_REDIRECT_STATUS_HEADER);
+		return {
+			href: redirectUrl.href,
+			type: response.headers.get("x-action-redirect-type") ?? "push",
+			status: statusHeader ? parseInt(statusHeader, 10) : 307
+		};
+	} catch {
+		performHardNavigation(actionRedirect);
+		return null;
+	}
+}
+var ServerActionRedirectError = class extends Error {
+	digest;
+	handled = true;
+	constructor(target) {
+		super("NEXT_REDIRECT");
+		const redirectUrl = new URL(target.href, window.location.href);
+		const redirectHref = redirectUrl.pathname + redirectUrl.search + redirectUrl.hash;
+		const redirectType = target.type === "push" ? "push" : "replace";
+		this.digest = `NEXT_REDIRECT;${redirectType};${encodeURIComponent(redirectHref)};${target.status};`;
+	}
+};
+async function invokeClientServerAction(id, args, actionInitiation, deps) {
+	deps.syncServerActionHttpFallbackHead(null);
+	const temporaryReferences = createTemporaryReferenceSet();
+	deps.syncCurrentHistoryState(actionInitiation.routerState.previousNextUrl, actionInitiation.routerState.bfcacheIds);
+	const body = await encodeReply(args, { temporaryReferences });
+	const headers = resolveServerActionRequestState({
+		actionId: id,
+		basePath: deps.basePath,
+		elements: actionInitiation.routerState.elements,
+		previousNextUrl: actionInitiation.routerState.previousNextUrl
+	}).headers;
+	const fetchResponse = await fetch(createServerActionRequestUrl(actionInitiation.path), {
+		method: "POST",
+		headers,
+		body
+	});
+	throwOnServerActionNotFound(fetchResponse, id);
+	const hasActionRedirect = fetchResponse.headers.has(ACTION_REDIRECT_HEADER);
+	const actionRedirectTarget = resolveActionRedirectTarget(fetchResponse, (url, historyMode) => deps.performHardNavigation(url, historyMode));
+	if (hasActionRedirect && !actionRedirectTarget) return void 0;
+	const actionResultFacts = createServerActionResultFacts({
+		actionRedirectHref: actionRedirectTarget?.href ?? null,
+		actionRedirectType: actionRedirectTarget?.type ?? null,
+		clientCompatibilityId: deps.clientRscCompatibilityId,
+		compatibilityIdHeader: fetchResponse.headers.get(VINEXT_RSC_COMPATIBILITY_ID_HEADER),
+		contentTypeHeader: fetchResponse.headers.get("content-type"),
+		currentHref: actionInitiation.href,
+		origin: window.location.origin,
+		responseUrl: fetchResponse.url
+	});
+	const fetchResponseIsRsc = actionResultFacts.isRscContentType;
+	if (applyServerActionResultDecision(deps.navigationPlanner.classifyServerActionResult(actionResultFacts), () => deps.clearClientNavigationCaches(), (url, historyMode) => deps.performHardNavigation(url, historyMode))) return;
+	const revalidation = parseServerActionRevalidationHeader(fetchResponse.headers);
+	if (revalidation !== "none") deps.clearClientNavigationCaches();
+	const invalidResponseError = await readInvalidServerActionResponseError(fetchResponse.clone(), actionRedirectTarget !== null);
+	if (invalidResponseError) throw invalidResponseError;
+	if (actionRedirectTarget && !fetchResponseIsRsc) {
+		deps.performHardNavigation(actionRedirectTarget.href);
+		return;
+	}
+	const flightResponse = fetchResponse.status === 303 ? new Response(fetchResponse.body, {
+		headers: fetchResponse.headers,
+		status: 200,
+		statusText: "OK"
+	}) : fetchResponse;
+	const result = await createFromFetch(Promise.resolve(flightResponse), { temporaryReferences });
+	if (revalidation === "none" && shouldClearClientNavigationCachesForServerActionResult(result, revalidation)) deps.clearClientNavigationCaches();
+	if (actionRedirectTarget) {
+		if (isServerActionResult(result) && result.root !== void 0) {
+			deps.renderRedirectPayload(AppElementsWire.decode(result.root), actionRedirectTarget, actionInitiation);
+			throw new ServerActionRedirectError(actionRedirectTarget);
+		}
+		deps.performHardNavigation(actionRedirectTarget.href);
+		return;
+	}
+	const hasSameUrlRerenderPayload = isServerActionResult(result) && result.root !== void 0;
+	deps.syncServerActionHttpFallbackHead(hasSameUrlRerenderPayload ? null : fetchResponse.status);
+	if (isServerActionResult(result)) {
+		if (result.root !== void 0) {
+			const returnValue = result.returnValue && !result.returnValue.ok ? {
+				ok: false,
+				data: normalizeServerActionThrownValue(result.returnValue.data, fetchResponse.status)
+			} : result.returnValue;
+			return deps.commitSameUrlNavigatePayload(Promise.resolve(AppElementsWire.decode(result.root)), actionInitiation, returnValue, revalidation);
+		}
+		if (result.returnValue) {
+			if (!result.returnValue.ok) throw normalizeServerActionThrownValue(result.returnValue.data, fetchResponse.status);
+			return result.returnValue.data;
+		}
+		return;
+	}
+	return deps.commitSameUrlNavigatePayload(Promise.resolve(AppElementsWire.decode(result)), actionInitiation, void 0, revalidation);
+}
+//#endregion
+export { invokeClientServerAction };

package/dist/server/app-browser-server-action-navigation.d.ts

@@ -0,0 +1,6 @@
+import { ServerActionResultDecision } from "./navigation-planner.js";
+
+//#region src/server/app-browser-server-action-navigation.d.ts
+declare function applyServerActionResultDecision(decision: ServerActionResultDecision, clearCaches: () => void, performHardNavigation: (url: string, historyMode?: "assign" | "replace") => void): boolean;
+//#endregion
+export { applyServerActionResultDecision };

package/dist/server/app-browser-server-action-navigation.js

@@ -0,0 +1,9 @@
+//#region src/server/app-browser-server-action-navigation.ts
+function applyServerActionResultDecision(decision, clearCaches, performHardNavigation) {
+	if (decision.kind !== "hardNavigate") return false;
+	if (decision.clearClientNavigationCaches) clearCaches();
+	performHardNavigation(decision.url, decision.historyMode);
+	return true;
+}
+//#endregion
+export { applyServerActionResultDecision };

package/dist/server/app-browser-state.d.ts

@@ -0,0 +1,140 @@
+import { RouteManifest } from "../routing/app-route-graph.js";
+import { CacheEntryReuseProof } from "./cache-proof.js";
+import { AppElements, AppElementsInterception, AppElementsSlotBinding, LayoutFlags } from "./app-elements-wire.js";
+import { NavigationTrace } from "./navigation-trace.js";
+import { OperationLane } from "./operation-token.js";
+import { BfcacheIdMap, HistoryTraversalIntent, createHistoryStateWithNavigationMetadata, createHistoryStateWithPreviousNextUrl, isHistoryStateBfcacheVersionCurrent, readHistoryStateBfcacheIds, readHistoryStateBfcacheVersion, readHistoryStatePreviousNextUrl, readHistoryStateTraversalIndex, resolveHistoryTraversalIntent } from "./app-history-state.js";
+import { createBfcacheSegmentStateKeyMap, createInitialBfcacheIdMap, createNextBfcacheIdMap, preserveBfcacheIdsForMergedElements } from "./app-bfcache-identity.js";
+import { ClientNavigationRenderSnapshot } from "../shims/navigation.js";
+
+//#region src/server/app-browser-state.d.ts
+type OperationRecordBase = {
+  id: number;
+  lane: OperationLane;
+  startedVisibleCommitVersion: number;
+};
+type PendingOperationRecord = OperationRecordBase & {
+  state: "pending";
+};
+type CommittedOperationRecord = OperationRecordBase & {
+  state: "committed";
+  visibleCommitVersion: number;
+};
+type OperationRecord = PendingOperationRecord | CommittedOperationRecord;
+type AppRouterState = {
+  activeOperation: OperationRecord | null;
+  bfcacheIds: BfcacheIdMap;
+  elements: AppElements;
+  interception: AppElementsInterception | null;
+  interceptionContext: string | null;
+  layoutFlags: LayoutFlags;
+  layoutIds: readonly string[];
+  previousNextUrl: string | null;
+  renderId: number;
+  navigationSnapshot: ClientNavigationRenderSnapshot;
+  rootLayoutTreePath: string | null;
+  routeId: string;
+  slotBindings: readonly AppElementsSlotBinding[];
+  visibleCommitVersion: number;
+};
+type AppRouterAction = {
+  bfcacheIds: BfcacheIdMap;
+  cacheEntryReuseProof?: CacheEntryReuseProof;
+  elements: AppElements;
+  interception: AppElementsInterception | null;
+  interceptionContext: string | null;
+  layoutFlags: LayoutFlags;
+  layoutIds: readonly string[];
+  navigationSnapshot: ClientNavigationRenderSnapshot;
+  operation: PendingOperationRecord;
+  previousNextUrl: string | null;
+  renderId: number;
+  rootLayoutTreePath: string | null;
+  reuseCurrentBfcacheIds: boolean;
+  routeId: string;
+  skippedLayoutIds: readonly string[];
+  slotBindings: readonly AppElementsSlotBinding[];
+  type: "navigate" | "replace" | "traverse";
+};
+type PendingNavigationCommit = {
+  action: AppRouterAction;
+  cacheEntryReuseProof?: CacheEntryReuseProof;
+  interception: AppElementsInterception | null;
+  interceptionContext: string | null;
+  previousNextUrl: string | null;
+  rootLayoutTreePath: string | null;
+  routeId: string;
+  skippedLayoutIds: readonly string[];
+};
+type AppNavigationPayloadOrigin = Readonly<{
+  origin: "fresh";
+} | {
+  origin: "visited-cache";
+}>;
+declare const FRESH_APP_NAVIGATION_PAYLOAD_ORIGIN: AppNavigationPayloadOrigin;
+declare const VISITED_CACHE_APP_NAVIGATION_PAYLOAD_ORIGIN: AppNavigationPayloadOrigin;
+type PendingNavigationCommitDisposition = "dispatch" | "hard-navigate" | "skip";
+type CacheRestorableAppPayloadMetadata = Readonly<{
+  cacheEntryReuseProof?: CacheEntryReuseProof;
+  skippedLayoutIds: readonly string[];
+}>;
+type DispatchPendingNavigationCommitDispositionDecision = {
+  disposition: "dispatch";
+  preserveAbsentSlots: boolean;
+  preserveElementIds: readonly string[];
+  preservePreviousSlotIds: readonly string[];
+  trace: NavigationTrace;
+};
+type NonDispatchPendingNavigationCommitDispositionDecision = {
+  disposition: Exclude<PendingNavigationCommitDisposition, "dispatch">;
+  preserveElementIds: readonly [];
+  trace: NavigationTrace;
+};
+type PendingNavigationCommitDispositionDecision = DispatchPendingNavigationCommitDispositionDecision | NonDispatchPendingNavigationCommitDispositionDecision;
+declare function isCacheRestorableAppPayloadMetadata(metadata: CacheRestorableAppPayloadMetadata): metadata is CacheRestorableAppPayloadMetadata & {
+  cacheEntryReuseProof: CacheEntryReuseProof;
+};
+declare function resolveInterceptionContextFromPreviousNextUrl(previousNextUrl: string | null, basePath?: string): string | null;
+type ResolveServerActionRequestStateOptions = {
+  actionId: string;
+  basePath: string;
+  elements: AppElements;
+  previousNextUrl: string | null;
+};
+type ResolveServerActionRequestStateResult = {
+  headers: Headers;
+};
+/**
+ * Pure: builds the fetch Headers for a server-action POST. Carries the same
+ * interception-context and mounted-slots headers the refresh path already
+ * sends, so the server-action re-render can rebuild the intercepted tree
+ * instead of replacing it with the direct route.
+ *
+ * Next.js sends `Next-URL: state.previousNextUrl || state.nextUrl` on action
+ * POSTs when `hasInterceptionRouteInCurrentTree(state.tree)`. Vinext's
+ * X-Vinext-Interception-Context is the equivalent signal for the server-side
+ * `findIntercept` lookup.
+ */
+declare function resolveServerActionRequestState(options: ResolveServerActionRequestStateOptions): ResolveServerActionRequestStateResult;
+declare function resolvePendingNavigationCommitDispositionDecision(options: {
+  activeNavigationId: number;
+  currentState: AppRouterState;
+  pending: PendingNavigationCommit;
+  routeManifest?: RouteManifest | null;
+  startedNavigationId: number;
+  targetHref?: string;
+}): PendingNavigationCommitDispositionDecision;
+declare function createPendingNavigationCommit(options: {
+  currentState: AppRouterState;
+  nextElements: Promise<AppElements>;
+  navigationSnapshot: ClientNavigationRenderSnapshot;
+  operationLane: OperationLane;
+  payloadOrigin: AppNavigationPayloadOrigin;
+  previousNextUrl?: string | null;
+  renderId: number;
+  restoredBfcacheIds?: BfcacheIdMap | null;
+  reuseCurrentBfcacheIds?: boolean;
+  type: "navigate" | "replace" | "traverse";
+}): Promise<PendingNavigationCommit>;
+//#endregion
+export { AppNavigationPayloadOrigin, AppRouterAction, AppRouterState, type BfcacheIdMap, CommittedOperationRecord, FRESH_APP_NAVIGATION_PAYLOAD_ORIGIN, type HistoryTraversalIntent, type OperationLane, PendingNavigationCommit, PendingOperationRecord, VISITED_CACHE_APP_NAVIGATION_PAYLOAD_ORIGIN, createBfcacheSegmentStateKeyMap, createHistoryStateWithNavigationMetadata, createHistoryStateWithPreviousNextUrl, createInitialBfcacheIdMap, createNextBfcacheIdMap, createPendingNavigationCommit, isCacheRestorableAppPayloadMetadata, isHistoryStateBfcacheVersionCurrent, preserveBfcacheIdsForMergedElements, readHistoryStateBfcacheIds, readHistoryStateBfcacheVersion, readHistoryStatePreviousNextUrl, readHistoryStateTraversalIndex, resolveHistoryTraversalIntent, resolveInterceptionContextFromPreviousNextUrl, resolvePendingNavigationCommitDispositionDecision, resolveServerActionRequestState };