@c15t/scripts 2.2.0 → 3.0.0-alpha.1

package/dist/vendors/analytics/rybbit-analytics.js

@@ -4,37 +4,37 @@ import { booleanDataAttribute } from "../_shared/attributes.js";
 import { joinUrlPath } from "../_shared/script-url.js";
 const rybbitAnalyticsManifest = {
     ...vendorManifestContract,
-    vendor: 'rybbit-analytics',
     category: 'measurement',
     install: [
         {
-            type: 'loadScript',
-            src: "{{scriptUrl}}",
-            defer: true,
             attributes: {
-                'data-site-id': '{{siteId}}',
+                'data-api-key': '{{apiKey}}',
                 'data-auto-track-pageview': '{{autoTrackPageview}}',
-                'data-track-spa': '{{trackSpa}}',
-                'data-track-query': '{{trackQuery}}',
-                'data-track-outbound': '{{trackOutbound}}',
-                'data-track-errors': '{{trackErrors}}',
+                'data-debounce': '{{debounce}}',
+                'data-mask-patterns': '{{maskPatterns}}',
                 'data-session-replay': '{{sessionReplay}}',
-                'data-web-vitals': '{{webVitals}}',
+                'data-site-id': '{{siteId}}',
                 'data-skip-patterns': '{{skipPatterns}}',
-                'data-mask-patterns': '{{maskPatterns}}',
-                'data-debounce': '{{debounce}}',
-                'data-api-key': '{{apiKey}}'
-            }
+                'data-track-errors': '{{trackErrors}}',
+                'data-track-outbound': '{{trackOutbound}}',
+                'data-track-query': '{{trackQuery}}',
+                'data-track-spa': '{{trackSpa}}',
+                'data-web-vitals': '{{webVitals}}'
+            },
+            defer: true,
+            src: "{{scriptUrl}}",
+            type: 'loadScript'
         }
-    ]
+    ],
+    vendor: 'rybbit-analytics'
 };
-function getRybbitScriptUrl(options) {
+const rybbit_analytics_getRybbitScriptUrl = function(options) {
     const url = options.scriptUrl?.trim();
     if (url && url.length > 0) return url;
     if (options.analyticsHost) return joinUrlPath(options.analyticsHost, "script.js");
     return "https://app.rybbit.io/api/script.js";
-}
-function rybbitAnalytics(options) {
+};
+const rybbit_analytics_rybbitAnalytics = function(options) {
     let siteId;
     siteId = void 0 === options.siteId || null === options.siteId ? '' : String(options.siteId).trim();
     if (0 === siteId.length) throw new Error('rybbitAnalytics: missing siteId');
@@ -45,19 +45,19 @@ function rybbitAnalytics(options) {
     let maskPatterns;
     if (options.maskPatterns) maskPatterns = JSON.stringify(options.maskPatterns);
     return resolveManifest(rybbitAnalyticsManifest, {
-        scriptUrl: getRybbitScriptUrl(options),
-        siteId,
+        apiKey: options.apiKey,
         autoTrackPageview: booleanDataAttribute(options.autoTrackPageview),
-        trackSpa: booleanDataAttribute(options.trackSpa),
-        trackQuery: booleanDataAttribute(options.trackQuery),
-        trackOutbound: booleanDataAttribute(options.trackOutbound),
-        trackErrors: booleanDataAttribute(options.trackErrors),
+        debounce,
+        maskPatterns,
+        scriptUrl: rybbit_analytics_getRybbitScriptUrl(options),
         sessionReplay: booleanDataAttribute(options.sessionReplay),
-        webVitals: booleanDataAttribute(options.webVitals),
+        siteId,
         skipPatterns,
-        maskPatterns,
-        debounce,
-        apiKey: options.apiKey
+        trackErrors: booleanDataAttribute(options.trackErrors),
+        trackOutbound: booleanDataAttribute(options.trackOutbound),
+        trackQuery: booleanDataAttribute(options.trackQuery),
+        trackSpa: booleanDataAttribute(options.trackSpa),
+        webVitals: booleanDataAttribute(options.webVitals)
     });
-}
-export { rybbitAnalytics, rybbitAnalyticsManifest };
+};
+export { rybbitAnalyticsManifest, rybbit_analytics_rybbitAnalytics as rybbitAnalytics };

package/dist/vendors/analytics/segment.js

@@ -3,18 +3,14 @@ import { vendorManifestContract } from "../../types.js";
 import { resolveScriptUrl } from "../_shared/script-url.js";
 const segmentManifest = {
     ...vendorManifestContract,
-    vendor: 'segment',
-    category: 'measurement',
     bootstrap: [
         {
-            type: 'setGlobal',
+            ifUndefined: true,
             name: 'analytics',
-            value: [],
-            ifUndefined: true
+            type: 'setGlobal',
+            value: []
         },
         {
-            type: 'defineQueueMethods',
-            target: 'analytics',
             methods: [
                 'track',
                 'page',
@@ -22,23 +18,27 @@ const segmentManifest = {
                 'group',
                 'alias',
                 'reset'
-            ]
+            ],
+            target: 'analytics',
+            type: 'defineQueueMethods'
         }
     ],
+    category: 'measurement',
     install: [
         {
-            type: 'callGlobal',
             global: 'analytics',
-            method: 'page'
+            method: 'page',
+            type: 'callGlobal'
         },
         {
-            type: 'loadScript',
+            async: true,
             src: "{{scriptUrl}}",
-            async: true
+            type: 'loadScript'
         }
-    ]
+    ],
+    vendor: 'segment'
 };
