@qzsy/vinext 0.1.7

package/dist/shims/navigation-context-state.d.ts

@@ -0,0 +1,40 @@
+import * as React$1 from "react";
+
+//#region src/shims/navigation-context-state.d.ts
+/**
+ * Map of parallel route key to child segments below the current layout.
+ * The "children" key is always present.
+ */
+type SegmentMap = Readonly<Record<string, string[]>> & {
+  readonly children: string[];
+};
+type NavigationContext = {
+  pathname: string;
+  searchParams: URLSearchParams;
+  params: Record<string, string | string[]>;
+};
+declare const ServerInsertedHTMLContext: React$1.Context<((callback: () => unknown) => void) | null> | null;
+declare function getLayoutSegmentContext(): React$1.Context<SegmentMap> | null;
+declare function getBfcacheIdMapContext(): React$1.Context<Readonly<Record<string, string>> | null> | null;
+declare function getBfcacheSegmentIdContext(): React$1.Context<string | null> | null;
+type NavigationStateAccessors = {
+  getServerContext: () => NavigationContext | null;
+  setServerContext: (context: NavigationContext | null) => void;
+  getInsertedHTMLCallbacks: () => Array<() => unknown>;
+  clearInsertedHTMLCallbacks: () => void;
+};
+declare const GLOBAL_ACCESSORS_KEY: unique symbol;
+declare function clearClientHydrationContext(): void;
+/**
+ * Register request-scoped accessors supplied by navigation-state.ts.
+ * The global accessor key also bridges separate Vite module instances.
+ */
+declare function _registerStateAccessors(accessors: NavigationStateAccessors): void;
+declare function getNavigationContext(): NavigationContext | null;
+declare function setNavigationContext(context: NavigationContext | null): void;
+declare function registerServerInsertedHTMLCallback(callback: () => unknown): void;
+declare function flushServerInsertedHTML(): unknown[];
+declare function renderServerInsertedHTML(): unknown[];
+declare function clearServerInsertedHTML(): void;
+//#endregion
+export { GLOBAL_ACCESSORS_KEY, NavigationContext, NavigationStateAccessors, SegmentMap, ServerInsertedHTMLContext, _registerStateAccessors, clearClientHydrationContext, clearServerInsertedHTML, flushServerInsertedHTML, getBfcacheIdMapContext, getBfcacheSegmentIdContext, getLayoutSegmentContext, getNavigationContext, registerServerInsertedHTMLCallback, renderServerInsertedHTML, setNavigationContext };

package/dist/shims/navigation-context-state.js

