@c15t/scripts 2.2.0 → 3.0.0-alpha.1

package/dist/vendors/ads-and-pixels/reddit-pixel.js

@@ -4,64 +4,71 @@ import { buildQueuePixelInstall } from "../_shared/install-builders.js";
 import { resolveScriptUrl } from "../_shared/script-url.js";
 const redditPixelManifest = {
     ...vendorManifestContract,
-    vendor: 'reddit-pixel',
-    category: 'marketing',
-    persistAfterConsentRevoked: true,
     bootstrap: [
         {
-            type: 'defineStubFunction',
+            dispatchProperty: 'sendEvent',
+            ifUndefined: true,
             name: 'rdt',
             queue: {
                 property: 'callQueue'
             },
-            dispatchProperty: 'sendEvent',
             queueFormat: 'array',
-            ifUndefined: true
+            type: 'defineStubFunction'
         }
     ],
+    category: 'marketing',
     install: [
         {
-            type: 'callGlobal',
-            global: 'rdt',
             args: [
                 'init',
                 '{{pixelId}}'
-            ]
+            ],
+            global: 'rdt',
+            type: 'callGlobal'
         },
         {
-            type: 'callGlobal',
-            global: 'rdt',
             args: [
                 'track',
                 'PageVisit'
-            ]
+            ],
+            global: 'rdt',
+            type: 'callGlobal'
         },
         {
-            type: 'loadScript',
+            async: true,
             src: "{{scriptUrl}}",
-            async: true
+            type: 'loadScript'
         }
     ],
-    onConsentGranted: [
+    onConsentDenied: [
         {
-            type: 'callGlobal',
-            global: 'rdt',
             args: [
-                'enableFirstPartyCookies'
-            ]
+                'disableFirstPartyCookies'
+            ],
+            global: 'rdt',
+            type: 'callGlobal'
         }
     ],
-    onConsentDenied: [
+    onConsentGranted: [
         {
-            type: 'callGlobal',
-            global: 'rdt',
             args: [
-                'disableFirstPartyCookies'
-            ]
+                'enableFirstPartyCookies'
+            ],
+            global: 'rdt',
+            type: 'callGlobal'
         }
-    ]
+    ],
+    persistAfterConsentRevoked: true,
+    vendor: 'reddit-pixel'
+};
+const reddit_pixel_getRedditPixelInitOptions = function({ initOptions, disableFirstPartyCookies }) {
+    if (void 0 === disableFirstPartyCookies) return initOptions;
+    return {
+        ...initOptions,
+        disableFirstPartyCookies
+    };
 };
