vinext 0.0.55 → 0.1.1

package/dist/shims/pages-router-runtime.js

@@ -1,16 +1,24 @@
 //#region src/shims/pages-router-runtime.ts
 let pagesRouterPopStateHandler;
+let stampInitialHistoryStateFn;
 let pagesRouterRuntimeInstalled = false;
 function setPagesRouterPopStateHandler(handler) {
 	pagesRouterPopStateHandler = handler;
 }
+/**
+* Register the function that stamps Next.js-shaped state onto the initial
+* document entry (called once at install time). Router.ts registers this so
+* the runtime module stays free of router internals.
+*/
+function setStampInitialHistoryState(fn) {
+	stampInitialHistoryStateFn = fn;
+}
 function installPagesRouterRuntime() {
 	if (typeof window === "undefined" || pagesRouterRuntimeInstalled) return;
 	if (!pagesRouterPopStateHandler) throw new Error("[vinext] Pages Router runtime installed before next/router was initialized");
 	pagesRouterRuntimeInstalled = true;
+	stampInitialHistoryStateFn?.();
 	window.addEventListener("popstate", pagesRouterPopStateHandler);
 }
 //#endregion
-export { installPagesRouterRuntime, setPagesRouterPopStateHandler };
-
-//# sourceMappingURL=pages-router-runtime.js.map
+export { installPagesRouterRuntime, setPagesRouterPopStateHandler, setStampInitialHistoryState };

package/dist/shims/ppr-fallback-shell.d.ts

@@ -0,0 +1,29 @@
+//#region src/shims/ppr-fallback-shell.d.ts
+type PprFallbackShellState = {
+  abortController: AbortController;
+  cacheEpoch: number;
+  cacheReadyResolvers: Array<() => void>;
+  fallbackParamNames: ReadonlySet<string>;
+  hasDynamicBoundary: boolean;
+  isAbortScheduled: boolean;
+  pendingAbortCleanup: (() => void) | null;
+  pendingCacheReadyCleanup: (() => void) | null;
+  pendingCacheTasks: number;
+  phase: "warmup" | "final";
+  routePattern: string;
+};
+type CreatePprFallbackShellStateOptions = {
+  fallbackParamNames: readonly string[];
+  routePattern: string;
+};
+declare function createPprFallbackShellState(options: CreatePprFallbackShellStateOptions): PprFallbackShellState;
+declare function runWithPprFallbackShellState<T>(state: PprFallbackShellState, fn: () => T): T;
+declare function getPprFallbackShellState(): PprFallbackShellState | null;
+declare function trackPprFallbackShellCacheTask<T>(fn: () => Promise<T>, cacheVariant: string): Promise<T>;
+declare function createPprFallbackShellSuspensePromiseForState<T>(state: PprFallbackShellState, expression: string): Promise<T>;
+declare function createPprFallbackShellSuspensePromise<T>(expression: string): Promise<T> | null;
+declare function waitForPprFallbackShellCacheReady(state: PprFallbackShellState): Promise<void>;
+declare function preparePprFallbackShellFinalRender(state: PprFallbackShellState): void;
+declare function isPprFallbackShellAbortError(error: unknown): boolean;
+//#endregion
+export { PprFallbackShellState, createPprFallbackShellState, createPprFallbackShellSuspensePromise, createPprFallbackShellSuspensePromiseForState, getPprFallbackShellState, isPprFallbackShellAbortError, preparePprFallbackShellFinalRender, runWithPprFallbackShellState, trackPprFallbackShellCacheTask, waitForPprFallbackShellCacheReady };

package/dist/shims/ppr-fallback-shell.js

