@databuddy/sdk 2.3.30 → 2.4.0

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

@@ -0,0 +1,81 @@
+interface FlagResult {
+    enabled: boolean;
+    value: boolean | string | number;
+    payload: Record<string, unknown> | null;
+    reason: string;
+    variant?: string;
+}
+interface UserContext {
+    userId?: string;
+    email?: string;
+    organizationId?: string;
+    teamId?: string;
+    properties?: Record<string, unknown>;
+}
+interface FlagsConfig {
+    clientId: string;
+    apiUrl?: string;
+    user?: UserContext;
+    disabled?: boolean;
+    debug?: boolean;
+    /** Skip persistent storage (browser only) */
+    skipStorage?: boolean;
+    /** Defer evaluation until session resolves */
+    isPending?: boolean;
+    /** Auto-fetch all flags on init (default: true) */
+    autoFetch?: boolean;
+    environment?: string;
+    /** Cache TTL in ms (default: 60000) */
+    cacheTtl?: number;
+    /** Stale time in ms — revalidate in background after this (default: cacheTtl/2) */
+    staleTime?: number;
+    /** Default values by flag key */
+    defaults?: Record<string, boolean | string | number>;
+}
+type FlagStatus = "loading" | "ready" | "error" | "pending";
+interface FlagState {
+    on: boolean;
+    status: FlagStatus;
+    loading: boolean;
+    value?: boolean | string | number;
+    variant?: string;
+}
+interface FlagsContext {
+    getFlag: (key: string) => FlagState;
+    getValue: <T extends boolean | string | number = boolean>(key: string, defaultValue?: T) => T;
+    isOn: (key: string) => boolean;
+    fetchFlag: (key: string) => Promise<FlagResult>;
+    fetchAllFlags: () => Promise<void>;
+    updateUser: (user: UserContext) => void;
+    refresh: (forceClear?: boolean) => Promise<void>;
+    isReady: boolean;
+}
+interface FlagsSnapshot {
+    flags: Record<string, FlagResult>;
+    isReady: boolean;
+}
+interface StorageInterface {
+    getAll(): Record<string, FlagResult>;
+    setAll(flags: Record<string, FlagResult>): void;
+    clear(): void;
+}
+interface FlagsManagerOptions {
+    config: FlagsConfig;
+    storage?: StorageInterface;
+}
+interface FlagsManager {
+    getFlag(key: string, user?: UserContext): Promise<FlagResult>;
+    isEnabled(key: string): FlagState;
+    getValue<T = boolean | string | number>(key: string, defaultValue?: T): T;
+    fetchAllFlags(user?: UserContext): Promise<void>;
+    updateUser(user: UserContext): void;
+    refresh(forceClear?: boolean): Promise<void>;
+    updateConfig(config: FlagsConfig): void;
+    getMemoryFlags(): Record<string, FlagResult>;
+    isReady(): boolean;
+    destroy(): void;
+    subscribe(callback: () => void): () => void;
+    getSnapshot(): FlagsSnapshot;
+}
+
+export type { FlagsConfig as F, StorageInterface as S, UserContext as U, FlagState as a, FlagsContext as b, FlagResult as c, FlagsManager as d, FlagsManagerOptions as e, FlagsSnapshot as f };

package/dist/vue/index.d.mts

@@ -1,7 +1,7 @@
 import * as vue from 'vue';
 import { App, ComputedRef } from 'vue';
