@d8a-tech/wt 0.1.0

package/dist/install.d.ts

@@ -0,0 +1,23 @@
+import { createQueueConsumer } from "./runtime/queue_consumer.ts";
+import { createDispatcher } from "./runtime/dispatcher.ts";
+import type { WindowLike } from "./types.ts";
+type InstallResult = {
+    consumer: ReturnType<typeof createQueueConsumer>;
+    dispatcher: ReturnType<typeof createDispatcher>;
+    dataLayerName: string;
+    globalName: string;
+};
+/**
+ * Installs the tracker runtime and begins consuming queued `dataLayer` entries.
+ *
+ * This is the programmatic installer used by both consumption modes:
+ * - script-tag bundle (`src/browser_entry.ts`) installs on load
+ * - ESM usage (`src/index.ts`) can call this explicitly
+ */
+export declare function installD8a({ windowRef, dataLayerName, globalName, gtagDataLayerName, }?: {
+    windowRef?: WindowLike;
+    dataLayerName?: unknown;
+    globalName?: unknown;
+    gtagDataLayerName?: unknown;
+}): InstallResult;
+export {};

package/dist/runtime/anon_cid.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Generates a cookieless cid using the same logic as our normal `_d8a` cookie
+ * value generator, but without persisting it anywhere.
+ *
+ * This keeps the cid format consistent across consented and non-consented flows.
+ */
+export declare function generateAnonCid(): string;
+export declare function getOrCreateAnonCid({ windowRef, state, }: {
+    windowRef?: unknown;
+    state?: {
+        anonCid?: string | null;
+    } | null;
+}): string;

package/dist/runtime/browser_context.d.ts

@@ -0,0 +1,2 @@
+import type { BrowserContext, WindowLike } from "../types.ts";
+export declare function getBrowserContext(w: WindowLike): BrowserContext;

package/dist/runtime/config_resolver.d.ts

@@ -0,0 +1,4 @@
+import type { PropertyConfig, RuntimeState } from "../types.ts";
+export declare function getPropertyIds(getState: () => RuntimeState): string[];
+export declare function getPropertyConfig(getState: () => RuntimeState, propertyId: string): PropertyConfig;
+export declare function getSetParams(getState: () => RuntimeState): Record<string, unknown>;

package/dist/runtime/consent_resolver.d.ts

@@ -0,0 +1,7 @@
+import type { ConsentState, RuntimeState } from "../types.ts";
+export declare function getEffectiveConsent(getState: () => RuntimeState): ConsentState;
+export declare function getConsentParts(getState: () => RuntimeState): {
+    consent: ConsentState;
+    consentDefault: ConsentState;
+    consentUpdate: ConsentState;
+};

package/dist/runtime/consent_update_ping.d.ts

@@ -0,0 +1,10 @@
+import type { RuntimeState } from "../types.ts";
+/**
+ * Tracks effective `analytics_storage` and emits a best-effort ping when it changes.
+ *
+ * Behavior:
+ * - Only fires if at least one property is configured.
+ * - Emits `user_engagement` with `consent_update=1` as an event param.
+ * - Uses effective consent (prefers mirrored gtag/GTM consent if present).
+ */
+export declare function maybeEmitConsentUpdatePing(getState: () => RuntimeState): void;

package/dist/runtime/d8a_global.d.ts

@@ -0,0 +1,11 @@
+export declare function createD8aGlobal({ windowRef, dataLayerName, }: {
+    windowRef: import("../types.ts").WindowLike;
+    dataLayerName?: string;
+}): {
+    (..._args: unknown[]): void;
+    js(date: unknown): void;
+    config(propertyId: unknown, params: unknown): void;
+    event(eventName: unknown, params: unknown): void;
+    set(a: unknown, b?: unknown): void;
+    consent(action: unknown, state: unknown): void;
+};

package/dist/runtime/debug_logger.d.ts

@@ -0,0 +1,6 @@
+export declare function createDebugLogger({ enabled }: {
+    enabled?: boolean;
+}): {
+    enabled: boolean;
+    log: (...args: unknown[]) => void;
+};

