@databuddy/sdk 2.1.0 → 2.1.1

package/dist/core/index.mjs

@@ -1,6 +1,6 @@
-import { D as Databuddy$1 } from '../shared/@databuddy/sdk.B72MFYNj.mjs';
-export { d as detectClientId } from '../shared/@databuddy/sdk.B72MFYNj.mjs';
-export { c as createScript, i as isScriptInjected } from '../shared/@databuddy/sdk.CtTNAIIE.mjs';
+import { D as Databuddy$1 } from '../shared/@databuddy/sdk.B1Fz4Gpw.mjs';
+export { d as detectClientId } from '../shared/@databuddy/sdk.B1Fz4Gpw.mjs';
+export { c as createScript, i as isScriptInjected } from '../shared/@databuddy/sdk.DqscWwcO.mjs';
 
 function isTrackerAvailable() {
   return typeof window !== "undefined" && (!!window.databuddy || !!window.db);

package/dist/react/index.d.mts

@@ -1 +1,61 @@
 export { b as Databuddy } from '../shared/@databuddy/sdk.ClgMzRh8.mjs';
+import * as react from 'react';
+import { ReactNode } from 'react';
+import * as jotai from 'jotai';
+
+interface FlagResult {
+    enabled: boolean;
+    value: boolean;
+    payload: any;
+    reason: string;
+    flagId?: string;
+    flagType?: 'boolean' | 'rollout';
+}
+interface FlagsConfig {
+    /** Client ID for flag evaluation */
+    clientId: string;
+    apiUrl?: string;
+    user?: {
+        userId?: string;
+        email?: string;
+        properties?: Record<string, any>;
+    };
+    disabled?: boolean;
+    /** Enable debug logging */
+    debug?: boolean;
+    /** Skip persistent storage */
+    skipStorage?: boolean;
+    /** Whether session is loading */
+    isPending?: boolean;
+    /** Automatically fetch all flags on initialization (default: true) */
+    autoFetch?: boolean;
+}
+interface FlagsContext {
+    isEnabled: (key: string) => boolean;
+    getValue: (key: string, defaultValue?: boolean) => boolean;
+    fetchAllFlags: () => Promise<void>;
+    updateUser: (user: FlagsConfig['user']) => void;
+    refresh: (forceClear?: boolean) => Promise<void>;
+}
+
+interface FlagsProviderProps extends FlagsConfig {
+    children: ReactNode;
+}
+declare function FlagsProvider({ children, ...config }: FlagsProviderProps): react.FunctionComponentElement<{
+    children?: ReactNode;
+    store?: {
+        get: <Value>(atom: jotai.Atom<Value>) => Value;
+        set: <Value, Args extends unknown[], Result>(atom: jotai.WritableAtom<Value, Args, Result>, ...args: Args) => Result;
+        sub: (atom: jotai.Atom<unknown>, listener: () => void) => () => void;
+    };
+}>;
+declare function useFlags(): {
+    isEnabled: (key: string) => boolean;
+    getValue: (key: string, defaultValue?: boolean) => boolean;
+    fetchAllFlags: () => Promise<void>;
+    updateUser: (user: FlagsConfig["user"]) => void;
+    refresh: (forceClear?: boolean) => Promise<void>;
+};
+
+export { FlagsProvider, useFlags };
+export type { FlagResult, FlagsConfig, FlagsContext };

package/dist/react/index.d.ts

@@ -1 +1,61 @@
 export { b as Databuddy } from '../shared/@databuddy/sdk.ClgMzRh8.js';
+import * as react from 'react';
+import { ReactNode } from 'react';
+import * as jotai from 'jotai';
+
+interface FlagResult {
+    enabled: boolean;
+    value: boolean;
+    payload: any;
+    reason: string;
+    flagId?: string;
+    flagType?: 'boolean' | 'rollout';
+}
+interface FlagsConfig {
+    /** Client ID for flag evaluation */
+    clientId: string;
+    apiUrl?: string;
+    user?: {
+        userId?: string;
+        email?: string;
+        properties?: Record<string, any>;
+    };
+    disabled?: boolean;
+    /** Enable debug logging */
+    debug?: boolean;
+    /** Skip persistent storage */
+    skipStorage?: boolean;
+    /** Whether session is loading */
+    isPending?: boolean;
+    /** Automatically fetch all flags on initialization (default: true) */
+    autoFetch?: boolean;
+}
+interface FlagsContext {
+    isEnabled: (key: string) => boolean;
+    getValue: (key: string, defaultValue?: boolean) => boolean;
+    fetchAllFlags: () => Promise<void>;
+    updateUser: (user: FlagsConfig['user']) => void;
+    refresh: (forceClear?: boolean) => Promise<void>;
+}
+
+interface FlagsProviderProps extends FlagsConfig {
+    children: ReactNode;
+}
+declare function FlagsProvider({ children, ...config }: FlagsProviderProps): react.FunctionComponentElement<{
+    children?: ReactNode;
+    store?: {
+        get: <Value>(atom: jotai.Atom<Value>) => Value;
+        set: <Value, Args extends unknown[], Result>(atom: jotai.WritableAtom<Value, Args, Result>, ...args: Args) => Result;
+        sub: (atom: jotai.Atom<unknown>, listener: () => void) => () => void;
+    };
+}>;
+declare function useFlags(): {
+    isEnabled: (key: string) => boolean;
+    getValue: (key: string, defaultValue?: boolean) => boolean;
+    fetchAllFlags: () => Promise<void>;
+    updateUser: (user: FlagsConfig["user"]) => void;
+    refresh: (forceClear?: boolean) => Promise<void>;
+};
+
+export { FlagsProvider, useFlags };
+export type { FlagResult, FlagsConfig, FlagsContext };

package/dist/react/index.mjs

@@ -1,4 +1,612 @@
 'use client';
 
-export { D as Databuddy } from '../shared/@databuddy/sdk.B72MFYNj.mjs';
-import '../shared/@databuddy/sdk.CtTNAIIE.mjs';
+export { D as Databuddy } from '../shared/@databuddy/sdk.B1Fz4Gpw.mjs';
+import { createStore, atom, Provider, useAtom } from 'jotai';
+import { useEffect, createElement } from 'react';
+import '../shared/@databuddy/sdk.DqscWwcO.mjs';
+
+class FlagStorage {
+  dbName = "databuddy-flags";
+  version = 1;
+  storeName = "flags";
+  ttl = 24 * 60 * 60 * 1e3;
+  // 24 hours in milliseconds
+  async get(key) {
+    try {
+      const db = await this.openDB();
+      const transaction = db.transaction(this.storeName, "readonly");
+      const store = transaction.objectStore(this.storeName);
+      return new Promise((resolve) => {
+        const request = store.get(key);
+        request.onsuccess = () => {
+          const result = request.result;
+          if (result && this.isExpired(result.expiresAt)) {
+            this.delete(key);
+            resolve(null);
+          } else {
+            resolve(result?.value);
+          }
+        };
+        request.onerror = () => resolve(null);
+      });
+    } catch {
+      return this.getFromLocalStorage(key);
+    }
+  }
+  async set(key, value) {
+    try {
+      const db = await this.openDB();
+      const transaction = db.transaction(this.storeName, "readwrite");
+      const store = transaction.objectStore(this.storeName);
+      const expiresAt = Date.now() + this.ttl;
+      store.put({ key, value, timestamp: Date.now(), expiresAt });
+    } catch {
+      this.setToLocalStorage(key, value);
+    }
+  }
+  async getAll() {
+    try {
+      const db = await this.openDB();
+      const transaction = db.transaction(this.storeName, "readonly");
+      const store = transaction.objectStore(this.storeName);
+      return new Promise((resolve) => {
+        const request = store.getAll();
+        request.onsuccess = () => {
+          const result = {};
+          const expiredKeys = [];
+          for (const item of request.result || []) {
+            if (this.isExpired(item.expiresAt)) {
+              expiredKeys.push(item.key);
+            } else {
+              result[item.key] = item.value;
+            }
+          }
+          if (expiredKeys.length > 0) {
+            this.deleteMultiple(expiredKeys);
+          }
+          resolve(result);
+        };
+        request.onerror = () => resolve({});
+      });
+    } catch {
+      const result = {};
+      const now = Date.now();
+      Object.keys(localStorage).filter((key) => key.startsWith("db-flag-")).forEach((key) => {
+        const flagKey = key.replace("db-flag-", "");
+        try {
+          const item = localStorage.getItem(key);
+          if (item) {
+            const parsed = JSON.parse(item);
+            if (parsed.expiresAt && now > parsed.expiresAt) {
+              localStorage.removeItem(key);
+            } else {
+              result[flagKey] = parsed.value || parsed;
+            }
+          }
+        } catch {
+        }
+      });
+      return result;
+    }
+  }
+  async clear() {
+    try {
+      const db = await this.openDB();
+      const transaction = db.transaction(this.storeName, "readwrite");
+      const store = transaction.objectStore(this.storeName);
+      store.clear();
+    } catch {
+      Object.keys(localStorage).filter((key) => key.startsWith("db-flag-")).forEach((key) => {
+        localStorage.removeItem(key);
+      });
+      return;
+    }
+  }
+  async openDB() {
+    return new Promise((resolve, reject) => {
+      const request = indexedDB.open(this.dbName, this.version);
+      request.onerror = () => reject(request.error);
+      request.onsuccess = () => resolve(request.result);
+      request.onupgradeneeded = () => {
+        const db = request.result;
+        if (!db.objectStoreNames.contains(this.storeName)) {
+          db.createObjectStore(this.storeName, { keyPath: "key" });
+        }
+      };
+    });
+  }
+  getFromLocalStorage(key) {
+    try {
+      const item = localStorage.getItem(`db-flag-${key}`);
+      if (!item) {
+        return null;
+      }
+      const parsed = JSON.parse(item);
+      if (parsed.expiresAt) {
+        if (this.isExpired(parsed.expiresAt)) {
+          localStorage.removeItem(`db-flag-${key}`);
+          return null;
+        }
+        return parsed.value;
+      }
+      return parsed;
+    } catch {
+      return null;
+    }
+  }
+  setToLocalStorage(key, value) {
+    try {
+      const item = {
+        value,
+        timestamp: Date.now(),
+        expiresAt: Date.now() + this.ttl
+      };
+      localStorage.setItem(`db-flag-${key}`, JSON.stringify(item));
+    } catch {
+    }
+  }
+  isExpired(expiresAt) {
+    if (!expiresAt) {
+      return false;
+    }
+    return Date.now() > expiresAt;
+  }
+  async delete(key) {
+    try {
+      const db = await this.openDB();
+      const transaction = db.transaction(this.storeName, "readwrite");
+      const store = transaction.objectStore(this.storeName);
+      store.delete(key);
+    } catch {
+      localStorage.removeItem(`db-flag-${key}`);
+    }
+  }
+  async deleteMultiple(keys) {
+    try {
+      const db = await this.openDB();
+      const transaction = db.transaction(this.storeName, "readwrite");
+      const store = transaction.objectStore(this.storeName);
+      for (const key of keys) {
+        store.delete(key);
+      }
+    } catch {
+      for (const key of keys) {
+        localStorage.removeItem(`db-flag-${key}`);
+      }
+    }
+  }
+  async setAll(flags) {
+    const currentFlags = await this.getAll();
+    const currentKeys = Object.keys(currentFlags);
+    const newKeys = Object.keys(flags);
+    const removedKeys = currentKeys.filter((key) => !newKeys.includes(key));
+    if (removedKeys.length > 0) {
+      await this.deleteMultiple(removedKeys);
+    }
+    for (const [key, value] of Object.entries(flags)) {
+      await this.set(key, value);
+    }
+  }
+  async cleanupExpired() {
+    try {
+      const db = await this.openDB();
+      const transaction = db.transaction(this.storeName, "readwrite");
+      const store = transaction.objectStore(this.storeName);
+      return new Promise((resolve) => {
+        const request = store.getAll();
+        request.onsuccess = () => {
+          const expiredKeys = [];
+          for (const item of request.result || []) {
+            if (this.isExpired(item.expiresAt)) {
+              expiredKeys.push(item.key);
+            }
+          }
+          if (expiredKeys.length > 0) {
+            this.deleteMultiple(expiredKeys).then(() => resolve()).catch(() => resolve());
+          } else {
+            resolve();
+          }
+        };
+        request.onerror = () => resolve();
+      });
+    } catch {
+      this.cleanupExpired();
+      const now = Date.now();
+      Object.keys(localStorage).filter((key) => key.startsWith("db-flag-")).forEach((key) => {
+        try {
+          const item = localStorage.getItem(key);
+          if (item) {
+            const parsed = JSON.parse(item);
+            if (parsed.expiresAt && now > parsed.expiresAt) {
+              localStorage.removeItem(key);
+            }
+          }
+        } catch {
+          localStorage.removeItem(key);
+        }
+      });
+    }
+  }
+}
+const flagStorage = new FlagStorage();
+
+const flagsStore = createStore();
+const configAtom = atom(null);
+const memoryFlagsAtom = atom({});
+const pendingFlagsAtom = atom(/* @__PURE__ */ new Set());
+function FlagsProvider({ children, ...config }) {
+  console.log("[Databuddy Flags] Provider rendering with config:", {
+    clientId: config.clientId,
+    debug: config.debug,
+    isPending: config.isPending,
+    hasUser: !!config.user
+  });
+  useEffect(() => {
+    const newConfig = {
+      clientId: config.clientId,
+      apiUrl: config.apiUrl,
+      user: config.user,
+      disabled: config.disabled,
+      debug: config.debug,
+      skipStorage: config.skipStorage,
+      isPending: config.isPending,
+      autoFetch: config.autoFetch
+    };
+    flagsStore.set(configAtom, newConfig);
+    console.log("[Databuddy Flags] Config set on store", {
+      clientId: config.clientId,
+      apiUrl: config.apiUrl,
+      user: config.user,
+      isPending: config.isPending,
+      skipStorage: config.skipStorage
+    });
+    if (!config.skipStorage) {
+      loadCachedFlagsImmediate(newConfig);
+      flagStorage.cleanupExpired().catch(() => {
+      });
+    }
+  }, [
+    config.clientId,
+    config.apiUrl,
+    config.user?.userId,
+    config.user?.email,
+    config.disabled,
+    config.debug,
+    config.skipStorage,
+    config.isPending,
+    config.autoFetch
+  ]);
+  const loadCachedFlagsImmediate = (configToUse) => {
+    if (configToUse.skipStorage) {
+      return;
+    }
+    try {
+      const cachedFlags = {};
+      const flagKeys = Object.keys(localStorage).filter(
+        (key) => key.startsWith("db-flag-")
+      );
+      for (const key of flagKeys) {
+        const flagKey = key.replace("db-flag-", "");
+        try {
+          const value = localStorage.getItem(key);
+          if (value) {
+            cachedFlags[flagKey] = JSON.parse(value);
+          }
+        } catch {
+        }
+      }
+      if (Object.keys(cachedFlags).length > 0) {
+        flagsStore.set(memoryFlagsAtom, cachedFlags);
+        if (configToUse.debug) {
+          console.log(
+            "[Databuddy Flags] Loaded cached flags immediately:",
+            Object.keys(cachedFlags)
+          );
+        }
+      }
+    } catch (err) {
+      if (configToUse.debug) {
+        console.warn(
+          "[Databuddy Flags] Error loading cached flags immediately:",
+          err
+        );
+      }
+    }
+    flagStorage.getAll().then((cachedFlags) => {
+      if (Object.keys(cachedFlags).length > 0) {
+        flagsStore.set(memoryFlagsAtom, (prev) => ({
+          ...prev,
+          ...cachedFlags
+        }));
+        if (configToUse.debug) {
+          console.log(
+            "[Databuddy Flags] Loaded cached flags from IndexedDB:",
+            Object.keys(cachedFlags)
+          );
+        }
+      }
+    }).catch((err) => {
+      if (configToUse.debug) {
+        console.warn("[Databuddy Flags] Error loading from IndexedDB:", err);
+      }
+    });
+  };
+  return createElement(Provider, { store: flagsStore }, children);
+}
+function useFlags() {
+  const [config] = useAtom(configAtom, { store: flagsStore });
+  const [memoryFlags, setMemoryFlags] = useAtom(memoryFlagsAtom, {
+    store: flagsStore
+  });
+  const [pendingFlags, setPendingFlags] = useAtom(pendingFlagsAtom, {
+    store: flagsStore
+  });
+  console.log("[Databuddy Flags] useFlags called with config:", {
+    hasConfig: !!config,
+    clientId: config?.clientId,
+    isPending: config?.isPending,
+    debug: config?.debug,
+    skipStorage: config?.skipStorage,
+    memoryFlagsCount: Object.keys(memoryFlags).length,
+    memoryFlags: Object.keys(memoryFlags)
+  });
+  const fetchAllFlags = async () => {
+    if (!config) {
+      console.warn("[Databuddy Flags] No config for bulk fetch");
+      return;
+    }
+    if (config.isPending) {
+      if (config.debug) {
+        console.log("[Databuddy Flags] Session pending, skipping bulk fetch");
+      }
+      return;
+    }
+    const params = new URLSearchParams();
+    params.set("clientId", config.clientId);
+    if (config.user?.userId) {
+      params.set("userId", config.user.userId);
+    }
+    if (config.user?.email) {
+      params.set("email", config.user.email);
+    }
+    if (config.user?.properties) {
+      params.set("properties", JSON.stringify(config.user.properties));
+    }
+    const url = `${config.apiUrl}/public/v1/flags/bulk?${params.toString()}`;
+    try {
+      const response = await fetch(url, {
+        method: "GET",
+        headers: { Accept: "application/json" }
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}`);
+      }
+      const result = await response.json();
+      if (config.debug) {
+        console.log("[Databuddy Flags] Bulk fetch response:", result);
+      }
+      if (result.flags) {
+        setMemoryFlags(result.flags);
+        if (!config.skipStorage) {
+          try {
+            await flagStorage.setAll(result.flags);
+            if (config.debug) {
+              console.log(
+                "[Databuddy Flags] Bulk flags synced to cache, removed old flags"
+              );
+            }
+          } catch (err) {
+            if (config.debug) {
+              console.warn("[Databuddy Flags] Bulk storage error:", err);
+            }
+          }
+        }
+      }
+    } catch (err) {
+      if (config.debug) {
+        console.error("[Databuddy Flags] Bulk fetch error:", err);
+      }
+    }
+  };
+  const fetchFlag = async (key) => {
+    if (!config) {
+      console.warn(`[Databuddy Flags] No config for flag: ${key}`);
+      return {
+        enabled: false,
+        value: false,
+        payload: null,
+        reason: "NO_CONFIG"
+      };
+    }
+    setPendingFlags((prev) => /* @__PURE__ */ new Set([...prev, key]));
+    const params = new URLSearchParams();
+    params.set("key", key);
+    params.set("clientId", config.clientId);
+    if (config.user?.userId) {
+      params.set("userId", config.user.userId);
+    }
+    if (config.user?.email) {
+      params.set("email", config.user.email);
+    }
+    if (config.user?.properties) {
+      params.set("properties", JSON.stringify(config.user.properties));
+    }
+    const url = `${config.apiUrl}/public/v1/flags/evaluate?${params.toString()}`;
+    if (config.debug) {
+      console.log(`[Databuddy Flags] Fetching from server: ${key}`, { url });
+      console.log(`[Databuddy Flags] Request details for ${key}:`, {
+        hasConfig: !!config,
+        hasUser: !!config.user,
+        userId: config.user?.userId || "MISSING",
+        email: config.user?.email || "MISSING",
+        clientId: config.clientId || "MISSING"
+      });
+    }
+    try {
+      const response = await fetch(url, {
+        method: "GET",
+        headers: { Accept: "application/json" }
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}`);
+      }
+      const result = await response.json();
+      if (config.debug) {
+        console.log(`[Databuddy Flags] Server response for: ${key}`, result);
+      }
+      setMemoryFlags((prev) => ({ ...prev, [key]: result }));
+      if (!config.skipStorage) {
+        try {
+          await flagStorage.set(key, result);
+          if (config.debug) {
+            console.log(`[Databuddy Flags] Stored in cache: ${key}`);
+          }
+        } catch (err) {
+          if (config.debug) {
+            console.warn(`[Databuddy Flags] Storage save error: ${key}`, err);
+          }
+        }
+      }
+      return result;
+    } catch (err) {
+      if (config.debug) {
+        console.error(`[Databuddy Flags] Fetch error for: ${key}`, err);
+      }
+      const fallback = {
+        enabled: false,
+        value: false,
+        payload: null,
+        reason: "ERROR"
+      };
+      setMemoryFlags((prev) => ({ ...prev, [key]: fallback }));
+      return fallback;
+    } finally {
+      setPendingFlags((prev) => {
+        const newSet = new Set(prev);
+        newSet.delete(key);
+        return newSet;
+      });
+    }
+  };
+  const getFlag = async (key) => {
+    if (config?.debug) {
+      console.log(`[Databuddy Flags] Getting flag: ${key}`);
+    }
+    if (config?.isPending) {
+      if (config?.debug) {
+        console.log(
+          `[Databuddy Flags] Session pending, returning default for: ${key}`
+        );
+      }
+      return {
+        enabled: false,
+        value: false,
+        payload: null,
+        reason: "SESSION_PENDING"
+      };
+    }
+    if (memoryFlags[key]) {
+      if (config?.debug) {
+        console.log(
+          `[Databuddy Flags] Found in memory: ${key}`,
+          memoryFlags[key]
+        );
+      }
+      return memoryFlags[key];
+    }
+    if (pendingFlags.has(key)) {
+      if (config?.debug) {
+        console.log(
+          `[Databuddy Flags] Already fetching: ${key}, returning default`
+        );
+      }
+      return {
+        enabled: false,
+        value: false,
+        payload: null,
+        reason: "FETCHING"
+      };
+    }
+    if (!config?.skipStorage) {
+      try {
+        const cached = await flagStorage.get(key);
+        if (cached) {
+          if (config?.debug) {
+            console.log(`[Databuddy Flags] Found in storage: ${key}`, cached);
+          }
+          setMemoryFlags((prev) => ({ ...prev, [key]: cached }));
+          return cached;
+        }
+      } catch (err) {
+        if (config?.debug) {
+          console.warn(`[Databuddy Flags] Storage error for: ${key}`, err);
+        }
+      }
+    }
+    return fetchFlag(key);
+  };
+  const isEnabled = (key) => {
+    if (memoryFlags[key]) {
+      return memoryFlags[key].enabled;
+    }
+    getFlag(key);
+    return false;
+  };
+  const getValue = (key, defaultValue = false) => {
+    if (memoryFlags[key]) {
+      return memoryFlags[key].value ?? defaultValue;
+    }
+    getFlag(key);
+    return defaultValue;
+  };
+  const refresh = async (forceClear = false) => {
+    if (config?.debug) {
+      console.log("[Databuddy Flags] Refreshing all flags", { forceClear });
+    }
+    if (forceClear) {
+      setMemoryFlags({});
+      if (!config?.skipStorage) {
+        try {
+          await flagStorage.clear();
+          if (config?.debug) {
+            console.log("[Databuddy Flags] Storage cleared");
+          }
+        } catch (err) {
+          if (config?.debug) {
+            console.warn("[Databuddy Flags] Storage clear error:", err);
+          }
+        }
+      }
+    }
+    await fetchAllFlags();
+  };
+  const updateUser = (user) => {
+    if (config) {
+      flagsStore.set(configAtom, { ...config, user });
+      refresh();
+    }
+  };
+  useEffect(() => {
+    if (config && !config.isPending && config.autoFetch !== false) {
+      if (config.debug) {
+        console.log("[Databuddy Flags] Auto-fetching flags in background");
+      }
+      fetchAllFlags();
+    }
+  }, [
+    config?.clientId,
+    config?.user?.userId,
+    config?.user?.email,
+    config?.isPending,
+    config?.autoFetch
+  ]);
+  return {
+    isEnabled,
+    getValue,
+    fetchAllFlags,
+    updateUser,
+    refresh
+  };
+}
+
+export { FlagsProvider, useFlags };