-function redditPixel({ pixelId, trackPageVisit = true, initOptions, disableFirstPartyCookies, scriptUrl }) {
+const reddit_pixel_redditPixel = function({ pixelId, trackPageVisit = true, initOptions, disableFirstPartyCookies, scriptUrl }) {
     let trackStep;
     if (trackPageVisit) trackStep = {
         args: [
@@ -69,9 +76,9 @@ function redditPixel({ pixelId, trackPageVisit = true, initOptions, disableFirst
             'PageVisit'
         ]
     };
-    const resolvedInitOptions = getRedditPixelInitOptions({
-        initOptions,
-        disableFirstPartyCookies
+    const resolvedInitOptions = reddit_pixel_getRedditPixelInitOptions({
+        disableFirstPartyCookies,
+        initOptions
     });
     const initArgs = [
         'init',
@@ -88,20 +95,13 @@ function redditPixel({ pixelId, trackPageVisit = true, initOptions, disableFirst
         install
     };
     return resolveManifest(manifest, {
-        pixelId,
         initOptions: resolvedInitOptions,
+        pixelId,
         scriptUrl: resolveScriptUrl(scriptUrl, 'https://www.redditstatic.com/ads/pixel.js')
     });
-}
-function getRedditPixelInitOptions({ initOptions, disableFirstPartyCookies }) {
-    if (void 0 === disableFirstPartyCookies) return initOptions;
-    return {
-        ...initOptions,
-        disableFirstPartyCookies
-    };
-}
+};
 const redditPixelEvent = (eventName, metadata)=>{
     if ("u" < typeof window || 'function' != typeof window.rdt) return;
     window.rdt('track', eventName, metadata);
 };
-export { redditPixel, redditPixelEvent, redditPixelManifest };
+export { redditPixelEvent, redditPixelManifest, reddit_pixel_redditPixel as redditPixel };

package/dist/vendors/ads-and-pixels/snapchat-pixel.js

@@ -4,55 +4,55 @@ import { buildQueuePixelInstall } from "../_shared/install-builders.js";
 import { resolveScriptUrl } from "../_shared/script-url.js";
 const snapchatPixelManifest = {
     ...vendorManifestContract,
-    vendor: 'snapchat-pixel',
-    category: 'marketing',
     bootstrap: [
         {
-            type: 'defineStubFunction',
+            aliases: [
+                '_snaptr'
+            ],
+            dispatchProperty: 'handleRequest',
+            ifUndefined: true,
             name: 'snaptr',
+            properties: {
+                loaded: true,
+                version: '1.0'
+            },
             queue: {
                 property: 'queue'
             },
-            dispatchProperty: 'handleRequest',
             queueFormat: 'array',
-            aliases: [
-                '_snaptr'
-            ],
             selfReferences: [
                 'push'
             ],
-            properties: {
-                loaded: true,
-                version: '1.0'
-            },
-            ifUndefined: true
+            type: 'defineStubFunction'
         }
     ],
+    category: 'marketing',
     install: [
         {
-            type: 'callGlobal',
-            global: 'snaptr',
             args: [
                 'init',
                 '{{pixelId}}'
-            ]
+            ],
+            global: 'snaptr',
+            type: 'callGlobal'
         },
         {
-            type: 'callGlobal',
-            global: 'snaptr',
             args: [
                 'track',
                 'PAGE_VIEW'
-            ]
+            ],
+            global: 'snaptr',
+            type: 'callGlobal'
         },
         {
-            type: 'loadScript',
+            async: true,
             src: "{{scriptUrl}}",
-            async: true
+            type: 'loadScript'
         }
-    ]
+    ],
+    vendor: 'snapchat-pixel'
 };
-function snapchatPixel({ pixelId, initOptions, trackPageView = true, scriptUrl }) {
+const snapchat_pixel_snapchatPixel = function({ pixelId, initOptions, trackPageView = true, scriptUrl }) {
     const initArgs = [
         'init',
         '{{pixelId}}'
@@ -75,13 +75,13 @@ function snapchatPixel({ pixelId, initOptions, trackPageView = true, scriptUrl }
         install
     };
     return resolveManifest(manifest, {
-        pixelId,
         initOptions,
+        pixelId,
         scriptUrl: resolveScriptUrl(scriptUrl, 'https://sc-static.net/scevent.min.js')
     });
-}
+};
 const snapchatPixelEvent = (eventName, properties)=>{
     if ("u" < typeof window || 'function' != typeof window.snaptr) return;
     window.snaptr('track', eventName, properties);
 };
-export { snapchatPixel, snapchatPixelEvent, snapchatPixelManifest };
+export { snapchatPixelEvent, snapchatPixelManifest, snapchat_pixel_snapchatPixel as snapchatPixel };

package/dist/vendors/ads-and-pixels/tiktok-pixel.js

@@ -2,24 +2,26 @@ import { resolveManifest } from "../../resolve.js";
 import { vendorManifestContract } from "../../types.js";
 const tiktokPixelManifest = {
     ...vendorManifestContract,
-    vendor: 'tiktok-pixel',
-    category: 'marketing',
-    persistAfterConsentRevoked: true,
+    afterLoad: [
+        {
+            global: 'ttq',
+            method: 'grantConsent',
+            type: 'callGlobal'
+        }
+    ],
     bootstrap: [
         {
-            type: 'setGlobal',
             name: 'TiktokAnalyticsObject',
+            type: 'setGlobal',
             value: 'ttq'
         },
         {
-            type: 'setGlobal',
+            ifUndefined: true,
             name: 'ttq',
-            value: [],
-            ifUndefined: true
+            type: 'setGlobal',
+            value: []
         },
         {
-            type: 'defineQueueMethods',
-            target: 'ttq',
             methods: [
                 'page',
                 'track',
@@ -37,53 +39,51 @@ const tiktokPixelManifest = {
                 'holdConsent',
                 'revokeConsent',
                 'grantConsent'
-            ]
+            ],
+            target: 'ttq',
+            type: 'defineQueueMethods'
         }
     ],
+    category: 'marketing',
     install: [
         {
-            type: 'callGlobal',
             global: 'ttq',
-            method: 'grantConsent'
+            method: 'grantConsent',
+            type: 'callGlobal'
         },
         {
-            type: 'callGlobal',
             global: 'ttq',
-            method: 'page'
+            method: 'page',
+            type: 'callGlobal'
         },
         {
-            type: 'loadScript',
+            async: true,
             src: "{{scriptSrc}}?sdkid={{pixelId}}&lib=ttq",
-            async: true
+            type: 'loadScript'
         }
     ],
-    afterLoad: [
+    onConsentDenied: [
         {
-            type: 'callGlobal',
             global: 'ttq',
-            method: 'grantConsent'
+            method: 'revokeConsent',
+            type: 'callGlobal'
         }
     ],
     onConsentGranted: [
         {
-            type: 'callGlobal',
             global: 'ttq',
-            method: 'grantConsent'
+            method: 'grantConsent',
+            type: 'callGlobal'
         }
     ],
-    onConsentDenied: [
-        {
-            type: 'callGlobal',
-            global: 'ttq',
-            method: 'revokeConsent'
-        }
-    ]
+    persistAfterConsentRevoked: true,
+    vendor: 'tiktok-pixel'
 };
-function tiktokPixel({ pixelId, scriptSrc }) {
+const tiktok_pixel_tiktokPixel = function({ pixelId, scriptSrc }) {
     const resolved = resolveManifest(tiktokPixelManifest, {
         pixelId,
         scriptSrc: scriptSrc ?? 'https://analytics.tiktok.com/i18n/pixel/events.js'
     });
     return resolved;
-}
-export { tiktokPixel, tiktokPixelManifest };
+};
+export { tiktokPixelManifest, tiktok_pixel_tiktokPixel as tiktokPixel };

package/dist/vendors/ads-and-pixels/x-pixel.js

@@ -2,47 +2,47 @@ import { resolveManifest } from "../../resolve.js";
 import { vendorManifestContract } from "../../types.js";
 const xPixelManifest = {
     ...vendorManifestContract,
-    vendor: 'x-pixel',
-    category: 'marketing',
     bootstrap: [
         {
-            type: 'defineStubFunction',
-            name: 'twq',
-            queue: {
-                property: 'queue'
-            },
             dispatchProperty: 'exe',
+            ifUndefined: true,
+            name: 'twq',
             properties: {
                 version: '1.1'
             },
-            ifUndefined: true
+            queue: {
+                property: 'queue'
+            },
+            type: 'defineStubFunction'
         }
     ],
+    category: 'marketing',
     install: [
         {
-            type: 'callGlobal',
-            global: 'twq',
             args: [
                 'config',
                 '{{pixelId}}'
-            ]
+            ],
+            global: 'twq',
+            type: 'callGlobal'
         },
         {
-            type: 'loadScript',
+            async: true,
             src: "{{scriptSrc}}",
-            async: true
+            type: 'loadScript'
         }
-    ]
+    ],
+    vendor: 'x-pixel'
 };
-function xPixel({ pixelId, scriptSrc }) {
+const x_pixel_xPixel = function({ pixelId, scriptSrc }) {
     const resolved = resolveManifest(xPixelManifest, {
         pixelId,
         scriptSrc: scriptSrc ?? 'https://static.ads-twitter.com/uwt.js'
     });
     return resolved;
-}
+};
 const xPixelEvent = (eventId, metadata)=>{
     if ("u" < typeof window || 'function' != typeof window.twq) throw new Error('X Pixel (twq) is not loaded. Ensure marketing consent is granted before calling xPixelEvent.');
     window.twq('event', eventId, metadata);
 };
-export { xPixel, xPixelEvent, xPixelManifest };
+export { xPixelEvent, xPixelManifest, x_pixel_xPixel as xPixel };

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

@@ -1,6 +1,6 @@
 import { resolveManifest } from "../../resolve.js";
 import { vendorManifestContract } from "../../types.js";
-function validateAdobeAnalyticsScriptUrl(scriptUrl) {
+const adobe_analytics_validateAdobeAnalyticsScriptUrl = function(scriptUrl) {
     const trimmed = scriptUrl.trim();
     if (0 === trimmed.length) throw new Error("adobeAnalytics: invalid scriptUrl - must be a non-empty https URL from your Adobe Data Collection embed code");
     let parsed;
@@ -11,39 +11,39 @@ function validateAdobeAnalyticsScriptUrl(scriptUrl) {
     }
     if ('https:' !== parsed.protocol) throw new Error("adobeAnalytics: invalid scriptUrl - must use https: from your Adobe Data Collection embed code");
     return trimmed;
-}
-function createAdobeAnalyticsManifest(options) {
+};
+const adobe_analytics_createAdobeAnalyticsManifest = function(options) {
     const install = [];
     if (options.seedAdobeDataLayer) install.push({
-        type: 'setGlobal',
+        ifUndefined: true,
         name: 'adobeDataLayer',
-        value: [],
-        ifUndefined: true
+        type: 'setGlobal',
+        value: []
     });
     install.push({
-        type: 'loadScript',
+        async: options.async,
         src: "{{scriptUrl}}",
-        async: options.async
+        type: 'loadScript'
     });
     return {
         ...vendorManifestContract,
-        vendor: 'adobe-analytics',
         category: 'measurement',
-        install
+        install,
+        vendor: 'adobe-analytics'
     };
-}
-const adobeAnalyticsManifest = createAdobeAnalyticsManifest({
+};
+const adobeAnalyticsManifest = adobe_analytics_createAdobeAnalyticsManifest({
     async: true,
     seedAdobeDataLayer: true
 });
-function adobeAnalytics(options) {
-    const scriptUrl = validateAdobeAnalyticsScriptUrl(options.scriptUrl);
-    const manifest = createAdobeAnalyticsManifest({
+const adobe_analytics_adobeAnalytics = function(options) {
+    const scriptUrl = adobe_analytics_validateAdobeAnalyticsScriptUrl(options.scriptUrl);
+    const manifest = adobe_analytics_createAdobeAnalyticsManifest({
         async: options.async ?? true,
         seedAdobeDataLayer: options.seedAdobeDataLayer ?? true
     });
     return resolveManifest(manifest, {
         scriptUrl
     });
-}
-export { adobeAnalytics, adobeAnalyticsManifest };
+};
+export { adobeAnalyticsManifest, adobe_analytics_adobeAnalytics as adobeAnalytics };

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

@@ -3,25 +3,25 @@ import { vendorManifestContract } from "../../types.js";
 import { resolveScriptUrl } from "../_shared/script-url.js";
 const ahrefsAnalyticsManifest = {
     ...vendorManifestContract,
-    vendor: 'ahrefs-analytics',
     category: 'measurement',
     install: [
         {
-            type: 'loadScript',
-            src: "{{scriptUrl}}",
             async: true,
             attributes: {
                 'data-key': '{{key}}'
-            }
+            },
+            src: "{{scriptUrl}}",
+            type: 'loadScript'
         }
-    ]
+    ],
+    vendor: 'ahrefs-analytics'
 };
-function ahrefsAnalytics(options) {
+const ahrefs_analytics_ahrefsAnalytics = function(options) {
     const key = 'string' == typeof options.key ? options.key.trim() : '';
     if (0 === key.length) throw new Error('ahrefsAnalytics: missing or invalid key');
     return resolveManifest(ahrefsAnalyticsManifest, {
         key,
         scriptUrl: resolveScriptUrl(options.scriptUrl, 'https://analytics.ahrefs.com/analytics.js')
     });
-}
-export { ahrefsAnalytics, ahrefsAnalyticsManifest };
+};
+export { ahrefsAnalyticsManifest, ahrefs_analytics_ahrefsAnalytics as ahrefsAnalytics };

package/dist/vendors/analytics/amplitude.js

@@ -32,38 +32,37 @@ const AMPLITUDE_IDENTIFY_METHODS = [
 ];
 const amplitudeManifest = {
     ...vendorManifestContract,
-    vendor: 'amplitude',
     category: 'measurement',
     install: [
         {
-            type: 'setGlobal',
+            ifUndefined: true,
             name: 'amplitude',
+            type: 'setGlobal',
             value: {
-                _q: [],
                 _iq: {},
+                _q: [],
                 invoked: true
-            },
-            ifUndefined: true
+            }
         },
         {
-            type: 'defineQueueClass',
-            target: 'amplitude',
-            name: 'Identify',
-            queueProperty: '_q',
             methods: [
                 ...AMPLITUDE_IDENTIFY_METHODS
-            ]
+            ],
+            name: 'Identify',
+            queueProperty: '_q',
+            target: 'amplitude',
+            type: 'defineQueueClass'
         },
         {
-            type: 'defineQueueMethods',
-            target: 'amplitude',
+            methods: [
+                ...AMPLITUDE_PROMISE_QUEUE_METHODS
+            ],
             queue: {
                 property: '_q'
             },
             queueFormat: 'wrappedMethodCall',
-            methods: [
-                ...AMPLITUDE_PROMISE_QUEUE_METHODS
-            ]
+            target: 'amplitude',
+            type: 'defineQueueMethods'
         },
         {
             type: 'defineQueueMethods',
@@ -77,52 +76,53 @@ const amplitudeManifest = {
             ]
         },
         {
-            type: 'callGlobal',
-            global: 'amplitude',
-            method: 'init',
             args: [
                 '{{apiKey}}',
                 '{{initOptions}}'
-            ]
+            ],
+            global: 'amplitude',
+            method: 'init',
+            type: 'callGlobal'
         },
         {
-            type: 'loadScript',
+            async: true,
             src: "{{scriptUrl}}",
-            async: true
+            type: 'loadScript'
         }
     ],
-    onLoadDenied: [
+    onConsentDenied: [
         {
-            type: 'callGlobal',
-            global: 'amplitude',
-            method: 'setOptOut',
             args: [
                 true
-            ]
+            ],
+            global: 'amplitude',
+            method: 'setOptOut',
+            type: 'callGlobal'
         }
     ],
     onConsentGranted: [
         {
-            type: 'callGlobal',
-            global: 'amplitude',
-            method: 'setOptOut',
             args: [
                 false
-            ]
+            ],
+            global: 'amplitude',
+            method: 'setOptOut',
+            type: 'callGlobal'
         }
     ],
-    onConsentDenied: [
+    onLoadDenied: [
         {
-            type: 'callGlobal',
-            global: 'amplitude',
-            method: 'setOptOut',
             args: [
                 true
-            ]
+            ],
+            global: 'amplitude',
+            method: 'setOptOut',
+            type: 'callGlobal'
         }
-    ]
+    ],
+    vendor: 'amplitude'
 };
