@logg/signals 0.1.0

package/dist/index.mjs

@@ -0,0 +1,489 @@
+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/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 ?? "");
+    }
+  }
+};
+export {
+  AsyncStorageAdapter,
+  EventQueue,
+  LocalStorageAdapter,
+  MemoryStorageAdapter,
+  Signals,
+  getDefaultStorageAdapter
+};

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@logg/signals",
+  "version": "0.1.0",
+  "description": "Universal event tracking SDK for Logg Signals",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts --clean",
+    "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
+    "test": "vitest",
+    "test:ui": "vitest --ui",
+    "type-check": "tsc --noEmit",
+    "lint": "eslint src --ext ts,tsx",
+    "prepublishOnly": "pnpm run build"
+  },
+  "keywords": [
+    "analytics",
+    "events",
+    "tracking",
+    "logg",
+    "signals",
+    "react-native",
+    "web",
+    "nodejs"
+  ],
+  "author": "Logg",
+  "license": "MIT",
+  "homepage": "https://github.com/synctree/session-app/tree/main/apps/signals-client#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/synctree/session-app.git",
+    "directory": "apps/signals-client"
+  },
+  "bugs": {
+    "url": "https://github.com/synctree/session-app/issues"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "@typescript-eslint/eslint-plugin": "^6.13.0",
+    "@typescript-eslint/parser": "^6.13.0",
+    "eslint": "^8.55.0",
+    "tsup": "^8.0.1",
+    "typescript": "^5.3.2",
+    "vitest": "^1.0.4"
+  },
+  "peerDependencies": {
+    "@react-native-async-storage/async-storage": "^1.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@react-native-async-storage/async-storage": {
+      "optional": true
+    }
+  }
+}