@@ -0,0 +1,149 @@
+import { getOrCreateAls } from "./internal/als-registry.js";
+import { makeHangingPromise } from "./internal/make-hanging-promise.js";
+//#region src/shims/ppr-fallback-shell.ts
+const pprFallbackShellAls = getOrCreateAls("vinext.pprFallbackShell.als");
+const pprFallbackShellCacheTaskStackAls = getOrCreateAls("vinext.pprFallbackShell.cacheTaskStack.als");
+function noop() {}
+function scheduleAfterTask(callback) {
+	let firstTimer = setTimeout(() => {
+		firstTimer = null;
+		secondTimer = setTimeout(() => {
+			secondTimer = null;
+			callback();
+		}, 0);
+	}, 0);
+	let secondTimer = null;
+	return () => {
+		if (firstTimer !== null) {
+			clearTimeout(firstTimer);
+			firstTimer = null;
+		}
+		if (secondTimer !== null) {
+			clearTimeout(secondTimer);
+			secondTimer = null;
+		}
+	};
+}
+function resolveCacheReadyIfSettled(state) {
+	if (state.pendingCacheTasks !== 0) return;
+	const resolvers = state.cacheReadyResolvers.splice(0);
+	for (const resolve of resolvers) resolve();
+}
+function cancelPendingCacheReady(state) {
+	if (state.pendingCacheReadyCleanup === null) return;
+	state.pendingCacheReadyCleanup();
+	state.pendingCacheReadyCleanup = null;
+}
+function scheduleCacheReadyIfSettled(state) {
+	if (state.pendingCacheTasks !== 0 || state.pendingCacheReadyCleanup !== null) return;
+	state.pendingCacheReadyCleanup = scheduleAfterTask(() => {
+		state.pendingCacheReadyCleanup = null;
+		resolveCacheReadyIfSettled(state);
+		if (state.phase === "final") scheduleAbortIfReady(state);
+	});
+}
+function scheduleAbortIfReady(state) {
+	if (state.phase !== "final" || !state.hasDynamicBoundary || state.pendingCacheTasks > 0 || state.pendingCacheReadyCleanup !== null || state.isAbortScheduled) return;
+	state.isAbortScheduled = true;
+	state.pendingAbortCleanup = scheduleAfterTask(() => {
+		state.pendingAbortCleanup = null;
+		state.isAbortScheduled = false;
+		if (state.phase === "final" && state.hasDynamicBoundary && state.pendingCacheTasks === 0 && state.pendingCacheReadyCleanup === null && !state.abortController.signal.aborted) state.abortController.abort();
+	});
+}
+function completeCacheTask(state, task) {
+	if (!task.isPending) return;
+	task.isPending = false;
+	if (task.epoch !== state.cacheEpoch) return;
+	state.pendingCacheTasks--;
+	scheduleCacheReadyIfSettled(state);
+}
+function ignoreCacheTask(state, task) {
+	if (!task.isPending || task.isIgnored) return;
+	task.isIgnored = true;
+	completeCacheTask(state, task);
+}
+function createPprFallbackShellState(options) {
+	return {
+		abortController: new AbortController(),
+		cacheEpoch: 0,
+		cacheReadyResolvers: [],
+		fallbackParamNames: new Set(options.fallbackParamNames),
+		hasDynamicBoundary: false,
+		isAbortScheduled: false,
+		pendingAbortCleanup: null,
+		pendingCacheReadyCleanup: null,
+		pendingCacheTasks: 0,
+		phase: "warmup",
+		routePattern: options.routePattern
+	};
+}
+function runWithPprFallbackShellState(state, fn) {
+	return pprFallbackShellAls.run(state, fn);
+}
+function getPprFallbackShellState() {
+	return pprFallbackShellAls.getStore() ?? null;
+}
+function trackPprFallbackShellCacheTask(fn, cacheVariant) {
+	const state = getPprFallbackShellState();
+	if (state === null || cacheVariant === "private") return fn();
+	cancelPendingCacheReady(state);
+	state.pendingCacheTasks++;
+	const task = {
+		epoch: state.cacheEpoch,
+		isIgnored: false,
+		isPending: true
+	};
+	const parentStack = pprFallbackShellCacheTaskStackAls.getStore() ?? [];
+	let promise;
+	try {
+		promise = pprFallbackShellCacheTaskStackAls.run([...parentStack, task], fn);
+	} catch (error) {
+		completeCacheTask(state, task);
+		return Promise.reject(error);
+	}
+	return promise.finally(() => {
+		if (!task.isIgnored) completeCacheTask(state, task);
+	});
+}
+function createPprFallbackShellSuspensePromiseForState(state, expression) {
+	state.hasDynamicBoundary = true;
+	for (const task of pprFallbackShellCacheTaskStackAls.getStore() ?? []) ignoreCacheTask(state, task);
+	scheduleCacheReadyIfSettled(state);
+	if (state.phase === "final") scheduleAbortIfReady(state);
+	const promise = makeHangingPromise(state.abortController.signal, state.routePattern, expression);
+	promise.catch(noop);
+	return promise;
+}
+function createPprFallbackShellSuspensePromise(expression) {
+	const state = getPprFallbackShellState();
+	if (state === null) return null;
+	return createPprFallbackShellSuspensePromiseForState(state, expression);
+}
+function waitForPprFallbackShellCacheReady(state) {
+	if (state.phase !== "warmup") return Promise.resolve();
+	return new Promise((resolve) => {
+		state.cacheReadyResolvers.push(resolve);
+		scheduleCacheReadyIfSettled(state);
+	});
+}
+function preparePprFallbackShellFinalRender(state) {
+	cancelPendingCacheReady(state);
+	if (state.pendingAbortCleanup !== null) {
+		state.pendingAbortCleanup();
+		state.pendingAbortCleanup = null;
+	}
+	state.abortController = new AbortController();
+	state.cacheEpoch++;
+	state.cacheReadyResolvers.length = 0;
+	state.hasDynamicBoundary = false;
+	state.isAbortScheduled = false;
+	state.pendingCacheTasks = 0;
+	state.phase = "final";
+}
+function isPprFallbackShellAbortError(error) {
+	if (typeof DOMException !== "undefined" && error instanceof DOMException && error.name === "AbortError") return true;
+	return error instanceof Error && error.name === "HangingPromiseRejectionError";
+}
+//#endregion
+export { createPprFallbackShellState, createPprFallbackShellSuspensePromise, createPprFallbackShellSuspensePromiseForState, getPprFallbackShellState, isPprFallbackShellAbortError, preparePprFallbackShellFinalRender, runWithPprFallbackShellState, trackPprFallbackShellCacheTask, waitForPprFallbackShellCacheReady };

