cloudflare-next-intl 0.9.20 → 0.9.22

package/dist/src/error_handling/use_stale_deploy_recovery.d.ts

@@ -1,3 +1,4 @@
 export declare function isRecentBuild(setAt: number | null, now: number, windowMs?: number): boolean;
-export declare function shouldRecoverFromStaleDeploy(error: unknown, buildId: string, marker: string | null, _recentBuild?: boolean): boolean;
+export declare function shouldRecoverFromStaleDeploy(error: unknown, buildId: string, marker: string | null, recentBuild?: boolean, reloadTime?: number | null, now?: number, throttleMs?: number): boolean;
+export declare function performCacheBustReload(): void;
 export default function useStaleDeployRecovery(error: unknown, onRecover?: () => Promise<unknown>, delayMs?: number): boolean;

package/dist/src/error_handling/use_stale_deploy_recovery.js

@@ -3,9 +3,11 @@ import { useEffect, useState } from 'react';
 import isStaleDeployError from './is_stale_deploy_error.js';
 import clearClientCache from './clear_client_cache.js';
 const RECOVERY_RELOAD_KEY = 'stale-deploy-recovery-reloaded';
+const RECOVERY_TIME_KEY = 'stale-deploy-recovery-time';
 const BUILD_ID_KEY = 'buildId';
 const BUILD_ID_SET_AT_KEY = 'buildIdSetAt';
 const RECENT_BUILD_WINDOW_MS = 60000;
