@c15t/scripts 3.0.0-alpha.0 → 3.0.0-alpha.2

package/dist/vendors/functional/front-chat.js

@@ -0,0 +1,64 @@
+import { resolveManifest } from "../../resolve.js";
+import { vendorManifestContract } from "../../types.js";
+import { resolveScriptUrl, trimToUndefined } from "../_shared/script-url.js";
+const FRONT_CHAT_SCRIPT_SRC = 'https://chat-assets.frontapp.com/v1/chat.bundle.js';
+const frontChatManifest = {
+    ...vendorManifestContract,
+    category: 'functionality',
+    install: [
+        {
+            async: true,
+            src: "{{scriptSrc}}",
+            type: 'loadScript'
+        }
+    ],
+    onLoadGranted: [
+        {
+            args: [
+                'init',
+                '{{initOptions}}'
+            ],
+            global: 'FrontChat',
+            type: 'callGlobal'
+        }
+    ],
+    vendor: 'front-chat'
+};
+const front_chat_frontChat = function(options) {
+    const chatId = 'string' == typeof options?.chatId ? options.chatId.trim() : '';
+    if (!chatId) throw new Error('frontChat: chatId must be a non-empty string.');
+    const scriptSrc = resolveScriptUrl(trimToUndefined(options.scriptSrc), FRONT_CHAT_SCRIPT_SRC);
+    const nonce = trimToUndefined(options.nonce);
+    const initOptions = {
+        chatId,
+        useDefaultLauncher: options.useDefaultLauncher ?? true
+    };
+    if (nonce) initOptions.nonce = nonce;
+    const script = resolveManifest(frontChatManifest, {
+        initOptions,
+        scriptSrc
+    });
+    return {
+        ...script,
+        nonce,
+        onLoad (info) {
+            if (!info.hasConsent || !info.element?.isConnected) return;
+            const loadedNonce = info.element.nonce;
+            const resolved = loadedNonce ? resolveManifest(frontChatManifest, {
+                initOptions: {
+                    ...initOptions,
+                    nonce: loadedNonce
+                },
+                scriptSrc
+            }) : script;
+            resolved.onLoad?.(info);
+        },
+        target: 'body'
+    };
+};
+const front_chat_shutdownFrontChat = function() {
+    if ("u" > typeof window && 'function' == typeof window.FrontChat) window.FrontChat('shutdown', {
+        clearSession: true
+    });
+};
+export { frontChatManifest, front_chat_frontChat as frontChat, front_chat_shutdownFrontChat as shutdownFrontChat };

package/dist/vendors/tag-managers/cloudflare-zaraz.js