@@ -0,0 +1,116 @@
+import * as React$1 from "react";
+//#region src/shims/navigation-context-state.ts
+const LAYOUT_SEGMENT_CONTEXT_KEY = Symbol.for("vinext.layoutSegmentContext");
+const SERVER_INSERTED_HTML_CONTEXT_KEY = Symbol.for("vinext.serverInsertedHTMLContext");
+const BFCACHE_ID_MAP_CONTEXT_KEY = Symbol.for("vinext.bfcacheIdMapContext");
+const BFCACHE_SEGMENT_ID_CONTEXT_KEY = Symbol.for("vinext.bfcacheSegmentIdContext");
+const GLOBAL_HYDRATION_CONTEXT_KEY = Symbol.for("vinext.navigation.clientHydrationContext");
+const NAVIGATION_FALLBACK_STATE_KEY = Symbol.for("vinext.navigation.fallback");
+function createContextIfAvailable(defaultValue) {
+	return typeof React$1.createContext === "function" ? React$1.createContext(defaultValue) : null;
+}
+function getServerInsertedHTMLContext() {
+	const globalState = globalThis;
+	if (!globalState[SERVER_INSERTED_HTML_CONTEXT_KEY]) globalState[SERVER_INSERTED_HTML_CONTEXT_KEY] = createContextIfAvailable(null);
+	return globalState[SERVER_INSERTED_HTML_CONTEXT_KEY] ?? null;
+}
+const ServerInsertedHTMLContext = getServerInsertedHTMLContext();
+function getLayoutSegmentContext() {
+	const globalState = globalThis;
+	if (!globalState[LAYOUT_SEGMENT_CONTEXT_KEY]) globalState[LAYOUT_SEGMENT_CONTEXT_KEY] = createContextIfAvailable({ children: [] });
+	return globalState[LAYOUT_SEGMENT_CONTEXT_KEY] ?? null;
+}
+function getBfcacheIdMapContext() {
+	const globalState = globalThis;
+	if (!globalState[BFCACHE_ID_MAP_CONTEXT_KEY]) globalState[BFCACHE_ID_MAP_CONTEXT_KEY] = createContextIfAvailable(null);
+	return globalState[BFCACHE_ID_MAP_CONTEXT_KEY] ?? null;
+}
+function getBfcacheSegmentIdContext() {
+	const globalState = globalThis;
+	if (!globalState[BFCACHE_SEGMENT_ID_CONTEXT_KEY]) globalState[BFCACHE_SEGMENT_ID_CONTEXT_KEY] = createContextIfAvailable(null);
+	return globalState[BFCACHE_SEGMENT_ID_CONTEXT_KEY] ?? null;
+}
+const GLOBAL_ACCESSORS_KEY = Symbol.for("vinext.navigation.globalAccessors");
+function getFallbackState() {
+	const globalState = globalThis;
+	return globalState[NAVIGATION_FALLBACK_STATE_KEY] ??= {
+		serverContext: null,
+		serverInsertedHTMLCallbacks: []
+	};
+}
+function getGlobalAccessors() {
+	return globalThis[GLOBAL_ACCESSORS_KEY];
+}
+function getClientHydrationContext() {
+	const globalState = globalThis;
+	if (Object.prototype.hasOwnProperty.call(globalState, GLOBAL_HYDRATION_CONTEXT_KEY)) return globalState[GLOBAL_HYDRATION_CONTEXT_KEY] ?? null;
+}
+function setClientHydrationContext(context) {
+	globalThis[GLOBAL_HYDRATION_CONTEXT_KEY] = context;
+}
+function clearClientHydrationContext() {
+	if (typeof window !== "undefined") setClientHydrationContext(null);
+}
+let getServerContext = () => {
+	if (typeof window !== "undefined") {
+		const hydrationContext = getClientHydrationContext();
+		return hydrationContext !== void 0 ? hydrationContext : getFallbackState().serverContext;
+	}
+	return getGlobalAccessors()?.getServerContext() ?? getFallbackState().serverContext;
+};
+let setServerContext = (context) => {
+	if (typeof window !== "undefined") {
+		getFallbackState().serverContext = context;
+		setClientHydrationContext(context);
+		return;
+	}
+	const accessors = getGlobalAccessors();
+	if (accessors) accessors.setServerContext(context);
+	else getFallbackState().serverContext = context;
+};
+let getInsertedHTMLCallbacks = () => getGlobalAccessors()?.getInsertedHTMLCallbacks() ?? getFallbackState().serverInsertedHTMLCallbacks;
+let clearInsertedHTMLCallbacks = () => {
+	const accessors = getGlobalAccessors();
+	if (accessors) accessors.clearInsertedHTMLCallbacks();
+	else getFallbackState().serverInsertedHTMLCallbacks = [];
+};
+/**
+* Register request-scoped accessors supplied by navigation-state.ts.
+* The global accessor key also bridges separate Vite module instances.
+*/
+function _registerStateAccessors(accessors) {
+	getServerContext = accessors.getServerContext;
+	setServerContext = accessors.setServerContext;
+	getInsertedHTMLCallbacks = accessors.getInsertedHTMLCallbacks;
+	clearInsertedHTMLCallbacks = accessors.clearInsertedHTMLCallbacks;
+}
+function getNavigationContext() {
+	return getServerContext();
+}
+function setNavigationContext(context) {
+	setServerContext(context);
+}
+function registerServerInsertedHTMLCallback(callback) {
+	getInsertedHTMLCallbacks().push(callback);
+}
+function renderInsertedHTMLCallbacks(clear) {
+	const callbacks = getInsertedHTMLCallbacks();
+	const results = [];
+	for (const callback of callbacks) try {
+		const result = callback();
+		if (result != null) results.push(result);
+	} catch {}
+	if (clear) callbacks.length = 0;
+	return results;
+}
+function flushServerInsertedHTML() {
+	return renderInsertedHTMLCallbacks(true);
+}
+function renderServerInsertedHTML() {
+	return renderInsertedHTMLCallbacks(false);
+}
+function clearServerInsertedHTML() {
+	clearInsertedHTMLCallbacks();
+}
+//#endregion
+export { GLOBAL_ACCESSORS_KEY, ServerInsertedHTMLContext, _registerStateAccessors, clearClientHydrationContext, clearServerInsertedHTML, flushServerInsertedHTML, getBfcacheIdMapContext, getBfcacheSegmentIdContext, getLayoutSegmentContext, getNavigationContext, registerServerInsertedHTMLCallback, renderServerInsertedHTML, setNavigationContext };