+const RELOAD_THROTTLE_MS = 15000;
 function currentBuildId() {
     try {
         return localStorage.getItem(BUILD_ID_KEY) ?? 'unknown';
@@ -26,21 +28,56 @@ function buildIdSetAt() {
 export function isRecentBuild(setAt, now, windowMs = RECENT_BUILD_WINDOW_MS) {
     return setAt !== null && now - setAt < windowMs;
 }
-export function shouldRecoverFromStaleDeploy(error, buildId, marker, _recentBuild = false) {
-    const isMarkerActive = marker !== null && marker !== '' && (buildId === 'unknown' || marker === buildId);
-    return isStaleDeployError(error) && !isMarkerActive;
+export function shouldRecoverFromStaleDeploy(error, buildId, marker, recentBuild = false, reloadTime = null, now = Date.now(), throttleMs = RELOAD_THROTTLE_MS) {
+    if (!isStaleDeployError(error))
+        return false;
+    const isRecentlyReloaded = reloadTime !== null && now - reloadTime < throttleMs;
+    const isSameBuildMarker = marker !== null && marker !== '' && (buildId === 'unknown' || marker === buildId);
+    if (isSameBuildMarker && isRecentlyReloaded && !recentBuild) {
+        return false;
+    }
+    return true;
 }
 function canRecover(error) {
     if (typeof window === 'undefined')
         return false;
     try {
-        return shouldRecoverFromStaleDeploy(error, currentBuildId(), sessionStorage.getItem(RECOVERY_RELOAD_KEY), isRecentBuild(buildIdSetAt(), Date.now()));
+        const reloadTimeRaw = sessionStorage.getItem(RECOVERY_TIME_KEY);
+        const reloadTime = reloadTimeRaw ? Number(reloadTimeRaw) : null;
+        const bId = currentBuildId();
+        const marker = sessionStorage.getItem(RECOVERY_RELOAD_KEY);
+        const isRecent = isRecentBuild(buildIdSetAt(), Date.now());
+        const isStale = isStaleDeployError(error);
+        const result = shouldRecoverFromStaleDeploy(error, bId, marker, isRecent, reloadTime, Date.now());
+        console.warn('[useStaleDeployRecovery]', {
+            error,
+            isStale,
+            bId,
+            marker,
+            isRecent,
+            reloadTime,
+            result,
+        });
+        return result;
     }
-    catch {
+    catch (e) {
+        console.error('[useStaleDeployRecovery] Error in canRecover:', e);
         return false;
     }
 }
-export default function useStaleDeployRecovery(error, onRecover, delayMs = 5000) {
+export function performCacheBustReload() {
+    if (typeof window === 'undefined')
+        return;
+    try {
+        const url = new URL(window.location.href);
+        url.searchParams.set('_stale_reload', String(Date.now()));
+        window.location.replace(url.toString());
+    }
+    catch {
+        window.location.reload();
+    }
+}
+export default function useStaleDeployRecovery(error, onRecover, delayMs = 1000) {
     const [recovering] = useState(() => canRecover(error));
     const [initialOnRecover] = useState(() => onRecover);
     const [initialDelayMs] = useState(() => delayMs);
@@ -53,9 +90,10 @@ export default function useStaleDeployRecovery(error, onRecover, delayMs = 5000)
                 .finally(() => {
                 try {
                     sessionStorage.setItem(RECOVERY_RELOAD_KEY, buildId);
+                    sessionStorage.setItem(RECOVERY_TIME_KEY, String(Date.now()));
                 }
                 catch { }
-                window.location.reload();
+                performCacheBustReload();
             });
         }, initialDelayMs);
         return () => clearTimeout(timeout);

package/dist/src/server/components/helper_script.js

@@ -23,31 +23,35 @@ export default function HelperScript() {
                     }
                     return false;
                 }
-                function recover(msg) {
-                    // One reload attempt per page load, no matter how many matching
-                    // errors fire in a row (a single stale deploy commonly throws
-                    // several near-simultaneous chunk failures) — without this guard
-                    // each one would race to read-then-write the same sessionStorage
-                    // key and could re-trigger reload() multiple times before the
-                    // first navigation lands.
+                function recover(msg, source) {
                     if (attemptedThisLoad) return;
                     try {
-                        if (!isStale(msg)) return;
+                        var stale = isStale(msg);
+                        console.warn('[StaleDeploy early-catch] Intercepted:', { source: source, msg: msg, isStale: stale });
+                        if (!stale) return;
                         var buildId = localStorage.getItem('buildId') || 'unknown';
-                        // Same marker/key as useStaleDeployRecovery: one reload per
-                        // build id, so a repeat failure on a build that already spent
-                        // its reload falls through instead of reloading forever.
-                        if (sessionStorage.getItem(key) === buildId) return;
+                        var marker = sessionStorage.getItem(key);
+                        if (marker === buildId) {
+                            console.warn('[StaleDeploy early-catch] Skipping reload, already attempted for buildId:', buildId);
+                            return;
+                        }
                         attemptedThisLoad = true;
                         sessionStorage.setItem(key, buildId);
-                        window.location.reload();
+                        console.warn('[StaleDeploy early-catch] Reloading for buildId:', buildId);
+                        try {
+                            var u = new URL(window.location.href);
+                            u.searchParams.set('_stale_reload', String(Date.now()));
+                            window.location.replace(u.toString());
+                        } catch (e) {
+                            window.location.reload();
+                        }
                     } catch (e) {
                         console.error('Stale Deploy Early Catch Script Error:', e);
                     }
                 }
-                window.addEventListener('error', function(e) { recover(e.message); });
+                window.addEventListener('error', function(e) { recover(e.message, 'error-event'); });
                 window.addEventListener('unhandledrejection', function(e) {
-                    recover(e.reason && e.reason.message);
+                    recover(e.reason && (e.reason.message || e.reason), 'unhandledrejection');
                 });
       })();`
                     } }), !isDev &&
@@ -107,7 +111,16 @@ export default function HelperScript() {
                     // 3. Handle Locale Redirect.
                     // The logic is clearer: redirect only if a non-default locale is set
                     // and the URL isn't already localized.
+                    // Clean up stale reload query parameter if present
                     const { pathname, search, hash } = window.location;
+                    if (search && search.indexOf('_stale_reload=') > -1) {
+                        try {
+                            const cleanUrl = new URL(window.location.href);
+                            cleanUrl.searchParams.delete('_stale_reload');
+                            window.history.replaceState(history.state, '', cleanUrl.pathname + cleanUrl.search + cleanUrl.hash);
+                        } catch (e) {}
+                    }
+
                     if (locale && locale !== '${config.defaultLocale}' && !pathname.startsWith(\`/\${locale}\`)) {
                         const newPath = \`/\${locale}\${pathname === '/' ? '' : pathname}\${search}\${hash}\`;
                         // Redirecting will stop further script execution on this page.

package/dist/src/server/components/link.d.ts

@@ -1,5 +1,8 @@
 import { type LinkProps } from 'next/link.js';
 import { type ComponentProps } from 'react';
-type NextLinkProps = Omit<ComponentProps<'a'>, keyof LinkProps> & Omit<LinkProps, 'locale'>;
+export type PrefetchType = 'custom' | 'default';
+type NextLinkProps = Omit<ComponentProps<'a'>, keyof LinkProps> & Omit<LinkProps, 'locale'> & {
+    prefetchType?: PrefetchType;
+};
 declare const Link: import("react").ForwardRefExoticComponent<Omit<NextLinkProps, "ref"> & import("react").RefAttributes<HTMLAnchorElement>>;
 export default Link;

package/dist/src/server/components/link.js

@@ -1,26 +1,79 @@
+"use client";
 import { jsx as _jsx } from "react/jsx-runtime";
 import LinkComponent from 'next/link.js';
-import { forwardRef, } from 'react';
+import { forwardRef, useEffect, useState, useTransition, } from 'react';
 import config from '../../config/intl_config.js';
 import { getLocaleCache } from '../../general/cache_variables.js';
-function CustomLinkFunction({ href, prefetch, ...rest }, ref) {
+import { usePathname, useRouter } from 'next/navigation.js';
+const prefetchedRoutes = new Set();
+function CustomLinkFunction({ href, prefetch, prefetchType = 'custom', onClick, onMouseEnter, onPointerDown, ...rest }, ref) {
     const localeValue = getLocaleCache();
+    const router = useRouter();
+    const pathname = usePathname();
+    const [isPending, startTransition] = useTransition();
+    const [isNavigating, setIsNavigating] = useState(false);
     const needsLangPath = localeValue !== config.defaultLocale || !localeValue;
     let pathnames;
+    let urlString;
     if (needsLangPath) {
-        let pathname;
-        if (typeof href === 'object') {
-            pathname = href.pathname || '';
-        }
-        else {
-            pathname = href;
-        }
-        pathnames = `/${localeValue}${pathname}`;
+        const pathPart = typeof href === 'object' ? (href.pathname || '') : (href || '');
+        pathnames = `/${localeValue}${pathPart}`;
+        urlString = pathnames;
     }
     else {
         pathnames = href;
+        urlString = typeof href === 'object' ? (href.pathname || '') : (href || '');
     }
-    return _jsx(LinkComponent, { ref: ref, href: pathnames, prefetch: prefetch, ...rest });
+    const isCustom = prefetchType === 'custom';
+    useEffect(() => {
+        setIsNavigating(false);
+    }, [pathname]);
+    const triggerPrefetch = () => {
+        if (!isCustom || !urlString || urlString.startsWith('#') || prefetchedRoutes.has(urlString)) {
+            return;
+        }
+        prefetchedRoutes.add(urlString);
+        try {
+            router.prefetch(typeof pathnames === 'string' ? pathnames : urlString);
+        }
+        catch {
+        }
+    };
+    useEffect(() => {
+        if (!isCustom)
+            return;
+        const timer = setTimeout(triggerPrefetch, 600);
+        return () => clearTimeout(timer);
+    }, [urlString, isCustom]);
+    const handleHoverPrefetch = () => {
+        if (isCustom) {
+            triggerPrefetch();
+        }
+    };
+    const handleClick = (e) => {
+        onClick?.(e);
+        if (e.defaultPrevented)
+            return;
+        if (isCustom && (isNavigating || isPending)) {
+            e.preventDefault();
+            return;
+        }
+        if (isCustom) {
+            setIsNavigating(true);
+            startTransition(() => {
+                router.push(typeof pathnames === 'string' ? pathnames : urlString);
+            });
+            e.preventDefault();
+        }
+    };
+    const effectivePrefetch = isCustom ? (prefetch ?? false) : prefetch;
+    return _jsx(LinkComponent, { ref: ref, href: pathnames, prefetch: effectivePrefetch, onClick: handleClick, onMouseEnter: (e) => {
+            handleHoverPrefetch();
+            onMouseEnter?.(e);
+        }, onPointerDown: (e) => {
+            handleHoverPrefetch();
+            onPointerDown?.(e);
+        }, ...rest });
 }
 const Link = forwardRef(CustomLinkFunction);
 export default Link;

package/dist/src/server/functions/geo.js

@@ -54,12 +54,13 @@ export async function getCountry(input, generate, headerNames) {
     const names = headerNames
         ?? gen?.countryHeaderNames
         ?? defaultCountryHeaderNames;
+    const cookieName = gen?.countryCookieName ?? countryCookieKey;
     if (input) {
         if ('headers' in input && input.headers) {
             const country = extractFromHeaderNames(input.headers, names);
             if (country)
                 return country;
-            const cookieCountry = extractCookieHeader(input.headers, countryCookieKey);
+            const cookieCountry = extractCookieHeader(input.headers, cookieName);
             if (cookieCountry)
                 return cookieCountry;
         }
@@ -67,11 +68,11 @@ export async function getCountry(input, generate, headerNames) {
             const country = extractFromHeaderNames(input, names);
             if (country)
                 return country;
-            const cookieCountry = extractCookieHeader(input, countryCookieKey);
+            const cookieCountry = extractCookieHeader(input, cookieName);
             if (cookieCountry)
                 return cookieCountry;
         }
-        const cookieCountry = extractCookie(input.cookies, countryCookieKey);
+        const cookieCountry = extractCookie(input.cookies, cookieName);
         if (cookieCountry) {
             return cookieCountry;
         }
@@ -86,7 +87,7 @@ export async function getCountry(input, generate, headerNames) {
         const country = extractFromHeaderNames(h, names);
         if (country)
             return country;
-        const cookieCountry = extractCookieHeader(h, countryCookieKey);
+        const cookieCountry = extractCookieHeader(h, cookieName);
         if (cookieCountry)
             return cookieCountry;
     }
@@ -95,7 +96,7 @@ export async function getCountry(input, generate, headerNames) {
     try {
         const { cookies } = await import('next/headers.js');
         const c = await cookies();
-        const country = extractCookie(c, countryCookieKey);
+        const country = extractCookie(c, cookieName);
         if (country)
             return country;
     }
@@ -129,12 +130,13 @@ export async function getTimezone(input, fallback, generate, headerNames) {
     const names = headerNames
         ?? gen?.timezoneHeaderNames
         ?? defaultTimezoneHeaderNames;
+    const cookieName = gen?.timezoneCookieName ?? timezoneCookieKey;
     if (input) {
         if ('headers' in input && input.headers) {
             const tz = extractFromHeaderNames(input.headers, names);
             if (tz)
                 return tz;
-            const cookieTimezone = extractCookieHeader(input.headers, timezoneCookieKey);
+            const cookieTimezone = extractCookieHeader(input.headers, cookieName);
             if (cookieTimezone)
                 return cookieTimezone;
         }
@@ -142,11 +144,11 @@ export async function getTimezone(input, fallback, generate, headerNames) {
             const tz = extractFromHeaderNames(input, names);
             if (tz)
                 return tz;
-            const cookieTimezone = extractCookieHeader(input, timezoneCookieKey);
+            const cookieTimezone = extractCookieHeader(input, cookieName);
             if (cookieTimezone)
                 return cookieTimezone;
         }
-        const cookieTimezone = extractCookie(input.cookies, timezoneCookieKey);
+        const cookieTimezone = extractCookie(input.cookies, cookieName);
         if (cookieTimezone) {
             return cookieTimezone;
         }
@@ -161,7 +163,7 @@ export async function getTimezone(input, fallback, generate, headerNames) {
         const tz = extractFromHeaderNames(h, names);
         if (tz)
             return tz;
-        const cookieTimezone = extractCookieHeader(h, timezoneCookieKey);
+        const cookieTimezone = extractCookieHeader(h, cookieName);
         if (cookieTimezone)
             return cookieTimezone;
     }
@@ -170,7 +172,7 @@ export async function getTimezone(input, fallback, generate, headerNames) {
     try {
         const { cookies } = await import('next/headers.js');
         const c = await cookies();
-        const tz = extractCookie(c, timezoneCookieKey);
+        const tz = extractCookie(c, cookieName);
         if (tz)
             return tz;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cloudflare-next-intl",
-  "version": "0.9.20",
+  "version": "0.9.22",
   "description": "Optimized Next Intl Package Special for App Router and Cloudflare",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",