@c15t/scripts 2.0.0 → 2.1.0

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

@@ -0,0 +1,39 @@
+import { resolveManifest } from "../../resolve.js";
+import { vendorManifestContract } from "../../types.js";
+import { booleanDataAttribute, listDataAttribute } from "../_shared/attributes.js";
+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-domains': '{{domains}}',
+                'data-tag': '{{tag}}',
+                'data-before-send': '{{beforeSend}}'
+            }
+        }
+    ]
+};
+function umamiAnalytics(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),
+        domains: listDataAttribute(options.domains),
+        tag: options.tag,
+        beforeSend: options.beforeSend,
+        scriptUrl: resolveScriptUrl(options.scriptUrl, "https://cloud.umami.is/script.js")
+    });
+    return resolved;
+}
+export { umamiAnalytics, umamiAnalyticsManifest };

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

@@ -0,0 +1,90 @@
+"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__.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__, {
+    vercelAnalyticsManifest: ()=>vercelAnalyticsManifest,
+    vercelAnalytics: ()=>vercelAnalytics
+});
+const external_resolve_cjs_namespaceObject = require("../../resolve.cjs");
+const external_types_cjs_namespaceObject = require("../../types.cjs");
+const vercelAnalyticsManifest = {
+    ...external_types_cjs_namespaceObject.vendorManifestContract,
+    vendor: 'vercel-analytics',
+    category: 'measurement',
+    bootstrap: [
+        {
+            type: 'setGlobal',
+            name: 'vaq',
+            value: [],
+            ifUndefined: true
+        },
+        {
+            type: 'defineStubFunction',
+            name: 'va',
+            queue: {
+                global: 'vaq'
+            },
+            queueFormat: 'array',
+            ifUndefined: true
+        }
+    ],
+    install: [
+        {
+            type: 'loadScript',
+            src: "{{scriptUrl}}",
+            defer: true,
+            attributes: {
+                'data-sdkn': 'c15t',
+                'data-dsn': '{{dsn}}',
+                'data-disable-auto-track': '{{disableAutoTrackAttribute}}',
+                'data-endpoint': '{{endpoint}}'
+            }
+        }
+    ]
+};
+function getVercelScriptUrl(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 = {}) {
+    let disableAutoTrackAttribute;
+    if (options.disableAutoTrack) disableAutoTrackAttribute = '1';
+    return (0, external_resolve_cjs_namespaceObject.resolveManifest)(vercelAnalyticsManifest, {
+        scriptUrl: getVercelScriptUrl(options),
+        dsn: options.dsn,
+        endpoint: options.endpoint,
+        disableAutoTrackAttribute
+    });
+}
+exports.vercelAnalytics = __webpack_exports__.vercelAnalytics;
+exports.vercelAnalyticsManifest = __webpack_exports__.vercelAnalyticsManifest;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "vercelAnalytics",
+    "vercelAnalyticsManifest"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,53 @@
+import { resolveManifest } from "../../resolve.js";
+import { vendorManifestContract } from "../../types.js";
+const vercelAnalyticsManifest = {
+    ...vendorManifestContract,
+    vendor: 'vercel-analytics',
+    category: 'measurement',
+    bootstrap: [
+        {
+            type: 'setGlobal',
+            name: 'vaq',
+            value: [],
+            ifUndefined: true
+        },
+        {
+            type: 'defineStubFunction',
+            name: 'va',
+            queue: {
+                global: 'vaq'
+            },
+            queueFormat: 'array',
+            ifUndefined: true
+        }
+    ],
+    install: [
+        {
+            type: 'loadScript',
+            src: "{{scriptUrl}}",
+            defer: true,
+            attributes: {
+                'data-sdkn': 'c15t',
+                'data-dsn': '{{dsn}}',
+                'data-disable-auto-track': '{{disableAutoTrackAttribute}}',
+                'data-endpoint': '{{endpoint}}'
+            }
+        }
+    ]
+};
+function getVercelScriptUrl(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 = {}) {
+    let disableAutoTrackAttribute;
+    if (options.disableAutoTrack) disableAutoTrackAttribute = '1';
+    return resolveManifest(vercelAnalyticsManifest, {
+        scriptUrl: getVercelScriptUrl(options),
+        dsn: options.dsn,
+        endpoint: options.endpoint,
+        disableAutoTrackAttribute
+    });
+}
+export { vercelAnalytics, vercelAnalyticsManifest };

package/dist/vendors/functional/crisp.cjs

