@databuddy/sdk 2.3.29 → 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.urY7MmVr.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.29",
+  "version": "2.4.0",
   "description": "Official Databuddy Analytics SDK",
   "main": "./dist/core/index.mjs",
   "types": "./dist/core/index.d.ts",
@@ -11,42 +11,31 @@
   "scripts": {
     "build": "unbuild",
     "test": "bun test",
+    "test:e2e": "playwright test",
+    "test:e2e:install": "playwright install",
+    "serve": "bun test-server.ts",
     "vscode:prepublish": "bun run build"
   },
   "devDependencies": {
-    "@ai-sdk/provider": "^3.0.2",
+    "@playwright/test": "^1.58.2",
     "@types/node": "^20.0.0",
+    "@types/react": "catalog:",
     "@vitejs/plugin-react": "^5.0.0",
-    "ai": "^5.0.51",
+    "msw": "^2.11.5",
     "react": "catalog:",
-    "@types/react": "catalog:",
-    "tokenlens": "^2.0.0-alpha.3",
     "typescript": "catalog:",
     "unbuild": "^3.6.1",
-    "vue": ">=3",
-    "msw": "^2.11.5"
+    "vue": ">=3"
   },
   "peerDependencies": {
-    "@ai-sdk/provider": "^2.0.0",
-    "ai": "^5.0.51",
     "react": ">=18",
-    "tokenlens": "^2.0.0-alpha.3",
     "msw": "^2.11.5",
     "vue": ">=3"
   },
   "peerDependenciesMeta": {
-    "@ai-sdk/provider": {
-      "optional": true
-    },
-    "ai": {
-      "optional": true
-    },
     "react": {
       "optional": true
     },
-    "tokenlens": {
-      "optional": true
-    },
     "msw": {
       "optional": true
     },
@@ -70,10 +59,6 @@
     "./node": {
       "types": "./dist/node/index.d.ts",
       "import": "./dist/node/index.mjs"
-    },
-    "./ai/vercel": {
-      "types": "./dist/ai/vercel/index.d.ts",
-      "import": "./dist/ai/vercel/index.mjs"
     }
   },
   "files": [

package/dist/ai/vercel/index.d.mts

@@ -1,236 +0,0 @@
-import { LanguageModelV2, LanguageModelV3 } from '@ai-sdk/provider';
-
-/**
- * Type guards and union types for Vercel AI SDK V2/V3 support
- *
- * Adapted from PostHog's AI SDK implementation:
- * https://github.com/PostHog/posthog-js/tree/main/packages/ai
- */
-
-type LanguageModel = LanguageModelV2 | LanguageModelV3;
-
-/**
- * Content types for input/output arrays
- */
-type MessageContent = {
-    type: "text";
-    text: string;
-} | {
-    type: "reasoning";
-    text: string;
-} | {
-    type: "tool-call";
-    id: string;
-    function: {
-        name: string;
-        arguments: string;
-    };
-} | {
-    type: "tool-result";
-    toolCallId: string;
-    toolName: string;
-    output: unknown;
-    isError?: boolean;
-} | {
-    type: "file";
-    file: string;
-    mediaType: string;
-} | {
-    type: "image";
-    image: string;
-    mediaType: string;
-} | {
-    type: "source";
-    sourceType: string;
-    id: string;
-    url: string;
-    title: string;
-};
-/**
- * Message format for input/output
- */
-interface AIMessage {
-    role: string;
-    content: string | MessageContent[];
-}
-/**
- * Token usage from AI model calls
- */
-interface TokenUsage {
-    inputTokens: number;
-    outputTokens: number;
-    totalTokens: number;
-    cachedInputTokens?: number;
-    cacheCreationInputTokens?: number;
-    reasoningTokens?: number;
-    webSearchCount?: number;
-}
-/**
- * Cost breakdown from TokenLens
- */
-interface TokenCost {
-    inputTokenCostUSD?: number;
-    outputTokenCostUSD?: number;
-    totalTokenCostUSD?: number;
-}
-/**
- * Tool call information
- */
-interface ToolCallInfo {
-    toolCallCount: number;
-    toolResultCount: number;
-    toolCallNames: string[];
-    availableTools?: string[];
-}
-/**
- * Error information for failed AI calls
- */
-interface AIError {
-    name: string;
-    message: string;
-    stack?: string;
-}
-/**
- * Complete AI call log entry
- */
-interface AICall {
-    timestamp: Date;
-    traceId: string;
-    type: "generate" | "stream";
-    model: string;
-    provider: string;
-    finishReason?: string;
-    input: AIMessage[];
-    output: AIMessage[];
-    usage: TokenUsage;
-    cost: TokenCost;
-    tools: ToolCallInfo;
-    error?: AIError;
-    durationMs: number;
-    httpStatus?: number;
-    params?: Record<string, unknown>;
-}
-/**
- * Transport function for sending log entries
- */
-type Transport = (call: AICall) => Promise<void> | void;
-/**
- * Configuration options for Databuddy LLM tracking
- */
-interface DatabuddyLLMOptions {
-    /**
-     * API endpoint for sending logs (should include /llm path)
-     * @default process.env.DATABUDDY_API_URL or 'https://basket.databuddy.cc/llm'
-     */
-    apiUrl?: string;
-    /**
-     * API key for authentication (determines owner - org or user)
-     * @default process.env.DATABUDDY_API_KEY
-     */
-    apiKey?: string;
-    /**
-     * Custom transport function to send log entries
-     * If provided, overrides default HTTP transport
-     */
-    transport?: Transport;
-    /**
-     * Whether to compute costs using TokenLens
-     * @default true
-     */
-    computeCosts?: boolean;
-    /**
-     * Privacy mode - when true, input/output content is not captured
-     * @default false
-     */
-    privacyMode?: boolean;
-    /**
-     * Maximum size for input/output content in bytes
-     * @default 1048576 (1MB)
-     */
-    maxContentSize?: number;
-    /**
-     * Called on successful AI calls
-     */
-    onSuccess?: (call: AICall) => void;
-    /**
-     * Called on failed AI calls
-     */
-    onError?: (call: AICall) => void;
-}
-/**
- * Configuration options for tracking individual models
- */
-interface TrackOptions {
-    /**
-     * Transport function to send log entries
-     * If not provided, uses the transport from DatabuddyLLM instance
-     */
-    transport?: Transport;
-    /**
-     * Trace ID to link related calls together
-     */
-    traceId?: string;
-    /**
-     * Whether to compute costs using TokenLens
-     * @default true
-     */
-    computeCosts?: boolean;
-    /**
-     * Privacy mode - when true, input/output content is not captured
-     * @default false
-     */
-    privacyMode?: boolean;
-    /**
-     * Called on successful AI calls
-     */
-    onSuccess?: (call: AICall) => void;
-    /**
-     * Called on failed AI calls
-     */
-    onError?: (call: AICall) => void;
-}
-
-/**
- * Create an HTTP transport that sends logs to an API endpoint
- *
- * @example
- * ```ts
- * import { databuddyLLM, httpTransport } from "@databuddy/sdk/ai/vercel";
- *
- * const { track } = databuddyLLM({
- *   transport: httpTransport("https://api.example.com/ai-logs", "api-key"),
- * });
- * ```
- */
-declare const httpTransport: (url: string, apiKey?: string) => Transport;
-
-/**
- * Vercel AI SDK middleware for Databuddy
- *
- * Inspired by and adapted from PostHog's AI SDK implementation:
- * https://github.com/PostHog/posthog-js/tree/main/packages/ai
- */
-
-/**
- * Create a Databuddy LLM tracking instance
- *
- * @example
- * ```ts
- * import { databuddyLLM } from "@databuddy/sdk/ai/vercel";
- *
- * const { track } = databuddyLLM({ apiKey: "your-api-key" });
- * const model = track(openai("gpt-4"));
- * ```
- */
-declare const databuddyLLM: (options?: DatabuddyLLMOptions) => {
-    track: <T extends LanguageModel>(model: T, trackOptions?: TrackOptions) => T;
-    transport: Transport;
-};
-
-/**
- * Generate a simple trace ID
- */
-declare const generateTraceId: () => string;
-
-export { databuddyLLM, generateTraceId, httpTransport };
-export type { AICall, AIError, DatabuddyLLMOptions, TokenCost, TokenUsage, ToolCallInfo, TrackOptions, Transport };