package/dist/shims/readonly-url-search-params.d.ts

@@ -10,5 +10,4 @@ declare class ReadonlyURLSearchParams extends URLSearchParams {
   sort(): never;
 }
 //#endregion
-export { ReadonlyURLSearchParams };
-//# sourceMappingURL=readonly-url-search-params.d.ts.map
+export { ReadonlyURLSearchParams };

package/dist/shims/readonly-url-search-params.js

@@ -24,5 +24,3 @@ var ReadonlyURLSearchParams = class extends URLSearchParams {
 };
 //#endregion
 export { ReadonlyURLSearchParams };
-
-//# sourceMappingURL=readonly-url-search-params.js.map

package/dist/shims/request-context.d.ts

@@ -22,13 +22,18 @@
  *   ctx?.waitUntil(somePromise);
  */
 /**
- * Minimal ExecutionContext interface matching the Cloudflare Workers runtime.
- * Using a structural interface so this file has no runtime dependency on
- * Cloudflare types packages.
+ * Minimal structural ExecutionContext interface, kept free of any host-runtime
+ * dependency.
  */
 type ExecutionContextLike = {
   waitUntil(promise: Promise<unknown>): void;
   passThroughOnException?(): void;
+  /**
+   * Optional host-provided cache handle that some runtimes expose on the
+   * execution context. Typed as `unknown` to keep this module runtime-agnostic;
+   * CDN cache adapters that know the concrete shape narrow it themselves.
+   */
+  cache?: unknown;
 };
 /**
  * Run `fn` with the given `ExecutionContext` available via
@@ -50,5 +55,4 @@ declare function runWithExecutionContext<T>(ctx: ExecutionContextLike, fn: () =>
  */
 declare function getRequestExecutionContext(): ExecutionContextLike | null;
 //#endregion
-export { ExecutionContextLike, getRequestExecutionContext, runWithExecutionContext };
-//# sourceMappingURL=request-context.d.ts.map
+export { ExecutionContextLike, getRequestExecutionContext, runWithExecutionContext };

package/dist/shims/request-context.js

@@ -43,5 +43,3 @@ function getRequestExecutionContext() {
 }
 //#endregion
 export { getRequestExecutionContext, runWithExecutionContext };
-
-//# sourceMappingURL=request-context.js.map

package/dist/shims/request-state-types.d.ts

@@ -9,4 +9,4 @@ import { RouterState, SSRContext } from "./router-state.js";
 import { HeadState } from "./head-state.js";
 import { I18nState } from "./i18n-state.js";
 import { NavigationState } from "./navigation-state.js";
-export { type CacheLifeConfig, type CacheState, type ExecutionContextLike, type FetchCacheState, type HeadState, type HeadersAccessPhase, type HeadersContext, type I18nState, type NavigationContext, type NavigationState, type PrivateCacheState, type RootParamsState, type RouterState, type SSRContext, type VinextHeadersShimState };
+export type { CacheLifeConfig, CacheState, ExecutionContextLike, FetchCacheState, HeadState, HeadersAccessPhase, HeadersContext, I18nState, NavigationContext, NavigationState, PrivateCacheState, RootParamsState, RouterState, SSRContext, VinextHeadersShimState };

package/dist/shims/root-params.d.ts

