@databuddy/sdk 2.1.76 → 2.1.78

package/dist/react/index.mjs

@@ -1,233 +1,30 @@
 'use client';
 
-export { D as Databuddy } from '../shared/@databuddy/sdk.DrN7UcWM.mjs';
+export { D as Databuddy } from '../shared/@databuddy/sdk.CHuEu0ou.mjs';
 import { createStore, atom, Provider, useAtom } from 'jotai';
-import { useEffect, createElement } from 'react';
-import '../shared/@databuddy/sdk.D3SKeeIX.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
-  get(key) {
-    return this.getFromLocalStorage(key);
-  }
-  set(key, value) {
-    this.setToLocalStorage(key, value);
-  }
-  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;
-  }
-  clear() {
-    const keys = Object.keys(localStorage).filter(
-      (key) => key.startsWith("db-flag-")
-    );
-    for (const key of keys) {
-      localStorage.removeItem(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;
-  }
-  delete(key) {
-    localStorage.removeItem(`db-flag-${key}`);
-  }
-  deleteMultiple(keys) {
-    for (const key of keys) {
-      localStorage.removeItem(`db-flag-${key}`);
-    }
-  }
-  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) {
-      this.deleteMultiple(removedKeys);
-    }
-    for (const [key, value] of Object.entries(flags)) {
-      this.set(key, value);
-    }
-  }
-  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);
-      }
-    }
-  }
-}
-const flagStorage = new FlagStorage();
+import { useRef, useEffect, createElement } from 'react';
+import { B as BrowserFlagStorage, C as CoreFlagsManager, l as logger } from '../shared/@databuddy/sdk.ItWNeH-Y.mjs';
 
 const flagsStore = createStore();
-const configAtom = atom(null);
+const managerAtom = atom(null);
 const memoryFlagsAtom = atom({});
