@c15t/scripts 2.2.0 → 3.0.0-alpha.1

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

@@ -1,6 +1,6 @@
 import { resolveManifest } from "../../resolve.js";
 import { vendorManifestContract } from "../../types.js";
-function buildPlausibleScriptUrl(options) {
+const plausible_analytics_buildPlausibleScriptUrl = function(options) {
     if (options.scriptId) return `https://plausible.io/js/pa-${options.scriptId}.js`;
     if (options.extension) {
         let extensions;
@@ -8,8 +8,8 @@ function buildPlausibleScriptUrl(options) {
         return `https://plausible.io/js/script.${extensions}.js`;
     }
     return "https://plausible.io/js/script.js";
-}
-function buildPlausibleInitOptions(options) {
+};
+const plausible_analytics_buildPlausibleInitOptions = function(options) {
     const initOptions = {};
     if (options.customProperties) initOptions.customProperties = options.customProperties;
     if (options.endpoint) initOptions.endpoint = options.endpoint;
@@ -18,38 +18,38 @@ function buildPlausibleInitOptions(options) {
     if (void 0 !== options.autoCapturePageviews) initOptions.autoCapturePageviews = options.autoCapturePageviews;
     if (void 0 !== options.captureOnLocalhost) initOptions.captureOnLocalhost = options.captureOnLocalhost;
     return initOptions;
-}
+};
 const plausibleAnalyticsManifest = {
     ...vendorManifestContract,
-    vendor: 'plausible-analytics',
-    category: 'measurement',
     bootstrap: [
         {
-            type: 'defineStubFunction',
+            ifUndefined: true,
             name: 'plausible',
+            properties: {
+                o: '{{initOptions}}'
+            },
             queue: {
                 property: 'q'
             },
             queueFormat: 'array',
-            properties: {
-                o: '{{initOptions}}'
-            },
-            ifUndefined: true
+            type: 'defineStubFunction'
         }
     ],
+    category: 'measurement',
     install: [
         {
-            type: 'loadScript',
-            src: "{{scriptUrl}}",
-            defer: true,
             attributes: {
-                'data-domain': '{{domain}}',
-                'data-api': '{{apiAttribute}}'
-            }
+                'data-api': '{{apiAttribute}}',
+                'data-domain': '{{domain}}'
+            },
+            defer: true,
+            src: "{{scriptUrl}}",
+            type: 'loadScript'
         }
-    ]
+    ],
+    vendor: 'plausible-analytics'
 };
