@drakkar.software/sunglasses-react-native 0.10.0 → 0.12.0

package/dist/index.d.mts

@@ -1,18 +1,24 @@
 import React$1 from 'react';
-import { ISunglassesClient, CaptureExceptionOptions, ScreenTrackingOptions } from '@drakkar.software/sunglasses-core';
-export { CaptureExceptionOptions, ConsentStatus, ISunglassesClient, ScreenTrackingOptions, SunglassesConfig, SunglassesCore, SunglassesEvent, captureException } from '@drakkar.software/sunglasses-core';
+import { ISunglassesClient, AutoCaptureErrorsOptions, ScreenTrackingOptions, CaptureExceptionOptions } from '@drakkar.software/sunglasses-core';
+export { AutoCaptureErrorsOptions, CaptureExceptionOptions, ConsentStatus, ConsoleCaptureOptions, GlobalErrorInfo, GlobalErrorListener, ISunglassesClient, ScreenTrackingOptions, SunglassesConfig, SunglassesCore, SunglassesEvent, captureException, patchConsole, publishGlobalError, subscribeGlobalError } from '@drakkar.software/sunglasses-core';
 
 interface SunglassesProviderProps {
     /** An initialized ISunglassesClient (from SunglassesCore.create()). */
     client: ISunglassesClient;
     /**
-     * Automatically capture unhandled JS errors as `$error` events
-     * (`$error_handled: false`) via React Native's global `ErrorUtils` handler.
-     * Pass `true` for defaults, or an options object to configure truncation /
-     * stack inclusion. The previous global handler is preserved and still
-     * invoked. Default: off.
+     * Automatically capture unhandled errors as `$error` events
+     * (`$error_handled: false`).
+     *
+     * - `true` installs a global `ErrorUtils` handler (the previous handler is
+     *   preserved and still invoked) and an unhandled promise rejection handler.
+     * - An options object additionally lets you toggle `globalHandlers` and
+     *   `unhandledRejections`, opt into `console` capture (`console.error` /
+     *   `console.warn`), plus configure truncation / stack inclusion / ignore
+     *   patterns.
+     *
+     * Default: off.
      */
-    autoCaptureErrors?: boolean | CaptureExceptionOptions;
+    autoCaptureErrors?: boolean | AutoCaptureErrorsOptions;
     children: React$1.ReactNode;
 }
 /**
@@ -222,4 +228,104 @@ interface SunglassesErrorBoundaryProps {
  */
 declare function SunglassesErrorBoundary(props: SunglassesErrorBoundaryProps): React$1.ReactElement;
 
