@hifilabs/pixel 0.1.5 → 0.1.7

package/dist/index.js

@@ -1,554 +1,643 @@
-var BalancePixel = (() => {
-  // src/browser.ts
-  (function() {
-    function parseUserAgent(ua) {
-      let device_type = "desktop";
-      if (/ipad|tablet|android(?!.*mobile)/i.test(ua))
-        device_type = "tablet";
-      else if (/mobile|iphone|android.*mobile|blackberry|iemobile/i.test(ua))
-        device_type = "mobile";
-      let browser = "Unknown";
-      if (/edg/i.test(ua))
-        browser = "Edge";
-      else if (/opr|opera/i.test(ua))
-        browser = "Opera";
-      else if (/firefox/i.test(ua))
-        browser = "Firefox";
-      else if (/chrome/i.test(ua))
-        browser = "Chrome";
-      else if (/safari/i.test(ua))
-        browser = "Safari";
-      let os = "Unknown";
-      if (/iphone|ipad/i.test(ua))
-        os = "iOS";
-      else if (/android/i.test(ua))
-        os = "Android";
-      else if (/windows/i.test(ua))
-        os = "Windows";
-      else if (/mac os/i.test(ua))
-        os = "macOS";
-      else if (/linux/i.test(ua))
-        os = "Linux";
-      else if (/cros/i.test(ua))
-        os = "ChromeOS";
-      return { device_type, browser, os };
-    }
-    let cachedDeviceInfo = null;
-    function getDeviceInfo() {
-      if (!cachedDeviceInfo) {
-        try {
-          cachedDeviceInfo = parseUserAgent(navigator.userAgent);
-        } catch {
-          cachedDeviceInfo = { device_type: "desktop", browser: "Unknown", os: "Unknown" };
-        }
-      }
-      return cachedDeviceInfo;
-    }
-    const currentScript = document.currentScript;
-    const artistId = currentScript?.dataset.artistId;
-    const projectId = currentScript?.dataset.projectId;
-    const useEmulator = currentScript?.dataset.emulator === "true";
-    const debug = currentScript?.dataset.debug === "true";
-    const heartbeatInterval = parseInt(currentScript?.dataset.heartbeatInterval || "30000", 10);
-    const heartbeatEnabled = currentScript?.dataset.heartbeat !== "false";
-    const explicitSource = currentScript?.dataset.source;
-    function detectTrackingSource() {
-      if (explicitSource)
-        return explicitSource;
-      const hasDataLayer = typeof window.dataLayer !== "undefined" && Array.isArray(window.dataLayer);
-      const hasGtag = typeof window.gtag === "function";
-      if (hasDataLayer && hasGtag) {
-        return "gtm";
-      }
-      return "pixel";
-    }
-    let trackingSource = "pixel";
-    if (!artistId) {
-      console.error("[BALANCE Pixel] Error: data-artist-id attribute is required");
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  BalanceAnalytics: () => BalanceAnalytics,
+  DEFAULT_GTM_CONSENT: () => DEFAULT_GTM_CONSENT,
+  GTMProvider: () => GTMProvider,
+  StorageManager: () => StorageManager,
+  getAttribution: () => getAttribution,
+  getConsent: () => getConsent,
+  getFanIdHash: () => getFanIdHash,
+  getSessionId: () => getSessionId,
+  getStorageManager: () => getStorageManager,
+  hasConsent: () => hasConsent,
+  identify: () => identify,
+  initStorageWithConsent: () => initStorageWithConsent,
+  page: () => page,
+  purchase: () => purchase,
+  setConsent: () => setConsent,
+  track: () => track,
+  useBalanceIdentify: () => useBalanceIdentify,
+  useGTMConsent: () => useGTMConsent
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/react/BalanceAnalytics.tsx
+var import_react = __toESM(require("react"));
+var import_navigation = require("next/navigation");
+function BalanceAnalyticsInner() {
+  const pathname = (0, import_navigation.usePathname)();
+  const searchParams = (0, import_navigation.useSearchParams)();
+  const isFirstRender = (0, import_react.useRef)(true);
+  const lastTrackedPath = (0, import_react.useRef)(null);
+  (0, import_react.useEffect)(() => {
+    if (typeof window === "undefined" || !window.balance)
+      return;
+    const currentPath = pathname + (searchParams?.toString() || "");
+    if (lastTrackedPath.current === currentPath) {
       return;
     }
-    const SESSION_KEY = "session_id";
-    const SESSION_TIMESTAMP_KEY = "session_timestamp";
-    const ATTRIBUTION_KEY = "attribution";
-    const FAN_ID_KEY = "fan_id_hash";
-    const CONSENT_STORAGE_KEY = "balance_consent";
-    const SESSION_DURATION = 60 * 60 * 1e3;
-    const STORAGE_PREFIX = "balance_";
-    const API_ENDPOINT = useEmulator ? `http://localhost:5001/artist-os-distro/us-central1/pixelEndpoint` : `https://us-central1-artist-os-distro.cloudfunctions.net/pixelEndpoint`;
-    let sessionId = null;
-    let fanIdHash = null;
-    let consent = null;
-    let attribution = {};
-    let eventQueue = [];
-    let flushTimer = null;
-    let currentStorageTier = "session";
-    let heartbeatTimer = null;
-    let pageStartTime = 0;
-    let activeTime = 0;
-    let lastActiveTimestamp = 0;
-    let isPageVisible = true;
-    const IDLE_TIMEOUT = 2 * 60 * 1e3;
-    let lastActivityTime = Date.now();
-    let isIdle = false;
-    const log = (...args) => {
-      if (debug)
-        console.log("[BALANCE Pixel]", ...args);
-    };
-    function getStorage() {
-      try {
-        return currentStorageTier === "local" ? localStorage : sessionStorage;
-      } catch {
-        return null;
-      }
-    }
-    function storageGet(key) {
-      const storage = getStorage();
-      if (!storage)
-        return null;
-      try {
-        const fullKey = STORAGE_PREFIX + key;
-        let value = storage.getItem(fullKey);
-        if (!value && currentStorageTier === "session") {
-          try {
-            value = localStorage.getItem(fullKey);
-          } catch {
-          }
-        }
-        return value;
-      } catch {
-        return null;
-      }
-    }
-    function storageSet(key, value) {
-      const storage = getStorage();
-      if (!storage)
-        return;
-      try {
-        storage.setItem(STORAGE_PREFIX + key, value);
-      } catch {
-      }
-    }
-    function upgradeStorageTier() {
-      if (currentStorageTier === "local")
+    if (isFirstRender.current) {
+      isFirstRender.current = false;
+      if (window._balanceInitialPageviewFired) {
+        lastTrackedPath.current = currentPath;
+        console.log("[BalanceAnalytics] Skipping initial pageview (script already fired)");
         return;
-      log("Upgrading storage tier: session -> local");
-      try {
-        const keysToMigrate = [];
-        for (let i = 0; i < sessionStorage.length; i++) {
-          const key = sessionStorage.key(i);
-          if (key?.startsWith(STORAGE_PREFIX)) {
-            keysToMigrate.push(key);
-          }
-        }
-        for (const key of keysToMigrate) {
-          const value = sessionStorage.getItem(key);
-          if (value) {
-            localStorage.setItem(key, value);
-          }
-        }
-        for (const key of keysToMigrate) {
-          sessionStorage.removeItem(key);
-        }
-        currentStorageTier = "local";
-        log(`Storage tier upgraded, migrated ${keysToMigrate.length} items`);
-      } catch (error) {
-        console.error("[BALANCE Pixel] Storage migration failed:", error);
       }
     }
-    function generateUUID() {
-      if (crypto && crypto.randomUUID) {
-        return crypto.randomUUID();
-      }
-      return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
-        const r = Math.random() * 16 | 0;
-        const v = c === "x" ? r : r & 3 | 8;
-        return v.toString(16);
-      });
-    }
-    function getOrCreateSession() {
-      try {
-        const stored = storageGet(SESSION_KEY);
-        const timestamp = storageGet(SESSION_TIMESTAMP_KEY);
-        if (stored && timestamp) {
-          const age = Date.now() - parseInt(timestamp, 10);
-          if (age < SESSION_DURATION) {
-            storageSet(SESSION_TIMESTAMP_KEY, Date.now().toString());
-            return stored;
-          }
-        }
-        const newId = generateUUID();
-        storageSet(SESSION_KEY, newId);
-        storageSet(SESSION_TIMESTAMP_KEY, Date.now().toString());
-        return newId;
-      } catch (e) {
-        return generateUUID();
-      }
-    }
-    function extractUTM() {
-      const params = new URLSearchParams(window.location.search);
-      const utm = {};
-      ["source", "medium", "campaign", "content", "term"].forEach((param) => {
-        const value = params.get(`utm_${param}`);
-        if (value)
-          utm[`utm_${param}`] = value;
-      });
-      return utm;
-    }
-    function captureAttribution() {
-      try {
-        const stored = storageGet(ATTRIBUTION_KEY);
-        if (stored) {
-          attribution = JSON.parse(stored);
-          log("Loaded attribution:", attribution);
-          return;
-        }
-        const utm = extractUTM();
-        if (Object.keys(utm).length > 0) {
-          attribution = utm;
-          storageSet(ATTRIBUTION_KEY, JSON.stringify(utm));
-          log("Captured attribution:", attribution);
+    const url = window.location.href;
+    const title = document.title;
+    lastTrackedPath.current = currentPath;
+    window.balance.page({ url, title });
+  }, [pathname, searchParams]);
+  return null;
+}
+function BalanceAnalytics() {
+  return /* @__PURE__ */ import_react.default.createElement(import_react.Suspense, { fallback: null }, /* @__PURE__ */ import_react.default.createElement(BalanceAnalyticsInner, null));
+}
+
+// src/react/useBalanceIdentify.ts
+var import_react2 = require("react");
+
+// src/storage/StorageManager.ts
+var DEFAULT_PREFIX = "balance_";
+var StorageManager = class {
+  constructor(config) {
+    __publicField(this, "prefix");
+    __publicField(this, "currentTier");
+    this.prefix = config?.prefix ?? DEFAULT_PREFIX;
+    this.currentTier = config?.tier ?? "session";
+  }
+  /**
+   * Get the appropriate storage based on current tier
+   */
+  getStorage() {
+    if (typeof window === "undefined")
+      return null;
+    try {
+      return this.currentTier === "local" ? localStorage : sessionStorage;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Get current storage tier
+   */
+  getTier() {
+    return this.currentTier;
+  }
+  /**
+   * Upgrade storage tier (e.g., when user gives consent)
+   * Automatically migrates data from sessionStorage to localStorage
+   */
+  upgradeTier(newTier) {
+    if (typeof window === "undefined")
+      return;
+    if (this.currentTier === newTier)
+      return;
+    const oldTier = this.currentTier;
+    if (oldTier === "session" && newTier === "local") {
+      this.migrateToLocal();
+    }
+    this.currentTier = newTier;
+    console.log(`[StorageManager] Upgraded tier: ${oldTier} -> ${newTier}`);
+  }
+  /**
+   * Downgrade storage tier (e.g., when user revokes consent)
+   * Clears localStorage data and falls back to sessionStorage
+   */
+  downgradeTier(newTier) {
+    if (typeof window === "undefined")
+      return;
+    if (this.currentTier === newTier)
+      return;
+    const oldTier = this.currentTier;
+    if (oldTier === "local" && newTier === "session") {
+      this.clearLocalStorage();
+    }
+    this.currentTier = newTier;
+    console.log(`[StorageManager] Downgraded tier: ${oldTier} -> ${newTier}`);
+  }
+  /**
+   * Migrate all prefixed data from sessionStorage to localStorage
+   */
+  migrateToLocal() {
+    if (typeof window === "undefined")
+      return;
+    try {
+      const keysToMigrate = [];
+      for (let i = 0; i < sessionStorage.length; i++) {
+        const key = sessionStorage.key(i);
+        if (key?.startsWith(this.prefix)) {
+          keysToMigrate.push(key);
         }
-      } catch (e) {
       }
-    }
-    function loadFanId() {
-      try {
-        fanIdHash = storageGet(FAN_ID_KEY);
-      } catch (e) {
-      }
-    }
-    function loadConsent() {
-      try {
-        const stored = localStorage.getItem(CONSENT_STORAGE_KEY);
-        if (stored) {
-          const parsed = JSON.parse(stored);
-          consent = parsed.preferences || null;
-          log("Loaded consent:", consent);
+      for (const key of keysToMigrate) {
+        const value = sessionStorage.getItem(key);
+        if (value) {
+          localStorage.setItem(key, value);
+          console.log(`[StorageManager] Migrated: ${key}`);
         }
-      } catch (e) {
-      }
-    }
-    function setConsent(preferences) {
-      const previousConsent = consent;
-      consent = preferences;
-      try {
-        const storage = {
-          preferences,
-          method: "explicit",
-          version: 1
-        };
-        localStorage.setItem(CONSENT_STORAGE_KEY, JSON.stringify(storage));
-        log("Consent saved:", preferences);
-      } catch (e) {
-        console.error("[BALANCE Pixel] Could not save consent:", e);
       }
-      if (preferences.analytics === true) {
-        upgradeStorageTier();
+      for (const key of keysToMigrate) {
+        sessionStorage.removeItem(key);
       }
-      const event = buildEvent({
-        event_name: "consent_updated",
-        metadata: {
-          consent_preferences: preferences,
-          consent_method: "explicit",
-          previous_consent: previousConsent || void 0
+      console.log(`[StorageManager] Migration complete: ${keysToMigrate.length} items`);
+    } catch (error) {
+      console.error("[StorageManager] Migration failed:", error);
+    }
+  }
+  /**
+   * Clear all prefixed data from localStorage
+   */
+  clearLocalStorage() {
+    if (typeof window === "undefined")
+      return;
+    try {
+      const keysToRemove = [];
+      for (let i = 0; i < localStorage.length; i++) {
+        const key = localStorage.key(i);
+        if (key?.startsWith(this.prefix)) {
+          keysToRemove.push(key);
         }
-      });
-      enqueueEvent(event);
-    }
-    function getConsent() {
-      return consent;
-    }
-    function hasConsent(type) {
-      return consent?.[type] === true;
-    }
-    async function hashEmail(email) {
-      const normalized = email.toLowerCase().trim();
-      const encoder = new TextEncoder();
-      const data = encoder.encode(normalized);
-      const hashBuffer = await crypto.subtle.digest("SHA-256", data);
-      const hashArray = Array.from(new Uint8Array(hashBuffer));
-      return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
-    }
-    function buildEvent(partial) {
-      const deviceInfo = getDeviceInfo();
-      const base = {
-        artist_id: artistId,
-        fan_session_id: sessionId,
-        fan_id_hash: fanIdHash || void 0,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        source_url: window.location.href,
-        referrer_url: document.referrer || void 0,
-        user_agent: navigator.userAgent,
-        // Device info (parsed client-side)
-        device_type: deviceInfo.device_type,
-        browser: deviceInfo.browser,
-        os: deviceInfo.os,
-        // Tracking source (gtm, pixel, etc.) - enables filtering in artistHQ
-        tracking_source: trackingSource,
-        ...partial,
-        ...attribution
-      };
-      if (projectId && !partial.projectId) {
-        base.projectId = projectId;
       }
-      return base;
-    }
-    function enqueueEvent(event) {
-      eventQueue.push(event);
-      log("Event queued:", event.event_name, "(queue:", eventQueue.length, ")");
-      if (eventQueue.length >= 10) {
-        flush();
+      for (const key of keysToRemove) {
+        localStorage.removeItem(key);
       }
-    }
-    async function flush() {
-      if (eventQueue.length === 0)
-        return;
-      const events = [...eventQueue];
-      eventQueue = [];
-      log("Flushing", events.length, "events to", API_ENDPOINT);
-      try {
-        const response = await fetch(API_ENDPOINT, {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({ events }),
-          keepalive: true
-          // Send even if page is closing
-        });
-        if (!response.ok) {
-          throw new Error(`HTTP ${response.status}`);
-        }
-        log("Events sent successfully");
-      } catch (error) {
-        console.error("[BALANCE Pixel] Failed to send events:", error);
-        if (eventQueue.length < 50) {
-          eventQueue.push(...events);
+      console.log(`[StorageManager] Cleared ${keysToRemove.length} items from localStorage`);
+    } catch (error) {
+      console.error("[StorageManager] Clear failed:", error);
+    }
+  }
+  /**
+   * Get item from current storage tier
+   */
+  getItem(key) {
+    const storage = this.getStorage();
+    if (!storage)
+      return null;
+    try {
+      const fullKey = this.prefix + key;
+      let value = storage.getItem(fullKey);
+      if (!value && this.currentTier === "session") {
+        try {
+          value = localStorage.getItem(fullKey);
+        } catch {
         }
       }
-    }
-    function startFlushTimer() {
-      if (flushTimer)
-        clearInterval(flushTimer);
-      flushTimer = window.setInterval(() => {
-        if (eventQueue.length > 0)
-          flush();
-      }, 5e3);
-    }
-    function startActiveTimeTracking() {
-      if (!lastActiveTimestamp) {
-        pageStartTime = Date.now();
-      }
-      lastActiveTimestamp = Date.now();
-      isPageVisible = true;
-      log("Active time tracking started/resumed");
-    }
-    function pauseActiveTimeTracking() {
-      if (lastActiveTimestamp && isPageVisible) {
-        activeTime += Date.now() - lastActiveTimestamp;
-      }
-      isPageVisible = false;
-      log("Active time tracking paused, accumulated:", activeTime, "ms");
-    }
-    function getCumulativeActiveTime() {
-      let total = activeTime;
-      if (isPageVisible && lastActiveTimestamp) {
-        total += Date.now() - lastActiveTimestamp;
-      }
-      return total;
-    }
-    function resetIdleTimer() {
-      lastActivityTime = Date.now();
-      if (isIdle) {
-        isIdle = false;
-        startActiveTimeTracking();
-        log("User returned from idle");
-      }
-    }
-    function sendHeartbeat() {
-      if (document.visibilityState === "hidden") {
-        log("Skipping heartbeat - tab hidden");
+      return value;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Set item in current storage tier
+   */
+  setItem(key, value) {
+    const storage = this.getStorage();
+    if (!storage)
+      return;
+    try {
+      const fullKey = this.prefix + key;
+      storage.setItem(fullKey, value);
+    } catch (error) {
+      console.error("[StorageManager] setItem failed:", error);
+    }
+  }
+  /**
+   * Remove item from all storage tiers
+   */
+  removeItem(key) {
+    if (typeof window === "undefined")
+      return;
+    const fullKey = this.prefix + key;
+    try {
+      sessionStorage.removeItem(fullKey);
+    } catch {
+    }
+    try {
+      localStorage.removeItem(fullKey);
+    } catch {
+    }
+  }
+  /**
+   * Get JSON-parsed item
+   */
+  getJSON(key) {
+    const value = this.getItem(key);
+    if (!value)
+      return null;
+    try {
+      return JSON.parse(value);
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Set JSON-stringified item
+   */
+  setJSON(key, value) {
+    try {
+      this.setItem(key, JSON.stringify(value));
+    } catch {
+    }
+  }
+};
+var storageManagerInstance = null;
+function getStorageManager() {
+  if (!storageManagerInstance) {
+    storageManagerInstance = new StorageManager();
+  }
+  return storageManagerInstance;
+}
+function initStorageWithConsent(hasAnalyticsConsent) {
+  const manager = getStorageManager();
+  if (hasAnalyticsConsent) {
+    manager.upgradeTier("local");
+  } else {
+    manager.downgradeTier("session");
+  }
+  return manager;
+}
+
+// src/react/useBalanceIdentify.ts
+var PENDING_IDENTIFY_KEY = "pending_identify";
+var MAX_PENDING_AGE_MS = 30 * 60 * 1e3;
+function checkAnalyticsConsent() {
+  if (typeof window === "undefined")
+    return false;
+  try {
+    if (window.balance?.hasConsent) {
+      return window.balance.hasConsent("analytics");
+    }
+    const stored = localStorage.getItem("balance_consent");
+    if (stored) {
+      const consent = JSON.parse(stored);
+      return consent?.preferences?.analytics !== false;
+    }
+    return true;
+  } catch {
+    return true;
+  }
+}
+function useBalanceIdentify() {
+  const pollIntervalRef = (0, import_react2.useRef)(null);
+  const hasProcessedPending = (0, import_react2.useRef)(false);
+  const storageManager = typeof window !== "undefined" ? getStorageManager() : null;
+  const getPendingIdentify = (0, import_react2.useCallback)(() => {
+    if (!storageManager)
+      return null;
+    const pending = storageManager.getJSON(PENDING_IDENTIFY_KEY);
+    if (!pending)
+      return null;
+    if (Date.now() - pending.timestamp > MAX_PENDING_AGE_MS) {
+      storageManager.removeItem(PENDING_IDENTIFY_KEY);
+      return null;
+    }
+    return pending;
+  }, [storageManager]);
+  const setPendingIdentify = (0, import_react2.useCallback)((email, traits) => {
+    if (!storageManager)
+      return;
+    storageManager.setJSON(PENDING_IDENTIFY_KEY, {
+      email,
+      traits,
+      timestamp: Date.now()
+    });
+  }, [storageManager]);
+  const clearPendingIdentify = (0, import_react2.useCallback)(() => {
+    if (!storageManager)
+      return;
+    storageManager.removeItem(PENDING_IDENTIFY_KEY);
+  }, [storageManager]);
+  const identify2 = (0, import_react2.useCallback)((email, traits) => {
+    const hasConsent2 = checkAnalyticsConsent();
+    if (!hasConsent2) {
+      console.log("[useBalanceIdentify] Skipping identify - user declined analytics consent");
+      return false;
+    }
+    if (storageManager) {
+      initStorageWithConsent(hasConsent2);
+    }
+    if (typeof window !== "undefined" && window.balance?.identify) {
+      window.balance.identify(email, traits);
+      console.log("[useBalanceIdentify] User identified:", email.split("@")[0] + "***");
+      clearPendingIdentify();
+      return true;
+    }
+    console.log("[useBalanceIdentify] Pixel not ready, queueing identify");
+    setPendingIdentify(email, traits);
+    return false;
+  }, [storageManager, clearPendingIdentify, setPendingIdentify]);
+  const processPendingIdentify = (0, import_react2.useCallback)(() => {
+    if (hasProcessedPending.current)
+      return;
+    const pending = getPendingIdentify();
+    if (!pending)
+      return;
+    if (typeof window !== "undefined" && window.balance?.identify) {
+      const hasConsent2 = checkAnalyticsConsent();
+      if (!hasConsent2) {
+        console.log("[useBalanceIdentify] Clearing pending identify - user declined analytics consent");
+        clearPendingIdentify();
+        hasProcessedPending.current = true;
         return;
       }
-      if (Date.now() - lastActivityTime > IDLE_TIMEOUT) {
-        if (!isIdle) {
-          isIdle = true;
-          pauseActiveTimeTracking();
-          log("User idle - pausing heartbeat");
-        }
-        return;
+      if (storageManager) {
+        initStorageWithConsent(hasConsent2);
       }
-      const timeOnPage = getCumulativeActiveTime();
-      const timeOnPageSeconds = Math.round(timeOnPage / 1e3);
-      const event = buildEvent({
-        event_name: "engagement_heartbeat",
-        metadata: {
-          time_on_page_seconds: timeOnPageSeconds,
-          time_on_page_ms: timeOnPage,
-          heartbeat_interval_ms: heartbeatInterval,
-          is_active: isPageVisible && !isIdle
+      console.log("[useBalanceIdentify] Processing pending identify");
+      window.balance.identify(pending.email, pending.traits);
+      clearPendingIdentify();
+      hasProcessedPending.current = true;
+    }
+  }, [getPendingIdentify, clearPendingIdentify, storageManager]);
+  (0, import_react2.useEffect)(() => {
+    processPendingIdentify();
+    const pending = getPendingIdentify();
+    if (pending && !hasProcessedPending.current) {
+      pollIntervalRef.current = setInterval(() => {
+        processPendingIdentify();
+        if (hasProcessedPending.current || !getPendingIdentify()) {
+          if (pollIntervalRef.current) {
+            clearInterval(pollIntervalRef.current);
+            pollIntervalRef.current = null;
+          }
         }
-      });
-      enqueueEvent(event);
-      log("Heartbeat sent:", timeOnPageSeconds, "seconds active");
+      }, 500);
     }
-    function startHeartbeat() {
-      if (!heartbeatEnabled) {
-        log('Heartbeat disabled via data-heartbeat="false"');
-        return;
-      }
-      if (heartbeatTimer)
-        clearInterval(heartbeatTimer);
-      startActiveTimeTracking();
-      heartbeatTimer = window.setInterval(() => {
-        sendHeartbeat();
-      }, heartbeatInterval);
-      log("Heartbeat started with interval:", heartbeatInterval, "ms");
-    }
-    function stopHeartbeat() {
-      if (heartbeatTimer) {
-        clearInterval(heartbeatTimer);
-        heartbeatTimer = null;
+    return () => {
+      if (pollIntervalRef.current) {
+        clearInterval(pollIntervalRef.current);
+        pollIntervalRef.current = null;
       }
-      if (heartbeatEnabled) {
-        sendHeartbeat();
-        log("Heartbeat stopped, final time sent");
-      }
-    }
-    function trackPageView(options = {}) {
-      const event = buildEvent({
-        event_name: "pageview",
-        page_title: options.title || document.title,
-        source_url: options.url || window.location.href
-      });
-      enqueueEvent(event);
-    }
-    function track(eventName, properties = {}) {
-      const event = buildEvent({
-        event_name: "custom",
-        metadata: {
-          event_type: eventName,
-          ...properties
-        }
-      });
-      enqueueEvent(event);
-    }
-    async function identify(email, traits = {}) {
-      try {
-        if (consent && consent.analytics === false) {
-          log("Identify skipped - user declined analytics consent");
-          return;
-        }
-        fanIdHash = await hashEmail(email);
-        if (consent?.analytics === true) {
-          upgradeStorageTier();
-        }
-        storageSet(FAN_ID_KEY, fanIdHash);
-        const emailParts = email.split("@");
-        const maskedEmail = emailParts[0].charAt(0) + "***@" + (emailParts[1] || "");
-        log("Fan identified:", {
-          name: traits.name || "(no name)",
-          email: maskedEmail,
-          hash: fanIdHash.substring(0, 16) + "...",
-          traits,
-          storageTier: currentStorageTier
-        });
-        const event = buildEvent({
-          event_name: "identify",
-          fan_id_hash: fanIdHash,
-          metadata: {
-            email_sha256: fanIdHash,
-            traits,
-            consent_preferences: consent || void 0,
-            storage_tier: currentStorageTier
-          }
-        });
-        enqueueEvent(event);
-      } catch (error) {
-        console.error("[BALANCE Pixel] Failed to identify:", error);
+    };
+  }, [processPendingIdentify, getPendingIdentify]);
+  return {
+    /**
+     * Identify a user with BALANCE pixel.
+     * Handles consent checks, queuing, and storage tier automatically.
+     */
+    identify: identify2,
+    /**
+     * Check if analytics consent is currently granted
+     */
+    hasAnalyticsConsent: checkAnalyticsConsent
+  };
+}
+
+// src/react/GTMProvider.tsx
+var import_react4 = __toESM(require("react"));
+var import_script = __toESM(require("next/script"));
+
+// src/react/useGTMConsent.ts
+var import_react3 = require("react");
+function useGTMConsent(options = {}) {
+  const { pollInterval = 1e3, debug = false, enabled = true } = options;
+  const lastConsentRef = (0, import_react3.useRef)("");
+  const log = (0, import_react3.useCallback)(
+    (...args) => {
+      if (debug) {
+        console.log("[useGTMConsent]", ...args);
       }
+    },
+    [debug]
+  );
+  const mapPixelConsentToGTM = (0, import_react3.useCallback)(() => {
+    if (typeof window === "undefined" || !window.balance) {
+      return {
+        ad_storage: "denied",
+        ad_user_data: "denied",
+        ad_personalization: "denied",
+        analytics_storage: "denied"
+      };
     }
-    function purchase(revenue, currency = "USD", properties = {}) {
-      const event = buildEvent({
-        event_name: "purchase",
-        metadata: {
-          revenue,
-          currency,
-          ...properties
-        }
-      });
-      enqueueEvent(event);
-    }
-    function init() {
-      trackingSource = detectTrackingSource();
-      log("Tracking source detected:", trackingSource);
-      loadConsent();
-      if (consent?.analytics === true) {
-        currentStorageTier = "local";
-        log("Storage tier: local (analytics consent granted)");
-      } else {
-        currentStorageTier = "session";
-        log("Storage tier: session (privacy by default)");
-      }
-      sessionId = getOrCreateSession();
-      loadFanId();
-      if (!consent) {
-        consent = {
-          analytics: true,
-          marketing: true,
-          personalization: true,
-          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    const hasAnalytics = window.balance.hasConsent("analytics");
+    const hasMarketing = window.balance.hasConsent("marketing");
+    const analyticsState = hasAnalytics ? "granted" : "denied";
+    const marketingState = hasMarketing ? "granted" : "denied";
+    return {
+      analytics_storage: analyticsState,
+      ad_storage: marketingState,
+      ad_user_data: marketingState,
+      ad_personalization: marketingState
+    };
+  }, []);
+  const updateGTMConsent = (0, import_react3.useCallback)(
+    (consentConfig) => {
+      if (typeof window === "undefined")
+        return;
+      window.dataLayer = window.dataLayer || [];
+      if (typeof window.gtag !== "function") {
+        window.gtag = function gtag(...args) {
+          window.dataLayer.push(args);
         };
-        log("Default consent enabled (all tracking):", consent);
-        upgradeStorageTier();
       }
-      captureAttribution();
-      startFlushTimer();
-      log("Initialized", {
-        artistId,
-        projectId: projectId || "(none - will track to all projects)",
-        sessionId,
-        fanIdHash,
-        consent,
-        storageTier: currentStorageTier,
-        trackingSource,
-        useEmulator,
-        endpoint: API_ENDPOINT
-      });
-      window._balanceInitialPageviewFired = true;
-      trackPageView();
-      startHeartbeat();
-      ["mousemove", "keydown", "scroll", "touchstart"].forEach((eventType) => {
-        document.addEventListener(eventType, resetIdleTimer, { passive: true });
-      });
-      window.addEventListener("beforeunload", () => {
-        stopHeartbeat();
-        flush();
-      });
-      document.addEventListener("visibilitychange", () => {
-        if (document.visibilityState === "hidden") {
-          pauseActiveTimeTracking();
-          flush();
-        } else {
-          startActiveTimeTracking();
-        }
-      });
-    }
-    window.balance = {
-      track,
-      identify,
-      page: trackPageView,
-      purchase,
-      getSessionId: () => sessionId,
-      getFanIdHash: () => fanIdHash,
-      getAttribution: () => attribution,
-      setConsent,
-      getConsent,
-      hasConsent
+      window.gtag("consent", "update", consentConfig);
+      log("Pushed consent update to GTM:", consentConfig);
+    },
+    [log]
+  );
+  const syncConsent = (0, import_react3.useCallback)(() => {
+    const currentConsent = mapPixelConsentToGTM();
+    const consentKey = JSON.stringify(currentConsent);
+    if (consentKey !== lastConsentRef.current) {
+      lastConsentRef.current = consentKey;
+      updateGTMConsent(currentConsent);
+    }
+  }, [mapPixelConsentToGTM, updateGTMConsent]);
+  (0, import_react3.useEffect)(() => {
+    if (typeof window === "undefined" || !enabled)
+      return;
+    syncConsent();
+    const intervalId = setInterval(syncConsent, pollInterval);
+    const handleStorageChange = (e) => {
+      if (e.key === "balance_consent") {
+        log("Consent changed in another tab, syncing...");
+        syncConsent();
+      }
+    };
+    window.addEventListener("storage", handleStorageChange);
+    return () => {
+      clearInterval(intervalId);
+      window.removeEventListener("storage", handleStorageChange);
     };
-    if (document.readyState === "loading") {
-      document.addEventListener("DOMContentLoaded", init);
-    } else {
-      init();
+  }, [syncConsent, pollInterval, log, enabled]);
+  return {
+    /**
+     * Manually trigger a consent sync
+     */
+    syncConsent,
+    /**
+     * Get current consent config
+     */
+    getConsentConfig: mapPixelConsentToGTM
+  };
+}
+
+// src/types/gtm.ts
+var DEFAULT_GTM_CONSENT = {
+  ad_storage: "denied",
+  ad_user_data: "denied",
+  ad_personalization: "denied",
+  analytics_storage: "denied"
+};
+
+// src/react/GTMProvider.tsx
+function GTMProvider({ gtmId, children, debug = false }) {
+  const resolvedGtmId = gtmId || process.env.NEXT_PUBLIC_GTM_ID;
+  useGTMConsent({ debug, enabled: !!resolvedGtmId });
+  if (!resolvedGtmId) {
+    if (debug) {
+      console.log("[GTMProvider] No GTM ID configured, skipping GTM initialization");
+    }
+    return /* @__PURE__ */ import_react4.default.createElement(import_react4.default.Fragment, null, children);
+  }
+  const consentJson = JSON.stringify(DEFAULT_GTM_CONSENT);
+  const consentScript = `
+    window.dataLayer = window.dataLayer || [];
+    function gtag(){dataLayer.push(arguments);}
+    window.gtag = gtag;
+    gtag('consent', 'default', ${consentJson});
+    gtag('set', 'wait_for_update', 500);
+    ${debug ? "console.log('[GTM] Default consent initialized (denied)');" : ""}
+  `;
+  return /* @__PURE__ */ import_react4.default.createElement(import_react4.default.Fragment, null, /* @__PURE__ */ import_react4.default.createElement(
+    import_script.default,
+    {
+      id: "gtm-consent-default",
+      strategy: "beforeInteractive",
+      dangerouslySetInnerHTML: { __html: consentScript }
+    }
+  ), /* @__PURE__ */ import_react4.default.createElement(
+    import_script.default,
+    {
+      id: "gtm-script",
+      strategy: "afterInteractive",
+      dangerouslySetInnerHTML: {
+        __html: `
+            (function(w,d,s,l,i){w[l]=w[l]||[];w[l].push({'gtm.start':
+            new Date().getTime(),event:'gtm.js'});var f=d.getElementsByTagName(s)[0],
+            j=d.createElement(s),dl=l!='dataLayer'?'&l='+l:'';j.async=true;j.src=
+            'https://www.googletagmanager.com/gtm.js?id='+i+dl;f.parentNode.insertBefore(j,f);
+            })(window,document,'script','dataLayer','${resolvedGtmId}');
+          `
+      }
     }
-    log("Pixel script loaded");
-  })();
-})();
+  ), /* @__PURE__ */ import_react4.default.createElement("noscript", null, /* @__PURE__ */ import_react4.default.createElement(
+    "iframe",
+    {
+      src: `https://www.googletagmanager.com/ns.html?id=${resolvedGtmId}`,
+      height: "0",
+      width: "0",
+      style: { display: "none", visibility: "hidden" },
+      title: "GTM"
+    }
+  )), children);
+}
+
+// src/index.esm.ts
+var track = (eventName, properties) => {
+  if (typeof window === "undefined")
+    return;
+  if (window.balance) {
+    window.balance.track(eventName, properties);
+  } else {
+    console.warn("[Balance Pixel] track() called before pixel initialized:", eventName);
+  }
+};
+var identify = (email, traits) => {
+  if (typeof window === "undefined")
+    return Promise.resolve();
+  if (window.balance) {
+    return window.balance.identify(email, traits);
+  } else {
+    console.warn("[Balance Pixel] identify() called before pixel initialized");
+    return Promise.resolve();
+  }
+};
+var page = (options) => {
+  if (typeof window === "undefined")
+    return;
+  if (window.balance) {
+    window.balance.page(options);
+  } else {
+    console.warn("[Balance Pixel] page() called before pixel initialized");
+  }
+};
+var purchase = (revenue, currency, properties) => {
+  if (typeof window === "undefined")
+    return;
+  if (window.balance) {
+    window.balance.purchase(revenue, currency, properties);
+  } else {
+    console.warn("[Balance Pixel] purchase() called before pixel initialized");
+  }
+};
+var getSessionId = () => {
+  if (typeof window === "undefined")
+    return null;
+  return window.balance?.getSessionId() ?? null;
+};
+var getFanIdHash = () => {
+  if (typeof window === "undefined")
+    return null;
+  return window.balance?.getFanIdHash() ?? null;
+};
+var getAttribution = () => {
+  if (typeof window === "undefined")
+    return {};
+  return window.balance?.getAttribution() ?? {};
+};
+var setConsent = (preferences) => {
+  if (typeof window === "undefined")
+    return;
+  if (window.balance) {
+    window.balance.setConsent(preferences);
+  } else {
+    console.warn("[Balance Pixel] setConsent() called before pixel initialized");
+  }
+};
+var getConsent = () => {
+  if (typeof window === "undefined")
+    return null;
+  return window.balance?.getConsent() ?? null;
+};
+var hasConsent = (type) => {
+  if (typeof window === "undefined")
+    return false;
+  return window.balance?.hasConsent(type) ?? false;
+};