-function plausibleAnalytics(options) {
+const plausible_analytics_plausibleAnalytics = function(options) {
     let scriptId;
     if (options.scriptId) scriptId = options.scriptId.trim();
     let domain;
@@ -63,10 +63,10 @@ function plausibleAnalytics(options) {
     if (domain) normalizedOptions.domain = domain;
     else delete normalizedOptions.domain;
     const manifestOptions = {
-        scriptUrl: normalizedOptions.scriptUrl ?? buildPlausibleScriptUrl(normalizedOptions),
-        domain: void 0,
         apiAttribute: void 0,
-        initOptions: buildPlausibleInitOptions(normalizedOptions)
+        domain: void 0,
+        initOptions: plausible_analytics_buildPlausibleInitOptions(normalizedOptions),
+        scriptUrl: normalizedOptions.scriptUrl ?? plausible_analytics_buildPlausibleScriptUrl(normalizedOptions)
     };
     if (scriptId) {
         manifestOptions.domain = void 0;
@@ -77,5 +77,5 @@ function plausibleAnalytics(options) {
     }
     const resolved = resolveManifest(plausibleAnalyticsManifest, manifestOptions);
     return resolved;
-}
-export { plausibleAnalytics, plausibleAnalyticsManifest };
+};
+export { plausibleAnalyticsManifest, plausible_analytics_plausibleAnalytics as plausibleAnalytics };

package/dist/vendors/analytics/posthog.js

@@ -8,188 +8,193 @@ const DEFAULTS_DATE = '2026-01-30';
 const REGION_HOSTS = {
     eu: {
         apiHost: DEFAULT_API_HOST,
-        uiHost: DEFAULT_UI_HOST,
-        scriptUrl: DEFAULT_SCRIPT_URL
+        scriptUrl: DEFAULT_SCRIPT_URL,
+        uiHost: DEFAULT_UI_HOST
     },
     us: {
         apiHost: 'https://us.i.posthog.com',
-        uiHost: 'https://us.posthog.com',
-        scriptUrl: 'https://us-assets.i.posthog.com/static/array.js'
+        scriptUrl: 'https://us-assets.i.posthog.com/static/array.js',
+        uiHost: 'https://us.posthog.com'
     }
 };
-function normalizeHost(host) {
+const posthog_normalizeHost = function(host) {
     return stripTrailingSlashes(host);
-}
-function regionFromHost(host) {
-    const normalized = normalizeHost(host);
-    if (/^https:\/\/(app|us|us-assets)(\.i)?\.posthog\.com$/i.test(normalized)) return 'us';
-    if (/^https:\/\/(eu|eu-assets)(\.i)?\.posthog\.com$/i.test(normalized)) return 'eu';
-}
-function deriveScriptUrlFromApiHost(apiHost) {
-    const normalized = normalizeHost(apiHost);
-    const region = regionFromHost(normalized);
+};
+const posthog_regionFromHost = function(host) {
+    const normalized = posthog_normalizeHost(host);
+    if (/^https:\/\/(?<capture1>app|us|us-assets)(?<capture2>\.i)?\.posthog\.com$/iu.test(normalized)) return 'us';
+    if (/^https:\/\/(?<capture1>eu|eu-assets)(?<capture2>\.i)?\.posthog\.com$/iu.test(normalized)) return 'eu';
+};
+const posthog_deriveScriptUrlFromApiHost = function(apiHost) {
+    const normalized = posthog_normalizeHost(apiHost);
+    const region = posthog_regionFromHost(normalized);
     if (region) return REGION_HOSTS[region].scriptUrl;
     return `${normalized}/static/array.js`;
-}
-function resolvePosthogHosts(options) {
+};
+const posthog_resolvePosthogHosts = function(options) {
     const regionDefaults = REGION_HOSTS[options.region ?? 'eu'];
-    const apiHost = normalizeHost(options.apiHost ?? regionDefaults.apiHost);
-    const inferredRegion = regionFromHost(apiHost);
+    const apiHost = posthog_normalizeHost(options.apiHost ?? regionDefaults.apiHost);
+    const inferredRegion = posthog_regionFromHost(apiHost);
     let uiHost;
-    uiHost = void 0 !== options.uiHost ? options.uiHost : inferredRegion ? REGION_HOSTS[inferredRegion].uiHost : void 0 !== options.region ? REGION_HOSTS[options.region].uiHost : apiHost;
+    uiHost = void 0 !== options.uiHost ? options.uiHost : inferredRegion ? REGION_HOSTS[inferredRegion].uiHost : void 0 === options.region ? apiHost : REGION_HOSTS[options.region].uiHost;
     let scriptUrl;
-    scriptUrl = void 0 !== options.scriptUrl ? options.scriptUrl : void 0 !== options.apiHost ? deriveScriptUrlFromApiHost(apiHost) : regionDefaults.scriptUrl;
+    scriptUrl = void 0 !== options.scriptUrl ? options.scriptUrl : void 0 === options.apiHost ? regionDefaults.scriptUrl : posthog_deriveScriptUrlFromApiHost(apiHost);
     return {
         apiHost,
-        uiHost: normalizeHost(uiHost),
-        scriptUrl
+        scriptUrl,
+        uiHost: posthog_normalizeHost(uiHost)
     };
-}
+};
 const posthogManifest = {
     ...vendorManifestContract,
-    vendor: 'posthog',
-    category: 'measurement',
     alwaysLoad: true,
     bootstrap: [
         {
-            type: 'setGlobal',
+            ifUndefined: true,
             name: 'posthog',
-            value: [],
-            ifUndefined: true
+            type: 'setGlobal',
+            value: []
         },
         {
-            type: 'setGlobalPath',
+            ifGlobalIsQueue: true,
             path: [
                 'posthog',
                 '_i'
             ],
+            type: 'setGlobalPath',
             value: [
                 [
                     '{{id}}',
                     '{{initOptions}}',
                     'posthog'
                 ]
-            ],
-            ifGlobalIsQueue: true
+            ]
         },
         {
-            type: 'setGlobalPath',
+            ifGlobalIsQueue: true,
             path: [
                 'posthog',
                 'people'
             ],
-            value: [],
-            ifGlobalIsQueue: true
+            type: 'setGlobalPath',
+            value: []
         },
         {
-            type: 'defineQueueMethods',
-            target: 'posthog',
             methods: [
                 'capture',
                 'opt_in_capturing',
                 'opt_out_capturing'
-            ]
+            ],
+            target: 'posthog',
+            type: 'defineQueueMethods'
         },
         {
-            type: 'defineGlobalMethods',
-            target: 'posthog',
             ifGlobalIsQueue: true,
             methods: [
                 {
-                    name: 'init',
-                    behavior: 'noop'
+                    behavior: 'noop',
+                    name: 'init'
                 },
                 {
-                    name: 'get_explicit_consent_status',
                     behavior: 'return',
+                    name: 'get_explicit_consent_status',
                     value: 'pending'
                 }
-            ]
+            ],
+            target: 'posthog',
+            type: 'defineGlobalMethods'
         }
     ],