-function segment({ writeKey, trackPageView = true, scriptUrl }) {
+const segment_segment = function({ writeKey, trackPageView = true, scriptUrl }) {
     let normalizedWriteKey = '';
     if ('string' == typeof writeKey) normalizedWriteKey = writeKey.trim();
     if (0 === normalizedWriteKey.length) throw new Error('segment: missing or invalid writeKey');
@@ -52,5 +52,5 @@ function segment({ writeKey, trackPageView = true, scriptUrl }) {
     return resolveManifest(manifest, {
         scriptUrl: resolveScriptUrl(scriptUrl, defaultScriptUrl)
     });
-}
-export { segment, segmentManifest };
+};
+export { segmentManifest, segment_segment as segment };

package/dist/vendors/analytics/umami-analytics.js

@@ -4,36 +4,36 @@ import { booleanDataAttribute, listDataAttribute } from "../_shared/attributes.j
 import { resolveScriptUrl } from "../_shared/script-url.js";
 const umamiAnalyticsManifest = {
     ...vendorManifestContract,
-    vendor: 'umami-analytics',
     category: 'measurement',
     install: [
         {
-            type: 'loadScript',
-            src: "{{scriptUrl}}",
-            defer: true,
             attributes: {
-                'data-website-id': '{{websiteId}}',
-                'data-host-url': '{{hostUrl}}',
                 'data-auto-track': '{{autoTrackAttribute}}',
+                'data-before-send': '{{beforeSend}}',
                 'data-domains': '{{domains}}',
+                'data-host-url': '{{hostUrl}}',
                 'data-tag': '{{tag}}',
-                'data-before-send': '{{beforeSend}}'
-            }
+                'data-website-id': '{{websiteId}}'
+            },
+            defer: true,
+            src: "{{scriptUrl}}",
+            type: 'loadScript'
         }
-    ]
+    ],
+    vendor: 'umami-analytics'
 };
-function umamiAnalytics(options) {
+const umami_analytics_umamiAnalytics = function(options) {
     const websiteId = options.websiteId.trim();
     if (0 === websiteId.length) throw new Error('umamiAnalytics: invalid websiteId - must be a non-empty string');
     const resolved = resolveManifest(umamiAnalyticsManifest, {
-        websiteId,
-        hostUrl: options.hostUrl,
         autoTrackAttribute: booleanDataAttribute(options.autoTrack),
+        beforeSend: options.beforeSend,
         domains: listDataAttribute(options.domains),
+        hostUrl: options.hostUrl,
+        scriptUrl: resolveScriptUrl(options.scriptUrl, "https://cloud.umami.is/script.js"),
         tag: options.tag,
-        beforeSend: options.beforeSend,
-        scriptUrl: resolveScriptUrl(options.scriptUrl, "https://cloud.umami.is/script.js")
+        websiteId
     });
     return resolved;
-}
-export { umamiAnalytics, umamiAnalyticsManifest };
+};
+export { umamiAnalyticsManifest, umami_analytics_umamiAnalytics as umamiAnalytics };

package/dist/vendors/analytics/vercel-analytics.js

