@databuddy/sdk 2.1.6 → 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,23 +1,95 @@
 '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 {
   ttl = 24 * 60 * 60 * 1e3;
   // 24 hours in milliseconds
-  async get(key) {
+  get(key) {
     return this.getFromLocalStorage(key);
   }
-  async set(key, value) {
+  set(key, value) {
     this.setToLocalStorage(key, value);
   }
-  async getAll() {
+  getAll() {
     const result = {};
     const now = Date.now();
-    Object.keys(localStorage).filter((key) => key.startsWith("db-flag-")).forEach((key) => {
+    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);
@@ -31,13 +103,16 @@ class FlagStorage {
         }
       } catch {
       }
-    });
+    }
     return result;
   }
-  async clear() {
-    Object.keys(localStorage).filter((key) => key.startsWith("db-flag-")).forEach((key) => {
+  clear() {
+    const keys = Object.keys(localStorage).filter(
+      (key) => key.startsWith("db-flag-")
+    );
+    for (const key of keys) {
       localStorage.removeItem(key);
-    });
+    }
   }
   getFromLocalStorage(key) {
     try {
@@ -75,29 +150,32 @@ class FlagStorage {
     }
     return Date.now() > expiresAt;
   }
-  async delete(key) {
+  delete(key) {
     localStorage.removeItem(`db-flag-${key}`);
   }
-  async deleteMultiple(keys) {
+  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() {
+  cleanupExpired() {
     const now = Date.now();
-    Object.keys(localStorage).filter((key) => key.startsWith("db-flag-")).forEach((key) => {
+    const keys = Object.keys(localStorage).filter(
+      (key) => key.startsWith("db-flag-")
+    );
+    for (const key of keys) {
       try {
         const item = localStorage.getItem(key);
         if (item) {
@@ -109,7 +187,7 @@ class FlagStorage {
       } catch {
         localStorage.removeItem(key);
       }
-    });
+    }
   }
 }
 const flagStorage = new FlagStorage();
@@ -120,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,
@@ -140,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,
@@ -169,24 +243,18 @@ function FlagsProvider({ children, ...config }) {
     if (config2.skipStorage) {
       return;
     }
-    flagStorage.getAll().then((cachedFlags) => {
+    try {
+      const cachedFlags = flagStorage.getAll();
       if (Object.keys(cachedFlags).length > 0) {
         flagsStore.set(
           memoryFlagsAtom,
           cachedFlags
         );
-        if (config2.debug) {
-          console.log(
-            "[Databuddy Flags] Loaded cached flags:",
-            Object.keys(cachedFlags)
-          );
-        }
-      }
-    }).catch((err) => {
-      if (config2.debug) {
-        console.warn("[Databuddy Flags] Error loading cached flags:", err);
+        logger.debug("Loaded cached flags:", Object.keys(cachedFlags));
       }
-    });
+    } catch (err) {
+      logger.warn("Error loading cached flags:", err);
+    }
   };
   return createElement(Provider, { store: flagsStore }, children);
 }
@@ -198,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();
@@ -238,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,
@@ -286,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,
@@ -333,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,
@@ -348,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,
@@ -368,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) {
@@ -425,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();
     }
   }, [
@@ -439,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.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.6",
+  "version": "2.1.75",
   "description": "Official Databuddy Analytics SDK",
   "main": "./dist/core/index.mjs",
   "types": "./dist/core/index.d.ts",