@databuddy/sdk 2.3.1 → 2.3.21

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

@@ -0,0 +1,482 @@
+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.DCKr2Zpd.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.DCKr2Zpd.mjs

@@ -0,0 +1,202 @@
+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();
+
+const DEFAULT_RESULT = {
+  enabled: false,
+  value: false,
+  payload: null,
+  reason: "DEFAULT"
+};
+function getCacheKey(key, user) {
+  if (!(user?.userId || user?.email)) {
+    return key;
+  }
+  return `${key}:${user.userId ?? ""}:${user.email ?? ""}`;
+}
+function buildQueryParams(config, user) {
+  const params = new URLSearchParams();
+  params.set("clientId", config.clientId);
+  const u = user ?? config.user;
+  if (u?.userId) {
+    params.set("userId", u.userId);
+  }
+  if (u?.email) {
+    params.set("email", u.email);
+  }
+  if (u?.properties) {
+    params.set("properties", JSON.stringify(u.properties));
+  }
+  if (config.environment) {
+    params.set("environment", config.environment);
+  }
+  return params;
+}
+async function fetchFlags(apiUrl, keys, params) {
+  const batchParams = new URLSearchParams(params);
+  batchParams.set("keys", keys.join(","));
+  const url = `${apiUrl}/public/v1/flags/bulk?${batchParams}`;
+  const response = await fetch(url);
+  if (!response.ok) {
+    const result = {};
+    for (const key of keys) {
+      result[key] = { ...DEFAULT_RESULT, reason: "ERROR" };
+    }
+    return result;
+  }
+  const data = await response.json();
+  return data.flags ?? {};
+}
+async function fetchAllFlags(apiUrl, params) {
+  const url = `${apiUrl}/public/v1/flags/bulk?${params}`;
+  const response = await fetch(url);
+  if (!response.ok) {
+    return {};
+  }
+  const data = await response.json();
+  return data.flags ?? {};
+}
+function isCacheValid(entry) {
+  if (!entry) {
+    return false;
+  }
+  return Date.now() <= entry.expiresAt;
+}
+function isCacheStale(entry) {
+  return Date.now() > entry.staleAt;
+}
+function createCacheEntry(result, ttl, staleTime) {
+  const now = Date.now();
+  return {
+    result,
+    staleAt: now + (staleTime ?? ttl / 2),
+    expiresAt: now + ttl
+  };
+}
+class RequestBatcher {
+  pending = /* @__PURE__ */ new Map();
+  timer = null;
+  batchDelayMs;
+  apiUrl;
+  params;
+  constructor(apiUrl, params, batchDelayMs = 10) {
+    this.apiUrl = apiUrl;
+    this.params = params;
+    this.batchDelayMs = batchDelayMs;
+  }
+  request(key) {
+    return new Promise((resolve, reject) => {
+      const existing = this.pending.get(key);
+      if (existing) {
+        existing.push({ resolve, reject });
+      } else {
+        this.pending.set(key, [{ resolve, reject }]);
+      }
+      if (!this.timer) {
+        this.timer = setTimeout(() => this.flush(), this.batchDelayMs);
+      }
+    });
+  }
+  async flush() {
+    this.timer = null;
+    const keys = [...this.pending.keys()];
+    const callbacks = new Map(this.pending);
+    this.pending.clear();
+    if (keys.length === 0) {
+      return;
+    }
+    try {
+      const results = await fetchFlags(this.apiUrl, keys, this.params);
+      for (const [key, cbs] of callbacks) {
+        const result = results[key] ?? {
+          ...DEFAULT_RESULT,
+          reason: "NOT_FOUND"
+        };
+        for (const cb of cbs) {
+          cb.resolve(result);
+        }
+      }
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error("Fetch failed");
+      for (const cbs of callbacks.values()) {
+        for (const cb of cbs) {
+          cb.reject(error);
+        }
+      }
+    }
+  }
+  destroy() {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    this.pending.clear();
+  }
+}
+
+export { DEFAULT_RESULT as D, RequestBatcher as R, isCacheStale as a, buildQueryParams as b, createCacheEntry as c, fetchAllFlags as f, getCacheKey as g, isCacheValid as i, logger as l };

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>;