@databuddy/sdk 2.1.5 → 2.1.75

package/dist/core/index.mjs

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

package/dist/react/index.d.mts

@@ -30,9 +30,13 @@ interface FlagsConfig {
     /** Automatically fetch all flags on initialization (default: true) */
     autoFetch?: boolean;
 }
+interface FlagState {
+    enabled: boolean;
+    isLoading: boolean;
+    isReady: boolean;
+}
 interface FlagsContext {
-    isEnabled: (key: string) => boolean | undefined;
-    getValue: (key: string, defaultValue?: boolean) => boolean;
+    isEnabled: (key: string) => FlagState;
     fetchAllFlags: () => Promise<void>;
     updateUser: (user: FlagsConfig['user']) => void;
     refresh: (forceClear?: boolean) => Promise<void>;
@@ -50,12 +54,11 @@ declare function FlagsProvider({ children, ...config }: FlagsProviderProps): rea
     };
 }>;
 declare function useFlags(): {
-    isEnabled: (key: string) => boolean | undefined;
-    getValue: (key: string, defaultValue?: boolean) => boolean;
+    isEnabled: (key: string) => FlagState;
     fetchAllFlags: () => Promise<void>;
     updateUser: (user: FlagsConfig["user"]) => void;
-    refresh: (forceClear?: boolean) => Promise<void>;
+    refresh: (forceClear?: boolean) => void;
 };
 
 export { FlagsProvider, useFlags };
-export type { FlagResult, FlagsConfig, FlagsContext };
+export type { FlagResult, FlagState, FlagsConfig, FlagsContext };

package/dist/react/index.d.ts

@@ -30,9 +30,13 @@ interface FlagsConfig {
     /** Automatically fetch all flags on initialization (default: true) */
     autoFetch?: boolean;
 }
+interface FlagState {
+    enabled: boolean;
+    isLoading: boolean;
+    isReady: boolean;
+}
 interface FlagsContext {
-    isEnabled: (key: string) => boolean | undefined;
-    getValue: (key: string, defaultValue?: boolean) => boolean;
+    isEnabled: (key: string) => FlagState;
     fetchAllFlags: () => Promise<void>;
     updateUser: (user: FlagsConfig['user']) => void;
     refresh: (forceClear?: boolean) => Promise<void>;
@@ -50,12 +54,11 @@ declare function FlagsProvider({ children, ...config }: FlagsProviderProps): rea
     };
 }>;
 declare function useFlags(): {
-    isEnabled: (key: string) => boolean | undefined;
-    getValue: (key: string, defaultValue?: boolean) => boolean;
+    isEnabled: (key: string) => FlagState;
     fetchAllFlags: () => Promise<void>;
     updateUser: (user: FlagsConfig["user"]) => void;
-    refresh: (forceClear?: boolean) => Promise<void>;
+    refresh: (forceClear?: boolean) => void;
 };
 
 export { FlagsProvider, useFlags };
-export type { FlagResult, FlagsConfig, FlagsContext };
+export type { FlagResult, FlagState, FlagsConfig, FlagsContext };

package/dist/react/index.mjs

@@ -1,120 +1,119 @@
 'use client';
 
-export { D as Databuddy } from '../shared/@databuddy/sdk.CG1QeYl0.mjs';
+export { D as Databuddy } from '../shared/@databuddy/sdk.mo6tEgU3.mjs';
 import { createStore, atom, Provider, useAtom } from 'jotai';
 import { useEffect, createElement } from 'react';
-import '../shared/@databuddy/sdk.RYpOP8Ko.mjs';
+import '../shared/@databuddy/sdk.DsZP9wPD.mjs';
+
+class Logger {
+  debugEnabled = false;
+  /**
+   * Enable or disable debug logging
+   */
+  setDebug(enabled) {
+    this.debugEnabled = enabled;
+  }
+  /**
+   * Log debug messages (only when debug is enabled)
+   */
+  debug(...args) {
+    if (this.debugEnabled) {
+      console.log("[Databuddy]", ...args);
+    }
+  }
+  /**
+   * Log info messages (always enabled)
+   */
+  info(...args) {
+    console.info("[Databuddy]", ...args);
+  }
+  /**
+   * Log warning messages (always enabled)
+   */
+  warn(...args) {
+    console.warn("[Databuddy]", ...args);
+  }
+  /**
+   * Log error messages (always enabled)
+   */
+  error(...args) {
+    console.error("[Databuddy]", ...args);
+  }
+  /**
+   * Log with table format (only when debug is enabled)
+   */
+  table(data) {
+    if (this.debugEnabled) {
+      console.table(data);
+    }
+  }
+  /**
+   * Time a function execution (only when debug is enabled)
+   */
+  time(label) {
+    if (this.debugEnabled) {
+      console.time(`[Databuddy] ${label}`);
+    }
+  }
+  /**
+   * End timing a function execution (only when debug is enabled)
+   */
+  timeEnd(label) {
+    if (this.debugEnabled) {
+      console.timeEnd(`[Databuddy] ${label}`);
+    }
+  }
+  /**
+   * Log JSON data (only when debug is enabled)
+   */
+  json(data) {
+    if (this.debugEnabled) {
+      console.log("[Databuddy]", JSON.stringify(data, null, 2));
+    }
+  }
+}
+const logger = new Logger();
 
 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);
