@pulseboard/react-native 0.1.0

package/dist/index.js

@@ -0,0 +1,741 @@
+'use strict';
+
+var reactNative = require('react-native');
+
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __commonJS = (cb, mod) => function __require() {
+  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$1, module) {
+    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$1) {
+    var Promise2 = require_core();
+    var DEFAULT_WHITELIST = [
+      ReferenceError,
+      TypeError,
+      RangeError
+    ];
+    var enabled = false;
+    exports$1.disable = disable;
+    function disable() {
+      enabled = false;
+      Promise2._B = null;
+      Promise2._C = null;
+    }
+    exports$1.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/client.ts
+var PulseBoardClient = class {
+  constructor(host, debug = false) {
+    this.host = host.replace(/\/$/, "");
+    this.debug = debug;
+  }
+  // ─── Event Ingest ─────────────────────────────────────────────────
+  async send(event) {
+    try {
+      const response = await fetch(`${this.host}/ingest`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(event)
+      });
+      if (!response.ok) {
+        this.log(
+          `Failed to send event: ${response.status} ${response.statusText}`
+        );
+        return false;
+      }
+      this.log(`Event sent: ${event.type} \u2014 ${event.name}`);
+      return true;
+    } catch (err) {
+      this.log(`Network error sending event: ${err}`);
+      return false;
+    }
+  }
+  async sendBatch(events) {
+    const chunks = this.chunk(events, 5);
+    for (const chunk of chunks) {
+      await Promise.all(chunk.map((e) => this.send(e)));
+    }
+    return true;
+  }
+  // ─── Analytics Ingest ─────────────────────────────────────────────
+  async sendAnalytics(type, payload) {
+    try {
+      const response = await fetch(`${this.host}/analytics/${type}`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(payload)
+      });
+      if (!response.ok) {
+        this.log(
+          `Failed to send analytics: ${response.status} ${response.statusText}`
+        );
+        return false;
+      }
+      this.log(`Analytics sent: ${type}`);
+      return true;
+    } catch (err) {
+      this.log(`Network error sending analytics: ${err}`);
+      return false;
+    }
+  }
+  // ─── Private ──────────────────────────────────────────────────────
+  chunk(arr, size) {
+    return Array.from(
+      { length: Math.ceil(arr.length / size) },
+      (_, i) => arr.slice(i * size, i * size + size)
+    );
+  }
+  log(message) {
+    if (this.debug) {
+      console.log(`[PulseBoard] ${message}`);
+    }
+  }
+};
+
+// src/queue.ts
+var EventQueue = class {
+  constructor(maxSize = 100) {
+    this.queue = [];
+    this.maxSize = maxSize;
+  }
+  enqueue(event) {
+    if (this.queue.length >= this.maxSize) {
+      this.queue.shift();
+    }
+    this.queue.push(event);
+  }
+  dequeue(count) {
+    return this.queue.splice(0, count);
+  }
+  get size() {
+    return this.queue.length;
+  }
+  get isEmpty() {
+    return this.queue.length === 0;
+  }
+  clear() {
+    this.queue = [];
+  }
+};
+
+// src/auto-capture.ts
+var AutoCapture = class {
+  constructor(handler) {
+    this.attached = false;
+    this.previousHandler = null;
+    this.handler = handler;
+  }
+  attach() {
+    if (this.attached) return;
+    this.previousHandler = ErrorUtils.getGlobalHandler();
+    ErrorUtils.setGlobalHandler((error, isFatal) => {
+      this.handler("uncaughtException", error, { isFatal: isFatal ?? false });
+      if (this.previousHandler) {
+        this.previousHandler(error, isFatal);
+      }
+    });
+    const tracking = require_rejection_tracking();
+    tracking.enable({
+      allRejections: true,
+      onUnhandled: (_id, error) => {
+        const err = error instanceof Error ? error : new Error(String(error));
+        this.handler("unhandledRejection", err, { fatal: false });
+      }
+    });
+    this.attached = true;
+  }
+  detach() {
+    if (!this.attached) return;
+    if (this.previousHandler) {
+      ErrorUtils.setGlobalHandler(this.previousHandler);
+      this.previousHandler = null;
+    }
+    this.attached = false;
+  }
+};
+var NativePulseBoardDevice_default = reactNative.TurboModuleRegistry.getEnforcing("PulseBoardDevice");
+var NativePulseBoardNetwork_default = reactNative.TurboModuleRegistry.getEnforcing("PulseBoardNetwork");
+
+// src/context.ts
+function generateSessionId() {
+  const timestamp = Date.now().toString(36);
+  const random = Math.random().toString(36).substring(2, 10);
+  return `${timestamp}-${random}`;
+}
+function mapNetworkType(type) {
+  switch (type) {
+    case "wifi":
+      return "wifi";
+    case "cellular":
+      return "cellular";
+    case "offline":
+      return "offline";
+    default:
+      return "unknown";
+  }
+}
+function getTimezone() {
+  try {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone;
+  } catch {
+    return "unknown";
+  }
+}
+function getLanguage() {
+  try {
+    return reactNative.I18nManager.getConstants?.()?.localeIdentifier?.replace("_", "-") ?? Intl.DateTimeFormat().resolvedOptions().locale ?? "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+var ContextCollector = class {
+  constructor(appContext = {}) {
+    this.userContext = {};
+    this.appContext = appContext;
+    this.sessionContext = {
+      sessionId: generateSessionId(),
+      startedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  identify(user) {
+    this.userContext = { ...this.userContext, ...user };
+  }
+  clearUser() {
+    this.userContext = {};
+  }
+  async collect() {
+    const { width, height } = reactNative.Dimensions.get("window");
+    let deviceInfo = null;
+    let networkInfo = null;
+    try {
+      if (NativePulseBoardDevice_default) {
+        deviceInfo = await NativePulseBoardDevice_default.getDeviceInfo();
+      }
+    } catch (e) {
+      console.warn("[PulseBoard] Failed to collect device info:", e);
+    }
+    try {
+      if (NativePulseBoardNetwork_default) {
+        networkInfo = await NativePulseBoardNetwork_default.getNetworkInfo();
+      }
+    } catch (e) {
+      console.warn("[PulseBoard] Failed to collect network info:", e);
+    }
+    const device = {
+      platform: reactNative.Platform.OS === "ios" ? "ios" : "android",
+      os: deviceInfo?.os ?? (reactNative.Platform.OS === "ios" ? "iOS" : "Android"),
+      osVersion: deviceInfo?.osVersion ?? reactNative.Platform.Version?.toString() ?? "unknown",
+      model: deviceInfo?.model ?? "unknown",
+      manufacturer: deviceInfo?.manufacturer ?? "unknown",
+      brand: deviceInfo?.brand ?? "unknown",
+      isTablet: deviceInfo?.isTablet ?? false,
+      appVersion: this.appContext.appVersion ?? deviceInfo?.appVersion ?? "unknown",
+      buildNumber: this.appContext.buildNumber ?? deviceInfo?.buildNumber ?? "unknown",
+      bundleId: deviceInfo?.bundleId ?? "unknown",
+      screenWidth: deviceInfo?.screenWidth ?? width,
+      screenHeight: deviceInfo?.screenHeight ?? height,
+      fontScale: reactNative.Dimensions.get("window").fontScale ?? 1,
+      isEmulator: deviceInfo?.isEmulator ?? false,
+      language: getLanguage(),
+      timezone: getTimezone()
+    };
+    const network = {
+      type: mapNetworkType(networkInfo?.type ?? "unknown"),
+      isConnected: networkInfo?.isConnected ?? false,
+      isWifiEnabled: networkInfo?.isWifiEnabled ?? false,
+      carrier: networkInfo?.carrier ?? "unknown",
+      ipAddress: networkInfo?.ipAddress ?? "unknown"
+    };
+    return {
+      app: this.appContext,
+      device,
+      network,
+      session: this.sessionContext,
+      user: this.userContext
+    };
+  }
+};
+
+// src/index.ts
+var PulseBoardSDK = class {
+  constructor() {
+    this.config = null;
+    this.client = null;
+    this.queue = null;
+    this.autoCapture = null;
+    this.contextCollector = null;
+    this.flushTimer = null;
+    this.initialized = false;
+  }
+  // ─── Public API ───────────────────────────────────────────────────
+  init(config) {
+    if (this.initialized) {
+      this.log("SDK already initialized \u2014 skipping");
+      return;
+    }
+    this.config = {
+      autoCapture: true,
+      debug: false,
+      flushInterval: 5e3,
+      maxQueueSize: 100,
+      ...config
+    };
+    this.client = new PulseBoardClient(this.config.host, this.config.debug);
+    this.queue = new EventQueue(this.config.maxQueueSize);
+    this.contextCollector = new ContextCollector(this.config.app ?? {});
+    this.flushTimer = setInterval(
+      () => this.flush(),
+      this.config.flushInterval
+    );
+    if (this.config.autoCapture) {
+      this.autoCapture = new AutoCapture((name, error, context) => {
+        this.captureError(error, { payload: context });
+      });
+      this.autoCapture.attach();
+    }
+    this.initialized = true;
+    this.log(`Initialized \u2014 host: ${this.config.host}`);
+  }
+  async getContext() {
+    this.assertInitialized("getContext");
+    return this.contextCollector.collect();
+  }
+  identify(user) {
+    this.assertInitialized("identify");
+    this.contextCollector.identify(user);
+    this.log(`User identified: ${JSON.stringify(user)}`);
+  }
+  clearUser() {
+    this.assertInitialized("clearUser");
+    this.contextCollector.clearUser();
+  }
+  track(name, options = {}) {
+    this.assertInitialized("track");
+    this.buildAndEnqueue(
+      "event",
+      name,
+      options.payload ?? {},
+      options.timestamp
+    );
+  }
+  metric(name, value, options = {}) {
+    this.assertInitialized("metric");
+    this.buildAndEnqueue(
+      "metric",
+      name,
+      { value, ...options.payload },
+      options.timestamp
+    );
+  }
+  captureError(error, options = {}) {
+    this.assertInitialized("captureError");
+    this.buildAndEnqueue("error", error.name ?? "UnknownError", {
+      message: error.message,
+      stack: error.stack,
+      ...options.payload
+    });
+  }
+  // ─── Analytics API ────────────────────────────────────────────────
+  startSession() {
+    this.assertInitialized("startSession");
+    this.contextCollector.collect().then((context) => {
+      this.client.sendAnalytics("session", {
+        apiKey: this.config.apiKey,
+        sessionId: context.session.sessionId,
+        startedAt: context.session.startedAt,
+        context
+      });
+      this.log(`Session started: ${context.session.sessionId}`);
+    }).catch((err) => {
+      this.log(`Failed to start session: ${err}`);
+    });
+  }
+  endSession(duration) {
+    this.assertInitialized("endSession");
+    this.contextCollector.collect().then((context) => {
+      this.client.sendAnalytics("session", {
+        apiKey: this.config.apiKey,
+        sessionId: context.session.sessionId,
+        startedAt: context.session.startedAt,
+        endedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        duration,
+        context
+      });
+      this.flush();
+      this.log(`Session ended: ${context.session.sessionId}`);
+    }).catch((err) => {
+      this.log(`Failed to end session: ${err}`);
+    });
+  }
+  trackScreen(screenName, loadTime) {
+    this.assertInitialized("trackScreen");
+    this.contextCollector.collect().then((context) => {
+      this.client.sendAnalytics("screen-view", {
+        apiKey: this.config.apiKey,
+        screenName,
+        loadTime,
+        sessionId: context.session.sessionId,
+        context
+      });
+      this.log(`Screen tracked: ${screenName}`);
+    }).catch((err) => {
+      this.log(`Failed to track screen: ${err}`);
+    });
+  }
+  trackApiCall(endpoint, httpMethod, statusCode, duration, payloadSize) {
+    this.assertInitialized("trackApiCall");
+    this.contextCollector.collect().then((context) => {
+      this.client.sendAnalytics("api-call", {
+        apiKey: this.config.apiKey,
+        endpoint,
+        httpMethod,
+        statusCode,
+        duration,
+        payloadSize,
+        sessionId: context.session.sessionId,
+        context
+      });
+      this.log(`API call tracked: ${httpMethod} ${endpoint} ${statusCode}`);
+    }).catch((err) => {
+      this.log(`Failed to track API call: ${err}`);
+    });
+  }
+  trackCrash(error, isFatal = false) {
+    this.assertInitialized("trackCrash");
+    this.contextCollector.collect().then((context) => {
+      this.client.sendAnalytics("crash", {
+        apiKey: this.config.apiKey,
+        errorName: error.name,
+        errorMessage: error.message,
+        stackTrace: error.stack ?? "",
+        isFatal,
+        sessionId: context.session.sessionId,
+        context
+      });
+      this.log(`Crash tracked: ${error.name} \u2014 fatal: ${isFatal}`);
+    }).catch((err) => {
+      this.log(`Failed to track crash: ${err}`);
+    });
+  }
+  // ─── Flush & Destroy ─────────────────────────────────────────────
+  async flush() {
+    if (!this.queue || this.queue.isEmpty) return;
+    if (!this.client) return;
+    const events = this.queue.dequeue(10);
+    this.log(`Flushing ${events.length} event(s)`);
+    await this.client.sendBatch(events);
+  }
+  destroy() {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+    this.autoCapture?.detach();
+    this.queue?.clear();
+    this.initialized = false;
+    this.config = null;
+    this.client = null;
+    this.queue = null;
+    this.contextCollector = null;
+    this.log("SDK destroyed");
+  }
+  // ─── Private ─────────────────────────────────────────────────────
+  buildAndEnqueue(type, name, payload, timestamp) {
+    this.contextCollector.collect().then((context) => {
+      const event = {
+        apiKey: this.config.apiKey,
+        type,
+        name,
+        payload,
+        timestamp: timestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
+        context
+      };
+      this.queue.enqueue(event);
+      this.log(`Queued: ${type} \u2014 ${name}`);
+      if (type === "error") {
+        this.flush();
+      }
+    }).catch((err) => {
+      this.log(`Failed to collect context: ${err}`);
+    });
+  }
+  assertInitialized(method) {
+    if (!this.initialized) {
+      throw new Error(`PulseBoard.${method}() called before PulseBoard.init()`);
+    }
+  }
+  log(message) {
+    if (this.config?.debug) {
+      console.log(`[PulseBoard] ${message}`);
+    }
+  }
+};
+var PulseBoard = new PulseBoardSDK();
+
+exports.PulseBoard = PulseBoard;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map