vinext 1.0.1 → 1.2.0

package/dist/shims/error-boundary.js

@@ -2,7 +2,7 @@
 import { isNavigationSignalError } from "../utils/navigation-signal.js";
 import { decodeRedirectError, isRedirectError } from "./navigation-errors.js";
 import "./navigation-server.js";
-import { useErrorBoundaryPathname, useErrorBoundaryRouter } from "./error-boundary-navigation.js";
+import { isRedirectToCurrentUrl, useErrorBoundaryPathname, useErrorBoundaryRouter } from "./error-boundary-navigation.js";
 import DefaultGlobalError from "./default-global-error.js";
 import { handleAppNavigationFailure } from "../client/app-nav-failure-handler.js";
 import { VINEXT_DEV_ERROR_RECOVERY_EVENT } from "../utils/dev-error-recovery-event.js";
@@ -43,9 +43,13 @@ function removeDevErrorRecoveryListener(listener) {
 	if (typeof window === "undefined") return;
 	window.removeEventListener(VINEXT_DEV_ERROR_RECOVERY_EVENT, listener);
 }
-function HandleRedirect({ redirect, redirectType, reset }) {
+function HandleRedirect({ redirect, redirectType, reset, stopsSelfRedirect }) {
 	const router = useErrorBoundaryRouter();
 	React.useEffect(() => {
+		if (stopsSelfRedirect && isRedirectToCurrentUrl(redirect)) {
+			console.error("[vinext] redirect() resolved to the current URL — not following it, to prevent an infinite loop.");
+			return;
+		}
 		React.startTransition(() => {
 			if (redirectType === "push") router.push(redirect);
 			else router.replace(redirect);
@@ -55,7 +59,8 @@ function HandleRedirect({ redirect, redirectType, reset }) {
 		redirect,
 		redirectType,
 		reset,
-		router
+		router,
+		stopsSelfRedirect
 	]);
 	return null;
 }
@@ -64,7 +69,17 @@ var RedirectErrorBoundary = class extends React.Component {
 		super(props);
 		this.state = {
 			redirect: null,
-			redirectType: null
+			redirectType: null,
+			previousResetKey: normalizeBoundaryResetKey(props.resetKey)
+		};
+	}
+	static getDerivedStateFromProps(props, state) {
+		const resetKey = normalizeBoundaryResetKey(props.resetKey);
+		if (resetKey === state.previousResetKey) return null;
+		return {
+			redirect: null,
+			redirectType: null,
+			previousResetKey: resetKey
 		};
 	}
 	static getDerivedStateFromError(error) {
@@ -90,13 +105,17 @@ var RedirectErrorBoundary = class extends React.Component {
 			reset: () => this.setState({
 				redirect: null,
 				redirectType: null
-			})
+			}),
+			stopsSelfRedirect: this.props.resetKey !== void 0
 		});
 		return this.props.children;
 	}
 };
