@fixprompt/react-native 0.0.1

package/dist/index.js

@@ -0,0 +1,791 @@
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+
+// node_modules/promise/setimmediate/core.js
+var require_core = __commonJS({
+  "node_modules/promise/setimmediate/core.js"(exports, module) {
+    "use strict";
+    function noop() {
+    }
+    var LAST_ERROR = null;
+    var IS_ERROR = {};
+    function getThen(obj) {
+      try {
+        return obj.then;
+      } catch (ex) {
+        LAST_ERROR = ex;
+        return IS_ERROR;
+      }
+    }
+    function tryCallOne(fn, a) {
+      try {
+        return fn(a);
+      } catch (ex) {
+        LAST_ERROR = ex;
+        return IS_ERROR;
+      }
+    }
+    function tryCallTwo(fn, a, b) {
+      try {
+        fn(a, b);
+      } catch (ex) {
+        LAST_ERROR = ex;
+        return IS_ERROR;
+      }
+    }
+    module.exports = Promise2;
+    function Promise2(fn) {
+      if (typeof this !== "object") {
+        throw new TypeError("Promises must be constructed via new");
+      }
+      if (typeof fn !== "function") {
+        throw new TypeError("Promise constructor's argument is not a function");
+      }
+      this._x = 0;
+      this._y = 0;
+      this._z = null;
+      this._A = null;
+      if (fn === noop) return;
+      doResolve(fn, this);
+    }
+    Promise2._B = null;
+    Promise2._C = null;
+    Promise2._D = noop;
+    Promise2.prototype.then = function(onFulfilled, onRejected) {
+      if (this.constructor !== Promise2) {
+        return safeThen(this, onFulfilled, onRejected);
+      }
+      var res = new Promise2(noop);
+      handle(this, new Handler(onFulfilled, onRejected, res));
+      return res;
+    };
+    function safeThen(self, onFulfilled, onRejected) {
+      return new self.constructor(function(resolve2, reject2) {
+        var res = new Promise2(noop);
+        res.then(resolve2, reject2);
+        handle(self, new Handler(onFulfilled, onRejected, res));
+      });
+    }
+    function handle(self, deferred) {
+      while (self._y === 3) {
+        self = self._z;
+      }
+      if (Promise2._B) {
+        Promise2._B(self);
+      }
+      if (self._y === 0) {
+        if (self._x === 0) {
+          self._x = 1;
+          self._A = deferred;
+          return;
+        }
+        if (self._x === 1) {
+          self._x = 2;
+          self._A = [self._A, deferred];
+          return;
+        }
+        self._A.push(deferred);
+        return;
+      }
+      handleResolved(self, deferred);
+    }
+    function handleResolved(self, deferred) {
+      setImmediate(function() {
+        var cb = self._y === 1 ? deferred.onFulfilled : deferred.onRejected;
+        if (cb === null) {
+          if (self._y === 1) {
+            resolve(deferred.promise, self._z);
+          } else {
+            reject(deferred.promise, self._z);
+          }
+          return;
+        }
+        var ret = tryCallOne(cb, self._z);
+        if (ret === IS_ERROR) {
+          reject(deferred.promise, LAST_ERROR);
+        } else {
+          resolve(deferred.promise, ret);
+        }
+      });
+    }
+    function resolve(self, newValue) {
+      if (newValue === self) {
+        return reject(
+          self,
+          new TypeError("A promise cannot be resolved with itself.")
+        );
+      }
+      if (newValue && (typeof newValue === "object" || typeof newValue === "function")) {
+        var then = getThen(newValue);
+        if (then === IS_ERROR) {
+          return reject(self, LAST_ERROR);
+        }
+        if (then === self.then && newValue instanceof Promise2) {
+          self._y = 3;
+          self._z = newValue;
+          finale(self);
+          return;
+        } else if (typeof then === "function") {
+          doResolve(then.bind(newValue), self);
+          return;
+        }
+      }
+      self._y = 1;
+      self._z = newValue;
+      finale(self);
+    }
+    function reject(self, newValue) {
+      self._y = 2;
+      self._z = newValue;
+      if (Promise2._C) {
+        Promise2._C(self, newValue);
+      }
+      finale(self);
+    }
+    function finale(self) {
+      if (self._x === 1) {
+        handle(self, self._A);
+        self._A = null;
+      }
+      if (self._x === 2) {
+        for (var i = 0; i < self._A.length; i++) {
+          handle(self, self._A[i]);
+        }
+        self._A = null;
+      }
+    }
+    function Handler(onFulfilled, onRejected, promise) {
+      this.onFulfilled = typeof onFulfilled === "function" ? onFulfilled : null;
+      this.onRejected = typeof onRejected === "function" ? onRejected : null;
+      this.promise = promise;
+    }
+    function doResolve(fn, promise) {
+      var done = false;
+      var res = tryCallTwo(fn, function(value) {
+        if (done) return;
+        done = true;
+        resolve(promise, value);
+      }, function(reason) {
+        if (done) return;
+        done = true;
+        reject(promise, reason);
+      });
+      if (!done && res === IS_ERROR) {
+        done = true;
+        reject(promise, LAST_ERROR);
+      }
+    }
+  }
+});
+
+// node_modules/promise/setimmediate/rejection-tracking.js
+var require_rejection_tracking = __commonJS({
+  "node_modules/promise/setimmediate/rejection-tracking.js"(exports) {
+    "use strict";
+    var Promise2 = require_core();
+    var DEFAULT_WHITELIST = [
+      ReferenceError,
+      TypeError,
+      RangeError
+    ];
+    var enabled = false;
+    exports.disable = disable;
+    function disable() {
+      enabled = false;
+      Promise2._B = null;
+      Promise2._C = null;
+    }
+    exports.enable = enable;
+    function enable(options) {
+      options = options || {};
+      if (enabled) disable();
+      enabled = true;
+      var id = 0;
+      var displayId = 0;
+      var rejections = {};
+      Promise2._B = function(promise) {
+        if (promise._y === 2 && // IS REJECTED
+        rejections[promise._E]) {
+          if (rejections[promise._E].logged) {
+            onHandled(promise._E);
+          } else {
+            clearTimeout(rejections[promise._E].timeout);
+          }
+          delete rejections[promise._E];
+        }
+      };
+      Promise2._C = function(promise, err) {
+        if (promise._x === 0) {
+          promise._E = id++;
+          rejections[promise._E] = {
+            displayId: null,
+            error: err,
+            timeout: setTimeout(
+              onUnhandled.bind(null, promise._E),
+              // For reference errors and type errors, this almost always
+              // means the programmer made a mistake, so log them after just
+              // 100ms
+              // otherwise, wait 2 seconds to see if they get handled
+              matchWhitelist(err, DEFAULT_WHITELIST) ? 100 : 2e3
+            ),
+            logged: false
+          };
+        }
+      };
+      function onUnhandled(id2) {
+        if (options.allRejections || matchWhitelist(
+          rejections[id2].error,
+          options.whitelist || DEFAULT_WHITELIST
+        )) {
+          rejections[id2].displayId = displayId++;
+          if (options.onUnhandled) {
+            rejections[id2].logged = true;
+            options.onUnhandled(
+              rejections[id2].displayId,
+              rejections[id2].error
+            );
+          } else {
+            rejections[id2].logged = true;
+            logError(
+              rejections[id2].displayId,
+              rejections[id2].error
+            );
+          }
+        }
+      }
+      function onHandled(id2) {
+        if (rejections[id2].logged) {
+          if (options.onHandled) {
+            options.onHandled(rejections[id2].displayId, rejections[id2].error);
+          } else if (!rejections[id2].onUnhandled) {
+            console.warn(
+              "Promise Rejection Handled (id: " + rejections[id2].displayId + "):"
+            );
+            console.warn(
+              '  This means you can ignore any previous messages of the form "Possible Unhandled Promise Rejection" with id ' + rejections[id2].displayId + "."
+            );
+          }
+        }
+      }
+    }
+    function logError(id, error) {
+      console.warn("Possible Unhandled Promise Rejection (id: " + id + "):");
+      var errStr = (error && (error.stack || error)) + "";
+      errStr.split("\n").forEach(function(line) {
+        console.warn("  " + line);
+      });
+    }
+    function matchWhitelist(error, list) {
+      return list.some(function(cls) {
+        return error instanceof cls;
+      });
+    }
+  }
+});
+
+// src/state.ts
+var STATE_KEY = "__fixprompt_rn_state__";
+function globalScope() {
+  if (typeof globalThis !== "undefined") return globalThis;
+  return {};
+}
+function getState() {
+  const g = globalScope();
+  if (!g[STATE_KEY]) {
+    g[STATE_KEY] = {
+      initialized: false,
+      config: null,
+      sessionId: null,
+      deviceId: null,
+      user: null,
+      cleanup: {}
+    };
+  }
+  return g[STATE_KEY];
+}
+
+// src/session.ts
+import AsyncStorage from "@react-native-async-storage/async-storage";
+var DEVICE_KEY = "@fixprompt/device_id";
+function uuid() {
+  if (typeof globalThis.crypto?.randomUUID === "function") {
+    return globalThis.crypto.randomUUID();
+  }
+  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);
+  });
+}
+function newSessionId() {
+  return uuid();
+}
+async function getDeviceId() {
+  try {
+    const SecureStore = await tryImport("expo-secure-store");
+    if (SecureStore) {
+      const existing = await SecureStore.getItemAsync("fixprompt_device_id");
+      if (existing) return existing;
+      const fresh = uuid();
+      await SecureStore.setItemAsync("fixprompt_device_id", fresh);
+      return fresh;
+    }
+  } catch {
+  }
+  try {
+    const existing = await AsyncStorage.getItem(DEVICE_KEY);
+    if (existing) return existing;
+    const fresh = uuid();
+    await AsyncStorage.setItem(DEVICE_KEY, fresh);
+    return fresh;
+  } catch {
+    return uuid();
+  }
+}
+async function tryImport(spec) {
+  try {
+    return __require(spec);
+  } catch {
+    return null;
+  }
+}
+
+// src/buffer.ts
+import AsyncStorage2 from "@react-native-async-storage/async-storage";
+var STORAGE_KEY = "@fixprompt/buffer";
+var MAX_BUFFER = 200;
+var MAX_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
+var OfflineBuffer = class {
+  constructor() {
+    this.items = [];
+    this.loaded = false;
+    this.persistTimer = null;
+  }
+  /** Load the persisted buffer once, on first use. */
+  async load() {
+    if (this.loaded) return;
+    this.loaded = true;
+    try {
+      const raw = await AsyncStorage2.getItem(STORAGE_KEY);
+      if (!raw) return;
+      const parsed = JSON.parse(raw);
+      const cutoff = Date.now() - MAX_AGE_MS;
+      this.items = parsed.filter((e) => e?.ts > cutoff).slice(-MAX_BUFFER);
+    } catch {
+      this.items = [];
+    }
+  }
+  push(payload) {
+    this.items.push({ ts: Date.now(), payload });
+    if (this.items.length > MAX_BUFFER) this.items.shift();
+    this.schedulePersist();
+  }
+  async drain() {
+    if (!this.loaded) await this.load();
+    const out = this.items.map((e) => e.payload);
+    this.items = [];
+    this.schedulePersist();
+    return out;
+  }
+  size() {
+    return this.items.length;
+  }
+  schedulePersist() {
+    if (this.persistTimer) return;
+    this.persistTimer = setTimeout(async () => {
+      this.persistTimer = null;
+      try {
+        await AsyncStorage2.setItem(STORAGE_KEY, JSON.stringify(this.items));
+      } catch {
+      }
+    }, 500);
+  }
+  /** Tests only. */
+  _resetForTests() {
+    this.items = [];
+    this.loaded = false;
+    if (this.persistTimer) {
+      clearTimeout(this.persistTimer);
+      this.persistTimer = null;
+    }
+  }
+};
+var offlineBuffer = new OfflineBuffer();
+
+// src/device.ts
+import { Platform } from "react-native";
+function getDeviceAttrs() {
+  return {
+    platform: String(Platform.OS),
+    os_version: String(Platform.Version ?? "unknown"),
+    rn_version: Platform.constants?.reactNativeVersion ? Object.values(Platform.constants.reactNativeVersion).join(".") : void 0
+  };
+}
+
+// src/version.ts
+var SDK_NAME = "@fixprompt/react-native";
+var SDK_VERSION = "0.0.1";
+
+// src/transport.ts
+var REQUEST_TIMEOUT_MS = 8e3;
+function sendEvent(config, payload) {
+  const state = getState();
+  const event = {
+    service: payload.service ?? config.service,
+    app: payload.app ?? config.app,
+    env: payload.env ?? config.env,
+    level: payload.level,
+    message: payload.message,
+    stack: payload.stack,
+    attrs: {
+      ...payload.attrs ?? {},
+      ...getDeviceAttrs(),
+      sdk: SDK_NAME,
+      sdk_version: SDK_VERSION,
+      release: config.release,
+      session_id: state.sessionId,
+      device_id: state.deviceId,
+      user_id: state.user?.id,
+      user_email: state.user?.email
+    },
+    synthetic: payload.synthetic
+  };
+  for (const k of Object.keys(event.attrs)) {
+    if (event.attrs[k] === void 0 || event.attrs[k] === null) {
+      delete event.attrs[k];
+    }
+  }
+  void postOrBuffer(config, event);
+}
+async function postOrBuffer(config, event) {
+  if (!await tryPost(
+    config,
+    event,
+    /* throwOnFail */
+    true
+  )) {
+    offlineBuffer.push(event);
+    return;
+  }
+  if (offlineBuffer.size() === 0) return;
+  const queued = await offlineBuffer.drain();
+  for (const buffered of queued) {
+    if (!await tryPost(config, buffered, true)) {
+      offlineBuffer.push(buffered);
+      for (let i = queued.indexOf(buffered) + 1; i < queued.length; i++) {
+        offlineBuffer.push(queued[i]);
+      }
+      return;
+    }
+  }
+}
+async function tryPost(config, event, throwOnFail) {
+  try {
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), REQUEST_TIMEOUT_MS);
+    try {
+      const res = await fetch(`${config.endpoint.replace(/\/$/, "")}/ingest/log`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-loghub-source": config.source,
+          "x-loghub-key": config.projectKey
+        },
+        body: JSON.stringify(event),
+        signal: ctrl.signal
+      });
+      if (res.status >= 400 && res.status < 500) {
+        if (config.debug) {
+          console.warn(`[fixprompt] ${res.status} from broker \u2014 dropping event`);
+        }
+        return true;
+      }
+      return res.ok;
+    } finally {
+      clearTimeout(timer);
+    }
+  } catch (err) {
+    if (config.debug) {
+      console.warn(`[fixprompt] transport error: ${err.message}`);
+    }
+    return false;
+  }
+}
+
+// src/handlers.ts
+function topStackFrame(stack) {
+  if (!stack) return "";
+  for (const raw of stack.split("\n")) {
+    const line = raw.trim();
+    if (!line) continue;
+    if (line.startsWith("Error")) continue;
+    if (/node_modules|@fixprompt/.test(line)) continue;
+    return line.slice(0, 200);
+  }
+  return stack.split("\n")[0]?.slice(0, 200) ?? "";
+}
+function installGlobalErrorHandler(config) {
+  const ErrorUtils = globalThis.ErrorUtils;
+  if (!ErrorUtils?.setGlobalHandler) {
+    return () => void 0;
+  }
+  const previous = ErrorUtils.getGlobalHandler?.();
+  const handler = (error, isFatal) => {
+    try {
+      sendEvent(config, {
+        level: isFatal ? "error" : "warn",
+        message: error?.message ?? "Uncaught error",
+        stack: typeof error?.stack === "string" ? error.stack : void 0,
+        attrs: {
+          kind: "rn.globalError",
+          severity: isFatal ? "critical" : "error",
+          error_name: error?.name,
+          top_frame: topStackFrame(error?.stack),
+          fatal: !!isFatal
+        }
+      });
+    } catch {
+    }
+    previous?.(error, isFatal);
+  };
+  ErrorUtils.setGlobalHandler(handler);
+  return () => {
+    if (previous) ErrorUtils.setGlobalHandler(previous);
+  };
+}
+function installRejectionHandler(config) {
+  let tracking;
+  try {
+    tracking = require_rejection_tracking();
+  } catch {
+    return () => void 0;
+  }
+  tracking.enable({
+    allRejections: true,
+    onUnhandled: (id, error) => {
+      try {
+        const isErr = error instanceof Error;
+        sendEvent(config, {
+          level: "error",
+          message: isErr ? error.message : safeJson(error),
+          stack: isErr && typeof error.stack === "string" ? error.stack : void 0,
+          attrs: {
+            kind: "rn.unhandledrejection",
+            severity: "error",
+            error_name: isErr ? error.name : typeof error,
+            top_frame: isErr ? topStackFrame(error.stack) : ""
+          }
+        });
+      } catch {
+      }
+    },
+    onHandled: () => void 0
+  });
+  return () => {
+    try {
+      tracking.disable();
+    } catch {
+    }
+  };
+}
+function safeJson(v) {
+  try {
+    return JSON.stringify(v);
+  } catch {
+    return String(v);
+  }
+}
+
+// src/console.ts
+function shouldCapture(args, patterns) {
+  if (patterns.length === 0) return true;
+  const first = typeof args[0] === "string" ? args[0] : "";
+  return patterns.some((re) => re.test(first));
+}
+function stringify(args) {
+  const errArg = args.find((a) => a instanceof Error);
+  const message = args.map((a) => {
+    if (a instanceof Error) return a.message;
+    if (typeof a === "string") return a;
+    try {
+      return JSON.stringify(a);
+    } catch {
+      return String(a);
+    }
+  }).join(" ").slice(0, 4e3);
+  return {
+    message,
+    stack: errArg && typeof errArg.stack === "string" ? errArg.stack : void 0
+  };
+}
+function patchConsoleError(config) {
+  const original = console.error.bind(console);
+  console.error = (...args) => {
+    try {
+      if (shouldCapture(args, config.captureTags)) {
+        const { message, stack } = stringify(args);
+        sendEvent(config, {
+          level: "warn",
+          message,
+          stack,
+          attrs: {
+            kind: "console.error",
+            severity: "warning"
+          }
+        });
+      }
+    } catch {
+    }
+    return original(...args);
+  };
+  return () => {
+    console.error = original;
+  };
+}
+function patchConsoleWarn(config) {
+  const original = console.warn.bind(console);
+  console.warn = (...args) => {
+    try {
+      if (shouldCapture(args, config.captureTags)) {
+        const { message, stack } = stringify(args);
+        sendEvent(config, {
+          level: "warn",
+          message,
+          stack,
+          attrs: {
+            kind: "console.warn",
+            severity: "warning"
+          }
+        });
+      }
+    } catch {
+    }
+    return original(...args);
+  };
+  return () => {
+    console.warn = original;
+  };
+}
+
+// src/init.ts
+var DEFAULT_ENDPOINT = "https://geosloghub-production.up.railway.app";
+function resolveConfig(opts) {
+  if (!opts?.projectKey) throw new Error("initFixPrompt: projectKey is required");
+  if (!opts?.source) throw new Error("initFixPrompt: source is required");
+  if (!opts?.service) throw new Error("initFixPrompt: service is required");
+  if (!opts?.app) throw new Error("initFixPrompt: app is required");
+  return {
+    projectKey: opts.projectKey,
+    source: opts.source,
+    endpoint: (opts.endpoint ?? DEFAULT_ENDPOINT).replace(/\/$/, ""),
+    service: opts.service,
+    app: opts.app,
+    env: opts.env ?? "prod",
+    release: opts.release ?? null,
+    captureTags: opts.captureTags ?? [],
+    patchConsoleWarn: opts.patchConsoleWarn ?? false,
+    patchConsoleError: opts.patchConsoleError ?? true,
+    debug: opts.debug ?? false
+  };
+}
+function initFixPrompt(opts) {
+  const state = getState();
+  if (state.initialized) {
+    if (opts?.debug) {
+      console.warn("[fixprompt] already initialized \u2014 call ignored");
+    }
+    return;
+  }
+  const config = resolveConfig(opts);
+  state.config = config;
+  state.sessionId = newSessionId();
+  state.cleanup.removeErrorHandler = installGlobalErrorHandler(config);
+  state.cleanup.removeRejectionHandler = installRejectionHandler(config);
+  if (config.patchConsoleError) {
+    state.cleanup.restoreConsoleError = patchConsoleError(config);
+  }
+  if (config.patchConsoleWarn) {
+    state.cleanup.restoreConsoleWarn = patchConsoleWarn(config);
+  }
+  state.initialized = true;
+  void (async () => {
+    try {
+      state.deviceId = await getDeviceId();
+      await offlineBuffer.load();
+      if (offlineBuffer.size() > 0) {
+        const items = await offlineBuffer.drain();
+        for (const ev of items) {
+          offlineBuffer.push(ev);
+        }
+        sendEvent(config, {
+          level: "debug",
+          message: "[fixprompt] resumed from offline buffer",
+          attrs: { kind: "sdk.startup", buffered: items.length }
+        });
+      }
+    } catch (err) {
+      if (config.debug) {
+        console.warn(`[fixprompt] init async setup failed: ${err.message}`);
+      }
+    }
+  })();
+  if (config.debug) {
+    console.log("[fixprompt] initialized", {
+      endpoint: config.endpoint,
+      service: config.service,
+      env: config.env,
+      session_id: state.sessionId
+    });
+  }
+}
+function captureException(err, options = {}) {
+  const state = getState();
+  if (!state.initialized || !state.config) return;
+  const isErr = err instanceof Error;
+  sendEvent(state.config, {
+    level: "error",
+    message: isErr ? err.message : String(err),
+    stack: isErr && typeof err.stack === "string" ? err.stack : void 0,
+    attrs: {
+      kind: "captureException",
+      severity: "error",
+      error_name: isErr ? err.name : typeof err,
+      ...options.attrs ?? {}
+    },
+    synthetic: options.synthetic === true
+  });
+}
+function setUser(user) {
+  const state = getState();
+  state.user = user;
+}
+function _resetForTests() {
+  const state = getState();
+  state.cleanup.removeErrorHandler?.();
+  state.cleanup.removeRejectionHandler?.();
+  state.cleanup.restoreConsoleError?.();
+  state.cleanup.restoreConsoleWarn?.();
+  state.initialized = false;
+  state.config = null;
+  state.sessionId = null;
+  state.deviceId = null;
+  state.user = null;
+  state.cleanup = {};
+}
+export {
+  SDK_NAME,
+  SDK_VERSION,
+  _resetForTests,
+  captureException,
+  initFixPrompt,
+  setUser
+};
+//# sourceMappingURL=index.js.map