-export { SunglassesErrorBoundary, type SunglassesErrorBoundaryProps, SunglassesProvider, type SunglassesProviderProps, captureDeepLinkUtmParams, useExpoRouterScreenTracking, useExpoRouterUtmCapture, useLinkingUtmCapture, useNavigationScreenTracking, useSunglasses };
+interface SunglassesGlobalErrorBoundaryProps {
+    /**
+     * SunGlasses client. Optional — defaults to the client provided by the
+     * nearest `<SunglassesProvider>`.
+     */
+    client?: ISunglassesClient;
+    /** Rendered when an error is caught. Defaults to rendering nothing. */
+    fallback?: React$1.ReactNode;
+    /** Error capture configuration forwarded to `captureException`. */
+    config?: CaptureExceptionOptions;
+    /**
+     * Also render the fallback for non-fatal global errors (e.g. `ErrorUtils`
+     * errors reported as non-fatal). Default: `false`.
+     */
+    includeNonFatalGlobalErrors?: boolean;
+    /**
+     * Also render the fallback for unhandled promise rejections. Off by default
+     * because many apps prefer to surface rejections as toasts or inline errors
+     * rather than as a full-screen fallback. Default: `false`.
+     */
+    includeUnhandledRejections?: boolean;
+    children: React$1.ReactNode;
+}
+/**
+ * A superset of `SunglassesErrorBoundary` that renders a fallback UI for fatal
+ * non-render errors (uncaught `ErrorUtils` errors and, optionally, unhandled
+ * rejections) in addition to the render-phase errors a normal error boundary
+ * catches.
+ *
+ * Render-phase errors are captured here as `$error` events
+ * (`$error_handled: true`). Global errors are captured by the provider's
+ * `autoCaptureErrors` handlers and merely surfaced here as a fallback — so the
+ * global fallback requires `autoCaptureErrors` to be enabled on the
+ * `<SunglassesProvider>`. No event is captured twice.
+ *
+ * @example
+ * ```tsx
+ * <SunglassesProvider client={client} autoCaptureErrors>
+ *   <SunglassesGlobalErrorBoundary fallback={<ErrorScreen />}>
+ *     <App />
+ *   </SunglassesGlobalErrorBoundary>
+ * </SunglassesProvider>
+ * ```
+ */
+declare function SunglassesGlobalErrorBoundary(props: SunglassesGlobalErrorBoundaryProps): React$1.ReactElement;
+
+/**
+ * Props Expo Router passes to a route-level `ErrorBoundary` export.
+ */
+interface ExpoRouterErrorBoundaryProps {
+    /** The render error caught by Expo Router for this route. */
+    error: Error;
+    /** Re-mounts the route's components to retry rendering. */
+    retry: () => Promise<void>;
+}
+interface WrapExpoRouterErrorBoundaryOptions {
+    /**
+     * SunGlasses client. Optional — defaults to the client provided by the
+     * nearest `<SunglassesProvider>`.
+     */
+    client?: ISunglassesClient;
+    /** Error capture configuration forwarded to `captureException`. */
+    config?: CaptureExceptionOptions;
+}
+/**
+ * Wrap an Expo Router route-level `ErrorBoundary` so render errors that reach it
+ * are also captured as SunGlasses `$error` events (`$error_handled: true`) with
+ * route context (`$route_path`, `$route_name`). The original boundary still
+ * renders unchanged.
+ *
+ * The client is read from the nearest `<SunglassesProvider>` by default; pass
+ * `options.client` to override. Each distinct error is captured once.
+ *
+ * @example
+ * ```tsx
+ * // app/_layout.tsx
+ * import { ErrorBoundary as ExpoErrorBoundary } from 'expo-router';
+ * import { wrapExpoRouterErrorBoundary } from '@drakkar.software/sunglasses-react-native';
+ *
+ * export const ErrorBoundary = wrapExpoRouterErrorBoundary(ExpoErrorBoundary);
+ * ```
+ */
+declare function wrapExpoRouterErrorBoundary<P extends ExpoRouterErrorBoundaryProps>(Boundary: React$1.ComponentType<P>, options?: WrapExpoRouterErrorBoundaryOptions): React$1.ComponentType<P>;
+
+/**
+ * Attach an unhandled promise rejection handler that captures rejections as
+ * `$error` events (`$error_handled: false`) and publishes them to the global
+ * error bus.
+ *
+ * Tries React Native's bundled rejection tracker first
+ * (`promise/setimmediate/rejection-tracking`, the same mechanism Sentry uses),
+ * then falls back to a global `unhandledrejection` listener / `onunhandledrejection`
+ * hook for engines that expose one. Never throws.
+ *
+ * @param client - SunGlasses client instance.
+ * @param options - Capture configuration forwarded to `captureException`.
+ * @returns A cleanup function that detaches the handler.
+ */
+declare function attachUnhandledRejectionHandler(client: ISunglassesClient, options?: CaptureExceptionOptions): () => void;
+
+export { type ExpoRouterErrorBoundaryProps, SunglassesErrorBoundary, type SunglassesErrorBoundaryProps, SunglassesGlobalErrorBoundary, type SunglassesGlobalErrorBoundaryProps, SunglassesProvider, type SunglassesProviderProps, type WrapExpoRouterErrorBoundaryOptions, attachUnhandledRejectionHandler, captureDeepLinkUtmParams, useExpoRouterScreenTracking, useExpoRouterUtmCapture, useLinkingUtmCapture, useNavigationScreenTracking, useSunglasses, wrapExpoRouterErrorBoundary };

package/dist/index.d.ts

@@ -1,18 +1,24 @@
 import React$1 from 'react';
-import { ISunglassesClient, CaptureExceptionOptions, ScreenTrackingOptions } from '@drakkar.software/sunglasses-core';
-export { CaptureExceptionOptions, ConsentStatus, ISunglassesClient, ScreenTrackingOptions, SunglassesConfig, SunglassesCore, SunglassesEvent, captureException } from '@drakkar.software/sunglasses-core';
+import { ISunglassesClient, AutoCaptureErrorsOptions, ScreenTrackingOptions, CaptureExceptionOptions } from '@drakkar.software/sunglasses-core';
+export { AutoCaptureErrorsOptions, CaptureExceptionOptions, ConsentStatus, ConsoleCaptureOptions, GlobalErrorInfo, GlobalErrorListener, ISunglassesClient, ScreenTrackingOptions, SunglassesConfig, SunglassesCore, SunglassesEvent, captureException, patchConsole, publishGlobalError, subscribeGlobalError } from '@drakkar.software/sunglasses-core';
 
 interface SunglassesProviderProps {
     /** An initialized ISunglassesClient (from SunglassesCore.create()). */
     client: ISunglassesClient;
     /**
-     * Automatically capture unhandled JS errors as `$error` events
-     * (`$error_handled: false`) via React Native's global `ErrorUtils` handler.
-     * Pass `true` for defaults, or an options object to configure truncation /
-     * stack inclusion. The previous global handler is preserved and still
-     * invoked. Default: off.
+     * Automatically capture unhandled errors as `$error` events
+     * (`$error_handled: false`).
+     *
+     * - `true` installs a global `ErrorUtils` handler (the previous handler is
+     *   preserved and still invoked) and an unhandled promise rejection handler.
+     * - An options object additionally lets you toggle `globalHandlers` and
+     *   `unhandledRejections`, opt into `console` capture (`console.error` /
+     *   `console.warn`), plus configure truncation / stack inclusion / ignore
+     *   patterns.
+     *
+     * Default: off.
      */
-    autoCaptureErrors?: boolean | CaptureExceptionOptions;
+    autoCaptureErrors?: boolean | AutoCaptureErrorsOptions;
     children: React$1.ReactNode;
 }
 /**
@@ -222,4 +228,104 @@ interface SunglassesErrorBoundaryProps {
  */
 declare function SunglassesErrorBoundary(props: SunglassesErrorBoundaryProps): React$1.ReactElement;
 
