@c15t/scripts 2.1.0 → 2.2.0-canary-20260804162155

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

@@ -1,5 +1,55 @@
 import { resolveManifest } from "../../resolve.js";
 import { vendorManifestContract } from "../../types.js";
+function toClarityConsentState(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) {
+    for (const key of keys){
+        const consent = toClarityConsentState(value[key]);
+        if (consent) return consent;
+    }
+}
+function getConsentPayloadFromState(consents) {
+    let adStorage;
+    adStorage = consents.marketing ? 'granted' : 'denied';
+    let analyticsStorage;
+    analyticsStorage = consents.measurement ? 'granted' : 'denied';
+    return {
+        ad_Storage: adStorage,
+        analytics_Storage: analyticsStorage
+    };
+}
+function getClarityConsentPayload(consents, defaultConsent) {
+    const fallback = getConsentPayloadFromState(consents);
+    if (void 0 === defaultConsent) return fallback;
+    const booleanConsent = toClarityConsentState(defaultConsent);
+    if (booleanConsent) return {
+        ad_Storage: booleanConsent,
+        analytics_Storage: booleanConsent
+    };
+    if (null !== defaultConsent && 'object' == typeof defaultConsent) return {
+        ad_Storage: getConsentValue(defaultConsent, [
+            'ad_Storage',
+            'ad_storage',
+            'marketing'
+        ]) ?? fallback.ad_Storage,
+        analytics_Storage: getConsentValue(defaultConsent, [
+            'analytics_Storage',
+            'analytics_storage',
+            'measurement',
+            'analytics'
+        ]) ?? fallback.analytics_Storage
+    };
+    return fallback;
+}
+function syncClarityConsent(info, defaultConsent) {
+    window.clarity?.('consentv2', getClarityConsentPayload(info.consents, defaultConsent));
+}
 const clarityManifest = {
     ...vendorManifestContract,
     vendor: 'microsoft-clarity',
@@ -13,9 +63,6 @@ const clarityManifest = {
                 property: 'q'
             },
             queueFormat: 'array',
-            properties: {
-                v: '0.7.0'
-            },
             ifUndefined: true
         }
     ],
@@ -25,49 +72,26 @@ const clarityManifest = {
             src: "{{scriptUrl}}",
             async: true
         }
-    ],
-    onConsentGranted: [
-        {
-            type: 'callGlobal',
-            global: 'clarity',
-            args: [
-                'consent',
-                true
-            ]
-        }
-    ],
-    onConsentDenied: [
-        {
-            type: 'callGlobal',
-            global: 'clarity',
-            args: [
-                'consent',
-                false
-            ]
-        }
     ]
 };
 function clarity({ 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.`);
-    let manifest = clarityManifest;
-    if (void 0 !== defaultConsent) manifest = {
-        ...clarityManifest,
-        install: [
-            {
-                type: 'callGlobal',
-                global: 'clarity',
-                args: [
-                    'consent',
-                    '{{defaultConsent}}'
-                ]
-            },
-            ...clarityManifest.install
-        ]
-    };
-    return resolveManifest(manifest, {
-        defaultConsent,
+    const resolved = resolveManifest(clarityManifest, {
         scriptUrl: scriptUrl ?? `https://www.clarity.ms/tag/${normalizedId}`
     });
+    const onBeforeLoad = resolved.onBeforeLoad;
+    const onConsentChange = resolved.onConsentChange;
+    return {
+        ...resolved,
+        onBeforeLoad: (info)=>{
+            onBeforeLoad?.(info);
+            syncClarityConsent(info, defaultConsent);
+        },
+        onConsentChange: (info)=>{
+            onConsentChange?.(info);
+            syncClarityConsent(info);
+        }
+    };
 }
 export { clarity, clarityManifest };

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

