@c15t/scripts 2.2.0 → 3.0.0-alpha.1

package/dist/vendors/analytics/cloudflare-web-analytics.js

@@ -3,30 +3,30 @@ import { vendorManifestContract } from "../../types.js";
 import { resolveScriptUrl } from "../_shared/script-url.js";
 const cloudflareWebAnalyticsManifest = {
     ...vendorManifestContract,
-    vendor: 'cloudflare-web-analytics',
     category: 'measurement',
     install: [
         {
-            type: 'loadScript',
-            src: "{{scriptUrl}}",
-            defer: true,
             attributes: {
                 'data-cf-beacon': '{{beaconConfig}}'
-            }
+            },
+            defer: true,
+            src: "{{scriptUrl}}",
+            type: 'loadScript'
         }
-    ]
+    ],
+    vendor: 'cloudflare-web-analytics'
 };
-function cloudflareWebAnalytics(options) {
+const cloudflare_web_analytics_cloudflareWebAnalytics = function(options) {
     let token;
     token = 'string' == typeof options.token ? options.token.trim() : '';
     if (0 === token.length) throw new Error('cloudflareWebAnalytics: missing token');
     const resolved = resolveManifest(cloudflareWebAnalyticsManifest, {
-        scriptUrl: resolveScriptUrl(options.scriptUrl, 'https://static.cloudflareinsights.com/beacon.min.js'),
         beaconConfig: JSON.stringify({
-            token,
-            spa: options.spa ?? true
-        })
+            spa: options.spa ?? true,
+            token
+        }),
+        scriptUrl: resolveScriptUrl(options.scriptUrl, 'https://static.cloudflareinsights.com/beacon.min.js')
     });
     return resolved;
-}
-export { cloudflareWebAnalytics, cloudflareWebAnalyticsManifest };
+};
+export { cloudflareWebAnalyticsManifest, cloudflare_web_analytics_cloudflareWebAnalytics as cloudflareWebAnalytics };

package/dist/vendors/analytics/databuddy.js

@@ -2,102 +2,102 @@ import { resolveManifest } from "../../resolve.js";
 import { vendorManifestContract } from "../../types.js";
 const databuddyManifest = {
     ...vendorManifestContract,
-    vendor: 'databuddy',
-    category: 'measurement',
     alwaysLoad: true,
+    category: 'measurement',
     install: [
         {
-            type: 'loadScript',
-            src: "{{scriptUrl}}",
             async: true,
             attributes: {
                 crossorigin: 'anonymous',
-                'data-client-id': '{{clientId}}',
-                'data-api-url': '{{apiUrl}}'
-            }
+                'data-api-url': '{{apiUrl}}',
+                'data-client-id': '{{clientId}}'
+            },
+            src: "{{scriptUrl}}",
+            type: 'loadScript'
         }
     ],
