consentlayer 0.0.0 → 1.0.0-rc.0

package/dist/types-BV_AFZKQ.d.ts

@@ -0,0 +1,407 @@
+/**
+ * Your own consent categories. Declare them here and pass them to `createAnalytics({ categories })`:
+ * `declare module 'consentlayer' { interface ConsentCategories { functional: true } }`
+ */
+interface ConsentCategories {
+}
+/** A category the visitor can toggle: the built-in ones plus yours. */
+type ConsentCategory = keyof ({
+    preferences: true;
+    analytics: true;
+    marketing: true;
+} & ConsentCategories);
+/** Consent per category. Necessary cookies are always allowed, so they have no flag. */
+type ConsentState = Record<ConsentCategory, boolean> & {
+    sale_of_data?: boolean;
+};
+/** What a plugin needs before it runs: a category, `'none'`, or a custom check. */
+type ProviderConsentRequirement = keyof ConsentState | 'none' | ((consent: ConsentState | null) => boolean);
+/** Who the visitor is, once known. Stored only with analytics or marketing consent. */
+type UserIdentity = {
+    userId?: string;
+    email?: string;
+    phone?: string;
+};
+/** Extra traits passed to `identify`; `email` and `phone` also update the identity. */
+type UserTraits = Record<string, unknown> & {
+    email?: string;
+    phone?: string;
+};
+/** Where a consent change came from. */
+type ConsentChangeSource = 'bootstrap' | 'storage' | 'adapter' | 'imperative' | 'unknown';
+/** DOM event names and window globals that announce consent changes to other scripts. */
+type ConsentBroadcastConfig = {
+    eventName?: string | string[];
+    globalKey?: string | string[];
+    document?: Document;
+    window?: Window;
+};
+/** Where consent is kept. Defaults to localStorage. */
+/** A stored choice: the consent, when it was made (epoch ms) and under which `policyVersion`. */
+type StoredConsent = {
+    consent: ConsentState;
+    updatedAt?: number;
+    policyVersion?: string;
+};
+interface ConsentStorageAdapter {
+    read(): StoredConsent | null;
+    write(record: StoredConsent | null): void;
+    subscribe?(listener: () => void): () => void;
+    clear?(): void;
+}
+/** Where the visitor identity is kept. Defaults to localStorage. */
+interface IdentityStorageAdapter {
+    read(): UserIdentity;
+    write(identity: Partial<UserIdentity>): void;
+    clear?(): void;
+}
+/** Syncs consent with an outside consent platform: reads its choice at boot, pushes changes to it, and listens for its updates. */
+interface ConsentIntegrationAdapter {
+    id: string;
+    /** Its bootstrap answer replaces the stored choice, which is used only when it answers `null` or fails. */
+    authoritative?: boolean;
+    bootstrap?(): Promise<ConsentState | null> | ConsentState | null;
+    apply?(consent: ConsentState): Promise<void> | void;
+    subscribe?(onConsent: (consent: ConsentState) => void): (() => void) | void;
+    /** Runs when the engine is created and after every consent change, whatever its source. */
+    observe?(consent: ConsentState | null): void;
+}
+type ConsentEngineOptions = {
+    storage?: ConsentStorageAdapter;
+    adapters?: ConsentIntegrationAdapter[];
+    initialConsent?: ConsentState | null;
+    /** Your own categories, on top of preferences, analytics and marketing. */
+    categories?: (keyof ConsentCategories)[];
+    broadcast?: ConsentBroadcastConfig;
+    /** A stored choice older than this many days is stale. Unset, never. */
+    maxAgeDays?: number;
+    /** A stored choice made under another major version (the part before the first `.`), or none, is stale. Unset, never. */
+    policyVersion?: string;
+    /** `'discard'` treats a stale choice as no choice; `'keep'` keeps it in force until the visitor chooses again. Either way the banner shows. */
+    onStale?: 'discard' | 'keep';
+    /** Honor the browser's Global Privacy Control signal: "accept all" leaves marketing off while it is on. Defaults to `true`. */
+    gpc?: boolean;
+    debug?: boolean | DebugOptions;
+    onError?: AnalyticsErrorHandler;
+};
+/** What consent subscribers receive. */
+type ConsentEngineSnapshot = {
+    consent: ConsentState | null;
+};
+interface ConsentEngine {
+    /** Every category the visitor can toggle, built-in first. */
+    categories: readonly ConsentCategory[];
+    /** Whether the browser sends the Global Privacy Control signal and the `gpc` option honors it. */
+    gpc: boolean;
+    bootstrap: () => Promise<ConsentState | null>;
+    getConsent: () => ConsentState | null;
+    /** Whether the stored choice is stale and the visitor should be asked again. */
+    isStale: () => boolean;
+    setConsent: (consent: ConsentState, source?: ConsentChangeSource) => Promise<void>;
+    subscribe: (listener: (snapshot: ConsentEngineSnapshot) => void) => () => void;
+    destroy: () => void;
+}
+/** When providers load: right away, when the browser is idle, or when you call `analytics.boot()`. */
+type LazyBootMode = 'immediate' | 'idle' | 'manual';
+/** When providers load, and how long to wait for idle time. */
+type LazyBootConfig = {
+    mode?: LazyBootMode;
+    timeoutMs?: number;
+};
+/** `'all'` tracks clicks on elements matching `selectors`; `'attribute'` only elements with the tracking attribute. */
+type AutoTrackingClickMode = 'all' | 'attribute';
+/** Which clicks are tracked automatically. */
+type AutoTrackingClickConfig = {
+    mode?: AutoTrackingClickMode;
+    attribute?: string;
+    selectors?: string[];
+};
+/** Scroll depths (percent) that send an event. */
+type AutoTrackingScrollConfig = {
+    thresholds?: number[];
+};
+/** Seconds on page that send an event. */
+type AutoTrackingTimeConfig = {
+    intervals?: number[];
+};
+/** Events tracked without code. `true` uses the defaults for that kind. */
+type AutoTrackingConfig = {
+    clicks?: boolean | AutoTrackingClickConfig;
+    scroll?: boolean | AutoTrackingScrollConfig;
+    timeOnPage?: boolean | AutoTrackingTimeConfig;
+    pageViews?: boolean;
+    /** Send auto-tracked events only to these provider ids. Defaults to all. */
+    only?: string[];
+};
+/** What `autoTracking()` returns: started once with `track` and a signal aborted on `destroy()`, it returns the function that starts a page session. */
+type AutoTracking = (context: {
+    track: (name: string, params: Record<string, unknown>, options: TrackEventOptions) => Promise<void>;
+    signal: AbortSignal;
+}) => () => void;
+/** Page view details; read from `location` and `document.title` when omitted. */
+type PageViewPayload = {
+    url?: string;
+    path?: string;
+    title?: string;
+};
+/** Per-event options for `track`. */
+type TrackEventOptions = {
+    requireAnalyticsConsent?: boolean;
+    requireMarketingConsent?: boolean;
+    /** Send only to these provider ids. */
+    only?: string[];
+    /** Shared by browser and server so providers can dedupe. Generated if omitted. */
+    eventId?: string;
+    /** Extra params merged into what a single provider sends, keyed by provider id. */
+    providers?: Record<string, Record<string, unknown>>;
+};
+/** An event as plugins receive it. */
+type AnalyticsEventPayload = {
+    id: string;
+    name: string;
+    params: Record<string, unknown>;
+    options: TrackEventOptions;
+};
+/** A product line in GA4 item format. */
+type EcommerceItem = {
+    item_id: string;
+    item_name?: string;
+    item_variant?: string;
+    item_brand?: string;
+    item_category?: string;
+    price?: number;
+    quantity?: number;
+    discount?: number;
+    coupon?: string;
+};
+type Money = {
+    value?: number;
+    currency?: string;
+};
+type EcommerceParams = Money & {
+    items?: EcommerceItem[];
+};
+/** Standard events every provider translates, named after GA4's. Any other name is sent as a custom event. */
+interface StandardEvents {
+    sign_up: {
+        method?: string;
+    };
+    login: {
+        method?: string;
+    };
+    search: {
+        search_term: string;
+    };
+    lead: Money;
+    share: {
+        method?: string;
+        content_type?: string;
+        item_id?: string;
+    };
+    contact: {
+        method?: string;
+    };
+    view_item: EcommerceParams;
+    view_item_list: EcommerceParams & {
+        item_list_id?: string;
+        item_list_name?: string;
+    };
+    add_to_cart: EcommerceParams;
+    remove_from_cart: EcommerceParams;
+    add_to_wishlist: EcommerceParams;
+    begin_checkout: EcommerceParams & {
+        coupon?: string;
+    };
+    add_payment_info: EcommerceParams & {
+        payment_type?: string;
+    };
+    add_shipping_info: EcommerceParams & {
+        shipping_tier?: string;
+    };
+    purchase: EcommerceParams & {
+        transaction_id: string;
+        tax?: number;
+        shipping?: number;
+        coupon?: string;
+    };
+    refund: EcommerceParams & {
+        transaction_id: string;
+    };
+    trial_started: Money & {
+        plan?: string;
+    };
+    subscription_started: Money & {
+        plan?: string;
+    };
+    subscription_cancelled: {
+        plan?: string;
+        reason?: string;
+    };
+}
+/** Params for an event: typed for the standard events, free-form for the rest. */
+type EventParams<Name extends string> = Name extends keyof StandardEvents ? StandardEvents[Name] & Record<string, unknown> : Record<string, unknown>;
+/** What `analytics.subscribe` listeners receive. */
+type AnalyticsManagerStateSnapshot = {
+    booted: boolean;
+    consent: ConsentState | null;
+    activeProviders: string[];
+};
+/** Which step failed. */
+type AnalyticsErrorScope = 'provider-setup' | 'provider-load' | 'provider-consent' | 'provider-page' | 'provider-track' | 'provider-identify' | 'provider-error' | 'provider-teardown' | 'provider-script-load' | 'server-forward' | 'consent-adapter' | 'auto-tracking' | 'queue-full';
+/** A failure inside a provider, the server forward or a consent adapter, or a full call queue. Never thrown; passed to `onError`. */
+type AnalyticsError = {
+    scope: AnalyticsErrorScope;
+    providerId?: string;
+    message: string;
+    cause?: unknown;
+};
+/** `consent`: changes and stale choices. `events`: page views, `track`, `identify`, `group` and `reset`, per provider. `providers`: boot and each provider's setup, consent, load and teardown. `errors`: `AnalyticsError`s and `captureError` deliveries. */
+type DebugTopic = 'consent' | 'events' | 'providers' | 'errors';
+type DebugEntry = {
+    topic: DebugTopic;
+    provider?: string;
+    message: string;
+    data: unknown[];
+};
+/** Topics set to `true` are logged; with none set to `true`, every topic not set to `false` is. */
+type DebugOptions = Partial<Record<DebugTopic, boolean>> & {
+    /** Drops entries about other providers. Entries about no provider are kept. */
+    only?: string[];
+    /** Receives each entry instead of `console.debug`. */
+    logger?: (entry: DebugEntry) => void;
+};
+/** Receives every `AnalyticsError`. */
+type AnalyticsErrorHandler = (error: AnalyticsError) => void;
+type AnalyticsManagerOptions = {
+    providers?: AnalyticsPlugin[];
+    consent?: ConsentState | null;
+    consentEngine?: ConsentEngine;
+    identityStorage?: IdentityStorageAdapter;
+    enabled?: boolean | (() => boolean);
+    debug?: boolean | DebugOptions;
+    /** `autoTracking()` from `consentlayer/auto-tracking`. Starts once analytics consent is granted; off by default. */
+    autoTracking?: AutoTracking;
+    onError?: AnalyticsErrorHandler;
+    /**
+     * `captureError` and the window `error` / `unhandledrejection` handlers.
+     * `false` turns both off; `{ globalHandlers: false }` keeps only `captureError`.
+     */
+    errors?: boolean | {
+        globalHandlers?: boolean;
+    };
+    /** HTTPS URLs or paths starting with "/". */
+    server?: {
+        /** Also send each event to this route (see `createAnalyticsHandler`). */
+        endpoint?: string;
+        /** Post each consent choice to this route (see `createConsentHandler`). */
+        consentEndpoint?: string;
+    };
+};
+/** What the browser sends to the server, and what `sendServerEvent` takes. */
+type ServerEvent = {
+    /** Shared with the browser event so destinations can dedupe. */
+    id?: string;
+    name: string;
+    params?: Record<string, unknown>;
+    /** The consent the event was collected under. */
+    consent: ConsentState;
+    identity?: UserIdentity;
+    url?: string;
+    /** GA4 client ID; read from the `_ga` cookie when omitted. */
+    clientId?: string;
+    only?: string[];
+    providers?: Record<string, Record<string, unknown>>;
+};
+/** What plugins receive on each call. */
+type PluginContext = {
+    consent: ConsentState | null;
+    identity: UserIdentity;
+    /** Whether the `debug` option is on. */
+    debug: boolean;
+    /** Logs under the `providers` debug topic, attributed to this plugin. */
+    log: (message: string, ...data: unknown[]) => void;
+    emitError: AnalyticsErrorHandler;
+};
+/** A page view as plugins receive it. */
+type PageEvent = PageViewPayload & {
+    /** Shared by browser and server so providers can dedupe. */
+    id: string;
+};
+/** Extra details for `captureError`. */
+type ErrorContext = {
+    level?: 'fatal' | 'error' | 'warning';
+    tags?: Record<string, string>;
+    extra?: Record<string, unknown>;
+    /** Where it was caught. */
+    source?: 'manual' | 'global' | 'boundary';
+};
+/**
+ * When `load` runs once consent allows it: right away (default), when the
+ * browser is idle, on the first interaction, or after a delay in ms. Calls made
+ * meanwhile are held (up to 100) and delivered after `load`.
+ */
+type LoadTiming = false | 'idle' | 'interaction' | number;
+type Hook<Args extends unknown[] = []> = (...args: [...Args, PluginContext]) => Promise<void> | void;
+/**
+ * A provider. The manager decides when each hook runs:
+ * `setup` when the instance is created in the browser, or else at boot;
+ * `load` once, when `requiredConsent` is granted (at boot
+ * with `loadBeforeConsent`, or when there is no `load`); then `consent` on
+ * every consent change. `page`, `track`, `identify` and `group` run only
+ * while consent is granted; a withdrawal runs `teardown`. Errors go to
+ * `onError` and never reach other plugins.
+ */
+interface AnalyticsPlugin {
+    id: string;
+    /** The consent the provider needs. `'none'` runs it without consent. */
+    requiredConsent: ProviderConsentRequirement;
+    /** Load before consent and rely on the provider's own consent mode. */
+    loadBeforeConsent?: boolean;
+    defer?: LoadTiming;
+    /** No network, no cookies. */
+    setup?: Hook;
+    /** Inject scripts. Runs once. */
+    load?: Hook;
+    /** Apply the current consent state. */
+    consent?: Hook;
+    page?: Hook<[page: PageEvent]>;
+    track?: Hook<[event: AnalyticsEventPayload]>;
+    identify?: Hook<[identity: UserIdentity, traits: UserTraits]>;
+    reset?: Hook;
+    group?: Hook<[groupId: string, traits: Record<string, unknown>]>;
+    /** Receives errors from `captureError` and the global handlers. */
+    error?: Hook<[error: unknown, context: ErrorContext]>;
+    /** Stop sending; remove cookies where possible. */
+    teardown?: Hook;
+}
+interface AnalyticsManager {
+    boot: () => Promise<void>;
+    registerProvider: (provider: AnalyticsPlugin) => () => void;
+    updateConsent: (consent: ConsentState | null) => Promise<void>;
+    getConsent: () => ConsentState | null;
+    /** `only` limits which providers and server destinations receive it; `server: true` ignores it for the server, `false` skips the server. */
+    page: (payload?: PageViewPayload, options?: {
+        only?: string[];
+        server?: boolean;
+    }) => Promise<void>;
+    track: <Name extends string>(name: Name, params?: EventParams<Name>, options?: TrackEventOptions) => Promise<void>;
+    identify: (userId?: string, traits?: UserTraits) => Promise<void>;
+    reset: () => Promise<void>;
+    group: (groupId: string, traits?: Record<string, unknown>) => Promise<void>;
+    captureError: (error: unknown, context?: ErrorContext) => Promise<void>;
+    newPageSession: () => void;
+    getSnapshot: () => AnalyticsManagerStateSnapshot;
+    subscribe: (listener: (snapshot: AnalyticsManagerStateSnapshot) => void) => () => void;
+    destroy: () => void;
+}
+/** Reads and changes consent: `analytics.consent`. */
+type ConsentApi = Omit<ConsentEngine, 'destroy'> & {
+    /** Merges into the current consent; categories left out stay as they are (denied if unset). */
+    update(partial: Partial<ConsentState>): Promise<void>;
+};
+/** The instance `createAnalytics` returns. */
+type Analytics = Omit<AnalyticsManager, 'updateConsent' | 'getConsent'> & {
+    consent: ConsentApi;
+};
+
+export type { AutoTrackingConfig as A, ConsentChangeSource as B, ConsentIntegrationAdapter as C, ConsentEngineSnapshot as D, EcommerceItem as E, DebugEntry as F, DebugOptions as G, DebugTopic as H, IdentityStorageAdapter as I, EventParams as J, LazyBootMode as K, LoadTiming as L, ServerEvent as M, PluginContext as P, StandardEvents as S, TrackEventOptions as T, UserIdentity as U, AutoTracking as a, AutoTrackingClickConfig as b, AutoTrackingClickMode as c, AutoTrackingScrollConfig as d, AutoTrackingTimeConfig as e, AnalyticsPlugin as f, PageEvent as g, AnalyticsEventPayload as h, UserTraits as i, ProviderConsentRequirement as j, ConsentCategory as k, ErrorContext as l, Analytics as m, PageViewPayload as n, LazyBootConfig as o, ConsentState as p, ConsentApi as q, AnalyticsManagerOptions as r, ConsentEngineOptions as s, ConsentStorageAdapter as t, AnalyticsError as u, AnalyticsErrorHandler as v, AnalyticsErrorScope as w, AnalyticsManagerStateSnapshot as x, ConsentBroadcastConfig as y, ConsentCategories as z };