-import { F as FlagsConfig, b as FlagState, d as FlagResult } from '../shared/@databuddy/sdk.CdLp6SQb.mjs';
-export { c as FlagsContext } from '../shared/@databuddy/sdk.CdLp6SQb.mjs';
+import { F as FlagsConfig, a as FlagState, c as FlagResult } from '../shared/@databuddy/sdk.rnu91OSC.mjs';
+export { b as FlagsContext } from '../shared/@databuddy/sdk.rnu91OSC.mjs';
 
 declare const Databuddy: vue.DefineComponent<{
     clientId?: string | undefined;
@@ -16,7 +16,6 @@ declare const Databuddy: vue.DefineComponent<{
     trackAttributes?: boolean | undefined;
     trackOutgoingLinks?: boolean | undefined;
     trackInteractions?: boolean | undefined;
-    trackScrollDepth?: boolean | undefined;
     trackPerformance?: boolean | undefined;
     trackWebVitals?: boolean | undefined;
     trackErrors?: boolean | undefined;
@@ -45,7 +44,6 @@ declare const Databuddy: vue.DefineComponent<{
     trackAttributes?: boolean | undefined;
     trackOutgoingLinks?: boolean | undefined;
     trackInteractions?: boolean | undefined;
-    trackScrollDepth?: boolean | undefined;
     trackPerformance?: boolean | undefined;
     trackWebVitals?: boolean | undefined;
     trackErrors?: boolean | undefined;
@@ -66,39 +64,21 @@ declare const Databuddy: vue.DefineComponent<{
 interface FlagsPluginOptions extends FlagsConfig {
 }
 declare function createFlagsPlugin(options: FlagsPluginOptions): {
-    install(app: App): void;
+    install(_app: App): void;
 };
 declare function useFlags(): {
-    isEnabled: (key: string) => FlagState;
+    getFlag: (key: string) => FlagState;
     fetchAllFlags: () => Promise<void>;
     updateUser: (user: FlagsConfig["user"]) => void;
-    refresh: (forceClear?: boolean) => void;
+    refresh: (forceClear?: boolean) => Promise<void>;
     updateConfig: (config: FlagsConfig) => void;
     memoryFlags: Record<string, FlagResult>;
 };
 
-interface UseFlagReturn {
-    /** Whether the flag is on */
+declare function useFlag(key: string): {
     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>;
-}
-/**
- * Vue composable for individual flag usage with reactivity
- */
-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>;
+};
 
-export { Databuddy, FlagResult, FlagState, FlagsConfig, createFlagsPlugin, useBooleanFlag, useFlag, useFlags };
+export { Databuddy, FlagResult, FlagState, FlagsConfig, createFlagsPlugin, useFlag, useFlags };

package/dist/vue/index.d.ts

@@ -1,7 +1,7 @@
 import * as vue from 'vue';
 import { App, ComputedRef } from 'vue';
-import { F as FlagsConfig, b as FlagState, d as FlagResult } from '../shared/@databuddy/sdk.CdLp6SQb.js';
-export { c as FlagsContext } from '../shared/@databuddy/sdk.CdLp6SQb.js';
+import { F as FlagsConfig, a as FlagState, c as FlagResult } from '../shared/@databuddy/sdk.rnu91OSC.js';
+export { b as FlagsContext } from '../shared/@databuddy/sdk.rnu91OSC.js';
 
 declare const Databuddy: vue.DefineComponent<{
     clientId?: string | undefined;
@@ -16,7 +16,6 @@ declare const Databuddy: vue.DefineComponent<{
     trackAttributes?: boolean | undefined;
     trackOutgoingLinks?: boolean | undefined;
     trackInteractions?: boolean | undefined;
-    trackScrollDepth?: boolean | undefined;
     trackPerformance?: boolean | undefined;
     trackWebVitals?: boolean | undefined;
     trackErrors?: boolean | undefined;
@@ -45,7 +44,6 @@ declare const Databuddy: vue.DefineComponent<{
     trackAttributes?: boolean | undefined;
     trackOutgoingLinks?: boolean | undefined;
     trackInteractions?: boolean | undefined;
-    trackScrollDepth?: boolean | undefined;
     trackPerformance?: boolean | undefined;
     trackWebVitals?: boolean | undefined;
     trackErrors?: boolean | undefined;
@@ -66,39 +64,21 @@ declare const Databuddy: vue.DefineComponent<{
 interface FlagsPluginOptions extends FlagsConfig {
 }
 declare function createFlagsPlugin(options: FlagsPluginOptions): {
-    install(app: App): void;
+    install(_app: App): void;
 };
 declare function useFlags(): {
-    isEnabled: (key: string) => FlagState;
+    getFlag: (key: string) => FlagState;
     fetchAllFlags: () => Promise<void>;
     updateUser: (user: FlagsConfig["user"]) => void;
-    refresh: (forceClear?: boolean) => void;
+    refresh: (forceClear?: boolean) => Promise<void>;
     updateConfig: (config: FlagsConfig) => void;
     memoryFlags: Record<string, FlagResult>;
 };
 
-interface UseFlagReturn {
-    /** Whether the flag is on */
+declare function useFlag(key: string): {
     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>;
-}
-/**
- * Vue composable for individual flag usage with reactivity
- */
-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>;
+};
 
-export { Databuddy, FlagResult, FlagState, FlagsConfig, createFlagsPlugin, useBooleanFlag, useFlag, useFlags };
+export { Databuddy, FlagResult, FlagState, FlagsConfig, createFlagsPlugin, useFlag, useFlags };

package/dist/vue/index.mjs

@@ -1,7 +1,7 @@
 import { defineComponent, ref, onMounted, onUnmounted, watch, reactive, watchEffect, computed } from 'vue';
-import { i as isScriptInjected, c as createScript } from '../shared/@databuddy/sdk.Clxo9P3a.mjs';
-import { B as BrowserFlagStorage, C as CoreFlagsManager } from '../shared/@databuddy/sdk.DE24-JrU.mjs';
-import '../shared/@databuddy/sdk.CALvx07o.mjs';
+import { i as isScriptInjected, c as createScript } from '../shared/@databuddy/sdk.P9GHqNXr.mjs';
+import { B as BrowserFlagStorage } from '../shared/@databuddy/sdk.GM10R1Kp.mjs';
+import { B as BrowserFlagsManager } from '../shared/@databuddy/sdk.Ugr1p2j9.mjs';
 
 const Databuddy = defineComponent({
   props: {},
@@ -39,92 +39,56 @@ const Databuddy = defineComponent({
   }
 });
 
-const FLAGS_SYMBOL = Symbol("flags");
-let globalState = null;
-let globalManager = null;
+let manager = null;
+let state = null;
 function createFlagsPlugin(options) {
   return {
-    install(app) {
+    install(_app) {
       const storage = options.skipStorage ? void 0 : new BrowserFlagStorage();
-      const state = reactive({
-        memoryFlags: {},
-        pendingFlags: /* @__PURE__ */ new Set()
-      });
-      const manager = new CoreFlagsManager({
-        config: options,
-        storage,
-        onFlagsUpdate: (flags) => {
-          state.memoryFlags = flags;
+      state = reactive({ flags: {} });
+      manager = new BrowserFlagsManager({ config: options, storage });
+      manager.subscribe(() => {
+        if (state) {
+          state.flags = manager?.getSnapshot().flags ?? {};
         }
       });
-      globalManager = manager;
-      globalState = state;
-      app.provide(FLAGS_SYMBOL, state);
     }
   };
 }
 function useFlags() {
-  if (!globalState) {
+  if (!manager) {
     throw new Error(
-      "Flags plugin not installed. Install with app.use(createFlagsPlugin(config))"
+      "Flags plugin not installed. Call app.use(createFlagsPlugin(config)) first."
     );
   }
-  if (!globalManager) {
-    throw new Error(
-      "Flags manager not initialized. Please reinstall the plugin."
-    );
-  }
-  const state = globalState;
-  const manager = globalManager;
-  const isEnabled = (key) => manager.isEnabled(key);
-  const fetchAllFlags = () => manager.fetchAllFlags();
-  const updateUser = (user) => {
-    if (user) {
-      manager.updateUser(user);
-    }
-  };
-  const refresh = (forceClear = false) => {
-    manager.refresh(forceClear);
-  };
-  const updateConfig = (config) => {
-    manager.updateConfig(config);
-  };
+  const m = manager;
+  const s = state;
   return {
-    isEnabled,
-    fetchAllFlags,
-    updateUser,
-    refresh,
-    updateConfig,
-    memoryFlags: state.memoryFlags
+    getFlag: (key) => m.isEnabled(key),
+    fetchAllFlags: () => m.fetchAllFlags(),
+    updateUser: (user) => {
+      if (user) {
+        m.updateUser(user);
+      }
+    },
+    refresh: (forceClear = false) => m.refresh(forceClear),
+    updateConfig: (config) => m.updateConfig(config),
+    memoryFlags: s?.flags ?? {}
   };
 }
 
-const defaultState = {
-  on: false,
-  enabled: false,
-  status: "loading",
-  loading: true,
-  isLoading: true,
-  isReady: false
-};
+const defaultState = { on: false, status: "loading", loading: true };
 function useFlag(key) {
-  const { isEnabled } = useFlags();
+  const { getFlag } = useFlags();
   const flagState = ref(defaultState);
   watchEffect(() => {
-    flagState.value = isEnabled(key);
+    flagState.value = getFlag(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 { on } = useFlag(key);
-  return on;
-}
 
-export { Databuddy, createFlagsPlugin, useBooleanFlag, useFlag, useFlags };
+export { Databuddy, createFlagsPlugin, useFlag, useFlags };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@databuddy/sdk",
-  "version": "2.3.30",
+  "version": "2.4.0",
   "description": "Official Databuddy Analytics SDK",
   "main": "./dist/core/index.mjs",
   "types": "./dist/core/index.d.ts",

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

@@ -1,208 +0,0 @@
-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?.organizationId) {
-    params.set("organizationId", u.organizationId);
-  }
-  if (u?.teamId) {
-    params.set("teamId", u.teamId);
-  }
-  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 };