@databuddy/sdk 2.3.0 → 2.3.2

package/dist/shared/@databuddy/sdk.Du7SE7-M.mjs

@@ -0,0 +1,479 @@
+import { l as logger, c as createCacheEntry, i as isCacheValid, b as buildQueryParams, R as RequestBatcher, a as isCacheStale, D as DEFAULT_RESULT, g as getCacheKey, f as fetchAllFlags } from './sdk.3kaCzyfu.mjs';
+
+class BrowserFlagStorage {
+  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);
+      }
+    }
+  }
+}
+
+class CoreFlagsManager {
+  config;
+  storage;
+  onFlagsUpdate;
+  onConfigUpdate;
+  onReady;
+  /** In-memory cache with stale tracking */
+  cache = /* @__PURE__ */ new Map();
+  /** In-flight requests for deduplication */
+  inFlight = /* @__PURE__ */ new Map();
+  /** Request batcher for batching multiple flag requests */
+  batcher = null;
+  /** Ready state */
+  ready = false;
+  /** Visibility state */
+  isVisible = true;
+  /** Visibility listener cleanup */
+  visibilityCleanup;
+  constructor(options) {
+    this.config = this.withDefaults(options.config);
+    this.storage = options.storage;
+    this.onFlagsUpdate = options.onFlagsUpdate;
+    this.onConfigUpdate = options.onConfigUpdate;
+    this.onReady = options.onReady;
+    logger.setDebug(this.config.debug ?? false);
+    logger.debug("FlagsManager initialized", {
+      clientId: this.config.clientId,
+      hasUser: Boolean(this.config.user)
+    });
+    this.setupVisibilityListener();
+    this.initialize();
+  }
+  withDefaults(config) {
+    return {
+      clientId: config.clientId,
+      apiUrl: config.apiUrl ?? "https://api.databuddy.cc",
+      user: config.user,
+      disabled: config.disabled ?? false,
+      debug: config.debug ?? false,
+      skipStorage: config.skipStorage ?? false,
+      isPending: config.isPending,
+      autoFetch: config.autoFetch !== false,
+      environment: config.environment,
+      cacheTtl: config.cacheTtl ?? 6e4,
+      // 1 minute
+      staleTime: config.staleTime ?? 3e4
+      // 30 seconds - revalidate after this
+    };
+  }
+  setupVisibilityListener() {
+    if (typeof document === "undefined") {
+      return;
+    }
+    const handleVisibility = () => {
+      this.isVisible = document.visibilityState === "visible";
+      if (this.isVisible) {
+        this.revalidateStale();
+      }
+    };
+    document.addEventListener("visibilitychange", handleVisibility);
+    this.visibilityCleanup = () => {
+      document.removeEventListener("visibilitychange", handleVisibility);
+    };
+  }
+  async initialize() {
+    if (!this.config.skipStorage && this.storage) {
+      this.loadFromStorage();
+    }
+    if (this.config.autoFetch && !this.config.isPending) {
+      await this.fetchAllFlags();
+    }
+    this.ready = true;
+    this.onReady?.();
+  }
+  loadFromStorage() {
+    if (!this.storage) {
+      return;
+    }
+    try {
+      const stored = this.storage.getAll();
+      const ttl = this.config.cacheTtl ?? 6e4;
+      const staleTime = this.config.staleTime ?? ttl / 2;
+      for (const [key, value] of Object.entries(stored)) {
+        if (value && typeof value === "object") {
+          this.cache.set(key, createCacheEntry(value, ttl, staleTime));
+        }
+      }
+      if (this.cache.size > 0) {
+        logger.debug(`Loaded ${this.cache.size} flags from storage`);
+        this.notifyUpdate();
+      }
+    } catch (err) {
+      logger.warn("Failed to load from storage:", err);
+    }
+  }
+  saveToStorage() {
+    if (!this.storage || this.config.skipStorage) {
+      return;
+    }
+    try {
+      const flags = {};
+      for (const [key, entry] of this.cache) {
+        flags[key] = entry.result;
+      }
+      this.storage.setAll(flags);
+    } catch (err) {
+      logger.warn("Failed to save to storage:", err);
+    }
+  }
+  getFromCache(key) {
+    const cached = this.cache.get(key);
+    if (isCacheValid(cached)) {
+      return cached;
+    }
+    if (cached) {
+      this.cache.delete(key);
+    }
+    return null;
+  }
+  getBatcher() {
+    if (!this.batcher) {
+      const apiUrl = this.config.apiUrl ?? "https://api.databuddy.cc";
+      const params = buildQueryParams(this.config);
+      this.batcher = new RequestBatcher(apiUrl, params);
+    }
+    return this.batcher;
+  }
+  /**
+   * Revalidate stale entries in background
+   */
+  revalidateStale() {
+    const staleKeys = [];
+    for (const [key, entry] of this.cache) {
+      if (isCacheStale(entry)) {
+        staleKeys.push(key.split(":")[0]);
+      }
+    }
+    if (staleKeys.length > 0) {
+      logger.debug(`Revalidating ${staleKeys.length} stale flags`);
+      this.fetchAllFlags().catch(
+        (err) => logger.error("Revalidation error:", err)
+      );
+    }
+  }
+  /**
+   * Fetch a single flag from API with deduplication and batching
+   */
+  async getFlag(key, user) {
+    if (this.config.disabled) {
+      return DEFAULT_RESULT;
+    }
+    if (this.config.isPending) {
+      return { ...DEFAULT_RESULT, reason: "SESSION_PENDING" };
+    }
+    const cacheKey = getCacheKey(key, user ?? this.config.user);
+    const cached = this.getFromCache(cacheKey);
+    if (cached) {
+      if (isCacheStale(cached) && this.isVisible) {
+        this.revalidateFlag(key, cacheKey);
+      }
+      return cached.result;
+    }
+    const existing = this.inFlight.get(cacheKey);
+    if (existing) {
+      logger.debug(`Deduplicating request: ${key}`);
+      return existing;
+    }
+    const promise = this.getBatcher().request(key);
+    this.inFlight.set(cacheKey, promise);
+    try {
+      const result = await promise;
+      const ttl = this.config.cacheTtl ?? 6e4;
+      const staleTime = this.config.staleTime ?? ttl / 2;
+      this.cache.set(cacheKey, createCacheEntry(result, ttl, staleTime));
+      this.notifyUpdate();
+      this.saveToStorage();
+      return result;
+    } finally {
+      this.inFlight.delete(cacheKey);
+    }
+  }
+  async revalidateFlag(key, cacheKey) {
+    if (this.inFlight.has(cacheKey)) {
+      return;
+    }
+    const promise = this.getBatcher().request(key);
+    this.inFlight.set(cacheKey, promise);
+    try {
+      const result = await promise;
+      const ttl = this.config.cacheTtl ?? 6e4;
+      const staleTime = this.config.staleTime ?? ttl / 2;
+      this.cache.set(cacheKey, createCacheEntry(result, ttl, staleTime));
+      this.notifyUpdate();
+      this.saveToStorage();
+      logger.debug(`Revalidated flag: ${key}`);
+    } catch (err) {
+      logger.error(`Revalidation error: ${key}`, err);
+    } finally {
+      this.inFlight.delete(cacheKey);
+    }
+  }
+  /**
+   * Fetch all flags for current user
+   */
+  async fetchAllFlags(user) {
+    if (this.config.disabled || this.config.isPending) {
+      return;
+    }
+    if (!this.isVisible && this.cache.size > 0) {
+      logger.debug("Skipping fetch - tab hidden");
+      return;
+    }
+    const apiUrl = this.config.apiUrl ?? "https://api.databuddy.cc";
+    const params = buildQueryParams(this.config, user);
+    try {
+      const flags = await fetchAllFlags(apiUrl, params);
+      const ttl = this.config.cacheTtl ?? 6e4;
+      const staleTime = this.config.staleTime ?? ttl / 2;
+      for (const [key, result] of Object.entries(flags)) {
+        const cacheKey = getCacheKey(key, user ?? this.config.user);
+        this.cache.set(cacheKey, createCacheEntry(result, ttl, staleTime));
+      }
+      this.ready = true;
+      this.notifyUpdate();
+      this.saveToStorage();
+      logger.debug(`Fetched ${Object.keys(flags).length} flags`);
+    } catch (err) {
+      logger.error("Bulk fetch error:", err);
+    }
+  }
+  /**
+   * Check if flag is enabled (synchronous, returns cached value)
+   * Uses stale-while-revalidate pattern
+   */
+  isEnabled(key) {
+    const cacheKey = getCacheKey(key, this.config.user);
+    const cached = this.getFromCache(cacheKey);
+    if (cached) {
+      if (isCacheStale(cached) && this.isVisible) {
+        this.revalidateFlag(key, cacheKey);
+      }
+      return {
+        on: cached.result.enabled,
+        enabled: cached.result.enabled,
+        status: cached.result.reason === "ERROR" ? "error" : "ready",
+        loading: false,
+        isLoading: false,
+        isReady: true,
+        value: cached.result.value,
+        variant: cached.result.variant
+      };
+    }
+    if (this.inFlight.has(cacheKey)) {
+      return {
+        on: false,
+        enabled: false,
+        status: "loading",
+        loading: true,
+        isLoading: true,
+        isReady: false
+      };
+    }
+    this.getFlag(key).catch(
+      (err) => logger.error(`Background fetch error: ${key}`, err)
+    );
+    return {
+      on: false,
+      enabled: false,
+      status: "loading",
+      loading: true,
+      isLoading: true,
+      isReady: false
+    };
+  }
+  /**
+   * Get flag value with type (synchronous, returns cached or default)
+   */
+  getValue(key, defaultValue) {
+    const cacheKey = getCacheKey(key, this.config.user);
+    const cached = this.getFromCache(cacheKey);
+    if (cached) {
+      if (isCacheStale(cached) && this.isVisible) {
+        this.revalidateFlag(key, cacheKey);
+      }
+      return cached.result.value;
+    }
+    if (!this.inFlight.has(cacheKey)) {
+      this.getFlag(key).catch(
+        (err) => logger.error(`Background fetch error: ${key}`, err)
+      );
+    }
+    return defaultValue ?? false;
+  }
+  /**
+   * Update user context and refresh flags
+   */
+  updateUser(user) {
+    this.config = { ...this.config, user };
+    this.batcher?.destroy();
+    this.batcher = null;
+    this.onConfigUpdate?.(this.config);
+    this.refresh().catch((err) => logger.error("Refresh error:", err));
+  }
+  /**
+   * Refresh all flags
+   */
+  async refresh(forceClear = false) {
+    if (forceClear) {
+      this.cache.clear();
+      this.storage?.clear();
+      this.notifyUpdate();
+    }
+    await this.fetchAllFlags();
+  }
+  /**
+   * Update configuration
+   */
+  updateConfig(config) {
+    const wasDisabled = this.config.disabled;
+    const wasPending = this.config.isPending;
+    this.config = this.withDefaults(config);
+    this.batcher?.destroy();
+    this.batcher = null;
+    this.onConfigUpdate?.(this.config);
+    if ((wasDisabled || wasPending) && !this.config.disabled && !this.config.isPending) {
+      this.fetchAllFlags().catch((err) => logger.error("Fetch error:", err));
+    }
+  }
+  /**
+   * Get all cached flags
+   */
+  getMemoryFlags() {
+    const flags = {};
+    for (const [key, entry] of this.cache) {
+      const flagKey = key.split(":")[0];
+      flags[flagKey] = entry.result;
+    }
+    return flags;
+  }
+  /**
+   * Check if manager is ready
+   */
+  isReady() {
+    return this.ready;
+  }
+  /**
+   * Cleanup resources
+   */
+  destroy() {
+    this.batcher?.destroy();
+    this.visibilityCleanup?.();
+    this.cache.clear();
+    this.inFlight.clear();
+  }
+  notifyUpdate() {
+    this.onFlagsUpdate?.(this.getMemoryFlags());
+  }
+}
+
+export { BrowserFlagStorage as B, CoreFlagsManager as C };