@@ -0,0 +1,139 @@
+"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__.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__, {
+    crisp: ()=>crisp,
+    crispManifest: ()=>crispManifest
+});
+const external_resolve_cjs_namespaceObject = require("../../resolve.cjs");
+const external_types_cjs_namespaceObject = require("../../types.cjs");
+const crispManifest = {
+    ...external_types_cjs_namespaceObject.vendorManifestContract,
+    vendor: 'crisp',
+    category: 'functionality',
+    install: [
+        {
+            type: 'setGlobal',
+            name: '$crisp',
+            value: [],
+            ifUndefined: false
+        },
+        {
+            type: 'setGlobal',
+            name: 'CRISP_WEBSITE_ID',
+            value: '{{websiteId}}',
+            ifUndefined: false
+        },
+        {
+            type: 'loadScript',
+            src: "{{scriptSrc}}",
+            async: true
+        }
+    ]
+};
+function createCrispManifest(options) {
+    const install = [
+        {
+            type: 'setGlobal',
+            name: '$crisp',
+            value: [],
+            ifUndefined: false
+        },
+        {
+            type: 'setGlobal',
+            name: 'CRISP_WEBSITE_ID',
+            value: '{{websiteId}}',
+            ifUndefined: false
+        }
+    ];
+    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 (options.cookieDomain) install.push({
+        type: 'setGlobal',
+        name: 'CRISP_COOKIE_DOMAIN',
+        value: '{{cookieDomain}}',
+        ifUndefined: false
+    });
+    if (void 0 !== options.cookieExpiry) install.push({
+        type: 'setGlobal',
+        name: 'CRISP_COOKIE_EXPIRE',
+        value: '{{cookieExpiry}}',
+        ifUndefined: false
+    });
+    if (options.tokenId) install.push({
+        type: 'setGlobal',
+        name: 'CRISP_TOKEN_ID',
+        value: '{{tokenId}}',
+        ifUndefined: false
+    });
+    if (options.safeMode) install.push({
+        type: 'pushToQueue',
+        queue: '$crisp',
+        value: [
+            'safe',
+            true
+        ]
+    });
+    install.push({
+        type: 'loadScript',
+        src: "{{scriptSrc}}",
+        async: true
+    });
+    return {
+        ...crispManifest,
+        install
+    };
+}
+function crisp(options) {
+    return (0, external_resolve_cjs_namespaceObject.resolveManifest)(createCrispManifest(options), {
+        websiteId: options.websiteId,
+        locale: options.locale,
+        cookieDomain: options.cookieDomain,
+        cookieExpiry: options.cookieExpiry,
+        tokenId: options.tokenId,
+        sessionMerge: options.sessionMerge,
+        scriptSrc: options.scriptSrc ?? 'https://client.crisp.chat/l.js'
+    });
+}
+exports.crisp = __webpack_exports__.crisp;
+exports.crispManifest = __webpack_exports__.crispManifest;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "crisp",
+    "crispManifest"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/vendors/functional/crisp.js

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

package/dist/vendors/functional/intercom.cjs

@@ -0,0 +1,85 @@
+"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__.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__, {
+    intercom: ()=>intercom,
+    intercomManifest: ()=>intercomManifest,
+    INTERCOM_API_BASES: ()=>INTERCOM_API_BASES
+});
+const external_resolve_cjs_namespaceObject = require("../../resolve.cjs");
+const external_types_cjs_namespaceObject = require("../../types.cjs");
+const INTERCOM_API_BASES = {
+    us: 'https://api-iam.intercom.io',
+    eu: 'https://api-iam.eu.intercom.io',
+    au: 'https://api-iam.au.intercom.io'
+};
+const intercomManifest = {
+    ...external_types_cjs_namespaceObject.vendorManifestContract,
+    vendor: 'intercom',
+    category: 'functionality',
+    install: [
+        {
+            type: 'defineStubFunction',
+            name: 'Intercom',
+            queue: {
+                property: 'q'
+            },
+            queueFormat: 'array',
+            ifUndefined: true
+        },
+        {
+            type: 'setGlobal',
+            name: 'intercomSettings',
+            value: '{{settings}}',
+            ifUndefined: false
+        },
+        {
+            type: 'loadScript',
+            src: "{{scriptSrc}}",
+            async: true
+        }
+    ]
+};
+function intercom({ appId, apiBase = INTERCOM_API_BASES.us, settings, scriptSrc }) {
+    return (0, external_resolve_cjs_namespaceObject.resolveManifest)(intercomManifest, {
+        settings: {
+            ...settings ?? {},
+            app_id: appId,
+            api_base: apiBase
+        },
+        scriptSrc: scriptSrc ?? `https://widget.intercom.io/widget/${appId}`
+    });
+}
+exports.INTERCOM_API_BASES = __webpack_exports__.INTERCOM_API_BASES;
+exports.intercom = __webpack_exports__.intercom;
+exports.intercomManifest = __webpack_exports__.intercomManifest;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "INTERCOM_API_BASES",
+    "intercom",
+    "intercomManifest"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/vendors/functional/intercom.js

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