package/dist/shims/navigation-errors.d.ts

@@ -0,0 +1,55 @@
+//#region src/shims/navigation-errors.d.ts
+/**
+ * Server-safe navigation control-flow errors and predicates.
+ *
+ * This module intentionally has no React or browser-runtime dependencies so
+ * RSC, SSR, and the public next/navigation shim can share one implementation.
+ */
+declare const HTTP_ERROR_FALLBACK_ERROR_CODE = "NEXT_HTTP_ERROR_FALLBACK";
+declare function isHTTPAccessFallbackError(error: unknown): boolean;
+declare function getAccessFallbackHTTPStatus(error: unknown): number;
+declare enum RedirectType {
+  push = "push",
+  replace = "replace"
+}
+/**
+ * The omitted redirect type is resolved by the catch site: push for Server
+ * Actions and replace for ordinary SSR/RSC rendering.
+ */
+declare function redirect(url: string, type?: "replace" | "push" | RedirectType): never;
+declare function permanentRedirect(url: string, type?: "replace" | "push" | RedirectType): never;
+declare function notFound(): never;
+declare function forbidden(): never;
+declare function unauthorized(): never;
+type RedirectErrorShape = Error & {
+  digest: string;
+};
+/**
+ * vinext accepts its three-part redirect digest and Next.js's five-part form.
+ * A prefix check is deliberate because vinext permits an empty redirect type.
+ */
+declare function isRedirectError(error: unknown): error is RedirectErrorShape;
+declare function decodeRedirectError(digest: string): {
+  url: string;
+  type: "push" | "replace";
+} | null;
+declare function isNextRouterError(error: unknown): boolean;
+declare class BailoutToCSRError extends Error {
+  readonly digest = "BAILOUT_TO_CLIENT_SIDE_RENDERING";
+  readonly reason: string;
+  constructor(reason: string);
+}
+declare function isBailoutToCSRError(error: unknown): error is BailoutToCSRError;
+declare class DynamicServerError extends Error {
+  readonly digest = "DYNAMIC_SERVER_USAGE";
+  readonly description: string;
+  constructor(description: string);
+}
+declare function isDynamicServerError(error: unknown): error is DynamicServerError;
+/**
+ * Rethrow framework control-flow signals before user error handling consumes
+ * them. This covers the categories vinext can currently produce.
+ */
+declare function unstable_rethrow(error: unknown): void;
+//#endregion
+export { BailoutToCSRError, DynamicServerError, HTTP_ERROR_FALLBACK_ERROR_CODE, RedirectType, decodeRedirectError, forbidden, getAccessFallbackHTTPStatus, isBailoutToCSRError, isDynamicServerError, isHTTPAccessFallbackError, isNextRouterError, isRedirectError, notFound, permanentRedirect, redirect, unauthorized, unstable_rethrow };

package/dist/shims/navigation-errors.js