package/dist/runtime/dispatcher.d.ts

@@ -0,0 +1,18 @@
+import type { RuntimeState, WindowLike } from "../types.ts";
+export declare function createDispatcher({ windowRef, getState, }: {
+    windowRef: WindowLike;
+    getState: () => RuntimeState;
+}): {
+    enqueueEvent: (name: string, params: Record<string, unknown>) => void;
+    flush: ({ useBeacon }: {
+        useBeacon: boolean;
+    }) => Promise<{
+        sent: number;
+    }>;
+    flushNow: ({ useBeacon }?: {
+        useBeacon?: boolean;
+    }) => Promise<{
+        sent: number;
+    }>;
+    attachLifecycleFlush: () => void;
+};

package/dist/runtime/engagement_timer.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Engagement timer
+ *
+ * Counts time only while the page is:
+ * - focused
+ * - visible
+ * - active (not pagehidden)
+ *
+ */
+import type { WindowLike } from "../types.ts";
+export declare function createEngagementTimer({ windowRef, nowMs, }?: {
+    windowRef?: WindowLike;
+    nowMs?: () => number;
+}): {
+    start: () => void;
+    peek: () => number;
+    getAndReset: () => number;
+    __internal: {
+        sync: () => void;
+    };
+};

package/dist/runtime/enhanced_measurement.d.ts

@@ -0,0 +1,14 @@
+import type { RuntimeState, WindowLike } from "../types.ts";
+export declare function createEnhancedMeasurement({ windowRef, getState, dispatcher, }: {
+    windowRef: WindowLike;
+    getState: () => RuntimeState;
+    dispatcher: {
+        enqueueEvent: (name: string, params: Record<string, unknown>) => void;
+        flushNow?: (opts?: {
+            useBeacon?: boolean;
+        }) => unknown;
+    };
+}): {
+    start: () => void;
+    onConfig: () => void;
+};

package/dist/runtime/gtag_consent_bridge.d.ts

@@ -0,0 +1,9 @@
+import type { RuntimeState, WindowLike } from "../types.ts";
+export declare function createGtagConsentBridge({ windowRef, getState, dataLayerName, }: {
+    windowRef?: WindowLike;
+    getState: () => RuntimeState;
+    dataLayerName?: string;
+}): {
+    start: () => void;
+    stop: () => void;
+};

package/dist/runtime/linker.d.ts

@@ -0,0 +1,53 @@
+import type { IncomingDlPayload, LinkerConfig, LinkerUrlPosition, RuntimeState, WindowLike } from "../types.ts";
+declare function resolveLinkerConfig(cfg: LinkerConfig): Required<LinkerConfig>;
+declare function stripParamFromUrl(url: string, name: string): string;
+declare function setParamInUrl(url: string, name: string, value: string, pos: LinkerUrlPosition): string;
+declare function encodeDl({ cookies, ts, windowRef, }: {
+    cookies: Record<string, string>;
+    ts: number;
+    windowRef: WindowLike;
+}): string;
+declare function decodeDl({ value, windowRef, ttlMs, }: {
+    value: string;
+    windowRef: WindowLike;
+    ttlMs?: number;
+}): IncomingDlPayload | null;
+type SharedLinkerCoordinator = ReturnType<typeof createSharedLinkerCoordinator>;
+declare function createSharedLinkerCoordinator({ windowRef }: {
+    windowRef: WindowLike;
+}): {
+    start: () => void;
+    stop: () => void;
+    applyIncomingIfReady: () => void;
+    registerRuntime: (getState: () => RuntimeState) => () => void;
+    updateConfigPatch: (patch: unknown) => void;
+    __internal: {
+        encodeDl: typeof encodeDl;
+        decodeDl: typeof decodeDl;
+        decorateUrlIfNeeded: (rawUrl: string) => string;
+        stripParamFromUrl: typeof stripParamFromUrl;
+        setParamInUrl: typeof setParamInUrl;
+        resolveLinkerConfig: typeof resolveLinkerConfig;
+    };
+};
+export declare function getSharedLinkerCoordinator({ windowRef, }: {
+    windowRef: WindowLike;
+}): SharedLinkerCoordinator;
+export declare function createLinker({ windowRef, getState, }: {
+    windowRef: WindowLike;
+    getState: () => RuntimeState;
+}): {
+    start: () => void;
+    stop: () => void;
+    applyIncomingIfReady: () => void;
+    updateConfigPatch: (patch: unknown) => void;
+    __internal: {
+        encodeDl: typeof encodeDl;
+        decodeDl: typeof decodeDl;
+        decorateUrlIfNeeded: (rawUrl: string) => string;
+        stripParamFromUrl: typeof stripParamFromUrl;
+        setParamInUrl: typeof setParamInUrl;
+        resolveLinkerConfig: typeof resolveLinkerConfig;
+    };
+};
+export {};