@@ -2,52 +2,52 @@ import { resolveManifest } from "../../resolve.js";
 import { vendorManifestContract } from "../../types.js";
 const vercelAnalyticsManifest = {
     ...vendorManifestContract,
-    vendor: 'vercel-analytics',
-    category: 'measurement',
     bootstrap: [
         {
-            type: 'setGlobal',
+            ifUndefined: true,
             name: 'vaq',
-            value: [],
-            ifUndefined: true
+            type: 'setGlobal',
+            value: []
         },
         {
-            type: 'defineStubFunction',
+            ifUndefined: true,
             name: 'va',
             queue: {
                 global: 'vaq'
             },
             queueFormat: 'array',
-            ifUndefined: true
+            type: 'defineStubFunction'
         }
     ],
+    category: 'measurement',
     install: [
         {
-            type: 'loadScript',
-            src: "{{scriptUrl}}",
-            defer: true,
             attributes: {
-                'data-sdkn': 'c15t',
-                'data-dsn': '{{dsn}}',
                 'data-disable-auto-track': '{{disableAutoTrackAttribute}}',
-                'data-endpoint': '{{endpoint}}'
-            }
+                'data-dsn': '{{dsn}}',
+                'data-endpoint': '{{endpoint}}',
+                'data-sdkn': 'c15t'
+            },
+            defer: true,
+            src: "{{scriptUrl}}",
+            type: 'loadScript'
         }
-    ]
+    ],
+    vendor: 'vercel-analytics'
 };
-function getVercelScriptUrl(options) {
+const vercel_analytics_getVercelScriptUrl = function(options) {
     if (options.scriptUrl) return options.scriptUrl;
     if ('development' === options.mode || options.debug) return "https://va.vercel-scripts.com/v1/script.debug.js";
     return "https://va.vercel-scripts.com/v1/script.js";
-}
-function vercelAnalytics(options = {}) {
+};
+const vercel_analytics_vercelAnalytics = function(options = {}) {
     let disableAutoTrackAttribute;
     if (options.disableAutoTrack) disableAutoTrackAttribute = '1';
     return resolveManifest(vercelAnalyticsManifest, {
-        scriptUrl: getVercelScriptUrl(options),
+        disableAutoTrackAttribute,
         dsn: options.dsn,
         endpoint: options.endpoint,
-        disableAutoTrackAttribute
+        scriptUrl: vercel_analytics_getVercelScriptUrl(options)
     });
-}
-export { vercelAnalytics, vercelAnalyticsManifest };
+};
+export { vercelAnalyticsManifest, vercel_analytics_vercelAnalytics as vercelAnalytics };

package/dist/vendors/functional/crisp.js

@@ -2,101 +2,99 @@ import { resolveManifest } from "../../resolve.js";
 import { vendorManifestContract } from "../../types.js";
 const crispManifest = {
     ...vendorManifestContract,
-    vendor: 'crisp',
     category: 'functionality',
     install: [
         {
-            type: 'setGlobal',
+            ifUndefined: false,
             name: '$crisp',
-            value: [],
-            ifUndefined: false
+            type: 'setGlobal',
+            value: []
         },
         {
-            type: 'setGlobal',
+            ifUndefined: false,
             name: 'CRISP_WEBSITE_ID',
-            value: '{{websiteId}}',
-            ifUndefined: false
+            type: 'setGlobal',
+            value: '{{websiteId}}'
         },
         {
-            type: 'loadScript',
+            async: true,
             src: "{{scriptSrc}}",
-            async: true
+            type: 'loadScript'
         }
-    ]
+    ],
+    vendor: 'crisp'
 };
