@c15t/scripts 2.2.0 → 3.0.0-alpha.0

package/dist/vendors/analytics/logrocket.js

@@ -2,49 +2,49 @@ import { resolveManifest } from "../../resolve.js";
 import { vendorManifestContract } from "../../types.js";
 import { resolveScriptUrl, trimToUndefined } from "../_shared/script-url.js";
 const DEFAULT_LOGROCKET_SCRIPT_URL = 'https://cdn.logrocket.io/LogRocket.min.js';
-function validateLogRocketAppId(appId) {
+const logrocket_validateLogRocketAppId = function(appId) {
     const normalized = 'string' == typeof appId ? appId.trim() : '';
     const segments = normalized.split('/');
     if (2 !== segments.length || segments.some((segment)=>0 === segment.length)) throw new Error("logRocket: invalid appId - must be a non-empty string in 'org/app' format");
     return normalized;
-}
+};
 const logRocketManifest = {
     ...vendorManifestContract,
-    vendor: 'logrocket',
+    afterLoad: [
+        {
+            args: [
+                '{{appId}}',
+                '{{initOptions}}'
+            ],
+            global: 'LogRocket',
+            method: 'init',
+            type: 'callGlobal'
+        }
+    ],
     category: 'measurement',
     install: [
         {
-            type: 'loadScript',
-            src: "{{scriptUrl}}",
             attributes: {
                 crossorigin: 'anonymous'
-            }
+            },
+            src: "{{scriptUrl}}",
+            type: 'loadScript'
         }
     ],
-    afterLoad: [
-        {
-            type: 'callGlobal',
-            global: 'LogRocket',
-            method: 'init',
-            args: [
-                '{{appId}}',
-                '{{initOptions}}'
-            ]
-        }
-    ]
+    vendor: 'logrocket'
 };
-function logRocket(options) {
-    const appId = validateLogRocketAppId(options?.appId);
+const logrocket_logRocket = function(options) {
+    const appId = logrocket_validateLogRocketAppId(options?.appId);
     const asyncScriptUrl = trimToUndefined(options.asyncScriptUrl);
     let manifest = logRocketManifest;
     if (asyncScriptUrl) manifest = {
         ...logRocketManifest,
         bootstrap: [
             {
-                type: 'setGlobal',
+                ifUndefined: false,
                 name: '_lrAsyncScript',
-                value: '{{asyncScriptUrl}}',
-                ifUndefined: false
+                type: 'setGlobal',
+                value: '{{asyncScriptUrl}}'
             }
         ]
     };
@@ -54,5 +54,5 @@ function logRocket(options) {
         initOptions: options.initOptions ?? {},
         scriptUrl: resolveScriptUrl(trimToUndefined(options.scriptUrl), DEFAULT_LOGROCKET_SCRIPT_URL)
     });
-}
-export { logRocket, logRocketManifest };
+};
+export { logRocketManifest, logrocket_logRocket as logRocket };

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

@@ -1,38 +1,38 @@
 import { resolveManifest } from "../../resolve.js";
 import { vendorManifestContract } from "../../types.js";
 import { joinUrlPath, stripTrailingSlashes } from "../_shared/script-url.js";
