consentlayer 0.0.0-stage → 1.0.0-rc.0

package/dist/chunk-LEAQJXJU.js

@@ -0,0 +1,582 @@
+import { isBrowser, normalizeIdentity, createDebugLog, createEventId, getWindowLocation, hasRequiredConsent, safeJsonParse } from './chunk-TVSZJLRC.js';
+import { assertHttpsOrRelativeUrl } from './chunk-J3KUPF4R.js';
+import { legacyStorageKeysFor } from './chunk-R6I7OYQB.js';
+
+// src/core/storage.ts
+function createLocalStorageConsentStorage(options) {
+  return {
+    read() {
+      return withStorage(
+        options,
+        (storage) => toRecord(safeJsonParse(readMigrating(storage, options))),
+        null
+      );
+    },
+    write(record) {
+      withStorage(
+        options,
+        (storage) => record ? storage.setItem(options.key, JSON.stringify(record)) : storage.removeItem(options.key),
+        void 0
+      );
+    },
+    subscribe(listener) {
+      const win = options.window ?? (isBrowser() ? window : void 0);
+      if (!win) return () => void 0;
+      const handleStorage = (event) => {
+        if (event.key === options.key) listener();
+      };
+      win.addEventListener("storage", handleStorage);
+      return () => win.removeEventListener("storage", handleStorage);
+    },
+    clear() {
+      withStorage(options, (storage) => storage.removeItem(options.key), void 0);
+    }
+  };
+}
+function createLocalStorageIdentityStorage(options) {
+  return {
+    read() {
+      return withStorage(
+        options,
+        (storage) => normalizeIdentity(safeJsonParse(readMigrating(storage, options)) ?? {}),
+        {}
+      );
+    },
+    write(identity) {
+      withStorage(
+        options,
+        (storage) => storage.setItem(options.key, JSON.stringify(normalizeIdentity(identity))),
+        void 0
+      );
+    },
+    clear() {
+      withStorage(
+        options,
+        (storage) => {
+          for (const key of [options.key, ...options.legacyKeys ?? legacyStorageKeysFor(options.key)]) {
+            storage.removeItem(key);
+          }
+        },
+        void 0
+      );
+    }
+  };
+}
+function createMemoryConsentStorage(initial = null) {
+  let value = toRecord(initial);
+  const listeners = /* @__PURE__ */ new Set();
+  return {
+    read() {
+      return value;
+    },
+    write(record) {
+      value = record;
+      listeners.forEach((listener) => listener());
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    clear() {
+      value = null;
+      listeners.forEach((listener) => listener());
+    }
+  };
+}
+function createMemoryIdentityStorage(initial = {}) {
+  let value = normalizeIdentity(initial);
+  return {
+    read() {
+      return value;
+    },
+    write(identity) {
+      value = normalizeIdentity(identity);
+    },
+    clear() {
+      value = {};
+    }
+  };
+}
+function toRecord(value) {
+  if (!value || typeof value !== "object") return null;
+  return "consent" in value && typeof value.consent === "object" ? value : { consent: value };
+}
+function readMigrating(storage, { key, legacyKeys = legacyStorageKeysFor(key) }) {
+  const value = storage.getItem(key);
+  if (value !== null) return value;
+  for (const legacyKey of legacyKeys) {
+    const legacyValue = storage.getItem(legacyKey);
+    if (legacyValue === null) continue;
+    storage.setItem(key, legacyValue);
+    storage.removeItem(legacyKey);
+    return legacyValue;
+  }
+  return null;
+}
+function withStorage(options, run, fallback) {
+  try {
+    const storage = options.storage ?? (isBrowser() ? window.localStorage : void 0);
+    return storage ? run(storage) : fallback;
+  } catch {
+    return fallback;
+  }
+}
+
+// src/core/analytics-manager.ts
+var LIFECYCLE_HOOKS = /* @__PURE__ */ new Set(["setup", "consent", "load", "teardown"]);
+var HOOK_TOPICS = {
+  setup: "providers",
+  consent: "providers",
+  load: "providers",
+  teardown: "providers",
+  page: "events",
+  track: "events",
+  identify: "events",
+  group: "events",
+  reset: "events",
+  error: "errors"
+};
+var INTERACTIONS = ["pointerdown", "keydown", "scroll", "touchstart"];
+function whenDue(timing, signal) {
+  if (!isBrowser()) return Promise.resolve();
+  return new Promise((resolve) => {
+    if (typeof timing === "number") {
+      window.setTimeout(resolve, timing);
+    } else if (timing === "idle") {
+      if (typeof window.requestIdleCallback === "function") {
+        window.requestIdleCallback(() => resolve(), { timeout: 5e3 });
+      } else window.setTimeout(resolve, 1);
+    } else {
+      const done = () => {
+        for (const type of INTERACTIONS) window.removeEventListener(type, done);
+        resolve();
+      };
+      for (const type of INTERACTIONS) {
+        window.addEventListener(type, done, { once: true, passive: true, signal });
+      }
+    }
+  });
+}
+function createAnalyticsManager(options = {}) {
+  if (options.autoTracking !== void 0 && typeof options.autoTracking !== "function") {
+    throw new Error("[consentlayer] autoTracking must be autoTracking() from consentlayer/auto-tracking");
+  }
+  const debugLog = createDebugLog(options.debug);
+  const listeners = /* @__PURE__ */ new Set();
+  const providerStates = /* @__PURE__ */ new Map();
+  const identityStorage = options.identityStorage ?? createMemoryIdentityStorage();
+  let consent = options.consent ?? options.consentEngine?.getConsent() ?? null;
+  const stored = identityStorage.read();
+  let identity = stored.userId ? { userId: stored.userId } : {};
+  let storedContact = stored.email || stored.phone ? stored : void 0;
+  const settleStoredContact = () => {
+    if (!storedContact || !consent) return;
+    if (consent.marketing && identity.userId === storedContact.userId) {
+      identity = { ...storedContact, ...identity };
+    }
+    storedContact = void 0;
+  };
+  settleStoredContact();
+  const pending = [];
+  let booted = false;
+  let ready = false;
+  let identifyQueued = false;
+  let destroyed = false;
+  const lifetime = new AbortController();
+  let lifecycleQueue = Promise.resolve();
+  let unsubscribeConsent;
+  let pageSession;
+  const snapshot = () => ({
+    booted,
+    consent,
+    activeProviders: [...providerStates.values()].filter((state) => state.active).map((state) => state.plugin.id)
+  });
+  let currentSnapshot = snapshot();
+  const refreshSnapshot = () => {
+    currentSnapshot = snapshot();
+  };
+  const notify = () => {
+    refreshSnapshot();
+    listeners.forEach((listener) => listener(currentSnapshot));
+  };
+  const runtimeEnabled = () => {
+    if (typeof options.enabled === "function") return options.enabled();
+    if (typeof options.enabled === "boolean") return options.enabled;
+    return true;
+  };
+  const emitError = (error) => {
+    debugLog("errors", error.providerId, `[${error.scope}] ${error.message}`, error.cause);
+    try {
+      options.onError?.(error);
+    } catch (handlerError) {
+      debugLog("errors", void 0, "onError handler threw", handlerError);
+    }
+  };
+  const overflowed = /* @__PURE__ */ new WeakSet();
+  const enqueue = (queue, run, providerId) => {
+    if (queue.length < 100) {
+      queue.push(run);
+    } else if (!overflowed.has(queue)) {
+      overflowed.add(queue);
+      emitError({
+        scope: "queue-full",
+        providerId,
+        message: `100 calls are already waiting ${providerId ? `for ${providerId} to load` : "for boot"}; later ones are dropped`
+      });
+    }
+  };
+  const providerEmitError = (providerId) => (error) => emitError({ ...error, providerId: error.providerId ?? providerId });
+  let serverEndpoint = options.server?.endpoint ? assertHttpsOrRelativeUrl(options.server.endpoint, "server.endpoint") : void 0;
+  const consentEndpoint = options.server?.consentEndpoint ? assertHttpsOrRelativeUrl(options.server.consentEndpoint, "server.consentEndpoint") : void 0;
+  let restoring = false;
+  const restoreConsentCookie = () => {
+    if (!consentEndpoint || restoring) return;
+    restoring = true;
+    fetch(consentEndpoint, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ consent, restored: true })
+    }).then((response) => {
+      if (!response.ok) throw new Error(`HTTP ${response.status}`);
+    }).catch(
+      (cause) => emitError({
+        scope: "server-forward",
+        message: `Restoring the consent cookie at ${consentEndpoint} failed`,
+        cause
+      })
+    );
+  };
+  const forward = (event) => {
+    if (!serverEndpoint || !(consent?.analytics || consent?.marketing)) return;
+    const body = JSON.stringify({ ...event, consent, identity: sharedIdentity() });
+    const fail = (cause) => emitError({ scope: "server-forward", message: `Sending ${event.name} to ${serverEndpoint} failed`, cause });
+    if (typeof fetch !== "function") {
+      if (!navigator.sendBeacon(serverEndpoint, new Blob([body], { type: "application/json" }))) {
+        fail(void 0);
+      }
+      return;
+    }
+    fetch(serverEndpoint, {
+      method: "POST",
+      keepalive: true,
+      headers: { "content-type": "application/json" },
+      body
+    }).then((response) => {
+      if (!response.ok) throw new Error(`HTTP ${response.status}`);
+      if (response.headers.get("consentlayer-forwarding") === "off") serverEndpoint = void 0;
+      if (response.headers.get("consentlayer-consent") === "missing") restoreConsentCookie();
+    }).catch(fail);
+  };
+  const sharedIdentity = () => consent?.marketing ? identity : identity.userId ? { userId: identity.userId } : {};
+  const persistIdentity = () => {
+    const stored2 = sharedIdentity();
+    if (Object.keys(stored2).length && (consent?.analytics || consent?.marketing)) identityStorage.write(stored2);
+    else identityStorage.clear?.();
+  };
+  const context = (providerId) => ({
+    consent,
+    identity: sharedIdentity(),
+    debug: Boolean(options.debug),
+    log: (message, ...data) => debugLog("providers", providerId, message, ...data),
+    emitError: providerEmitError(providerId)
+  });
+  const call = async (state, hook, run, ...detail) => {
+    if (destroyed) return false;
+    const { plugin } = state;
+    if (state.backlog && !LIFECYCLE_HOOKS.has(hook)) {
+      enqueue(state.backlog, () => call(state, hook, run, ...detail), plugin.id);
+      return Boolean(plugin[hook]);
+    }
+    if (plugin[hook]) debugLog(HOOK_TOPICS[hook], plugin.id, `${plugin.id}.${hook}`, ...detail);
+    try {
+      await run(plugin, context(plugin.id));
+    } catch (error) {
+      emitError({
+        scope: hook === "reset" || hook === "group" ? "provider-identify" : `provider-${hook}`,
+        providerId: plugin.id,
+        message: `${plugin.id}.${hook} failed`,
+        cause: error
+      });
+    }
+    return Boolean(plugin[hook]);
+  };
+  const ensureProviderState = (plugin) => {
+    const existing = providerStates.get(plugin.id);
+    if (existing) {
+      if (existing.plugin !== plugin) {
+        emitError({
+          scope: "provider-setup",
+          providerId: plugin.id,
+          message: `Another provider already uses the id "${plugin.id}"; this one is ignored`
+        });
+      }
+      return existing;
+    }
+    const created = { plugin, setup: false, loaded: false, active: false };
+    providerStates.set(plugin.id, created);
+    return created;
+  };
+  const teardown = async (state) => {
+    if (!state.active) return;
+    state.active = false;
+    await call(state, "teardown", (plugin, ctx) => plugin.teardown?.(ctx));
+  };
+  const setupProvider = async (state) => {
+    if (state.setup) return;
+    state.setup = true;
+    await call(state, "setup", (p, ctx) => p.setup?.(ctx));
+  };
+  const evaluateProvider = async (state) => {
+    if (!booted || !runtimeEnabled()) return teardown(state);
+    const { plugin } = state;
+    const allowed = hasRequiredConsent(consent, plugin.requiredConsent);
+    await setupProvider(state);
+    await call(state, "consent", (p, ctx) => p.consent?.(ctx));
+    if (!state.loaded && (allowed || plugin.loadBeforeConsent)) {
+      state.loaded = true;
+      if (plugin.defer) deferLoad(state, plugin.defer);
+      else await call(state, "load", (p, ctx) => p.load?.(ctx));
+    }
+    if (!allowed) return teardown(state);
+    if (state.active) return;
+    state.active = true;
+    if (Object.keys(sharedIdentity()).length && !identifyQueued) {
+      await call(state, "identify", (p, ctx) => p.identify?.(sharedIdentity(), {}, ctx));
+    }
+  };
+  const deferLoad = (state, timing) => {
+    state.backlog = [];
+    void whenDue(timing, lifetime.signal).then(() => {
+      lifecycleQueue = lifecycleQueue.then(async () => {
+        const backlog = state.backlog ?? [];
+        state.backlog = void 0;
+        if (!state.active && !state.plugin.loadBeforeConsent) {
+          state.loaded = false;
+          return;
+        }
+        await call(state, "load", (p, ctx) => p.load?.(ctx));
+        for (const run of backlog) if (state.active) await run();
+      });
+    });
+  };
+  const runLifecycle = async () => {
+    const evaluated = consent;
+    for (const state of providerStates.values()) {
+      await evaluateProvider(state);
+    }
+    if (options.autoTracking && !pageSession && booted && evaluated?.analytics && isBrowser()) {
+      pageSession = () => {
+      };
+      try {
+        pageSession = options.autoTracking({ track: api.track, signal: lifetime.signal });
+        pageSession();
+      } catch (cause) {
+        emitError({ scope: "auto-tracking", message: "Auto-tracking failed to start", cause });
+      }
+    }
+    notify();
+  };
+  const queueLifecycle = async () => {
+    lifecycleQueue = lifecycleQueue.then(runLifecycle);
+    await lifecycleQueue;
+  };
+  const labelTopic = (label) => label === "captureError" ? "errors" : "events";
+  const trackAgainstProviders = async (label, selectedProviderIds, callback, serverEvent) => {
+    if (destroyed) return;
+    if (!runtimeEnabled()) return debugLog(labelTopic(label), void 0, `${label} dropped: enabled is false`);
+    if (!ready) {
+      debugLog(labelTopic(label), void 0, `${label} held until boot`);
+      enqueue(pending, () => deliver(label, selectedProviderIds, callback, serverEvent));
+      return;
+    }
+    await deliver(label, selectedProviderIds, callback, serverEvent);
+  };
+  const deliver = async (label, selectedProviderIds, callback, serverEvent) => {
+    if (destroyed) return;
+    const event = serverEvent?.();
+    if (event) forward(event);
+    let reached = 0;
+    for (const state of providerStates.values()) {
+      if (!state.active) continue;
+      if (!hasRequiredConsent(consent, state.plugin.requiredConsent)) continue;
+      if (selectedProviderIds && !selectedProviderIds.includes(state.plugin.id)) {
+        continue;
+      }
+      if (await callback(state)) reached += 1;
+    }
+    if (!reached) debugLog(labelTopic(label), void 0, `${label} reached no provider`);
+  };
+  const identifyProviders = (traits, only) => trackAgainstProviders(
+    "identify",
+    only,
+    (state) => call(state, "identify", (p, ctx) => p.identify?.(sharedIdentity(), traits, ctx), traits)
+  );
+  if (options.consentEngine) {
+    unsubscribeConsent = options.consentEngine.subscribe(({ consent: nextConsent }) => {
+      void api.updateConsent(nextConsent);
+    });
+  }
+  for (const provider of options.providers ?? []) {
+    const state = ensureProviderState(provider);
+    if (isBrowser() && runtimeEnabled()) void setupProvider(state);
+  }
+  const errorsEnabled = options.errors !== false;
+  const reportedErrors = /* @__PURE__ */ new WeakSet();
+  const onWindowError = (event) => void api.captureError(event.error ?? event.message, { source: "global", level: "fatal" });
+  const onRejection = (event) => void api.captureError(event.reason, { source: "global" });
+  const globalHandlers = errorsEnabled && isBrowser() && !(typeof options.errors === "object" && options.errors.globalHandlers === false);
+  const api = {
+    async boot() {
+      if (destroyed || booted) return;
+      booted = true;
+      debugLog("providers", void 0, "boot");
+      if (globalHandlers) {
+        window.addEventListener("error", onWindowError);
+        window.addEventListener("unhandledrejection", onRejection);
+      }
+      await queueLifecycle();
+      for (let run = pending.shift(); run; run = pending.shift()) await run();
+      ready = true;
+      identifyQueued = false;
+    },
+    registerProvider(provider) {
+      const state = ensureProviderState(provider);
+      if (booted) void queueLifecycle();
+      else notify();
+      return () => {
+        if (!providerStates.has(provider.id)) return;
+        void teardown(state);
+        providerStates.delete(provider.id);
+        notify();
+      };
+    },
+    async updateConsent(nextConsent) {
+      const hadMarketing = Boolean(consent?.marketing);
+      const hadContact = Boolean(identity.email || identity.phone);
+      const wasActive = [...providerStates.values()].filter((state) => state.active).map((state) => state.plugin.id);
+      consent = nextConsent;
+      if (!nextConsent) storedContact = void 0;
+      settleStoredContact();
+      if (nextConsent && !nextConsent.marketing) {
+        identity = identity.userId ? { userId: identity.userId } : {};
+      }
+      persistIdentity();
+      await queueLifecycle();
+      if (!hadContact || hadMarketing === Boolean(nextConsent?.marketing)) return;
+      if (hadMarketing) {
+        for (const state of providerStates.values()) {
+          if (state.active) await call(state, "identify", (p, ctx) => p.identify?.(sharedIdentity(), {}, ctx));
+          else if (state.setup) await call(state, "reset", (p, ctx) => p.reset?.(ctx));
+        }
+      } else if (wasActive.length) {
+        await identifyProviders({}, wasActive);
+      }
+    },
+    getConsent() {
+      return consent;
+    },
+    async page(payload = {}, { only, server } = {}) {
+      const page = { ...getWindowLocation(), ...payload, id: createEventId() };
+      await trackAgainstProviders(
+        "page",
+        only,
+        (state) => call(state, "page", (p, ctx) => p.page?.(page, ctx), page),
+        () => server === false ? void 0 : { id: page.id, name: "page_view", url: page.url, only: server ? void 0 : only }
+      );
+    },
+    async track(name, params, optionsInput = {}) {
+      const event = {
+        id: optionsInput.eventId ?? createEventId(),
+        name,
+        params: params ?? {},
+        options: optionsInput
+      };
+      const allowed = () => !(optionsInput.requireAnalyticsConsent && !consent?.analytics) && !(optionsInput.requireMarketingConsent && !consent?.marketing);
+      await trackAgainstProviders(
+        name,
+        optionsInput.only,
+        async (state) => allowed() && await call(state, "track", (p, ctx) => allowed() ? p.track?.(event, ctx) : void 0, name, event.params),
+        () => allowed() ? {
+          id: event.id,
+          name,
+          params: event.params,
+          url: getWindowLocation().url,
+          only: optionsInput.only,
+          providers: optionsInput.providers
+        } : void 0
+      );
+    },
+    async identify(userId, traits = {}) {
+      if (userId && userId !== identity.userId) identity = {};
+      identity = {
+        ...identity,
+        ...normalizeIdentity({ userId, email: traits.email, phone: traits.phone })
+      };
+      persistIdentity();
+      if (!ready) identifyQueued = true;
+      await identifyProviders(
+        Object.fromEntries(Object.entries(traits).filter(([key]) => key !== "email" && key !== "phone"))
+      );
+    },
+    async reset() {
+      identity = {};
+      storedContact = void 0;
+      identityStorage.clear?.();
+      for (const state of providerStates.values()) {
+        if (!state.setup) continue;
+        await call(state, "reset", (p, ctx) => p.reset?.(ctx));
+      }
+    },
+    async group(groupId, traits = {}) {
+      await trackAgainstProviders(
+        "group",
+        void 0,
+        (state) => call(state, "group", (p, ctx) => p.group?.(groupId, traits, ctx), groupId, traits)
+      );
+    },
+    async captureError(error, errorContext = {}) {
+      if (!errorsEnabled) return;
+      if (typeof error === "object" && error !== null) {
+        if (reportedErrors.has(error)) return;
+        reportedErrors.add(error);
+      }
+      const captured = { source: "manual", ...errorContext };
+      await trackAgainstProviders(
+        "captureError",
+        void 0,
+        (state) => call(state, "error", (p, ctx) => p.error?.(error, captured, ctx), error)
+      );
+    },
+    newPageSession() {
+      try {
+        pageSession?.();
+      } catch (cause) {
+        emitError({ scope: "auto-tracking", message: "Auto-tracking failed to start a page session", cause });
+      }
+    },
+    getSnapshot() {
+      return currentSnapshot;
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    destroy() {
+      for (const state of providerStates.values()) void teardown(state);
+      destroyed = true;
+      lifetime.abort();
+      unsubscribeConsent?.();
+      if (globalHandlers) {
+        window.removeEventListener("error", onWindowError);
+        window.removeEventListener("unhandledrejection", onRejection);
+      }
+      providerStates.clear();
+      listeners.clear();
+    }
+  };
+  return api;
+}
+
+export { createAnalyticsManager, createLocalStorageConsentStorage, createLocalStorageIdentityStorage, createMemoryConsentStorage, createMemoryIdentityStorage };
+//# sourceMappingURL=chunk-LEAQJXJU.js.map
+//# sourceMappingURL=chunk-LEAQJXJU.js.map