@@ -1,11 +1,15 @@
 "use strict";
 var __webpack_require__ = {};
 (()=>{
-    __webpack_require__.d = (exports1, definition)=>{
-        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
-            enumerable: true,
-            get: definition[key]
-        });
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
     };
 })();
 (()=>{
@@ -41,6 +45,28 @@ const mixpanelAnalyticsManifest = {
             value: [],
             ifUndefined: true
         },
+        {
+            type: 'setGlobalPath',
+            path: [
+                'mixpanel',
+                '__SV'
+            ],
+            value: 1.2
+        },
+        {
+            type: 'setGlobalPath',
+            path: [
+                'mixpanel',
+                '_i'
+            ],
+            value: [
+                [
+                    '{{token}}',
+                    '{{initOptions}}',
+                    'mixpanel'
+                ]
+            ]
+        },
         {
             type: 'defineQueueMethods',
             target: 'mixpanel',
@@ -59,17 +85,6 @@ const mixpanelAnalyticsManifest = {
             async: true
         }
     ],
-    afterLoad: [
-        {
-            type: 'callGlobal',
-            global: 'mixpanel',
-            method: 'init',
-            args: [
-                '{{token}}',
-                '{{initOptions}}'
-            ]
-        }
-    ],
     onLoadGranted: [
         {
             type: 'callGlobal',

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

@@ -12,6 +12,28 @@ const mixpanelAnalyticsManifest = {
             value: [],
             ifUndefined: true
         },
+        {
+            type: 'setGlobalPath',
+            path: [
+                'mixpanel',
+                '__SV'
+            ],
+            value: 1.2
+        },
+        {
+            type: 'setGlobalPath',
+            path: [
+                'mixpanel',
+                '_i'
+            ],
+            value: [
+                [
+                    '{{token}}',
+                    '{{initOptions}}',
+                    'mixpanel'
+                ]
+            ]
+        },
         {
             type: 'defineQueueMethods',
             target: 'mixpanel',
@@ -30,17 +52,6 @@ const mixpanelAnalyticsManifest = {
             async: true
         }
     ],
-    afterLoad: [
-        {
-            type: 'callGlobal',
-            global: 'mixpanel',
-            method: 'init',
-            args: [
-                '{{token}}',
-                '{{initOptions}}'
-            ]
-        }
-    ],
     onLoadGranted: [
         {
             type: 'callGlobal',

package/dist/vendors/analytics/pirsch.cjs

@@ -0,0 +1,108 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    pirsch: ()=>pirsch,
+    pirschManifest: ()=>pirschManifest
+});
+const external_resolve_cjs_namespaceObject = require("../../resolve.cjs");
+const external_types_cjs_namespaceObject = require("../../types.cjs");
+const script_url_cjs_namespaceObject = require("../_shared/script-url.cjs");
+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 = {
+    ...external_types_cjs_namespaceObject.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-event-endpoint': '{{eventEndpoint}}',
+                'data-disable-page-views': '{{disablePageViews}}'
+            }
+        }
+    ]
+};
+function commaListDataAttribute(value) {
+    if (void 0 === value) return;
+    if (Array.isArray(value)) {
+        const items = value.map((item)=>item.trim()).filter((item)=>item.length > 0);
+        if (0 === items.length) return;
+        return items.join(',');
+    }
+    return (0, script_url_cjs_namespaceObject.trimToUndefined)(value);
+}
+function presenceDataAttribute(value) {
+    if (true === value) return '';
+}
+function getPirschScriptElementId(options) {
+    if (true === options.extended) return 'pirschextendedjs';
+    return 'pianjs';
+}
+function getPirschScriptUrl(options) {
+    const defaultScriptUrl = true === options.extended ? DEFAULT_PIRSCH_EXTENDED_SCRIPT_URL : DEFAULT_PIRSCH_SCRIPT_URL;
+    return (0, script_url_cjs_namespaceObject.resolveScriptUrl)((0, script_url_cjs_namespaceObject.trimToUndefined)(options.scriptUrl), defaultScriptUrl);
+}
+function pirsch(options) {
+    const identificationCode = options.identificationCode.trim();
+    if (0 === identificationCode.length) throw new Error('pirsch: invalid identificationCode - must be a non-empty string');
+    const resolved = (0, external_resolve_cjs_namespaceObject.resolveManifest)(pirschManifest, {
+        identificationCode,
+        domain: commaListDataAttribute(options.domain),
+        dev: (0, script_url_cjs_namespaceObject.trimToUndefined)(options.dev),
+        hitEndpoint: (0, script_url_cjs_namespaceObject.trimToUndefined)(options.hitEndpoint),
+        eventEndpoint: (0, script_url_cjs_namespaceObject.trimToUndefined)(options.eventEndpoint),
+        disablePageViews: presenceDataAttribute(options.disablePageViews),
+        scriptElementId: getPirschScriptElementId(options),
+        scriptUrl: getPirschScriptUrl(options)
+    });
+    const manifestOnLoad = resolved.onLoad;
+    resolved.onLoad = (info)=>{
+        manifestOnLoad?.(info);
+        if ('loading' !== document.readyState) window.pirschInit?.();
+    };
+    return resolved;
+}
+exports.pirsch = __webpack_exports__.pirsch;
+exports.pirschManifest = __webpack_exports__.pirschManifest;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "pirsch",
+    "pirschManifest"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/vendors/analytics/pirsch.js

@@ -0,0 +1,67 @@
+import { resolveManifest } from "../../resolve.js";
+import { vendorManifestContract } from "../../types.js";
+import { resolveScriptUrl, trimToUndefined } from "../_shared/script-url.js";
+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-event-endpoint': '{{eventEndpoint}}',
+                'data-disable-page-views': '{{disablePageViews}}'
+            }
+        }
+    ]
+};
+function commaListDataAttribute(value) {
+    if (void 0 === value) return;
+    if (Array.isArray(value)) {
+        const items = value.map((item)=>item.trim()).filter((item)=>item.length > 0);
+        if (0 === items.length) return;
+        return items.join(',');
+    }
+    return trimToUndefined(value);
+}
+function presenceDataAttribute(value) {
+    if (true === value) return '';
+}
+function getPirschScriptElementId(options) {
+    if (true === options.extended) return 'pirschextendedjs';
+    return 'pianjs';
+}
+function getPirschScriptUrl(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 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),
+        eventEndpoint: trimToUndefined(options.eventEndpoint),
+        disablePageViews: presenceDataAttribute(options.disablePageViews),
+        scriptElementId: getPirschScriptElementId(options),
+        scriptUrl: getPirschScriptUrl(options)
+    });
+    const manifestOnLoad = resolved.onLoad;
+    resolved.onLoad = (info)=>{
+        manifestOnLoad?.(info);
+        if ('loading' !== document.readyState) window.pirschInit?.();
+    };
+    return resolved;
+}
+export { pirsch, pirschManifest };