-function createCrispManifest(options) {
+const crisp_createCrispManifest = function(options) {
     const install = [
         {
-            type: 'setGlobal',
+            ifUndefined: false,
             name: '$crisp',
-            value: [],
-            ifUndefined: false
+            type: 'setGlobal',
+            value: []
         },
         {
-            type: 'setGlobal',
+            ifUndefined: false,
             name: 'CRISP_WEBSITE_ID',
-            value: '{{websiteId}}',
-            ifUndefined: false
+            type: 'setGlobal',
+            value: '{{websiteId}}'
         }
     ];
-    if (void 0 !== options.locale || void 0 !== options.sessionMerge) install.push({
-        type: 'setGlobal',
-        name: 'CRISP_RUNTIME_CONFIG',
-        value: {
-            ...void 0 !== options.locale ? {
-                locale: '{{locale}}'
-            } : {},
-            ...void 0 !== options.sessionMerge ? {
-                session_merge: '{{sessionMerge}}'
-            } : {}
-        },
-        ifUndefined: false
-    });
+    if (void 0 !== options.locale || void 0 !== options.sessionMerge) {
+        const value = {};
+        if (void 0 !== options.locale) value.locale = '{{locale}}';
+        if (void 0 !== options.sessionMerge) value.session_merge = '{{sessionMerge}}';
+        install.push({
+            ifUndefined: false,
+            name: 'CRISP_RUNTIME_CONFIG',
+            type: 'setGlobal',
+            value
+        });
+    }
     if (options.cookieDomain) install.push({
-        type: 'setGlobal',
+        ifUndefined: false,
         name: 'CRISP_COOKIE_DOMAIN',
-        value: '{{cookieDomain}}',
-        ifUndefined: false
+        type: 'setGlobal',
+        value: '{{cookieDomain}}'
     });
     if (void 0 !== options.cookieExpiry) install.push({
-        type: 'setGlobal',
+        ifUndefined: false,
         name: 'CRISP_COOKIE_EXPIRE',
-        value: '{{cookieExpiry}}',
-        ifUndefined: false
+        type: 'setGlobal',
+        value: '{{cookieExpiry}}'
     });
     if (options.tokenId) install.push({
-        type: 'setGlobal',
+        ifUndefined: false,
         name: 'CRISP_TOKEN_ID',
-        value: '{{tokenId}}',
-        ifUndefined: false
+        type: 'setGlobal',
+        value: '{{tokenId}}'
     });
     if (options.safeMode) install.push({
-        type: 'pushToQueue',
         queue: '$crisp',
+        type: 'pushToQueue',
         value: [
             'safe',
             true
         ]
     });
     install.push({
-        type: 'loadScript',
+        async: true,
         src: "{{scriptSrc}}",
-        async: true
+        type: 'loadScript'
     });
     return {
         ...crispManifest,
         install
     };
-}
-function crisp(options) {
-    return resolveManifest(createCrispManifest(options), {
-        websiteId: options.websiteId,
-        locale: options.locale,
+};
+const crisp_crisp = function(options) {
+    return resolveManifest(crisp_createCrispManifest(options), {
         cookieDomain: options.cookieDomain,
         cookieExpiry: options.cookieExpiry,
-        tokenId: options.tokenId,
+        locale: options.locale,
+        scriptSrc: options.scriptSrc ?? 'https://client.crisp.chat/l.js',
         sessionMerge: options.sessionMerge,
-        scriptSrc: options.scriptSrc ?? 'https://client.crisp.chat/l.js'
+        tokenId: options.tokenId,
+        websiteId: options.websiteId
     });
-}
-export { crisp, crispManifest };
+};
+export { crispManifest, crisp_crisp as crisp };

package/dist/vendors/functional/intercom.js

@@ -1,45 +1,45 @@
 import { resolveManifest } from "../../resolve.js";
 import { vendorManifestContract } from "../../types.js";
 const INTERCOM_API_BASES = {
-    us: 'https://api-iam.intercom.io',
+    au: 'https://api-iam.au.intercom.io',
     eu: 'https://api-iam.eu.intercom.io',
-    au: 'https://api-iam.au.intercom.io'
+    us: 'https://api-iam.intercom.io'
 };
 const intercomManifest = {
     ...vendorManifestContract,
-    vendor: 'intercom',
     category: 'functionality',
     install: [
         {
-            type: 'defineStubFunction',
+            ifUndefined: true,
             name: 'Intercom',
             queue: {
                 property: 'q'
             },
             queueFormat: 'array',
-            ifUndefined: true
+            type: 'defineStubFunction'
         },
         {
-            type: 'setGlobal',
+            ifUndefined: false,
             name: 'intercomSettings',
-            value: '{{settings}}',
-            ifUndefined: false
+            type: 'setGlobal',
+            value: '{{settings}}'
         },
         {
-            type: 'loadScript',
+            async: true,
             src: "{{scriptSrc}}",
-            async: true
+            type: 'loadScript'
         }
-    ]
+    ],
+    vendor: 'intercom'
 };
-function intercom({ appId, apiBase = INTERCOM_API_BASES.us, settings, scriptSrc }) {
+const intercom_intercom = function({ appId, apiBase = INTERCOM_API_BASES.us, settings, scriptSrc }) {
     return resolveManifest(intercomManifest, {
+        scriptSrc: scriptSrc ?? `https://widget.intercom.io/widget/${appId}`,
         settings: {
             ...settings ?? {},
-            app_id: appId,
-            api_base: apiBase
-        },
-        scriptSrc: scriptSrc ?? `https://widget.intercom.io/widget/${appId}`
+            api_base: apiBase,
+            app_id: appId
+        }
     });
-}
-export { INTERCOM_API_BASES, intercom, intercomManifest };
+};
+export { INTERCOM_API_BASES, intercomManifest, intercom_intercom as intercom };

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 };