-    onBeforeLoadGranted: [
+    onBeforeLoadDenied: [
         {
-            type: 'setGlobal',
+            ifUndefined: true,
             name: 'databuddyConfig',
-            value: '{{configWhenGranted}}',
-            ifUndefined: true
+            type: 'setGlobal',
+            value: '{{configWhenDenied}}'
         }
     ],
-    onBeforeLoadDenied: [
+    onBeforeLoadGranted: [
         {
-            type: 'setGlobal',
+            ifUndefined: true,
             name: 'databuddyConfig',
-            value: '{{configWhenDenied}}',
-            ifUndefined: true
+            type: 'setGlobal',
+            value: '{{configWhenGranted}}'
         }
     ],
-    onLoadGranted: [
+    onConsentDenied: [
         {
-            type: 'setGlobalPath',
-            path: [
-                'databuddy',
-                'options',
-                'disabled'
-            ],
-            value: false
-        }
-    ],
-    onLoadDenied: [
+            ifUndefined: false,
+            name: 'databuddyConfig',
+            type: 'setGlobal',
+            value: '{{configWhenDenied}}'
+        },
         {
-            type: 'setGlobalPath',
             path: [
                 'databuddy',
                 'options',
                 'disabled'
             ],
+            type: 'setGlobalPath',
             value: true
         }
     ],
     onConsentGranted: [
         {
-            type: 'setGlobal',
+            ifUndefined: false,
             name: 'databuddyConfig',
-            value: '{{configWhenGranted}}',
-            ifUndefined: false
+            type: 'setGlobal',
+            value: '{{configWhenGranted}}'
         },
         {
-            type: 'setGlobalPath',
             path: [
                 'databuddy',
                 'options',
                 'disabled'
             ],
+            type: 'setGlobalPath',
             value: false
         }
     ],
-    onConsentDenied: [
-        {
-            type: 'setGlobal',
-            name: 'databuddyConfig',
-            value: '{{configWhenDenied}}',
-            ifUndefined: false
-        },
+    onLoadDenied: [
         {
-            type: 'setGlobalPath',
             path: [
                 'databuddy',
                 'options',
                 'disabled'
             ],
+            type: 'setGlobalPath',
             value: true
         }
-    ]
+    ],
+    onLoadGranted: [
+        {
+            path: [
+                'databuddy',
+                'options',
+                'disabled'
+            ],
+            type: 'setGlobalPath',
+            value: false
+        }
+    ],
+    vendor: 'databuddy'
 };
-function databuddy(options) {
+const databuddy_databuddy = function(options) {
     const resolved = resolveManifest(databuddyManifest, {
-        clientId: options.clientId,
         apiUrl: options.apiUrl ?? 'https://basket.databuddy.cc',
-        configWhenGranted: options.configWhenGranted,
+        clientId: options.clientId,
         configWhenDenied: options.configWhenDenied,
+        configWhenGranted: options.configWhenGranted,
         scriptUrl: options.scriptUrl ?? 'https://cdn.databuddy.cc/databuddy.js'
     });
     return resolved;
-}
-export { databuddy, databuddyManifest };
+};
+export { databuddyManifest, databuddy_databuddy as databuddy };

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

@@ -4,32 +4,32 @@ import { booleanDataAttribute } from "../_shared/attributes.js";
 import { resolveScriptUrl } from "../_shared/script-url.js";
 const fathomAnalyticsManifest = {
     ...vendorManifestContract,
-    vendor: 'fathom-analytics',
     category: 'measurement',
     install: [
         {
-            type: 'loadScript',
-            src: "{{scriptUrl}}",
-            defer: true,
             attributes: {
-                'data-site': '{{site}}',
-                'data-spa': '{{spa}}',
                 'data-auto': '{{autoAttribute}}',
                 'data-canonical': '{{canonicalAttribute}}',
-                'data-honor-dnt': '{{honorDntAttribute}}'
-            }
+                'data-honor-dnt': '{{honorDntAttribute}}',
+                'data-site': '{{site}}',
+                'data-spa': '{{spa}}'
+            },
+            defer: true,
+            src: "{{scriptUrl}}",
+            type: 'loadScript'
         }
-    ]
+    ],
+    vendor: 'fathom-analytics'
 };
-function fathomAnalytics(options) {
+const fathom_analytics_fathomAnalytics = function(options) {
     const resolved = resolveManifest(fathomAnalyticsManifest, {
-        site: options.site,
-        spa: options.spa,
         autoAttribute: booleanDataAttribute(options.auto),
         canonicalAttribute: booleanDataAttribute(options.canonical),
         honorDntAttribute: booleanDataAttribute(options.honorDnt),
-        scriptUrl: resolveScriptUrl(options.scriptUrl, "https://cdn.usefathom.com/script.js")
+        scriptUrl: resolveScriptUrl(options.scriptUrl, "https://cdn.usefathom.com/script.js"),
+        site: options.site,
+        spa: options.spa
     });
     return resolved;
-}
-export { fathomAnalytics, fathomAnalyticsManifest };
+};
+export { fathomAnalyticsManifest, fathom_analytics_fathomAnalytics as fathomAnalytics };

package/dist/vendors/analytics/google-tag.js