-const pendingFlagsAtom = atom(/* @__PURE__ */ new Set());
 function FlagsProvider({ children, ...config }) {
-  const debug = config.debug ?? false;
-  logger.setDebug(debug);
-  logger.debug("Provider rendering with config:", {
-    clientId: config.clientId,
-    debug,
-    isPending: config.isPending,
-    hasUser: !!config.user
-  });
+  const managerRef = useRef(null);
   useEffect(() => {
-    const configWithDefaults = {
-      clientId: config.clientId,
-      apiUrl: config.apiUrl ?? "https://api.databuddy.cc",
-      user: config.user,
-      disabled: config.disabled ?? false,
-      debug,
-      skipStorage: config.skipStorage ?? false,
-      isPending: config.isPending,
-      autoFetch: config.autoFetch !== false
-    };
-    flagsStore.set(configAtom, configWithDefaults);
-    logger.debug("Config set on store", {
-      clientId: config.clientId,
-      apiUrl: configWithDefaults.apiUrl,
-      user: config.user,
-      isPending: config.isPending,
-      skipStorage: config.skipStorage ?? false
+    const storage = config.skipStorage ? void 0 : new BrowserFlagStorage();
+    const manager = new CoreFlagsManager({
+      config,
+      storage,
+      onFlagsUpdate: (flags) => {
+        flagsStore.set(memoryFlagsAtom, flags);
+      }
     });
-    if (!(config.skipStorage ?? false)) {
-      loadCachedFlagsImmediate(configWithDefaults);
-      flagStorage.cleanupExpired();
-    }
+    managerRef.current = manager;
+    flagsStore.set(managerAtom, manager);
+    return () => {
+      managerRef.current = null;
+      flagsStore.set(managerAtom, null);
+    };
   }, [
     config.clientId,
     config.apiUrl,
@@ -239,238 +36,64 @@ function FlagsProvider({ children, ...config }) {
     config.isPending,
     config.autoFetch
   ]);
-  const loadCachedFlagsImmediate = (config2) => {
-    if (config2.skipStorage) {
-      return;
-    }
-    try {
-      const cachedFlags = flagStorage.getAll();
-      if (Object.keys(cachedFlags).length > 0) {
-        flagsStore.set(
-          memoryFlagsAtom,
-          cachedFlags
-        );
-        logger.debug("Loaded cached flags:", Object.keys(cachedFlags));
-      }
-    } catch (err) {
-      logger.warn("Error loading cached flags:", err);
+  useEffect(() => {
+    if (managerRef.current) {
+      managerRef.current.updateConfig(config);
     }
-  };
+  }, [
+    config.clientId,
+    config.apiUrl,
+    config.user?.userId,
+    config.user?.email,
+    config.disabled,
+    config.debug,
+    config.skipStorage,
+    config.isPending,
+    config.autoFetch
+  ]);
   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, {
+  const [manager] = useAtom(managerAtom, { store: flagsStore });
+  const [memoryFlags] = useAtom(memoryFlagsAtom, {
     store: flagsStore
   });
-  logger.debug("useFlags called with config:", {
-    hasConfig: !!config,
-    clientId: config?.clientId,
-    isPending: config?.isPending,
-    debug: config?.debug,
-    skipStorage: config?.skipStorage,
+  logger.debug("useFlags called with manager:", {
+    hasManager: !!manager,
     memoryFlagsCount: Object.keys(memoryFlags).length,
     memoryFlags: Object.keys(memoryFlags)
   });
-  const fetchAllFlags = async () => {
-    if (!config) {
-      logger.warn("No config for bulk fetch");
-      return;
-    }
-    if (config.isPending) {
-      logger.debug("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);
-      if (!response.ok) {
-        throw new Error(`HTTP ${response.status}`);
-      }
-      const result = await response.json();
-      logger.debug("Bulk fetch response:", result);
-      if (result.flags) {
-        setMemoryFlags(result.flags);
-        if (!config.skipStorage) {
-          try {
-            flagStorage.setAll(result.flags);
-            logger.debug("Bulk flags synced to cache");
-          } catch (err) {
-            logger.warn("Bulk storage error:", err);
-          }
-        }
-      }
-    } catch (err) {
-      logger.error("Bulk fetch error:", err);
-    }
-  };
-  const fetchFlag = async (key) => {
-    if (!config) {
-      logger.warn(`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()}`;
-    logger.debug(`Fetching: ${key}`);
-    try {
-      const response = await fetch(url);
-      if (!response.ok) {
-        throw new Error(`HTTP ${response.status}`);
-      }
-      const result = await response.json();
-      logger.debug(`Response for ${key}:`, result);
-      setMemoryFlags((prev) => ({ ...prev, [key]: result }));
-      if (!config.skipStorage) {
-        try {
-          flagStorage.set(key, result);
-          logger.debug(`Cached: ${key}`);
-        } catch (err) {
-          logger.warn(`Cache error: ${key}`, err);
-        }
-      }
-      return result;
-    } catch (err) {
-      logger.error(`Fetch error: ${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) => {
-    logger.debug(`Getting: ${key}`);
-    if (config?.isPending) {
-      logger.debug(`Session pending for: ${key}`);
-      return {
-        enabled: false,
-        value: false,
-        payload: null,
-        reason: "SESSION_PENDING"
-      };
-    }
-    if (memoryFlags[key]) {
-      logger.debug(`Memory: ${key}`);
-      return memoryFlags[key];
-    }
-    if (pendingFlags.has(key)) {
-      logger.debug(`Pending: ${key}`);
-      return {
-        enabled: false,
-        value: false,
-        payload: null,
-        reason: "FETCHING"
-      };
-    }
-    if (!config?.skipStorage) {
-      try {
-        const cached = await flagStorage.get(key);
-        if (cached) {
-          logger.debug(`Cache: ${key}`);
-          setMemoryFlags((prev) => ({ ...prev, [key]: cached }));
-          return cached;
-        }
-      } catch (err) {
-        logger.warn(`Storage error: ${key}`, err);
-      }
-    }
-    return fetchFlag(key);
-  };
   const isEnabled = (key) => {
-    if (memoryFlags[key]) {
-      return {
-        enabled: memoryFlags[key].enabled,
-        isLoading: false,
-        isReady: true
-      };
-    }
-    if (pendingFlags.has(key)) {
+    if (!manager) {
       return {
         enabled: false,
-        isLoading: true,
+        isLoading: false,
         isReady: false
       };
     }
-    getFlag(key);
-    return {
-      enabled: false,
-      isLoading: true,
-      isReady: false
-    };
+    return manager.isEnabled(key);
   };
-  const refresh = (forceClear = false) => {
-    logger.debug("Refreshing", { forceClear });
-    if (forceClear) {
-      setMemoryFlags({});
-      if (!config?.skipStorage) {
-        try {
-          flagStorage.clear();
-          logger.debug("Storage cleared");
-        } catch (err) {
-          logger.warn("Storage clear error:", err);
-        }
-      }
+  const fetchAllFlags = () => {
+    if (!manager) {
+      logger.warn("No manager for bulk fetch");
+      return;
     }
-    fetchAllFlags();
+    return manager.fetchAllFlags();
   };
   const updateUser = (user) => {
-    if (config) {
-      flagsStore.set(configAtom, { ...config, user });
-      refresh();
+    if (!manager) {
+      logger.warn("No manager for user update");
+      return;
     }
+    manager.updateUser(user);
   };
-  useEffect(() => {
-    if (config && !config.isPending && config.autoFetch !== false) {
-      logger.debug("Auto-fetching");
-      fetchAllFlags();
+  const refresh = (forceClear = false) => {
+    if (!manager) {
+      logger.warn("No manager for refresh");
+      return;
     }
-  }, [
-    config?.clientId,
-    config?.user?.userId,
-    config?.user?.email,
-    config?.isPending,
-    config?.autoFetch
-  ]);
+    manager.refresh(forceClear);
+  };
   return {
     isEnabled,
     fetchAllFlags,

package/dist/shared/@databuddy/{sdk.DrN7UcWM.mjs → sdk.CHuEu0ou.mjs}

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