@databuddy/sdk 2.3.1 → 2.3.21

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.ByNF_UxE.mjs';
+import { i as isScriptInjected, c as createScript } from '../shared/@databuddy/sdk.C8vEu9Y4.mjs';
+import { B as BrowserFlagStorage, C as CoreFlagsManager } from '../shared/@databuddy/sdk.D0dyEsAb.mjs';
+import '../shared/@databuddy/sdk.DCKr2Zpd.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.1",
+  "version": "2.3.21",
   "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",

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

@@ -1,25 +0,0 @@
-function detectClientId(providedClientId) {
-  if (providedClientId) {
-    return providedClientId;
-  }
-  if (typeof process !== "undefined" && process.env) {
-    return process.env.NEXT_PUBLIC_DATABUDDY_CLIENT_ID || process.env.NUXT_PUBLIC_DATABUDDY_CLIENT_ID || process.env.VITE_DATABUDDY_CLIENT_ID || process.env.REACT_APP_DATABUDDY_CLIENT_ID;
-  }
-  if (typeof window !== "undefined") {
-    const nextEnv = window.__NEXT_DATA__?.env?.NEXT_PUBLIC_DATABUDDY_CLIENT_ID;
-    if (nextEnv) {
-      return nextEnv;
-    }
-    const nuxtEnv = window.__NUXT__?.env?.NUXT_PUBLIC_DATABUDDY_CLIENT_ID;
-    if (nuxtEnv) {
-      return nuxtEnv;
-    }
-    const viteEnv = window.__VITE_ENV__?.VITE_DATABUDDY_CLIENT_ID;
-    if (viteEnv) {
-      return viteEnv;
-    }
-  }
-  return;
-}
-
-export { detectClientId as d };

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

@@ -1,471 +0,0 @@
-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.3.0";
-
-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 { BrowserFlagStorage as B, CoreFlagsManager as C, createScript as c, isScriptInjected as i, logger as l };

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

@@ -1,64 +0,0 @@
-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 };