@@ -0,0 +1,110 @@
+//#region src/shims/navigation-errors.ts
+/**
+* Server-safe navigation control-flow errors and predicates.
+*
+* This module intentionally has no React or browser-runtime dependencies so
+* RSC, SSR, and the public next/navigation shim can share one implementation.
+*/
+const HTTP_ERROR_FALLBACK_ERROR_CODE = "NEXT_HTTP_ERROR_FALLBACK";
+function isHTTPAccessFallbackError(error) {
+	if (!error || typeof error !== "object" || !("digest" in error)) return false;
+	const digest = String(error.digest);
+	return digest === "NEXT_NOT_FOUND" || digest.startsWith(`NEXT_HTTP_ERROR_FALLBACK;`);
+}
+function getAccessFallbackHTTPStatus(error) {
+	if (error && typeof error === "object" && "digest" in error) {
+		const digest = String(error.digest);
+		if (digest === "NEXT_NOT_FOUND") return 404;
+		if (digest.startsWith(`NEXT_HTTP_ERROR_FALLBACK;`)) return Number.parseInt(digest.split(";")[1], 10);
+	}
+	return 404;
+}
+let RedirectType = /* @__PURE__ */ function(RedirectType) {
+	RedirectType["push"] = "push";
+	RedirectType["replace"] = "replace";
+	return RedirectType;
+}({});
+var VinextNavigationError = class extends Error {
+	digest;
+	constructor(message, digest) {
+		super(message);
+		this.digest = digest;
+	}
+};
+/**
+* The omitted redirect type is resolved by the catch site: push for Server
+* Actions and replace for ordinary SSR/RSC rendering.
+*/
+function redirect(url, type) {
+	throw new VinextNavigationError(`NEXT_REDIRECT:${url}`, `NEXT_REDIRECT;${type ?? ""};${encodeURIComponent(url)}`);
+}
+function permanentRedirect(url, type = "replace") {
+	throw new VinextNavigationError(`NEXT_REDIRECT:${url}`, `NEXT_REDIRECT;${type};${encodeURIComponent(url)};308`);
+}
+function notFound() {
+	throw new VinextNavigationError("NEXT_NOT_FOUND", `${HTTP_ERROR_FALLBACK_ERROR_CODE};404`);
+}
+function forbidden() {
+	throw new VinextNavigationError("NEXT_FORBIDDEN", `${HTTP_ERROR_FALLBACK_ERROR_CODE};403`);
+}
+function unauthorized() {
+	throw new VinextNavigationError("NEXT_UNAUTHORIZED", `${HTTP_ERROR_FALLBACK_ERROR_CODE};401`);
+}
+/**
+* vinext accepts its three-part redirect digest and Next.js's five-part form.
+* A prefix check is deliberate because vinext permits an empty redirect type.
+*/
+function isRedirectError(error) {
+	return !!error && typeof error === "object" && "digest" in error && typeof error.digest === "string" && error.digest.startsWith("NEXT_REDIRECT;");
+}
+function decodeRedirectError(digest) {
+	if (!digest.startsWith("NEXT_REDIRECT;")) return null;
+	const parts = digest.split(";");
+	const encodedTarget = parts.length >= 5 ? parts.slice(2, -2).join(";") : parts[2];
+	if (!encodedTarget) return null;
+	try {
+		return {
+			url: decodeURIComponent(encodedTarget),
+			type: parts[1] === "push" ? "push" : "replace"
+		};
+	} catch {
+		return null;
+	}
+}
+function isNextRouterError(error) {
+	return isRedirectError(error) || isHTTPAccessFallbackError(error);
+}
+const BAILOUT_TO_CSR_DIGEST = "BAILOUT_TO_CLIENT_SIDE_RENDERING";
+var BailoutToCSRError = class extends Error {
+	digest = BAILOUT_TO_CSR_DIGEST;
+	reason;
+	constructor(reason) {
+		super(`Bail out to client-side rendering: ${reason}`);
+		this.reason = reason;
+	}
+};
+function isBailoutToCSRError(error) {
+	return !!error && typeof error === "object" && "digest" in error && error.digest === BAILOUT_TO_CSR_DIGEST;
+}
+const DYNAMIC_SERVER_USAGE_DIGEST = "DYNAMIC_SERVER_USAGE";
+var DynamicServerError = class extends Error {
+	digest = DYNAMIC_SERVER_USAGE_DIGEST;
+	description;
+	constructor(description) {
+		super(`Dynamic server usage: ${description}`);
+		this.description = description;
+	}
+};
+function isDynamicServerError(error) {
+	return !!error && typeof error === "object" && "digest" in error && error.digest === DYNAMIC_SERVER_USAGE_DIGEST;
+}
+/**
+* Rethrow framework control-flow signals before user error handling consumes
+* them. This covers the categories vinext can currently produce.
+*/
+function unstable_rethrow(error) {
+	if (isNextRouterError(error) || isBailoutToCSRError(error) || isDynamicServerError(error)) throw error;
+	if (error instanceof Error && "cause" in error) unstable_rethrow(error.cause);
+}
+//#endregion
+export { BailoutToCSRError, DynamicServerError, HTTP_ERROR_FALLBACK_ERROR_CODE, RedirectType, decodeRedirectError, forbidden, getAccessFallbackHTTPStatus, isBailoutToCSRError, isDynamicServerError, isHTTPAccessFallbackError, isNextRouterError, isRedirectError, notFound, permanentRedirect, redirect, unauthorized, unstable_rethrow };