package/dist/runtime/param_precedence.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Param resolution helpers with precedence rules:
+ * - event params (per-event) override
+ * - config params (per-property) fallback
+ * - set params (global defaults) fallback
+ *
+ * `resolveString` returns a trimmed, non-empty string or null.
+ * `resolveBool` returns a boolean or null.
+ */
+export declare function resolveWithPrecedence({ key, eventParams, config, setParams, }: {
+    key: string;
+    eventParams?: Record<string, unknown> | null;
+    config?: Record<string, unknown> | null;
+    setParams?: Record<string, unknown> | null;
+}): {} | null;
+export declare function resolveString({ key, eventParams, config, setParams, }: {
+    key: string;
+    eventParams?: Record<string, unknown> | null;
+    config?: Record<string, unknown> | null;
+    setParams?: Record<string, unknown> | null;
+}): string | null;
+export declare function resolveBool({ key, eventParams, config, setParams, }: {
+    key: string;
+    eventParams?: Record<string, unknown> | null;
+    config?: Record<string, unknown> | null;
+    setParams?: Record<string, unknown> | null;
+}): boolean | null;

package/dist/runtime/queue_consumer.d.ts

@@ -0,0 +1,12 @@
+import type { RuntimeState, WindowLike } from "../types.ts";
+export declare function createQueueConsumer({ windowRef, dataLayerName, }: {
+    windowRef?: WindowLike;
+    dataLayerName?: string;
+}): {
+    start: () => void;
+    getState: () => RuntimeState;
+    setOnEvent: (fn: RuntimeState["__onEvent"]) => void;
+    setOnConfig: (fn: RuntimeState["__onConfig"]) => void;
+    setOnSet: (fn: RuntimeState["__onSet"]) => void;
+    stop: () => void;
+};

package/dist/runtime/runtime_names.d.ts

@@ -0,0 +1,12 @@
+export declare function resolveDataLayerName({ windowRef, dataLayerName, }: {
+    windowRef?: import("../types.ts").WindowLike;
+    dataLayerName?: unknown;
+}): string;
+export declare function resolveGlobalName({ windowRef, globalName, }: {
+    windowRef?: import("../types.ts").WindowLike;
+    globalName?: unknown;
+}): string;
+export declare function resolveGtagDataLayerName({ windowRef, gtagDataLayerName, }: {
+    windowRef?: import("../types.ts").WindowLike;
+    gtagDataLayerName?: unknown;
+}): string;

package/dist/runtime/state.d.ts

@@ -0,0 +1,2 @@
+import type { RuntimeState } from "../types.ts";
+export declare function createRuntimeState(): RuntimeState;

package/dist/runtime/uach.d.ts

@@ -0,0 +1,31 @@
+type UachFullVersion = {
+    brand?: string;
+    version?: string;
+};
+type Uach = {
+    architecture?: string;
+    bitness?: string;
+    fullVersionList?: UachFullVersion[];
+    mobile?: boolean;
+    model?: string;
+    platform?: string;
+    platformVersion?: string;
+    wow64?: boolean;
+};
+type UserAgentDataLike = {
+    getHighEntropyValues: (hints: readonly string[]) => Promise<Uach>;
+};
+type WindowLike = import("../types.ts").WindowLike;
+type WindowUachCapable = WindowLike & {
+    navigator: NonNullable<WindowLike["navigator"]> & {
+        userAgentData: UserAgentDataLike;
+    };
+};
+export declare function hasUachApi(w: WindowLike): w is WindowUachCapable;
+export declare function getUachCached(w: WindowLike): Uach | null;
+export declare function fetchUach(w: WindowLike): Promise<Uach> | null;
+export declare function uachToParams(uach: Uach | null): Record<string, string> | null;
+export declare const __internal: {
+    HIGH_ENTROPY_KEYS: readonly ["platform", "platformVersion", "architecture", "model", "bitness", "fullVersionList", "wow64", "mobile"];
+};
+export {};