@@ -0,0 +1,98 @@
+const consentCategories = [
+    'necessary',
+    'functionality',
+    'experience',
+    'measurement',
+    'marketing'
+];
+const readyEvent = 'zarazConsentAPIReady';
+const isConsentApi = (api)=>'object' == typeof api && null !== api && 'APIReady' in api && true === api.APIReady && 'getAll' in api && 'function' == typeof api.getAll && 'set' in api && 'function' == typeof api.set && 'sendQueuedEvents' in api && 'function' == typeof api.sendQueuedEvents;
+const getConsentApi = ()=>{
+    if ("u" < typeof window || !('zaraz' in window)) return;
+    const { zaraz } = window;
+    if ('object' != typeof zaraz || null === zaraz || !('consent' in zaraz)) return;
+    return isConsentApi(zaraz.consent) ? zaraz.consent : void 0;
+};
+const cloudflareZaraz = (options)=>{
+    const mappings = new Map();
+    for (const category of consentCategories)for (const purpose of options.purposes[category] ?? []){
+        if (!purpose.trim() || purpose !== purpose.trim()) throw new Error('Zaraz purpose IDs must be non-empty and have no surrounding whitespace.');
+        if (mappings.has(purpose)) throw new Error(`Zaraz purpose '${purpose}' is mapped more than once.`);
+        mappings.set(purpose, category);
+    }
+    if (0 === mappings.size) throw new Error('Map at least one Zaraz purpose to a c15t category.');
+    let latest;
+    let listeningDocument;
+    let initialized = false;
+    const pendingReplay = new Set();
+    const synchronize = ()=>{
+        const api = getConsentApi();
+        if (!latest || !api) return false;
+        const previous = api.getAll();
+        const permissions = {};
+        let changed = false;
+        for (const purpose of Object.keys(previous)){
+            const category = mappings.get(purpose);
+            const allowed = void 0 !== category && true === latest[category];
+            Object.defineProperty(permissions, purpose, {
+                enumerable: true,
+                value: allowed
+            });
+            changed ||= previous[purpose] !== allowed;
+            if (allowed && true !== previous[purpose]) pendingReplay.add(purpose);
+        }
+        for (const purpose of pendingReplay)if (true !== permissions[purpose]) pendingReplay.delete(purpose);
+        if (false !== options.hideBuiltInModal && true === api.modal) api.modal = false;
+        if (changed) api.set(permissions);
+        if (pendingReplay.size > 0 && false !== options.sendQueuedEvents) api.sendQueuedEvents();
+        pendingReplay.clear();
+        return true;
+    };
+    const apply = ()=>{
+        try {
+            if (!synchronize()) return false;
+        } catch (error) {
+            if (!options.onError) throw error;
+            options.onError(error);
+            return false;
+        }
+        listeningDocument?.removeEventListener(readyEvent, apply);
+        listeningDocument = void 0;
+        if (!initialized) {
+            initialized = true;
+            options.onReady?.();
+        }
+        return true;
+    };
+    const update = ({ consents })=>{
+        latest = consents;
+        if ("u" < typeof document) return;
+        let applied = false;
+        try {
+            applied = apply();
+        } finally{
+            if (!applied && !listeningDocument) {
+                listeningDocument = document;
+                document.addEventListener(readyEvent, apply);
+            }
+        }
+    };
+    return {
+        alwaysLoad: true,
+        callbackOnly: true,
+        category: 'necessary',
+        id: 'cloudflare-zaraz',
+        onConsentChange: (info)=>{
+            if (info.hasConsent) update(info);
+        },
+        onDispose: ()=>{
+            listeningDocument?.removeEventListener(readyEvent, apply);
+            listeningDocument = void 0;
+            latest = void 0;
+            initialized = false;
+            pendingReplay.clear();
+        },
+        onLoad: update
+    };
+};
+export { cloudflareZaraz };

package/dist/vendors/tag-managers/google-tag-manager.js

@@ -48,12 +48,26 @@ const googleTagManagerManifest = {
     ],
     vendor: 'google-tag-manager'
 };