+    category: 'measurement',
     install: [
         {
-            type: 'loadScript',
-            src: "{{scriptUrl}}",
             async: true,
             attributes: {
                 crossorigin: 'anonymous',
                 'data-api-host': '{{apiHost}}',
                 'data-ui-host': '{{uiHost}}'
-            }
+            },
+            src: "{{scriptUrl}}",
+            type: 'loadScript'
         }
     ],
-    onBeforeLoadGranted: [
+    onBeforeLoadDenied: [
         {
-            type: 'pushToQueue',
             queue: 'posthog',
+            type: 'pushToQueue',
             value: [
-                'opt_in_capturing',
-                {
-                    captureEventName: null
-                }
+                'opt_out_capturing'
             ]
         }
     ],
-    onBeforeLoadDenied: [
+    onBeforeLoadGranted: [
         {
-            type: 'pushToQueue',
             queue: 'posthog',
+            type: 'pushToQueue',
             value: [
-                'opt_out_capturing'
+                'opt_in_capturing',
+                {
+                    captureEventName: null
+                }
             ]
         }
     ],
-    onLoadGranted: [
+    onConsentDenied: [
         {
-            type: 'callGlobal',
             global: 'posthog',
-            method: 'opt_in_capturing'
+            method: 'opt_out_capturing',
+            type: 'callGlobal'
         }
     ],
-    onLoadDenied: [
+    onConsentGranted: [
         {
-            type: 'callGlobal',
             global: 'posthog',
-            method: 'opt_out_capturing'
+            method: 'opt_in_capturing',
+            type: 'callGlobal'
         }
     ],
-    onConsentGranted: [
+    onLoadDenied: [
         {
-            type: 'callGlobal',
             global: 'posthog',
-            method: 'opt_in_capturing'
+            method: 'opt_out_capturing',
+            type: 'callGlobal'
         }
     ],
-    onConsentDenied: [
+    onLoadGranted: [
         {
-            type: 'callGlobal',
+            args: [
+                {
+                    captureEventName: null
+                }
+            ],
             global: 'posthog',
-            method: 'opt_out_capturing'
+            method: 'opt_in_capturing',
+            type: 'callGlobal'
         }
-    ]
+    ],
+    vendor: 'posthog'
 };
-function posthog(options) {
+const posthog_posthog = function(options) {
     if ('disabled' === options.loadMode) return {
-        id: 'posthog',
+        callbackOnly: true,
         category: 'measurement',
-        callbackOnly: true
+        id: 'posthog'
     };
-    const { apiHost, uiHost, scriptUrl } = resolvePosthogHosts(options);
+    const { apiHost, uiHost, scriptUrl } = posthog_resolvePosthogHosts(options);
     const resolved = resolveManifest(posthogManifest, {
-        id: options.id,
         apiHost,
-        uiHost,
-        scriptUrl,
+        id: options.id,
         initOptions: {
-            defaults: DEFAULTS_DATE,
             cookieless_mode: 'on_reject',
+            defaults: DEFAULTS_DATE,
             ...options.initOptions,
             api_host: apiHost,
             ui_host: uiHost
-        }
+        },
+        scriptUrl,
+        uiHost
     });
     if ('after-consent' === options.loadMode) resolved.alwaysLoad = void 0;
     return resolved;
-}
-export { posthog, posthogManifest };
+};
+export { posthogManifest, posthog_posthog as posthog };

package/dist/vendors/analytics/promptwatch.js

@@ -3,20 +3,20 @@ import { vendorManifestContract } from "../../types.js";
 import { resolveScriptUrl, trimToUndefined } from "../_shared/script-url.js";
 const promptwatchManifest = {
     ...vendorManifestContract,
-    vendor: 'promptwatch',
     category: 'measurement',
     install: [
         {
-            type: 'loadScript',
-            src: "{{scriptUrl}}",
             async: true,
             attributes: {
                 'data-project-id': '{{projectId}}'
-            }
+            },
+            src: "{{scriptUrl}}",
+            type: 'loadScript'
         }
-    ]
+    ],
+    vendor: 'promptwatch'
 };
-function promptwatch({ projectId, scriptUrl }) {
+const promptwatch_promptwatch = function({ projectId, scriptUrl }) {
     const normalizedProjectId = projectId.trim();
     if (0 === normalizedProjectId.length) throw new Error('promptwatch: invalid projectId - must be a non-empty string');
     const defaultScriptUrl = 'https://ingest.promptwatch.com/js/client.min.js';
@@ -25,5 +25,5 @@ function promptwatch({ projectId, scriptUrl }) {
         projectId: normalizedProjectId,
         scriptUrl: normalizedScriptUrl
     });
-}
-export { promptwatch, promptwatchManifest };
+};
+export { promptwatchManifest, promptwatch_promptwatch as promptwatch };