@@ -3,55 +3,55 @@ import { runtimeDateValue, vendorManifestContract } from "../../types.js";
 import { GOOGLE_CONSENT_MODE_V2_DEFAULT_MAPPING, withOptionalConsentMapping } from "../_shared/google-consent.js";
 const gtagManifest = {
     ...vendorManifestContract,
-    vendor: 'gtag',
-    category: '{{category}}',
     alwaysLoad: true,
-    persistAfterConsentRevoked: true,
     bootstrap: [
         {
-            type: 'setGlobal',
+            ifUndefined: true,
             name: 'dataLayer',
-            value: [],
-            ifUndefined: true
+            type: 'setGlobal',
+            value: []
         },
         {
-            type: 'defineQueueFunction',
+            ifUndefined: true,
             name: 'gtag',
             queue: 'dataLayer',
-            ifUndefined: true
+            type: 'defineQueueFunction'
         }
     ],
+    category: '{{category}}',
+    consentMapping: GOOGLE_CONSENT_MODE_V2_DEFAULT_MAPPING,
+    consentSignal: 'gtag',
     install: [
         {
-            type: 'callGlobal',
-            global: 'gtag',
             args: [
                 'js',
                 runtimeDateValue
-            ]
+            ],
+            global: 'gtag',
+            type: 'callGlobal'
         },
         {
-            type: 'callGlobal',
-            global: 'gtag',
             args: [
                 'config',
                 '{{id}}'
-            ]
+            ],
+            global: 'gtag',
+            type: 'callGlobal'
         },
         {
-            type: 'loadScript',
+            async: true,
             src: 'https://www.googletagmanager.com/gtag/js?id={{id}}',
-            async: true
+            type: 'loadScript'
         }
     ],
-    consentMapping: GOOGLE_CONSENT_MODE_V2_DEFAULT_MAPPING,
-    consentSignal: 'gtag'
+    persistAfterConsentRevoked: true,
+    vendor: 'gtag'
 };
-function gtag({ id, category, consentMapping, script }) {
+const google_tag_gtag = function({ id, category, consentMapping, script }) {
     const manifest = withOptionalConsentMapping(gtagManifest, consentMapping);
     const resolved = resolveManifest(manifest, {
-        id,
-        category
+        category,
+        id
     });
     if (!script) return resolved;
     return {
@@ -62,5 +62,5 @@ function gtag({ id, category, consentMapping, script }) {
             ...script.attributes ?? {}
         }
     };
-}
-export { gtag, gtagManifest };
+};
+export { google_tag_gtag as gtag, gtagManifest };

package/dist/vendors/analytics/heap.js

@@ -29,74 +29,74 @@ const HEAP_QUEUE_METHODS = [
 ];
 const heapManifest = {
     ...vendorManifestContract,
-    vendor: 'heap',
     category: 'measurement',
     install: [
         {
-            type: 'setGlobal',
+            ifUndefined: true,
             name: 'heapReadyCb',
-            value: [],
-            ifUndefined: true
+            type: 'setGlobal',
+            value: []
         },
         {
-            type: 'setGlobal',
+            ifUndefined: true,
             name: 'heap',
-            value: [],
-            ifUndefined: true
+            type: 'setGlobal',
+            value: []
         },
         {
-            type: 'setGlobalPath',
             path: [
                 'heap',
                 'envId'
             ],
+            type: 'setGlobalPath',
             value: '{{envId}}'
         },
         {
-            type: 'setGlobalPath',
             path: [
                 'heap',
                 'appid'
             ],
+            type: 'setGlobalPath',
             value: '{{envId}}'
         },
         {
-            type: 'setGlobalPath',
             path: [
                 'heap',
                 'clientConfig'
             ],
+            type: 'setGlobalPath',
             value: '{{clientConfig}}'
         },
         {
-            type: 'defineQueueMethods',
-            target: 'heap',
+            methods: [
+                ...HEAP_QUEUE_METHODS
+            ],
             queue: {
                 global: 'heapReadyCb'
             },
             queueFormat: 'callback',
-            methods: [
-                ...HEAP_QUEUE_METHODS
-            ]
+            target: 'heap',
+            type: 'defineQueueMethods'
         },
         {
-            type: 'loadScript',
+            async: true,
             src: "{{scriptUrl}}",
-            async: true
+            type: 'loadScript'
         }
-    ]
+    ],
+    vendor: 'heap'
 };
