@databuddy/sdk 2.3.2 → 2.3.22

package/dist/react/index.d.ts

@@ -1,4 +1,5 @@
-import { D as DatabuddyConfig } from '../shared/@databuddy/sdk.C9b3SVYK.js';
+import { D as DatabuddyConfig } from '../shared/@databuddy/sdk.BsF1xr6_.js';
+export { c as clear, f as flush, d as getAnonymousId, e as getSessionId, g as getTracker, h as getTrackingIds, j as getTrackingParams, i as isTrackerAvailable, t as track, b as trackError } from '../shared/@databuddy/sdk.BsF1xr6_.js';
 import React, { ReactNode } from 'react';
 import { F as FlagsConfig, a as FeatureState, b as FlagState, c as FlagsContext } from '../shared/@databuddy/sdk.B6nwxnPC.js';
 

package/dist/react/index.mjs

@@ -1,10 +1,11 @@
 'use client';
 
-import { i as isScriptInjected, c as createScript } from '../shared/@databuddy/sdk.F8Xt1uF7.mjs';
-import { d as detectClientId } from '../shared/@databuddy/sdk.BUsPV0LH.mjs';
+import { detectClientId } from '../core/index.mjs';
+export { clear, flush, getAnonymousId, getSessionId, getTracker, getTrackingIds, getTrackingParams, isTrackerAvailable, track, trackError } from '../core/index.mjs';
+import { i as isScriptInjected, c as createScript } from '../shared/@databuddy/sdk.C8vEu9Y4.mjs';
 import React, { useRef, useMemo, useEffect, useSyncExternalStore, createContext, useContext } from 'react';
