@codmir/sdk 0.1.1

package/dist/react-native/index.d.cts

@@ -0,0 +1,95 @@
+import { O as OverseerConfig } from '../index-BlgYnCLd.cjs';
+export { B as Breadcrumb, S as SeverityLevel, U as UserContext, d as addBreadcrumb, c as captureException, a as captureMessage, e as close, f as flush, g as getClient, b as setTags, s as setUser } from '../index-BlgYnCLd.cjs';
+
+/**
+ * @codmir/sdk/react-native - React Native Integration
+ *
+ * Error tracking and monitoring for React Native applications.
+ *
+ * @example
+ * ```typescript
+ * // App.tsx
+ * import * as Codmir from '@codmir/sdk/react-native';
+ *
+ * Codmir.init({
+ *   dsn: 'https://your-project.codmir.com/api/overseer',
+ * });
+ *
+ * export default function App() {
+ *   return (
+ *     <Codmir.ErrorBoundary fallback={<ErrorScreen />}>
+ *       <YourApp />
+ *     </Codmir.ErrorBoundary>
+ *   );
+ * }
+ * ```
+ */
+
+interface ReactNativeConfig extends OverseerConfig {
+    /** Automatically capture native crashes */
+    captureNativeCrashes?: boolean;
+    /** Automatically track screen views */
+    trackScreenViews?: boolean;
+    /** Automatically track app state changes */
+    trackAppState?: boolean;
+    /** Include device info in events */
+    includeDeviceInfo?: boolean;
+}
+interface DeviceInfo {
+    platform: "ios" | "android";
+    osVersion?: string;
+    deviceModel?: string;
+    appVersion?: string;
+    buildNumber?: string;
+    isEmulator?: boolean;
+}
+declare function init(config?: ReactNativeConfig): void;
+/**
+ * Set device information (call this after getting device info from react-native-device-info)
+ */
+declare function setDeviceInfo(info: DeviceInfo): void;
+/**
+ * Track screen view (call this from your navigation listener)
+ */
+declare function trackScreenView(screenName: string, params?: Record<string, unknown>): void;
+/**
+ * Create a navigation listener for React Navigation
+ */
+declare function createNavigationListener(): (state: any) => void;
+/**
+ * Track app state change (foreground/background)
+ */
+declare function trackAppStateChange(state: "active" | "background" | "inactive"): void;
+/**
+ * Error Boundary props
+ */
+interface ErrorBoundaryProps {
+    children: React.ReactNode;
+    fallback: React.ReactNode | ((error: Error) => React.ReactNode);
+    onError?: (error: Error, componentStack: string) => void;
+}
+/**
+ * Note: ErrorBoundary is a class component placeholder.
+ * In actual usage, import React and implement properly.
+ */
+declare function createErrorBoundary(React: any): {
+    new (props: ErrorBoundaryProps): {
+        [x: string]: any;
+        componentDidCatch(error: Error, errorInfo: {
+            componentStack: string;
+        }): void;
+        render(): any;
+    };
+    [x: string]: any;
+    getDerivedStateFromError(error: Error): {
+        hasError: boolean;
+        error: Error;
+    };
+};
+
+/**
+ * Check if Overseer is initialized
+ */
+declare function isOverseerInitialized(): boolean;
+
+export { type DeviceInfo, type ErrorBoundaryProps, OverseerConfig, type ReactNativeConfig, createErrorBoundary, createNavigationListener, init, isOverseerInitialized, setDeviceInfo, trackAppStateChange, trackScreenView };

package/dist/react-native/index.d.ts