-    }
+  get(key) {
+    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);
-    }
+  set(key, value) {
+    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;
-            }
+  getAll() {
+    const result = {};
+    const now = Date.now();
+    const keys = Object.keys(localStorage).filter(
+      (key) => key.startsWith("db-flag-")
+    );
+    for (const key of keys) {
+      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;
+      } 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;
+  clear() {
+    const keys = Object.keys(localStorage).filter(
+      (key) => key.startsWith("db-flag-")
+    );
+    for (const key of keys) {
+      localStorage.removeItem(key);
     }
   }
-  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}`);
@@ -151,80 +150,43 @@ class FlagStorage {
     }
     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}`);
-    }
+  delete(key) {
+    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}`);
-      }
+  deleteMultiple(keys) {
+    for (const key of keys) {
+      localStorage.removeItem(`db-flag-${key}`);
     }
   }
-  async setAll(flags) {
-    const currentFlags = await this.getAll();
+  setAll(flags) {
+    const currentFlags = 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);
+      this.deleteMultiple(removedKeys);
     }
     for (const [key, value] of Object.entries(flags)) {
-      await this.set(key, value);
+      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);
-            }
+  cleanupExpired() {
+    const now = Date.now();
+    const keys = Object.keys(localStorage).filter(
+      (key) => key.startsWith("db-flag-")
+    );
+    for (const key of keys) {
+      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);
         }
-      });
+      } catch {
+        localStorage.removeItem(key);
+      }
     }
   }
 }
@@ -236,14 +198,13 @@ const memoryFlagsAtom = atom({});
 const pendingFlagsAtom = atom(/* @__PURE__ */ new Set());
 function FlagsProvider({ children, ...config }) {
   const debug = config.debug ?? false;
-  if (debug) {
-    console.log("[Databuddy Flags] Provider rendering with config:", {
-      clientId: config.clientId,
-      debug,
-      isPending: config.isPending,
-      hasUser: !!config.user
-    });
-  }
+  logger.setDebug(debug);
+  logger.debug("Provider rendering with config:", {
+    clientId: config.clientId,
+    debug,
+    isPending: config.isPending,
+    hasUser: !!config.user
+  });
   useEffect(() => {
     const configWithDefaults = {
       clientId: config.clientId,
@@ -256,19 +217,16 @@ function FlagsProvider({ children, ...config }) {
       autoFetch: config.autoFetch !== false
     };
     flagsStore.set(configAtom, configWithDefaults);
-    if (debug) {
-      console.log("[Databuddy Flags] Config set on store", {
-        clientId: config.clientId,
-        apiUrl: configWithDefaults.apiUrl,
-        user: config.user,
-        isPending: config.isPending,
-        skipStorage: config.skipStorage ?? false
-      });
-    }
+    logger.debug("Config set on store", {
+      clientId: config.clientId,
+      apiUrl: configWithDefaults.apiUrl,
+      user: config.user,
+      isPending: config.isPending,
+      skipStorage: config.skipStorage ?? false
+    });
     if (!(config.skipStorage ?? false)) {
       loadCachedFlagsImmediate(configWithDefaults);
-      flagStorage.cleanupExpired().catch(() => {
-      });
+      flagStorage.cleanupExpired();
     }
   }, [
     config.clientId,
@@ -286,55 +244,17 @@ function FlagsProvider({ children, ...config }) {
       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 {
-        }
-      }
+      const cachedFlags = flagStorage.getAll();
       if (Object.keys(cachedFlags).length > 0) {
-        flagsStore.set(memoryFlagsAtom, cachedFlags);
-        if (config2.debug) {
-          console.log(
-            "[Databuddy Flags] Loaded cached flags immediately:",
-            Object.keys(cachedFlags)
-          );
-        }
-      }
-    } catch (err) {
-      if (config2.debug) {
-        console.warn(
-          "[Databuddy Flags] Error loading cached flags immediately:",
-          err
+        flagsStore.set(
+          memoryFlagsAtom,
+          cachedFlags
         );
+        logger.debug("Loaded cached flags:", Object.keys(cachedFlags));
       }
+    } catch (err) {
+      logger.warn("Error loading cached flags:", err);
     }
-    flagStorage.getAll().then((cachedFlags) => {
-      if (Object.keys(cachedFlags).length > 0) {
-        flagsStore.set(memoryFlagsAtom, (prev) => ({
-          ...prev,
-          ...cachedFlags
-        }));
-        if (config2.debug) {
-          console.log(
-            "[Databuddy Flags] Loaded cached flags from IndexedDB:",
-            Object.keys(cachedFlags)
-          );
-        }
-      }
-    }).catch((err) => {
-      if (config2.debug) {
-        console.warn("[Databuddy Flags] Error loading from IndexedDB:", err);
-      }
-    });
   };
   return createElement(Provider, { store: flagsStore }, children);
 }
@@ -346,26 +266,22 @@ function useFlags() {
   const [pendingFlags, setPendingFlags] = useAtom(pendingFlagsAtom, {
     store: flagsStore
   });
-  if (config?.debug) {
-    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)
-    });
-  }
+  logger.debug("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");
+      logger.warn("No config for bulk fetch");
       return;
     }
     if (config.isPending) {
-      if (config.debug) {
-        console.log("[Databuddy Flags] Session pending, skipping bulk fetch");
-      }
+      logger.debug("Session pending, skipping bulk fetch");
       return;
     }
     const params = new URLSearchParams();
@@ -386,33 +302,25 @@ function useFlags() {
         throw new Error(`HTTP ${response.status}`);
       }
       const result = await response.json();
-      if (config.debug) {
-        console.log("[Databuddy Flags] Bulk fetch response:", result);
-      }
+      logger.debug("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");
-            }
+            flagStorage.setAll(result.flags);
+            logger.debug("Bulk flags synced to cache");
           } catch (err) {
-            if (config.debug) {
-              console.warn("[Databuddy Flags] Bulk storage error:", err);
-            }
+            logger.warn("Bulk storage error:", err);
           }
         }
       }
     } catch (err) {
-      if (config.debug) {
-        console.error("[Databuddy Flags] Bulk fetch error:", err);
-      }
+      logger.error("Bulk fetch error:", err);
     }
   };
   const fetchFlag = async (key) => {
     if (!config) {
-      console.warn(`[Databuddy Flags] No config for flag: ${key}`);
+      logger.warn(`No config for flag: ${key}`);
       return {
         enabled: false,
         value: false,
@@ -434,36 +342,26 @@ function useFlags() {
       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: ${key}`);