package/dist/shared/@databuddy/sdk.F8Xt1uF7.mjs

@@ -0,0 +1,35 @@
+const version = "2.3.2";
+
+const INJECTED_SCRIPT_ATTRIBUTE = "data-databuddy-injected";
+function isScriptInjected() {
+  return !!document.querySelector(`script[${INJECTED_SCRIPT_ATTRIBUTE}]`);
+}
+function createScript({
+  scriptUrl,
+  sdkVersion,
+  clientSecret,
+  filter,
+  debug,
+  ...props
+}) {
+  const script = document.createElement("script");
+  script.src = scriptUrl || "https://cdn.databuddy.cc/databuddy.js";
+  script.async = true;
+  script.crossOrigin = "anonymous";
+  script.setAttribute(INJECTED_SCRIPT_ATTRIBUTE, "true");
+  script.setAttribute("data-sdk-version", sdkVersion || version);
+  for (const [key, value] of Object.entries(props)) {
+    if (value === void 0 || value === null) {
+      continue;
+    }
+    const dataKey = `data-${key.replace(/([A-Z])/g, "-$1").toLowerCase()}`;
+    if (Array.isArray(value) || value && typeof value === "object") {
+      script.setAttribute(dataKey, JSON.stringify(value));
+    } else {
+      script.setAttribute(dataKey, String(value));
+    }
+  }
+  return script;
+}
+
+export { createScript as c, isScriptInjected as i };