@@ -0,0 +1,95 @@
+import { O as OverseerConfig } from '../index-BlgYnCLd.js';
+export { B as Breadcrumb, S as SeverityLevel, U as UserContext, d as addBreadcrumb, c as captureException, a as captureMessage, e as close, f as flush, g as getClient, b as setTags, s as setUser } from '../index-BlgYnCLd.js';
+
+/**
+ * @codmir/sdk/react-native - React Native Integration
+ *
+ * Error tracking and monitoring for React Native applications.
+ *
+ * @example
+ * ```typescript
+ * // App.tsx
+ * import * as Codmir from '@codmir/sdk/react-native';
+ *
+ * Codmir.init({
+ *   dsn: 'https://your-project.codmir.com/api/overseer',
+ * });
+ *
+ * export default function App() {
+ *   return (
+ *     <Codmir.ErrorBoundary fallback={<ErrorScreen />}>
+ *       <YourApp />
+ *     </Codmir.ErrorBoundary>
+ *   );
+ * }
+ * ```
+ */
+
+interface ReactNativeConfig extends OverseerConfig {
+    /** Automatically capture native crashes */
+    captureNativeCrashes?: boolean;
+    /** Automatically track screen views */
+    trackScreenViews?: boolean;
+    /** Automatically track app state changes */
+    trackAppState?: boolean;
+    /** Include device info in events */
+    includeDeviceInfo?: boolean;
+}
+interface DeviceInfo {
+    platform: "ios" | "android";
+    osVersion?: string;
+    deviceModel?: string;
+    appVersion?: string;
+    buildNumber?: string;
+    isEmulator?: boolean;
+}
+declare function init(config?: ReactNativeConfig): void;
+/**
+ * Set device information (call this after getting device info from react-native-device-info)
+ */
+declare function setDeviceInfo(info: DeviceInfo): void;
+/**
+ * Track screen view (call this from your navigation listener)
+ */
+declare function trackScreenView(screenName: string, params?: Record<string, unknown>): void;
+/**
+ * Create a navigation listener for React Navigation
+ */
+declare function createNavigationListener(): (state: any) => void;
+/**
+ * Track app state change (foreground/background)
+ */
+declare function trackAppStateChange(state: "active" | "background" | "inactive"): void;
+/**
+ * Error Boundary props
+ */
+interface ErrorBoundaryProps {
+    children: React.ReactNode;
+    fallback: React.ReactNode | ((error: Error) => React.ReactNode);
+    onError?: (error: Error, componentStack: string) => void;
+}
+/**
+ * Note: ErrorBoundary is a class component placeholder.
+ * In actual usage, import React and implement properly.
+ */
+declare function createErrorBoundary(React: any): {
+    new (props: ErrorBoundaryProps): {
+        [x: string]: any;
+        componentDidCatch(error: Error, errorInfo: {
+            componentStack: string;
+        }): void;
+        render(): any;
+    };
+    [x: string]: any;
+    getDerivedStateFromError(error: Error): {
+        hasError: boolean;
+        error: Error;
+    };
+};
+
+/**
+ * Check if Overseer is initialized
+ */
+declare function isOverseerInitialized(): boolean;
+
+export { type DeviceInfo, type ErrorBoundaryProps, OverseerConfig, type ReactNativeConfig, createErrorBoundary, createNavigationListener, init, isOverseerInitialized, setDeviceInfo, trackAppStateChange, trackScreenView };

package/dist/react-native/index.js

@@ -0,0 +1,128 @@
+import {
+  addBreadcrumb,
+  captureException,
+  captureMessage,
+  close,
+  flush,
+  getClient,
+  init,
+  setTags,
+  setUser
+} from "../chunk-T7OAAOG2.js";
+import "../chunk-MLKGABMK.js";
+
+// src/react-native/index.ts
+var isInitialized = false;
+var deviceInfo = null;
+function init2(config = {}) {
+  if (isInitialized) return;
+  const {
+    captureNativeCrashes = true,
+    trackScreenViews = true,
+    trackAppState = true,
+    includeDeviceInfo = true,
+    ...coreConfig
+  } = config;
+  init(coreConfig);
+  isInitialized = true;
+  const originalHandler = ErrorUtils.getGlobalHandler();
+  ErrorUtils.setGlobalHandler((error, isFatal) => {
+    captureException(error, {
+      handled: false,
+      mechanism: "global-error-handler",
+      fatal: isFatal,
+      device: deviceInfo
+    });
+    if (originalHandler) {
+      originalHandler(error, isFatal);
+    }
+  });
+}
+function setDeviceInfo(info) {
+  deviceInfo = info;
+  setTags({
+    "device.platform": info.platform,
+    "device.os_version": info.osVersion || "unknown",
+    "device.model": info.deviceModel || "unknown",
+    "app.version": info.appVersion || "unknown",
+    "app.build": info.buildNumber || "unknown"
+  });
+}
+function trackScreenView(screenName, params) {
+  addBreadcrumb({
+    category: "navigation",
+    message: `Screen: ${screenName}`,
+    data: params
+  });
+}
+function createNavigationListener() {
+  return (state) => {
+    const currentRoute = getCurrentRouteName(state);
+    if (currentRoute) {
+      trackScreenView(currentRoute);
+    }
+  };
+}
+function getCurrentRouteName(state) {
+  if (!state) return null;
+  const route = state.routes[state.index];
+  if (route.state) {
+    return getCurrentRouteName(route.state);
+  }
+  return route.name;
+}
+function trackAppStateChange(state) {
+  addBreadcrumb({
+    category: "app.lifecycle",
+    message: `App state: ${state}`,
+    data: { state }
+  });
+}
+function createErrorBoundary(React) {
+  return class ErrorBoundary extends React.Component {
+    constructor(props) {
+      super(props);
+      this.state = { hasError: false, error: null };
+    }
+    static getDerivedStateFromError(error) {
+      return { hasError: true, error };
+    }
+    componentDidCatch(error, errorInfo) {
+      captureException(error, {
+        mechanism: "react-error-boundary",
+        componentStack: errorInfo.componentStack
+      });
+      this.props.onError?.(error, errorInfo.componentStack);
+    }
+    render() {
+      if (this.state.hasError) {
+        const { fallback } = this.props;
+        if (typeof fallback === "function") {
+          return fallback(this.state.error);
+        }
+        return fallback;
+      }
+      return this.props.children;
+    }
+  };
+}
+function isOverseerInitialized() {
+  return isInitialized && getClient() !== null;
+}
+export {
+  addBreadcrumb,
+  captureException,
+  captureMessage,
+  close,
+  createErrorBoundary,
+  createNavigationListener,
+  flush,
+  getClient,
+  init2 as init,
+  isOverseerInitialized,
+  setDeviceInfo,
+  setTags,
+  setUser,
+  trackAppStateChange,
+  trackScreenView
+};