-    }
+    logger.debug(`Fetching: ${key}`);
     try {
       const response = await fetch(url);
       if (!response.ok) {
         throw new Error(`HTTP ${response.status}`);
       }
       const result = await response.json();
-      if (config.debug) {
-        console.log(`[Databuddy Flags] Response for ${key}:`, result);
-      }
+      logger.debug(`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] Cached: ${key}`);
-          }
+          flagStorage.set(key, result);
+          logger.debug(`Cached: ${key}`);
         } catch (err) {
-          if (config.debug) {
-            console.warn(`[Databuddy Flags] Cache error: ${key}`, err);
-          }
+          logger.warn(`Cache error: ${key}`, err);
         }
       }
       return result;
     } catch (err) {
-      if (config.debug) {
-        console.error(`[Databuddy Flags] Fetch error: ${key}`, err);
-      }
+      logger.error(`Fetch error: ${key}`, err);
       const fallback = {
         enabled: false,
         value: false,
@@ -481,13 +379,9 @@ function useFlags() {
     }
   };
   const getFlag = async (key) => {
-    if (config?.debug) {
-      console.log(`[Databuddy Flags] Getting: ${key}`);
-    }
+    logger.debug(`Getting: ${key}`);
     if (config?.isPending) {
-      if (config?.debug) {
-        console.log(`[Databuddy Flags] Session pending for: ${key}`);
-      }
+      logger.debug(`Session pending for: ${key}`);
       return {
         enabled: false,
         value: false,
@@ -496,15 +390,11 @@ function useFlags() {
       };
     }
     if (memoryFlags[key]) {
-      if (config?.debug) {
-        console.log(`[Databuddy Flags] Memory: ${key}`);
-      }
+      logger.debug(`Memory: ${key}`);
       return memoryFlags[key];
     }
     if (pendingFlags.has(key)) {
-      if (config?.debug) {
-        console.log(`[Databuddy Flags] Pending: ${key}`);
-      }
+      logger.debug(`Pending: ${key}`);
       return {
         enabled: false,
         value: false,
@@ -516,54 +406,52 @@ function useFlags() {
       try {
         const cached = await flagStorage.get(key);
         if (cached) {
-          if (config?.debug) {
-            console.log(`[Databuddy Flags] Cache: ${key}`);
-          }
+          logger.debug(`Cache: ${key}`);
           setMemoryFlags((prev) => ({ ...prev, [key]: cached }));
           return cached;
         }
       } catch (err) {
-        if (config?.debug) {
-          console.warn(`[Databuddy Flags] Storage error: ${key}`, err);
-        }
+        logger.warn(`Storage error: ${key}`, err);
       }
     }
     return fetchFlag(key);
   };
   const isEnabled = (key) => {
     if (memoryFlags[key]) {
-      return memoryFlags[key].enabled;
+      return {
+        enabled: memoryFlags[key].enabled,
+        isLoading: false,
+        isReady: true
+      };
     }
-    getFlag(key);
-    return;
-  };
-  const getValue = (key, defaultValue = false) => {
-    if (memoryFlags[key]) {
-      return memoryFlags[key].value ?? defaultValue;
+    if (pendingFlags.has(key)) {
+      return {
+        enabled: false,
+        isLoading: true,
+        isReady: false
+      };
     }
     getFlag(key);
-    return defaultValue;
+    return {
+      enabled: false,
+      isLoading: true,
+      isReady: false
+    };
   };
-  const refresh = async (forceClear = false) => {
-    if (config?.debug) {
-      console.log("[Databuddy Flags] Refreshing", { forceClear });
-    }
+  const refresh = (forceClear = false) => {
+    logger.debug("Refreshing", { forceClear });
     if (forceClear) {
       setMemoryFlags({});
       if (!config?.skipStorage) {
         try {
-          await flagStorage.clear();
-          if (config?.debug) {
-            console.log("[Databuddy Flags] Storage cleared");
-          }
+          flagStorage.clear();
+          logger.debug("Storage cleared");
         } catch (err) {
-          if (config?.debug) {
-            console.warn("[Databuddy Flags] Storage clear error:", err);
-          }
+          logger.warn("Storage clear error:", err);
         }
       }
     }
-    await fetchAllFlags();
+    fetchAllFlags();
   };
   const updateUser = (user) => {
     if (config) {
@@ -573,9 +461,7 @@ function useFlags() {
   };
   useEffect(() => {
     if (config && !config.isPending && config.autoFetch !== false) {
-      if (config.debug) {
-        console.log("[Databuddy Flags] Auto-fetching");
-      }
+      logger.debug("Auto-fetching");
       fetchAllFlags();
     }
   }, [
@@ -587,7 +473,6 @@ function useFlags() {
   ]);
   return {
     isEnabled,
-    getValue,
     fetchAllFlags,
     updateUser,
     refresh

package/dist/shared/@databuddy/{sdk.RYpOP8Ko.mjs → sdk.DsZP9wPD.mjs}

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

package/dist/shared/@databuddy/{sdk.CG1QeYl0.mjs → sdk.mo6tEgU3.mjs}

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

package/dist/vue/index.d.mts

@@ -146,11 +146,11 @@ declare const Databuddy: vue.DefineComponent<{
         required: false;
     } | undefined;
 }, () => null, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<{} & {
+    sdk?: string | undefined;
     clientId?: string | undefined;
     clientSecret?: string | undefined;
     apiUrl?: string | undefined;
     scriptUrl?: string | undefined;
-    sdk?: string | undefined;
     sdkVersion?: string | undefined;
     disabled?: boolean | undefined;
     debug?: boolean | undefined;

package/dist/vue/index.d.ts

@@ -146,11 +146,11 @@ declare const Databuddy: vue.DefineComponent<{
         required: false;
     } | undefined;
 }, () => null, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<{} & {
+    sdk?: string | undefined;
     clientId?: string | undefined;
     clientSecret?: string | undefined;
     apiUrl?: string | undefined;
     scriptUrl?: string | undefined;
-    sdk?: string | undefined;
     sdkVersion?: string | undefined;
     disabled?: boolean | undefined;
     debug?: boolean | undefined;

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.RYpOP8Ko.mjs';
+import { i as isScriptInjected, c as createScript } from '../shared/@databuddy/sdk.DsZP9wPD.mjs';
 
 const Databuddy = defineComponent({
   props: {},

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@databuddy/sdk",
-  "version": "2.1.5",
+  "version": "2.1.75",
   "description": "Official Databuddy Analytics SDK",
   "main": "./dist/core/index.mjs",
   "types": "./dist/core/index.d.ts",