package/dist/vendors/analytics/rudderstack.js

@@ -20,74 +20,74 @@ const RUDDERSTACK_QUEUE_METHODS = [
 ];
 const rudderstackManifest = {
     ...vendorManifestContract,
-    vendor: 'rudderstack',
-    category: 'measurement',
     bootstrap: [
         {
-            type: 'setGlobal',
+            ifUndefined: true,
             name: 'rudderanalytics',
-            value: [],
-            ifUndefined: true
+            type: 'setGlobal',
+            value: []
         },
         {
-            type: 'setGlobal',
             name: 'RudderSnippetVersion',
+            type: 'setGlobal',
             value: '3.0.32'
         },
         {
-            type: 'setGlobal',
             name: 'rudderAnalyticsBuildType',
+            type: 'setGlobal',
             value: 'modern'
         },
         {
-            type: 'setGlobalPath',
             path: [
                 'rudderanalytics',
                 'snippetExecuted'
             ],
+            type: 'setGlobalPath',
             value: true
         },
         {
-            type: 'defineQueueMethods',
-            target: 'rudderanalytics',
             methods: [
                 ...RUDDERSTACK_QUEUE_METHODS
-            ]
+            ],
+            target: 'rudderanalytics',
+            type: 'defineQueueMethods'
         }
     ],
+    category: 'measurement',
     install: [
         {
-            type: 'callGlobal',
-            global: 'rudderanalytics',
-            method: 'load',
             args: [
                 '{{writeKey}}',
                 '{{dataPlaneUrl}}',
                 '{{loadOptions}}'
-            ]
+            ],
+            global: 'rudderanalytics',
+            method: 'load',
+            type: 'callGlobal'
         },
         {
-            type: 'callGlobal',
             global: 'rudderanalytics',
-            method: 'page'
+            method: 'page',
+            type: 'callGlobal'
         },
         {
-            type: 'loadScript',
-            src: "{{scriptUrl}}",
             async: true,
             attributes: {
                 'data-loader': 'RS_JS_SDK',
                 'data-rsa-write-key': '{{writeKey}}'
-            }
+            },
+            src: "{{scriptUrl}}",
+            type: 'loadScript'
         }
-    ]
+    ],
+    vendor: 'rudderstack'
 };