-function validateEnvId(envId) {
+const heap_validateEnvId = function(envId) {
     const normalized = 'string' == typeof envId ? envId.trim() : '';
     if (0 === normalized.length) throw new Error('heap: missing or invalid envId');
     return normalized;
-}
-function isPlainRecord(value) {
+};
+const heap_isPlainRecord = function(value) {
     if (null === value || 'object' != typeof value || Array.isArray(value)) return false;
     const prototype = Object.getPrototypeOf(value);
     return prototype === Object.prototype || null === prototype;
-}
-function toJsonValue(value, path) {
+};
+const heap_toJsonValue = function toJsonValue(value, path) {
     if (null === value) return null;
     if ('string' == typeof value || 'boolean' == typeof value) return value;
     if ('number' == typeof value) {
@@ -104,31 +104,31 @@ function toJsonValue(value, path) {
         throw new TypeError(`heap: clientConfig${path ? `.${path}` : ''} must be a finite number`);
     }
     if (Array.isArray(value)) return value.map((item, index)=>toJsonValue(item, `${path}[${index}]`));
-    if (isPlainRecord(value)) {
+    if (heap_isPlainRecord(value)) {
         const result = {};
         for (const [key, nestedValue] of Object.entries(value))result[key] = toJsonValue(nestedValue, path ? `${path}.${key}` : key);
         return result;
     }
     throw new TypeError(`heap: clientConfig${path ? `.${path}` : ''} must be JSON-serializable`);
-}
-function normalizeClientConfig(clientConfig) {
+};
+const heap_normalizeClientConfig = function(clientConfig) {
     const config = clientConfig ?? {};
-    const normalized = toJsonValue(config, '');
-    if (!isPlainRecord(normalized)) throw new TypeError('heap: clientConfig must be a plain object');
+    const normalized = heap_toJsonValue(config, '');
+    if (!heap_isPlainRecord(normalized)) throw new TypeError('heap: clientConfig must be a plain object');
     return {
         ...normalized,
         shouldFetchServerConfig: false
     };
-}
-function resolveHeapScriptUrl(envId, scriptUrl) {
+};
+const heap_resolveHeapScriptUrl = function(envId, scriptUrl) {
     return resolveScriptUrl(trimToUndefined(scriptUrl), joinUrlPath(DEFAULT_HEAP_CONFIG_BASE_URL, `${envId}/heap_config.js`));
-}
-function heap({ envId, clientConfig, scriptUrl }) {
-    const normalizedEnvId = validateEnvId(envId);
+};
+const heap_heap = function({ envId, clientConfig, scriptUrl }) {
+    const normalizedEnvId = heap_validateEnvId(envId);
     return resolveManifest(heapManifest, {
+        clientConfig: heap_normalizeClientConfig(clientConfig),
         envId: normalizedEnvId,
-        clientConfig: normalizeClientConfig(clientConfig),
-        scriptUrl: resolveHeapScriptUrl(normalizedEnvId, scriptUrl)
+        scriptUrl: heap_resolveHeapScriptUrl(normalizedEnvId, scriptUrl)
     });
-}
-export { DEFAULT_HEAP_CONFIG_BASE_URL, HEAP_QUEUE_METHODS, heap, heapManifest };
+};
+export { DEFAULT_HEAP_CONFIG_BASE_URL, HEAP_QUEUE_METHODS, heapManifest, heap_heap as heap };

package/dist/vendors/analytics/hightouch.js

@@ -27,73 +27,73 @@ const HIGHTOUCH_QUEUE_METHODS = [
 ];
 const hightouchManifest = {
     ...vendorManifestContract,
-    vendor: 'hightouch',
-    category: 'measurement',
     bootstrap: [
         {
-            type: 'setGlobal',
+            ifUndefined: true,
             name: 'htevents',
-            value: [],
-            ifUndefined: true
+            type: 'setGlobal',
+            value: []
         },
         {
-            type: 'defineQueueMethods',
-            target: 'htevents',
             methods: [
                 ...HIGHTOUCH_QUEUE_METHODS
-            ]
+            ],
+            target: 'htevents',
+            type: 'defineQueueMethods'
         },
         {
-            type: 'setGlobalPath',
             path: [
                 'htevents',
                 '_writeKey'
             ],
+            type: 'setGlobalPath',
             value: '{{writeKey}}'
         },
         {
-            type: 'setGlobalPath',
             path: [
                 'htevents',
                 '_loadOptions'
             ],
+            type: 'setGlobalPath',
             value: '{{loadOptions}}'
         }
     ],
+    category: 'measurement',
     install: [
         {
-            type: 'callGlobal',
-            global: 'htevents',
-            method: 'load',
             args: [
                 '{{writeKey}}',
                 '{{loadOptions}}'
-            ]
+            ],
+            global: 'htevents',
+            method: 'load',
+            type: 'callGlobal'
         },
         {
-            type: 'callGlobal',
             global: 'htevents',
-            method: 'page'
+            method: 'page',
+            type: 'callGlobal'
         },
         {
-            type: 'loadScript',
+            async: true,
             src: "{{scriptUrl}}",
-            async: true
+            type: 'loadScript'
         }
-    ]
+    ],
+    vendor: 'hightouch'
 };