-const google_tag_manager_googleTagManager = function({ id, updateEventName, consentMapping }) {
-    const manifest = withOptionalConsentMapping(googleTagManagerManifest, consentMapping);
+const google_tag_manager_googleTagManager = function({ id, dataLayer = 'dataLayer', updateEventName, consentMapping }) {
+    let manifest = withOptionalConsentMapping(googleTagManagerManifest, consentMapping);
+    if ('dataLayer' !== dataLayer) {
+        manifest = JSON.parse(JSON.stringify(manifest).replace(/"(?:dataLayer|gtag)"/gu, (token)=>JSON.stringify('"dataLayer"' === token ? dataLayer : `${dataLayer}Gtag`)).replace('gtm.js?id={{id}}', `gtm.js?id={{id}}&l=${encodeURIComponent(dataLayer)}`));
+        manifest = {
+            ...manifest,
+            consentSignal: 'gtag',
+            consentSignalTarget: `${dataLayer}Gtag`
+        };
+    }
     const resolved = resolveManifest(manifest, {
         id,
         updateEventName: updateEventName ?? 'consent-update'
     });
-    return resolved;
+    return {
+        ...resolved,
+        attributes: {
+            ...resolved.attributes,
+            'data-c15t-layer': dataLayer
+        }
+    };
 };
 export { googleTagManagerManifest, google_tag_manager_googleTagManager as googleTagManager };

package/dist-types/__tests__/helpers.d.ts

@@ -1,5 +1,5 @@
 import type { ConsentState, Script, ScriptCallbackInfo } from '@c15t/core';
-import type { BuiltInScriptIntegrationKey } from '../registry';
+import type { BuiltInScriptIntegrationKey } from '../registry.js';
 /**
  * Typed view of `globalThis` used by script helper tests.
  *
@@ -31,7 +31,7 @@ export interface ExpectedScriptSnapshot {
     /** Expected consent-revocation persistence flag from the generated script. */
     persistAfterConsentRevoked: boolean | undefined;
     /** Expected remote script URL from the generated helper script. */
-    src: string;
+    src: string | undefined;
 }
 /**
  * Consent state with only required storage enabled.

package/dist-types/engine/compile.d.ts

@@ -1,3 +1,3 @@
-import type { ResolvedManifest, VendorManifest } from '../types';
+import type { ResolvedManifest, VendorManifest } from '../types.js';
 export declare const interpolateValue: (value: unknown, config: Record<string, unknown>) => unknown;
 export declare const compileManifest: (manifest: VendorManifest, config?: Record<string, unknown>) => ResolvedManifest;

package/dist-types/engine/runtime.d.ts

@@ -1,3 +1,3 @@
 import type { Script } from '@c15t/core';
-import type { ResolvedManifest } from '../types';
+import type { ResolvedManifest } from '../types.js';
 export declare const resolvedManifestToScript: (resolvedManifest: ResolvedManifest) => Script;

package/dist-types/events.d.ts

@@ -0,0 +1,46 @@
+import type { ConsentSnapshot, Script } from '@c15t/core';
+/** Flat event metadata accepted by the shared dispatcher. */
+export type EventProperties = Record<string, string | number | boolean>;
+/** Runtime inputs: the host owns event names, c15t owns delivery eligibility. */
+export interface EventDispatcherOptions {
+    scripts: readonly Script[];
+    getSnapshot: () => ConsentSnapshot;
+    /** SDKs needing explicit SPA pageviews. Omit SDKs that track history themselves. */
+    pageviews?: readonly string[];
+    /** Injectable browser globals for testing or embedded runtimes. */
+    globals?: object;
+}
+/**
+ * Deliver events only to configured integrations with current analytics consent.
+ * Denied events are discarded, and a vendor error does not stop other deliveries.
+ *
+ * @param options - Scripts, current consent snapshot, optional SPA integrations
+ * and browser globals used to call their SDKs.
+ * @returns A dispatcher with `track` for named events and `pageview` for SPA
+ * navigation. The first pageview seeds the path without sending; later calls
+ * ignore duplicate paths and hash-only changes. Only configured `pageviews`
+ * integrations receive navigation events.
+ * @example
+ * ```ts
+ * const events = createEventDispatcher({ scripts, getSnapshot: kernel.getSnapshot,
+ *   pageviews: ['segment'] });
+ * events.pageview(location.pathname);
+ * events.track('search', { length: 4 });
+ * events.pageview('/results');
+ * ```
+ */
+export declare const createEventDispatcher: (options: EventDispatcherOptions) => {
+    /**
+     * Seed the initial path, then deliver permitted navigation events.
+     * @param path - Current path, including any query and hash. Hash-only changes are ignored.
+     * @returns Nothing. The first call and duplicate paths do not send events.
+     */
+    pageview(path: string): void;
+    /**
+     * Send a named event to each configured, currently permitted integration.
+     * @param event - Application event name understood by the configured SDKs.
+     * @param properties - Flat metadata copied for each vendor delivery.
+     * @returns Nothing. Denied events are discarded and SDK errors are isolated.
+     */
+    track(event: string, properties?: EventProperties): void;
+};

package/dist-types/registry.d.ts