package/dist/vue.d.ts

@@ -0,0 +1,92 @@
+import * as vue from 'vue';
+import { Ref, Plugin } from 'vue';
+import { C as ConsentControllerState, a as ConsentControllerActions, b as ConsentControllerOptions } from './consent-controller-DyHPNfyT.js';
+import { m as Analytics, n as PageViewPayload, p as ConsentState, q as ConsentApi } from './types-BV_AFZKQ.js';
+
+type RouteLike = {
+    fullPath: string;
+};
+/** The part of a Vue Router instance ConsentLayer uses. */
+type RouterLike = {
+    currentRoute: {
+        value: RouteLike;
+    };
+    isReady: () => Promise<void>;
+    afterEach: (guard: (to: RouteLike, from: RouteLike, failure?: unknown) => unknown) => () => void;
+};
+/** Options for `app.use(consentLayer, options)`. */
+type ConsentLayerOptions = ConsentControllerOptions & {
+    analytics: Analytics;
+    /** Sends a page view on every navigation. Without it, one page view is sent for the page load. */
+    router?: RouterLike;
+    page?: PageViewPayload;
+    /** Sends errors from `app.config.errorHandler` through `captureError`. Defaults to `true`. */
+    captureErrors?: boolean;
+};
+/** What `useConsentController()` returns: the UI state as refs, and the actions. */
+type ConsentController = {
+    readonly [Key in keyof ConsentControllerState]: Readonly<Ref<ConsentControllerState[Key]>>;
+} & ConsentControllerActions;
+/** Boots analytics, sends page views on navigation and provides the state for your consent UI. */
+declare const consentLayer: Plugin<[ConsentLayerOptions]>;
+/** The instance from `app.use(consentLayer)`, else the one `createAnalytics()` made. */
+declare function useAnalytics(): Analytics;
+/** Current consent as a ref, `null` before a choice. */
+declare function useConsent(): {
+    consent: Readonly<Ref<ConsentState | null>>;
+    engine: ConsentApi;
+    setConsent: (consent: ConsentState) => Promise<void>;
+    update: (partial: Partial<ConsentState>) => Promise<void>;
+};
+/** State and actions for building your own consent UI. */
+declare function useConsentController(): ConsentController;
+/**
+ * Meta's `<noscript>` PageView pixel. It fires only for visitors without
+ * JavaScript, who never see the consent banner, so it tracks them without
+ * consent. Render it only where that is lawful for you. Renders nothing without
+ * `enabled` or while `pixelId` is unset. Other attributes go to the `<img>`.
+ */
+declare const MetaPixelNoscript: vue.DefineComponent<vue.ExtractPropTypes<{
+    pixelId: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    enabled: BooleanConstructor;
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    pixelId: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    enabled: BooleanConstructor;
+}>> & Readonly<{}>, {
+    enabled: boolean;
+    pixelId: string;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+/**
+ * Google Tag Manager's `<noscript>` iframe. It loads the container only for
+ * visitors without JavaScript, who never see the consent banner, so its tags
+ * run without consent. Render it only where that is lawful for you. Renders
+ * nothing without `enabled` or while `containerId` is unset. Other attributes go to the `<iframe>`.
+ */
+declare const GtmNoscript: vue.DefineComponent<vue.ExtractPropTypes<{
+    containerId: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    enabled: BooleanConstructor;
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    containerId: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    enabled: BooleanConstructor;
+}>> & Readonly<{}>, {
+    enabled: boolean;
+    containerId: string;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+export { type ConsentController, type ConsentLayerOptions, GtmNoscript, MetaPixelNoscript, type RouterLike, consentLayer, useAnalytics, useConsent, useConsentController };

package/dist/vue.js

@@ -0,0 +1,97 @@
+import { metaNoscriptImg, gtmNoscriptIframe } from './chunk-VIIGBALD.js';
+import { createConsentController, latestAnalytics } from './chunk-FDJMIJFV.js';
+import { defineComponent, h, shallowRef, inject, getCurrentScope, onScopeDispose, computed } from 'vue';
+
+var AnalyticsKey = /* @__PURE__ */ Symbol("consentlayer.analytics");
+var ControllerKey = /* @__PURE__ */ Symbol("consentlayer.controller");
+var routeKey = (route) => route.fullPath.replace(/#.*$/, "");
+var consentLayer = {
+  install(app, { analytics, router, page, captureErrors = true, ...options }) {
+    const controller = createConsentController(analytics, options);
+    const state = shallowRef(controller.getSnapshot());
+    const field = (key) => computed(() => state.value[key]);
+    app.provide(AnalyticsKey, analytics);
+    app.provide(ControllerKey, {
+      ready: field("ready"),
+      error: field("error"),
+      bannerVisible: field("bannerVisible"),
+      dialogVisible: field("dialogVisible"),
+      categories: field("categories"),
+      gpc: field("gpc"),
+      prefs: field("prefs"),
+      ...controller.actions
+    });
+    if (typeof window === "undefined") return;
+    if (captureErrors) {
+      const previous = app.config.errorHandler;
+      app.config.errorHandler = (error, instance, info) => {
+        void analytics.captureError(error, { source: "boundary", tags: { vue_info: info } });
+        if (previous) previous(error, instance, info);
+        else console.error(error);
+      };
+    }
+    const unsubscribe = controller.subscribe(() => {
+      state.value = controller.getSnapshot();
+    });
+    const stop = controller.start();
+    let stopRouter = () => {
+    };
+    if (router) {
+      stopRouter = router.afterEach((to, _from, failure) => {
+        if (!failure) controller.setRoute(routeKey(to), page);
+      });
+      void router.isReady().then(() => controller.setRoute(routeKey(router.currentRoute.value), page));
+    } else {
+      controller.setRoute("default", page);
+    }
+    app.onUnmount(() => {
+      stopRouter();
+      stop();
+      unsubscribe();
+    });
+  }
+};
+function useAnalytics() {
+  const analytics = inject(AnalyticsKey, void 0) ?? latestAnalytics();
+  if (!analytics) throw new Error("useAnalytics needs createAnalytics() to have run, or app.use(consentLayer)");
+  return analytics;
+}
+function useConsent() {
+  const analytics = useAnalytics();
+  const consent = shallowRef(analytics.consent.getConsent());
+  const unsubscribe = analytics.consent.subscribe(() => {
+    consent.value = analytics.consent.getConsent();
+  });
+  if (getCurrentScope()) onScopeDispose(unsubscribe);
+  return {
+    consent,
+    engine: analytics.consent,
+    setConsent: (next) => analytics.consent.setConsent(next),
+    update: (partial) => analytics.consent.update(partial)
+  };
+}
+function useConsentController() {
+  const controller = inject(ControllerKey, void 0);
+  if (!controller) throw new Error("useConsentController needs app.use(consentLayer)");
+  return controller;
+}
+var MetaPixelNoscript = defineComponent({
+  name: "MetaPixelNoscript",
+  inheritAttrs: false,
+  props: { pixelId: { type: String, default: void 0 }, enabled: Boolean },
+  setup(props, { attrs }) {
+    return () => props.enabled && props.pixelId ? h("noscript", { innerHTML: metaNoscriptImg(props.pixelId, attrs) }) : null;
+  }
+});
+var GtmNoscript = defineComponent({
+  name: "GtmNoscript",
+  inheritAttrs: false,
+  props: { containerId: { type: String, default: void 0 }, enabled: Boolean },
+  setup(props, { attrs }) {
+    return () => props.enabled && props.containerId ? h("noscript", { innerHTML: gtmNoscriptIframe(props.containerId, attrs) }) : null;
+  }
+});
+
+export { GtmNoscript, MetaPixelNoscript, consentLayer, useAnalytics, useConsent, useConsentController };
+//# sourceMappingURL=vue.js.map
+//# sourceMappingURL=vue.js.map

package/dist/vue.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/vue.ts"],"names":[],"mappings":"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","file":"vue.js","sourcesContent":["import {\n  computed,\n  defineComponent,\n  getCurrentScope,\n  h,\n  inject,\n  onScopeDispose,\n  shallowRef,\n  type App,\n  type InjectionKey,\n  type Plugin,\n  type Ref,\n} from 'vue'\nimport {\n  createConsentController,\n  type ConsentControllerActions,\n  type ConsentControllerOptions,\n  type ConsentControllerState,\n} from './core/consent-controller'\nimport { latestAnalytics } from './core/create-analytics'\nimport { gtmNoscriptIframe, metaNoscriptImg } from './core/noscript'\nimport type { Analytics, ConsentApi, ConsentState, PageViewPayload } from './core/types'\n\ntype RouteLike = { fullPath: string }\n\n/** The part of a Vue Router instance ConsentLayer uses. */\nexport type RouterLike = {\n  currentRoute: { value: RouteLike }\n  isReady: () => Promise<void>\n  afterEach: (guard: (to: RouteLike, from: RouteLike, failure?: unknown) => unknown) => () => void\n}\n\n/** Options for `app.use(consentLayer, options)`. */\nexport type ConsentLayerOptions = ConsentControllerOptions & {\n  analytics: Analytics\n  /** Sends a page view on every navigation. Without it, one page view is sent for the page load. */\n  router?: RouterLike\n  page?: PageViewPayload\n  /** Sends errors from `app.config.errorHandler` through `captureError`. Defaults to `true`. */\n  captureErrors?: boolean\n}\n\n/** What `useConsentController()` returns: the UI state as refs, and the actions. */\nexport type ConsentController = {\n  readonly [Key in keyof ConsentControllerState]: Readonly<Ref<ConsentControllerState[Key]>>\n} & ConsentControllerActions\n\nconst AnalyticsKey: InjectionKey<Analytics> = Symbol('consentlayer.analytics')\nconst ControllerKey: InjectionKey<ConsentController> = Symbol('consentlayer.controller')\n\nconst routeKey = (route: RouteLike) => route.fullPath.replace(/#.*$/, '')\n\n/** Boots analytics, sends page views on navigation and provides the state for your consent UI. */\nexport const consentLayer: Plugin<[ConsentLayerOptions]> = {\n  install(app: App, { analytics, router, page, captureErrors = true, ...options }: ConsentLayerOptions) {\n    const controller = createConsentController(analytics, options)\n    const state = shallowRef(controller.getSnapshot())\n    const field = <Key extends keyof ConsentControllerState>(key: Key) => computed(() => state.value[key])\n    app.provide(AnalyticsKey, analytics)\n    app.provide(ControllerKey, {\n      ready: field('ready'),\n      error: field('error'),\n      bannerVisible: field('bannerVisible'),\n      dialogVisible: field('dialogVisible'),\n      categories: field('categories'),\n      gpc: field('gpc'),\n      prefs: field('prefs'),\n      ...controller.actions,\n    })\n\n    if (typeof window === 'undefined') return\n    if (captureErrors) {\n      const previous = app.config.errorHandler\n      app.config.errorHandler = (error, instance, info) => {\n        void analytics.captureError(error, { source: 'boundary', tags: { vue_info: info } })\n        if (previous) previous(error, instance, info)\n        else console.error(error)\n      }\n    }\n\n    const unsubscribe = controller.subscribe(() => {\n      state.value = controller.getSnapshot()\n    })\n    const stop = controller.start()\n    let stopRouter = () => {}\n    if (router) {\n      stopRouter = router.afterEach((to, _from, failure) => {\n        if (!failure) controller.setRoute(routeKey(to), page)\n      })\n      void router.isReady().then(() => controller.setRoute(routeKey(router.currentRoute.value), page))\n    } else {\n      controller.setRoute('default', page)\n    }\n    app.onUnmount(() => {\n      stopRouter()\n      stop()\n      unsubscribe()\n    })\n  },\n}\n\n/** The instance from `app.use(consentLayer)`, else the one `createAnalytics()` made. */\nexport function useAnalytics(): Analytics {\n  const analytics = inject(AnalyticsKey, undefined) ?? latestAnalytics()\n  if (!analytics) throw new Error('useAnalytics needs createAnalytics() to have run, or app.use(consentLayer)')\n  return analytics\n}\n\n/** Current consent as a ref, `null` before a choice. */\nexport function useConsent(): {\n  consent: Readonly<Ref<ConsentState | null>>\n  engine: ConsentApi\n  setConsent: (consent: ConsentState) => Promise<void>\n  update: (partial: Partial<ConsentState>) => Promise<void>\n} {\n  const analytics = useAnalytics()\n  const consent = shallowRef(analytics.consent.getConsent())\n  const unsubscribe = analytics.consent.subscribe(() => {\n    consent.value = analytics.consent.getConsent()\n  })\n  if (getCurrentScope()) onScopeDispose(unsubscribe)\n  return {\n    consent,\n    engine: analytics.consent,\n    setConsent: (next) => analytics.consent.setConsent(next),\n    update: (partial) => analytics.consent.update(partial),\n  }\n}\n\n/** State and actions for building your own consent UI. */\nexport function useConsentController(): ConsentController {\n  const controller = inject(ControllerKey, undefined)\n  if (!controller) throw new Error('useConsentController needs app.use(consentLayer)')\n  return controller\n}\n\n/**\n * Meta's `<noscript>` PageView pixel. It fires only for visitors without\n * JavaScript, who never see the consent banner, so it tracks them without\n * consent. Render it only where that is lawful for you. Renders nothing without\n * `enabled` or while `pixelId` is unset. Other attributes go to the `<img>`.\n */\nexport const MetaPixelNoscript = defineComponent({\n  name: 'MetaPixelNoscript',\n  inheritAttrs: false,\n  props: { pixelId: { type: String, default: undefined }, enabled: Boolean },\n  setup(props, { attrs }) {\n    return () =>\n      props.enabled && props.pixelId ? h('noscript', { innerHTML: metaNoscriptImg(props.pixelId, attrs) }) : null\n  },\n})\n\n/**\n * Google Tag Manager's `<noscript>` iframe. It loads the container only for\n * visitors without JavaScript, who never see the consent banner, so its tags\n * run without consent. Render it only where that is lawful for you. Renders\n * nothing without `enabled` or while `containerId` is unset. Other attributes go to the `<iframe>`.\n */\nexport const GtmNoscript = defineComponent({\n  name: 'GtmNoscript',\n  inheritAttrs: false,\n  props: { containerId: { type: String, default: undefined }, enabled: Boolean },\n  setup(props, { attrs }) {\n    return () =>\n      props.enabled && props.containerId\n        ? h('noscript', { innerHTML: gtmNoscriptIframe(props.containerId, attrs) })\n        : null\n  },\n})\n"]}