cloudflare-next-intl 0.6.6 → 0.6.7

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

@@ -2,11 +2,29 @@ import { type ReportErrorConfig } from './report_error';
 /**
  * Replaces the global `console.error` so every `console.error(...)` call is
  * also routed through `config.errorHandling.onError`/`reportError` — the
- * original `console.error` still runs afterwards, nothing is swallowed.
- * Safe to call more than once (a no-op after the first call in this JS
- * realm — call it separately on the server and on the client, each has its
- * own `console`). Only takes effect when `config.errorHandling.overrideConsoleError`
- * is `true`.
+ * original `console.error` still runs afterwards, nothing is swallowed by
+ * default. Safe to call more than once (a no-op after the first call in
+ * this JS realm — call it separately on the server and on the client, each
+ * has its own `console`). Only takes effect when
+ * `config.errorHandling.overrideConsoleError` is `true`.
+ *
+ * On the client ONLY (`isClient: true`), passing
+ * `config.errorHandling.suppressClientConsoleError: true` skips the
+ * browser's own `console.error` output entirely once a call has been
+ * routed to `onError`/`reportError` — the error is still reported, it just
+ * never shows up in browser devtools. Has no effect server-side.
+ *
+ * Sets `consoleOverrideState.active = true` in `report_error.ts` — once
+ * installed, THIS override becomes the sole place that ever calls the real
+ * console for a report (it already logs the raw message below, before
+ * calling `reportError`), and `reportError`'s own console-logging step
+ * stays out of the loop entirely. Without that, `reportError`'s own
+ * fallback log would call `console.error` again — landing right back on
+ * this override and recursing. (An "original console.error, captured once
+ * at module load" reference does NOT reliably dodge this: Next.js's own
+ * dev-mode console interception forwards through whatever `console.error`
+ * is CURRENT at call time, not the function it originally wrapped, so a
+ * stale capture can still loop back into a patched `console.error`.)
  *
  * A component stuck in a render-error loop calls `console.error` on every
  * render — `reportError`'s own dedup/cap (on by default, see

package/dist/src/error_handling/install_console_error_override.js

@@ -1,14 +1,32 @@
-import reportError from './report_error';
+import reportError, { consoleOverrideState } from './report_error';
 import stringifyUnknown from './stringify_unknown';
 import { defaultIgnoredConsoleErrors } from './default_ignored_console_errors';
 /**
  * Replaces the global `console.error` so every `console.error(...)` call is
  * also routed through `config.errorHandling.onError`/`reportError` — the
- * original `console.error` still runs afterwards, nothing is swallowed.
- * Safe to call more than once (a no-op after the first call in this JS
- * realm — call it separately on the server and on the client, each has its
- * own `console`). Only takes effect when `config.errorHandling.overrideConsoleError`
- * is `true`.
+ * original `console.error` still runs afterwards, nothing is swallowed by
+ * default. Safe to call more than once (a no-op after the first call in
+ * this JS realm — call it separately on the server and on the client, each
+ * has its own `console`). Only takes effect when
+ * `config.errorHandling.overrideConsoleError` is `true`.
+ *
+ * On the client ONLY (`isClient: true`), passing
+ * `config.errorHandling.suppressClientConsoleError: true` skips the
+ * browser's own `console.error` output entirely once a call has been
+ * routed to `onError`/`reportError` — the error is still reported, it just
+ * never shows up in browser devtools. Has no effect server-side.
+ *
+ * Sets `consoleOverrideState.active = true` in `report_error.ts` — once
+ * installed, THIS override becomes the sole place that ever calls the real
+ * console for a report (it already logs the raw message below, before
+ * calling `reportError`), and `reportError`'s own console-logging step
+ * stays out of the loop entirely. Without that, `reportError`'s own
+ * fallback log would call `console.error` again — landing right back on
+ * this override and recursing. (An "original console.error, captured once
+ * at module load" reference does NOT reliably dodge this: Next.js's own
+ * dev-mode console interception forwards through whatever `console.error`
+ * is CURRENT at call time, not the function it originally wrapped, so a
+ * stale capture can still loop back into a patched `console.error`.)
  *
  * A component stuck in a render-error loop calls `console.error` on every
  * render — `reportError`'s own dedup/cap (on by default, see
@@ -34,8 +52,12 @@ export default function installConsoleErrorOverride(config, isClient) {
     if (console.error.__isErrorHandlingOverride)
         return;
     const originalConsoleError = console.error.bind(console);
+    consoleOverrideState.active = true;
+    const suppressOnClient = isClient === true && config.errorHandling?.suppressClientConsoleError === true;
     const override = (message, ...optionalParams) => {
-        originalConsoleError(message, ...optionalParams);
+        if (!suppressOnClient) {
+            originalConsoleError(message, ...optionalParams);
+        }
         const stringified = stringifyUnknown(message, isClient);
         const ignoreList = config.errorHandling?.ignoreConsoleErrors ?? defaultIgnoredConsoleErrors;
         if (ignoreList.some((ignored) => stringified.includes(ignored)))

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

@@ -3,18 +3,23 @@ export interface ReportErrorConfig {
     errorHandling?: ErrorHandlingRoutingConfig;
     generate?: GenerateRoutingConfig;
 }
+export declare const consoleOverrideState: {
+    active: boolean;
+};
 /**
- * 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
+ * Reports `params`: logs `params.formattedMessage` via `console.error`
+ * (unless `config.errorHandling.logToConsole` is `false`, or
+ * `installConsoleErrorOverride` is active — in which case IT already did
+ * the console logging before calling this) 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
- * `onError` must not mask the original error (falls back to logging via the
- * real console instead).
+ * `onError` must not mask the original error (falls back to logging via
+ * `console.error` instead, when the override isn't already handling that).
  *
  * Always overwrites `params.formattedMessage` with a fresh
  * `formatErrorMessage(params)` before reporting — a human-readable one-line
@@ -22,15 +27,20 @@ export interface ReportErrorConfig {
  * instead of the raw `error`/`params` object, for a default reporter (or a
  * simple `onError`) to print directly.
  *
- * When `config.generate?.getCloudflareContext` is set, `waitUntil` is called
- * SYNCHRONOUSLY, in the same tick, with the `callOnError(...)` promise —
- * Cloudflare Workers only extends the request's lifetime for work already
- * registered with `waitUntil` by the time the handler returns; deferring
- * that call through an extra microtask (e.g. `Promise.resolve().then(...)`)
- * risks the isolate tearing down the request before `waitUntil` is ever
- * actually invoked, silently dropping the report. Falls back to awaiting
- * `onError` directly when `getCloudflareContext`/`ctx.waitUntil` is unset or
- * unavailable (e.g. outside a Cloudflare Worker).
+ * When `config.generate?.getCloudflareContext` is set AND `params.isClient`
+ * is not `true`, `waitUntil` is called SYNCHRONOUSLY, in the same tick, with
+ * the `callOnError(...)` promise — Cloudflare Workers only extends the
+ * request's lifetime for work already registered with `waitUntil` by the
+ * time the handler returns; deferring that call through an extra microtask
+ * (e.g. `Promise.resolve().then(...)`) risks the isolate tearing down the
+ * request before `waitUntil` is ever actually invoked, silently dropping
+ * the report. `getCloudflareContext` is never called at all for a
+ * client-originated report (`params.isClient: true`) — it only exists
+ * server-side inside a Cloudflare Worker and throws synchronously (not a
+ * rejected promise) when called anywhere else, including the browser.
+ * Falls back to awaiting `onError` directly when `getCloudflareContext`/
+ * `ctx.waitUntil` is unset, unavailable (e.g. outside a Cloudflare Worker),
+ * or skipped for a client report.
  *
  * Passing `params.error` as `null`/`undefined` with `errorHandling.resetDedup: true`
  * and nothing else is a valid "reset-only" call: the dedup state clears and

package/dist/src/error_handling/report_error.js

@@ -1,13 +1,22 @@
 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);
+// Set by `installConsoleErrorOverride` once it patches `console.error`.
+// When active, THAT override is the sole place that ever calls the real
+// console for a report — it already logs the raw message itself, before
+// calling `reportError` — so `callOnError`'s own console-logging step must
+// stay OUT of the loop entirely rather than trying to detect and skip a
+// recursive call after the fact. Attempting the latter (capturing "the
+// original console.error" at module load, or tagging messages with a
+// marker) is unreliable: Next.js's own dev-mode console interception
+// forwards through whatever `console.error` is CURRENT at call time, not
+// the function it originally wrapped, so any capture-then-call-through
+// strategy can still loop back into a patched `console.error`. Removing
+// the second caller removes the race entirely — not a per-module boolean
+// (that would only cover one bundle chunk's module instance of this file;
+// this constant is exported so `installConsoleErrorOverride` can mutate it
+// via a live binding regardless of chunk).
+export const consoleOverrideState = { active: false };
 // 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
@@ -20,30 +29,39 @@ function buildDedupKey(params) {
 }
 async function callOnError(config, params) {
     const paramsWithFormattedMessage = { ...params, formattedMessage: formatErrorMessage(params) };
-    if (config?.logToConsole !== false) {
-        originalConsoleError(paramsWithFormattedMessage.formattedMessage);
+    // When `installConsoleErrorOverride` is active, it already logged the
+    // raw message to the real console BEFORE calling `reportError` — logging
+    // `formattedMessage` here too would be a second, redundant console
+    // write (differently formatted) for the exact same call, not a fix for
+    // a missing one.
+    if (config?.logToConsole !== false && !consoleOverrideState.active) {
+        console.error(paramsWithFormattedMessage.formattedMessage);
     }
     if (config?.onError) {
         try {
             await config.onError(paramsWithFormattedMessage);
         }
         catch {
-            originalConsoleError(paramsWithFormattedMessage.formattedMessage);
+            if (!consoleOverrideState.active) {
+                console.error(paramsWithFormattedMessage.formattedMessage);
+            }
         }
     }
 }
 /**
- * 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
+ * Reports `params`: logs `params.formattedMessage` via `console.error`
+ * (unless `config.errorHandling.logToConsole` is `false`, or
+ * `installConsoleErrorOverride` is active — in which case IT already did
+ * the console logging before calling this) 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
- * `onError` must not mask the original error (falls back to logging via the
- * real console instead).
+ * `onError` must not mask the original error (falls back to logging via
+ * `console.error` instead, when the override isn't already handling that).
  *
  * Always overwrites `params.formattedMessage` with a fresh
  * `formatErrorMessage(params)` before reporting — a human-readable one-line
@@ -51,15 +69,20 @@ async function callOnError(config, params) {
  * instead of the raw `error`/`params` object, for a default reporter (or a
  * simple `onError`) to print directly.
  *
- * When `config.generate?.getCloudflareContext` is set, `waitUntil` is called
- * SYNCHRONOUSLY, in the same tick, with the `callOnError(...)` promise —
- * Cloudflare Workers only extends the request's lifetime for work already
- * registered with `waitUntil` by the time the handler returns; deferring
- * that call through an extra microtask (e.g. `Promise.resolve().then(...)`)
- * risks the isolate tearing down the request before `waitUntil` is ever
- * actually invoked, silently dropping the report. Falls back to awaiting
- * `onError` directly when `getCloudflareContext`/`ctx.waitUntil` is unset or
- * unavailable (e.g. outside a Cloudflare Worker).
+ * When `config.generate?.getCloudflareContext` is set AND `params.isClient`
+ * is not `true`, `waitUntil` is called SYNCHRONOUSLY, in the same tick, with
+ * the `callOnError(...)` promise — Cloudflare Workers only extends the
+ * request's lifetime for work already registered with `waitUntil` by the
+ * time the handler returns; deferring that call through an extra microtask
+ * (e.g. `Promise.resolve().then(...)`) risks the isolate tearing down the
+ * request before `waitUntil` is ever actually invoked, silently dropping
+ * the report. `getCloudflareContext` is never called at all for a
+ * client-originated report (`params.isClient: true`) — it only exists
+ * server-side inside a Cloudflare Worker and throws synchronously (not a
+ * rejected promise) when called anywhere else, including the browser.
+ * Falls back to awaiting `onError` directly when `getCloudflareContext`/
+ * `ctx.waitUntil` is unset, unavailable (e.g. outside a Cloudflare Worker),
+ * or skipped for a client report.
  *
  * Passing `params.error` as `null`/`undefined` with `errorHandling.resetDedup: true`
  * and nothing else is a valid "reset-only" call: the dedup state clears and
@@ -91,9 +114,13 @@ export default async function reportError(config, params) {
         lastDedupKey = dedupKey;
         lastReportedAt = now;
     }
-    const waitUntil = config?.generate?.getCloudflareContext?.({ async: false })?.ctx?.waitUntil;
-    if (waitUntil) {
-        waitUntil(callOnError(errorHandling, params));
+    // `getCloudflareContext` only exists server-side inside a Cloudflare
+    // Worker (with `initOpenNextCloudflareForDev` set up in dev) — calling
+    // it at all for a client-originated report throws synchronously, before
+    // any "is it available" check can run.
+    const ctx = params.isClient ? undefined : config?.generate?.getCloudflareContext?.({ async: false })?.ctx;
+    if (ctx?.waitUntil) {
+        ctx.waitUntil(callOnError(errorHandling, params));
         return;
     }
     await callOnError(errorHandling, params);

package/dist/src/error_handling/stringify_unknown.js

@@ -1,4 +1,10 @@
 const MAX_FUNCTION_RESOLUTION_ATTEMPTS = 5;
+// eslint-disable-next-line no-control-regex
+const ANSI_ESCAPE_CODE_PATTERN = /\x1b\[[0-9;]*m/g;
+/** Strips ANSI color/style escape codes (e.g. from Next.js's own pretty-printed terminal errors) — unreadable once JSON-escaped into a report. */
+function stripAnsiCodes(value) {
+    return value.replace(ANSI_ESCAPE_CODE_PATTERN, '');
+}
 function resolveFunctionError(value) {
     let result = value;
     try {
@@ -24,9 +30,9 @@ function resolveFunctionError(value) {
  */
 export default function stringifyUnknown(value, isClient, isNested = false) {
     if (typeof value === 'string')
-        return value;
+        return stripAnsiCodes(value);
     if (value instanceof Error)
-        return `${value.name}: ${value.message}\n\n${value.stack ?? ''}`;
+        return stripAnsiCodes(`${value.name}: ${value.message}\n\n${value.stack ?? ''}`);
     if (typeof value === 'function') {
         if (isClient)
             return '[Function]';
@@ -34,7 +40,7 @@ export default function stringifyUnknown(value, isClient, isNested = false) {
         return typeof resolved !== 'function' ? stringifyUnknown(resolved, isClient) : '[Function]';
     }
     try {
-        return isNested ? JSON.stringify(value) : JSON.stringify(value, null, 2);
+        return stripAnsiCodes(isNested ? JSON.stringify(value) : JSON.stringify(value, null, 2));
     }
     catch {
         return '[Unserializable value]';

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

@@ -194,6 +194,18 @@ export interface ErrorHandlingRoutingConfig {
      * bigger behavior change than a plain function call.
      */
     overrideConsoleError?: boolean;
+    /**
+     * On the CLIENT only (`installConsoleErrorOverride(config, true)`),
+     * suppresses the browser's own `console.error(...)` output for a call
+     * once it's been routed to `onError`/`reportError` — the error is still
+     * reported (server-side logging, Sentry, etc), it just never shows up
+     * in browser devtools. Has no effect server-side (the server override
+     * always keeps logging normally — there's no "hide it from the
+     * terminal" use case). Only consulted when `overrideConsoleError` is
+     * `true`. Defaults to `false` (nothing is swallowed anywhere, matching
+     * `overrideConsoleError`'s own doc).
+     */
+    suppressClientConsoleError?: boolean;
     /**
      * Substrings matched against the stringified message of each
      * `console.error(...)` call (only consulted when `overrideConsoleError`

package/package.json

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