-export { SunglassesErrorBoundary, type SunglassesErrorBoundaryProps, SunglassesProvider, type SunglassesProviderProps, captureDeepLinkUtmParams, useExpoRouterScreenTracking, useExpoRouterUtmCapture, useLinkingUtmCapture, useNavigationScreenTracking, useSunglasses };
+interface SunglassesGlobalErrorBoundaryProps {
+    /**
+     * SunGlasses client. Optional — defaults to the client provided by the
+     * nearest `<SunglassesProvider>`.
+     */
+    client?: ISunglassesClient;
+    /** Rendered when an error is caught. Defaults to rendering nothing. */
+    fallback?: React$1.ReactNode;
+    /** Error capture configuration forwarded to `captureException`. */
+    config?: CaptureExceptionOptions;
+    /**
+     * Also render the fallback for non-fatal global errors (e.g. `ErrorUtils`
+     * errors reported as non-fatal). Default: `false`.
+     */
+    includeNonFatalGlobalErrors?: boolean;
+    /**
+     * Also render the fallback for unhandled promise rejections. Off by default
+     * because many apps prefer to surface rejections as toasts or inline errors
+     * rather than as a full-screen fallback. Default: `false`.
+     */
+    includeUnhandledRejections?: boolean;
+    children: React$1.ReactNode;
+}
+/**
+ * A superset of `SunglassesErrorBoundary` that renders a fallback UI for fatal
+ * non-render errors (uncaught `ErrorUtils` errors and, optionally, unhandled
+ * rejections) in addition to the render-phase errors a normal error boundary
+ * catches.
+ *
+ * Render-phase errors are captured here as `$error` events
+ * (`$error_handled: true`). Global errors are captured by the provider's
+ * `autoCaptureErrors` handlers and merely surfaced here as a fallback — so the
+ * global fallback requires `autoCaptureErrors` to be enabled on the
+ * `<SunglassesProvider>`. No event is captured twice.
+ *
+ * @example
+ * ```tsx
+ * <SunglassesProvider client={client} autoCaptureErrors>
+ *   <SunglassesGlobalErrorBoundary fallback={<ErrorScreen />}>
+ *     <App />
+ *   </SunglassesGlobalErrorBoundary>
+ * </SunglassesProvider>
+ * ```
+ */
+declare function SunglassesGlobalErrorBoundary(props: SunglassesGlobalErrorBoundaryProps): React$1.ReactElement;
+
+/**
+ * Props Expo Router passes to a route-level `ErrorBoundary` export.
+ */
+interface ExpoRouterErrorBoundaryProps {
+    /** The render error caught by Expo Router for this route. */
+    error: Error;
+    /** Re-mounts the route's components to retry rendering. */
+    retry: () => Promise<void>;
+}
+interface WrapExpoRouterErrorBoundaryOptions {
+    /**
+     * SunGlasses client. Optional — defaults to the client provided by the
+     * nearest `<SunglassesProvider>`.
+     */
+    client?: ISunglassesClient;
+    /** Error capture configuration forwarded to `captureException`. */
+    config?: CaptureExceptionOptions;
+}
+/**
+ * Wrap an Expo Router route-level `ErrorBoundary` so render errors that reach it
+ * are also captured as SunGlasses `$error` events (`$error_handled: true`) with
+ * route context (`$route_path`, `$route_name`). The original boundary still
+ * renders unchanged.
+ *
+ * The client is read from the nearest `<SunglassesProvider>` by default; pass
+ * `options.client` to override. Each distinct error is captured once.
+ *
+ * @example
+ * ```tsx
+ * // app/_layout.tsx
+ * import { ErrorBoundary as ExpoErrorBoundary } from 'expo-router';
+ * import { wrapExpoRouterErrorBoundary } from '@drakkar.software/sunglasses-react-native';
+ *
+ * export const ErrorBoundary = wrapExpoRouterErrorBoundary(ExpoErrorBoundary);
+ * ```
+ */
+declare function wrapExpoRouterErrorBoundary<P extends ExpoRouterErrorBoundaryProps>(Boundary: React$1.ComponentType<P>, options?: WrapExpoRouterErrorBoundaryOptions): React$1.ComponentType<P>;
+
+/**
+ * Attach an unhandled promise rejection handler that captures rejections as
+ * `$error` events (`$error_handled: false`) and publishes them to the global
+ * error bus.
+ *
+ * Tries React Native's bundled rejection tracker first
+ * (`promise/setimmediate/rejection-tracking`, the same mechanism Sentry uses),
+ * then falls back to a global `unhandledrejection` listener / `onunhandledrejection`
+ * hook for engines that expose one. Never throws.
+ *
+ * @param client - SunGlasses client instance.
+ * @param options - Capture configuration forwarded to `captureException`.
+ * @returns A cleanup function that detaches the handler.
+ */
+declare function attachUnhandledRejectionHandler(client: ISunglassesClient, options?: CaptureExceptionOptions): () => void;
+
+export { type ExpoRouterErrorBoundaryProps, SunglassesErrorBoundary, type SunglassesErrorBoundaryProps, SunglassesGlobalErrorBoundary, type SunglassesGlobalErrorBoundaryProps, SunglassesProvider, type SunglassesProviderProps, type WrapExpoRouterErrorBoundaryOptions, attachUnhandledRejectionHandler, captureDeepLinkUtmParams, useExpoRouterScreenTracking, useExpoRouterUtmCapture, useLinkingUtmCapture, useNavigationScreenTracking, useSunglasses, wrapExpoRouterErrorBoundary };