@@ -77,6 +77,15 @@ export declare const BUILT_IN_INTEGRATION_CATEGORIES: readonly [{
  * the CLI can discover it from the same source.
  */
 export declare const builtInScriptIntegrations: readonly [{
+    readonly consentCategory: 'necessary';
+    readonly docsSlug: 'cloudflare-zaraz';
+    readonly hint: 'Consent bridge for tools managed by Zaraz';
+    readonly integrationCategory: 'tag-manager';
+    readonly key: 'cloudflareZaraz';
+    readonly label: 'Cloudflare Zaraz';
+    readonly packageSubpath: 'cloudflare-zaraz';
+    readonly vendor: 'cloudflare-zaraz';
+}, {
     readonly consentCategory: 'necessary';
     readonly docsSlug: 'google-tag-manager';
     readonly hint: 'GTM container script';
@@ -184,6 +193,15 @@ export declare const builtInScriptIntegrations: readonly [{
     readonly label: 'Mixpanel Analytics';
     readonly packageSubpath: 'mixpanel-analytics';
     readonly vendor: 'mixpanel-analytics';
+}, {
+    readonly consentCategory: 'measurement';
+    readonly docsSlug: 'one-dollar-stats';
+    readonly hint: 'Website analytics with no API key';
+    readonly integrationCategory: 'analytics';
+    readonly key: 'oneDollarStats';
+    readonly label: 'OneDollarStats';
+    readonly packageSubpath: 'one-dollar-stats';
+    readonly vendor: 'one-dollar-stats';
 }, {
     readonly consentCategory: 'measurement';
     readonly docsSlug: 'hotjar';
@@ -310,6 +328,15 @@ export declare const builtInScriptIntegrations: readonly [{
     readonly label: 'Crisp';
     readonly packageSubpath: 'crisp';
     readonly vendor: 'crisp';
+}, {
+    readonly consentCategory: 'functionality';
+    readonly docsSlug: 'front-chat';
+    readonly hint: 'Live chat widget';
+    readonly integrationCategory: 'functional';
+    readonly key: 'frontChat';
+    readonly label: 'Front Chat';
+    readonly packageSubpath: 'front-chat';
+    readonly vendor: 'front-chat';
 }, {
     readonly consentCategory: 'functionality';
     readonly docsSlug: 'intercom';
@@ -337,6 +364,15 @@ export declare const builtInScriptIntegrations: readonly [{
     readonly label: 'OpenAI Pixel (ChatGPT Ads)';
     readonly packageSubpath: 'openai-pixel';
     readonly vendor: 'openai-pixel';
+}, {
+    readonly consentCategory: 'marketing';
+    readonly docsSlug: 'pinterest-tag';
+    readonly hint: 'Pinterest ads tracking';
+    readonly integrationCategory: 'ads-and-pixels';
+    readonly key: 'pinterestTag';
+    readonly label: 'Pinterest Tag';
+    readonly packageSubpath: 'pinterest-tag';
+    readonly vendor: 'pinterest-tag';
 }, {
     readonly consentCategory: 'marketing';
     readonly docsSlug: 'reddit-pixel';

package/dist-types/resolve.d.ts

@@ -1,5 +1,5 @@
 import type { Script } from '@c15t/core';
-import type { VendorManifest } from './types';
+import type { VendorManifest } from './types.js';
 /**
  * Compiles a `VendorManifest` + config into a `Script` object.
  *

package/dist-types/vendors/_shared/install-builders.d.ts

@@ -1,4 +1,4 @@
-import type { VendorManifest } from '../../types';
+import type { VendorManifest } from '../../types.js';
 /**
  * Optional tracking call inserted between the vendor init call and script load.
  */

package/dist-types/vendors/ads-and-pixels/pinterest-tag.d.ts

@@ -0,0 +1,295 @@
+import type { Script } from '@c15t/core';
+/**
+ * The 20 Pinterest Tag event types accepted by `pintrk('track', ...)`.
+ *
+ * Conversion tracking and reporting require one of these names. Any other
+ * string is treated as a user-defined event, which Pinterest makes available
+ * for audience targeting only.
+ *
+ * @see {@link https://help.pinterest.com/en/business/article/add-event-codes} Add event codes
+ */
+export type PinterestTagEventName = 'pagevisit' | 'viewcategory' | 'search' | 'addtocart' | 'checkout' | 'watchvideo' | 'signup' | 'lead' | 'custom' | 'addpaymentinfo' | 'addtowishlist' | 'initiatecheckout' | 'subscribe' | 'viewcontent' | 'contact' | 'schedule' | 'findlocation' | 'customizeproduct' | 'submitapplication' | 'starttrial';
+/**
+ * A product entry in `PinterestTagEventData.line_items`.
+ *
+ * Pinterest reads product-level details from `line_items`, not from the
+ * top level of the event data.
+ */
+export interface PinterestTagLineItem {
+    /** Product name, for example `Parker Boots`. */
+    product_name?: string;
+    /** Product identifier or SKU. */
+    product_id?: string;
+    /** Product category, for example `Shoes`. */
+    product_category?: string;
+    /** Variant identifier, for example `1414-Red`. */
+    product_variant_id?: string;
+    /** Human-readable variant, for example `Red`. */
+    product_variant?: string;
+    /** Unit price of the product. */
+    product_price?: number;
+    /** Quantity of this product in the event. */
+    product_quantity?: number;
+    /** Brand name. */
+    product_brand?: string;
+    [key: string]: unknown;
+}
+/**
+ * Currency codes Pinterest accepts in `PinterestTagEventData.currency`.
+ *
+ * Pinterest converts the reported value to your advertiser account currency.
+ */
+export type PinterestTagCurrency = 'AED' | 'AMD' | 'ARS' | 'AUD' | 'AZN' | 'BAM' | 'BGN' | 'BHD' | 'BMD' | 'BND' | 'BOB' | 'BRL' | 'BSD' | 'CAD' | 'CHF' | 'CLP' | 'CNY' | 'COP' | 'CRC' | 'CZK' | 'DKK' | 'DOP' | 'EGP' | 'EUR' | 'FJD' | 'GBP' | 'GEL' | 'GIP' | 'HKD' | 'HNL' | 'HRK' | 'HUF' | 'IDR' | 'ILS' | 'INR' | 'ISK' | 'JMD' | 'JPY' | 'KGS' | 'KRW' | 'KWD' | 'KZT' | 'MAD' | 'MDL' | 'MOP' | 'MXN' | 'MYR' | 'NOK' | 'NZD' | 'OMR' | 'PAB' | 'PEN' | 'PHP' | 'PKR' | 'PLN' | 'QAR' | 'RON' | 'RSD' | 'RUB' | 'SAR' | 'SEK' | 'SGD' | 'THB' | 'TRY' | 'TWD' | 'UAH' | 'USD' | 'UYU' | 'VND' | 'ZAR';
+/**
+ * Event data accepted by `pintrk('track', ...)`.
+ *
+ * Pinterest documents the same field set for every event type; which fields
+ * are meaningful depends on the event. All event data is available for
+ * audience targeting, but only `value` and `order_quantity` appear in paid
+ * and organic conversion reporting. Any additional keys are forwarded
+ * unchanged.
+ */
+export interface PinterestTagEventData {
+    /**
+     * Unique event identifier used to deduplicate against Conversions API
+     * events. Pinterest also accepts this under `eventID` or `eid`.
+     */
+    event_id?: string;
+    /** Case-sensitive alias for `event_id`. */
+    eventID?: string;
+    /** Case-sensitive alias for `event_id`. */
+    eid?: string;
+    /**
+     * Total monetary value for commerce events such as `checkout`.
+     *
+     * Available in conversion reporting.
+     */
+    value?: number;
+    /**
+     * Total number of items in the order.
+     *
+     * Available in conversion reporting.
+     */
+    order_quantity?: number;
+    /**
+     * Currency code for `value`, for example `USD`. Required for `addtocart`
+     * and `checkout` in catalog sales campaigns.
+     */
+    currency?: PinterestTagCurrency | (string & Record<never, never>);
+    /**
+     * Order identifier for `checkout` events. Required for conversion
+     * analysis reporting.
+     */
+    order_id?: string;
+    /** Promo code applied to the order. */
+    promo_code?: string;
+    /** Property or store name, for example `Athleta`. */
+    property?: string;
+    /** Query text for `search` events. */
+    search_query?: string;
+    /** Video title for `watchvideo` events. */
+    video_title?: string;
+    /** Lead type for `lead` events, for example `Newsletter`. */
+    lead_type?: string;
+    /** Products associated with the event. */
+    line_items?: PinterestTagLineItem[];
+    [key: string]: unknown;
+}
+/**
+ * Options passed as the third argument to `pintrk('load', tagId, options)`.
+ */
+export interface PinterestTagLoadOptions {
+    /**
+     * Email address (plain or SHA-256 hashed) for Pinterest enhanced match.
+     *
+     * Only provide this when your application has separately obtained the
+     * appropriate user consent to share it with Pinterest.
+     */
+    em?: string;
+    /**
+     * Hashed external user identifier used by Pinterest for attribution.
+     */
+    external_id?: string;
+    [key: string]: unknown;
+}
+/**
+ * Optional callback passed as the last argument to `pintrk('track', ...)`.
+ *
+ * @param didInit - `true` when Pinterest constructed the event call
+ *   successfully, `false` when it detected an error.
+ * @param error - Error description when `didInit` is `false`, otherwise
+ *   `undefined`.
+ */
+export type PinterestTagEventCallback = (didInit: boolean, error?: string) => void;
+interface PinterestTagFunction {
+    (command: 'load', tagId: string, options?: PinterestTagLoadOptions): void;
+    (command: 'page'): void;
+    (command: 'track', eventName: PinterestTagEventName | (string & Record<never, never>), eventData?: PinterestTagEventData, callback?: PinterestTagEventCallback): void;
+    (command: 'setconsent', consent: boolean): void;
+    (command: 'set', data: Record<string, unknown>): void;
+    (command: string, ...args: unknown[]): void;
+}
+declare global {
+    interface Window {
+        pintrk?: PinterestTagFunction & {
+            queue?: unknown[][];
+            version?: string;
+        };
+    }
+}
+/**
+ * Pinterest Tag vendor manifest.
+ *
+ * Mirrors Pinterest's v3 base code: a `pintrk` stub that pushes argument
+ * arrays onto `pintrk.queue`, `pintrk.version = "3.0"`, then the async
+ * `core.js` loader.
+ *
+ * Pinterest exposes a runtime consent API via `pintrk('setconsent', boolean)`.
+ * `setconsent(false)` stops events and clears Pinterest's first-party
+ * storage, so the script persists after consent revocation and receives the
+ * updated consent state instead of being removed from the document.
+ */
+export declare const pinterestTagManifest: {
+    readonly kind: "c15t.vendor-manifest";
+    readonly schemaVersion: 1;
+    readonly bootstrap: [{
+        readonly ifUndefined: true;
+        readonly name: 'pintrk';
+        readonly properties: {
+            readonly version: '3.0';
+        };
+        readonly queue: {
+            readonly property: 'queue';
+        };
+        readonly queueFormat: 'array';
+        readonly type: 'defineStubFunction';
+    }];
+    readonly category: 'marketing';
+    readonly install: [{
+        readonly args: ["load", "{{tagId}}"];
+        readonly global: 'pintrk';
+        readonly type: 'callGlobal';
+    }, {
+        readonly args: ["setconsent", true];
+        readonly global: 'pintrk';
+        readonly type: 'callGlobal';
+    }, {
+        readonly args: ["page"];
+        readonly global: 'pintrk';
+        readonly type: 'callGlobal';
+    }, {
+        readonly async: true;
+        readonly src: '{{scriptUrl}}';
+        readonly type: 'loadScript';
+    }];
+    readonly onConsentDenied: [{
+        readonly args: ["setconsent", false];
+        readonly global: 'pintrk';
+        readonly type: 'callGlobal';
+    }];
+    readonly onConsentGranted: [{
+        readonly args: ["setconsent", true];
+        readonly global: 'pintrk';
+        readonly type: 'callGlobal';
+    }];
+    readonly persistAfterConsentRevoked: true;
+    readonly vendor: 'pinterest-tag';
+};
+export interface PinterestTagOptions {
+    /**
+     * Your Pinterest Tag ID.
+     * @example `2613654212508`
+     */
+    tagId: string;
+    /**
+     * Optional payload passed to `pintrk('load', tagId, loadOptions)`, for
+     * example enhanced match values.
+     *
+     * Do not provide user identifiers unless the appropriate consent and
+     * privacy requirements have already been satisfied.
+     */
+    loadOptions?: PinterestTagLoadOptions;
+    /**
+     * Queue the default `pintrk('page')` page-visit event during setup.
+     * @default true
+     */
+    trackPageVisit?: boolean;
+    /** Pinterest Tag loader URL. */
+    scriptUrl?: string;
+}
+/**
+ * Creates a Pinterest Tag script.
+ *
+ * This script persists after consent is revoked because Pinterest exposes
+ * `pintrk('setconsent', boolean)`, which lets c15t disable tracking and clear
+ * Pinterest's first-party storage without removing the script element.
+ *
+ * @param options.tagId - Pinterest Tag ID used in `pintrk('load', ...)`.
+ *   Numeric string from Pinterest Ads Manager, for example `'2613654212508'`.
+ * @param options.loadOptions - Optional object passed as the third argument to
+ *   `pintrk('load', tagId, loadOptions)`, for example `{ em: 'user@example.com' }`.
+ * @param options.trackPageVisit - Whether to queue the default `pintrk('page')`
+ *   call during setup. Defaults to `true`.
+ * @param options.scriptUrl - Override for Pinterest's `core.js` loader URL.
+ * @returns A resolved c15t `Script` configuration that defines the `pintrk`
+ *   queue stub, queues `load`, `setconsent`, and optionally `page`, then loads
+ *   Pinterest's `core.js`.
+ *
+ * @example
+ * ```ts
+ * const script = pinterestTag({
+ * 	tagId: '2613654212508',
+ * 	loadOptions: { em: 'user@example.com' },
+ * 	trackPageVisit: false,
+ * });
+ * ```
+ *
+ * @see {@link https://help.pinterest.com/en/business/article/install-the-pinterest-tag} Pinterest Tag documentation
+ */
+export declare const pinterestTag: ({ tagId, loadOptions, trackPageVisit, scriptUrl, }: PinterestTagOptions) => Script;
+/**
+ * Tracks a Pinterest Tag event.
+ *
+ * This helper is a no-op until Pinterest has been initialized by c15t, so it
+ * is safe to call before marketing consent is granted. It does not bypass
+ * consent: after revocation Pinterest's own `setconsent(false)` state
+ * suppresses the event.
+ *
+ * @param eventName - One of Pinterest's 20 event types or a user-defined
+ *   event name.
+ * @param eventData - Optional event data, including `event_id` for Tag plus
+ *   Conversions API deduplication.
+ * @param callback - Optional `(didInit, error)` callback Pinterest invokes
+ *   after constructing the event call. Useful for surfacing tag errors in
+ *   development.
+ *
+ * @example
+ * ```ts
+ * pinterestTagEvent('checkout', {
+ * 	event_id: 'event-123',
+ * 	value: 99.99,
+ * 	order_quantity: 1,
+ * 	currency: 'USD',
+ * 	order_id: 'order-123',
+ * 	line_items: [
+ * 		{
+ * 			product_name: 'Parker Boots',
+ * 			product_id: '1414',
+ * 			product_price: 99.99,
+ * 			product_quantity: 1,
+ * 		},
+ * 	],
+ * });
+ * ```
+ *
+ * @example
+ * ```ts
+ * pinterestTagEvent('lead', { lead_type: 'Newsletter' }, (didInit, error) => {
+ * 	if (!didInit) {
+ * 		console.error(error);
+ * 	}
+ * });
+ * ```
+ */
+export declare const pinterestTagEvent: (eventName: PinterestTagEventName | (string & Record<never, never>), eventData?: PinterestTagEventData, callback?: PinterestTagEventCallback) => void;
+export {};

package/dist-types/vendors/analytics/adobe-analytics.d.ts

@@ -1,5 +1,5 @@
 import type { Script } from '@c15t/core';
-import type { VendorManifest } from '../../types';
+import type { VendorManifest } from '../../types.js';
 declare global {
     interface Window {
         adobeDataLayer?: unknown[];

package/dist-types/vendors/analytics/google-tag.d.ts

@@ -49,6 +49,8 @@ export declare const gtagManifest: {
     readonly vendor: 'gtag';
 };
 export interface GtagOptions {
+    /** Parameters forwarded to gtag config. */
+    config?: Record<string, unknown>;
     /**
      * Your gtag id
      * @example `G-XXXXXXX`
@@ -90,4 +92,4 @@ export interface GtagOptions {
  * @param options - The options for the gtag script.
  * @returns The Google Tag Manager script.
  */
-export declare const gtag: ({ id, category, consentMapping, script, }: GtagOptions) => Script;
+export declare const gtag: ({ id, config, category, consentMapping, script, }: GtagOptions) => Script;

package/dist-types/vendors/analytics/matomo-analytics.d.ts

@@ -1,5 +1,5 @@
 import type { Script } from '@c15t/core';
-import type { VendorManifest } from '../../types';
+import type { VendorManifest } from '../../types.js';
 declare global {
     interface Window {
         _paq?: unknown[];