package/dist/shared/@databuddy/{sdk.B72MFYNj.mjs → sdk.B1Fz4Gpw.mjs}

@@ -1,4 +1,4 @@
-import { i as isScriptInjected, c as createScript } from './sdk.CtTNAIIE.mjs';
+import { i as isScriptInjected, c as createScript } from './sdk.DqscWwcO.mjs';
 
 function detectClientId(providedClientId) {
   if (providedClientId) {

package/dist/shared/@databuddy/{sdk.CtTNAIIE.mjs → sdk.DqscWwcO.mjs}

@@ -1,4 +1,4 @@
-const version = "2.0.0";
+const version = "2.1.0";
 
 const INJECTED_SCRIPT_ATTRIBUTE = "data-databuddy-injected";
 function isScriptInjected() {

package/dist/vue/index.mjs

@@ -1,5 +1,5 @@
 import { defineComponent, ref, onMounted, onUnmounted, watch } from 'vue';
-import { i as isScriptInjected, c as createScript } from '../shared/@databuddy/sdk.CtTNAIIE.mjs';
+import { i as isScriptInjected, c as createScript } from '../shared/@databuddy/sdk.DqscWwcO.mjs';
 
 const Databuddy = defineComponent({
   props: {},

package/package.json

@@ -1,58 +1,62 @@
-{
-  "name": "@databuddy/sdk",
-  "version": "2.1.0",
-  "description": "Official Databuddy Analytics SDK",
-  "main": "./dist/core/index.mjs",
-  "types": "./dist/core/index.d.ts",
-  "license": "MIT",
-  "private": false,
-  "scripts": {
-    "build": "unbuild"
-  },
-  "devDependencies": {
-    "@types/node": "^20.0.0",
-    "@vitejs/plugin-react": "^5.0.0",
-    "react": "18.0.0",
-    "typescript": "catalog:",
-    "unbuild": "^3.6.1",
-    "vue": "3.0.0",
-    "vue-sfc-transformer": "^0.1.16"
-  },
-  "peerDependencies": {
-    "react": ">=18",
-    "vue": ">=3"
-  },
-  "peerDependenciesMeta": {
-    "react": {
-      "optional": true
-    },
-    "vue": {
-      "optional": true
-    }
-  },
-  "exports": {
-    ".": {
-      "types": "./dist/core/index.d.ts",
-      "import": "./dist/core/index.mjs"
-    },
-    "./react": {
-      "types": "./dist/react/index.d.ts",
-      "import": "./dist/react/index.mjs"
-    },
-    "./vue": {
-      "types": "./dist/vue/index.d.ts",
-      "import": "./dist/vue/index.mjs"
-    }
-  },
-  "files": [
-    "dist"
-  ],
-  "keywords": [
-    "analytics",
-    "tracking",
-    "databuddy",
-    "sdk",
-    "react",
-    "vue"
-  ]
-}
+{
+  "name": "@databuddy/sdk",
+  "version": "2.1.1",
+  "description": "Official Databuddy Analytics SDK",
+  "main": "./dist/core/index.mjs",
+  "types": "./dist/core/index.d.ts",
+  "license": "MIT",
+  "private": false,
+  "scripts": {
+    "build": "unbuild"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "@vitejs/plugin-react": "^5.0.0",
+    "react": "18.0.0",
+    "typescript": "catalog:",
+    "unbuild": "^3.6.1",
+    "vue": "3.0.0",
+    "vue-sfc-transformer": "^0.1.16"
+  },
+  "peerDependencies": {
+    "react": ">=18",
+    "vue": ">=3",
+    "jotai": ">=2.0.0"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    },
+    "vue": {
+      "optional": true
+    },
+    "jotai": {
+      "optional": true
+    }
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/core/index.d.ts",
+      "import": "./dist/core/index.mjs"
+    },
+    "./react": {
+      "types": "./dist/react/index.d.ts",
+      "import": "./dist/react/index.mjs"
+    },
+    "./vue": {
+      "types": "./dist/vue/index.d.ts",
+      "import": "./dist/vue/index.mjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "analytics",
+    "tracking",
+    "databuddy",
+    "sdk",
+    "react",
+    "vue"
+  ]
+}