package/dist/index.js

@@ -30,23 +30,29 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  SunglassesCore: () => import_sunglasses_core3.SunglassesCore,
+  SunglassesCore: () => import_sunglasses_core6.SunglassesCore,
   SunglassesErrorBoundary: () => SunglassesErrorBoundary,
+  SunglassesGlobalErrorBoundary: () => SunglassesGlobalErrorBoundary,
   SunglassesProvider: () => SunglassesProvider,
+  attachUnhandledRejectionHandler: () => attachUnhandledRejectionHandler,
   captureDeepLinkUtmParams: () => captureDeepLinkUtmParams,
-  captureException: () => import_sunglasses_core3.captureException,
+  captureException: () => import_sunglasses_core6.captureException,
+  patchConsole: () => import_sunglasses_core6.patchConsole,
+  publishGlobalError: () => import_sunglasses_core6.publishGlobalError,
+  subscribeGlobalError: () => import_sunglasses_core6.subscribeGlobalError,
   useExpoRouterScreenTracking: () => useExpoRouterScreenTracking,
   useExpoRouterUtmCapture: () => useExpoRouterUtmCapture,
   useLinkingUtmCapture: () => useLinkingUtmCapture,
   useNavigationScreenTracking: () => useNavigationScreenTracking,
-  useSunglasses: () => useSunglasses
+  useSunglasses: () => useSunglasses,
+  wrapExpoRouterErrorBoundary: () => wrapExpoRouterErrorBoundary
 });
 module.exports = __toCommonJS(index_exports);
 
 // src/SunglassesProvider.tsx
 var import_react2 = require("react");
 var import_react_native = require("react-native");
-var import_sunglasses_core = require("@drakkar.software/sunglasses-core");
+var import_sunglasses_core2 = require("@drakkar.software/sunglasses-core");
 
 // src/context.ts
 var import_react = require("react");
@@ -61,6 +67,68 @@ function useSunglasses() {
   return client;
 }
 