package/dist/vue/index.d.mts

@@ -1,7 +1,7 @@
 import * as vue from 'vue';
 import { App, ComputedRef } from 'vue';
-import { d as FlagsConfig, c as FlagState, b as FlagResult } from '../shared/@databuddy/sdk.OK9Nbqlf.mjs';
-export { e as FlagsContext } from '../shared/@databuddy/sdk.OK9Nbqlf.mjs';
+import { F as FlagsConfig, b as FlagState, d as FlagResult } from '../shared/@databuddy/sdk.B6nwxnPC.mjs';
+export { c as FlagsContext } from '../shared/@databuddy/sdk.B6nwxnPC.mjs';
 
 declare const Databuddy: vue.DefineComponent<{
     clientId?: string | undefined;
@@ -78,9 +78,17 @@ declare function useFlags(): {
 };
 
 interface UseFlagReturn {
+    /** Whether the flag is on */
+    on: ComputedRef<boolean>;
+    /** @deprecated Use `on` instead */
     enabled: ComputedRef<boolean>;
+    /** Whether the flag is loading */
+    loading: ComputedRef<boolean>;
+    /** @deprecated Use `loading` instead */
     isLoading: ComputedRef<boolean>;
+    /** @deprecated Use `status === 'ready'` instead */
     isReady: ComputedRef<boolean>;
+    /** Full flag state */
     state: ComputedRef<FlagState>;
 }
 /**
@@ -89,6 +97,7 @@ interface UseFlagReturn {
 declare function useFlag(key: string): UseFlagReturn;
 /**
  * Vue composable for boolean flag checking
+ * @deprecated Use `useFlag(key).on` instead
  */
 declare function useBooleanFlag(key: string): ComputedRef<boolean>;
 

package/dist/vue/index.d.ts

@@ -1,7 +1,7 @@
 import * as vue from 'vue';
 import { App, ComputedRef } from 'vue';
-import { d as FlagsConfig, c as FlagState, b as FlagResult } from '../shared/@databuddy/sdk.OK9Nbqlf.js';
-export { e as FlagsContext } from '../shared/@databuddy/sdk.OK9Nbqlf.js';
+import { F as FlagsConfig, b as FlagState, d as FlagResult } from '../shared/@databuddy/sdk.B6nwxnPC.js';
+export { c as FlagsContext } from '../shared/@databuddy/sdk.B6nwxnPC.js';
 
 declare const Databuddy: vue.DefineComponent<{
     clientId?: string | undefined;
@@ -78,9 +78,17 @@ declare function useFlags(): {
 };
 
 interface UseFlagReturn {
+    /** Whether the flag is on */
+    on: ComputedRef<boolean>;
+    /** @deprecated Use `on` instead */
     enabled: ComputedRef<boolean>;
+    /** Whether the flag is loading */
+    loading: ComputedRef<boolean>;
+    /** @deprecated Use `loading` instead */
     isLoading: ComputedRef<boolean>;
+    /** @deprecated Use `status === 'ready'` instead */
     isReady: ComputedRef<boolean>;
+    /** Full flag state */
     state: ComputedRef<FlagState>;
 }
 /**
@@ -89,6 +97,7 @@ interface UseFlagReturn {
 declare function useFlag(key: string): UseFlagReturn;
 /**
  * Vue composable for boolean flag checking
+ * @deprecated Use `useFlag(key).on` instead
  */
 declare function useBooleanFlag(key: string): ComputedRef<boolean>;
 

package/dist/vue/index.mjs

@@ -1,5 +1,7 @@
 import { defineComponent, ref, onMounted, onUnmounted, watch, reactive, watchEffect, computed } from 'vue';
-import { i as isScriptInjected, c as createScript, B as BrowserFlagStorage, C as CoreFlagsManager } from '../shared/@databuddy/sdk.Cn2tDA8H.mjs';
+import { i as isScriptInjected, c as createScript } from '../shared/@databuddy/sdk.F8Xt1uF7.mjs';
+import { B as BrowserFlagStorage, C as CoreFlagsManager } from '../shared/@databuddy/sdk.Du7SE7-M.mjs';
+import '../shared/@databuddy/sdk.3kaCzyfu.mjs';
 
 const Databuddy = defineComponent({
   props: {},
@@ -77,7 +79,9 @@ function useFlags() {
   const isEnabled = (key) => manager.isEnabled(key);
   const fetchAllFlags = () => manager.fetchAllFlags();
   const updateUser = (user) => {
-    manager.updateUser(user);
+    if (user) {
+      manager.updateUser(user);
+    }
   };
   const refresh = (forceClear = false) => {
     manager.refresh(forceClear);
@@ -95,26 +99,32 @@ function useFlags() {
   };
 }
 
+const defaultState = {
+  on: false,
+  enabled: false,
+  status: "loading",
+  loading: true,
+  isLoading: true,
+  isReady: false
+};
 function useFlag(key) {
   const { isEnabled } = useFlags();
-  const flagState = ref({
-    enabled: false,
-    isLoading: true,
-    isReady: false
-  });
+  const flagState = ref(defaultState);
   watchEffect(() => {
     flagState.value = isEnabled(key);
   });
   return {
+    on: computed(() => flagState.value.on),
     enabled: computed(() => flagState.value.enabled),
+    loading: computed(() => flagState.value.loading),
     isLoading: computed(() => flagState.value.isLoading),
     isReady: computed(() => flagState.value.isReady),
     state: computed(() => flagState.value)
   };
 }
 function useBooleanFlag(key) {
-  const { enabled } = useFlag(key);
-  return enabled;
+  const { on } = useFlag(key);
+  return on;
 }
 
 export { Databuddy, createFlagsPlugin, useBooleanFlag, useFlag, useFlags };

package/package.json

@@ -1,19 +1,18 @@
 {
   "name": "@databuddy/sdk",
-  "version": "2.3.0",
+  "version": "2.3.2",
   "description": "Official Databuddy Analytics SDK",
   "main": "./dist/core/index.mjs",
   "types": "./dist/core/index.d.ts",
   "license": "MIT",
   "private": false,
+  "sideEffects": false,
+  "type": "module",
   "scripts": {
     "build": "unbuild",
     "test": "bun test",
     "vscode:prepublish": "bun run build"
   },
-  "dependencies": {
-    "jotai": "^2.15.1"
-  },
   "devDependencies": {
     "@ai-sdk/provider": "^2.0.0",
     "@types/node": "^20.0.0",