package/dist/transport/send.d.ts

@@ -0,0 +1,20 @@
+import type { WindowLikeTransport } from "../types.ts";
+export declare function sendWithRetries({ url, windowRef, useBeacon, maxRetries, initialBackoffMs, }: {
+    url: string;
+    windowRef: WindowLikeTransport;
+    useBeacon: boolean;
+    maxRetries?: number;
+    initialBackoffMs?: number;
+}): Promise<{
+    ok: boolean;
+    via: "beacon";
+    status?: undefined;
+} | {
+    ok: boolean;
+    via: "fetch";
+    status: number;
+} | {
+    ok: boolean;
+    via: "fetch";
+    status: null;
+}>;

package/dist/types.d.ts

@@ -0,0 +1,144 @@
+import type { SessionToken } from "./cookies/d8a_cookies.ts";
+export type ConsentValue = "granted" | "denied";
+export type ConsentKey = "ad_storage" | "analytics_storage" | "ad_user_data" | "ad_personalization";
+export type ConsentState = Partial<Record<ConsentKey, ConsentValue>> & Record<string, unknown>;
+export type RuntimeEvent = {
+    name: string;
+    params: Record<string, unknown>;
+};
+export type BrowserContext = {
+    dl: string;
+    dt: string;
+    dr: string;
+    dh: string;
+    ul: string;
+    sr: string;
+};
+export type PropertyConfig = Record<string, unknown> & {
+    server_container_url?: string;
+    send_page_view?: boolean;
+};
+export type RuntimeState = {
+    jsDate: Date | null;
+    pageLoadMs: number | null;
+    propertyIds: string[];
+    propertyConfigs: Record<string, PropertyConfig>;
+    primaryPropertyId: string;
+    consent: ConsentState;
+    consentDefault: ConsentState;
+    consentUpdate: ConsentState;
+    consentGtag: ConsentState;
+    consentDefaultGtag: ConsentState;
+    consentUpdateGtag: ConsentState;
+    userId: string | null;
+    set: Record<string, unknown>;
+    linker: LinkerConfig;
+    incomingDl: IncomingDlPayload | null;
+    events: RuntimeEvent[];
+    __onEvent: null | ((name: string, params: Record<string, unknown>) => void);
+    __onConfig: null | ((propertyId: string, patchCfg: Record<string, unknown>) => void);
+    __onSet: null | ((args: SetCommandArgs) => void);
+    hitCounter: number;
+    sessionEngagementMs: number;
+    sessionEngaged: boolean;
+    anonCid: string | null;
+    cookieAttrsSig: Record<string, string> | null;
+    sharedSessionTokens: SessionToken[] | null;
+    sharedSessionValue: string | null;
+    emInstalled: boolean;
+    emSiteSearchFired: boolean;
+    __lastEffectiveAnalyticsStorage: ConsentValue | undefined;
+    __consentPingInitScheduled?: boolean;
+    __consentPingInitDone?: boolean;
+};
+export type D8aTagData = Record<string, unknown> & {
+    __d8aInstallResults?: Record<string, unknown>;
+    __d8aInstallResultsByDataLayer?: Record<string, unknown>;
+};
+export type WindowLike = {
+    d8aDataLayerName?: unknown;
+    d8aGlobalName?: unknown;
+    d8aGtagDataLayerName?: unknown;
+    document: {
+        cookie: string;
+        title?: string;
+        hidden?: boolean;
+        visibilityState?: string;
+        referrer?: string;
+        currentScript?: unknown;
+        hasFocus?: () => boolean;
+        addEventListener?: (type: string, listener: (...args: unknown[]) => void, options?: boolean | {
+            capture?: boolean;
+            passive?: boolean;
+            once?: boolean;
+        }) => void;
+        removeEventListener?: (type: string, listener: (...args: unknown[]) => void, options?: boolean | {
+            capture?: boolean;
+            passive?: boolean;
+            once?: boolean;
+        }) => void;
+    };
+    location?: {
+        href?: string;
+        hostname?: string;
+        protocol?: string;
+        search?: string;
+        pathname?: string;
+    };
+    history?: {
+        replaceState?: (data: unknown, unused: string, url?: string) => void;
+    };
+    navigator?: {
+        language?: string;
+        userAgent?: string;
+        userLanguage?: string;
+        userAgentData?: unknown;
+        sendBeacon?: null | ((url: string | URL, data?: SendBeaconData) => boolean);
+    };
+    screen?: {
+        width?: number;
+        height?: number;
+    };
+    addEventListener?: (type: string, listener: (...args: unknown[]) => void, options?: boolean | {
+        capture?: boolean;
+        passive?: boolean;
+        once?: boolean;
+    }) => void;
+    removeEventListener?: (type: string, listener: (...args: unknown[]) => void, options?: boolean | {
+        capture?: boolean;
+        passive?: boolean;
+        once?: boolean;
+    }) => void;
+    setTimeout: (handler: (...args: unknown[]) => void, timeout?: number) => number;
+    clearTimeout: (id: number) => void;
+    d8a_tag_data?: D8aTagData;
+    hasFocus?: () => boolean;
+};
+export type LinkerUrlPosition = "query" | "fragment";
+export type LinkerConfig = {
+    domains: string[];
+    accept_incoming?: boolean;
+    decorate_forms?: boolean;
+    url_position?: LinkerUrlPosition;
+};
+export type IncomingDlPayload = {
+    ts: number;
+    cookies: Record<string, string>;
+};
+export type SetCommandArgs = {
+    type: "object";
+    obj: Record<string, unknown>;
+} | {
+    type: "field";
+    field: string;
+    value: unknown;
+};
+export type WindowLikeTransport = {
+    navigator?: {
+        sendBeacon?: null | ((url: string | URL, data?: SendBeaconData) => boolean);
+    };
+    fetch?: (url: string, opts?: unknown) => Promise<{
+        status?: number;
+    }>;
+};
+export type SendBeaconData = string | Blob | FormData | URLSearchParams | ArrayBuffer | null | undefined;

