@allstak/react-native 0.3.0 → 0.3.1

package/dist/index.js

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
@@ -22,19 +32,26 @@ var index_exports = {};
 __export(index_exports, {
   AllStak: () => AllStak,
   AllStakClient: () => AllStakClient,
+  AllStakProvider: () => AllStakProvider,
   HttpRequestModule: () => HttpRequestModule,
   INGEST_HOST: () => INGEST_HOST,
   ReplaySurrogate: () => ReplaySurrogate,
   SDK_NAME: () => SDK_NAME,
   SDK_VERSION: () => SDK_VERSION,
   Scope: () => Scope,
+  __devTriggerNativeCrash: () => __devTriggerNativeCrash,
+  __resetAutoNavigationFlagForTest: () => __resetAutoNavigationFlagForTest,
+  __resetConsoleInstrumentationFlagForTest: () => __resetConsoleInstrumentationFlagForTest,
+  __resetProviderInstanceForTest: () => __resetProviderInstanceForTest,
   __setNativeModuleForTest: () => __setNativeModuleForTest,
   applyArchitectureTags: () => applyArchitectureTags,
   detectArchitecture: () => detectArchitecture,
   drainPendingNativeCrashes: () => drainPendingNativeCrashes,
   installReactNative: () => installReactNative,
   instrumentNavigationFromLinking: () => instrumentNavigationFromLinking,
-  instrumentReactNavigation: () => instrumentReactNavigation
+  instrumentReactNavigation: () => instrumentReactNavigation,
+  tryAutoInstrumentNavigation: () => tryAutoInstrumentNavigation,
+  useAllStak: () => useAllStak
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -1003,7 +1020,7 @@ function installHttpInstrumentation(module2, options, ownIngestHost) {
 // src/client.ts
 var INGEST_HOST = "https://api.allstak.sa";
 var SDK_NAME = "allstak-react-native";
-var SDK_VERSION = "0.3.0";
+var SDK_VERSION = "0.3.1";
 var ERRORS_PATH = "/ingest/v1/errors";
 var LOGS_PATH = "/ingest/v1/logs";
 var VALID_BREADCRUMB_TYPES = /* @__PURE__ */ new Set(["http", "log", "ui", "navigation", "query", "default"]);
@@ -1484,6 +1501,9 @@ var AllStak = {
   }
 };
 
+// src/provider.tsx
+var React = __toESM(require("react"));
+
 // src/auto-breadcrumbs.ts
 var FETCH_FLAG2 = "__allstak_fetch_patched__";
 var CONSOLE_FLAG = "__allstak_console_patched__";
@@ -1530,36 +1550,92 @@ function instrumentFetch(addBreadcrumb, ownBaseUrl) {
   wrapped[FETCH_FLAG2] = true;
   g.fetch = wrapped;
 }
-function instrumentConsole(addBreadcrumb) {
+var CONSOLE_DEFAULTS = {
+  log: false,
+  info: false,
+  warn: true,
+  error: true
+};
+var CONSOLE_METHOD_TO_LEVEL = {
+  log: "info",
+  info: "info",
+  warn: "warn",
+  error: "error"
+};
+var MAX_ARG_BYTES = 5e3;
+function instrumentConsole(addBreadcrumb, options = {}) {
   if (typeof console === "undefined") return;
   if (console[CONSOLE_FLAG]) return;
-  const origWarn = console.warn;
-  const origError = console.error;
-  console.warn = function(...args) {
-    try {
-      addBreadcrumb("log", args.map(safeString).join(" "), "warn");
-    } catch {
-    }
-    return origWarn.apply(console, args);
+  const opts = {
+    log: options.log ?? CONSOLE_DEFAULTS.log,
+    info: options.info ?? CONSOLE_DEFAULTS.info,
+    warn: options.warn ?? CONSOLE_DEFAULTS.warn,
+    error: options.error ?? CONSOLE_DEFAULTS.error
   };
-  console.error = function(...args) {
-    try {
-      addBreadcrumb("log", args.map(safeString).join(" "), "error");
-    } catch {
-    }
-    return origError.apply(console, args);
+  const wrap = (method) => {
+    const orig = console[method];
+    if (typeof orig !== "function") return;
+    const level = CONSOLE_METHOD_TO_LEVEL[method];
+    console[method] = function(...args) {
+      if (opts[method]) {
+        try {
+          const serialized = args.map(safeStringifyArg);
+          const message = truncate(serialized.join(" "));
+          addBreadcrumb("log", message, level, {
+            category: "console",
+            method,
+            args: serialized
+          });
+        } catch {
+        }
+      }
+      return orig.apply(console, args);
+    };
   };
+  if (opts.log) wrap("log");
+  if (opts.info) wrap("info");
+  if (opts.warn) wrap("warn");
+  if (opts.error) wrap("error");
   console[CONSOLE_FLAG] = true;
 }
-function safeString(v) {
-  if (v == null) return String(v);
+function __resetConsoleInstrumentationFlagForTest() {
+  if (typeof console !== "undefined") {
+    delete console[CONSOLE_FLAG];
+  }
+}
+function safeStringifyArg(v) {
+  if (v === null || v === void 0) return String(v);
   if (typeof v === "string") return v;
-  if (v instanceof Error) return `${v.name}: ${v.message}`;
-  try {
-    return typeof v === "object" ? JSON.stringify(v) : String(v);
-  } catch {
-    return Object.prototype.toString.call(v);
+  if (typeof v === "number" || typeof v === "boolean" || typeof v === "bigint") return String(v);
+  if (typeof v === "symbol") return v.toString();
+  if (typeof v === "function") return `[Function${v.name ? ` ${v.name}` : ""}]`;
+  if (v instanceof Error) {
+    return `${v.name || "Error"}: ${v.message}${v.stack ? `
+${v.stack}` : ""}`;
+  }
+  if (typeof v === "object") {
+    try {
+      const seen = /* @__PURE__ */ new WeakSet();
+      const out = JSON.stringify(v, (_key, val) => {
+        if (typeof val === "object" && val !== null) {
+          if (seen.has(val)) return "[Circular]";
+          seen.add(val);
+        }
+        if (typeof val === "bigint") return val.toString();
+        if (typeof val === "function") return `[Function${val.name ? ` ${val.name}` : ""}]`;
+        if (typeof val === "symbol") return val.toString();
+        return val;
+      });
+      return out ?? Object.prototype.toString.call(v);
+    } catch {
+      return Object.prototype.toString.call(v);
+    }
   }
+  return String(v);
+}
+function truncate(s) {
+  if (s.length <= MAX_ARG_BYTES) return s;
+  return s.slice(0, MAX_ARG_BYTES) + "\u2026[truncated]";
 }
 
 // src/architecture.ts
@@ -1587,6 +1663,7 @@ function applyArchitectureTags(setTag) {
 // src/navigation.ts
 var NAV_FLAG = /* @__PURE__ */ Symbol.for("allstak.nav.subscribed");
 var LINKING_FLAG = "__allstak_linking_patched__";
+var NAV_AUTO_PATCH_FLAG = /* @__PURE__ */ Symbol.for("allstak.nav.autoPatched");
 function instrumentReactNavigation(navigationRef, options = {}) {
   if (!navigationRef || typeof navigationRef.addListener !== "function") {
     return () => {
@@ -1654,8 +1731,59 @@ function instrumentNavigationFromLinking() {
   } catch {
   }
 }
+function tryAutoInstrumentNavigation() {
+  const g = globalThis;
+  const isMetro = typeof g.__METRO_GLOBAL_PREFIX__ !== "undefined" || typeof g.__r === "function" || typeof g.HermesInternal !== "undefined";
+  if (isMetro) return false;
+  try {
+    const rnav = require("@react-navigation/native");
+    if (!rnav || !rnav.NavigationContainer) return false;
+    if (rnav[NAV_AUTO_PATCH_FLAG]) return true;
+    const React2 = require("react");
+    if (!React2 || typeof React2.forwardRef !== "function") return false;
+    const OrigContainer = rnav.NavigationContainer;
+    const Wrapped = React2.forwardRef(function AllStakNavigationContainer(props, userRef) {
+      const internalRef = React2.useRef(null);
+      const setRef = React2.useCallback((r) => {
+        internalRef.current = r;
+        if (typeof userRef === "function") userRef(r);
+        else if (userRef) userRef.current = r;
+      }, [userRef]);
+      React2.useEffect(() => {
+        if (internalRef.current) {
+          try {
+            instrumentReactNavigation(internalRef.current);
+          } catch {
+          }
+        }
+      }, []);
+      return React2.createElement(OrigContainer, { ...props, ref: setRef });
+    });
+    Wrapped.displayName = "AllStakNavigationContainer";
+    try {
+      Object.defineProperty(rnav, "NavigationContainer", {
+        value: Wrapped,
+        configurable: true,
+        writable: true
+      });
+      rnav[NAV_AUTO_PATCH_FLAG] = true;
+      return true;
+    } catch {
+      return false;
+    }
+  } catch {
+    return false;
+  }
+}
+function __resetAutoNavigationFlagForTest() {
+  try {
+    const rnav = require("@react-navigation/native");
+    if (rnav) delete rnav[NAV_AUTO_PATCH_FLAG];
+  } catch {
+  }
+}
 
-// src/index.ts
+// src/install.ts
 function instrumentXmlHttpRequest() {
   const flag = "__allstak_xhr_patched__";
   const X = globalThis.XMLHttpRequest;
@@ -1707,43 +1835,6 @@ function instrumentXmlHttpRequest() {
   };
   X.prototype[flag] = true;
 }
-var __testNativeModule = null;
-function __setNativeModuleForTest(mod) {
-  __testNativeModule = mod;
-}
-async function drainPendingNativeCrashes(release) {
-  try {
-    let native = __testNativeModule;
-    if (!native) {
-      const rn = require("react-native");
-      native = rn?.NativeModules?.AllStakNative;
-    }
-    if (!native) return;
-    if (typeof native.install === "function") {
-      try {
-        await native.install(release ?? "");
-      } catch {
-      }
-    }
-    if (typeof native.drainPendingCrash === "function") {
-      const json = await native.drainPendingCrash();
-      if (json && json !== "") {
-        try {
-          const payload = JSON.parse(json);
-          const err = new Error(payload?.message ?? "Native crash");
-          err.name = payload?.exceptionClass ?? "NativeCrash";
-          err.stack = Array.isArray(payload?.stackTrace) ? payload.stackTrace.join("\n") : String(payload?.stackTrace ?? "");
-          AllStak.captureException(err, {
-            ...payload?.metadata || {},
-            "native.crash": "true"
-          });
-        } catch {
-        }
-      }
-    }
-  } catch {
-  }
-}
 function installReactNative(options = {}) {
   const autoError = options.autoErrorHandler !== false;
   const autoPromise = options.autoPromiseRejections !== false;
@@ -1790,9 +1881,21 @@ function installReactNative(options = {}) {
   }
   if (options.autoConsoleBreadcrumbs !== false) {
     try {
-      instrumentConsole(__safeAddBreadcrumbForInstrumentation);
+      const cfg = AllStak.getConfig();
+      instrumentConsole(__safeAddBreadcrumbForInstrumentation, cfg?.captureConsole);
+    } catch {
+    }
+  }
+  if (options.autoNavigationBreadcrumbs !== false) {
+    let navResult = false;
+    try {
+      navResult = tryAutoInstrumentNavigation();
     } catch {
     }
+    if (options.debugLogs) {
+      if (navResult) console.log("[AllStak] Navigation auto-instrumentation enabled");
+      else console.log("[AllStak] Navigation auto-instrumentation not applied; use instrumentReactNavigation(ref) fallback");
+    }
   }
   if (autoDevice) {
     try {
@@ -1843,17 +1946,30 @@ function installReactNative(options = {}) {
     }
   }
   if (autoPromise) {
+    const wrapTrackerReason = (rejection) => rejection instanceof Error ? rejection : new Error(`Unhandled promise rejection: ${String(rejection)}`);
+    const ship = (err) => {
+      try {
+        AllStak.captureException(err, { source: "unhandledRejection" });
+      } catch {
+      }
+    };
+    try {
+      const hermesInternal = globalThis.HermesInternal;
+      if (hermesInternal && typeof hermesInternal.enablePromiseRejectionTracker === "function") {
+        hermesInternal.enablePromiseRejectionTracker({
+          allRejections: true,
+          onUnhandled: (_id, rejection) => ship(wrapTrackerReason(rejection)),
+          onHandled: () => {
+          }
+        });
+      }
+    } catch {
+    }
     try {
       const tracking = require("promise/setimmediate/rejection-tracking");
       tracking.enable({
         allRejections: true,
-        onUnhandled: (_id, rejection) => {
-          const err = rejection instanceof Error ? rejection : new Error(`Unhandled promise rejection: ${String(rejection)}`);
-          try {
-            AllStak.captureException(err, { source: "unhandledRejection" });
-          } catch {
-          }
-        },
+        onUnhandled: (_id, rejection) => ship(wrapTrackerReason(rejection)),
         onHandled: () => {
         }
       });
@@ -1863,13 +1979,206 @@ function installReactNative(options = {}) {
         g.addEventListener("unhandledrejection", (ev) => {
           const reason = ev?.reason;
           const err = reason instanceof Error ? reason : new Error(String(reason));
-          try {
-            AllStak.captureException(err, { source: "unhandledRejection" });
-          } catch {
-          }
+          ship(err);
         });
       }
     }
   }
 }
+
+// src/provider.tsx
+var AllStakContext = React.createContext(null);
+var __providerOwnedInstance = null;
+var AllStakErrorBoundary = class extends React.Component {
+  constructor() {
+    super(...arguments);
+    this.state = { error: null };
+    this.resetError = () => this.setState({ error: null });
+  }
+  static getDerivedStateFromError(error) {
+    return { error };
+  }
+  componentDidCatch(error, info) {
+    try {
+      AllStak.addBreadcrumb("ui", "React error boundary caught error", "error", {
+        componentStack: info.componentStack ?? ""
+      });
+      AllStak.captureException(error, {
+        componentStack: info.componentStack ?? "",
+        source: "AllStakProvider.ErrorBoundary"
+      });
+      if (this.props.debug) {
+        console.log(`[AllStak] Captured render error: ${error.message}`);
+      }
+    } catch {
+    }
+    try {
+      this.props.onError?.(error, info.componentStack ?? void 0);
+    } catch {
+    }
+  }
+  render() {
+    if (this.state.error) {
+      const { fallback } = this.props;
+      if (typeof fallback === "function") {
+        return fallback({ error: this.state.error, resetError: this.resetError });
+      }
+      if (fallback !== void 0) return fallback;
+      return null;
+    }
+    return this.props.children;
+  }
+};
+function AllStakProvider({
+  children,
+  apiKey,
+  environment,
+  release,
+  host,
+  user,
+  tags,
+  debug,
+  enableHttpTracking,
+  httpTracking,
+  captureConsole,
+  sampleRate,
+  beforeSend,
+  replay,
+  tracesSampleRate,
+  service,
+  dist,
+  destroyOnUnmount = false,
+  fallback,
+  onError,
+  autoErrorHandler,
+  autoPromiseRejections,
+  autoDeviceTags,
+  autoAppStateBreadcrumbs,
+  autoNetworkCapture,
+  autoFetchBreadcrumbs,
+  autoConsoleBreadcrumbs,
+  autoNavigationBreadcrumbs
+}) {
+  const clientRef = React.useRef(null);
+  if (!clientRef.current) {
+    const existing = AllStak._getInstance();
+    if (existing && __providerOwnedInstance === existing) {
+      clientRef.current = existing;
+      if (debug) {
+        console.log(`[AllStak] Reusing session ${AllStak.getSessionId()}`);
+      }
+    } else {
+      const config = {
+        apiKey,
+        environment,
+        release,
+        host,
+        user,
+        tags,
+        enableHttpTracking,
+        httpTracking,
+        captureConsole,
+        sampleRate,
+        beforeSend,
+        replay,
+        tracesSampleRate,
+        service,
+        dist
+      };
+      clientRef.current = AllStak.init(config);
+      __providerOwnedInstance = clientRef.current;
+      installReactNative({
+        autoErrorHandler,
+        autoPromiseRejections,
+        autoDeviceTags,
+        autoAppStateBreadcrumbs,
+        autoNetworkCapture,
+        autoFetchBreadcrumbs,
+        autoConsoleBreadcrumbs,
+        autoNavigationBreadcrumbs,
+        debugLogs: debug
+      });
+      if (debug) {
+        console.log(`[AllStak] Initialized \u2014 session ${AllStak.getSessionId()}`);
+      }
+    }
+  }
+  React.useEffect(() => {
+    return () => {
+      if (destroyOnUnmount) {
+        AllStak.destroy();
+        __providerOwnedInstance = null;
+        clientRef.current = null;
+        if (debug) console.log("[AllStak] Destroyed on unmount");
+      }
+    };
+  }, [destroyOnUnmount, debug]);
+  return /* @__PURE__ */ React.createElement(AllStakContext.Provider, { value: clientRef.current }, /* @__PURE__ */ React.createElement(AllStakErrorBoundary, { fallback, onError, debug }, children));
+}
+function useAllStak() {
+  return React.useMemo(
+    () => ({
+      captureException: (error, ctx) => AllStak.captureException(error, ctx),
+      captureMessage: (msg, level = "info") => AllStak.captureMessage(msg, level),
+      setUser: (user) => AllStak.setUser(user),
+      setTag: (key, value) => AllStak.setTag(key, value),
+      addBreadcrumb: (type, message, level, data) => AllStak.addBreadcrumb(type, message, level, data)
+    }),
+    []
+  );
+}
+function __resetProviderInstanceForTest() {
+  __providerOwnedInstance = null;
+}
+
+// src/index.ts
+var __testNativeModule = null;
+function __setNativeModuleForTest(mod) {
+  __testNativeModule = mod;
+}
+async function __devTriggerNativeCrash() {
+  try {
+    let native = __testNativeModule;
+    if (!native) {
+      const rn = require("react-native");
+      native = rn?.NativeModules?.AllStakNative;
+    }
+    if (!native || typeof native.__devTriggerCrash !== "function") return;
+    await native.__devTriggerCrash();
+  } catch {
+  }
+}
+async function drainPendingNativeCrashes(release) {
+  try {
+    let native = __testNativeModule;
+    if (!native) {
+      const rn = require("react-native");
+      native = rn?.NativeModules?.AllStakNative;
+    }
+    if (!native) return;
+    if (typeof native.install === "function") {
+      try {
+        await native.install(release ?? "");
+      } catch {
+      }
+    }
+    if (typeof native.drainPendingCrash === "function") {
+      const json = await native.drainPendingCrash();
+      if (json && json !== "") {
+        try {
+          const payload = JSON.parse(json);
+          const err = new Error(payload?.message ?? "Native crash");
+          err.name = payload?.exceptionClass ?? "NativeCrash";
+          err.stack = Array.isArray(payload?.stackTrace) ? payload.stackTrace.join("\n") : String(payload?.stackTrace ?? "");
+          AllStak.captureException(err, {
+            ...payload?.metadata || {},
+            "native.crash": "true"
+          });
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+}
 //# sourceMappingURL=index.js.map