-import { B as BrowserFlagStorage, C as CoreFlagsManager } from '../shared/@databuddy/sdk.Du7SE7-M.mjs';
-import { l as logger } from '../shared/@databuddy/sdk.3kaCzyfu.mjs';
+import { B as BrowserFlagStorage, C as CoreFlagsManager } from '../shared/@databuddy/sdk.DBtQ5j2L.mjs';
+import { l as logger } from '../shared/@databuddy/sdk.DCKr2Zpd.mjs';
 
 function Databuddy(props) {
   const clientId = detectClientId(props.clientId);

package/dist/shared/@databuddy/{sdk.C9b3SVYK.d.mts → sdk.BsF1xr6_.d.mts}

@@ -361,4 +361,227 @@ type TrackFunction = <T extends EventName>(eventName: T, properties?: Properties
 type ScreenViewFunction = (properties?: Record<string, unknown>) => void;
 type SetGlobalPropertiesFunction = (properties: EventProperties) => void;
 
-export type { BaseEventProperties as B, DatabuddyConfig as D, EventProperties as E, PropertiesForEvent as P, ScreenViewFunction as S, TrackFunction as T, DatabuddyTracker as a, EventTypeMap as b, EventName as c, DataAttributes as d, SetGlobalPropertiesFunction as e };
+/**
+ * Checks if the Databuddy tracker script has loaded and is available.
+ * Use this before calling tracking functions in conditional scenarios.
+ *
+ * @returns `true` if tracker is available, `false` if not loaded or on server
+ *
+ * @example
+ * ```ts
+ * import { isTrackerAvailable, track } from "@databuddy/sdk";
+ *
+ * if (isTrackerAvailable()) {
+ *   track("feature_used", { feature: "export" });
+ * }
+ * ```
+ */
+declare function isTrackerAvailable(): boolean;
+/**
+ * Returns the raw Databuddy tracker instance for advanced use cases.
+ * Prefer using the exported functions (`track`, `flush`, etc.) instead.
+ *
+ * @returns Tracker instance or `null` if not available
+ *
+ * @example
+ * ```ts
+ * import { getTracker, getAnonymousId, getSessionId } from "@databuddy/sdk";
+ *
+ * const tracker = getTracker();
+ * if (tracker) {
+ *   // Access tracker methods
+ *   tracker.track("event", { prop: "value" });
+ *
+ *   // Get IDs using dedicated functions
+ *   const anonId = getAnonymousId();
+ *   const sessionId = getSessionId();
+ * }
+ * ```
+ */
+declare function getTracker(): DatabuddyTracker | null;
+/**
+ * Tracks a custom event with optional properties.
+ * Events are batched and sent efficiently to minimize network overhead.
+ * Safe to call on server (no-op) or before tracker loads.
+ *
+ * @param name - Event name (e.g., "button_click", "purchase", "signup")
+ * @param properties - Key-value pairs of event data
+ *
+ * @example
+ * ```ts
+ * import { track } from "@databuddy/sdk";
+ *
+ * // Simple event
+ * track("signup_started");
+ *
+ * // Event with properties
+ * track("item_purchased", {
+ *   itemId: "sku-123",
+ *   price: 29.99,
+ *   currency: "USD"
+ * });
+ *
+ * // In a React component
+ * function CheckoutButton() {
+ *   return (
+ *     <button onClick={() => track("checkout_clicked", { cartSize: 3 })}>
+ *       Checkout
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+declare function track(name: string, properties?: Record<string, unknown>): void;
+/** @deprecated Use `track()` instead. Will be removed in v3.0. */
+declare function trackCustomEvent(name: string, properties?: Record<string, unknown>): void;
+/**
+ * Clears the current user session and generates new anonymous/session IDs.
+ * Use after logout to ensure the next user gets a fresh identity.
+ *
+ * @example
+ * ```ts
+ * import { clear } from "@databuddy/sdk";
+ *
+ * async function handleLogout() {
+ *   await signOut();
+ *   clear(); // Reset tracking identity
+ *   router.push("/login");
+ * }
+ * ```
+ */
+declare function clear(): void;
+/**
+ * Forces all queued events to be sent immediately.
+ * Useful before navigation or when you need to ensure events are captured.
+ *
+ * @example
+ * ```ts
+ * import { track, flush } from "@databuddy/sdk";
+ *
+ * function handleExternalLink(url: string) {
+ *   track("external_link_clicked", { url });
+ *   flush(); // Ensure event is sent before leaving
+ *   window.location.href = url;
+ * }
+ * ```
+ */
+declare function flush(): void;
+/**
+ * Tracks an error event. Convenience wrapper around `track("error", ...)`.
+ *
+ * @param message - Error message
+ * @param properties - Additional error context (filename, line number, stack trace)
+ *
+ * @example
+ * ```ts
+ * import { trackError } from "@databuddy/sdk";
+ *
+ * try {
+ *   await riskyOperation();
+ * } catch (error) {
+ *   trackError(error.message, {
+ *     stack: error.stack,
+ *     error_type: error.name,
+ *     context: "checkout_flow"
+ *   });
+ * }
+ * ```
+ */
+declare function trackError(message: string, properties?: {
+    filename?: string;
+    lineno?: number;
+    colno?: number;
+    stack?: string;
+    error_type?: string;
+    [key: string]: string | number | boolean | null | undefined;
+}): void;
+/**
+ * Gets the anonymous user ID. Persists across sessions via localStorage.
+ * Useful for server-side identification or cross-domain tracking.
+ *
+ * @param urlParams - Optional URLSearchParams to check for `anonId` param (highest priority)
+ * @returns Anonymous ID or `null` if unavailable
+ *
+ * Priority: URL params → tracker instance → localStorage
+ *
+ * @example
+ * ```ts
+ * import { getAnonymousId } from "@databuddy/sdk";
+ *
+ * // Get from tracker
+ * const anonId = getAnonymousId();
+ *
+ * // Check URL params first (for cross-domain tracking)
+ * const params = new URLSearchParams(window.location.search);
+ * const anonId = getAnonymousId(params);
+ *
+ * // Pass to server
+ * await fetch("/api/identify", {
+ *   body: JSON.stringify({ anonId })
+ * });
+ * ```
+ */
+declare function getAnonymousId(urlParams?: URLSearchParams): string | null;
+/**
+ * Gets the current session ID. Resets after 30 min of inactivity.
+ * Useful for correlating events within a single browsing session.
+ *
+ * @param urlParams - Optional URLSearchParams to check for `sessionId` param (highest priority)
+ * @returns Session ID or `null` if unavailable
+ *
+ * Priority: URL params → tracker instance → sessionStorage
+ *
+ * @example
+ * ```ts
+ * import { getSessionId } from "@databuddy/sdk";
+ *
+ * const sessionId = getSessionId();
+ * console.log("Current session:", sessionId);
+ * ```
+ */
+declare function getSessionId(urlParams?: URLSearchParams): string | null;
+/**
+ * Gets both anonymous ID and session ID in a single call.
+ *
+ * @param urlParams - Optional URLSearchParams to check for tracking params
+ * @returns Object with `anonId` and `sessionId` (either may be null)
+ *
+ * @example
+ * ```ts
+ * import { getTrackingIds } from "@databuddy/sdk";
+ *
+ * const { anonId, sessionId } = getTrackingIds();
+ *
+ * // Send to your backend
+ * await api.identify({ anonId, sessionId, userId: user.id });
+ * ```
+ */
+declare function getTrackingIds(urlParams?: URLSearchParams): {
+    anonId: string | null;
+    sessionId: string | null;
+};
+/**
+ * Returns tracking IDs as a URL query string for cross-domain tracking.
+ * Append to URLs when linking to other domains you own.
+ *
+ * @param urlParams - Optional URLSearchParams to preserve existing params
+ * @returns Query string like `"anonId=xxx&sessionId=yyy"` or empty string
+ *
+ * @example
+ * ```ts
+ * import { getTrackingParams } from "@databuddy/sdk";
+ *
+ * // Link to subdomain with tracking continuity
+ * const params = getTrackingParams();
+ * const url = `https://app.example.com/dashboard${params ? `?${params}` : ""}`;
+ *
+ * // In a component
+ * <a href={`https://shop.example.com?${getTrackingParams()}`}>
+ *   Visit Shop
+ * </a>
+ * ```
+ */
+declare function getTrackingParams(urlParams?: URLSearchParams): string;
+
+export { trackCustomEvent as a, trackError as b, clear as c, getAnonymousId as d, getSessionId as e, flush as f, getTracker as g, getTrackingIds as h, isTrackerAvailable as i, getTrackingParams as j, track as t };
+export type { BaseEventProperties as B, DatabuddyConfig as D, EventProperties as E, PropertiesForEvent as P, ScreenViewFunction as S, TrackFunction as T, EventTypeMap as k, EventName as l, DatabuddyTracker as m, DataAttributes as n, SetGlobalPropertiesFunction as o };

package/dist/shared/@databuddy/{sdk.C9b3SVYK.d.ts → sdk.BsF1xr6_.d.ts}

@@ -361,4 +361,227 @@ type TrackFunction = <T extends EventName>(eventName: T, properties?: Properties
 type ScreenViewFunction = (properties?: Record<string, unknown>) => void;
 type SetGlobalPropertiesFunction = (properties: EventProperties) => void;
 
-export type { BaseEventProperties as B, DatabuddyConfig as D, EventProperties as E, PropertiesForEvent as P, ScreenViewFunction as S, TrackFunction as T, DatabuddyTracker as a, EventTypeMap as b, EventName as c, DataAttributes as d, SetGlobalPropertiesFunction as e };
+/**
+ * Checks if the Databuddy tracker script has loaded and is available.
+ * Use this before calling tracking functions in conditional scenarios.
+ *
+ * @returns `true` if tracker is available, `false` if not loaded or on server
+ *
+ * @example
+ * ```ts
+ * import { isTrackerAvailable, track } from "@databuddy/sdk";
+ *
+ * if (isTrackerAvailable()) {
+ *   track("feature_used", { feature: "export" });
+ * }
+ * ```
+ */
+declare function isTrackerAvailable(): boolean;
+/**
+ * Returns the raw Databuddy tracker instance for advanced use cases.
+ * Prefer using the exported functions (`track`, `flush`, etc.) instead.
+ *
+ * @returns Tracker instance or `null` if not available
+ *
+ * @example
+ * ```ts
+ * import { getTracker, getAnonymousId, getSessionId } from "@databuddy/sdk";
+ *
+ * const tracker = getTracker();
+ * if (tracker) {
+ *   // Access tracker methods
+ *   tracker.track("event", { prop: "value" });
+ *
+ *   // Get IDs using dedicated functions
+ *   const anonId = getAnonymousId();
+ *   const sessionId = getSessionId();
+ * }
+ * ```
+ */
+declare function getTracker(): DatabuddyTracker | null;
+/**
+ * Tracks a custom event with optional properties.
+ * Events are batched and sent efficiently to minimize network overhead.
+ * Safe to call on server (no-op) or before tracker loads.
+ *
+ * @param name - Event name (e.g., "button_click", "purchase", "signup")
+ * @param properties - Key-value pairs of event data
+ *
+ * @example
+ * ```ts
+ * import { track } from "@databuddy/sdk";
+ *
+ * // Simple event
+ * track("signup_started");
+ *
+ * // Event with properties
+ * track("item_purchased", {
+ *   itemId: "sku-123",
+ *   price: 29.99,
+ *   currency: "USD"
+ * });
+ *
+ * // In a React component
+ * function CheckoutButton() {
+ *   return (
+ *     <button onClick={() => track("checkout_clicked", { cartSize: 3 })}>
+ *       Checkout
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+declare function track(name: string, properties?: Record<string, unknown>): void;
+/** @deprecated Use `track()` instead. Will be removed in v3.0. */
+declare function trackCustomEvent(name: string, properties?: Record<string, unknown>): void;
+/**
+ * Clears the current user session and generates new anonymous/session IDs.
+ * Use after logout to ensure the next user gets a fresh identity.
+ *
+ * @example
+ * ```ts
+ * import { clear } from "@databuddy/sdk";
+ *
+ * async function handleLogout() {
+ *   await signOut();
+ *   clear(); // Reset tracking identity
+ *   router.push("/login");
+ * }
+ * ```
+ */
+declare function clear(): void;
+/**
+ * Forces all queued events to be sent immediately.
+ * Useful before navigation or when you need to ensure events are captured.
+ *
+ * @example
+ * ```ts
+ * import { track, flush } from "@databuddy/sdk";
+ *
+ * function handleExternalLink(url: string) {
+ *   track("external_link_clicked", { url });
+ *   flush(); // Ensure event is sent before leaving
+ *   window.location.href = url;
+ * }
+ * ```
+ */
+declare function flush(): void;
+/**
+ * Tracks an error event. Convenience wrapper around `track("error", ...)`.
+ *
+ * @param message - Error message
+ * @param properties - Additional error context (filename, line number, stack trace)
+ *
+ * @example
+ * ```ts
+ * import { trackError } from "@databuddy/sdk";
+ *
+ * try {
+ *   await riskyOperation();
+ * } catch (error) {
+ *   trackError(error.message, {
+ *     stack: error.stack,
+ *     error_type: error.name,
+ *     context: "checkout_flow"
+ *   });
+ * }
+ * ```
+ */
+declare function trackError(message: string, properties?: {
+    filename?: string;
+    lineno?: number;
+    colno?: number;
+    stack?: string;
+    error_type?: string;
+    [key: string]: string | number | boolean | null | undefined;
+}): void;
+/**
+ * Gets the anonymous user ID. Persists across sessions via localStorage.
+ * Useful for server-side identification or cross-domain tracking.
+ *
+ * @param urlParams - Optional URLSearchParams to check for `anonId` param (highest priority)
+ * @returns Anonymous ID or `null` if unavailable
+ *
+ * Priority: URL params → tracker instance → localStorage
+ *
+ * @example
+ * ```ts
+ * import { getAnonymousId } from "@databuddy/sdk";
+ *
+ * // Get from tracker
+ * const anonId = getAnonymousId();
+ *
+ * // Check URL params first (for cross-domain tracking)
+ * const params = new URLSearchParams(window.location.search);
+ * const anonId = getAnonymousId(params);
+ *
+ * // Pass to server
+ * await fetch("/api/identify", {
+ *   body: JSON.stringify({ anonId })
+ * });
+ * ```
+ */
+declare function getAnonymousId(urlParams?: URLSearchParams): string | null;
+/**
+ * Gets the current session ID. Resets after 30 min of inactivity.
+ * Useful for correlating events within a single browsing session.
+ *
+ * @param urlParams - Optional URLSearchParams to check for `sessionId` param (highest priority)
+ * @returns Session ID or `null` if unavailable
+ *
+ * Priority: URL params → tracker instance → sessionStorage
+ *
+ * @example
+ * ```ts
+ * import { getSessionId } from "@databuddy/sdk";
+ *
+ * const sessionId = getSessionId();
+ * console.log("Current session:", sessionId);
+ * ```
+ */
+declare function getSessionId(urlParams?: URLSearchParams): string | null;
+/**
+ * Gets both anonymous ID and session ID in a single call.
+ *
+ * @param urlParams - Optional URLSearchParams to check for tracking params
+ * @returns Object with `anonId` and `sessionId` (either may be null)
+ *
+ * @example
+ * ```ts
+ * import { getTrackingIds } from "@databuddy/sdk";
+ *
+ * const { anonId, sessionId } = getTrackingIds();
+ *
+ * // Send to your backend
+ * await api.identify({ anonId, sessionId, userId: user.id });
+ * ```
+ */
+declare function getTrackingIds(urlParams?: URLSearchParams): {
+    anonId: string | null;
+    sessionId: string | null;
+};
+/**
+ * Returns tracking IDs as a URL query string for cross-domain tracking.
+ * Append to URLs when linking to other domains you own.
+ *
+ * @param urlParams - Optional URLSearchParams to preserve existing params
+ * @returns Query string like `"anonId=xxx&sessionId=yyy"` or empty string
+ *
+ * @example
+ * ```ts
+ * import { getTrackingParams } from "@databuddy/sdk";
+ *
+ * // Link to subdomain with tracking continuity
+ * const params = getTrackingParams();
+ * const url = `https://app.example.com/dashboard${params ? `?${params}` : ""}`;
+ *
+ * // In a component
+ * <a href={`https://shop.example.com?${getTrackingParams()}`}>
+ *   Visit Shop
+ * </a>
+ * ```
+ */
+declare function getTrackingParams(urlParams?: URLSearchParams): string;
+
+export { trackCustomEvent as a, trackError as b, clear as c, getAnonymousId as d, getSessionId as e, flush as f, getTracker as g, getTrackingIds as h, isTrackerAvailable as i, getTrackingParams as j, track as t };
+export type { BaseEventProperties as B, DatabuddyConfig as D, EventProperties as E, PropertiesForEvent as P, ScreenViewFunction as S, TrackFunction as T, EventTypeMap as k, EventName as l, DatabuddyTracker as m, DataAttributes as n, SetGlobalPropertiesFunction as o };

package/dist/shared/@databuddy/{sdk.F8Xt1uF7.mjs → sdk.C8vEu9Y4.mjs}

@@ -1,4 +1,4 @@
-const version = "2.3.2";
+const version = "2.3.21";
 
 const INJECTED_SCRIPT_ATTRIBUTE = "data-databuddy-injected";
 function isScriptInjected() {

package/dist/shared/@databuddy/{sdk.Du7SE7-M.mjs → sdk.DBtQ5j2L.mjs}

@@ -1,15 +1,25 @@
-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.3kaCzyfu.mjs';
+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';
 
+const isBrowser = typeof window !== "undefined" && typeof localStorage !== "undefined";
 class BrowserFlagStorage {
   ttl = 24 * 60 * 60 * 1e3;
   // 24 hours in milliseconds
   get(key) {
+    if (!isBrowser) {
+      return null;
+    }
     return this.getFromLocalStorage(key);
   }
   set(key, value) {
+    if (!isBrowser) {
+      return;
+    }
     this.setToLocalStorage(key, value);
   }
   getAll() {
+    if (!isBrowser) {
+      return {};
+    }
     const result = {};
     const now = Date.now();
     const keys = Object.keys(localStorage).filter(
@@ -33,6 +43,9 @@ class BrowserFlagStorage {
     return result;
   }
   clear() {
+    if (!isBrowser) {
+      return;
+    }
     const keys = Object.keys(localStorage).filter(
       (key) => key.startsWith("db-flag-")
     );
@@ -77,14 +90,23 @@ class BrowserFlagStorage {
     return Date.now() > expiresAt;
   }
   delete(key) {
+    if (!isBrowser) {
+      return;
+    }
     localStorage.removeItem(`db-flag-${key}`);
   }
   deleteMultiple(keys) {
+    if (!isBrowser) {
+      return;
+    }
     for (const key of keys) {
       localStorage.removeItem(`db-flag-${key}`);
     }
   }
   setAll(flags) {
+    if (!isBrowser) {
+      return;
+    }
     const currentFlags = this.getAll();
     const currentKeys = Object.keys(currentFlags);
     const newKeys = Object.keys(flags);
@@ -97,6 +119,9 @@ class BrowserFlagStorage {
     }
   }
   cleanupExpired() {
+    if (!isBrowser) {
+      return;
+    }
     const now = Date.now();
     const keys = Object.keys(localStorage).filter(
       (key) => key.startsWith("db-flag-")
@@ -181,6 +206,16 @@ class CoreFlagsManager {
       document.removeEventListener("visibilitychange", handleVisibility);
     };
   }
+  removeStaleKeys(validKeys, user) {
+    const ctx = user ?? this.config.user;
+    const suffix = ctx?.userId || ctx?.email ? `:${ctx.userId ?? ""}:${ctx.email ?? ""}` : "";
+    for (const key of this.cache.keys()) {
+      const belongsToUser = suffix ? key.endsWith(suffix) : !key.includes(":");
+      if (belongsToUser && !validKeys.has(key)) {
+        this.cache.delete(key);
+      }
+    }
+  }
   async initialize() {
     if (!this.config.skipStorage && this.storage) {
       this.loadFromStorage();
@@ -201,7 +236,10 @@ class CoreFlagsManager {
       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));
+          this.cache.set(
+            key,
+            createCacheEntry(value, ttl, staleTime)
+          );
         }
       }
       if (this.cache.size > 0) {
@@ -331,13 +369,20 @@ class CoreFlagsManager {
     }
     const apiUrl = this.config.apiUrl ?? "https://api.databuddy.cc";
     const params = buildQueryParams(this.config, user);
+    const ttl = this.config.cacheTtl ?? 6e4;
+    const staleTime = this.config.staleTime ?? ttl / 2;
     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));
+      const flagCacheEntries = Object.entries(flags).map(([key, result]) => ({
+        cacheKey: getCacheKey(key, user ?? this.config.user),
+        cacheEntry: createCacheEntry(result, ttl, staleTime)
+      }));
+      this.removeStaleKeys(
+        new Set(flagCacheEntries.map(({ cacheKey }) => cacheKey)),
+        user
+      );
+      for (const { cacheKey, cacheEntry } of flagCacheEntries) {
+        this.cache.set(cacheKey, cacheEntry);
       }
       this.ready = true;
       this.notifyUpdate();

package/dist/shared/@databuddy/{sdk.3kaCzyfu.mjs → sdk.DCKr2Zpd.mjs}

@@ -173,7 +173,10 @@ class RequestBatcher {
     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" };
+        const result = results[key] ?? {
+          ...DEFAULT_RESULT,
+          reason: "NOT_FOUND"
+        };
         for (const cb of cbs) {
           cb.resolve(result);
         }

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.F8Xt1uF7.mjs';
-import { B as BrowserFlagStorage, C as CoreFlagsManager } from '../shared/@databuddy/sdk.Du7SE7-M.mjs';
-import '../shared/@databuddy/sdk.3kaCzyfu.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.DBtQ5j2L.mjs';
+import '../shared/@databuddy/sdk.DCKr2Zpd.mjs';
 
 const Databuddy = defineComponent({
   props: {},

package/package.json

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

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