@levo-so/core 0.1.58 → 0.1.60

package/dist/index.js

@@ -356,58 +356,282 @@ var getLevoError = (error) => {
   });
 };
 
-// src/utils/lock.ts
-var LocalStorageLock = class {
-  key;
-  constructor(lockKey) {
-    this.key = lockKey;
-  }
-  acquireLock(expiryMs = 5e3) {
-    const now = Date.now();
-    const lockValue = localStorage.getItem(this.key);
-    if (lockValue) {
-      const timestamp = Number(lockValue);
-      if (now - timestamp < expiryMs) {
-        return false;
-      }
-    }
-    localStorage.setItem(this.key, now.toString());
-    setTimeout(() => {
-      if (this.isLocked(expiryMs)) {
-        this.releaseLock();
-      }
-    }, expiryMs);
-    return true;
-  }
-  releaseLock() {
-    localStorage.removeItem(this.key);
-  }
-  isLocked(expiryMs = 5e3) {
-    const lockValue = localStorage.getItem(this.key);
-    if (!lockValue) {
-      return false;
-    }
-    const timestamp = Number(lockValue);
-    return Date.now() - timestamp < expiryMs;
-  }
-};
-
 // src/control/audience.ts
+var BATCH_SIZE = 50;
+var BATCH_INTERVAL_MS = 5e3;
+var MAX_EVENTS_PER_PAGE = 500;
+var BROADCAST_CHANNEL_NAME = "levo_analytics";
 var createLevoAudienceModule = (core, httpClient) => {
   const _IDLE_THROTTLE = 1 * 1e3;
   const _IDLE_TIMEOUT = 60 * 1e3;
   let instance = null;
   let idle_listener = null;
   const storage_keys = {
+    /** Legacy: Lock key for identify operation (no longer used internally) */
     identify: "lock:lv_aud_identify",
+    /** Key for tracking open tab count */
     open_tabs: "lv_insights_ot",
+    /** Key for current tab ID (sessionStorage) */
     current_tab: "lv_insights_ct",
-    all_tabs: "lv_insights_at"
+    /** Key for all tabs registry */
+    all_tabs: "lv_insights_at",
+    /** Device JWT for direct mode (1yr expiry, rotated on /welcome, analytics-only scope) */
+    device_token: "lv_aud_device",
+    /** Session JWT for direct mode (1yr expiry, rotated on /welcome, analytics-only scope) */
+    session_token: "lv_aud_session",
+    /** Cached insights mode ('proxy' | 'direct') */
+    mode: "lv_aud_mode"
+  };
+  let _insightsMode = "proxy";
+  let _insightsBaseUrl = "";
+  let _localStorageAvailable = true;
+  const _memoryStorage = /* @__PURE__ */ new Map();
+  const checkLocalStorageAvailable = () => {
+    if (typeof window === "undefined" || !("localStorage" in window)) {
+      return false;
+    }
+    try {
+      const testKey = "__levo_test__";
+      window.localStorage.setItem(testKey, "test");
+      window.localStorage.removeItem(testKey);
+      return true;
+    } catch {
+      return false;
+    }
+  };
+  const getFromStorage = (key) => {
+    if (typeof window === "undefined") {
+      return _memoryStorage.get(key) || null;
+    }
+    if (_localStorageAvailable) {
+      try {
+        return window.localStorage.getItem(key);
+      } catch {
+        return _memoryStorage.get(key) || null;
+      }
+    }
+    return _memoryStorage.get(key) || null;
+  };
+  const setInStorage = (key, value) => {
+    if (typeof window === "undefined") {
+      _memoryStorage.set(key, value);
+      return;
+    }
+    if (_localStorageAvailable) {
+      try {
+        window.localStorage.setItem(key, value);
+        return;
+      } catch {
+      }
+    }
+    _memoryStorage.set(key, value);
+  };
+  const removeFromStorage = (key) => {
+    _memoryStorage.delete(key);
+    if (typeof window === "undefined" || !_localStorageAvailable) {
+      return;
+    }
+    try {
+      window.localStorage.removeItem(key);
+    } catch {
+    }
+  };
+  const getAuthHeaders = () => {
+    const headers = {};
+    if (_insightsMode === "direct") {
+      const deviceToken = getFromStorage(storage_keys.device_token);
+      const sessionToken = getFromStorage(storage_keys.session_token);
+      if (deviceToken) headers["Levo-Audience-Device"] = deviceToken;
+      if (sessionToken) headers["Levo-Audience-Session"] = sessionToken;
+    }
+    return headers;
+  };
+  const pingEndpoint = async (url, timeout) => {
+    let timeoutId = null;
+    try {
+      const controller = new AbortController();
+      timeoutId = setTimeout(() => controller.abort(), timeout);
+      const response = await fetch(url, {
+        method: "GET",
+        signal: controller.signal,
+        credentials: "omit"
+      });
+      return response.ok;
+    } catch {
+      return false;
+    } finally {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+    }
+  };
+  const detectInsightsMode = async () => {
+    if (core.insightsMode === "proxy") {
+      _insightsBaseUrl = core.insightsUrl;
+      return "proxy";
+    }
+    if (core.insightsMode === "direct") {
+      if (!core.directInsightsUrl) {
+        console.warn(
+          "[@levo-so/core] insightsMode='direct' but directInsightsUrl not set. Falling back to proxy."
+        );
+        _insightsBaseUrl = core.insightsUrl;
+        return "proxy";
+      }
+      _insightsBaseUrl = core.directInsightsUrl;
+      setInStorage(storage_keys.mode, "direct");
+      return "direct";
+    }
+    const cachedMode = getFromStorage(storage_keys.mode);
+    if (cachedMode === "proxy" || cachedMode === "direct") {
+      if (cachedMode === "direct" && !core.directInsightsUrl) {
+        removeFromStorage(storage_keys.mode);
+        _insightsBaseUrl = "";
+      } else {
+        const pingUrl = cachedMode === "proxy" ? `${core.insightsUrl}/ping` : `${core.directInsightsUrl}/ping`;
+        if (await pingEndpoint(pingUrl, core.pingTimeout)) {
+          _insightsBaseUrl = cachedMode === "proxy" ? core.insightsUrl : core.directInsightsUrl;
+          return cachedMode;
+        }
+      }
+    }
+    if (await pingEndpoint(`${core.insightsUrl}/ping`, core.pingTimeout)) {
+      setInStorage(storage_keys.mode, "proxy");
+      _insightsBaseUrl = core.insightsUrl;
+      return "proxy";
+    }
+    if (core.directInsightsUrl) {
+      setInStorage(storage_keys.mode, "direct");
+      _insightsBaseUrl = core.directInsightsUrl;
+      return "direct";
+    }
+    _insightsBaseUrl = core.insightsUrl;
+    return "proxy";
   };
   let _session = "";
   let _device = "";
   let is_identified = false;
-  let _batch = [];
+  let _eventCount = 0;
+  let _eventQueue = [];
+  let _flushTimer = null;
+  let _channel = null;
+  let _pendingIdentify = false;
+  const buildSessionSyncMessage = () => {
+    const message = {
+      type: "SESSION_SYNC",
+      session: _session,
+      device: _device
+    };
+    if (_insightsMode === "direct") {
+      const storedDeviceToken = getFromStorage(storage_keys.device_token);
+      const storedSessionToken = getFromStorage(storage_keys.session_token);
+      if (storedDeviceToken) message.deviceToken = storedDeviceToken;
+      if (storedSessionToken) message.sessionToken = storedSessionToken;
+    }
+    return message;
+  };
+  const initBroadcastChannel = () => {
+    if (typeof BroadcastChannel === "undefined") {
+      return;
+    }
+    try {
+      _channel = new BroadcastChannel(BROADCAST_CHANNEL_NAME);
+      _channel.onmessage = (event) => {
+        const { type, session, device, deviceToken, sessionToken } = event.data;
+        if (type === "SESSION_SYNC" && !is_identified) {
+          _session = session;
+          _device = device;
+          is_identified = true;
+          _pendingIdentify = false;
+          if (_insightsMode === "direct" && deviceToken && sessionToken) {
+            setInStorage(storage_keys.device_token, deviceToken);
+            setInStorage(storage_keys.session_token, sessionToken);
+          }
+        }
+        if (type === "SESSION_REQUEST" && is_identified) {
+          _channel?.postMessage(buildSessionSyncMessage());
+        }
+      };
+    } catch (e) {
+    }
+  };
+  const requestSessionFromOtherTabs = () => {
+    _channel?.postMessage({ type: "SESSION_REQUEST" });
+  };
+  const broadcastSession = () => {
+    _channel?.postMessage(buildSessionSyncMessage());
+  };
+  const flushEventQueue = () => {
+    const baseUrl = _insightsBaseUrl || core?.insightsUrl;
+    if (_eventQueue.length === 0 || !baseUrl || !core.workspace) {
+      return;
+    }
+    const batch = _eventQueue.map((event) => ({
+      ...event,
+      session_id: event.session_id || _session,
+      device_id: event.device_id || _device
+    }));
+    _eventQueue = [];
+    const url = `${baseUrl}/v1/insights/event/bulk?workspace=${core.workspace}`;
+    const headers = {
+      "Content-Type": "application/json",
+      ...getAuthHeaders()
+    };
+    if (_insightsMode === "proxy" && navigator.sendBeacon) {
+      const success = navigator.sendBeacon(url, JSON.stringify(batch));
+      if (success) {
+        return;
+      }
+    }
+    fetch(url, {
+      method: "POST",
+      body: JSON.stringify(batch),
+      headers,
+      keepalive: true,
+      credentials: _insightsMode === "proxy" ? "include" : "omit"
+    }).catch(() => {
+    });
+  };
+  const startFlushTimer = () => {
+    if (_flushTimer) {
+      return;
+    }
+    _flushTimer = setInterval(() => {
+      flushEventQueue();
+    }, BATCH_INTERVAL_MS);
+    if (typeof document !== "undefined") {
+      document.addEventListener("visibilitychange", () => {
+        if (document.visibilityState === "hidden") {
+          flushEventQueue();
+        }
+      });
+      window.addEventListener("beforeunload", () => {
+        flushEventQueue();
+      });
+      window.addEventListener("pagehide", () => {
+        flushEventQueue();
+      });
+    }
+  };
+  const stopFlushTimer = () => {
+    if (_flushTimer) {
+      clearInterval(_flushTimer);
+      _flushTimer = null;
+    }
+  };
+  const queueEvent = (collectInput) => {
+    if (_eventCount >= MAX_EVENTS_PER_PAGE) {
+      console.warn(
+        `[@levo-so/core] Event limit (${MAX_EVENTS_PER_PAGE}) reached for this page`
+      );
+      return;
+    }
+    _eventCount++;
+    _eventQueue.push(collectInput);
+    if (_eventQueue.length >= BATCH_SIZE) {
+      flushEventQueue();
+    }
+  };
   const getReferrer = () => {
     if (typeof document === "undefined") {
       return {};
@@ -477,11 +701,13 @@ var createLevoAudienceModule = (core, httpClient) => {
   const request = async (url, data) => {
     const headers = {
       Accept: "application/json",
-      "Content-Type": "application/json"
+      "Content-Type": "application/json",
+      ...getAuthHeaders()
     };
     try {
-      const response = await httpClient.instance.url(core?.insightsUrl, true).url(url).options({
-        keepAlive: true
+      const response = await httpClient.instance.url(_insightsBaseUrl || core?.insightsUrl, true).url(url).options({
+        keepAlive: true,
+        credentials: _insightsMode === "proxy" ? "include" : "omit"
       }).headers(headers).post(data).json();
       return response;
     } catch (error) {
@@ -493,8 +719,26 @@ var createLevoAudienceModule = (core, httpClient) => {
     if (core.NODE_ENV === "development") {
       return;
     }
+    _eventCount = 0;
+    _localStorageAvailable = checkLocalStorageAvailable();
+    _insightsMode = await detectInsightsMode();
+    initBroadcastChannel();
+    requestSessionFromOtherTabs();
+    startFlushTimer();
+    await new Promise((resolve) => setTimeout(resolve, 50));
     const plugin = {
       name: core.workspace,
+      /**
+       * Handle track events (custom events like clicks, scrolls, etc.)
+       *
+       * Enriches the event with:
+       * - Session/device IDs
+       * - Page metadata (URL, title, etc.)
+       * - Tab information
+       * - Timestamp
+       *
+       * Then queues for batched sending.
+       */
       track: ({ payload }) => {
         if (!core?.insightsUrl || !core.workspace) {
           return;
@@ -506,9 +750,11 @@ var createLevoAudienceModule = (core, httpClient) => {
           event: payload.event,
           version: payload.version || 1,
           workspace_id: core.workspace,
+          site_id: core.site || void 0,
           properties: {
             ...properties,
             ...payloadProperties,
+            // Remove metadata fields from properties (they're top-level)
             version: void 0,
             resource: void 0,
             identifier: void 0,
@@ -528,21 +774,19 @@ var createLevoAudienceModule = (core, httpClient) => {
           tab_id: getCurrentTabId(),
           tab_count: getTabCount()
         };
-        let isQueued = false;
-        if (navigator.sendBeacon) {
-          isQueued = navigator.sendBeacon(
-            `${core?.insightsUrl}/v1/insights/event/collect`,
-            JSON.stringify(collectInput)
-          );
-        }
-        if (!isQueued) {
-          request("/v1/insights/event/collect", collectInput);
-        }
+        queueEvent(collectInput);
       },
+      /**
+       * Handle page view events.
+       *
+       * Called when navigating to a new page (in SPAs) or on initial load.
+       * Resets the rate limit counter and tracks a page.view event.
+       */
       page: ({ payload }) => {
         if (!core?.insightsUrl) {
           return;
         }
+        _eventCount = 0;
         const payloadProperties = payload?.properties || {};
         track("page.view", {
           ...properties,
@@ -552,11 +796,28 @@ var createLevoAudienceModule = (core, httpClient) => {
           resource: "page"
         });
       },
+      /**
+       * Handle identify events (session establishment).
+       *
+       * This is called when identify() is invoked. It:
+       * 1. Checks if already identified (via BroadcastChannel) - if so, skip
+       * 2. Calls /welcome API to get session/device IDs
+       * 3. On success, broadcasts session to other tabs
+       *
+       * The /welcome API uses HttpOnly cookies to maintain persistent
+       * device identity across sessions.
+       */
       identify: ({ payload }) => {
         if (!core?.insightsUrl || !core.workspace) {
           return;
         }
-        const withLock = payload?.traits?.withLock ?? true;
+        if (is_identified) {
+          return;
+        }
+        if (_pendingIdentify) {
+          return;
+        }
+        _pendingIdentify = true;
         const welcomeInput = {
           private_mode: payload.traits.private_mode,
           dark_mode: payload.traits.dark_mode,
@@ -565,6 +826,7 @@ var createLevoAudienceModule = (core, httpClient) => {
           referrer: payload.traits.referrer,
           properties: payload.traits.properties,
           workspace_id: core.workspace,
+          site_id: core.site || void 0,
           hostname: window.location.hostname,
           pathname: window.location.pathname,
           page_title: document.title,
@@ -573,36 +835,33 @@ var createLevoAudienceModule = (core, httpClient) => {
           tab_id: getCurrentTabId(),
           tab_count: getTabCount()
         };
-        let identifyLock = null;
-        if (withLock) {
-          identifyLock = new LocalStorageLock(storage_keys.identify);
-        }
-        if (!identifyLock || identifyLock.acquireLock()) {
-          request(`/v1/insights/event/welcome`, welcomeInput).then((data) => {
-            is_identified = true;
-            if (data?.content?.data?.session) {
-              _session = data?.content.data.session;
-            }
-            if (data?.content?.data?.device) {
-              _device = data?.content.data.device;
-            }
-            let isQueued = false;
-            if (navigator.sendBeacon) {
-              isQueued = navigator.sendBeacon(
-                `${core?.insightsUrl}/v1/insights/event/bulk?workspace=${core?.workspace}`,
-                JSON.stringify(_batch)
-              );
+        request(`/v1/insights/event/welcome`, welcomeInput).then((data) => {
+          if (is_identified) {
+            _pendingIdentify = false;
+            return;
+          }
+          is_identified = true;
+          _pendingIdentify = false;
+          if (data?.content?.data?.session) {
+            _session = data?.content.data.session;
+          }
+          if (data?.content?.data?.device) {
+            _device = data?.content.data.device;
+          }
+          if (_insightsMode === "direct" && data?.content?.meta) {
+            const meta = data.content.meta;
+            if (meta.device_token) {
+              setInStorage(storage_keys.device_token, meta.device_token);
             }
-            if (!isQueued) {
-              request("/v1/insights/event/bulk", _batch);
+            if (meta.session_token) {
+              setInStorage(storage_keys.session_token, meta.session_token);
             }
-            _batch = [];
-            identifyLock?.releaseLock();
-          }).catch((e) => {
-            identifyLock?.releaseLock();
-            return getLevoError(e);
-          });
-        }
+          }
+          broadcastSession();
+        }).catch((e) => {
+          _pendingIdentify = false;
+          return getLevoError(e);
+        });
       }
     };
     instance = Analytics({
@@ -650,10 +909,10 @@ var createLevoAudienceModule = (core, httpClient) => {
     if (!core.workspace) {
       return;
     }
-    if (instance && is_identified) {
+    if (instance) {
       return instance.track(event, properties);
     }
-    return _batch.push({
+    const collectInput = {
       event,
       version: properties?.version || 1,
       properties: {
@@ -674,23 +933,39 @@ var createLevoAudienceModule = (core, httpClient) => {
       resource: properties?.resource || "page",
       identifier: properties?.identifier || properties?.id,
       workspace_id: core.workspace,
+      site_id: core.site || void 0,
       created_at: (/* @__PURE__ */ new Date()).toISOString(),
       tab_id: getCurrentTabId(),
       tab_count: getTabCount()
-    });
+    };
+    queueEvent(collectInput);
+  };
+  const destroy = () => {
+    flushEventQueue();
+    stopFlushTimer();
+    _channel?.close();
   };
   return {
+    /** Get the underlying analytics instance (read-only) */
     get instance() {
       return instance;
     },
+    /** Check if session has been established (read-only) */
     get is_identified() {
       return is_identified;
     },
+    /** Storage keys used by the module */
     storage_keys,
+    /** Initialize the module for a page */
     initiate,
+    /** Identify/establish session */
     identify,
+    /** Track a custom event */
     track,
-    bounce
+    /** Track a bounce event */
+    bounce,
+    /** Cleanup the module */
+    destroy
   };
 };
 
@@ -700,11 +975,16 @@ var createLevoControl = (options) => {
   const {
     appName,
     workspace = null,
+    site = null,
     apiUrl = "https://public-api.levo.so",
     insightsUrl = "/.levo/insights/api",
+    directInsightsUrl,
+    insightsMode = "auto",
+    pingTimeout = 3e3,
     NODE_ENV = "",
     APP_MODE = "production"
   } = options;
+  const sanitizedPingTimeout = Number.isFinite(pingTimeout) && pingTimeout >= 0 ? pingTimeout : 3e3;
   if (workspace) {
     if (!workspaceIdRegex.test(workspace)) {
       throw new Error(
@@ -713,6 +993,7 @@ var createLevoControl = (options) => {
     }
   }
   let _workspace = workspace;
+  let _site = site;
   return {
     get workspace() {
       return _workspace;
@@ -727,6 +1008,12 @@ var createLevoControl = (options) => {
       }
       _workspace = value;
     },
+    get site() {
+      return _site;
+    },
+    set site(value) {
+      _site = value;
+    },
     get appName() {
       return appName;
     },
@@ -736,6 +1023,15 @@ var createLevoControl = (options) => {
     get insightsUrl() {
       return insightsUrl;
     },
+    get directInsightsUrl() {
+      return directInsightsUrl || "";
+    },
+    get insightsMode() {
+      return insightsMode;
+    },
+    get pingTimeout() {
+      return sanitizedPingTimeout;
+    },
     get NODE_ENV() {
       return NODE_ENV;
     },
@@ -1295,16 +1591,30 @@ var AnalyticsEventsList = [
   "page.impression",
   "page.scroll",
   "page.view",
-  "page.metrics",
   "page.selection",
-  "page.speedtest",
   // User Activity Events
   "user.active",
-  "user.speedtest",
   "user.idle"
 ];
 var AnalyticsEvents = listToRecord(AnalyticsEventsList);
 
+// src/types/forum/post.ts
+var FORUM_POST_KIND = {
+  post: "post",
+  poll: "poll",
+  gallery: "gallery",
+  link: "link"
+};
+var ForumPostKindExpandedList = Object.keys(FORUM_POST_KIND);
+
+// src/types/forum/comment.ts
+var COMMENT_STATUS = {
+  active: "active",
+  edited: "edited",
+  deleted: "deleted",
+  pending_moderation: "pending_moderation"
+};
+
 // src/constants/collection/fieldInterfaceFormat.ts
 var formatsByInterface = {
   ArrayWidget: [],
@@ -1350,7 +1660,6 @@ var defaultByKinds = {
   record: null,
   group: [],
   collection: {
-    o2m: null,
     m2o: null,
     o2o: null,
     m2m: []
@@ -1515,6 +1824,7 @@ var LEVO_INTEGRATIONS = {
   event: "so.levo.event",
   membership: "so.levo.membership",
   payment: "so.levo.payment",
+  community: "so.levo.community",
   search_console: "com.google.search_console"
 };
 var LEVO_INTEGRATIONS_LIST = Object.values(LEVO_INTEGRATIONS);
@@ -1530,4 +1840,40 @@ var formatImagePath = (string) => {
   return "";
 };
 
-export { AnalyticsEvents, AnalyticsEventsList, CommonFieldIntefaces, CommonFieldInterfacesList, ComplexFieldInterfacesList, FieldInterfaces, FieldInterfacesList, FieldKind, FieldKindList, LEVO_INTEGRATIONS, LEVO_INTEGRATIONS_LIST, LevoError, LevoOAuthProviderList, LocalStorageLock, MediaKind, MediaKindList, createLevoClient, defaultByKinds, formatImagePath, formatsByInterface, getLevoError, interfaceKinds };
+// src/utils/lock.ts
+var LocalStorageLock = class {
+  key;
+  constructor(lockKey) {
+    this.key = lockKey;
+  }
+  acquireLock(expiryMs = 5e3) {
+    const now = Date.now();
+    const lockValue = localStorage.getItem(this.key);
+    if (lockValue) {
+      const timestamp = Number(lockValue);
+      if (now - timestamp < expiryMs) {
+        return false;
+      }
+    }
+    localStorage.setItem(this.key, now.toString());
+    setTimeout(() => {
+      if (this.isLocked(expiryMs)) {
+        this.releaseLock();
+      }
+    }, expiryMs);
+    return true;
+  }
+  releaseLock() {
+    localStorage.removeItem(this.key);
+  }
+  isLocked(expiryMs = 5e3) {
+    const lockValue = localStorage.getItem(this.key);
+    if (!lockValue) {
+      return false;
+    }
+    const timestamp = Number(lockValue);
+    return Date.now() - timestamp < expiryMs;
+  }
+};
+
+export { AnalyticsEvents, AnalyticsEventsList, COMMENT_STATUS, CommonFieldIntefaces, CommonFieldInterfacesList, ComplexFieldInterfacesList, FORUM_POST_KIND, FieldInterfaces, FieldInterfacesList, FieldKind, FieldKindList, ForumPostKindExpandedList, LEVO_INTEGRATIONS, LEVO_INTEGRATIONS_LIST, LevoError, LevoOAuthProviderList, LocalStorageLock, MediaKind, MediaKindList, createLevoClient, defaultByKinds, formatImagePath, formatsByInterface, getLevoError, interfaceKinds };