package/dist/utils/endpoint.d.ts

@@ -0,0 +1,14 @@
+declare function isProbablyUrl(s: unknown): boolean;
+/**
+ * Resolves the final tracking URL.
+ *
+ * `server_container_url` is required and is treated as the final endpoint URL.
+ * Examples:
+ * - Cloud: "https://global.t.d8a.tech/<property_id>/d/c"
+ * - On-prem: "https://example.org/d/c"
+ */
+export declare function resolveTrackingUrl(configOrUrl?: unknown): string;
+export declare const __internal: {
+    isProbablyUrl: typeof isProbablyUrl;
+};
+export {};

package/dist/utils/gtag_primitives.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Small helpers used to implement a gtag-compatible integration surface.
+ *
+ * Important: this code is a clean reimplementation of behaviors we need for compatibility
+ * (e.g. cookie domain candidate ordering).
+ */
+export declare function getCookieDomainCandidates(hostname: unknown): string[];
+export declare function stripTrailingSlashes(s: unknown): string;

package/dist/utils/is_record.d.ts

@@ -0,0 +1 @@
+export declare function isRecord(v: unknown): v is Record<string, unknown>;

package/dist/utils/window_slots.d.ts

@@ -0,0 +1,4 @@
+import type { WindowLike } from "../types.ts";
+export declare function getWindowSlot<T = unknown>(w: WindowLike, key: string): T | undefined;
+export declare function setWindowSlot<T = unknown>(w: WindowLike, key: string, value: T): void;
+export declare function ensureArraySlot<T = unknown>(w: WindowLike, key: string): T[];