@databuddy/sdk 2.1.76 → 2.1.77

package/dist/shared/@databuddy/sdk.DsZMb6-q.mjs

@@ -0,0 +1,465 @@
+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 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 CoreFlagsManager {
+  config;
+  storage;
+  onFlagsUpdate;
+  onConfigUpdate;
+  memoryFlags = {};
+  pendingFlags = /* @__PURE__ */ new Set();
+  constructor(options) {
+    this.config = this.withDefaults(options.config);
+    this.storage = options.storage;
+    this.onFlagsUpdate = options.onFlagsUpdate;
+    this.onConfigUpdate = options.onConfigUpdate;
+    logger.setDebug(this.config.debug ?? false);
+    logger.debug("CoreFlagsManager initialized with config:", {
+      clientId: this.config.clientId,
+      debug: this.config.debug,
+      isPending: this.config.isPending,
+      hasUser: !!this.config.user
+    });
+    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
+    };
+  }
+  async initialize() {
+    if (!this.config.skipStorage && this.storage) {
+      this.loadCachedFlags();
+      this.storage.cleanupExpired();
+    }
+    if (this.config.autoFetch && !this.config.isPending) {
+      await this.fetchAllFlags();
+    }
+  }
+  loadCachedFlags() {
+    if (!this.storage || this.config.skipStorage) {
+      return;
+    }
+    try {
+      const cachedFlags = this.storage.getAll();
+      if (Object.keys(cachedFlags).length > 0) {
+        this.memoryFlags = cachedFlags;
+        this.notifyFlagsUpdate();
+        logger.debug("Loaded cached flags:", Object.keys(cachedFlags));
+      }
+    } catch (err) {
+      logger.warn("Error loading cached flags:", err);
+    }
+  }
+  async fetchAllFlags() {
+    if (this.config.isPending) {
+      logger.debug("Session pending, skipping bulk fetch");
+      return;
+    }
+    const params = new URLSearchParams();
+    params.set("clientId", this.config.clientId);
+    if (this.config.user?.userId) {
+      params.set("userId", this.config.user.userId);
+    }
+    if (this.config.user?.email) {
+      params.set("email", this.config.user.email);
+    }
+    if (this.config.user?.properties) {
+      params.set("properties", JSON.stringify(this.config.user.properties));
+    }
+    const url = `${this.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) {
+        this.memoryFlags = result.flags;
+        this.notifyFlagsUpdate();
+        if (!this.config.skipStorage && this.storage) {
+          try {
+            this.storage.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);
+    }
+  }
+  async getFlag(key) {
+    logger.debug(`Getting: ${key}`);
+    if (this.config.isPending) {
+      logger.debug(`Session pending for: ${key}`);
+      return {
+        enabled: false,
+        value: false,
+        payload: null,
+        reason: "SESSION_PENDING"
+      };
+    }
+    if (this.memoryFlags[key]) {
+      logger.debug(`Memory: ${key}`);
+      return this.memoryFlags[key];
+    }
+    if (this.pendingFlags.has(key)) {
+      logger.debug(`Pending: ${key}`);
+      return {
+        enabled: false,
+        value: false,
+        payload: null,
+        reason: "FETCHING"
+      };
+    }
+    if (!this.config.skipStorage && this.storage) {
+      try {
+        const cached = await this.storage.get(key);
+        if (cached) {
+          logger.debug(`Cache: ${key}`);
+          this.memoryFlags[key] = cached;
+          this.notifyFlagsUpdate();
+          return cached;
+        }
+      } catch (err) {
+        logger.warn(`Storage error: ${key}`, err);
+      }
+    }
+    return this.fetchFlag(key);
+  }
+  async fetchFlag(key) {
+    this.pendingFlags.add(key);
+    const params = new URLSearchParams();
+    params.set("key", key);
+    params.set("clientId", this.config.clientId);
+    if (this.config.user?.userId) {
+      params.set("userId", this.config.user.userId);
+    }
+    if (this.config.user?.email) {
+      params.set("email", this.config.user.email);
+    }
+    if (this.config.user?.properties) {
+      params.set("properties", JSON.stringify(this.config.user.properties));
+    }
+    const url = `${this.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);
+      this.memoryFlags[key] = result;
+      this.notifyFlagsUpdate();
+      if (!this.config.skipStorage && this.storage) {
+        try {
+          this.storage.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"
+      };
+      this.memoryFlags[key] = fallback;
+      this.notifyFlagsUpdate();
+      return fallback;
+    } finally {
+      this.pendingFlags.delete(key);
+    }
+  }
+  isEnabled(key) {
+    if (this.memoryFlags[key]) {
+      return {
+        enabled: this.memoryFlags[key].enabled,
+        isLoading: false,
+        isReady: true
+      };
+    }
+    if (this.pendingFlags.has(key)) {
+      return {
+        enabled: false,
+        isLoading: true,
+        isReady: false
+      };
+    }
+    this.getFlag(key);
+    return {
+      enabled: false,
+      isLoading: true,
+      isReady: false
+    };
+  }
+  refresh(forceClear = false) {
+    logger.debug("Refreshing", { forceClear });
+    if (forceClear) {
+      this.memoryFlags = {};
+      this.notifyFlagsUpdate();
+      if (!this.config.skipStorage && this.storage) {
+        try {
+          this.storage.clear();
+          logger.debug("Storage cleared");
+        } catch (err) {
+          logger.warn("Storage clear error:", err);
+        }
+      }
+    }
+    this.fetchAllFlags();
+  }
+  updateUser(user) {
+    this.config = { ...this.config, user };
+    this.onConfigUpdate?.(this.config);
+    this.refresh();
+  }
+  updateConfig(config) {
+    this.config = this.withDefaults(config);
+    this.onConfigUpdate?.(this.config);
+    if (!this.config.skipStorage && this.storage) {
+      this.loadCachedFlags();
+      this.storage.cleanupExpired();
+    }
+    if (this.config.autoFetch && !this.config.isPending) {
+      this.fetchAllFlags();
+    }
+  }
+  getMemoryFlags() {
+    return { ...this.memoryFlags };
+  }
+  getPendingFlags() {
+    return new Set(this.pendingFlags);
+  }
+  notifyFlagsUpdate() {
+    this.onFlagsUpdate?.(this.getMemoryFlags());
+  }
+}
+
+const version = "2.1.76";
+
+const INJECTED_SCRIPT_ATTRIBUTE = "data-databuddy-injected";
+function isScriptInjected() {
+  return !!document.querySelector(`script[${INJECTED_SCRIPT_ATTRIBUTE}]`);
+}
+function createScript({
+  scriptUrl,
+  sdkVersion,
+  ...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)) {
+    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 { BrowserFlagStorage as B, CoreFlagsManager as C, createScript as c, isScriptInjected as i, logger as l };

package/dist/shared/@databuddy/{sdk.DrN7UcWM.mjs → sdk.VZOaS2Dk.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.DsZMb6-q.mjs';
 
 function detectClientId(providedClientId) {
   if (providedClientId) {

package/dist/shared/@databuddy/sdk.YfiY9DoZ.d.mts

@@ -0,0 +1,64 @@
+interface FlagResult {
+    enabled: boolean;
+    value: boolean;
+    payload: any;
+    reason: string;
+    flagId?: string;
+    flagType?: 'boolean' | 'rollout';
+}
+interface FlagsConfig {
+    /** Client ID for flag evaluation */
+    clientId: string;
+    apiUrl?: string;
+    user?: {
+        userId?: string;
+        email?: string;
+        properties?: Record<string, any>;
+    };
+    disabled?: boolean;
+    /** Enable debug logging */
+    debug?: boolean;
+    /** Skip persistent storage */
+    skipStorage?: boolean;
+    /** Whether session is loading */
+    isPending?: boolean;
+    /** Automatically fetch all flags on initialization (default: true) */
+    autoFetch?: boolean;
+}
+interface FlagState {
+    enabled: boolean;
+    isLoading: boolean;
+    isReady: boolean;
+}
+interface FlagsContext {
+    isEnabled: (key: string) => FlagState;
+    fetchAllFlags: () => Promise<void>;
+    updateUser: (user: FlagsConfig['user']) => void;
+    refresh: (forceClear?: boolean) => Promise<void>;
+}
+interface StorageInterface {
+    get(key: string): any;
+    set(key: string, value: unknown): void;
+    getAll(): Record<string, unknown>;
+    clear(): void;
+    setAll(flags: Record<string, unknown>): void;
+    cleanupExpired(): void;
+}
+interface FlagsManagerOptions {
+    config: FlagsConfig;
+    storage?: StorageInterface;
+    onFlagsUpdate?: (flags: Record<string, FlagResult>) => void;
+    onConfigUpdate?: (config: FlagsConfig) => void;
+}
+interface FlagsManager {
+    getFlag: (key: string) => Promise<FlagResult>;
+    isEnabled: (key: string) => FlagState;
+    fetchAllFlags: () => Promise<void>;
+    updateUser: (user: FlagsConfig['user']) => void;
+    refresh: (forceClear?: boolean) => void;
+    updateConfig: (config: FlagsConfig) => void;
+    getMemoryFlags: () => Record<string, FlagResult>;
+    getPendingFlags: () => Set<string>;
+}
+
+export type { FlagsManager as F, StorageInterface as S, FlagsManagerOptions as a, FlagResult as b, FlagState as c, FlagsConfig as d, FlagsContext as e };

package/dist/shared/@databuddy/sdk.YfiY9DoZ.d.ts

@@ -0,0 +1,64 @@
+interface FlagResult {
+    enabled: boolean;
+    value: boolean;
+    payload: any;
+    reason: string;
+    flagId?: string;
+    flagType?: 'boolean' | 'rollout';
+}
+interface FlagsConfig {
+    /** Client ID for flag evaluation */
+    clientId: string;
+    apiUrl?: string;
+    user?: {
+        userId?: string;
+        email?: string;
+        properties?: Record<string, any>;
+    };
+    disabled?: boolean;
+    /** Enable debug logging */
+    debug?: boolean;
+    /** Skip persistent storage */
+    skipStorage?: boolean;
+    /** Whether session is loading */
+    isPending?: boolean;
+    /** Automatically fetch all flags on initialization (default: true) */
+    autoFetch?: boolean;
+}
+interface FlagState {
+    enabled: boolean;
+    isLoading: boolean;
+    isReady: boolean;
+}
+interface FlagsContext {
+    isEnabled: (key: string) => FlagState;
+    fetchAllFlags: () => Promise<void>;
+    updateUser: (user: FlagsConfig['user']) => void;
+    refresh: (forceClear?: boolean) => Promise<void>;
+}
+interface StorageInterface {
+    get(key: string): any;
+    set(key: string, value: unknown): void;
+    getAll(): Record<string, unknown>;
+    clear(): void;
+    setAll(flags: Record<string, unknown>): void;
+    cleanupExpired(): void;
+}
+interface FlagsManagerOptions {
+    config: FlagsConfig;
+    storage?: StorageInterface;
+    onFlagsUpdate?: (flags: Record<string, FlagResult>) => void;
+    onConfigUpdate?: (config: FlagsConfig) => void;
+}
+interface FlagsManager {
+    getFlag: (key: string) => Promise<FlagResult>;
+    isEnabled: (key: string) => FlagState;
+    fetchAllFlags: () => Promise<void>;
+    updateUser: (user: FlagsConfig['user']) => void;
+    refresh: (forceClear?: boolean) => void;
+    updateConfig: (config: FlagsConfig) => void;
+    getMemoryFlags: () => Record<string, FlagResult>;
+    getPendingFlags: () => Set<string>;
+}
+
+export type { FlagsManager as F, StorageInterface as S, FlagsManagerOptions as a, FlagResult as b, FlagState as c, FlagsConfig as d, FlagsContext as e };

package/dist/vue/index.d.mts

@@ -1,4 +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.YfiY9DoZ.mjs';
+export { e as FlagsContext } from '../shared/@databuddy/sdk.YfiY9DoZ.mjs';
 
 declare const Databuddy: vue.DefineComponent<{
     clientId?: {
@@ -194,4 +197,33 @@ declare const Databuddy: vue.DefineComponent<{
     maskPatterns?: any;
 }>, {}>;
 
-export { Databuddy };
+interface FlagsPluginOptions extends FlagsConfig {
+}
+declare function createFlagsPlugin(options: FlagsPluginOptions): {
+    install(app: App): void;
+};
+declare function useFlags(): {
+    isEnabled: (key: string) => FlagState;
+    fetchAllFlags: () => Promise<void>;
+    updateUser: (user: FlagsConfig["user"]) => void;
+    refresh: (forceClear?: boolean) => void;
+    updateConfig: (config: FlagsConfig) => void;
+    memoryFlags: Record<string, FlagResult>;
+};
+
+interface UseFlagReturn {
+    enabled: ComputedRef<boolean>;
+    isLoading: ComputedRef<boolean>;
+    isReady: ComputedRef<boolean>;
+    state: ComputedRef<FlagState>;
+}
+/**
+ * Vue composable for individual flag usage with reactivity
+ */
+declare function useFlag(key: string): UseFlagReturn;
+/**
+ * Vue composable for boolean flag checking
+ */
+declare function useBooleanFlag(key: string): ComputedRef<boolean>;
+
+export { Databuddy, FlagResult, FlagState, FlagsConfig, createFlagsPlugin, useBooleanFlag, useFlag, useFlags };

package/dist/vue/index.d.ts

@@ -1,4 +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.YfiY9DoZ.js';
+export { e as FlagsContext } from '../shared/@databuddy/sdk.YfiY9DoZ.js';
 
 declare const Databuddy: vue.DefineComponent<{
     clientId?: {
@@ -194,4 +197,33 @@ declare const Databuddy: vue.DefineComponent<{
     maskPatterns?: any;
 }>, {}>;
 
-export { Databuddy };
+interface FlagsPluginOptions extends FlagsConfig {
+}
+declare function createFlagsPlugin(options: FlagsPluginOptions): {
+    install(app: App): void;
+};
+declare function useFlags(): {
+    isEnabled: (key: string) => FlagState;
+    fetchAllFlags: () => Promise<void>;
+    updateUser: (user: FlagsConfig["user"]) => void;
+    refresh: (forceClear?: boolean) => void;
+    updateConfig: (config: FlagsConfig) => void;
+    memoryFlags: Record<string, FlagResult>;
+};
+
+interface UseFlagReturn {
+    enabled: ComputedRef<boolean>;
+    isLoading: ComputedRef<boolean>;
+    isReady: ComputedRef<boolean>;
+    state: ComputedRef<FlagState>;
+}
+/**
+ * Vue composable for individual flag usage with reactivity
+ */
+declare function useFlag(key: string): UseFlagReturn;
+/**
+ * Vue composable for boolean flag checking
+ */
+declare function useBooleanFlag(key: string): ComputedRef<boolean>;
+
+export { Databuddy, FlagResult, FlagState, FlagsConfig, createFlagsPlugin, useBooleanFlag, useFlag, useFlags };