package/dist/vendors/analytics/plausible-analytics.cjs

@@ -1,11 +1,15 @@
 "use strict";
 var __webpack_require__ = {};
 (()=>{
-    __webpack_require__.d = (exports1, definition)=>{
-        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
-            enumerable: true,
-            get: definition[key]
-        });
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
     };
 })();
 (()=>{

package/dist/vendors/analytics/posthog.cjs

@@ -1,11 +1,15 @@
 "use strict";
 var __webpack_require__ = {};
 (()=>{
-    __webpack_require__.d = (exports1, definition)=>{
-        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
-            enumerable: true,
-            get: definition[key]
-        });
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
     };
 })();
 (()=>{
@@ -24,8 +28,8 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    posthogManifest: ()=>posthogManifest,
-    posthog: ()=>posthog
+    posthog: ()=>posthog,
+    posthogManifest: ()=>posthogManifest
 });
 const external_resolve_cjs_namespaceObject = require("../../resolve.cjs");
 const external_types_cjs_namespaceObject = require("../../types.cjs");
@@ -83,29 +87,51 @@ const posthogManifest = {
         {
             type: 'setGlobal',
             name: 'posthog',
-            value: {},
+            value: [],
             ifUndefined: true
         },
+        {
+            type: 'setGlobalPath',
+            path: [
+                'posthog',
+                '_i'
+            ],
+            value: [
+                [
+                    '{{id}}',
+                    '{{initOptions}}',
+                    'posthog'
+                ]
+            ],
+            ifGlobalIsQueue: true
+        },
+        {
+            type: 'setGlobalPath',
+            path: [
+                'posthog',
+                'people'
+            ],
+            value: [],
+            ifGlobalIsQueue: true
+        },
+        {
+            type: 'defineQueueMethods',
+            target: 'posthog',
+            methods: [
+                'capture',
+                'opt_in_capturing',
+                'opt_out_capturing'
+            ]
+        },
         {
             type: 'defineGlobalMethods',
             target: 'posthog',
+            ifGlobalIsQueue: true,
             methods: [
                 {
                     name: 'init',
                     behavior: 'noop'
                 },
-                {
-                    name: 'capture',
-                    behavior: 'noop'
-                },
-                {
-                    name: 'opt_in_capturing',
-                    behavior: 'noop'
-                },
-                {
-                    name: 'opt_out_capturing',
-                    behavior: 'noop'
-                },
                 {
                     name: 'get_explicit_consent_status',
                     behavior: 'return',
@@ -126,14 +152,24 @@ const posthogManifest = {
             }
         }
     ],
-    afterLoad: [
+    onBeforeLoadGranted: [
         {
-            type: 'callGlobal',
-            global: 'posthog',
-            method: 'init',
-            args: [
-                '{{id}}',
-                '{{initOptions}}'
+            type: 'pushToQueue',
+            queue: 'posthog',
+            value: [
+                'opt_in_capturing',
+                {
+                    captureEventName: null
+                }
+            ]
+        }
+    ],
+    onBeforeLoadDenied: [
+        {
+            type: 'pushToQueue',
+            queue: 'posthog',
+            value: [
+                'opt_out_capturing'
             ]
         }
     ],

package/dist/vendors/analytics/posthog.js

@@ -54,29 +54,51 @@ const posthogManifest = {
         {
             type: 'setGlobal',
             name: 'posthog',
-            value: {},
+            value: [],
             ifUndefined: true
         },
+        {
+            type: 'setGlobalPath',
+            path: [
+                'posthog',
+                '_i'
+            ],
+            value: [
+                [
+                    '{{id}}',
+                    '{{initOptions}}',
+                    'posthog'
+                ]
+            ],
+            ifGlobalIsQueue: true
+        },
+        {
+            type: 'setGlobalPath',
+            path: [
+                'posthog',
+                'people'
+            ],
+            value: [],
+            ifGlobalIsQueue: true
+        },
+        {
+            type: 'defineQueueMethods',
+            target: 'posthog',
+            methods: [
+                'capture',
+                'opt_in_capturing',
+                'opt_out_capturing'
+            ]
+        },
         {
             type: 'defineGlobalMethods',
             target: 'posthog',
+            ifGlobalIsQueue: true,
             methods: [
                 {
                     name: 'init',
                     behavior: 'noop'
                 },
-                {
-                    name: 'capture',
-                    behavior: 'noop'
-                },
-                {
-                    name: 'opt_in_capturing',
-                    behavior: 'noop'
-                },
-                {
-                    name: 'opt_out_capturing',
-                    behavior: 'noop'
-                },
                 {
                     name: 'get_explicit_consent_status',
                     behavior: 'return',
@@ -97,14 +119,24 @@ const posthogManifest = {
             }
         }
     ],
-    afterLoad: [
+    onBeforeLoadGranted: [
         {
-            type: 'callGlobal',
-            global: 'posthog',
-            method: 'init',
-            args: [
-                '{{id}}',
-                '{{initOptions}}'
+            type: 'pushToQueue',
+            queue: 'posthog',
+            value: [
+                'opt_in_capturing',
+                {
+                    captureEventName: null
+                }
+            ]
+        }
+    ],
+    onBeforeLoadDenied: [
+        {
+            type: 'pushToQueue',
+            queue: 'posthog',
+            value: [
+                'opt_out_capturing'
             ]
         }
     ],