cloudflare-next-intl 0.6.5 → 0.6.6

package/dist/src/client/components/client_provider.js

@@ -5,6 +5,7 @@ import { createContext, useMemo } from "react";
 import dynamic from "next/dynamic";
 import config from "@intl-config";
 import installConsoleErrorOverride from "../../error_handling/install_console_error_override";
+import installGlobalErrorOverride from "../../error_handling/install_global_error_override";
 export const LocaleContext = createContext(undefined);
 // Hoisted to module scope — calling `dynamic()` inside the component body
 // creates a brand-new component identity every render, forcing React to
@@ -22,6 +23,7 @@ export default function LocationzationClientProvider({ language, messages, initi
     setLocaleCache(language);
     setMessageForLocaleCache(language, messages);
     installConsoleErrorOverride(config, true);
+    installGlobalErrorOverride(config);
     // `LocaleContext.Provider` stays the outermost element here — the
     // client `AuthUserProvider` (and its descendants calling
     // usePathname()/useLocale()) must render as a CHILD of it, not a

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

@@ -3,6 +3,7 @@ export type { WithErrorHandlingOptions } from './with_error_handling';
 export { default as reportError } from './report_error';
 export type { ReportErrorConfig } from './report_error';
 export { default as installConsoleErrorOverride } from './install_console_error_override';
+export { default as installGlobalErrorOverride } from './install_global_error_override';
 export { default as stringifyUnknown } from './stringify_unknown';
 export { default as formatErrorMessage } from './format_error_message';
 export { defaultIgnoredConsoleErrors } from './default_ignored_console_errors';

package/dist/src/error_handling/index.js

@@ -1,6 +1,7 @@
 export { default as withErrorHandling } from './with_error_handling';
 export { default as reportError } from './report_error';
 export { default as installConsoleErrorOverride } from './install_console_error_override';
+export { default as installGlobalErrorOverride } from './install_global_error_override';
 export { default as stringifyUnknown } from './stringify_unknown';
 export { default as formatErrorMessage } from './format_error_message';
 export { defaultIgnoredConsoleErrors } from './default_ignored_console_errors';

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

@@ -0,0 +1,20 @@
+import { type ReportErrorConfig } from './report_error';
+/**
+ * Client-only: attaches `window.addEventListener('error'|'unhandledrejection', ...)`
+ * handlers that route through `config.errorHandling.onError`/`reportError` —
+ * catches uncaught exceptions and unhandled promise rejections that never go
+ * through `console.error` at all (unlike `installConsoleErrorOverride`),
+ * e.g. Next.js's own internal "Failed to fetch RSC payload" navigation
+ * fallback. Neither handler calls `event.preventDefault()` — the browser's
+ * own default handling (logging to the console) still happens, nothing is
+ * swallowed. Safe to call more than once (a no-op after the first call in
+ * this JS realm). Takes effect when `config.errorHandling.overrideWindowErrors`
+ * is `true`, or when it's omitted and `overrideConsoleError` is `true` (so
+ * enabling `overrideConsoleError` alone catches everything by default; pass
+ * `overrideWindowErrors: false` explicitly to opt out of just this part).
+ * No-op when `window` doesn't exist (server-side).
+ *
+ * @param config Pass the relevant slices of your `RoutingConfig` directly —
+ *   `{ errorHandling: config.errorHandling, generate: config.generate }`.
+ */
+export default function installGlobalErrorOverride(config: ReportErrorConfig | undefined): void;

package/dist/src/error_handling/install_global_error_override.js

@@ -0,0 +1,44 @@
+import reportError from './report_error';
+import stringifyUnknown from './stringify_unknown';
+/**
+ * Client-only: attaches `window.addEventListener('error'|'unhandledrejection', ...)`
+ * handlers that route through `config.errorHandling.onError`/`reportError` —
+ * catches uncaught exceptions and unhandled promise rejections that never go
+ * through `console.error` at all (unlike `installConsoleErrorOverride`),
+ * e.g. Next.js's own internal "Failed to fetch RSC payload" navigation
+ * fallback. Neither handler calls `event.preventDefault()` — the browser's
+ * own default handling (logging to the console) still happens, nothing is
+ * swallowed. Safe to call more than once (a no-op after the first call in
+ * this JS realm). Takes effect when `config.errorHandling.overrideWindowErrors`
+ * is `true`, or when it's omitted and `overrideConsoleError` is `true` (so
+ * enabling `overrideConsoleError` alone catches everything by default; pass
+ * `overrideWindowErrors: false` explicitly to opt out of just this part).
+ * No-op when `window` doesn't exist (server-side).
+ *
+ * @param config Pass the relevant slices of your `RoutingConfig` directly —
+ *   `{ errorHandling: config.errorHandling, generate: config.generate }`.
+ */
+export default function installGlobalErrorOverride(config) {
+    const enabled = config?.errorHandling?.overrideWindowErrors ?? config?.errorHandling?.overrideConsoleError;
+    if (enabled !== true)
+        return;
+    if (typeof window === 'undefined')
+        return;
+    if (window.__isGlobalErrorOverrideInstalled)
+        return;
+    window.__isGlobalErrorOverrideInstalled = true;
+    window.addEventListener('error', (event) => {
+        void reportError(config, {
+            error: event.error ?? stringifyUnknown(event.message, true),
+            classOrMethodName: 'Global Window Error Handler',
+            isClient: true,
+        });
+    });
+    window.addEventListener('unhandledrejection', (event) => {
+        void reportError(config, {
+            error: event.reason,
+            classOrMethodName: 'Global Unhandled Rejection Handler',
+            isClient: true,
+        });
+    });
+}

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

@@ -4,13 +4,17 @@ export interface ReportErrorConfig {
     generate?: GenerateRoutingConfig;
 }
 /**
- * Reports `params` via `config.errorHandling.onError` (default
- * `console.error(params.formattedMessage)`), unless
+ * Reports `params`: logs `params.formattedMessage` via the real
+ * `console.error` (unless `config.errorHandling.logToConsole` is `false`)
+ * AND calls `config.errorHandling.onError` when set — both run, not one
+ * instead of the other, so wiring `onError` (Sentry, Telegram, etc) never
+ * silently loses the console output. Skips reporting entirely when
  * `config.errorHandling.enable === false`, `params.consent` is set and not
  * `true` (reporting to a third party without cookie consent can itself be
  * GDPR-relevant), or dedup throttles it (on by default — see
  * `errorHandling.dedup`/`throttleMs`/`resetDedup`). Never throws — a broken
- * reporter must not mask the original error.
+ * `onError` must not mask the original error (falls back to logging via the
+ * real console instead).
  *
  * Always overwrites `params.formattedMessage` with a fresh
  * `formatErrorMessage(params)` before reporting — a human-readable one-line

package/dist/src/error_handling/report_error.js

@@ -1,6 +1,13 @@
 import formatErrorMessage from './format_error_message';
 import stringifyUnknown from './stringify_unknown';
 const DEFAULT_THROTTLE_MS = 5000;
+// Captured once at module load — BEFORE `installConsoleErrorOverride` can
+// ever patch `console.error` — so `callOnError`'s own fallback/always-log
+// path calls the real console, never the override. Calling a possibly-
+// patched `console.error` here would loop straight back into
+// `reportError` (the override's job is to call `reportError`), producing
+// a duplicate (or, if `onError` itself throws, an infinite) report.
+const originalConsoleError = console.error.bind(console);
 // Module-scope dedup state — safe by default only because a fresh JS realm
 // (isolate/Worker instance) starts with it cleared. In a long-lived server
 // process reused across many requests, pass `resetDedup: true` on the first
@@ -13,26 +20,30 @@ function buildDedupKey(params) {
 }
 async function callOnError(config, params) {
     const paramsWithFormattedMessage = { ...params, formattedMessage: formatErrorMessage(params) };
-    try {
-        if (config?.onError) {
+    if (config?.logToConsole !== false) {
+        originalConsoleError(paramsWithFormattedMessage.formattedMessage);
+    }
+    if (config?.onError) {
+        try {
             await config.onError(paramsWithFormattedMessage);
         }
-        else {
-            console.error(paramsWithFormattedMessage.formattedMessage);
+        catch {
+            originalConsoleError(paramsWithFormattedMessage.formattedMessage);
         }
     }
-    catch {
-        console.error(paramsWithFormattedMessage.formattedMessage);
-    }
 }
 /**
- * Reports `params` via `config.errorHandling.onError` (default
- * `console.error(params.formattedMessage)`), unless
+ * Reports `params`: logs `params.formattedMessage` via the real
+ * `console.error` (unless `config.errorHandling.logToConsole` is `false`)
+ * AND calls `config.errorHandling.onError` when set — both run, not one
+ * instead of the other, so wiring `onError` (Sentry, Telegram, etc) never
+ * silently loses the console output. Skips reporting entirely when
  * `config.errorHandling.enable === false`, `params.consent` is set and not
  * `true` (reporting to a third party without cookie consent can itself be
  * GDPR-relevant), or dedup throttles it (on by default — see
  * `errorHandling.dedup`/`throttleMs`/`resetDedup`). Never throws — a broken
- * reporter must not mask the original error.
+ * `onError` must not mask the original error (falls back to logging via the
+ * real console instead).
  *
  * Always overwrites `params.formattedMessage` with a fresh
  * `formatErrorMessage(params)` before reporting — a human-readable one-line

package/dist/src/firebase_auth/client/auth_user_provider.js

@@ -183,7 +183,7 @@ export default function AuthUserProvider({ initialUser = null, children }) {
         }
         finally {
             await clearSession(sessionCookieName, refreshTokenCookieName);
-            window.location.assign(fa.redirectAuthPath);
+            router.push(fa.redirectAuthPath);
         }
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [fa.redirectAuthPath, sessionCookieName, refreshTokenCookieName]);

package/dist/src/types/types.d.ts

@@ -167,11 +167,22 @@ export interface ErrorHandlingRoutingConfig {
      */
     enable?: boolean;
     /**
-     * Called with the caught error whenever one is reported. Defaults to
-     * `console.error`. Use this to wire your own error-tracking/logging
-     * transport (Sentry, Telegram, etc).
+     * Called with the caught error whenever one is reported, in ADDITION to
+     * the always-on `console.error(params.formattedMessage)` (see
+     * `logToConsole` to disable that). Use this to wire your own
+     * error-tracking/logging transport (Sentry, Telegram, etc) alongside the
+     * console log, not instead of it. Omit to just log to the console.
      */
     onError?: (params: ErrorHandlingParams) => void | Promise<void>;
+    /**
+     * Whether `reportError` also logs `params.formattedMessage` via the
+     * real, unpatched `console.error` (captured at module load, before
+     * `installConsoleErrorOverride` can touch it — so this never loops back
+     * into `reportError` even when the override is installed). Defaults to
+     * `true`. Set `false` if `onError` is your only sink and you don't want
+     * console output at all.
+     */
+    logToConsole?: boolean;
     /**
      * Whether `reportError`/`withErrorHandling` replace the global
      * `console.error` so every `console.error(...)` call in your app is
@@ -201,6 +212,20 @@ export interface ErrorHandlingRoutingConfig {
      * substring match.
      */
     ignoreConsoleError?: (message: string) => boolean;
+    /**
+     * Whether the client `LocationzationClientProvider` also installs
+     * `window.addEventListener('error'|'unhandledrejection', ...)` handlers
+     * that route through `onError`/`reportError` the same way
+     * `overrideConsoleError` does for `console.error(...)` calls. Catches
+     * uncaught exceptions and unhandled promise rejections that never go
+     * through `console.error` at all — e.g. Next.js's own internal
+     * "Failed to fetch RSC payload" navigation-fallback error. Defaults to
+     * `overrideConsoleError`'s value (so setting just `overrideConsoleError:
+     * true` catches everything by default) — pass `false` explicitly to
+     * enable console overriding without the window listeners. No-op on the
+     * server (no `window` there).
+     */
+    overrideWindowErrors?: boolean;
     /**
      * Dedup: `reportError` skips reporting an error whose key (`dedupKey`,
      * or a built-in key derived from `classOrMethodName`/`error`/`params`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cloudflare-next-intl",
-  "version": "0.6.5",
+  "version": "0.6.6",
   "description": "Optimized Next Intl Package Special for App Router and Cloudflare",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -148,6 +148,10 @@
       "types": "./dist/src/error_handling/install_console_error_override.d.ts",
       "import": "./dist/src/error_handling/install_console_error_override.js"
     },
+    "./installGlobalErrorOverride": {
+      "types": "./dist/src/error_handling/install_global_error_override.d.ts",
+      "import": "./dist/src/error_handling/install_global_error_override.js"
+    },
     "./stringifyUnknown": {
       "types": "./dist/src/error_handling/stringify_unknown.d.ts",
       "import": "./dist/src/error_handling/stringify_unknown.js"