-function stripProtocol(value) {
+const matomo_analytics_stripProtocol = function(value) {
     if (value.startsWith('https://')) return value.slice(8);
     if (value.startsWith('http://')) return value.slice(7);
     return value;
-}
-function resolveMatomoOrigin(options) {
+};
+const matomo_analytics_resolveMatomoOrigin = function(options) {
     if (options.matomoUrl) return stripTrailingSlashes(options.matomoUrl);
     if (options.cloudId) {
-        const cleanedCloudId = stripTrailingSlashes(stripProtocol(options.cloudId));
+        const cleanedCloudId = stripTrailingSlashes(matomo_analytics_stripProtocol(options.cloudId));
         if (cleanedCloudId.endsWith('.matomo.cloud')) return `https://${cleanedCloudId}`;
         return `https://cdn.matomo.cloud/${cleanedCloudId}`;
     }
-}
-function buildInstallSteps(options) {
+};
+const matomo_analytics_buildInstallSteps = function(options) {
     const install = [
         {
-            type: 'setGlobal',
+            ifUndefined: true,
             name: '_paq',
-            value: [],
-            ifUndefined: true
+            type: 'setGlobal',
+            value: []
         },
         {
-            type: 'pushToQueue',
             queue: '_paq',
+            type: 'pushToQueue',
             value: [
                 'setTrackerUrl',
                 '{{trackerUrl}}'
             ]
         },
         {
-            type: 'pushToQueue',
             queue: '_paq',
+            type: 'pushToQueue',
             value: [
                 'setSiteId',
                 '{{siteId}}'
@@ -40,68 +40,68 @@ function buildInstallSteps(options) {
         }
     ];
     if (options.enableLinkTracking) install.push({
-        type: 'pushToQueue',
         queue: '_paq',
+        type: 'pushToQueue',
         value: [
             'enableLinkTracking'
         ]
     });
     if (options.disableCookies) install.push({
-        type: 'pushToQueue',
         queue: '_paq',
+        type: 'pushToQueue',
         value: [
             'disableCookies'
         ]
     });
     if (options.enableConsentMode && !options.consentInitiallyGiven) install.push({
-        type: 'pushToQueue',
         queue: '_paq',
+        type: 'pushToQueue',
         value: [
             'requireConsent'
         ]
     });
     if (options.enableConsentMode && options.consentInitiallyGiven) {
         install.push({
-            type: 'pushToQueue',
             queue: '_paq',
+            type: 'pushToQueue',
             value: [
                 'setConsentGiven'
             ]
         });
         if (options.trackPageView) install.push({
-            type: 'pushToQueue',
             queue: '_paq',
+            type: 'pushToQueue',
             value: [
                 'trackPageView'
             ]
         });
     }
     if (options.trackPageView && !options.enableConsentMode) install.push({
-        type: 'pushToQueue',
         queue: '_paq',
+        type: 'pushToQueue',
         value: [
             'trackPageView'
         ]
     });
     install.push({
-        type: 'loadScript',
+        async: true,
         src: "{{scriptUrl}}",
-        async: true
+        type: 'loadScript'
     });
     return install;
-}
-function buildGrantedHooks(options) {
+};
+const matomo_analytics_buildGrantedHooks = function(options) {
     const onBeforeLoadGranted = [];
     if (options.enableConsentMode && !options.consentInitiallyGiven) onBeforeLoadGranted.push({
-        type: 'pushToQueue',
         queue: '_paq',
+        type: 'pushToQueue',
         value: [
             'setConsentGiven'
         ]
     });
     if (options.trackPageView && options.enableConsentMode && !options.consentInitiallyGiven) onBeforeLoadGranted.push({
-        type: 'pushToQueue',
         queue: '_paq',
+        type: 'pushToQueue',
         value: [
             'trackPageView'
         ]
@@ -109,15 +109,15 @@ function buildGrantedHooks(options) {
     const onConsentGranted = [];
     if (options.enableConsentMode) {
         onConsentGranted.push({
-            type: 'pushToQueue',
             queue: '_paq',
+            type: 'pushToQueue',
             value: [
                 'setConsentGiven'
             ]
         });
         if (options.trackPageView) onConsentGranted.push({
-            type: 'pushToQueue',
             queue: '_paq',
+            type: 'pushToQueue',
             value: [
                 'trackPageView'
             ]
@@ -127,20 +127,20 @@ function buildGrantedHooks(options) {
         onBeforeLoadGranted,
         onConsentGranted
     };
-}
-function buildDeniedHooks(options) {
+};
+const matomo_analytics_buildDeniedHooks = function(options) {
     const onConsentDenied = [];
     if (options.enableConsentMode) onConsentDenied.push({
-        type: 'pushToQueue',
         queue: '_paq',
+        type: 'pushToQueue',
         value: [
             'forgetConsentGiven'
         ]
     });
     return onConsentDenied;
-}
-function createMatomoAnalyticsManifest(options) {
-    const { onBeforeLoadGranted, onConsentGranted } = buildGrantedHooks(options);
+};
+const matomo_analytics_createMatomoAnalyticsManifest = function(options) {
+    const { onBeforeLoadGranted, onConsentGranted } = matomo_analytics_buildGrantedHooks(options);
     let alwaysLoad;
     let persistAfterConsentRevoked;
     if (options.enableConsentMode) {
@@ -149,43 +149,43 @@ function createMatomoAnalyticsManifest(options) {
     }
     return {
         ...vendorManifestContract,
-        vendor: 'matomo-analytics',
-        category: 'measurement',
         alwaysLoad,
-        persistAfterConsentRevoked,
-        install: buildInstallSteps(options),
+        category: 'measurement',
+        install: matomo_analytics_buildInstallSteps(options),
         onBeforeLoadGranted,
+        onConsentDenied: matomo_analytics_buildDeniedHooks(options),
         onConsentGranted,
-        onConsentDenied: buildDeniedHooks(options)
+        persistAfterConsentRevoked,
+        vendor: 'matomo-analytics'
     };
-}
-const matomoAnalyticsManifest = createMatomoAnalyticsManifest({
-    enableConsentMode: false,
+};
+const matomoAnalyticsManifest = matomo_analytics_createMatomoAnalyticsManifest({
     consentInitiallyGiven: false,
-    enableLinkTracking: false,
     disableCookies: false,
+    enableConsentMode: false,
+    enableLinkTracking: false,
     trackPageView: true
 });
-function matomoAnalytics(options = {}) {
-    const origin = resolveMatomoOrigin(options);
-    let trackerUrl = options.trackerUrl;
+const matomo_analytics_matomoAnalytics = function(options = {}) {
+    const origin = matomo_analytics_resolveMatomoOrigin(options);
+    let { trackerUrl } = options;
     if (!trackerUrl && origin) trackerUrl = joinUrlPath(origin, 'matomo.php');
-    let scriptUrl = options.scriptUrl;
+    let { scriptUrl } = options;
     if (!scriptUrl && origin) scriptUrl = joinUrlPath(origin, 'matomo.js');
     if (!trackerUrl || !scriptUrl) throw new Error("matomoAnalytics requires `matomoUrl`, `cloudId`, or explicit `trackerUrl` and `scriptUrl` values.");
     const enableConsentMode = 'required' === options.defaultConsent || 'given' === options.defaultConsent;
     const consentInitiallyGiven = 'given' === options.defaultConsent;
-    const manifest = createMatomoAnalyticsManifest({
-        enableConsentMode,
+    const manifest = matomo_analytics_createMatomoAnalyticsManifest({
         consentInitiallyGiven,
-        enableLinkTracking: options.enableLinkTracking ?? false,
         disableCookies: options.disableCookies ?? false,
+        enableConsentMode,
+        enableLinkTracking: options.enableLinkTracking ?? false,
         trackPageView: options.trackPageView ?? true
     });
     return resolveManifest(manifest, {
+        scriptUrl,
         siteId: String(options.siteId ?? 1),
-        trackerUrl,
-        scriptUrl
+        trackerUrl
     });
-}
-export { matomoAnalytics, matomoAnalyticsManifest };
+};
+export { matomoAnalyticsManifest, matomo_analytics_matomoAnalytics as matomoAnalytics };

package/dist/vendors/analytics/microsoft-clarity.js

@@ -1,20 +1,20 @@
 import { resolveManifest } from "../../resolve.js";
 import { vendorManifestContract } from "../../types.js";
-function toClarityConsentState(value) {
+const microsoft_clarity_toClarityConsentState = function(value) {
     if (true === value) return 'granted';
     if (false === value) return 'denied';
     if ('string' != typeof value) return;
     const normalized = value.toLowerCase();
     if ('granted' === normalized || 'true' === normalized) return 'granted';
     if ('denied' === normalized || 'false' === normalized) return 'denied';
-}
-function getConsentValue(value, keys) {
+};
+const microsoft_clarity_getConsentValue = function(value, keys) {
     for (const key of keys){
-        const consent = toClarityConsentState(value[key]);
+        const consent = microsoft_clarity_toClarityConsentState(value[key]);
         if (consent) return consent;
     }
-}
-function getConsentPayloadFromState(consents) {
+};
+const microsoft_clarity_getConsentPayloadFromState = function(consents) {
     let adStorage;
     adStorage = consents.marketing ? 'granted' : 'denied';
     let analyticsStorage;
@@ -23,22 +23,22 @@ function getConsentPayloadFromState(consents) {
         ad_Storage: adStorage,
         analytics_Storage: analyticsStorage
     };
-}
-function getClarityConsentPayload(consents, defaultConsent) {
-    const fallback = getConsentPayloadFromState(consents);
+};
+const microsoft_clarity_getClarityConsentPayload = function(consents, defaultConsent) {
+    const fallback = microsoft_clarity_getConsentPayloadFromState(consents);
     if (void 0 === defaultConsent) return fallback;
-    const booleanConsent = toClarityConsentState(defaultConsent);
+    const booleanConsent = microsoft_clarity_toClarityConsentState(defaultConsent);
     if (booleanConsent) return {
         ad_Storage: booleanConsent,
         analytics_Storage: booleanConsent
     };
     if (null !== defaultConsent && 'object' == typeof defaultConsent) return {
-        ad_Storage: getConsentValue(defaultConsent, [
+        ad_Storage: microsoft_clarity_getConsentValue(defaultConsent, [
             'ad_Storage',
             'ad_storage',
             'marketing'
         ]) ?? fallback.ad_Storage,
-        analytics_Storage: getConsentValue(defaultConsent, [
+        analytics_Storage: microsoft_clarity_getConsentValue(defaultConsent, [
             'analytics_Storage',
             'analytics_storage',
             'measurement',
@@ -46,52 +46,52 @@ function getClarityConsentPayload(consents, defaultConsent) {
         ]) ?? fallback.analytics_Storage
     };
     return fallback;
-}
-function syncClarityConsent(info, defaultConsent) {
-    window.clarity?.('consentv2', getClarityConsentPayload(info.consents, defaultConsent));
-}
+};
+const microsoft_clarity_syncClarityConsent = function(info, defaultConsent) {
+    window.clarity?.('consentv2', microsoft_clarity_getClarityConsentPayload(info.consents, defaultConsent));
+};
 const clarityManifest = {
     ...vendorManifestContract,
-    vendor: 'microsoft-clarity',
-    category: 'measurement',
-    persistAfterConsentRevoked: true,
     bootstrap: [
         {
-            type: 'defineStubFunction',
+            ifUndefined: true,
             name: 'clarity',
             queue: {
                 property: 'q'
             },
             queueFormat: 'array',
-            ifUndefined: true
+            type: 'defineStubFunction'
         }
     ],
+    category: 'measurement',
     install: [
         {
-            type: 'loadScript',
+            async: true,
             src: "{{scriptUrl}}",
-            async: true
+            type: 'loadScript'
         }
-    ]
+    ],
+    persistAfterConsentRevoked: true,
+    vendor: 'microsoft-clarity'
 };
-function clarity({ id, defaultConsent, scriptUrl }) {
+const microsoft_clarity_clarity = function({ id, defaultConsent, scriptUrl }) {
     const normalizedId = id.trim();
     if (void 0 === scriptUrl && 0 === normalizedId.length) throw new Error(`Invalid Clarity id value "${id}". A non-empty id is required to construct the Clarity loader URL when scriptUrl is not provided.`);
     const resolved = resolveManifest(clarityManifest, {
         scriptUrl: scriptUrl ?? `https://www.clarity.ms/tag/${normalizedId}`
     });
-    const onBeforeLoad = resolved.onBeforeLoad;
-    const onConsentChange = resolved.onConsentChange;
+    const { onBeforeLoad } = resolved;
+    const { onConsentChange } = resolved;
     return {
         ...resolved,
         onBeforeLoad: (info)=>{
             onBeforeLoad?.(info);
-            syncClarityConsent(info, defaultConsent);
+            microsoft_clarity_syncClarityConsent(info, defaultConsent);
         },
         onConsentChange: (info)=>{
             onConsentChange?.(info);
-            syncClarityConsent(info);
+            microsoft_clarity_syncClarityConsent(info);
         }
     };
-}
-export { clarity, clarityManifest };
+};
+export { clarityManifest, microsoft_clarity_clarity as clarity };

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

@@ -2,30 +2,29 @@ import { resolveManifest } from "../../resolve.js";
 import { vendorManifestContract } from "../../types.js";
 const mixpanelAnalyticsManifest = {
     ...vendorManifestContract,
-    vendor: 'mixpanel-analytics',
-    category: 'measurement',
     alwaysLoad: true,
+    category: 'measurement',
     install: [
         {
-            type: 'setGlobal',
+            ifUndefined: true,
             name: 'mixpanel',
-            value: [],
-            ifUndefined: true
+            type: 'setGlobal',
+            value: []
         },
         {
-            type: 'setGlobalPath',
             path: [
                 'mixpanel',
                 '__SV'
             ],
+            type: 'setGlobalPath',
             value: 1.2
         },
         {
-            type: 'setGlobalPath',
             path: [
                 'mixpanel',
                 '_i'
             ],
+            type: 'setGlobalPath',
             value: [
                 [
                     '{{token}}',
@@ -35,8 +34,6 @@ const mixpanelAnalyticsManifest = {
             ]
         },
         {
-            type: 'defineQueueMethods',
-            target: 'mixpanel',
             methods: [
                 'track',
                 'identify',
@@ -44,50 +41,53 @@ const mixpanelAnalyticsManifest = {
                 'register',
                 'opt_in_tracking',
                 'opt_out_tracking'
-            ]
+            ],
+            target: 'mixpanel',
+            type: 'defineQueueMethods'
         },
         {
-            type: 'loadScript',
+            async: true,
             src: "{{scriptUrl}}",
-            async: true
+            type: 'loadScript'
         }
     ],
-    onLoadGranted: [
+    onConsentDenied: [
         {
-            type: 'callGlobal',
             global: 'mixpanel',
-            method: 'opt_in_tracking'
+            method: 'opt_out_tracking',
+            type: 'callGlobal'
         }
     ],
-    onLoadDenied: [
+    onConsentGranted: [
         {
-            type: 'callGlobal',
             global: 'mixpanel',
-            method: 'opt_out_tracking'
+            method: 'opt_in_tracking',
+            type: 'callGlobal'
         }
     ],
-    onConsentGranted: [
+    onLoadDenied: [
         {
-            type: 'callGlobal',
             global: 'mixpanel',
-            method: 'opt_in_tracking'
+            method: 'opt_out_tracking',
+            type: 'callGlobal'
         }
     ],
-    onConsentDenied: [
+    onLoadGranted: [
         {
-            type: 'callGlobal',
             global: 'mixpanel',
-            method: 'opt_out_tracking'
+            method: 'opt_in_tracking',
+            type: 'callGlobal'
         }
-    ]
+    ],
+    vendor: 'mixpanel-analytics'
 };
-function mixpanelAnalytics({ token, initOptions, scriptUrl }) {
+const mixpanel_analytics_mixpanelAnalytics = function({ token, initOptions, scriptUrl }) {
     const normalizedToken = token.trim();
-    if (!/^[a-f0-9]{32}$/i.test(normalizedToken)) throw new Error("mixpanelAnalytics: token must be a non-empty 32-character hexadecimal string");
+    if (!/^[a-f0-9]{32}$/iu.test(normalizedToken)) throw new Error("mixpanelAnalytics: token must be a non-empty 32-character hexadecimal string");
     return resolveManifest(mixpanelAnalyticsManifest, {
-        token: normalizedToken,
         initOptions: initOptions ?? {},
-        scriptUrl: scriptUrl ?? 'https://cdn.mxpnl.com/libs/mixpanel-2-latest.min.js'
+        scriptUrl: scriptUrl ?? 'https://cdn.mxpnl.com/libs/mixpanel-2-latest.min.js',
+        token: normalizedToken
     });
-}
-export { mixpanelAnalytics, mixpanelAnalyticsManifest };
+};
+export { mixpanelAnalyticsManifest, mixpanel_analytics_mixpanelAnalytics as mixpanelAnalytics };

package/dist/vendors/analytics/pirsch.js

@@ -5,26 +5,26 @@ const DEFAULT_PIRSCH_SCRIPT_URL = 'https://api.pirsch.io/pa.js';
 const DEFAULT_PIRSCH_EXTENDED_SCRIPT_URL = 'https://api.pirsch.io/pirsch-extended.js';
 const pirschManifest = {
     ...vendorManifestContract,
-    vendor: 'pirsch',
     category: 'measurement',
     install: [
         {
-            type: 'loadScript',
-            src: "{{scriptUrl}}",
-            defer: true,
             attributes: {
-                id: "{{scriptElementId}}",
                 'data-code': '{{identificationCode}}',
-                'data-domain': '{{domain}}',
                 'data-dev': '{{dev}}',
-                'data-hit-endpoint': '{{hitEndpoint}}',
+                'data-disable-page-views': '{{disablePageViews}}',
+                'data-domain': '{{domain}}',
                 'data-event-endpoint': '{{eventEndpoint}}',
-                'data-disable-page-views': '{{disablePageViews}}'
-            }
+                'data-hit-endpoint': '{{hitEndpoint}}',
+                id: "{{scriptElementId}}"
+            },
+            defer: true,
+            src: "{{scriptUrl}}",
+            type: 'loadScript'
         }
-    ]
+    ],
+    vendor: 'pirsch'
 };
-function commaListDataAttribute(value) {
+const pirsch_commaListDataAttribute = function(value) {
     if (void 0 === value) return;
     if (Array.isArray(value)) {
         const items = value.map((item)=>item.trim()).filter((item)=>item.length > 0);
@@ -32,30 +32,30 @@ function commaListDataAttribute(value) {
         return items.join(',');
     }
     return trimToUndefined(value);
-}
-function presenceDataAttribute(value) {
+};
+const pirsch_presenceDataAttribute = function(value) {
     if (true === value) return '';
-}
-function getPirschScriptElementId(options) {
+};
+const pirsch_getPirschScriptElementId = function(options) {
     if (true === options.extended) return 'pirschextendedjs';
     return 'pianjs';
-}
-function getPirschScriptUrl(options) {
+};
+const pirsch_getPirschScriptUrl = function(options) {
     const defaultScriptUrl = true === options.extended ? DEFAULT_PIRSCH_EXTENDED_SCRIPT_URL : DEFAULT_PIRSCH_SCRIPT_URL;
     return resolveScriptUrl(trimToUndefined(options.scriptUrl), defaultScriptUrl);
-}
-function pirsch(options) {
+};
+const pirsch_pirsch = function(options) {
     const identificationCode = options.identificationCode.trim();
     if (0 === identificationCode.length) throw new Error('pirsch: invalid identificationCode - must be a non-empty string');
     const resolved = resolveManifest(pirschManifest, {
-        identificationCode,
-        domain: commaListDataAttribute(options.domain),
         dev: trimToUndefined(options.dev),
-        hitEndpoint: trimToUndefined(options.hitEndpoint),
+        disablePageViews: pirsch_presenceDataAttribute(options.disablePageViews),
+        domain: pirsch_commaListDataAttribute(options.domain),
         eventEndpoint: trimToUndefined(options.eventEndpoint),
-        disablePageViews: presenceDataAttribute(options.disablePageViews),
-        scriptElementId: getPirschScriptElementId(options),
-        scriptUrl: getPirschScriptUrl(options)
+        hitEndpoint: trimToUndefined(options.hitEndpoint),
+        identificationCode,
+        scriptElementId: pirsch_getPirschScriptElementId(options),
+        scriptUrl: pirsch_getPirschScriptUrl(options)
     });
     const manifestOnLoad = resolved.onLoad;
     resolved.onLoad = (info)=>{
@@ -63,5 +63,5 @@ function pirsch(options) {
         if ('loading' !== document.readyState) window.pirschInit?.();
     };
     return resolved;
-}
-export { pirsch, pirschManifest };
+};
+export { pirschManifest, pirsch_pirsch as pirsch };