package/dist/shims/navigation-server.d.ts

@@ -0,0 +1,3 @@
+import { GLOBAL_ACCESSORS_KEY, NavigationContext, NavigationStateAccessors, SegmentMap, ServerInsertedHTMLContext, _registerStateAccessors, clearClientHydrationContext, clearServerInsertedHTML, flushServerInsertedHTML, getBfcacheIdMapContext, getBfcacheSegmentIdContext, getLayoutSegmentContext, getNavigationContext, registerServerInsertedHTMLCallback, renderServerInsertedHTML, setNavigationContext } from "./navigation-context-state.js";
+import { BailoutToCSRError, DynamicServerError, HTTP_ERROR_FALLBACK_ERROR_CODE, RedirectType, decodeRedirectError, forbidden, getAccessFallbackHTTPStatus, isBailoutToCSRError, isDynamicServerError, isHTTPAccessFallbackError, isNextRouterError, isRedirectError, notFound, permanentRedirect, redirect, unauthorized, unstable_rethrow } from "./navigation-errors.js";
+export { BailoutToCSRError, DynamicServerError, GLOBAL_ACCESSORS_KEY, HTTP_ERROR_FALLBACK_ERROR_CODE, type NavigationContext, type NavigationStateAccessors, RedirectType, type SegmentMap, ServerInsertedHTMLContext, _registerStateAccessors, clearClientHydrationContext, clearServerInsertedHTML, decodeRedirectError, flushServerInsertedHTML, forbidden, getAccessFallbackHTTPStatus, getBfcacheIdMapContext, getBfcacheSegmentIdContext, getLayoutSegmentContext, getNavigationContext, isBailoutToCSRError, isDynamicServerError, isHTTPAccessFallbackError, isNextRouterError, isRedirectError, notFound, permanentRedirect, redirect, registerServerInsertedHTMLCallback, renderServerInsertedHTML, setNavigationContext, unauthorized, unstable_rethrow };

package/dist/shims/navigation-server.js

@@ -0,0 +1,3 @@
+import { GLOBAL_ACCESSORS_KEY, ServerInsertedHTMLContext, _registerStateAccessors, clearClientHydrationContext, clearServerInsertedHTML, flushServerInsertedHTML, getBfcacheIdMapContext, getBfcacheSegmentIdContext, getLayoutSegmentContext, getNavigationContext, registerServerInsertedHTMLCallback, renderServerInsertedHTML, setNavigationContext } from "./navigation-context-state.js";
+import { BailoutToCSRError, DynamicServerError, HTTP_ERROR_FALLBACK_ERROR_CODE, RedirectType, decodeRedirectError, forbidden, getAccessFallbackHTTPStatus, isBailoutToCSRError, isDynamicServerError, isHTTPAccessFallbackError, isNextRouterError, isRedirectError, notFound, permanentRedirect, redirect, unauthorized, unstable_rethrow } from "./navigation-errors.js";
+export { BailoutToCSRError, DynamicServerError, GLOBAL_ACCESSORS_KEY, HTTP_ERROR_FALLBACK_ERROR_CODE, RedirectType, ServerInsertedHTMLContext, _registerStateAccessors, clearClientHydrationContext, clearServerInsertedHTML, decodeRedirectError, flushServerInsertedHTML, forbidden, getAccessFallbackHTTPStatus, getBfcacheIdMapContext, getBfcacheSegmentIdContext, getLayoutSegmentContext, getNavigationContext, isBailoutToCSRError, isDynamicServerError, isHTTPAccessFallbackError, isNextRouterError, isRedirectError, notFound, permanentRedirect, redirect, registerServerInsertedHTMLCallback, renderServerInsertedHTML, setNavigationContext, unauthorized, unstable_rethrow };

package/dist/shims/navigation-state.d.ts

