cloudflare-next-intl 0.9.21 → 0.9.23

package/dist/src/error_handling/is_stale_deploy_error.js

@@ -8,6 +8,10 @@ export const defaultStaleDeployPatterns = [
     'minified react error #412',
     'the above error occurred in a react component',
     'the connection to the page was unexpectedly closed',
+    'readablestream',
+    'readable stream',
+    'uncaught exception: undefined',
+    'uncaught undefined',
     'server action not found',
     'unrecognizedactionerror',
 ];
@@ -25,11 +29,18 @@ export default function isStaleDeployError(error, patterns) {
         return true;
     if (!error)
         return false;
-    if (!(error instanceof Error))
+    let message = '';
+    if (error instanceof Error) {
+        if (error.name === 'ChunkLoadError' || error.name === 'UnrecognizedActionError')
+            return true;
+        message = (error.message || '').toLowerCase();
+    }
+    else if (typeof error === 'string') {
+        message = error.toLowerCase();
+    }
+    else {
         return false;
-    if (error.name === 'ChunkLoadError' || error.name === 'UnrecognizedActionError')
-        return true;
-    const message = (error.message || '').toLowerCase();
+    }
     const list = patterns ? patterns.map((p) => p.toLowerCase()) : activeLowercasedPatterns;
     for (const pattern of list) {
         if (message.includes(pattern)) {

package/dist/src/error_handling/use_stale_deploy_recovery.js

@@ -44,9 +44,24 @@ function canRecover(error) {
     try {
         const reloadTimeRaw = sessionStorage.getItem(RECOVERY_TIME_KEY);
         const reloadTime = reloadTimeRaw ? Number(reloadTimeRaw) : null;
-        return shouldRecoverFromStaleDeploy(error, currentBuildId(), sessionStorage.getItem(RECOVERY_RELOAD_KEY), isRecentBuild(buildIdSetAt(), Date.now()), reloadTime, Date.now());
+        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;
     }
 }

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

@@ -23,23 +23,21 @@ 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);
+                        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()));
@@ -51,9 +49,9 @@ export default function HelperScript() {
                         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 &&

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/package.json

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