+// src/unhandledRejections.ts
+var import_sunglasses_core = require("@drakkar.software/sunglasses-core");
+
+// src/rejectionTracking.ts
+var _tracking = null;
+try {
+  const required = require("promise/setimmediate/rejection-tracking");
+  const resolved = required.default ?? required;
+  if (resolved && typeof resolved.enable === "function") {
+    _tracking = resolved;
+  }
+} catch {
+}
+var rejectionTracking = _tracking;
+
+// src/unhandledRejections.ts
+function reasonOf(event) {
+  if (event && typeof event === "object" && "reason" in event) {
+    return event.reason;
+  }
+  return event;
+}
+function attachUnhandledRejectionHandler(client, options = {}) {
+  const onUnhandled = (error) => {
+    (0, import_sunglasses_core.captureException)(client, error, { handled: false, ...options });
+    (0, import_sunglasses_core.publishGlobalError)({ error, fatal: false, kind: "rejection" });
+  };
+  const tracking = rejectionTracking;
+  if (tracking) {
+    tracking.enable({
+      allRejections: true,
+      onUnhandled: (_id, error) => onUnhandled(error),
+      onHandled: () => {
+      }
+    });
+    return () => {
+      try {
+        tracking.disable?.();
+      } catch {
+      }
+    };
+  }
+  const g = globalThis;
+  if (typeof g.addEventListener === "function" && typeof g.removeEventListener === "function") {
+    const listener = (event) => onUnhandled(reasonOf(event));
+    g.addEventListener("unhandledrejection", listener);
+    return () => g.removeEventListener?.("unhandledrejection", listener);
+  }
+  if ("onunhandledrejection" in g) {
+    const previous = g.onunhandledrejection ?? null;
+    g.onunhandledrejection = (event) => {
+      onUnhandled(reasonOf(event));
+      previous?.(event);
+    };
+    return () => {
+      g.onunhandledrejection = previous;
+    };
+  }
+  return () => {
+  };
+}
+
 // src/SunglassesProvider.tsx
 var import_jsx_runtime = require("react/jsx-runtime");
 function SunglassesProvider({
@@ -76,15 +144,28 @@ function SunglassesProvider({
   }, [client]);
   (0, import_react2.useEffect)(() => {
     if (!autoCaptureErrors) return;
-    if (typeof ErrorUtils === "undefined" || !ErrorUtils.setGlobalHandler) return;
     const options = typeof autoCaptureErrors === "object" ? autoCaptureErrors : {};
-    const previous = ErrorUtils.getGlobalHandler?.();
-    ErrorUtils.setGlobalHandler((error, isFatal) => {
-      (0, import_sunglasses_core.captureException)(client, error, { handled: false, ...options });
-      previous?.(error, isFatal);
-    });
+    const cleanups = [];
+    if (options.globalHandlers !== false && typeof ErrorUtils !== "undefined" && ErrorUtils.setGlobalHandler) {
+      const previous = ErrorUtils.getGlobalHandler?.();
+      ErrorUtils.setGlobalHandler((error, isFatal) => {
+        (0, import_sunglasses_core2.captureException)(client, error, { handled: false, ...options });
+        (0, import_sunglasses_core2.publishGlobalError)({ error, fatal: isFatal !== false, kind: "error" });
+        previous?.(error, isFatal);
+      });
+      cleanups.push(() => {
+        if (previous) ErrorUtils.setGlobalHandler?.(previous);
+      });
+    }
+    if (options.unhandledRejections !== false) {
+      cleanups.push(attachUnhandledRejectionHandler(client, options));
+    }
+    if (options.console) {
+      const consoleOptions = typeof options.console === "object" ? options.console : {};
+      cleanups.push((0, import_sunglasses_core2.patchConsole)(client, consoleOptions));
+    }
     return () => {
-      if (previous) ErrorUtils.setGlobalHandler?.(previous);
+      for (const cleanup of cleanups) cleanup();
     };
   }, [client, autoCaptureErrors]);
   (0, import_react2.useEffect)(() => {
@@ -104,8 +185,8 @@ var import_react3 = require("react");
 function useExpoRouterScreenTracking(client, options = {}) {
   let pathname;
   try {
-    const { usePathname } = require("expo-router");
-    pathname = usePathname();
+    const { usePathname: usePathname2 } = require("expo-router");
+    pathname = usePathname2();
   } catch {
     return;
   }
@@ -199,11 +280,15 @@ var import_react6 = require("react");
 
 // src/expoRouterCompat.ts
 var _useGlobalSearchParams = null;
+var _usePathname = null;
 try {
-  ({ useGlobalSearchParams: _useGlobalSearchParams } = require("expo-router"));
+  const expoRouter = require("expo-router");
+  _useGlobalSearchParams = expoRouter.useGlobalSearchParams;
+  _usePathname = expoRouter.usePathname;
 } catch {
 }
 var useGlobalSearchParams = _useGlobalSearchParams;
+var usePathname = _usePathname;
 
 // src/useExpoRouterUtmCapture.ts
 function useExpoRouterUtmCapture(client) {
@@ -227,7 +312,7 @@ function useExpoRouterUtmCapture(client) {
 
 // src/SunglassesErrorBoundary.tsx
 var import_react7 = __toESM(require("react"));
-var import_sunglasses_core2 = require("@drakkar.software/sunglasses-core");
+var import_sunglasses_core3 = require("@drakkar.software/sunglasses-core");
 var import_jsx_runtime2 = require("react/jsx-runtime");
 var ErrorBoundaryInner = class extends import_react7.default.Component {
   constructor() {
@@ -239,7 +324,7 @@ var ErrorBoundaryInner = class extends import_react7.default.Component {
   }
   componentDidCatch(error) {
     const { client, config } = this.props;
-    (0, import_sunglasses_core2.captureException)(client, error, { handled: true, ...config });
+    (0, import_sunglasses_core3.captureException)(client, error, { handled: true, ...config });
   }
   render() {
     if (this.state.hasError) return this.props.fallback ?? null;
@@ -257,18 +342,109 @@ function SunglassesErrorBoundary(props) {
   return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(ErrorBoundaryInner, { ...props, client });
 }
 
+// src/SunglassesGlobalErrorBoundary.tsx
+var import_react8 = __toESM(require("react"));
+var import_sunglasses_core4 = require("@drakkar.software/sunglasses-core");
+var import_jsx_runtime3 = require("react/jsx-runtime");
+var GlobalErrorBoundaryInner = class extends import_react8.default.Component {
+  constructor() {
+    super(...arguments);
+    this.state = { hasError: false };
+  }
+  static getDerivedStateFromError() {
+    return { hasError: true };
+  }
+  componentDidMount() {
+    this.unsubscribe = (0, import_sunglasses_core4.subscribeGlobalError)((info) => this.handleGlobalError(info));
+  }
+  componentWillUnmount() {
+    this.unsubscribe?.();
+  }
+  componentDidCatch(error) {
+    const { client, config } = this.props;
+    (0, import_sunglasses_core4.captureException)(client, error, { handled: true, ...config });
+  }
+  /**
+   * React to a global error published by the provider's auto-capture handlers.
+   * The provider already captured it, so we only decide whether to show the
+   * fallback — we never re-capture here.
+   */
+  handleGlobalError(info) {
+    if (this.state.hasError) return;
+    const { includeNonFatalGlobalErrors, includeUnhandledRejections } = this.props;
+    const shouldShow = info.kind === "rejection" ? includeUnhandledRejections === true : info.fatal || includeNonFatalGlobalErrors === true;
+    if (shouldShow) this.setState({ hasError: true });
+  }
+  render() {
+    if (this.state.hasError) return this.props.fallback ?? null;
+    return this.props.children;
+  }
+};
+function SunglassesGlobalErrorBoundary(props) {
+  const contextClient = (0, import_react8.useContext)(SunglassesContext);
+  const client = props.client ?? contextClient;
+  if (client === null) {
+    throw new Error(
+      "[SunGlasses] <SunglassesGlobalErrorBoundary> must be inside a <SunglassesProvider> or receive a `client` prop."
+    );
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(GlobalErrorBoundaryInner, { ...props, client });
+}
+
+// src/wrapExpoRouterErrorBoundary.tsx
+var import_react9 = require("react");
+var import_sunglasses_core5 = require("@drakkar.software/sunglasses-core");
+var import_jsx_runtime4 = require("react/jsx-runtime");
+function useExpoRouterPathname() {
+  if (!usePathname) return void 0;
+  return usePathname();
+}
+function wrapExpoRouterErrorBoundary(Boundary, options = {}) {
+  function WrappedExpoRouterErrorBoundary(props) {
+    const contextClient = (0, import_react9.useContext)(SunglassesContext);
+    const client = options.client ?? contextClient;
+    const pathname = useExpoRouterPathname();
+    const lastCaptured = (0, import_react9.useRef)(null);
+    const { error } = props;
+    (0, import_react9.useEffect)(() => {
+      if (!client || !error || lastCaptured.current === error) return;
+      lastCaptured.current = error;
+      const routeProps = {};
+      if (pathname) {
+        routeProps.$route_path = pathname;
+        routeProps.$route_name = pathname;
+      }
+      (0, import_sunglasses_core5.captureException)(client, error, {
+        handled: true,
+        ...options.config,
+        properties: { ...routeProps, ...options.config?.properties }
+      });
+    }, [client, error, pathname]);
+    return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(Boundary, { ...props });
+  }
+  const name = Boundary.displayName || Boundary.name || "ErrorBoundary";
+  WrappedExpoRouterErrorBoundary.displayName = `wrapExpoRouterErrorBoundary(${name})`;
+  return WrappedExpoRouterErrorBoundary;
+}
+
 // src/index.ts
-var import_sunglasses_core3 = require("@drakkar.software/sunglasses-core");
+var import_sunglasses_core6 = require("@drakkar.software/sunglasses-core");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   SunglassesCore,
   SunglassesErrorBoundary,
+  SunglassesGlobalErrorBoundary,
   SunglassesProvider,
+  attachUnhandledRejectionHandler,
   captureDeepLinkUtmParams,
   captureException,
+  patchConsole,
+  publishGlobalError,
+  subscribeGlobalError,
   useExpoRouterScreenTracking,
   useExpoRouterUtmCapture,
   useLinkingUtmCapture,
   useNavigationScreenTracking,
-  useSunglasses
+  useSunglasses,
+  wrapExpoRouterErrorBoundary
 });

package/dist/index.mjs

@@ -8,7 +8,7 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 // src/SunglassesProvider.tsx
 import { useEffect } from "react";
 import { AppState } from "react-native";
-import { captureException } from "@drakkar.software/sunglasses-core";
+import { captureException as captureException2, patchConsole, publishGlobalError as publishGlobalError2 } from "@drakkar.software/sunglasses-core";
 
 // src/context.ts
 import { createContext, useContext } from "react";
@@ -23,6 +23,68 @@ function useSunglasses() {
   return client;
 }
 
+// src/unhandledRejections.ts
+import { captureException, publishGlobalError } from "@drakkar.software/sunglasses-core";
+
+// src/rejectionTracking.ts
+var _tracking = null;
+try {
+  const required = __require("promise/setimmediate/rejection-tracking");
+  const resolved = required.default ?? required;
+  if (resolved && typeof resolved.enable === "function") {
+    _tracking = resolved;
+  }
+} catch {
+}
+var rejectionTracking = _tracking;
+
+// src/unhandledRejections.ts
+function reasonOf(event) {
+  if (event && typeof event === "object" && "reason" in event) {
+    return event.reason;
+  }
+  return event;
+}
+function attachUnhandledRejectionHandler(client, options = {}) {
+  const onUnhandled = (error) => {
+    captureException(client, error, { handled: false, ...options });
+    publishGlobalError({ error, fatal: false, kind: "rejection" });
+  };
+  const tracking = rejectionTracking;
+  if (tracking) {
+    tracking.enable({
+      allRejections: true,
+      onUnhandled: (_id, error) => onUnhandled(error),
+      onHandled: () => {
+      }
+    });
+    return () => {
+      try {
+        tracking.disable?.();
+      } catch {
+      }
+    };
+  }
+  const g = globalThis;
+  if (typeof g.addEventListener === "function" && typeof g.removeEventListener === "function") {
+    const listener = (event) => onUnhandled(reasonOf(event));
+    g.addEventListener("unhandledrejection", listener);
+    return () => g.removeEventListener?.("unhandledrejection", listener);
+  }
+  if ("onunhandledrejection" in g) {
+    const previous = g.onunhandledrejection ?? null;
+    g.onunhandledrejection = (event) => {
+      onUnhandled(reasonOf(event));
+      previous?.(event);
+    };
+    return () => {
+      g.onunhandledrejection = previous;
+    };
+  }
+  return () => {
+  };
+}
+
 // src/SunglassesProvider.tsx
 import { jsx } from "react/jsx-runtime";
 function SunglassesProvider({
@@ -38,15 +100,28 @@ function SunglassesProvider({
   }, [client]);
   useEffect(() => {
     if (!autoCaptureErrors) return;
-    if (typeof ErrorUtils === "undefined" || !ErrorUtils.setGlobalHandler) return;
     const options = typeof autoCaptureErrors === "object" ? autoCaptureErrors : {};
-    const previous = ErrorUtils.getGlobalHandler?.();
-    ErrorUtils.setGlobalHandler((error, isFatal) => {
-      captureException(client, error, { handled: false, ...options });
-      previous?.(error, isFatal);
-    });
+    const cleanups = [];
+    if (options.globalHandlers !== false && typeof ErrorUtils !== "undefined" && ErrorUtils.setGlobalHandler) {
+      const previous = ErrorUtils.getGlobalHandler?.();
+      ErrorUtils.setGlobalHandler((error, isFatal) => {
+        captureException2(client, error, { handled: false, ...options });
+        publishGlobalError2({ error, fatal: isFatal !== false, kind: "error" });
+        previous?.(error, isFatal);
+      });
+      cleanups.push(() => {
+        if (previous) ErrorUtils.setGlobalHandler?.(previous);
+      });
+    }
+    if (options.unhandledRejections !== false) {
+      cleanups.push(attachUnhandledRejectionHandler(client, options));
+    }
+    if (options.console) {
+      const consoleOptions = typeof options.console === "object" ? options.console : {};
+      cleanups.push(patchConsole(client, consoleOptions));
+    }
     return () => {
-      if (previous) ErrorUtils.setGlobalHandler?.(previous);
+      for (const cleanup of cleanups) cleanup();
     };
   }, [client, autoCaptureErrors]);
   useEffect(() => {
@@ -66,8 +141,8 @@ import { useEffect as useEffect2 } from "react";
 function useExpoRouterScreenTracking(client, options = {}) {
   let pathname;
   try {
-    const { usePathname } = __require("expo-router");
-    pathname = usePathname();
+    const { usePathname: usePathname2 } = __require("expo-router");
+    pathname = usePathname2();
   } catch {
     return;
   }
@@ -161,11 +236,15 @@ import { useEffect as useEffect5 } from "react";
 
 // src/expoRouterCompat.ts
 var _useGlobalSearchParams = null;
+var _usePathname = null;
 try {
-  ({ useGlobalSearchParams: _useGlobalSearchParams } = __require("expo-router"));
+  const expoRouter = __require("expo-router");
+  _useGlobalSearchParams = expoRouter.useGlobalSearchParams;
+  _usePathname = expoRouter.usePathname;
 } catch {
 }
 var useGlobalSearchParams = _useGlobalSearchParams;
+var usePathname = _usePathname;
 
 // src/useExpoRouterUtmCapture.ts
 function useExpoRouterUtmCapture(client) {
@@ -189,7 +268,7 @@ function useExpoRouterUtmCapture(client) {
 
 // src/SunglassesErrorBoundary.tsx
 import React2, { useContext as useContext2 } from "react";
-import { captureException as captureException2 } from "@drakkar.software/sunglasses-core";
+import { captureException as captureException3 } from "@drakkar.software/sunglasses-core";
 import { jsx as jsx2 } from "react/jsx-runtime";
 var ErrorBoundaryInner = class extends React2.Component {
   constructor() {
@@ -201,7 +280,7 @@ var ErrorBoundaryInner = class extends React2.Component {
   }
   componentDidCatch(error) {
     const { client, config } = this.props;
-    captureException2(client, error, { handled: true, ...config });
+    captureException3(client, error, { handled: true, ...config });
   }
   render() {
     if (this.state.hasError) return this.props.fallback ?? null;
@@ -219,17 +298,114 @@ function SunglassesErrorBoundary(props) {
   return /* @__PURE__ */ jsx2(ErrorBoundaryInner, { ...props, client });
 }
 
+// src/SunglassesGlobalErrorBoundary.tsx
+import React3, { useContext as useContext3 } from "react";
+import { captureException as captureException4, subscribeGlobalError } from "@drakkar.software/sunglasses-core";
+import { jsx as jsx3 } from "react/jsx-runtime";
+var GlobalErrorBoundaryInner = class extends React3.Component {
+  constructor() {
+    super(...arguments);
+    this.state = { hasError: false };
+  }
+  static getDerivedStateFromError() {
+    return { hasError: true };
+  }
+  componentDidMount() {
+    this.unsubscribe = subscribeGlobalError((info) => this.handleGlobalError(info));
+  }
+  componentWillUnmount() {
+    this.unsubscribe?.();
+  }
+  componentDidCatch(error) {
+    const { client, config } = this.props;
+    captureException4(client, error, { handled: true, ...config });
+  }
+  /**
+   * React to a global error published by the provider's auto-capture handlers.
+   * The provider already captured it, so we only decide whether to show the
+   * fallback — we never re-capture here.
+   */
+  handleGlobalError(info) {
+    if (this.state.hasError) return;
+    const { includeNonFatalGlobalErrors, includeUnhandledRejections } = this.props;
+    const shouldShow = info.kind === "rejection" ? includeUnhandledRejections === true : info.fatal || includeNonFatalGlobalErrors === true;
+    if (shouldShow) this.setState({ hasError: true });
+  }
+  render() {
+    if (this.state.hasError) return this.props.fallback ?? null;
+    return this.props.children;
+  }
+};
+function SunglassesGlobalErrorBoundary(props) {
+  const contextClient = useContext3(SunglassesContext);
+  const client = props.client ?? contextClient;
+  if (client === null) {
+    throw new Error(
+      "[SunGlasses] <SunglassesGlobalErrorBoundary> must be inside a <SunglassesProvider> or receive a `client` prop."
+    );
+  }
+  return /* @__PURE__ */ jsx3(GlobalErrorBoundaryInner, { ...props, client });
+}
+
+// src/wrapExpoRouterErrorBoundary.tsx
+import { useContext as useContext4, useEffect as useEffect6, useRef as useRef2 } from "react";
+import { captureException as captureException5 } from "@drakkar.software/sunglasses-core";
+import { jsx as jsx4 } from "react/jsx-runtime";
+function useExpoRouterPathname() {
+  if (!usePathname) return void 0;
+  return usePathname();
+}
+function wrapExpoRouterErrorBoundary(Boundary, options = {}) {
+  function WrappedExpoRouterErrorBoundary(props) {
+    const contextClient = useContext4(SunglassesContext);
+    const client = options.client ?? contextClient;
+    const pathname = useExpoRouterPathname();
+    const lastCaptured = useRef2(null);
+    const { error } = props;
+    useEffect6(() => {
+      if (!client || !error || lastCaptured.current === error) return;
+      lastCaptured.current = error;
+      const routeProps = {};
+      if (pathname) {
+        routeProps.$route_path = pathname;
+        routeProps.$route_name = pathname;
+      }
+      captureException5(client, error, {
+        handled: true,
+        ...options.config,
+        properties: { ...routeProps, ...options.config?.properties }
+      });
+    }, [client, error, pathname]);
+    return /* @__PURE__ */ jsx4(Boundary, { ...props });
+  }
+  const name = Boundary.displayName || Boundary.name || "ErrorBoundary";
+  WrappedExpoRouterErrorBoundary.displayName = `wrapExpoRouterErrorBoundary(${name})`;
+  return WrappedExpoRouterErrorBoundary;
+}
+
 // src/index.ts
-import { SunglassesCore, captureException as captureException3 } from "@drakkar.software/sunglasses-core";
+import {
+  SunglassesCore,
+  captureException as captureException6,
+  patchConsole as patchConsole2,
+  publishGlobalError as publishGlobalError3,
+  subscribeGlobalError as subscribeGlobalError2
+} from "@drakkar.software/sunglasses-core";
 export {
   SunglassesCore,
   SunglassesErrorBoundary,
+  SunglassesGlobalErrorBoundary,
   SunglassesProvider,
+  attachUnhandledRejectionHandler,
   captureDeepLinkUtmParams,
-  captureException3 as captureException,
+  captureException6 as captureException,
+  patchConsole2 as patchConsole,
+  publishGlobalError3 as publishGlobalError,
+  subscribeGlobalError2 as subscribeGlobalError,
   useExpoRouterScreenTracking,
   useExpoRouterUtmCapture,
   useLinkingUtmCapture,
   useNavigationScreenTracking,
-  useSunglasses
+  useSunglasses,
+  wrapExpoRouterErrorBoundary
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@drakkar.software/sunglasses-react-native",
-  "version": "0.10.0",
+  "version": "0.12.0",
   "description": "React Native / Expo provider and hooks for SunGlasses event tracking",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -16,7 +16,7 @@
     "dist"
   ],
   "dependencies": {
-    "@drakkar.software/sunglasses-core": "0.10.0"
+    "@drakkar.software/sunglasses-core": "0.12.0"
   },
   "peerDependencies": {
     "expo-router": ">=3.0.0",