@@ -0,0 +1,25 @@
+import { NavigationContext } from "./navigation-context-state.js";
+//#region src/shims/navigation-state.d.ts
+type NavigationState = {
+  serverContext: NavigationContext | null;
+  serverInsertedHTMLCallbacks: Array<() => unknown>;
+};
+/**
+ * Run a function within a navigation ALS scope.
+ * Ensures per-request isolation for navigation context and
+ * useServerInsertedHTML callbacks on concurrent runtimes.
+ */
+declare function runWithNavigationContext<T>(fn: () => Promise<T>): Promise<T>;
+declare function runWithNavigationContext<T>(fn: () => T | Promise<T>): T | Promise<T>;
+/**
+ * Run a function with a fresh useServerInsertedHTML callback list while
+ * preserving the current navigation context.
+ *
+ * Used by the Pages Router ISR cache-fill pass: it is the same request/path,
+ * but it needs a fresh callback collection so CSS-in-JS insertions from the
+ * streamed render cannot accumulate into the cache-fill render.
+ */
+declare function runWithServerInsertedHTMLState<T>(fn: () => Promise<T>): Promise<T>;
+declare function runWithServerInsertedHTMLState<T>(fn: () => T | Promise<T>): T | Promise<T>;
+//#endregion
+export { NavigationState, runWithNavigationContext, runWithServerInsertedHTMLState };

package/dist/shims/navigation-state.js

@@ -0,0 +1,66 @@
+import { getOrCreateAls } from "./internal/als-registry.js";
+import { getRequestContext, isInsideUnifiedScope, runWithUnifiedStateMutation } from "./unified-request-context.js";
+import { GLOBAL_ACCESSORS_KEY, _registerStateAccessors } from "./navigation-context-state.js";
+import "./navigation-server.js";
+//#region src/shims/navigation-state.ts
+/**
+* Server-only navigation state backed by AsyncLocalStorage.
+*
+* This module provides request-scoped isolation for navigation context
+* and useServerInsertedHTML callbacks. Without ALS, concurrent requests
+* on Cloudflare Workers would share module-level state and leak data
+* (pathnames, params, CSS-in-JS styles) between requests.
+*
+* This module is server-only — it imports node:async_hooks and must NOT
+* be bundled for the browser. The dual-environment navigation.ts shim
+* uses a registration pattern so it works in both environments.
+*/
+const _FALLBACK_KEY = Symbol.for("vinext.navigation.fallback");
+const _g = globalThis;
+const _als = getOrCreateAls("vinext.navigation.als");
+const _fallbackState = _g[_FALLBACK_KEY] ??= {
+	serverContext: null,
+	serverInsertedHTMLCallbacks: []
+};
+function _getState() {
+	if (isInsideUnifiedScope()) return getRequestContext();
+	return _als.getStore() ?? _fallbackState;
+}
+function runWithNavigationContext(fn) {
+	if (isInsideUnifiedScope()) return runWithUnifiedStateMutation((uCtx) => {
+		uCtx.serverContext = null;
+		uCtx.serverInsertedHTMLCallbacks = [];
+	}, fn);
+	return _als.run({
+		serverContext: null,
+		serverInsertedHTMLCallbacks: []
+	}, fn);
+}
+function runWithServerInsertedHTMLState(fn) {
+	if (isInsideUnifiedScope()) return runWithUnifiedStateMutation((uCtx) => {
+		uCtx.serverInsertedHTMLCallbacks = [];
+	}, fn);
+	const state = {
+		serverContext: (_als.getStore() ?? _fallbackState).serverContext,
+		serverInsertedHTMLCallbacks: []
+	};
+	return _als.run(state, fn);
+}
+const _accessors = {
+	getServerContext() {
+		return _getState().serverContext;
+	},
+	setServerContext(ctx) {
+		_getState().serverContext = ctx;
+	},
+	getInsertedHTMLCallbacks() {
+		return _getState().serverInsertedHTMLCallbacks;
+	},
+	clearInsertedHTMLCallbacks() {
+		_getState().serverInsertedHTMLCallbacks = [];
+	}
+};
+_registerStateAccessors(_accessors);
+globalThis[GLOBAL_ACCESSORS_KEY] = _accessors;
+//#endregion
+export { runWithNavigationContext, runWithServerInsertedHTMLState };