-function validateWriteKey(writeKey) {
+const hightouch_validateWriteKey = function(writeKey) {
     const normalized = 'string' == typeof writeKey ? writeKey.trim() : '';
     if (0 === normalized.length) throw new Error('hightouch: missing or invalid writeKey');
     return normalized;
-}
-function normalizeApiHost(apiHost) {
+};
+const hightouch_normalizeApiHost = function(apiHost) {
     return trimToUndefined(apiHost);
-}
-function hightouch({ writeKey, apiHost, trackPageView = true, scriptUrl }) {
-    const normalizedWriteKey = validateWriteKey(writeKey);
+};
+const hightouch_hightouch = function({ writeKey, apiHost, trackPageView = true, scriptUrl }) {
+    const normalizedWriteKey = hightouch_validateWriteKey(writeKey);
     const loadOptions = {
-        apiHost: normalizeApiHost(apiHost)
+        apiHost: hightouch_normalizeApiHost(apiHost)
     };
     let manifest = hightouchManifest;
     if (!trackPageView) manifest = {
@@ -102,8 +102,8 @@ function hightouch({ writeKey, apiHost, trackPageView = true, scriptUrl }) {
     };
     return resolveManifest(manifest, {
         loadOptions,
-        writeKey: normalizedWriteKey,
-        scriptUrl: resolveScriptUrl(trimToUndefined(scriptUrl), DEFAULT_HIGHTOUCH_SCRIPT_URL)
+        scriptUrl: resolveScriptUrl(trimToUndefined(scriptUrl), DEFAULT_HIGHTOUCH_SCRIPT_URL),
+        writeKey: normalizedWriteKey
     });
-}
-export { HIGHTOUCH_QUEUE_METHODS, hightouch, hightouchManifest };
+};
+export { HIGHTOUCH_QUEUE_METHODS, hightouchManifest, hightouch_hightouch as hightouch };

package/dist/vendors/analytics/hotjar.js

@@ -3,42 +3,42 @@ import { vendorManifestContract } from "../../types.js";
 import { resolveScriptUrl } from "../_shared/script-url.js";
 const hotjarManifest = {
     ...vendorManifestContract,
-    vendor: 'hotjar',
     category: 'measurement',
     install: [
         {
-            type: 'setGlobal',
+            ifUndefined: true,
             name: '_hjSettings',
+            type: 'setGlobal',
             value: {
                 hjid: '{{siteId}}',
                 hjsv: '{{version}}'
-            },
-            ifUndefined: true
+            }
         },
         {
-            type: 'defineStubFunction',
+            ifUndefined: true,
             name: 'hj',
             queue: {
                 property: 'q'
             },
             queueFormat: 'array',
-            ifUndefined: true
+            type: 'defineStubFunction'
         },
         {
-            type: 'loadScript',
+            async: true,
             src: "{{scriptUrl}}",
-            async: true
+            type: 'loadScript'
         }
-    ]
+    ],
+    vendor: 'hotjar'
 };
-function hotjar({ siteId, version = 6, scriptUrl }) {
+const hotjar_hotjar = function({ siteId, version = 6, scriptUrl }) {
     if (null == siteId) throw new Error('hotjar: missing or invalid siteId');
     const normalizedSiteId = String(siteId).trim();
     if (0 === normalizedSiteId.length || '0' === normalizedSiteId) throw new Error('hotjar: missing or invalid siteId');
     return resolveManifest(hotjarManifest, {
+        scriptUrl: resolveScriptUrl(scriptUrl, `https://static.hotjar.com/c/hotjar-${normalizedSiteId}.js?sv=${version}`),
         siteId: normalizedSiteId,
-        version,
-        scriptUrl: resolveScriptUrl(scriptUrl, `https://static.hotjar.com/c/hotjar-${normalizedSiteId}.js?sv=${version}`)
+        version
     });
-}
-export { hotjar, hotjarManifest };
+};
+export { hotjarManifest, hotjar_hotjar as hotjar };