-function amplitude({ apiKey, initOptions = {}, scriptUrl }) {
+const amplitude_amplitude = function({ apiKey, initOptions = {}, scriptUrl }) {
     const normalizedApiKey = 'string' == typeof apiKey ? apiKey.trim() : '';
     if (0 === normalizedApiKey.length) throw new Error('amplitude: missing or invalid apiKey');
     return resolveManifest(amplitudeManifest, {
@@ -130,5 +130,5 @@ function amplitude({ apiKey, initOptions = {}, scriptUrl }) {
         initOptions,
         scriptUrl: resolveScriptUrl(trimToUndefined(scriptUrl), DEFAULT_AMPLITUDE_SCRIPT_URL)
     });
-}
-export { AMPLITUDE_IDENTIFY_METHODS, AMPLITUDE_PROMISE_QUEUE_METHODS, AMPLITUDE_QUEUE_METHODS, AMPLITUDE_SYNC_QUEUE_METHODS, DEFAULT_AMPLITUDE_BROWSER_SDK_VERSION, DEFAULT_AMPLITUDE_SCRIPT_URL, amplitude, amplitudeManifest };
+};
+export { AMPLITUDE_IDENTIFY_METHODS, AMPLITUDE_PROMISE_QUEUE_METHODS, AMPLITUDE_QUEUE_METHODS, AMPLITUDE_SYNC_QUEUE_METHODS, DEFAULT_AMPLITUDE_BROWSER_SDK_VERSION, DEFAULT_AMPLITUDE_SCRIPT_URL, amplitudeManifest, amplitude_amplitude as amplitude };

package/dist/vendors/analytics/clearbit.js

@@ -1,28 +1,28 @@
 import { resolveManifest } from "../../resolve.js";
 import { vendorManifestContract } from "../../types.js";
 import { resolveScriptUrl, trimToUndefined } from "../_shared/script-url.js";
-function getDefaultClearbitScriptUrl(publishableKey) {
+const clearbit_getDefaultClearbitScriptUrl = function(publishableKey) {
     return `https://tag.clearbitscripts.com/v1/${encodeURIComponent(publishableKey)}/tags.js`;
-}
+};
 const clearbitManifest = {
     ...vendorManifestContract,
-    vendor: 'clearbit',
     category: 'marketing',
     install: [
         {
-            type: 'loadScript',
-            src: "{{scriptUrl}}",
             attributes: {
                 referrerpolicy: 'strict-origin-when-cross-origin'
-            }
+            },
+            src: "{{scriptUrl}}",
+            type: 'loadScript'
         }
-    ]
+    ],
+    vendor: 'clearbit'
 };
-function clearbit(options) {
+const clearbit_clearbit = function(options) {
     const publishableKey = 'string' == typeof options.publishableKey ? options.publishableKey.trim() : '';
     if (0 === publishableKey.length) throw new Error('clearbit: invalid publishableKey - must be a non-empty string');
     return resolveManifest(clearbitManifest, {
-        scriptUrl: resolveScriptUrl(trimToUndefined(options.scriptUrl), getDefaultClearbitScriptUrl(publishableKey))
+        scriptUrl: resolveScriptUrl(trimToUndefined(options.scriptUrl), clearbit_getDefaultClearbitScriptUrl(publishableKey))
     });
-}
-export { clearbit, clearbitManifest };
+};
+export { clearbitManifest, clearbit_clearbit as clearbit };