@levo-so/core 0.1.34 → 0.1.36

package/dist/index.js

@@ -1,92 +1,1146 @@
-export { LevoError, getLevoError } from './chunk-VQMSBMEM.js';
-export { LevoOAuthProviderList } from './chunk-ZLLCLSGE.js';
-export { LevoPlugin } from './chunk-QJSKNLTV.js';
+import { onUserActivity } from '@analytics/activity-utils';
+import { getVisitorSource } from '@analytics/visitor-source';
+import { Analytics } from 'analytics';
+import getUserLocale from 'get-user-locale';
+import { WretchError } from 'wretch/resolver';
 import wretch from 'wretch';
-import QueryStringAddon from 'wretch/addons/queryString';
+import queryStringAddon from 'wretch/addons/queryString';
 
-var workspaceIdRegex = /^W[A-Z0-9]{7}$/;
-var LevoClient = class {
-  appName;
-  #workspace;
-  #apiUrl;
-  #insightsUrl;
-  #NODE_ENV;
-  #APP_MODE;
-  #pageContext = {
-    url: typeof window !== "undefined" ? window?.location?.href : "",
-    referrer: typeof document !== "undefined" ? document?.referrer : "",
-    title: typeof document !== "undefined" ? document?.title : ""
-  };
-  constructor(props) {
-    const defaultProps = {
-      workspace: null,
-      apiUrl: "https://public-api.levo.so",
-      insightsUrl: "/.levo/insights/api",
-      NODE_ENV: "production"
-    };
-    const finalProps = { ...defaultProps, ...props };
-    if (props.workspace) {
-      if (!workspaceIdRegex.test(props.workspace)) {
-        throw new Error(
-          `Invalid workspace ID: ${props.workspace}. Workspace ID must be a string of the format "W[A-Z0-9]{7}".`
+// src/control/audience.ts
+
+// src/utils/isIncognito.ts
+var isIncognito = () => new Promise((resolve, reject) => {
+  let browserName = "Unknown";
+  function __callback(isPrivate) {
+    resolve({
+      isPrivate,
+      browserName
+    });
+  }
+  function identifyChromium() {
+    const ua = navigator.userAgent;
+    if (ua.match(/Chrome/)) {
+      if (navigator.brave !== void 0) {
+        return "Brave";
+      }
+      if (ua.match(/Edg/)) {
+        return "Edge";
+      }
+      if (ua.match(/OPR/)) {
+        return "Opera";
+      }
+      return "Chrome";
+    }
+    return "Chromium";
+  }
+  function assertEvalToString(value) {
+    return value === eval.toString().length;
+  }
+  function isSafari() {
+    const v = navigator.vendor;
+    return v !== void 0 && v.indexOf("Apple") === 0 && assertEvalToString(37);
+  }
+  function isChrome() {
+    const v = navigator.vendor;
+    return v !== void 0 && v.indexOf("Google") === 0 && assertEvalToString(33);
+  }
+  function isFirefox() {
+    return document.documentElement !== void 0 && document.documentElement.style.MozAppearance !== void 0 && assertEvalToString(37);
+  }
+  function isMSIE() {
+    return navigator.msSaveBlob !== void 0 && assertEvalToString(39);
+  }
+  function newSafariTest() {
+    const tmp_name = String(Math.random());
+    try {
+      const db = window.indexedDB.open(tmp_name, 1);
+      db.onupgradeneeded = (i) => {
+        const res = i.target?.result;
+        try {
+          res.createObjectStore("test", {
+            autoIncrement: true
+          }).put(new Blob());
+          __callback(false);
+        } catch (e) {
+          let message = e;
+          if (e instanceof Error) {
+            message = e.message ?? e;
+          }
+          if (typeof message !== "string") {
+            return __callback(false);
+          }
+          const matchesExpectedError = /BlobURLs are not yet supported/.test(
+            message
+          );
+          return __callback(matchesExpectedError);
+        } finally {
+          res.close();
+          window.indexedDB.deleteDatabase(tmp_name);
+        }
+      };
+    } catch (e) {
+      return __callback(false);
+    }
+  }
+  function oldSafariTest() {
+    const openDB = window.openDatabase;
+    const storage = window.localStorage;
+    try {
+      openDB(null, null, null, null);
+    } catch (e) {
+      return __callback(true);
+    }
+    try {
+      storage.setItem("test", "1");
+      storage.removeItem("test");
+    } catch (e) {
+      return __callback(true);
+    }
+    return __callback(false);
+  }
+  function safariPrivateTest() {
+    if (navigator.maxTouchPoints !== void 0) {
+      newSafariTest();
+    } else {
+      oldSafariTest();
+    }
+  }
+  function getQuotaLimit() {
+    const w = window;
+    if (w.performance !== void 0 && w.performance.memory !== void 0 && w.performance.memory.jsHeapSizeLimit !== void 0) {
+      return performance.memory.jsHeapSizeLimit;
+    }
+    return 1073741824;
+  }
+  function storageQuotaChromePrivateTest() {
+    navigator.webkitTemporaryStorage.queryUsageAndQuota(
+      (_, quota) => {
+        const quotaInMib = Math.round(quota / (1024 * 1024));
+        const quotaLimitInMib = Math.round(getQuotaLimit() / (1024 * 1024)) * 2;
+        __callback(quotaInMib < quotaLimitInMib);
+      },
+      (e) => {
+        reject(
+          new Error(
+            `detectIncognito somehow failed to query storage quota: ${e.message}`
+          )
         );
       }
+    );
+  }
+  function oldChromePrivateTest() {
+    const fs = window.webkitRequestFileSystem;
+    const success = () => {
+      __callback(false);
+    };
+    const error = () => {
+      __callback(true);
+    };
+    fs(0, 1, success, error);
+  }
+  function chromePrivateTest() {
+    if (self.Promise !== void 0 && self.Promise.allSettled !== void 0) {
+      storageQuotaChromePrivateTest();
+    } else {
+      oldChromePrivateTest();
+    }
+  }
+  function firefoxPrivateTest() {
+    __callback(navigator.serviceWorker === void 0);
+  }
+  function msiePrivateTest() {
+    __callback(window.indexedDB === void 0);
+  }
+  function main() {
+    if (isSafari()) {
+      browserName = "Safari";
+      safariPrivateTest();
+    } else if (isChrome()) {
+      browserName = identifyChromium();
+      chromePrivateTest();
+    } else if (isFirefox()) {
+      browserName = "Firefox";
+      firefoxPrivateTest();
+    } else if (isMSIE()) {
+      browserName = "Internet Explorer";
+      msiePrivateTest();
+    } else {
+      reject(new Error("detectIncognito cannot determine the browser"));
+    }
+  }
+  main();
+});
+var isIncognito_default = isIncognito;
+
+// src/utils/getUserProperties.ts
+var getGPUInfo = () => {
+  const canvas = document.createElement("canvas");
+  const gl = canvas?.getContext("webgl") || canvas?.getContext("experimental-webgl");
+  if (!gl) {
+    return null;
+  }
+  const debugInfo = gl?.getExtension("WEBGL_debug_renderer_info");
+  return debugInfo ? gl?.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL) : null;
+};
+var getUserProperties = async () => {
+  let locale = "";
+  let timezone = "";
+  let dark_mode = false;
+  let private_mode = false;
+  const properties = {};
+  if (!window) {
+    return {
+      locale,
+      timezone,
+      dark_mode,
+      private_mode,
+      properties
+    };
+  }
+  try {
+    ({ isPrivate: private_mode } = await isIncognito_default());
+  } catch (e) {
+    console.error(e);
+  }
+  try {
+    dark_mode = window.matchMedia?.("(prefers-color-scheme: dark)").matches;
+  } catch (e) {
+    console.error(e);
+  }
+  try {
+    timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+  } catch (e) {
+    console.error(e);
+  }
+  try {
+    locale = getUserLocale();
+  } catch (e) {
+    console.error(e);
+  }
+  if (navigator && "connection" in navigator) {
+    const connection = navigator.connection || navigator?.mozConnection || navigator.webkitConnection;
+    properties.network_type = connection.effectiveType;
+  }
+  properties.width = window?.innerWidth;
+  properties.height = window?.innerHeight;
+  properties.pixel_ratio = window?.devicePixelRatio;
+  if (screen) {
+    properties.screen_width = screen?.width;
+    properties.screen_height = screen?.height;
+    properties.color_depth = screen?.colorDepth;
+    properties.orientation = screen?.orientation?.type;
+  }
+  if (navigator && "getBattery" in navigator) {
+    const battery = await navigator?.getBattery();
+    if (battery) {
+      properties.battery_level = Number((battery?.level * 100).toFixed(0));
+      properties.battery_charging = battery?.charging;
+      properties.battery_discharging_time = battery?.dischargingTime;
+      properties.battery_full_charge_capacity = battery?.fullChargeCapacity;
+      properties.battery_charging_time = battery?.chargingTime;
     }
-    this.#workspace = finalProps.workspace;
-    this.#apiUrl = finalProps.apiUrl;
-    this.#insightsUrl = finalProps.insightsUrl;
-    this.#NODE_ENV = finalProps.NODE_ENV;
-    this.#APP_MODE = finalProps.APP_MODE;
-    this.appName = finalProps.appName;
   }
-  get workspace() {
-    return this.#workspace;
+  if (navigator && "deviceMemory" in navigator) {
+    properties.device_memory = navigator?.deviceMemory;
   }
-  get apiUrl() {
-    return this.#apiUrl;
+  const supportsTouch = "ontouchstart" in window || typeof navigator?.maxTouchPoints !== "undefined" && navigator?.maxTouchPoints > 0;
+  properties.touch_supported = supportsTouch;
+  if ("hardwareConcurrency" in navigator) {
+    properties.hardware_concurrency = navigator?.hardwareConcurrency;
   }
-  get insightsUrl() {
-    return this.#insightsUrl;
+  if (navigator && "mediaDevices" in navigator) {
+    const mediaDevices = navigator?.mediaDevices;
+    const devices = await mediaDevices?.enumerateDevices();
+    const hasCamera = devices.some((device) => device?.kind === "videoinput");
+    properties.camera_supported = hasCamera;
+    const hasMicrophone = devices.some(
+      (device) => device?.kind === "audioinput"
+    );
+    properties.microphone_supported = hasMicrophone;
   }
-  get NODE_ENV() {
-    return this.#NODE_ENV;
+  properties.gpu = getGPUInfo();
+  return {
+    locale,
+    timezone,
+    dark_mode,
+    private_mode,
+    properties
+  };
+};
+
+// src/utils/LevoError.ts
+var LevoError = class extends Error {
+  code;
+  title;
+  message;
+  status;
+  constructor(data) {
+    super(data?.message || data?.description);
+    this.name = "Levo Request Error";
+    this.status = data?.status;
+    this.code = data?.code;
+    this.message = data?.message || data?.description;
+    this.title = data?.title;
   }
-  get APP_MODE() {
-    return this.#APP_MODE;
+};
+
+// src/utils/getLevoError.ts
+var getLevoError = (error) => {
+  if (error instanceof WretchError) {
+    const errorResponse = error?.json;
+    if (typeof errorResponse === "object" && errorResponse?.content) {
+      const errorMessage = errorResponse?.content;
+      return new LevoError(errorMessage);
+    }
+  }
+  let displayMessage = error?.message || "Something unexpected happened.";
+  switch (error?.message) {
+    case "Network Error":
+      displayMessage = "Couldn't connect to our servers.";
+      break;
+  }
+  return new LevoError({
+    status: "500",
+    title: "Network Error",
+    description: displayMessage,
+    code: "UNKNOWN_ERROR"
+  });
+};
+
+// src/utils/lock.ts
+var LocalStorageLock = class {
+  key;
+  constructor(lockKey) {
+    this.key = `lock_${lockKey}`;
   }
-  updateWorkspace(workspace) {
-    this.#workspace = workspace;
+  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());
+    return true;
   }
-  getPageContext() {
-    return this.#pageContext;
+  releaseLock() {
+    localStorage.removeItem(this.key);
   }
-  updatePageContext(pageContext) {
-    this.#pageContext = pageContext;
+  isLocked(expiryMs = 5e3) {
+    const lockValue = localStorage.getItem(this.key);
+    if (!lockValue) return false;
+    const timestamp = Number(lockValue);
+    return Date.now() - timestamp < expiryMs;
   }
-  get fetch() {
-    const options = {
-      credentials: "include",
-      signal: AbortSignal.timeout(3e4),
-      // 30 seconds timeout,
-      headers: {}
+};
+
+// src/control/audience.ts
+var createLevoAudienceModule = (core, httpClient) => {
+  const _IDLE_THROTTLE = 1 * 1e3;
+  const _IDLE_TIMEOUT = 60 * 1e3;
+  let instance = null;
+  let idle_listener = null;
+  let _session = "";
+  let _device = "";
+  let _is_identified = false;
+  let _batch = [];
+  const request = (url, data) => {
+    const headers = {
+      Accept: "application/json",
+      "Content-Type": "application/json"
     };
-    if (this.workspace) {
-      options.headers = {
-        ...options?.headers || {},
-        "Levo-Workspace": this.workspace
-      };
+    return httpClient.instance.url(core?.insightsUrl, true).url(url).options({
+      keepAlive: true
+    }).headers(headers).post(data).json();
+  };
+  const getReferrer = () => {
+    if (typeof document === "undefined") {
+      return {};
+    }
+    const {
+      type,
+      referrer,
+      data = {}
+    } = getVisitorSource({
+      referrer: document.referrer,
+      currentUrl: window.location.href,
+      mapper: null
+    });
+    const dataKeys = Object.keys(data);
+    for (const key of dataKeys) {
+      if (data[key] && Array.isArray(data[key]) && data[key].length > 0) {
+        data[key] = data[key]?.[0];
+      }
+    }
+    return { type, referrer, data, raw: document.referrer };
+  };
+  const getCurrentTabId = () => {
+    try {
+      if (typeof window === "undefined" || !("sessionStorage" in window)) {
+        return "";
+      }
+      const CURRENT_TAB_LOCAL_STORAGE_KEY = "lv_insights_ct";
+      return window.sessionStorage.getItem(CURRENT_TAB_LOCAL_STORAGE_KEY) || "";
+    } catch (_) {
+      return "";
+    }
+  };
+  const getTabCount = () => {
+    try {
+      if (typeof window === "undefined" || !("localStorage" in window)) {
+        return 0;
+      }
+      const OT_LOCAL_STORAGE_KEY = "lv_insights_ot";
+      return Number(window.localStorage.getItem(OT_LOCAL_STORAGE_KEY)) || 0;
+    } catch (_) {
+      return 0;
+    }
+  };
+  const startActivityListener = () => {
+    if (typeof document !== "undefined" && !idle_listener) {
+      idle_listener = onUserActivity({
+        timeout: _IDLE_TIMEOUT,
+        throttle: _IDLE_THROTTLE,
+        onIdle: (activeForSeconds) => {
+          track("user.idle", {
+            seconds_active: activeForSeconds
+          });
+        },
+        onWakeUp: (idleForSeconds) => {
+          track("user.active", {
+            seconds_idle: idleForSeconds
+          });
+        }
+      });
+    }
+    return null;
+  };
+  const getActivityStatus = () => {
+    const status = idle_listener?.getStatus();
+    if (!status) {
+      return null;
+    }
+    return {
+      status: status.isIdle ? "idle" : "active",
+      seconds: status.isIdle ? status.idle : status.active
+    };
+  };
+  const initiate = async (properties) => {
+    if (core.NODE_ENV === "development") {
+      return;
+    }
+    const plugin = {
+      name: core.workspace,
+      track: ({ payload }) => {
+        if (!core?.insightsUrl || !core.workspace) {
+          return;
+        }
+        const payloadProperties = payload?.properties || {};
+        const collectInput = {
+          session_id: _session,
+          device_id: _device,
+          event: payload.event,
+          version: payload.version || 1,
+          workspace_id: core.workspace,
+          properties: {
+            ...properties,
+            ...payloadProperties,
+            version: void 0,
+            resource: void 0,
+            identifier: void 0,
+            hostname: void 0,
+            pathname: void 0,
+            url: void 0,
+            page_title: void 0,
+            created_at: void 0
+          },
+          hostname: payload?.hostname || window.location.hostname,
+          pathname: payload?.pathname || window.location.pathname,
+          url: payload?.url || window.location.href,
+          page_title: payload?.page_title || document.title,
+          resource: payloadProperties?.resource || "page",
+          identifier: payloadProperties?.identifier || properties?.id,
+          created_at: payload?.created_at || (/* @__PURE__ */ new Date()).toISOString(),
+          tab_id: getCurrentTabId(),
+          tab_count: getTabCount()
+        };
+        let isQueued = false;
+        try {
+          isQueued = navigator.sendBeacon(
+            `${core?.insightsUrl}/v1/insights/event/collect`,
+            JSON.stringify(collectInput)
+          );
+        } catch (e) {
+        }
+        if (!isQueued) {
+          request("/v1/insights/event/collect", collectInput);
+        }
+      },
+      page: ({ payload }) => {
+        if (!core?.insightsUrl) {
+          return;
+        }
+        const payloadProperties = payload?.properties || {};
+        track("page.view", {
+          ...properties,
+          ...payloadProperties,
+          title: document.title,
+          identifier: properties.id,
+          resource: "page"
+        });
+      },
+      identify: ({ payload }) => {
+        if (!core?.insightsUrl || !core.workspace) {
+          return;
+        }
+        const welcomeInput = {
+          private_mode: payload.traits.private_mode,
+          dark_mode: payload.traits.dark_mode,
+          timezone: payload.traits.timezone,
+          locale: payload.traits.locale,
+          referrer: payload.traits.referrer,
+          properties: payload.traits.properties,
+          workspace_id: core.workspace,
+          hostname: window.location.hostname,
+          pathname: window.location.pathname,
+          page_title: document.title,
+          url: window.location.href,
+          created_at: (/* @__PURE__ */ new Date()).toISOString(),
+          tab_id: getCurrentTabId(),
+          tab_count: getTabCount()
+        };
+        const identifyLock = new LocalStorageLock("lv_aud_identify");
+        if (identifyLock.acquireLock()) {
+          request(`/v1/insights/event/welcome`, welcomeInput).then((data) => {
+            _is_identified = true;
+            _session = data.content.data.session;
+            _device = data.content.data.device;
+            let isQueued = false;
+            try {
+              isQueued = navigator.sendBeacon(
+                `${core?.insightsUrl}/v1/insights/event/bulk?workspace=${core?.workspace}`,
+                JSON.stringify(_batch)
+              );
+            } catch (e) {
+            }
+            if (!isQueued) {
+              request("/v1/insights/event/bulk", _batch);
+            }
+            _batch = [];
+            identifyLock.releaseLock();
+          }).catch((e) => {
+            identifyLock.releaseLock();
+            return getLevoError(e);
+          });
+        }
+      }
+    };
+    instance = Analytics({
+      app: core.workspace || "",
+      plugins: [plugin]
+    });
+    await identify();
+    startActivityListener();
+    return instance.page({
+      resource: "page",
+      identifier: properties.id
+    });
+  };
+  const identify = async () => {
+    if (!instance) {
+      return;
+    }
+    const referrer = getReferrer();
+    const traits = await getUserProperties();
+    await instance.identify("", {
+      ...traits,
+      referrer
+    });
+  };
+  const bounce = async (properties) => {
+    const activity_status = getActivityStatus();
+    if (activity_status) {
+      if (activity_status?.status === "idle") {
+        properties.seconds_idle = activity_status.seconds;
+      } else {
+        properties.seconds_active = activity_status.seconds;
+      }
+    }
+    track("page.bounce", properties);
+  };
+  const track = async (event, properties) => {
+    if (!core.workspace) {
+      return;
+    }
+    if (instance && _is_identified) {
+      return instance.track(event, properties);
+    }
+    return _batch.push({
+      event,
+      version: properties?.version || 1,
+      properties: {
+        ...properties,
+        version: void 0,
+        resource: void 0,
+        identifier: void 0,
+        hostname: void 0,
+        pathname: void 0,
+        url: void 0,
+        page_title: void 0,
+        created_at: void 0
+      },
+      hostname: window.location.hostname,
+      pathname: window.location.pathname,
+      url: window.location.href,
+      page_title: document.title,
+      resource: properties?.resource || "page",
+      identifier: properties?.identifier || properties?.id,
+      workspace_id: core.workspace,
+      created_at: (/* @__PURE__ */ new Date()).toISOString(),
+      tab_id: getCurrentTabId(),
+      tab_count: getTabCount()
+    });
+  };
+  return {
+    get instance() {
+      return instance;
+    },
+    initiate,
+    identify,
+    track,
+    bounce
+  };
+};
+
+// src/control/index.ts
+var workspaceIdRegex = /^W[A-Z0-9]{7}$/;
+var createLevoControl = (options) => {
+  const {
+    appName,
+    workspace = null,
+    apiUrl = "https://public-api.levo.so",
+    insightsUrl = "/.levo/insights/api",
+    NODE_ENV = "",
+    APP_MODE = "production"
+  } = options;
+  if (workspace) {
+    if (!workspaceIdRegex.test(workspace)) {
+      throw new Error(
+        `Invalid workspace ID: ${workspace}. Workspace ID must be a string of the format "W[A-Z0-9]{7}".`
+      );
     }
-    if (this.#pageContext && typeof this.#pageContext === "object" && Object.keys(this.#pageContext).length > 0) {
-      options.headers = {
-        ...options?.headers || {},
-        "Levo-Page-Context": encodeURIComponent(
-          JSON.stringify(this.#pageContext)
-        )
+  }
+  let _workspace = workspace;
+  return {
+    get workspace() {
+      return _workspace;
+    },
+    set workspace(value) {
+      if (value) {
+        if (!workspaceIdRegex.test(value)) {
+          throw new Error(
+            `Invalid workspace ID: ${value}. Workspace ID must be a string of the format "W[A-Z0-9]{7}".`
+          );
+        }
+      }
+      _workspace = value;
+    },
+    get appName() {
+      return appName;
+    },
+    get apiUrl() {
+      return apiUrl;
+    },
+    get insightsUrl() {
+      return insightsUrl;
+    },
+    get NODE_ENV() {
+      return NODE_ENV;
+    },
+    get APP_MODE() {
+      return APP_MODE;
+    }
+  };
+};
+var createHttpClient = (core, pageContext) => {
+  const wr = wretch(core.apiUrl).addon(queryStringAddon);
+  return {
+    get instance() {
+      const options = {
+        credentials: "include",
+        signal: AbortSignal.timeout(3e4),
+        // 30 seconds timeout,
+        headers: {}
       };
+      if (core.workspace) {
+        options.headers = {
+          ...options?.headers || {},
+          "Levo-Workspace": core.workspace
+        };
+      }
+      if (pageContext && typeof pageContext === "object" && Object.keys(pageContext).length > 0) {
+        options.headers = {
+          ...options?.headers || {},
+          "Levo-Page-Context": encodeURIComponent(JSON.stringify(pageContext))
+        };
+      }
+      return wr.options(options);
+    },
+    pageContext
+  };
+};
+var createLogBatch = (options = {}) => {
+  const { logApiUrl = "https://public-api.levo.so" } = options;
+  const _logApiUrl = logApiUrl;
+  const _logs = /* @__PURE__ */ new Map();
+  let activeFlush = Promise.resolve();
+  let nextFlush = setTimeout(() => {
+  }, 0);
+  let lastFlush = /* @__PURE__ */ new Date();
+  const addUniqueLog = (newLog) => {
+    const contentKey = JSON.stringify(newLog?.content ?? "{}");
+    const messageKey = newLog?.message ?? "";
+    _logs.set(`${messageKey}${contentKey}`, newLog);
+  };
+  const sendLogs = async (logs) => {
+    const url = `${_logApiUrl}/v1/apm/logs/json`;
+    const sendFallback = () => {
+      return wretch().url(url).post(logs).res().catch((e) => console.error(e));
+    };
+    try {
+      if (typeof fetch === "undefined") {
+        throw new Error("fetch is not defined");
+      } else if (typeof window !== "undefined" && navigator.sendBeacon) {
+        try {
+          if (!navigator.sendBeacon.bind(navigator)(url, JSON.stringify(logs))) {
+            return sendFallback();
+          }
+        } catch {
+          return sendFallback();
+        }
+      } else {
+        return sendFallback();
+      }
+    } catch (e) {
+      console.warn(`Failed to send logs to server: ${e}`);
+      logs.forEach((log) => addUniqueLog(log));
     }
-    return wretch(this.apiUrl, options).addon(QueryStringAddon);
+  };
+  const flush = async () => {
+    const tasks = Array.from(_logs.values());
+    _logs.clear();
+    clearTimeout(nextFlush);
+    await activeFlush;
+    if (tasks.length === 0) {
+      lastFlush = /* @__PURE__ */ new Date();
+      return;
+    }
+    try {
+      await sendLogs(tasks);
+    } catch (e) {
+      console.log("error sending logs", e);
+    } finally {
+      lastFlush = /* @__PURE__ */ new Date();
+    }
+  };
+  const ingest = (log) => {
+    if (!logApiUrl) return;
+    const tasks = Array.isArray(log) ? log : [log];
+    tasks.forEach((task) => addUniqueLog(task));
+    if (_logs.size >= 50 || lastFlush.getTime() < Date.now() - 1500) {
+      clearTimeout(nextFlush);
+      activeFlush = flush();
+    } else {
+      clearTimeout(nextFlush);
+      nextFlush = setTimeout(() => {
+        activeFlush = flush();
+      }, 1500);
+    }
+  };
+  return {
+    ingest,
+    flush
+  };
+};
+
+// src/logger/index.ts
+var isBrowser = typeof window !== "undefined";
+var getMethodName = (level) => {
+  switch (level) {
+    case 0 /* debug */:
+      return "log";
+    case 1 /* info */:
+      return "info";
+    case 2 /* warn */:
+      return "warn";
+    case 3 /* error */:
+      return "error";
+    default:
+      return "log";
   }
 };
+var createLevoLogger = (core, options = {}) => {
+  const {
+    enableRemote = core.NODE_ENV !== "development",
+    level: logLevel = core.NODE_ENV !== "development" ? 2 /* warn */ : 0 /* debug */,
+    context = {},
+    logApiUrl
+  } = options;
+  const batch = createLogBatch({ logApiUrl });
+  const format = (messages) => {
+    let message = "";
+    const formattedMessages = messages.map((arg) => {
+      let payload = "";
+      const isMessageEmpty = !message;
+      if (typeof arg === "string") {
+        payload = arg;
+        if (isMessageEmpty) {
+          message = arg;
+        }
+      } else if (arg instanceof Error) {
+        payload = {
+          message: arg.message,
+          name: arg.name,
+          stack: arg.stack
+        };
+        if (isMessageEmpty) {
+          message = arg.message;
+        }
+      } else if (typeof arg === "object") {
+        payload = arg;
+      } else {
+        payload = String(arg);
+        if (isMessageEmpty) {
+          message = String(arg);
+        }
+      }
+      return payload;
+    }).filter(Boolean);
+    if (!message && formattedMessages.length > 0) {
+      message = "Default message (Check content for details)";
+    }
+    if (formattedMessages?.length === 1 && formattedMessages[0] === message) {
+      return { message, content: {} };
+    }
+    return {
+      message,
+      content: formattedMessages
+    };
+  };
+  const log = (level, args) => {
+    const messages = Array.isArray(args) ? args : [args];
+    if (level < logLevel) {
+      return;
+    }
+    if (enableRemote && level === 3 /* error */) {
+      const { content = {}, message } = format(messages);
+      if (message) {
+        const log2 = {
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          level: "error",
+          workspace: core.workspace,
+          appName: core?.appName,
+          isBrowser,
+          ...context,
+          message,
+          content
+        };
+        if (isBrowser) {
+          log2.hostname = window.location.hostname;
+          log2.pathname = window.location.pathname;
+          log2.url = window.location.href;
+          log2.page_title = window.document.title;
+          log2.userAgent = window.navigator.userAgent;
+        }
+        batch.ingest(log2);
+      }
+    }
+    const method = getMethodName(level);
+    console[method](...messages);
+  };
+  const debug = (...args) => {
+    log(0 /* debug */, args);
+  };
+  const info = (...args) => {
+    log(1 /* info */, args);
+  };
+  const warn = (...args) => {
+    log(2 /* warn */, args);
+  };
+  const error = (...args) => {
+    log(3 /* error */, args);
+  };
+  return {
+    debug,
+    info,
+    warn,
+    error
+  };
+};
+
+// src/modules/blog.ts
+var createLevoBlogModule = (core, httpClient, audience = null) => {
+  const getAllBlogs = (blog_key, data = {}, options) => {
+    return httpClient.instance.url(`/v1/blog/${blog_key}/post/query`).query({ ...options?.params || {} }).options({
+      headers: {
+        "Levo-Workspace": options?.workspace_id || void 0
+      }
+    }).post(data).json();
+  };
+  const getSingleBlog = (blog_key, slug, options) => {
+    return httpClient.instance.url(`/v1/blog/${blog_key}/post/${slug}`).query({ ...options?.params || {} }).options({
+      headers: {
+        "Levo-Workspace": options?.workspace_id || void 0
+      }
+    }).get().json();
+  };
+  return {
+    getAllBlogs,
+    getSingleBlog
+  };
+};
+
+// src/modules/collection.ts
+var createLevoCollectionModule = (core, httpsClient, audience = null) => {
+  const getAllCollections = async (data = {}, options = {}) => {
+    return httpsClient.instance.url("/v1/bevy/collection/query").options(options).post(data).json();
+  };
+  const getCollectionByIDExpanded = async (id, options = {}) => {
+    return httpsClient.instance.url(`/v1/bevy/collection/${id}`).options(options).get().json();
+  };
+  const createCollection = async (data) => {
+    return httpsClient.instance.url("/v1/bevy/collection").post(data).json();
+  };
+  const saveCollectionData = async ({
+    collection_id,
+    data,
+    options = {}
+  }) => {
+    return httpsClient.instance.url(`/v1/bevy/content/${collection_id}`).options(options).post(data).json();
+  };
+  const getCollectionContentList = async ({
+    collection_key,
+    page,
+    search,
+    limit = 10,
+    where
+  }) => {
+    return httpsClient.instance.url(`/v1/bevy/content/${collection_key}/query`).post({
+      page,
+      limit,
+      search,
+      where
+    }).json();
+  };
+  const saveDraftEntry = async (collection_key, data) => {
+    return httpsClient.instance.url(`/v1/bevy/content/${collection_key}/save-entry`).post(data).json();
+  };
+  const getDraftEntry = async (collection_key) => {
+    return httpsClient.instance.url(`/v1/bevy/content/${collection_key}/list-entry`).get().json();
+  };
+  const submitDraftEntry = async (collection_key, data) => {
+    return httpsClient.instance.url(`/v1/bevy/content/${collection_key}/submit-entry`).post(data).json();
+  };
+  return {
+    getAllCollections,
+    getCollectionByIDExpanded,
+    createCollection,
+    saveCollectionData,
+    getCollectionContentList,
+    saveDraftEntry,
+    getDraftEntry,
+    submitDraftEntry
+  };
+};
+
+// src/modules/media.ts
+var createLevoMediaModule = (core, httpsClient, audience = null) => {
+  const mediaBulkUpload = (formData, options = {}) => {
+    return httpsClient.instance.url("/v1/assets/media/bulk").options(options).post(formData).json();
+  };
+  const getAllMedia = async (data = {}) => {
+    return await httpsClient.instance.url("/v1/assets/media/query").post(data).json();
+  };
+  return {
+    mediaBulkUpload,
+    getAllMedia
+  };
+};
+
+// src/constants/oauthProvider.ts
+var LevoOAuthProviderList = [
+  "google",
+  "linkedin",
+  "microsoft"
+];
+
+// src/modules/membership.ts
+var createLevoMembershipModule = (core, httpsClient, audience = null) => {
+  const getOAuthURL = async (options = {}) => {
+    try {
+      const response = await httpsClient.instance.url("/v1/membership/auth/oauth/get-redirect-url").options(options).get().json();
+      const result = response?.content?.data;
+      const providers = Object.keys(result);
+      if (typeof window !== "undefined") {
+        for (const provider of providers) {
+          const raw_url = result[provider];
+          if (raw_url) {
+            const url = new URL(raw_url);
+            const url_params = url.searchParams;
+            url_params.set("redirect_uri", window.location.href);
+            if (core.workspace) {
+              url_params.set("workspace_id", core.workspace);
+            }
+            if (httpsClient.pageContext) {
+              url_params.set(
+                "page_context",
+                JSON.stringify(httpsClient.pageContext)
+              );
+            }
+            result[provider] = `${url.origin}${url.pathname}?${url_params.toString()}`;
+          }
+        }
+      }
+      return result;
+    } catch (_) {
+      return LevoOAuthProviderList.reduce((acc, provider) => {
+        acc[provider] = null;
+        return acc;
+      }, {});
+    }
+  };
+  const signOut = async (options = {}) => {
+    return httpsClient.instance.url("/v1/membership/auth/sign-out").options(options).post("").json();
+  };
+  const getMe = async (options = {}) => {
+    const response = await httpsClient.instance.url("/v1/membership/auth/get-me").options(options).get().json();
+    return response?.content?.data;
+  };
+  const updateMe = async (data, options = {}) => {
+    const response = await httpsClient.instance.url("/v1/membership/auth/update-me").options(options).put(data).json();
+    return response?.content?.data;
+  };
+  const createPassword = async (data, options = {}) => {
+    const response = await httpsClient.instance.url("/v1/membership/auth/change-password").options(options).put(data).json();
+    return response?.content?.data;
+  };
+  const isLoggedIn = async (options = {}) => {
+    try {
+      const account = await getMe(options);
+      return account;
+    } catch (_) {
+      return null;
+    }
+  };
+  const requestMagicLink = async (data, options = {}) => {
+    if (typeof window !== "undefined" && !data.redirect_uri) {
+      data.redirect_uri = window.location.href;
+    }
+    const response = await httpsClient.instance.url("/v1/membership/auth/request-magic-link").options(options).post(data).json();
+    return response?.content?.data;
+  };
+  const requestOtp = async (data, options = {}) => {
+    const response = await httpsClient.instance.url("/v1/membership/auth/request-otp").options(options).post(data).json();
+    return response?.content?.data;
+  };
+  const signInWithOtp = async (data, options = {}) => {
+    const response = await httpsClient.instance.url("/v1/membership/auth/signin-with-otp").options(options).post(data).json();
+    return response?.content?.data;
+  };
+  const signInWithPassword = async (data, options = {}) => {
+    const response = await httpsClient.instance.url("/v1/membership/auth/signin-with-password").options(options).post(data).json();
+    return response?.content?.data;
+  };
+  const signUpWithPassword = async (data, options = {}) => {
+    const response = await httpsClient.instance.url("/v1/membership/auth/signup-with-password").options(options).post(data).json();
+    return response?.content?.data;
+  };
+  return {
+    getOAuthURL,
+    signOut,
+    getMe,
+    updateMe,
+    createPassword,
+    isLoggedIn,
+    requestMagicLink,
+    requestOtp,
+    signInWithOtp,
+    signInWithPassword,
+    signUpWithPassword
+  };
+};
+
+// src/client.ts
+var createLevoClient = (options) => {
+  const {
+    pageContext = {
+      url: typeof window !== "undefined" ? window?.location?.href : "",
+      referrer: typeof document !== "undefined" ? document?.referrer : "",
+      title: typeof document !== "undefined" ? document?.title : ""
+    },
+    loggerOptions = {
+      logApiUrl: "https://public-api.levo.so"
+    },
+    ...coreOptions
+  } = options;
+  let _pageContext = pageContext;
+  const core = createLevoControl(coreOptions);
+  const httpsClient = createHttpClient(core, _pageContext);
+  const audience = createLevoAudienceModule(core, httpsClient);
+  const blog = createLevoBlogModule(core, httpsClient, audience);
+  const membership = createLevoMembershipModule(core, httpsClient, audience);
+  const collection = createLevoCollectionModule(core, httpsClient, audience);
+  const media = createLevoMediaModule(core, httpsClient, audience);
+  const logger = createLevoLogger(core, loggerOptions);
+  const updatePageContext = (newContext) => {
+    _pageContext = Object.assign({}, _pageContext, newContext);
+  };
+  const updateWorkspace = (workspace) => {
+    core.workspace = workspace;
+  };
+  return {
+    get apiUrl() {
+      return core.apiUrl;
+    },
+    get insightsUrl() {
+      return core.insightsUrl;
+    },
+    get workspace() {
+      return core.workspace;
+    },
+    get audience() {
+      return audience;
+    },
+    get blog() {
+      return blog;
+    },
+    get membership() {
+      return membership;
+    },
+    get collection() {
+      return collection;
+    },
+    get media() {
+      return media;
+    },
+    get logger() {
+      return logger;
+    },
+    get fetch() {
+      return httpsClient.instance;
+    },
+    get APP_MODE() {
+      return core.APP_MODE;
+    },
+    get pageContext() {
+      return _pageContext;
+    },
+    updatePageContext,
+    updateWorkspace
+  };
+};
 
 // src/constants/collection/fieldInterfaceFormat.ts
 var formatsByInterface = {
@@ -297,4 +1351,4 @@ var formatImagePath = (string) => {
   return "";
 };
 
-export { FieldInterfaces, FieldInterfacesList, FieldKind, FieldKindList, LevoClient, MediaKind, MediaKindList, defaultByKinds, formatImagePath, formatsByInterface, interfaceKinds, workspaceIdRegex };
+export { FieldInterfaces, FieldInterfacesList, FieldKind, FieldKindList, LevoError, LevoOAuthProviderList, LocalStorageLock, MediaKind, MediaKindList, createLevoClient, defaultByKinds, formatImagePath, formatsByInterface, getLevoError, interfaceKinds };