@@ -9,5 +9,4 @@ declare function getRootParam(name: string): Promise<string | string[] | undefin
 declare function runWithRootParamsScope<T>(params: RootParams, fn: () => Promise<T>): Promise<T>;
 declare function runWithRootParamsScope<T>(params: RootParams, fn: () => T | Promise<T>): T | Promise<T>;
 //#endregion
-export { RootParams, RootParamsState, getRootParam, pickRootParams, runWithRootParamsScope, setRootParams };
-//# sourceMappingURL=root-params.d.ts.map
+export { RootParams, RootParamsState, getRootParam, pickRootParams, runWithRootParamsScope, setRootParams };

package/dist/shims/root-params.js

@@ -28,5 +28,3 @@ function runWithRootParamsScope(params, fn) {
 }
 //#endregion
 export { getRootParam, pickRootParams, runWithRootParamsScope, setRootParams };
-
-//# sourceMappingURL=root-params.js.map

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

@@ -12,6 +12,7 @@ type SSRContext = {
   pathname: string;
   query: Record<string, string | string[]>;
   asPath: string;
+  navigationIsReady?: boolean;
   locale?: string;
   locales?: string[];
   defaultLocale?: string;
@@ -28,5 +29,4 @@ type RouterState = {
 declare function runWithRouterState<T>(fn: () => Promise<T>): Promise<T>;
 declare function runWithRouterState<T>(fn: () => T | Promise<T>): T | Promise<T>;
 //#endregion
-export { RouterState, SSRContext, runWithRouterState };
-//# sourceMappingURL=router-state.d.ts.map
+export { RouterState, SSRContext, runWithRouterState };

package/dist/shims/router-state.js

@@ -1,6 +1,7 @@
 import { getOrCreateAls } from "./internal/als-registry.js";
 import { getRequestContext, isInsideUnifiedScope, runWithUnifiedStateMutation } from "./unified-request-context.js";
 import { _registerRouterStateAccessors } from "./router.js";
+import { registerRoutePatternForWarningAccessor } from "./internal/route-pattern-for-warning.js";
 //#region src/shims/router-state.ts
 /**
 * Server-only Pages Router state backed by AsyncLocalStorage.
@@ -33,7 +34,6 @@ _registerRouterStateAccessors({
 		_getState().ssrContext = ctx;
 	}
 });
+registerRoutePatternForWarningAccessor(() => _getState().ssrContext?.pathname ?? null);
 //#endregion
 export { runWithRouterState };
-
-//# sourceMappingURL=router-state.js.map

package/dist/shims/router.d.ts

@@ -61,6 +61,8 @@ type SSRContext = {
   pathname: string;
   query: Record<string, string | string[]>;
   asPath: string;
+  navigationIsReady?: boolean;
+  nextData?: VinextNextData;
   locale?: string;
   locales?: string[];
   defaultLocale?: string;
@@ -84,9 +86,9 @@ declare function _registerRouterStateAccessors(accessors: {
 }): void;
 declare function setSSRContext(ctx: SSRContext | null): void;
 type PagesNavigationContextShape = {
-  pathname: string;
+  pathname: string | null;
   searchParams: URLSearchParams;
-  params: Record<string, string | string[]>;
+  params: Record<string, string | string[]> | null;
 };
 /**
  * Cross-router compat shim source for `next/navigation` hooks.
@@ -105,6 +107,7 @@ type PagesNavigationContextShape = {
  * treat null as "App Router context, use normal app-router state".
  */
 declare function getPagesNavigationContext(): PagesNavigationContextShape | null;
+declare function getPagesNavigationIsReadyFromSerializedState(routePattern: string | undefined, searchString: string, nextData?: VinextNextData): boolean;
 /**
  * useRouter hook - Pages Router compatible.
  *
@@ -173,5 +176,4 @@ declare const RouterMethods: {
 };
 declare const Router: typeof RouterMethods & Omit<NextRouter, keyof typeof RouterMethods>;
 //#endregion
-export { ExcludeRouterProps, NextRouter, WithRouterProps, _registerRouterStateAccessors, applyNavigationLocale, Router as default, getPagesNavigationContext, isExternalUrl, isHashOnlyChange, setSSRContext, useRouter, withRouter, wrapWithRouterContext };
-//# sourceMappingURL=router.d.ts.map
+export { ExcludeRouterProps, NextRouter, WithRouterProps, _registerRouterStateAccessors, applyNavigationLocale, Router as default, getPagesNavigationContext, getPagesNavigationIsReadyFromSerializedState, isExternalUrl, isHashOnlyChange, setSSRContext, useRouter, withRouter, wrapWithRouterContext };