-function validateRequiredString(value, label) {
+const rudderstack_validateRequiredString = function(value, label) {
     const normalized = 'string' == typeof value ? value.trim() : '';
     if (0 === normalized.length) throw new Error(`rudderstack: missing or invalid ${label}`);
     return normalized;
-}
-function validateOptionalHttpsScriptUrl(scriptUrl) {
+};
+const rudderstack_validateOptionalHttpsScriptUrl = function(scriptUrl) {
     if (void 0 === scriptUrl) return;
     let parsed;
     try {
@@ -97,11 +97,11 @@ function validateOptionalHttpsScriptUrl(scriptUrl) {
     }
     if ('https:' !== parsed.protocol) throw new Error("rudderstack: scriptUrl must be a valid https URL");
     return scriptUrl;
-}
-function isJsonObjectValue(value) {
+};
+const rudderstack_isJsonObjectValue = function(value) {
     return 'object' == typeof value && null !== value && !Array.isArray(value);
-}
-function validateConsentMapping(consentManagement) {
+};
+const rudderstack_validateConsentMapping = function(consentManagement) {
     const normalized = {};
     for (const [category, ids] of Object.entries(consentManagement.mapping)){
         if (!Array.isArray(ids)) throw new Error(`rudderstack: consentManagement.mapping.${category} must be an array of consent IDs`);
@@ -114,25 +114,25 @@ function validateConsentMapping(consentManagement) {
     }
     if (0 === Object.keys(normalized).length) throw new Error('rudderstack: consentManagement.mapping must map at least one c15t category to a non-empty list of RudderStack consent IDs');
     return normalized;
-}
-function buildPreConsentLoadOptions(loadOptions) {
+};
+const rudderstack_buildPreConsentLoadOptions = function(loadOptions) {
     let userConsentManagement = {};
-    if (isJsonObjectValue(loadOptions.consentManagement)) userConsentManagement = loadOptions.consentManagement;
+    if (rudderstack_isJsonObjectValue(loadOptions.consentManagement)) userConsentManagement = loadOptions.consentManagement;
     let userPreConsent = {};
-    if (isJsonObjectValue(loadOptions.preConsent)) userPreConsent = loadOptions.preConsent;
+    if (rudderstack_isJsonObjectValue(loadOptions.preConsent)) userPreConsent = loadOptions.preConsent;
     let storage = {
         strategy: 'none'
     };
-    if (isJsonObjectValue(userPreConsent.storage)) storage = userPreConsent.storage;
+    if (rudderstack_isJsonObjectValue(userPreConsent.storage)) storage = userPreConsent.storage;
     return {
         ...loadOptions,
         preConsent: {
             ...userPreConsent,
             enabled: true,
-            storage,
             events: {
                 delivery: 'buffer'
-            }
+            },
+            storage
         },
         consentManagement: {
             ...userConsentManagement,
@@ -140,9 +140,9 @@ function buildPreConsentLoadOptions(loadOptions) {
             provider: 'custom'
         }
     };
-}
-function validateDataPlaneUrl(dataPlaneUrl) {
-    const normalized = validateRequiredString(dataPlaneUrl, 'dataPlaneUrl');
+};
+const rudderstack_validateDataPlaneUrl = function(dataPlaneUrl) {
+    const normalized = rudderstack_validateRequiredString(dataPlaneUrl, 'dataPlaneUrl');
     let parsed;
     try {
         parsed = new URL(normalized);
@@ -151,23 +151,23 @@ function validateDataPlaneUrl(dataPlaneUrl) {
     }
     if ('https:' !== parsed.protocol) throw new Error('rudderstack: dataPlaneUrl must be a valid https URL');
     return normalized;
-}
-function rudderstack({ writeKey, dataPlaneUrl, consentManagement, loadOptions = {}, trackPageView = true, scriptUrl }) {
-    const normalizedWriteKey = validateRequiredString(writeKey, 'writeKey');
-    const normalizedDataPlaneUrl = validateDataPlaneUrl(dataPlaneUrl);
+};
+const rudderstack_rudderstack = function({ writeKey, dataPlaneUrl, consentManagement, loadOptions = {}, trackPageView = true, scriptUrl }) {
+    const normalizedWriteKey = rudderstack_validateRequiredString(writeKey, 'writeKey');
+    const normalizedDataPlaneUrl = rudderstack_validateDataPlaneUrl(dataPlaneUrl);
     let manifest = rudderstackManifest;
     let resolvedLoadOptions = loadOptions;
     if (consentManagement) {
-        const consentMapping = validateConsentMapping(consentManagement);
+        const consentMapping = rudderstack_validateConsentMapping(consentManagement);
         manifest = {
             ...manifest,
             alwaysLoad: true,
-            persistAfterConsentRevoked: true,
             consentMapping,
             consentSignal: 'rudderstack',
-            consentSignalTarget: 'rudderanalytics'
+            consentSignalTarget: 'rudderanalytics',
+            persistAfterConsentRevoked: true
         };
-        resolvedLoadOptions = buildPreConsentLoadOptions(loadOptions);
+        resolvedLoadOptions = rudderstack_buildPreConsentLoadOptions(loadOptions);
     }
     if (!trackPageView) manifest = {
         ...manifest,
@@ -176,8 +176,8 @@ function rudderstack({ writeKey, dataPlaneUrl, consentManagement, loadOptions =
     return resolveManifest(manifest, {
         dataPlaneUrl: normalizedDataPlaneUrl,
         loadOptions: resolvedLoadOptions,
-        writeKey: normalizedWriteKey,
-        scriptUrl: resolveScriptUrl(validateOptionalHttpsScriptUrl(trimToUndefined(scriptUrl)), DEFAULT_RUDDERSTACK_SCRIPT_URL)
+        scriptUrl: resolveScriptUrl(rudderstack_validateOptionalHttpsScriptUrl(trimToUndefined(scriptUrl)), DEFAULT_RUDDERSTACK_SCRIPT_URL),
+        writeKey: normalizedWriteKey
     });
-}
-export { RUDDERSTACK_QUEUE_METHODS, rudderstack, rudderstackManifest };
+};
+export { RUDDERSTACK_QUEUE_METHODS, rudderstackManifest, rudderstack_rudderstack as rudderstack };