eventlog-rn 0.3.1

package/dist/index.js

@@ -0,0 +1,1170 @@
+'use strict';
+
+var MMKVModule = require('react-native-mmkv');
+var React5 = require('react');
+var reactNative = require('react-native');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var MMKVModule__namespace = /*#__PURE__*/_interopNamespace(MMKVModule);
+var React5__default = /*#__PURE__*/_interopDefault(React5);
+
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/core/utils.ts
+var generateUUID = () => {
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+};
+var getTimestamp = () => Date.now();
+var getTimestampISO = () => (/* @__PURE__ */ new Date()).toISOString();
+var getTimezone = () => {
+  try {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone;
+  } catch {
+    return "UTC";
+  }
+};
+var debounce = (func, wait) => {
+  let timeout = null;
+  return (...args) => {
+    if (timeout !== null) {
+      clearTimeout(timeout);
+    }
+    timeout = setTimeout(() => {
+      func(...args);
+    }, wait);
+  };
+};
+
+// src/core/events.ts
+var createEvent = (session, context, category, payload) => {
+  return {
+    eventId: generateUUID(),
+    sessionId: session.sessionId,
+    seq: session.seq,
+    timestamp: getTimestamp(),
+    timestampISO: getTimestampISO(),
+    timezone: getTimezone(),
+    category,
+    payload,
+    context
+  };
+};
+var createScreenPayload = (name, params) => {
+  return { name, params };
+};
+var createActionPayload = (name, data) => {
+  return { name, data };
+};
+var createLogPayload = (level, message, data) => {
+  return { level, message, data };
+};
+var createErrorPayload = (error, context) => {
+  const err = error;
+  const payload = {
+    message: err.message ?? String(error),
+    ...err.stack !== void 0 && { stack: err.stack },
+    ...context !== void 0 && { context }
+  };
+  return payload;
+};
+var incrementSeq = (session) => {
+  return {
+    ...session,
+    seq: session.seq + 1
+  };
+};
+var updateSessionActivity = (session) => {
+  return {
+    ...session,
+    lastActivityTime: getTimestamp()
+  };
+};
+var createSession = (startType) => {
+  const now = getTimestamp();
+  return {
+    sessionId: generateUUID(),
+    sessionStart: now,
+    startType,
+    seq: 0,
+    lastActivityTime: now
+  };
+};
+var SENSITIVE_KEYS = [
+  "password",
+  "token",
+  "authorization",
+  "secret",
+  "apiKey",
+  "api_key",
+  "accessToken",
+  "access_token",
+  "refreshToken",
+  "refresh_token"
+];
+var MAX_DEPTH = 10;
+var MAX_SIZE = 100 * 1024;
+var isSensitiveKey = (key) => {
+  const lowerKey = key.toLowerCase();
+  return SENSITIVE_KEYS.some((sensitive) => lowerKey.includes(sensitive));
+};
+var sanitizeValue = (value, depth) => {
+  if (depth > MAX_DEPTH) {
+    return { _maxDepthExceeded: true };
+  }
+  if (value === null || value === void 0) {
+    return value;
+  }
+  if (typeof value !== "object") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => sanitizeValue(item, depth + 1));
+  }
+  const sanitized = {};
+  for (const key in value) {
+    if (Object.prototype.hasOwnProperty.call(value, key)) {
+      const val = value[key];
+      sanitized[key] = isSensitiveKey(key) ? "***REDACTED***" : sanitizeValue(val, depth + 1);
+    }
+  }
+  return sanitized;
+};
+var sanitizeEvent = (event) => {
+  const sanitizedPayload = sanitizeValue(event.payload, 0);
+  const sanitizedContext = sanitizeValue(event.context, 0);
+  const size = JSON.stringify(event).length;
+  if (size > MAX_SIZE) {
+    return {
+      ...event,
+      payload: { _truncated: true, _originalSize: size },
+      context: event.context
+    };
+  }
+  return {
+    ...event,
+    payload: sanitizedPayload,
+    context: sanitizedContext
+  };
+};
+var exportEventsAsJSONL = (events, mode) => {
+  const filtered = mode === "repro" ? getReproEvents(events) : events;
+  return filtered.map((event) => JSON.stringify(event)).join("\n");
+};
+var getReproEvents = (events) => {
+  if (events.length === 0) {
+    return [];
+  }
+  const lastEvent = events[events.length - 1];
+  if (lastEvent === void 0) {
+    return [];
+  }
+  const currentSessionId = lastEvent.sessionId;
+  const sessionIds = Array.from(new Set(events.map((e) => e.sessionId)));
+  const currentSessionIndex = sessionIds.indexOf(currentSessionId);
+  const previousSessionId = currentSessionIndex > 0 ? sessionIds[currentSessionIndex - 1] ?? null : null;
+  const errors = events.filter((e) => e.category === "error").slice(-10);
+  const sessionEvents = events.filter(
+    (e) => e.sessionId === currentSessionId || e.sessionId === previousSessionId
+  );
+  const combined = [...sessionEvents];
+  errors.forEach((error) => {
+    if (!combined.find((e) => e.eventId === error.eventId)) {
+      combined.push(error);
+    }
+  });
+  return combined.sort((a, b) => a.timestamp - b.timestamp);
+};
+
+// src/core/buffer.ts
+var createRingBuffer = (maxSize) => {
+  return {
+    buffer: new Array(maxSize).fill(void 0),
+    writeIndex: 0,
+    size: 0,
+    maxSize
+  };
+};
+var pushEvent = (state, event) => {
+  const newBuffer = [...state.buffer];
+  newBuffer[state.writeIndex] = event;
+  return {
+    ...state,
+    buffer: newBuffer,
+    writeIndex: (state.writeIndex + 1) % state.maxSize,
+    size: Math.min(state.size + 1, state.maxSize)
+  };
+};
+var toArray = (state) => {
+  if (state.size < state.maxSize) {
+    return state.buffer.slice(0, state.size).filter((e) => e !== void 0);
+  }
+  const afterWrite = state.buffer.slice(state.writeIndex);
+  const beforeWrite = state.buffer.slice(0, state.writeIndex);
+  return [...afterWrite, ...beforeWrite].filter((e) => e !== void 0);
+};
+var clearBuffer = (state) => {
+  return createRingBuffer(state.maxSize);
+};
+
+// src/core/query.ts
+var queryEvents = (events, query) => {
+  let filtered = events;
+  if (query.category && query.category.length > 0) {
+    filtered = filtered.filter((e) => {
+      const categories = query.category;
+      return categories ? categories.includes(e.category) : true;
+    });
+  }
+  if (query.timeRange) {
+    filtered = filtered.filter(
+      (e) => e.timestamp >= query.timeRange.start && e.timestamp <= query.timeRange.end
+    );
+  }
+  if (query.sessionId) {
+    filtered = filtered.filter((e) => e.sessionId === query.sessionId);
+  }
+  if (query.search) {
+    const searchLower = query.search.toLowerCase();
+    filtered = filtered.filter((e) => {
+      const payloadStr = JSON.stringify(e.payload).toLowerCase();
+      return payloadStr.includes(searchLower);
+    });
+  }
+  if (query.limit && query.limit > 0) {
+    filtered = filtered.slice(-query.limit);
+  }
+  return filtered;
+};
+
+// src/core/network.ts
+var originalFetch = global.fetch;
+var originalXMLHttpRequest = global.XMLHttpRequest;
+var interceptFetch = (eventLog2, config) => {
+  if (!config.interceptFetch) return;
+  global.fetch = async (input, init) => {
+    const startTime = Date.now();
+    const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
+    const method = (init?.method ?? "GET").toUpperCase();
+    try {
+      const response = await originalFetch(input, init);
+      const endTime = Date.now();
+      const duration = endTime - startTime;
+      const clone = response.clone();
+      let responseBody;
+      if (config.logResponseBody) {
+        try {
+          const text = await clone.text();
+          if (!config.maxBodySize || text.length <= config.maxBodySize) {
+            try {
+              responseBody = JSON.parse(text);
+            } catch {
+              responseBody = text;
+            }
+          } else {
+            responseBody = `[Body too large: ${text.length} bytes]`;
+          }
+        } catch {
+          responseBody = "[Failed to read response body]";
+        }
+      }
+      const payload = {
+        url,
+        method,
+        status: response.status,
+        duration,
+        responseHeaders: config.redactHeaders ? redactHeaders(response.headers, config.redactHeaders) : headersToObject(response.headers),
+        responseBody
+      };
+      eventLog2.network(payload);
+      return response;
+    } catch (error) {
+      const endTime = Date.now();
+      eventLog2.error(error, {
+        url,
+        method,
+        duration: endTime - startTime,
+        category: "network"
+        // Context hack
+      });
+      throw error;
+    }
+  };
+};
+var interceptXHR = (eventLog2, config) => {
+  if (config.interceptAxios === false) return;
+  const XHR = originalXMLHttpRequest;
+  global.XMLHttpRequest = function() {
+    const xhr = new XHR();
+    const startTime = Date.now();
+    let method = "GET";
+    let url = "";
+    const originalOpen = xhr.open;
+    const originalSend = xhr.send;
+    xhr.open = function(m, u, ...args) {
+      method = m.toUpperCase();
+      url = u;
+      return originalOpen.apply(this, [m, u, ...args]);
+    };
+    xhr.send = function(body) {
+      xhr.addEventListener("loadend", () => {
+        const duration = Date.now() - startTime;
+        const responseHeadersString = xhr.getAllResponseHeaders();
+        const responseHeaders = parseXHRHeaders(responseHeadersString);
+        let responseBody;
+        if (config.logResponseBody) {
+          try {
+            if (xhr.responseType === "" || xhr.responseType === "text") {
+              responseBody = xhr.responseText;
+              if (responseBody && typeof responseBody === "string" && (!config.maxBodySize || responseBody.length <= config.maxBodySize)) {
+                try {
+                  responseBody = JSON.parse(responseBody);
+                } catch {
+                }
+              }
+            }
+          } catch {
+          }
+        }
+        const payload = {
+          url,
+          method,
+          status: xhr.status,
+          duration,
+          responseHeaders: config.redactHeaders ? redactHeaders(responseHeaders, config.redactHeaders) : responseHeaders,
+          responseBody
+        };
+        if (typeof eventLog2.network === "function") {
+          eventLog2.network(payload);
+        }
+      });
+      return originalSend.apply(this, [body]);
+    };
+    return xhr;
+  };
+  global.XMLHttpRequest.prototype = XHR.prototype;
+  Object.assign(global.XMLHttpRequest, XHR);
+};
+var headersToObject = (headers) => {
+  const obj = {};
+  headers.forEach((value, key) => {
+    obj[key] = value;
+  });
+  return obj;
+};
+var redactHeaders = (headers, keysToRedact) => {
+  const obj = headers instanceof Headers ? headersToObject(headers) : headers;
+  const redacted = { ...obj };
+  keysToRedact.forEach((key) => {
+    const lowerKey = key.toLowerCase();
+    Object.keys(redacted).forEach((h) => {
+      if (h.toLowerCase() === lowerKey) {
+        redacted[h] = "***REDACTED***";
+      }
+    });
+  });
+  return redacted;
+};
+var parseXHRHeaders = (headers) => {
+  if (!headers) return {};
+  const result = {};
+  const pairs = headers.trim().split(/[\r\n]+/);
+  pairs.forEach((line) => {
+    const parts = line.split(": ");
+    if (parts.length >= 2) {
+      const key = parts.shift();
+      const value = parts.join(": ");
+      result[key] = value;
+    }
+  });
+  return result;
+};
+var enableNetworkInterception = (eventLog2, config) => {
+  if (!config || false) return;
+  restoreNetworkInterception();
+  if (config.interceptFetch !== false) {
+    interceptFetch(eventLog2, config);
+  }
+  if (config.interceptAxios !== false) {
+    interceptXHR(eventLog2, config);
+  }
+};
+var restoreNetworkInterception = () => {
+  global.fetch = originalFetch;
+  global.XMLHttpRequest = originalXMLHttpRequest;
+};
+
+// src/core/errors.ts
+var enableGlobalErrorLogging = (eventLog2, config) => {
+  if (!config || config.enabled === false) return;
+  try {
+    if (global.ErrorUtils) {
+      const originalHandler = global.ErrorUtils.getGlobalHandler();
+      global.ErrorUtils.setGlobalHandler((error, isFatal) => {
+        eventLog2.error(error, {
+          isFatal,
+          origin: "global_handler",
+          timestamp: Date.now()
+        });
+        if (originalHandler) {
+          originalHandler(error, isFatal);
+        }
+      });
+    }
+  } catch (e) {
+    console.warn("[EventLog] Failed to setup ErrorUtils handler", e);
+  }
+  const rejectionHandler = (event) => {
+    const reason = event?.reason;
+    if (reason) {
+      eventLog2.error(reason, {
+        origin: "unhandled_rejection",
+        isFatal: false
+      });
+    }
+  };
+  if (typeof window !== "undefined" && window.addEventListener) {
+    window.addEventListener("unhandledrejection", rejectionHandler);
+  }
+};
+var mmkv;
+try {
+  const m = MMKVModule__namespace?.default ? MMKVModule__namespace.default : MMKVModule__namespace;
+  if (typeof m.createMMKV === "function") {
+    mmkv = m.createMMKV({ id: "eventlog-rn" });
+  } else if (typeof m.MMKV === "function") {
+    mmkv = new m.MMKV({ id: "eventlog-rn" });
+  } else if (typeof m === "function") {
+    mmkv = new m({ id: "eventlog-rn" });
+  } else {
+    throw new Error("MMKV module found but no valid constructor (createMMKV or class MMKV) found.");
+  }
+} catch (error) {
+  const errorMessage = error instanceof Error ? error.message : String(error);
+  throw new Error(
+    `[EventLog] Failed to initialize MMKV: ${errorMessage}.`
+  );
+}
+var internalStorage = {
+  setItem: async (key, value) => {
+    mmkv.set(key, value);
+  },
+  getItem: async (key) => {
+    return mmkv.getString(key) ?? null;
+  },
+  removeItem: async (key) => {
+    if (typeof mmkv.remove === "function") {
+      mmkv.remove(key);
+    } else {
+      mmkv.delete(key);
+    }
+  }
+};
+
+// src/core/eventlog.ts
+var STORAGE_KEYS = {
+  SESSION: "eventlog-rn/session",
+  EVENTS: "eventlog-rn/events"
+};
+var createEventLog = (config = {}) => {
+  let state = null;
+  let initPromise = null;
+  let preInitQueue = [];
+  const loadSession = async (storage) => {
+    try {
+      const data = await storage.getItem(STORAGE_KEYS.SESSION);
+      if (!data) {
+        return null;
+      }
+      return JSON.parse(data);
+    } catch {
+      return null;
+    }
+  };
+  const saveSession = async (storage, session) => {
+    try {
+      await storage.setItem(STORAGE_KEYS.SESSION, JSON.stringify(session));
+    } catch (error) {
+      console.warn("[EventLog] Failed to save session:", error);
+    }
+  };
+  const loadEvents = async (storage) => {
+    try {
+      const data = await storage.getItem(STORAGE_KEYS.EVENTS);
+      if (!data) {
+        return [];
+      }
+      return JSON.parse(data);
+    } catch {
+      return [];
+    }
+  };
+  const saveEventsImmediate = async (storage, events) => {
+    try {
+      await storage.setItem(STORAGE_KEYS.EVENTS, JSON.stringify(events));
+    } catch (error) {
+      console.warn("[EventLog] Failed to save events:", error);
+    }
+  };
+  const saveEvents = debounce(
+    (storage, events) => {
+      saveEventsImmediate(storage, events);
+    },
+    config.batchWriteDelayMs ?? 100
+  );
+  const autoDetectDeviceInfo = () => {
+    try {
+      const { Platform, Dimensions } = __require("react-native");
+      return {
+        platform: Platform.OS,
+        platformVersion: Platform.Version,
+        screenWidth: Dimensions.get("window").width,
+        screenHeight: Dimensions.get("window").height
+      };
+    } catch {
+      return {};
+    }
+  };
+  const init = async (runtimeConfig) => {
+    if (runtimeConfig) {
+      Object.assign(config, runtimeConfig);
+    }
+    if (state?.initialized) {
+      return { ok: true, value: void 0 };
+    }
+    if (initPromise) {
+      return initPromise;
+    }
+    initPromise = (async () => {
+      try {
+        const savedSession = await loadSession(internalStorage);
+        const now = Date.now();
+        const timeoutMs = (config.sessionTimeoutMinutes ?? 30) * 60 * 1e3;
+        const session = savedSession && now - savedSession.lastActivityTime < timeoutMs ? { ...savedSession, startType: "warm" } : createSession("cold");
+        const events = await loadEvents(internalStorage);
+        let buffer = createRingBuffer(config.maxEvents ?? 1e3);
+        const maxAge = (config.maxAgeDays ?? 7) * 24 * 60 * 60 * 1e3;
+        events.forEach((event) => {
+          if (now - event.timestamp < maxAge) {
+            buffer = pushEvent(buffer, event);
+          }
+        });
+        const deviceInfo = autoDetectDeviceInfo();
+        state = {
+          config,
+          session,
+          buffer,
+          context: { deviceInfo },
+          initialized: true
+        };
+        await saveSession(internalStorage, session);
+        if (preInitQueue.length > 0) {
+          preInitQueue.forEach((item) => {
+            logEvent(item.category, item.payload);
+          });
+          preInitQueue = [];
+        }
+        const networkConfig = config.features?.network ?? { enabled: true };
+        if (networkConfig.enabled !== false) {
+          const proxyConfig = {
+            ...networkConfig,
+            enabled: true
+          };
+          const networkProxy = {
+            log: (level, message, data) => logEvent("log", createLogPayload(level, message, data)),
+            error: (error, context) => logEvent("error", createErrorPayload(error, context)),
+            network: (payload) => logEvent("network", payload)
+          };
+          enableNetworkInterception(networkProxy, proxyConfig);
+        }
+        const globalErrorsConfig = config.features?.globalErrors ?? { enabled: true };
+        if (globalErrorsConfig.enabled !== false) {
+          const errorProxy = {
+            error: (error, context) => logEvent("error", createErrorPayload(error, context))
+          };
+          enableGlobalErrorLogging(errorProxy, { ...globalErrorsConfig, enabled: true });
+        }
+        return { ok: true, value: void 0 };
+      } catch (error) {
+        console.error("[EventLog] Initialization failed:", error);
+        return {
+          ok: false,
+          error: error instanceof Error ? error : new Error(String(error))
+        };
+      }
+    })();
+    return initPromise;
+  };
+  const isReady = () => {
+    return state?.initialized ?? false;
+  };
+  const logEvent = (category, payload) => {
+    if (!state?.initialized) {
+      preInitQueue.push({ category, payload });
+      return { ok: true, value: void 0 };
+    }
+    try {
+      let event = createEvent(state.session, state.context, category, payload);
+      event = sanitizeEvent(event);
+      if (state.config.sanitize) {
+        event = state.config.sanitize(event);
+      }
+      state.buffer = pushEvent(state.buffer, event);
+      state.session = incrementSeq(state.session);
+      state.session = updateSessionActivity(state.session);
+      const events = toArray(state.buffer);
+      saveEvents(internalStorage, events);
+      saveSession(internalStorage, state.session);
+      return { ok: true, value: void 0 };
+    } catch (error) {
+      return {
+        ok: false,
+        error: error instanceof Error ? error : new Error(String(error))
+      };
+    }
+  };
+  return {
+    init,
+    isReady,
+    screen: (name, params) => {
+      return logEvent("screen", createScreenPayload(name, params));
+    },
+    action: (name, data) => {
+      return logEvent("action", createActionPayload(name, data));
+    },
+    log: (level, message, data) => {
+      return logEvent("log", createLogPayload(level, message, data));
+    },
+    error: (error, context) => {
+      return logEvent("error", createErrorPayload(error, context));
+    },
+    setUser: (user) => {
+      if (state) {
+        state.context = { ...state.context, user };
+      }
+    },
+    setContext: (key, value) => {
+      if (state) {
+        state.context = { ...state.context, [key]: value };
+      }
+    },
+    setDeviceInfo: (info) => {
+      if (state) {
+        state.context = { ...state.context, deviceInfo: info };
+      }
+    },
+    export: async (options) => {
+      if (!state?.initialized) {
+        return {
+          ok: false,
+          error: new Error("[EventLog] Not initialized")
+        };
+      }
+      try {
+        const events = toArray(state.buffer);
+        await saveEventsImmediate(internalStorage, events);
+        const jsonl = exportEventsAsJSONL(events, options.mode);
+        return { ok: true, value: jsonl };
+      } catch (error) {
+        return {
+          ok: false,
+          error: error instanceof Error ? error : new Error(String(error))
+        };
+      }
+    },
+    clear: async () => {
+      if (!state?.initialized) {
+        return {
+          ok: false,
+          error: new Error("[EventLog] Not initialized")
+        };
+      }
+      try {
+        state.buffer = clearBuffer(state.buffer);
+        state.context = {};
+        await internalStorage.removeItem(STORAGE_KEYS.EVENTS);
+        return { ok: true, value: void 0 };
+      } catch (error) {
+        return {
+          ok: false,
+          error: error instanceof Error ? error : new Error(String(error))
+        };
+      }
+    },
+    getEvents: () => {
+      if (!state?.initialized) {
+        return {
+          ok: false,
+          error: new Error("[EventLog] Not initialized")
+        };
+      }
+      const events = toArray(state.buffer);
+      return { ok: true, value: events };
+    },
+    query: (query) => {
+      if (!state?.initialized) {
+        return {
+          ok: false,
+          error: new Error("[EventLog] Not initialized")
+        };
+      }
+      try {
+        const events = toArray(state.buffer);
+        const filtered = queryEvents(events, query);
+        return { ok: true, value: filtered };
+      } catch (error) {
+        return {
+          ok: false,
+          error: error instanceof Error ? error : new Error(String(error))
+        };
+      }
+    },
+    network: (payload) => {
+      return logEvent("network", payload);
+    }
+  };
+};
+var colors = {
+  background: "#f9fafb",
+  surface: "#fff",
+  border: "#e5e7eb",
+  text: {
+    primary: "#111827",
+    secondary: "#6b7280",
+    tertiary: "#9ca3af"
+  },
+  primary: "#3b82f6"
+};
+var styles = reactNative.StyleSheet.create({
+  container: {
+    flex: 1,
+    backgroundColor: colors.background
+  },
+  header: {
+    flexDirection: "row",
+    justifyContent: "space-between",
+    alignItems: "center",
+    padding: 16,
+    backgroundColor: colors.surface,
+    borderBottomWidth: 1,
+    borderBottomColor: colors.border
+  },
+  title: {
+    fontSize: 18,
+    fontWeight: "600",
+    color: colors.text.primary
+  },
+  headerButtons: {
+    flexDirection: "row",
+    gap: 8
+  },
+  button: {
+    paddingHorizontal: 12,
+    paddingVertical: 6,
+    backgroundColor: colors.primary,
+    borderRadius: 6
+  },
+  buttonText: {
+    color: "#fff",
+    fontSize: 14,
+    fontWeight: "500"
+  },
+  searchInput: {
+    margin: 16,
+    marginBottom: 8,
+    padding: 12,
+    backgroundColor: colors.surface,
+    borderRadius: 8,
+    borderWidth: 1,
+    borderColor: colors.border,
+    fontSize: 14,
+    color: colors.text.primary
+  },
+  filters: {
+    paddingHorizontal: 16,
+    paddingBottom: 12,
+    maxHeight: 50
+  },
+  filterChip: {
+    paddingHorizontal: 12,
+    paddingVertical: 6,
+    borderRadius: 16,
+    marginRight: 8,
+    justifyContent: "center",
+    alignItems: "center"
+  },
+  filterText: {
+    fontSize: 12,
+    fontWeight: "500",
+    textAlign: "center",
+    textAlignVertical: "center"
+    // Android
+  },
+  eventList: {
+    flex: 1
+  },
+  eventItem: {
+    backgroundColor: colors.surface,
+    marginHorizontal: 16,
+    marginBottom: 8,
+    padding: 12,
+    borderRadius: 8,
+    borderWidth: 1,
+    borderColor: colors.border
+  },
+  eventHeader: {
+    flexDirection: "row",
+    justifyContent: "space-between",
+    alignItems: "center",
+    marginBottom: 8
+  },
+  categoryBadge: {
+    paddingHorizontal: 8,
+    paddingVertical: 4,
+    borderRadius: 4,
+    justifyContent: "center",
+    alignItems: "center"
+  },
+  categoryText: {
+    color: "#fff",
+    fontSize: 12,
+    fontWeight: "600",
+    textTransform: "uppercase",
+    textAlign: "center",
+    textAlignVertical: "center"
+    // Android specific
+  },
+  timestamp: {
+    fontSize: 12,
+    color: colors.text.secondary
+  },
+  eventSummary: {
+    fontSize: 14,
+    color: colors.text.secondary,
+    fontFamily: "monospace"
+  },
+  eventDetails: {
+    marginTop: 12,
+    paddingTop: 12,
+    borderTopWidth: 1,
+    borderTopColor: colors.border
+  },
+  detailsLabel: {
+    fontSize: 12,
+    fontWeight: "600",
+    color: colors.text.secondary,
+    marginTop: 8,
+    marginBottom: 4
+  },
+  detailsText: {
+    fontSize: 12,
+    color: colors.text.secondary,
+    fontFamily: "monospace"
+  },
+  emptyState: {
+    padding: 32,
+    alignItems: "center"
+  },
+  emptyText: {
+    fontSize: 14,
+    color: colors.text.tertiary
+  }
+});
+
+// src/viewer/Header.tsx
+var Header = ({ eventCount, onExport, onClear }) => {
+  return /* @__PURE__ */ React5__default.default.createElement(reactNative.View, { style: styles.header }, /* @__PURE__ */ React5__default.default.createElement(reactNative.Text, { style: styles.title }, "Event Log (", eventCount, ")"), /* @__PURE__ */ React5__default.default.createElement(reactNative.View, { style: styles.headerButtons }, /* @__PURE__ */ React5__default.default.createElement(reactNative.TouchableOpacity, { onPress: onExport, style: styles.button }, /* @__PURE__ */ React5__default.default.createElement(reactNative.Text, { style: styles.buttonText }, "Export")), /* @__PURE__ */ React5__default.default.createElement(reactNative.TouchableOpacity, { onPress: onClear, style: styles.button }, /* @__PURE__ */ React5__default.default.createElement(reactNative.Text, { style: styles.buttonText }, "Clear"))));
+};
+var SearchBar = ({ value, onChange }) => {
+  return /* @__PURE__ */ React5__default.default.createElement(
+    reactNative.TextInput,
+    {
+      style: styles.searchInput,
+      placeholder: "Search events...",
+      value,
+      onChangeText: onChange,
+      placeholderTextColor: colors.text.tertiary
+    }
+  );
+};
+
+// src/viewer/types.ts
+var CATEGORY_COLORS = {
+  screen: "#3b82f6",
+  action: "#10b981",
+  network: "#f59e0b",
+  error: "#ef4444",
+  log: "#6b7280"
+};
+var ALL_CATEGORIES = [
+  "screen",
+  "action",
+  "network",
+  "error",
+  "log"
+];
+var FilterChip = ({ category, selected, onToggle }) => {
+  return /* @__PURE__ */ React5__default.default.createElement(
+    reactNative.TouchableOpacity,
+    {
+      onPress: onToggle,
+      style: [
+        styles.filterChip,
+        {
+          backgroundColor: selected ? CATEGORY_COLORS[category] : colors.border
+        }
+      ]
+    },
+    /* @__PURE__ */ React5__default.default.createElement(
+      reactNative.Text,
+      {
+        style: [
+          styles.filterText,
+          { color: selected ? "#fff" : colors.text.secondary }
+        ]
+      },
+      category
+    )
+  );
+};
+
+// src/viewer/FilterBar.tsx
+var FilterBar = ({ selected, onToggle }) => {
+  return /* @__PURE__ */ React5__default.default.createElement(reactNative.ScrollView, { horizontal: true, style: styles.filters, showsHorizontalScrollIndicator: false }, ALL_CATEGORIES.map((category) => /* @__PURE__ */ React5__default.default.createElement(
+    FilterChip,
+    {
+      key: category,
+      category,
+      selected: selected.includes(category),
+      onToggle: () => onToggle(category)
+    }
+  )));
+};
+var EventItem = ({ event, expanded, onPress }) => {
+  return /* @__PURE__ */ React5__default.default.createElement(reactNative.TouchableOpacity, { onPress, style: styles.eventItem }, /* @__PURE__ */ React5__default.default.createElement(reactNative.View, { style: styles.eventHeader }, /* @__PURE__ */ React5__default.default.createElement(
+    reactNative.View,
+    {
+      style: [
+        styles.categoryBadge,
+        { backgroundColor: CATEGORY_COLORS[event.category] }
+      ]
+    },
+    /* @__PURE__ */ React5__default.default.createElement(reactNative.Text, { style: styles.categoryText }, event.category)
+  ), /* @__PURE__ */ React5__default.default.createElement(reactNative.Text, { style: styles.timestamp }, new Date(event.timestamp).toLocaleTimeString())), /* @__PURE__ */ React5__default.default.createElement(reactNative.Text, { style: styles.eventSummary, numberOfLines: expanded ? void 0 : 1 }, JSON.stringify(event.payload)), expanded && /* @__PURE__ */ React5__default.default.createElement(reactNative.View, { style: styles.eventDetails }, /* @__PURE__ */ React5__default.default.createElement(reactNative.Text, { style: styles.detailsLabel }, "Session:"), /* @__PURE__ */ React5__default.default.createElement(reactNative.Text, { style: styles.detailsText }, event.sessionId), /* @__PURE__ */ React5__default.default.createElement(reactNative.Text, { style: styles.detailsLabel }, "Sequence:"), /* @__PURE__ */ React5__default.default.createElement(reactNative.Text, { style: styles.detailsText }, event.seq), /* @__PURE__ */ React5__default.default.createElement(reactNative.Text, { style: styles.detailsLabel }, "Timezone:"), /* @__PURE__ */ React5__default.default.createElement(reactNative.Text, { style: styles.detailsText }, event.timezone), event.context && Object.keys(event.context).length > 0 && /* @__PURE__ */ React5__default.default.createElement(React5__default.default.Fragment, null, /* @__PURE__ */ React5__default.default.createElement(reactNative.Text, { style: styles.detailsLabel }, "Context:"), /* @__PURE__ */ React5__default.default.createElement(reactNative.Text, { style: styles.detailsText }, JSON.stringify(event.context, null, 2))), /* @__PURE__ */ React5__default.default.createElement(reactNative.Text, { style: styles.detailsLabel }, "Full Event:"), /* @__PURE__ */ React5__default.default.createElement(reactNative.Text, { style: styles.detailsText }, JSON.stringify(event, null, 2))));
+};
+
+// src/viewer/EventList.tsx
+var EventList = ({ events, onEventPress, expandedId }) => {
+  const renderItem = ({ item }) => /* @__PURE__ */ React5__default.default.createElement(
+    EventItem,
+    {
+      event: item,
+      expanded: expandedId === item.eventId,
+      onPress: () => onEventPress(item.eventId)
+    }
+  );
+  const keyExtractor = (item) => item.eventId;
+  const renderEmpty = () => /* @__PURE__ */ React5__default.default.createElement(reactNative.View, { style: styles.emptyState }, /* @__PURE__ */ React5__default.default.createElement(reactNative.Text, { style: styles.emptyText }, "No events"));
+  return /* @__PURE__ */ React5__default.default.createElement(
+    reactNative.FlatList,
+    {
+      data: events,
+      renderItem,
+      keyExtractor,
+      ListEmptyComponent: renderEmpty,
+      style: styles.eventList,
+      initialNumToRender: 20,
+      maxToRenderPerBatch: 10,
+      windowSize: 5
+    }
+  );
+};
+var useEvents = (eventLog2, maxEvents) => {
+  const [events, setEvents] = React5.useState([]);
+  const fetchEvents = React5.useCallback(() => {
+    const result = eventLog2.getEvents();
+    if (result.ok) {
+      setEvents(result.value.slice(-maxEvents));
+    }
+  }, [eventLog2, maxEvents]);
+  React5.useEffect(() => {
+    fetchEvents();
+  }, [fetchEvents]);
+  return { events, refetch: fetchEvents };
+};
+var useEventFilter = (events) => {
+  const [filter, setFilter] = React5.useState([]);
+  const [search, setSearch] = React5.useState("");
+  const toggleFilter = React5.useCallback((category) => {
+    setFilter(
+      (prev) => prev.includes(category) ? prev.filter((c) => c !== category) : [...prev, category]
+    );
+  }, []);
+  const filteredEvents = events.filter((event) => {
+    if (filter.length > 0 && !filter.includes(event.category)) {
+      return false;
+    }
+    if (search) {
+      const searchLower = search.toLowerCase();
+      const payloadStr = JSON.stringify(event.payload).toLowerCase();
+      return payloadStr.includes(searchLower);
+    }
+    return true;
+  });
+  return {
+    filter,
+    search,
+    setSearch,
+    toggleFilter,
+    filteredEvents
+  };
+};
+var useEventActions = (eventLog2, onClear) => {
+  const handleClear = React5.useCallback(async () => {
+    await eventLog2.clear();
+    if (onClear) {
+      onClear();
+    }
+  }, [eventLog2, onClear]);
+  const handleExport = React5.useCallback(async () => {
+    const result = await eventLog2.export({ mode: "full" });
+    if (result.ok) {
+      console.log("=== EXPORTED LOGS ===");
+      console.log(result.value);
+      console.log("=== END LOGS ===");
+    }
+  }, [eventLog2]);
+  return { handleClear, handleExport };
+};
+
+// src/instance.ts
+var eventLog = createEventLog();
+
+// src/viewer/EventLogViewer.tsx
+var EventLogViewer = ({
+  maxEvents = 100
+}) => {
+  const [expandedId, setExpandedId] = React5.useState(null);
+  const { events, refetch } = useEvents(eventLog, maxEvents);
+  const { filter, search, setSearch, toggleFilter, filteredEvents } = useEventFilter(events);
+  const { handleClear, handleExport } = useEventActions(eventLog, refetch);
+  const handleEventPress = (eventId) => {
+    setExpandedId(expandedId === eventId ? null : eventId);
+  };
+  return /* @__PURE__ */ React5__default.default.createElement(reactNative.View, { style: styles.container }, /* @__PURE__ */ React5__default.default.createElement(
+    Header,
+    {
+      eventCount: filteredEvents.length,
+      onExport: handleExport,
+      onClear: handleClear
+    }
+  ), /* @__PURE__ */ React5__default.default.createElement(SearchBar, { value: search, onChange: setSearch }), /* @__PURE__ */ React5__default.default.createElement(FilterBar, { selected: filter, onToggle: toggleFilter }), /* @__PURE__ */ React5__default.default.createElement(
+    EventList,
+    {
+      events: filteredEvents,
+      onEventPress: handleEventPress,
+      expandedId
+    }
+  ));
+};
+var EventLogErrorBoundary = class extends React5.Component {
+  constructor(props) {
+    super(props);
+    this.resetError = () => {
+      this.setState({ hasError: false, error: null });
+    };
+    this.state = { hasError: false, error: null };
+  }
+  static getDerivedStateFromError(error) {
+    return { hasError: true, error };
+  }
+  componentDidCatch(error, info) {
+    eventLog.error(error, {
+      origin: "react_error_boundary",
+      componentStack: info.componentStack
+    });
+    if (this.props.onError) {
+      this.props.onError(error, info);
+    }
+  }
+  render() {
+    if (this.state.hasError) {
+      if (this.props.fallback) {
+        return this.props.fallback;
+      }
+      return /* @__PURE__ */ React5__default.default.createElement(reactNative.View, { style: styles2.content }, /* @__PURE__ */ React5__default.default.createElement(reactNative.Text, { style: styles2.title }, "Something went wrong"), /* @__PURE__ */ React5__default.default.createElement(reactNative.Text, { style: styles2.message }, this.state.error?.message || "An unexpected error occurred."), /* @__PURE__ */ React5__default.default.createElement(reactNative.TouchableOpacity, { style: styles2.button, onPress: this.resetError }, /* @__PURE__ */ React5__default.default.createElement(reactNative.Text, { style: styles2.buttonText }, "Try Again")));
+    }
+    return this.props.children;
+  }
+};
+var styles2 = reactNative.StyleSheet.create({
+  container: {
+    flex: 1,
+    backgroundColor: "#fff",
+    justifyContent: "center",
+    alignItems: "center"
+  },
+  content: {
+    padding: 20,
+    flex: 1,
+    backgroundColor: "#fff",
+    justifyContent: "center",
+    alignItems: "center"
+  },
+  title: {
+    fontSize: 20,
+    fontWeight: "bold",
+    marginBottom: 10,
+    color: "#333"
+  },
+  message: {
+    fontSize: 14,
+    color: "#666",
+    textAlign: "center",
+    marginBottom: 20
+  },
+  button: {
+    backgroundColor: "#3b82f6",
+    paddingHorizontal: 20,
+    paddingVertical: 10,
+    borderRadius: 8
+  },
+  buttonText: {
+    color: "#fff",
+    fontWeight: "600"
+  }
+});
+
+exports.EventLogErrorBoundary = EventLogErrorBoundary;
+exports.EventLogViewer = EventLogViewer;
+exports.createEventLog = createEventLog;
+exports.eventLog = eventLog;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map