package/dist/{google-tag-manager.cjs → vendors/tag-managers/google-tag-manager.cjs}

@@ -27,8 +27,9 @@ __webpack_require__.d(__webpack_exports__, {
     googleTagManagerManifest: ()=>googleTagManagerManifest,
     googleTagManager: ()=>googleTagManager
 });
-const external_resolve_cjs_namespaceObject = require("./resolve.cjs");
-const external_types_cjs_namespaceObject = require("./types.cjs");
+const external_resolve_cjs_namespaceObject = require("../../resolve.cjs");
+const external_types_cjs_namespaceObject = require("../../types.cjs");
+const google_consent_cjs_namespaceObject = require("../_shared/google-consent.cjs");
 const googleTagManagerManifest = {
     ...external_types_cjs_namespaceObject.vendorManifestContract,
     vendor: 'google-tag-manager',
@@ -53,7 +54,7 @@ const googleTagManagerManifest = {
             type: 'pushToQueue',
             queue: 'dataLayer',
             value: {
-                'gtm.start': '{{loadTime}}',
+                'gtm.start': external_types_cjs_namespaceObject.runtimeTimestampValue,
                 event: 'gtm.js'
             }
         },
@@ -73,35 +74,13 @@ const googleTagManagerManifest = {
             ]
         }
     ],
-    consentMapping: {
-        necessary: [
-            'security_storage'
-        ],
-        functionality: [
-            'functionality_storage'
-        ],
-        measurement: [
-            'analytics_storage'
-        ],
-        marketing: [
-            'ad_storage',
-            'ad_user_data',
-            'ad_personalization'
-        ],
-        experience: [
-            'personalization_storage'
-        ]
-    },
+    consentMapping: google_consent_cjs_namespaceObject.GOOGLE_CONSENT_MODE_V2_DEFAULT_MAPPING,
     consentSignal: 'gtag'
 };
 function googleTagManager({ id, updateEventName, consentMapping }) {
-    const manifest = consentMapping ? {
-        ...googleTagManagerManifest,
-        consentMapping
-    } : googleTagManagerManifest;
+    const manifest = (0, google_consent_cjs_namespaceObject.withOptionalConsentMapping)(googleTagManagerManifest, consentMapping);
     const resolved = (0, external_resolve_cjs_namespaceObject.resolveManifest)(manifest, {
         id,
-        loadTime: Date.now(),
         updateEventName: updateEventName ?? 'consent-update'
     });
     return resolved;

package/dist/{google-tag-manager.js → vendors/tag-managers/google-tag-manager.js}

@@ -1,5 +1,6 @@
-import { resolveManifest } from "./resolve.js";
-import { vendorManifestContract } from "./types.js";
+import { resolveManifest } from "../../resolve.js";
+import { runtimeTimestampValue, vendorManifestContract } from "../../types.js";
+import { GOOGLE_CONSENT_MODE_V2_DEFAULT_MAPPING, withOptionalConsentMapping } from "../_shared/google-consent.js";
 const googleTagManagerManifest = {
     ...vendorManifestContract,
     vendor: 'google-tag-manager',
@@ -24,7 +25,7 @@ const googleTagManagerManifest = {
             type: 'pushToQueue',
             queue: 'dataLayer',
             value: {
-                'gtm.start': '{{loadTime}}',
+                'gtm.start': runtimeTimestampValue,
                 event: 'gtm.js'
             }
         },
@@ -44,35 +45,13 @@ const googleTagManagerManifest = {
             ]
         }
     ],
-    consentMapping: {
-        necessary: [
-            'security_storage'
-        ],
-        functionality: [
-            'functionality_storage'
-        ],
-        measurement: [
-            'analytics_storage'
-        ],
-        marketing: [
-            'ad_storage',
-            'ad_user_data',
-            'ad_personalization'
-        ],
-        experience: [
-            'personalization_storage'
-        ]
-    },
+    consentMapping: GOOGLE_CONSENT_MODE_V2_DEFAULT_MAPPING,
     consentSignal: 'gtag'
 };
 function googleTagManager({ id, updateEventName, consentMapping }) {
-    const manifest = consentMapping ? {
-        ...googleTagManagerManifest,
-        consentMapping
-    } : googleTagManagerManifest;
+    const manifest = withOptionalConsentMapping(googleTagManagerManifest, consentMapping);
     const resolved = resolveManifest(manifest, {
         id,
-        loadTime: Date.now(),
         updateEventName: updateEventName ?? 'consent-update'
     });
     return resolved;