-function RedirectBoundary({ children }) {
-	return /* @__PURE__ */ jsx(RedirectErrorBoundary, { children });
+function RedirectBoundary({ children, resetKey }) {
+	return /* @__PURE__ */ jsx(RedirectErrorBoundary, {
+		resetKey,
+		children
+	});
 }
 /**
 * Generic ErrorBoundary used to wrap route segments with error.tsx.

package/dist/shims/fetch-cache-state.d.ts

@@ -0,0 +1,66 @@
+//#region src/shims/fetch-cache-state.d.ts
+/**
+ * Request-scoped fetch cache state, kept apart from the fetch patching in
+ * fetch-cache.ts so modules that only read or update it, like next/cache,
+ * don't pull the patched fetch and its Node.js builtins into client graphs
+ * that import them.
+ */
+export type FetchDedupeEntry = {
+  key: string;
+  promise: Promise<Response>;
+  response: Response | null;
+};
+export type FetchCacheState = {
+  cacheableFetchUrls: Set<string>;
+  currentRequestTags: string[];
+  currentFetchSoftTags: string[];
+  currentFetchCacheMode: FetchCacheMode | null;
+  currentFetchRevalidate: number | null;
+  currentForceDynamicFetchDefault: boolean;
+  dynamicFetchUrls: Set<string>;
+  refreshStaleFetchesInForeground: boolean;
+  isFetchDedupeActive: boolean;
+  currentFetchDedupeEntries: Map<string, FetchDedupeEntry[]>;
+  nextFetchId: number;
+};
+export type FetchCacheMode = "auto" | "default-cache" | "default-no-store" | "force-cache" | "force-no-store" | "only-cache" | "only-no-store";
+export declare const fetchCacheAls: import("node:async_hooks").AsyncLocalStorage<FetchCacheState>;
+/**
+ * Process-wide state used only while the deprecated `withFetchCache()` is
+ * active, which marks it with `isFetchDedupeActive`.
+ */
+export declare const fallbackFetchCacheState: FetchCacheState;
+export declare function getFetchCacheState(): FetchCacheState;
+/**
+ * Reset the fallback state for a new request.  Used by `withFetchCache()`
+ * in single-threaded contexts where ALS.run() isn't used.
+ */
+export declare function resetFallbackFetchCacheState(isFetchDedupeActive: boolean): void;
+/**
+ * Append cache tags to the current request's collected tags.
+ *
+ * Mirrors Next.js's `propagateCacheLifeAndTagsToRevalidateStore`: tags declared
+ * inside a `"use cache"` function (via `cacheTag()`, persisted on the data cache
+ * entry) must also bubble up to the surrounding page / route-handler ISR entry
+ * so `revalidateTag()` / `revalidatePath()` can evict the rendered output, not
+ * just the inner data cache entry. Without this, a cached `"use cache"` result
+ * keeps being served from a stale page/route entry after its tag is revalidated
+ * (issue #1453). Tags are already encoded by the caller; deduped to match the
+ * tagged-fetch path. A no-op for empty input.
+ */
+export declare function addCollectedRequestTags(tags: readonly string[]): void;
+/**
+ * Read the path-derived soft tags for the current render.
+ *
+ * Used by the "use cache" runtime to pass soft tags to the cache handler
+ * so that `revalidatePath()` invalidates "use cache" entries during the
+ * affected route's next request, even when the entry carries no hard tags.
+ */
+export declare function getCurrentFetchSoftTags(): string[];
+/**
+ * Run `fn` with the request's fetch settings but its own record of the tags and
+ * URLs its fetches touch, so work done on the request's behalf after the fact
+ * (a background regeneration) leaves the request's response untouched.
+ */
+export declare function runWithDetachedFetchObservations<T>(fn: () => Promise<T>): Promise<T>;
+//#endregion

package/dist/shims/fetch-cache-state.js

@@ -0,0 +1,92 @@
+import { getOrCreateAls } from "./internal/als-registry.js";
+import { getRequestContext, isInsideUnifiedScope, runWithUnifiedStateMutation } from "./unified-request-context.js";
+//#region src/shims/fetch-cache-state.ts
+/**
+* Request-scoped fetch cache state, kept apart from the fetch patching in
+* fetch-cache.ts so modules that only read or update it, like next/cache,
+* don't pull the patched fetch and its Node.js builtins into client graphs
+* that import them.
+*/
+const _FALLBACK_KEY = Symbol.for("vinext.fetchCache.fallback");
+const fetchCacheAls = getOrCreateAls("vinext.fetchCache.als");
+function createFetchCacheState() {
+	return {
+		cacheableFetchUrls: /* @__PURE__ */ new Set(),
+		currentRequestTags: [],
+		currentFetchSoftTags: [],
+		currentFetchCacheMode: null,
+		currentFetchRevalidate: null,
+		currentForceDynamicFetchDefault: false,
+		dynamicFetchUrls: /* @__PURE__ */ new Set(),
+		refreshStaleFetchesInForeground: false,
+		isFetchDedupeActive: false,
+		currentFetchDedupeEntries: /* @__PURE__ */ new Map(),
+		nextFetchId: 1
+	};
+}
+/**
+* Process-wide state used only while the deprecated `withFetchCache()` is
+* active, which marks it with `isFetchDedupeActive`.
+*/
+const fallbackFetchCacheState = globalThis[_FALLBACK_KEY] ??= createFetchCacheState();
+function getFetchCacheState() {
+	if (isInsideUnifiedScope()) return getRequestContext();
+	const store = fetchCacheAls.getStore();
+	if (store) return store;
+	if (fallbackFetchCacheState.isFetchDedupeActive) return fallbackFetchCacheState;
+	return createFetchCacheState();
+}
+/**
+* Reset the fallback state for a new request.  Used by `withFetchCache()`
+* in single-threaded contexts where ALS.run() isn't used.
+*/
+function resetFallbackFetchCacheState(isFetchDedupeActive) {
+	Object.assign(fallbackFetchCacheState, createFetchCacheState(), { isFetchDedupeActive });
+}
+/**
+* Append cache tags to the current request's collected tags.
+*
+* Mirrors Next.js's `propagateCacheLifeAndTagsToRevalidateStore`: tags declared
+* inside a `"use cache"` function (via `cacheTag()`, persisted on the data cache
+* entry) must also bubble up to the surrounding page / route-handler ISR entry
+* so `revalidateTag()` / `revalidatePath()` can evict the rendered output, not
+* just the inner data cache entry. Without this, a cached `"use cache"` result
+* keeps being served from a stale page/route entry after its tag is revalidated
+* (issue #1453). Tags are already encoded by the caller; deduped to match the
+* tagged-fetch path. A no-op for empty input.
+*/
+function addCollectedRequestTags(tags) {
+	if (tags.length === 0) return;
+	const reqTags = getFetchCacheState().currentRequestTags;
+	for (const tag of tags) if (!reqTags.includes(tag)) reqTags.push(tag);
+}
+/**
+* Read the path-derived soft tags for the current render.
+*
+* Used by the "use cache" runtime to pass soft tags to the cache handler
+* so that `revalidatePath()` invalidates "use cache" entries during the
+* affected route's next request, even when the entry carries no hard tags.
+*/
+function getCurrentFetchSoftTags() {
+	return getFetchCacheState().currentFetchSoftTags;
+}
+/**
+* Run `fn` with the request's fetch settings but its own record of the tags and
+* URLs its fetches touch, so work done on the request's behalf after the fact
+* (a background regeneration) leaves the request's response untouched.
+*/
+function runWithDetachedFetchObservations(fn) {
+	if (isInsideUnifiedScope()) return runWithUnifiedStateMutation((uCtx) => {
+		uCtx.cacheableFetchUrls = /* @__PURE__ */ new Set();
+		uCtx.currentRequestTags = [];
+		uCtx.dynamicFetchUrls = /* @__PURE__ */ new Set();
+	}, fn);
+	return fetchCacheAls.run({
+		...getFetchCacheState(),
+		cacheableFetchUrls: /* @__PURE__ */ new Set(),
+		currentRequestTags: [],
+		dynamicFetchUrls: /* @__PURE__ */ new Set()
+	}, fn);
+}
+//#endregion
+export { addCollectedRequestTags, fallbackFetchCacheState, fetchCacheAls, getCurrentFetchSoftTags, getFetchCacheState, resetFallbackFetchCacheState, runWithDetachedFetchObservations };

package/dist/shims/fetch-cache.d.ts

@@ -1,33 +1,9 @@
+import { FetchCacheMode, FetchCacheState, addCollectedRequestTags, getCurrentFetchSoftTags, runWithDetachedFetchObservations } from "./fetch-cache-state.js";
 //#region src/shims/fetch-cache.d.ts
-/**
- * Extended fetch() with Next.js caching semantics.
- *
- * Patches `globalThis.fetch` during server rendering to support:
- *
- *   fetch(url, { next: { revalidate: 60, tags: ['posts'] } })
- *   fetch(url, { cache: 'force-cache' })
- *   fetch(url, { cache: 'no-store' })
- *
- * Cached responses are stored via the pluggable CacheHandler, so
- * revalidateTag() and revalidatePath() invalidate fetch-level caches.
- *
- * Usage (in server entry):
- *   import { withFetchCache, cleanupFetchCache } from './fetch-cache';
- *   const cleanup = withFetchCache();
- *   try { ... render ... } finally { cleanup(); }
- *
- * Or use the async helper:
- *   await runWithFetchCache(async () => { ... render ... });
- */
 type NextFetchOptions = {
   revalidate?: number | false;
   tags?: string[];
 };
-type FetchDedupeEntry = {
-  key: string;
-  promise: Promise<Response>;
-  response: Response | null;
-};
 declare global {
   interface RequestInit {
     next?: NextFetchOptions;
@@ -35,20 +11,6 @@ declare global {
 }
 /** @internal Reset dedup state — exposed for test isolation only. */
 export declare function _resetPendingRefetches(): void;
-export type FetchCacheState = {
-  cacheableFetchUrls: Set<string>;
-  currentRequestTags: string[];
-  currentFetchSoftTags: string[];
-  currentFetchCacheMode: FetchCacheMode | null;
-  currentFetchRevalidate: number | null;
-  currentForceDynamicFetchDefault: boolean;
-  dynamicFetchUrls: Set<string>;
-  refreshStaleFetchesInForeground: boolean;
-  isFetchDedupeActive: boolean;
-  currentFetchDedupeEntries: Map<string, FetchDedupeEntry[]>;
-  nextFetchId: number;
-};
-export type FetchCacheMode = "auto" | "default-cache" | "default-no-store" | "force-cache" | "force-no-store" | "only-cache" | "only-no-store";
 export declare function peekCacheableFetchObservations(): string[];
 export declare function peekDynamicFetchObservations(): string[];
 export declare function consumeDynamicFetchObservations(): string[];
@@ -58,19 +20,6 @@ export declare function consumeDynamicFetchObservations(): string[];
  * fetch tags used during rendering.
  */
 export declare function getCollectedFetchTags(): string[];
-/**
- * Append cache tags to the current request's collected tags.
- *
- * Mirrors Next.js's `propagateCacheLifeAndTagsToRevalidateStore`: tags declared
- * inside a `"use cache"` function (via `cacheTag()`, persisted on the data cache
- * entry) must also bubble up to the surrounding page / route-handler ISR entry
- * so `revalidateTag()` / `revalidatePath()` can evict the rendered output, not
- * just the inner data cache entry. Without this, a cached `"use cache"` result
- * keeps being served from a stale page/route entry after its tag is revalidated
- * (issue #1453). Tags are already encoded by the caller; deduped to match the
- * tagged-fetch path. A no-op for empty input.
- */
-export declare function addCollectedRequestTags(tags: readonly string[]): void;
 /**
  * Set path-derived implicit tags for fetch cache reads in the current render.
  *
@@ -79,14 +28,6 @@ export declare function addCollectedRequestTags(tags: readonly string[]): void;
  * affected route, without permanently coupling a shared fetch entry to one path.
  */
 export declare function setCurrentFetchSoftTags(tags: string[]): void;
-/**
- * Read the path-derived soft tags for the current render.
- *
- * Used by the "use cache" runtime to pass soft tags to the cache handler
- * so that `revalidatePath()` invalidates "use cache" entries during the
- * affected route's next request, even when the entry carries no hard tags.
- */
-export declare function getCurrentFetchSoftTags(): string[];
 export declare function setCurrentFetchCacheMode(mode: FetchCacheMode | null): void;
 export declare function setCurrentFetchRevalidate(revalidate: number | null): void;
 export declare function setCurrentForceDynamicFetchDefault(enabled: boolean): void;
@@ -137,4 +78,5 @@ export declare function ensureFetchPatch(): void;
  * Useful for internal code that should bypass caching.
  */
 export declare function getOriginalFetch(): typeof globalThis.fetch;
-//#endregion
+//#endregion
+export { type FetchCacheMode, type FetchCacheState, addCollectedRequestTags, getCurrentFetchSoftTags, runWithDetachedFetchObservations };