crumbtrail-react-native 0.2.0

package/dist/index.js

@@ -0,0 +1,766 @@
+// src/capabilities.ts
+var REACT_NATIVE_CAPABILITY_BITS = {
+  asyncStorage: 1 << 0,
+  navigation: 1 << 1,
+  viewShot: 1 << 2
+};
+var OPTIONAL_MODULES = [
+  {
+    key: "asyncStorage",
+    packageName: "@react-native-async-storage/async-storage",
+    capability: "async-storage",
+    bit: REACT_NATIVE_CAPABILITY_BITS.asyncStorage
+  },
+  {
+    key: "navigation",
+    packageName: "@react-navigation/native",
+    capability: "navigation",
+    bit: REACT_NATIVE_CAPABILITY_BITS.navigation
+  },
+  {
+    key: "viewShot",
+    packageName: "react-native-view-shot",
+    capability: "view-snapshot",
+    bit: REACT_NATIVE_CAPABILITY_BITS.viewShot
+  }
+];
+function detectReactNativeCapabilities(options = {}) {
+  const resolver = options.resolver ?? safeRequireOptionalModule;
+  const modules = {};
+  const capabilities = [];
+  let bitset = 0;
+  for (const optionalModule of OPTIONAL_MODULES) {
+    const present = isModulePresent(optionalModule.packageName, resolver);
+    modules[optionalModule.key] = {
+      packageName: optionalModule.packageName,
+      present,
+      status: present ? "present" : "absent"
+    };
+    if (present) {
+      bitset |= optionalModule.bit;
+      capabilities.push(optionalModule.capability);
+    }
+  }
+  return { bitset, capabilities, modules };
+}
+function isModulePresent(packageName, resolver) {
+  try {
+    return resolver(packageName) !== void 0;
+  } catch {
+    return false;
+  }
+}
+function safeRequireOptionalModule(packageName) {
+  try {
+    const requireFn = getRequire();
+    return requireFn ? requireFn(packageName) : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function getRequire() {
+  try {
+    const maybeRequire = Function(
+      'return typeof require === "function" ? require : undefined'
+    )();
+    return typeof maybeRequire === "function" ? maybeRequire : void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/session-store.ts
+import { DEFAULT_SESSION_STORAGE_KEY } from "crumbtrail-core";
+function createReactNativeSessionStore(storage, key = DEFAULT_SESSION_STORAGE_KEY) {
+  if (!storage) return void 0;
+  let cached;
+  return {
+    read() {
+      return cached;
+    },
+    write(session) {
+      cached = session;
+      try {
+        const result = storage.setItem(key, JSON.stringify(session));
+        if (result && typeof result.catch === "function") {
+          void result.catch(() => {
+          });
+        }
+      } catch {
+      }
+    },
+    async hydrate() {
+      try {
+        const raw = await storage.getItem(key);
+        cached = parsePersistedSession(raw);
+        return cached;
+      } catch {
+        return void 0;
+      }
+    }
+  };
+}
+function parsePersistedSession(raw) {
+  if (!raw) return void 0;
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.id !== "string" || parsed.id.length === 0)
+      return void 0;
+    return {
+      id: parsed.id,
+      lastActivity: typeof parsed.lastActivity === "number" ? parsed.lastActivity : 0
+    };
+  } catch {
+    return void 0;
+  }
+}
+
+// src/logger.ts
+import { Crumbtrail } from "crumbtrail-core";
+
+// src/target-descriptor.ts
+function createReactNativeTargetDescriptor(input) {
+  const descriptor = {
+    role: input.role,
+    label: input.label ?? input.accessibilityLabel,
+    testID: input.testID ?? input.testId,
+    accessibilityId: input.accessibilityId,
+    componentName: input.componentName,
+    routePath: input.routePath,
+    ancestryHash: input.ancestryHash,
+    bounds: input.bounds,
+    redaction: input.redaction
+  };
+  const hasIdentity = Boolean(
+    descriptor.role || descriptor.label || descriptor.testID || descriptor.accessibilityId || descriptor.componentName || descriptor.routePath || descriptor.ancestryHash
+  );
+  return hasIdentity ? descriptor : void 0;
+}
+
+// src/replay-lite.ts
+function createReactNativeReplayLite(options) {
+  const emit2 = (type, data, target) => {
+    options.logger.addEvent({
+      type,
+      data,
+      platform: "react-native",
+      sdk: { name: "crumbtrail-react-native" },
+      capabilities: options.capabilities,
+      ...target ? { target } : {}
+    });
+  };
+  return {
+    recordViewSnapshot(snapshot) {
+      emit2("view-snapshot", {
+        kind: "component-tree",
+        routePath: snapshot.routePath,
+        root: sanitizeNode(snapshot.root)
+      });
+    },
+    recordTouch(overlay) {
+      const target = overlay.target ? createReactNativeTargetDescriptor(
+        overlay.target
+      ) : void 0;
+      emit2(
+        "touch",
+        {
+          kind: "overlay",
+          x: overlay.x,
+          y: overlay.y,
+          phase: overlay.phase ?? "press"
+        },
+        target
+      );
+    },
+    async captureCrashScreenshot(target) {
+      const capture = target !== void 0 && options.viewShot?.captureRef ? options.viewShot.captureRef(target, { format: "jpg", quality: 0.7 }) : options.viewShot?.captureScreen?.({ format: "jpg", quality: 0.7 });
+      if (!capture) return void 0;
+      try {
+        const uri = await capture;
+        emit2("view-snapshot", {
+          kind: "crash-screenshot",
+          uri,
+          capture: "react-native-view-shot"
+        });
+        return uri;
+      } catch {
+        return void 0;
+      }
+    }
+  };
+}
+function sanitizeNode(node) {
+  return {
+    id: node.id,
+    componentName: node.componentName,
+    role: node.role,
+    label: node.label,
+    testID: node.testID,
+    accessibilityId: node.accessibilityId,
+    bounds: node.bounds,
+    children: node.children?.map(sanitizeNode)
+  };
+}
+
+// src/collectors.ts
+var DEFAULT_COLLECTORS = {
+  console: true,
+  errors: true,
+  network: true,
+  appState: true,
+  environment: true,
+  navigation: true,
+  replayLite: true
+};
+function startReactNativeCollectors(logger, options) {
+  const enabled = resolveCollectorConfig(options.config);
+  const globalObject = options.globalObject ?? globalThis;
+  const reactNative = options.reactNative ?? resolveModule("react-native", options.resolver);
+  const cleanup = [];
+  if (enabled.console)
+    cleanup.push(
+      startConsoleCollector(logger, options.capabilities, globalObject)
+    );
+  if (enabled.errors)
+    cleanup.push(
+      startErrorCollector(
+        logger,
+        options.capabilities,
+        globalObject,
+        options.errorUtils
+      )
+    );
+  if (enabled.network)
+    cleanup.push(
+      startNetworkCollector(logger, options.capabilities, globalObject)
+    );
+  if (enabled.appState)
+    cleanup.push(
+      startAppStateCollector(
+        logger,
+        options.capabilities,
+        reactNative?.AppState
+      )
+    );
+  if (enabled.environment)
+    startEnvironmentCollector(logger, options.capabilities, reactNative);
+  if (enabled.navigation)
+    cleanup.push(
+      startNavigationCollector(
+        logger,
+        options.capabilities,
+        options.navigation
+      )
+    );
+  const viewShot = resolveModule(
+    "react-native-view-shot",
+    options.resolver
+  );
+  const replayLite = enabled.replayLite ? createReactNativeReplayLite({
+    logger,
+    capabilities: options.capabilities.capabilities,
+    viewShot
+  }) : void 0;
+  return {
+    cleanup() {
+      for (const stop of cleanup.splice(0).reverse()) stop();
+    },
+    replayLite
+  };
+}
+function resolveCollectorConfig(config) {
+  if (config === false) {
+    return Object.fromEntries(
+      Object.keys(DEFAULT_COLLECTORS).map((key) => [key, false])
+    );
+  }
+  if (config === true || config === void 0) return { ...DEFAULT_COLLECTORS };
+  return { ...DEFAULT_COLLECTORS, ...config };
+}
+function emit(logger, capabilities, type, data, target) {
+  logger.addEvent({
+    type,
+    data,
+    platform: "react-native",
+    sdk: { name: "crumbtrail-react-native" },
+    capabilities: capabilities.capabilities,
+    ...target ? { target } : {}
+  });
+}
+function startConsoleCollector(logger, capabilities, globalObject) {
+  const consoleObject = globalObject.console;
+  if (!consoleObject) return () => {
+  };
+  const mutableConsole = consoleObject;
+  const methods = ["log", "warn", "error", "debug", "info"];
+  const originals = /* @__PURE__ */ new Map();
+  const level = {
+    log: "log",
+    warn: "warn",
+    error: "err",
+    debug: "dbg",
+    info: "info"
+  };
+  for (const method of methods) {
+    if (typeof mutableConsole[method] !== "function") continue;
+    const original = mutableConsole[method].bind(consoleObject);
+    originals.set(method, original);
+    mutableConsole[method] = (...args) => {
+      emit(logger, capabilities, "con", {
+        lv: level[method],
+        args: args.map((arg) => safeStringify(arg))
+      });
+      original(...args);
+    };
+  }
+  return () => {
+    for (const [method, original] of originals) {
+      mutableConsole[method] = original;
+    }
+  };
+}
+function startErrorCollector(logger, capabilities, globalObject, suppliedErrorUtils) {
+  const cleanup = [];
+  const errorUtils = suppliedErrorUtils ?? globalObject.ErrorUtils;
+  if (errorUtils?.setGlobalHandler && errorUtils.getGlobalHandler) {
+    const previous = errorUtils.getGlobalHandler();
+    if (typeof previous !== "function") return () => {
+    };
+    errorUtils.setGlobalHandler((error, isFatal) => {
+      emit(logger, capabilities, "err", {
+        msg: error instanceof Error ? error.message : String(error),
+        stk: error instanceof Error ? error.stack : void 0,
+        fatal: Boolean(isFatal),
+        source: "react-native-global-handler"
+      });
+      previous?.(error, isFatal);
+    });
+    cleanup.push(() => {
+      if (previous) errorUtils.setGlobalHandler?.(previous);
+    });
+  }
+  const addEventListener = globalObject.addEventListener;
+  const removeEventListener = globalObject.removeEventListener;
+  if (addEventListener && removeEventListener) {
+    const onUnhandledRejection = (event) => {
+      const reason = event.reason;
+      emit(logger, capabilities, "rej", {
+        msg: reason instanceof Error ? reason.message : String(reason),
+        stk: reason instanceof Error ? reason.stack : void 0,
+        source: "react-native-unhandled-rejection"
+      });
+    };
+    addEventListener.call(
+      globalObject,
+      "unhandledrejection",
+      onUnhandledRejection
+    );
+    cleanup.push(
+      () => removeEventListener.call(
+        globalObject,
+        "unhandledrejection",
+        onUnhandledRejection
+      )
+    );
+  }
+  return () => {
+    for (const stop of cleanup.reverse()) stop();
+  };
+}
+function startNetworkCollector(logger, capabilities, globalObject) {
+  const cleanup = [];
+  const originalFetch = globalObject.fetch;
+  if (typeof originalFetch === "function") {
+    globalObject.fetch = (async (input, init) => {
+      const startedAt = Date.now();
+      const method = init?.method?.toUpperCase() ?? "GET";
+      const url = extractUrl(input);
+      try {
+        const response = await originalFetch(input, init);
+        emit(logger, capabilities, "net", {
+          url,
+          method,
+          status: response.status,
+          ok: response.ok,
+          dur: Date.now() - startedAt,
+          source: "fetch"
+        });
+        return response;
+      } catch (error) {
+        emit(logger, capabilities, "net", {
+          url,
+          method,
+          error: error instanceof Error ? error.message : String(error),
+          dur: Date.now() - startedAt,
+          source: "fetch"
+        });
+        throw error;
+      }
+    });
+    cleanup.push(() => {
+      globalObject.fetch = originalFetch;
+    });
+  }
+  const Xhr = globalObject.XMLHttpRequest;
+  if (Xhr?.prototype) {
+    const originalOpen = Xhr.prototype.open;
+    const originalSend = Xhr.prototype.send;
+    if (typeof originalOpen === "function" && typeof originalSend === "function") {
+      Xhr.prototype.open = function open(method, url, ...rest) {
+        this.__crumbtrailNetwork = { method, url };
+        return originalOpen.call(this, method, url, ...rest);
+      };
+      Xhr.prototype.send = function send(body) {
+        const startedAt = Date.now();
+        const info = this.__crumbtrailNetwork;
+        const previous = this.onreadystatechange;
+        this.onreadystatechange = () => {
+          if (this.readyState === 4) {
+            emit(logger, capabilities, "net", {
+              url: info?.url,
+              method: info?.method?.toUpperCase(),
+              status: this.status,
+              dur: Date.now() - startedAt,
+              source: "xmlhttprequest"
+            });
+          }
+          previous?.call(this);
+        };
+        return originalSend.call(this, body);
+      };
+      cleanup.push(() => {
+        Xhr.prototype.open = originalOpen;
+        Xhr.prototype.send = originalSend;
+      });
+    }
+  }
+  return () => {
+    for (const stop of cleanup.reverse()) stop();
+  };
+}
+function startAppStateCollector(logger, capabilities, appState) {
+  if (!appState?.addEventListener) return () => {
+  };
+  const subscription = appState.addEventListener("change", (state) => {
+    emit(logger, capabilities, "app-lifecycle", { state, source: "AppState" });
+  });
+  emit(logger, capabilities, "app-lifecycle", {
+    state: appState.currentState,
+    source: "AppState",
+    kind: "initial"
+  });
+  return toCleanup(subscription);
+}
+function startEnvironmentCollector(logger, capabilities, reactNative) {
+  const window = reactNative?.Dimensions?.get?.("window");
+  emit(logger, capabilities, "env", {
+    kind: "snapshot",
+    platform: {
+      os: reactNative?.Platform?.OS,
+      version: reactNative?.Platform?.Version,
+      constants: reactNative?.Platform?.constants
+    },
+    viewport: window ? {
+      w: window.width,
+      h: window.height,
+      scale: window.scale,
+      fontScale: window.fontScale
+    } : void 0
+  });
+}
+function startNavigationCollector(logger, capabilities, navigation) {
+  if (!navigation?.addListener) return () => {
+  };
+  let previousRouteKey;
+  const emitCurrentRoute = () => {
+    const route = navigation.getCurrentRoute?.();
+    if (!route || route.key === previousRouteKey) return;
+    previousRouteKey = route.key;
+    emit(logger, capabilities, "navigation", {
+      name: route.name,
+      path: route.path,
+      key: route.key
+    });
+  };
+  const subscription = navigation.addListener("state", emitCurrentRoute);
+  emitCurrentRoute();
+  return toCleanup(subscription);
+}
+function resolveModule(packageName, resolver) {
+  if (!resolver) return void 0;
+  try {
+    return resolver(packageName);
+  } catch {
+    return void 0;
+  }
+}
+function extractUrl(input) {
+  if (typeof input === "string") return input;
+  if (input instanceof URL) return input.toString();
+  if (typeof Request !== "undefined" && input instanceof Request)
+    return input.url;
+  return String(input);
+}
+function safeStringify(value) {
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function toCleanup(subscription) {
+  if (typeof subscription === "function") return subscription;
+  if (subscription?.remove) return () => subscription.remove?.();
+  return () => {
+  };
+}
+
+// src/logger.ts
+var REACT_NATIVE_DEFAULT_CONFIG = {
+  network: false,
+  interactions: false,
+  keystrokes: false,
+  scroll: false,
+  visibility: false,
+  clipboard: false,
+  cookies: false,
+  storage: false,
+  performance: false,
+  video: false,
+  audio: false,
+  widget: false,
+  sessionPersistence: "session"
+};
+function createReactNativeCrumbtrail(options = {}) {
+  const capabilities = detectReactNativeCapabilities({
+    resolver: options.resolver
+  });
+  const userConfig = options.config;
+  const sessionStore = options.asyncStorage ? createReactNativeSessionStore(options.asyncStorage) : userConfig?.sessionStore;
+  const config = {
+    ...REACT_NATIVE_DEFAULT_CONFIG,
+    ...userConfig,
+    ...sessionStore ? { sessionStore } : {}
+  };
+  const logger = Crumbtrail.init(config);
+  if (options.reportCapabilities !== false) {
+    logger.addEvent({
+      type: "rn.capabilities",
+      data: {
+        bitset: capabilities.bitset,
+        capabilities: capabilities.capabilities,
+        modules: capabilities.modules
+      },
+      platform: "react-native",
+      sdk: { name: "crumbtrail-react-native" },
+      capabilities: capabilities.capabilities
+    });
+  }
+  const collectors = startReactNativeCollectors(logger, {
+    config: options.collectors,
+    capabilities,
+    resolver: options.resolver,
+    globalObject: options.globalObject,
+    reactNative: options.reactNative,
+    navigation: options.navigation,
+    errorUtils: options.errorUtils
+  });
+  wrapStopWithCollectorCleanup(logger, collectors);
+  return { logger, capabilities, collectors };
+}
+async function createReactNativeCrumbtrailAsync(options = {}) {
+  const sessionStore = options.asyncStorage ? createReactNativeSessionStore(options.asyncStorage) : void 0;
+  await sessionStore?.hydrate();
+  return createReactNativeCrumbtrail({
+    ...options,
+    asyncStorage: void 0,
+    config: {
+      ...options.config,
+      ...sessionStore ? { sessionStore } : {}
+    }
+  });
+}
+function wrapStopWithCollectorCleanup(logger, collectors) {
+  const stop = logger.stop.bind(logger);
+  let cleaned = false;
+  logger.stop = async () => {
+    if (!cleaned) {
+      cleaned = true;
+      collectors.cleanup();
+    }
+    return stop();
+  };
+}
+
+// src/provider.ts
+import {
+  createContext,
+  createElement,
+  useContext,
+  useEffect,
+  useState
+} from "react";
+var CrumbtrailReactNativeContext = createContext(void 0);
+function CrumbtrailReactNativeProvider(props) {
+  const [value, setValue] = useState(() => {
+    if (!props.logger && props.asyncStorage) return void 0;
+    return props.logger ? {
+      logger: props.logger,
+      capabilities: detectReactNativeCapabilities({
+        resolver: props.resolver
+      })
+    } : createReactNativeCrumbtrail({
+      config: props.config,
+      resolver: props.resolver,
+      reportCapabilities: props.reportCapabilities
+    });
+  });
+  useEffect(() => {
+    let active = true;
+    if (props.logger) {
+      setValue({
+        logger: props.logger,
+        capabilities: detectReactNativeCapabilities({
+          resolver: props.resolver
+        })
+      });
+      return;
+    }
+    if (!props.asyncStorage) return;
+    let hydratedLogger;
+    createReactNativeCrumbtrailAsync({
+      config: props.config,
+      asyncStorage: props.asyncStorage,
+      resolver: props.resolver,
+      reportCapabilities: props.reportCapabilities
+    }).then((result) => {
+      if (!active) {
+        void result.logger.stop();
+        return;
+      }
+      hydratedLogger = result.logger;
+      setValue(result);
+    }).catch(() => {
+    });
+    return () => {
+      active = false;
+      if (hydratedLogger) void hydratedLogger.stop();
+    };
+  }, [
+    props.asyncStorage,
+    props.config,
+    props.logger,
+    props.reportCapabilities,
+    props.resolver
+  ]);
+  if (!value) return props.fallback ?? null;
+  return createElement(
+    CrumbtrailReactNativeContext.Provider,
+    { value },
+    props.children
+  );
+}
+function useCrumbtrailReactNative() {
+  const value = useContext(CrumbtrailReactNativeContext);
+  if (!value) {
+    throw new Error(
+      "useCrumbtrailReactNative must be used within CrumbtrailReactNativeProvider"
+    );
+  }
+  return value;
+}
+
+// src/use-bug-state.ts
+import { useEffect as useEffect2, useRef } from "react";
+var REDACTED_VALUE = "[REDACTED]";
+var SENSITIVE_NAME_RE = /(^|[^a-z0-9])(access[-_]?token|api[-_]?key|auth|authorization|bearer|card[-_]?number|client[-_]?secret|cookie|credential(s)?|creds|csrf|cvv|cvc|id[-_]?token|jsessionid|jwt|mfa|otp|pass[-_]?phrase|pass(code|word)?|passwd|password[-_]?confirmation|pin|private[-_]?key|pwd|refresh[-_]?token|secret|security[-_]?code|session|session[-_]?id|sid|ssn|token|verification[-_]?code|xsrf)([^a-z0-9]|$)/i;
+var TOKEN_RE = /\b(?:Bearer|Token|Basic)\s+[A-Za-z0-9._~+/=-]{8,}\b|\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\b|(?:sk|pk|rk|ghp|gho|ghu|ghs|glpat|xox[baprs])[-_][A-Za-z0-9_.=-]{12,}|\b[A-Fa-f0-9]{32,}\b|\b[A-Za-z0-9_-]{40,}\b/gi;
+function isSensitiveName(name) {
+  const normalized = name.replace(/([a-z])([A-Z])/g, "$1_$2");
+  return SENSITIVE_NAME_RE.test(name) || SENSITIVE_NAME_RE.test(normalized);
+}
+function redactReactNativeSnapshot(value, keyName) {
+  if (keyName && isSensitiveName(keyName)) return REDACTED_VALUE;
+  if (typeof value === "string") {
+    if (/^\s*[^:=\n\r]{1,120}\s*[:=]/.test(value)) {
+      return value.replace(
+        /^(\s*[^:=\n\r]{1,120}\s*[:=]).*$/s,
+        (_match, key) => {
+          return isSensitiveName(key) ? `${key}${REDACTED_VALUE}` : value.replace(TOKEN_RE, REDACTED_VALUE);
+        }
+      );
+    }
+    return value.replace(TOKEN_RE, REDACTED_VALUE);
+  }
+  if (Array.isArray(value))
+    return value.map((entry) => redactReactNativeSnapshot(entry));
+  if (value && typeof value === "object") {
+    const output = {};
+    for (const [key, entry] of Object.entries(
+      value
+    )) {
+      output[key] = redactReactNativeSnapshot(entry, key);
+    }
+    return output;
+  }
+  return value;
+}
+function useBugState(logger, name, value, options = {}) {
+  const valueRef = useRef(value);
+  valueRef.current = value;
+  useEffect2(() => {
+    if (!logger || typeof logger.registerStateProvider !== "function") return;
+    return logger.registerStateProvider(
+      name,
+      () => options.captureRawState ? valueRef.current : redactReactNativeSnapshot(valueRef.current)
+    );
+  }, [logger, name, options.captureRawState]);
+}
+
+// src/error-boundary.ts
+import { Component } from "react";
+var CrumbtrailReactNativeErrorBoundary = class extends Component {
+  constructor(props) {
+    super(props);
+    this.state = { hasError: false };
+  }
+  static getDerivedStateFromError(_error) {
+    return { hasError: true };
+  }
+  componentDidCatch(error, errorInfo) {
+    this.props.logger.addEvent({
+      type: "err",
+      data: {
+        msg: redactReactNativeSnapshot(error.message),
+        stack: redactReactNativeSnapshot(error.stack),
+        componentStack: redactReactNativeSnapshot(errorInfo.componentStack),
+        source: "react-native-error-boundary"
+      }
+    });
+  }
+  resetError() {
+    this.setState({ hasError: false });
+  }
+  render() {
+    if (this.state.hasError) {
+      return this.props.fallback ?? null;
+    }
+    return this.props.children;
+  }
+};
+export {
+  CrumbtrailReactNativeErrorBoundary,
+  CrumbtrailReactNativeProvider,
+  REACT_NATIVE_CAPABILITY_BITS,
+  createReactNativeCrumbtrail,
+  createReactNativeCrumbtrailAsync,
+  createReactNativeReplayLite,
+  createReactNativeSessionStore,
+  createReactNativeTargetDescriptor,
+  detectReactNativeCapabilities,
+  redactReactNativeSnapshot,
+  startReactNativeCollectors,
+  useBugState,
+  useCrumbtrailReactNative
+};