@logg/signals 0.1.0

package/dist/index.js

@@ -0,0 +1,514 @@
+"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/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AsyncStorageAdapter: () => AsyncStorageAdapter,
+  EventQueue: () => EventQueue,
+  LocalStorageAdapter: () => LocalStorageAdapter,
+  MemoryStorageAdapter: () => MemoryStorageAdapter,
+  Signals: () => Signals,
+  getDefaultStorageAdapter: () => getDefaultStorageAdapter
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/utils/helpers.ts
+function uuid() {
+  if (typeof crypto !== "undefined" && crypto.randomUUID) {
+    return 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 getTimestamp() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function retry(fn, options) {
+  const { maxRetries, initialDelay, onRetry } = options;
+  let lastError;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      if (attempt < maxRetries) {
+        const delay = initialDelay * Math.pow(2, attempt);
+        onRetry?.(attempt + 1, lastError);
+        await sleep(delay);
+      }
+    }
+  }
+  throw lastError;
+}
+
+// src/EventQueue.ts
+var STORAGE_KEY = "session_signals_queue";
+var EventQueue = class {
+  constructor(storage, sessionId) {
+    this.queue = [];
+    this.storage = storage;
+    this.sessionId = sessionId;
+  }
+  /**
+   * Initialize queue by loading persisted events
+   */
+  async init() {
+    try {
+      const stored = await this.storage.getItem(STORAGE_KEY);
+      if (stored) {
+        const parsed = JSON.parse(stored);
+        this.queue = Array.isArray(parsed) ? parsed : [];
+      }
+    } catch (error) {
+      console.warn("Failed to load persisted events:", error);
+      this.queue = [];
+    }
+  }
+  /**
+   * Add event to queue
+   */
+  async add(eventData) {
+    const event = {
+      event_id: uuid(),
+      timestamp: getTimestamp(),
+      session_id: this.sessionId,
+      ...eventData
+    };
+    this.queue.push({
+      event,
+      timestamp: Date.now()
+    });
+    await this.persist();
+    return event;
+  }
+  /**
+   * Get all events in queue
+   */
+  getAll() {
+    return this.queue.map((item) => item.event);
+  }
+  /**
+   * Get events up to a certain size
+   */
+  getBatch(size) {
+    return this.queue.slice(0, size).map((item) => item.event);
+  }
+  /**
+   * Remove events from queue
+   */
+  async remove(count) {
+    this.queue.splice(0, count);
+    await this.persist();
+  }
+  /**
+   * Clear all events from queue
+   */
+  async clear() {
+    this.queue = [];
+    await this.persist();
+  }
+  /**
+   * Get queue size
+   */
+  size() {
+    return this.queue.length;
+  }
+  /**
+   * Check if queue is empty
+   */
+  isEmpty() {
+    return this.queue.length === 0;
+  }
+  /**
+   * Get oldest event timestamp
+   */
+  getOldestTimestamp() {
+    if (this.queue.length === 0) return null;
+    return this.queue[0]?.timestamp ?? null;
+  }
+  /**
+   * Persist queue to storage
+   */
+  async persist() {
+    try {
+      await this.storage.setItem(STORAGE_KEY, JSON.stringify(this.queue));
+    } catch (error) {
+      console.warn("Failed to persist events:", error);
+    }
+  }
+};
+
+// src/storage/LocalStorageAdapter.ts
+var LocalStorageAdapter = class {
+  async getItem(key) {
+    try {
+      return localStorage.getItem(key);
+    } catch (error) {
+      console.warn("LocalStorage not available:", error);
+      return null;
+    }
+  }
+  async setItem(key, value) {
+    try {
+      localStorage.setItem(key, value);
+    } catch (error) {
+      console.warn("LocalStorage setItem failed:", error);
+    }
+  }
+  async removeItem(key) {
+    try {
+      localStorage.removeItem(key);
+    } catch (error) {
+      console.warn("LocalStorage removeItem failed:", error);
+    }
+  }
+  /**
+   * Check if localStorage is available
+   */
+  static isAvailable() {
+    try {
+      const test = "__localStorage_test__";
+      localStorage.setItem(test, test);
+      localStorage.removeItem(test);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/storage/AsyncStorageAdapter.ts
+var AsyncStorageAdapter = class {
+  constructor() {
+    try {
+      this.asyncStorage = require("@react-native-async-storage/async-storage").default;
+    } catch (error) {
+      throw new Error(
+        "AsyncStorage not found. Please install @react-native-async-storage/async-storage"
+      );
+    }
+  }
+  async getItem(key) {
+    try {
+      return await this.asyncStorage.getItem(key);
+    } catch (error) {
+      console.warn("AsyncStorage getItem failed:", error);
+      return null;
+    }
+  }
+  async setItem(key, value) {
+    try {
+      await this.asyncStorage.setItem(key, value);
+    } catch (error) {
+      console.warn("AsyncStorage setItem failed:", error);
+    }
+  }
+  async removeItem(key) {
+    try {
+      await this.asyncStorage.removeItem(key);
+    } catch (error) {
+      console.warn("AsyncStorage removeItem failed:", error);
+    }
+  }
+  /**
+   * Check if AsyncStorage is available
+   */
+  static isAvailable() {
+    try {
+      require("@react-native-async-storage/async-storage");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/storage/MemoryStorageAdapter.ts
+var MemoryStorageAdapter = class {
+  constructor() {
+    this.storage = /* @__PURE__ */ new Map();
+  }
+  async getItem(key) {
+    return this.storage.get(key) ?? null;
+  }
+  async setItem(key, value) {
+    this.storage.set(key, value);
+  }
+  async removeItem(key) {
+    this.storage.delete(key);
+  }
+};
+
+// src/storage/index.ts
+function getDefaultStorageAdapter() {
+  if (LocalStorageAdapter.isAvailable()) {
+    return new LocalStorageAdapter();
+  }
+  if (AsyncStorageAdapter.isAvailable()) {
+    return new AsyncStorageAdapter();
+  }
+  return new MemoryStorageAdapter();
+}
+
+// src/utils/metadata.ts
+function detectClientType() {
+  if (typeof navigator !== "undefined" && navigator.product === "ReactNative") {
+    return "react-native";
+  }
+  if (typeof window !== "undefined" && typeof document !== "undefined") {
+    return "web";
+  }
+  return "node";
+}
+function getUserAgent() {
+  if (typeof navigator !== "undefined") {
+    return navigator.userAgent;
+  }
+  return void 0;
+}
+function getScreenDimensions() {
+  if (typeof window !== "undefined" && window.screen) {
+    return {
+      width: window.screen.width,
+      height: window.screen.height
+    };
+  }
+  try {
+    const { Dimensions } = require("react-native");
+    const { width, height } = Dimensions.get("window");
+    return { width, height };
+  } catch {
+    return void 0;
+  }
+}
+function getLocale() {
+  if (typeof navigator !== "undefined") {
+    return navigator.language;
+  }
+  return void 0;
+}
+function getTimezone() {
+  try {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone;
+  } catch {
+    return void 0;
+  }
+}
+function collectMetadata(version) {
+  const clientType = detectClientType();
+  const metadata = {
+    type: clientType,
+    version
+  };
+  if (clientType === "web" || clientType === "react-native") {
+    metadata.user_agent = getUserAgent();
+    metadata.screen = getScreenDimensions();
+    metadata.locale = getLocale();
+    metadata.timezone = getTimezone();
+  }
+  return metadata;
+}
+
+// src/Signals.ts
+var VERSION = "0.1.0";
+var DEFAULT_BATCH_SIZE = 10;
+var DEFAULT_BATCH_INTERVAL = 5e3;
+var DEFAULT_MAX_RETRIES = 3;
+var DEFAULT_RETRY_DELAY = 1e3;
+var Signals = class {
+  constructor(config) {
+    this.flushTimer = null;
+    this.isDestroyed = false;
+    this.isFlushing = false;
+    if (!config.apiKey) {
+      throw new Error("Signals: apiKey is required");
+    }
+    if (!config.endpoint) {
+      throw new Error("Signals: endpoint is required");
+    }
+    this.config = {
+      apiKey: config.apiKey,
+      endpoint: config.endpoint,
+      batchSize: config.batchSize ?? DEFAULT_BATCH_SIZE,
+      batchInterval: config.batchInterval ?? DEFAULT_BATCH_INTERVAL,
+      maxRetries: config.maxRetries ?? DEFAULT_MAX_RETRIES,
+      retryDelay: config.retryDelay ?? DEFAULT_RETRY_DELAY,
+      debug: config.debug ?? false,
+      storage: config.storage ?? getDefaultStorageAdapter(),
+      sessionId: config.sessionId ?? uuid()
+    };
+    this.queue = new EventQueue(this.config.storage, this.config.sessionId);
+    this.init();
+  }
+  /**
+   * Initialize client
+   */
+  async init() {
+    await this.queue.init();
+    this.log("Signals initialized", {
+      sessionId: this.config.sessionId,
+      queueSize: this.queue.size()
+    });
+    this.startFlushTimer();
+    if (!this.queue.isEmpty()) {
+      await this.flush();
+    }
+  }
+  /**
+   * Track an event
+   */
+  async event(eventData) {
+    if (this.isDestroyed) {
+      throw new Error("Signals instance has been destroyed");
+    }
+    const event = await this.queue.add(eventData);
+    this.log("Event tracked", event);
+    if (this.queue.size() >= this.config.batchSize) {
+      await this.flush();
+    }
+  }
+  /**
+   * Manually flush events
+   */
+  async flush() {
+    if (this.isDestroyed || this.queue.isEmpty() || this.isFlushing) {
+      return;
+    }
+    this.isFlushing = true;
+    const events = this.queue.getBatch(this.config.batchSize);
+    if (events.length === 0) {
+      this.isFlushing = false;
+      return;
+    }
+    this.log(`Flushing ${events.length} events`);
+    const batch = {
+      api_key: this.config.apiKey,
+      batch_id: uuid(),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      metadata: collectMetadata(VERSION),
+      events
+    };
+    try {
+      await this.sendBatch(batch);
+      await this.queue.remove(events.length);
+      this.log("Batch sent successfully");
+    } catch (error) {
+      this.log("Failed to send batch", error);
+    } finally {
+      this.isFlushing = false;
+    }
+  }
+  /**
+   * Send batch to backend with retry logic
+   */
+  async sendBatch(batch) {
+    await retry(
+      async () => {
+        const response = await fetch(this.config.endpoint, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "Authorization": `Bearer ${this.config.apiKey}`
+          },
+          body: JSON.stringify(batch)
+        });
+        if (!response.ok) {
+          throw new Error(
+            `HTTP ${response.status}: ${response.statusText}`
+          );
+        }
+      },
+      {
+        maxRetries: this.config.maxRetries,
+        initialDelay: this.config.retryDelay,
+        onRetry: (attempt, error) => {
+          this.log(`Retry attempt ${attempt}`, error);
+        }
+      }
+    );
+  }
+  /**
+   * Start periodic flush timer
+   */
+  startFlushTimer() {
+    this.stopFlushTimer();
+    this.flushTimer = setInterval(() => {
+      if (!this.queue.isEmpty()) {
+        this.flush().catch((error) => {
+          this.log("Auto-flush failed", error);
+        });
+      }
+    }, this.config.batchInterval);
+  }
+  /**
+   * Stop flush timer
+   */
+  stopFlushTimer() {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+  }
+  /**
+   * Get current session ID
+   */
+  getSessionId() {
+    return this.config.sessionId;
+  }
+  /**
+   * Get queue size
+   */
+  getQueueSize() {
+    return this.queue.size();
+  }
+  /**
+   * Destroy client and cleanup
+   */
+  async destroy() {
+    if (this.isDestroyed) return;
+    this.log("Destroying Signals instance");
+    this.isDestroyed = true;
+    this.stopFlushTimer();
+    await this.flush();
+  }
+  /**
+   * Debug logging
+   */
+  log(message, data) {
+    if (this.config.debug) {
+      console.log(`[LoggClient] ${message}`, data ?? "");
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AsyncStorageAdapter,
+  EventQueue,
+  LocalStorageAdapter,
+  MemoryStorageAdapter,
+  Signals,
+  getDefaultStorageAdapter
+});