package/dist/replay/index.cjs

@@ -0,0 +1,284 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/replay/index.ts
+var replay_exports = {};
+__export(replay_exports, {
+  ReplayPlayer: () => ReplayPlayer,
+  ReplayRecorder: () => ReplayRecorder,
+  createReplayPlayer: () => createReplayPlayer,
+  createReplayRecorder: () => createReplayRecorder
+});
+module.exports = __toCommonJS(replay_exports);
+var import_nanoid = require("nanoid");
+var DEFAULT_PRIVACY = {
+  maskAllInputs: false,
+  maskInputTypes: ["password", "credit-card"],
+  maskSelectors: ["[data-private]", ".private"],
+  blockSelectors: ["[data-block-replay]"],
+  ignoreSelectors: []
+};
+var DEFAULT_CONFIG = {
+  sessionSampleRate: 0.1,
+  errorSampleRate: 1,
+  maxSessionDuration: 60 * 60 * 1e3,
+  segmentDuration: 5 * 60 * 1e3,
+  privacy: DEFAULT_PRIVACY
+};
+var ReplayRecorder = class {
+  config;
+  session = null;
+  currentSegment = null;
+  isRecording = false;
+  sessionStartTime = 0;
+  cleanupFns = [];
+  onSegmentReady;
+  onSessionEnd;
+  constructor(config = {}) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+  }
+  start(options) {
+    if (this.isRecording) return this.session?.id || null;
+    if (typeof window === "undefined") return null;
+    if (Math.random() > this.config.sessionSampleRate) return null;
+    this.sessionStartTime = Date.now();
+    this.session = {
+      id: (0, import_nanoid.nanoid)(),
+      userId: options?.userId,
+      startedAt: /* @__PURE__ */ new Date(),
+      duration: 0,
+      url: window.location.href,
+      userAgent: navigator.userAgent,
+      viewport: { width: window.innerWidth, height: window.innerHeight },
+      events: [],
+      errorIds: [],
+      segments: [],
+      tags: options?.tags || {}
+    };
+    this.startNewSegment();
+    this.isRecording = true;
+    this.setupEventListeners();
+    this.captureSnapshot();
+    return this.session.id;
+  }
+  stop() {
+    if (!this.isRecording || !this.session) return null;
+    this.isRecording = false;
+    this.session.endedAt = /* @__PURE__ */ new Date();
+    this.session.duration = Date.now() - this.sessionStartTime;
+    if (this.currentSegment) {
+      this.currentSegment.endTime = this.session.duration;
+      this.session.segments.push(this.currentSegment);
+      this.onSegmentReady?.(this.currentSegment);
+    }
+    this.cleanupFns.forEach((fn) => fn());
+    this.cleanupFns = [];
+    let finalSession = this.session;
+    if (this.config.beforeSend) {
+      const processed = this.config.beforeSend(this.session);
+      if (!processed) {
+        this.session = null;
+        return null;
+      }
+      finalSession = processed;
+    }
+    this.onSessionEnd?.(finalSession);
+    const result = finalSession;
+    this.session = null;
+    this.currentSegment = null;
+    return result;
+  }
+  markError(errorId) {
+    this.session?.errorIds.push(errorId);
+  }
+  addCustomEvent(name, payload) {
+    this.addEvent({
+      type: "custom",
+      timestamp: this.getRelativeTime(),
+      data: { name, payload }
+    });
+  }
+  getSessionId() {
+    return this.session?.id || null;
+  }
+  isActive() {
+    return this.isRecording;
+  }
+  onSegment(handler) {
+    this.onSegmentReady = handler;
+  }
+  onSession(handler) {
+    this.onSessionEnd = handler;
+  }
+  getRelativeTime() {
+    return Date.now() - this.sessionStartTime;
+  }
+  addEvent(event) {
+    if (!this.isRecording || !this.currentSegment) return;
+    this.currentSegment.events.push(event);
+    if (event.timestamp - this.currentSegment.startTime >= this.config.segmentDuration) {
+      this.finalizeSegment();
+      this.startNewSegment();
+    }
+    if (event.timestamp >= this.config.maxSessionDuration) {
+      this.stop();
+    }
+  }
+  startNewSegment() {
+    this.currentSegment = {
+      id: (0, import_nanoid.nanoid)(),
+      sessionId: this.session.id,
+      sequenceNumber: this.session.segments.length,
+      startTime: this.getRelativeTime(),
+      endTime: 0,
+      events: []
+    };
+  }
+  finalizeSegment() {
+    if (!this.currentSegment || !this.session) return;
+    this.currentSegment.endTime = this.getRelativeTime();
+    this.session.segments.push(this.currentSegment);
+    this.onSegmentReady?.(this.currentSegment);
+  }
+  captureSnapshot() {
+    if (typeof document === "undefined") return;
+    this.addEvent({
+      type: "dom_snapshot",
+      timestamp: this.getRelativeTime(),
+      data: {
+        html: document.documentElement.outerHTML,
+        baseUrl: document.baseURI,
+        doctype: document.doctype ? `<!DOCTYPE ${document.doctype.name}>` : void 0
+      }
+    });
+  }
+  setupEventListeners() {
+    let lastMouseMove = 0;
+    const onMouseMove = (e) => {
+      if (Date.now() - lastMouseMove < 50) return;
+      lastMouseMove = Date.now();
+      this.addEvent({
+        type: "mouse_move",
+        timestamp: this.getRelativeTime(),
+        data: { x: e.clientX, y: e.clientY }
+      });
+    };
+    window.addEventListener("mousemove", onMouseMove);
+    this.cleanupFns.push(() => window.removeEventListener("mousemove", onMouseMove));
+    const onClick = (e) => {
+      this.addEvent({
+        type: "mouse_click",
+        timestamp: this.getRelativeTime(),
+        data: { x: e.clientX, y: e.clientY, button: e.button }
+      });
+    };
+    window.addEventListener("click", onClick);
+    this.cleanupFns.push(() => window.removeEventListener("click", onClick));
+    let lastScroll = 0;
+    const onScroll = () => {
+      if (Date.now() - lastScroll < 100) return;
+      lastScroll = Date.now();
+      this.addEvent({
+        type: "scroll",
+        timestamp: this.getRelativeTime(),
+        data: { targetId: "window", x: window.scrollX, y: window.scrollY }
+      });
+    };
+    window.addEventListener("scroll", onScroll);
+    this.cleanupFns.push(() => window.removeEventListener("scroll", onScroll));
+    const onResize = () => {
+      this.addEvent({
+        type: "viewport",
+        timestamp: this.getRelativeTime(),
+        data: { width: window.innerWidth, height: window.innerHeight }
+      });
+    };
+    window.addEventListener("resize", onResize);
+    this.cleanupFns.push(() => window.removeEventListener("resize", onResize));
+  }
+};
+var ReplayPlayer = class {
+  config;
+  session = null;
+  state = "idle";
+  currentTime = 0;
+  animationFrameId = null;
+  constructor(config) {
+    this.config = {
+      speed: 1,
+      skipInactiveThreshold: 5e3,
+      showCursor: true,
+      showClickRipple: true,
+      highlightErrors: true,
+      ...config
+    };
+  }
+  load(session) {
+    this.session = session;
+    this.currentTime = 0;
+    this.state = "idle";
+  }
+  play() {
+    if (!this.session) return;
+    this.state = "playing";
+  }
+  pause() {
+    this.state = "paused";
+    if (this.animationFrameId) {
+      cancelAnimationFrame(this.animationFrameId);
+    }
+  }
+  stop() {
+    this.pause();
+    this.currentTime = 0;
+    this.state = "idle";
+  }
+  seek(time) {
+    if (!this.session) return;
+    this.currentTime = Math.max(0, Math.min(time, this.session.duration));
+  }
+  setSpeed(speed) {
+    this.config.speed = speed;
+  }
+  getState() {
+    return this.state;
+  }
+  getCurrentTime() {
+    return this.currentTime;
+  }
+  getDuration() {
+    return this.session?.duration || 0;
+  }
+  destroy() {
+    this.stop();
+  }
+};
+function createReplayRecorder(config) {
+  return new ReplayRecorder(config);
+}
+function createReplayPlayer(config) {
+  return new ReplayPlayer(config);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ReplayPlayer,
+  ReplayRecorder,
+  createReplayPlayer,
+  createReplayRecorder
+});