@c15t/scripts 2.2.0 → 3.0.0-alpha.1

package/dist/vendors/_shared/install-builders.js

@@ -1,21 +1,21 @@
-function buildQueuePixelInstall({ global, initArgs, trackStep, scriptPlaceholder = "{{scriptUrl}}" }) {
+const install_builders_buildQueuePixelInstall = function({ global, initArgs, trackStep, scriptPlaceholder = "{{scriptUrl}}" }) {
     const install = [
         {
-            type: 'callGlobal',
+            args: initArgs,
             global,
-            args: initArgs
+            type: 'callGlobal'
         }
     ];
     if (void 0 !== trackStep) install.push({
-        type: 'callGlobal',
+        args: trackStep.args,
         global,
-        args: trackStep.args
+        type: 'callGlobal'
     });
     install.push({
-        type: 'loadScript',
+        async: true,
         src: scriptPlaceholder,
-        async: true
+        type: 'loadScript'
     });
     return install;
-}
-export { buildQueuePixelInstall };
+};
+export { install_builders_buildQueuePixelInstall as buildQueuePixelInstall };

package/dist/vendors/_shared/script-url.js

@@ -1,28 +1,28 @@
-function trimToUndefined(value) {
+const script_url_trimToUndefined = function(value) {
     if (void 0 === value) return;
     const trimmed = value.trim();
     if (0 === trimmed.length) return;
     return trimmed;
-}
-function resolveScriptUrl(override, fallback) {
+};
+const script_url_resolveScriptUrl = function(override, fallback) {
     if (void 0 !== override) return override;
     return fallback;
-}
-function stripLeadingSlashes(value) {
+};
+const script_url_stripLeadingSlashes = function(value) {
     let index = 0;
     while(index < value.length && 47 === value.charCodeAt(index))index += 1;
     return 0 === index ? value : value.slice(index);
-}
-function stripTrailingSlashes(value) {
+};
+const script_url_stripTrailingSlashes = function(value) {
     let end = value.length;
     while(end > 0 && 47 === value.charCodeAt(end - 1))end -= 1;
     return end === value.length ? value : value.slice(0, end);
-}
-function joinUrlPath(base, path) {
+};
+const script_url_joinUrlPath = function(base, path) {
     const trimmedBase = base.trim();
     const trimmedPath = path.trim();
     if (0 === trimmedBase.length) throw new TypeError(`joinUrlPath requires a non-empty base URL. Received base=${JSON.stringify(base)}, path=${JSON.stringify(path)}.`);
     if (0 === trimmedPath.length) throw new TypeError(`joinUrlPath requires a non-empty path. Received base=${JSON.stringify(base)}, path=${JSON.stringify(path)}.`);
-    return `${stripTrailingSlashes(trimmedBase)}/${stripLeadingSlashes(trimmedPath)}`;
-}
-export { joinUrlPath, resolveScriptUrl, stripLeadingSlashes, stripTrailingSlashes, trimToUndefined };
+    return `${script_url_stripTrailingSlashes(trimmedBase)}/${script_url_stripLeadingSlashes(trimmedPath)}`;
+};
+export { script_url_joinUrlPath as joinUrlPath, script_url_resolveScriptUrl as resolveScriptUrl, script_url_stripLeadingSlashes as stripLeadingSlashes, script_url_stripTrailingSlashes as stripTrailingSlashes, script_url_trimToUndefined as trimToUndefined };

package/dist/vendors/ads-and-pixels/linkedin-insights.js

@@ -2,47 +2,47 @@ import { resolveManifest } from "../../resolve.js";
 import { vendorManifestContract } from "../../types.js";
 const linkedinInsightsManifest = {
     ...vendorManifestContract,
-    vendor: 'linkedin-insights',
     category: 'marketing',
     install: [
         {
-            type: 'setGlobal',
+            ifUndefined: false,
             name: '_linkedin_partner_id',
-            value: '{{id}}',
-            ifUndefined: false
+            type: 'setGlobal',
+            value: '{{id}}'
         },
         {
-            type: 'setGlobal',
+            ifUndefined: true,
             name: '_linkedin_data_partner_ids',
-            value: [],
-            ifUndefined: true
+            type: 'setGlobal',
+            value: []
         },
         {
-            type: 'pushToQueue',
             queue: '_linkedin_data_partner_ids',
+            type: 'pushToQueue',
             value: '{{id}}'
         },
         {
-            type: 'defineStubFunction',
+            ifUndefined: true,
             name: 'lintrk',
             queue: {
                 property: 'q'
             },
             queueFormat: 'array',
-            ifUndefined: true
+            type: 'defineStubFunction'
         },
         {
-            type: 'loadScript',
+            async: true,
             src: "{{scriptSrc}}",
-            async: true
+            type: 'loadScript'
         }
-    ]
+    ],
+    vendor: 'linkedin-insights'
 };
-function linkedinInsights({ id, scriptSrc }) {
+const linkedin_insights_linkedinInsights = function({ id, scriptSrc }) {
     const resolved = resolveManifest(linkedinInsightsManifest, {
         id,
         scriptSrc: scriptSrc ?? 'https://snap.licdn.com/li.lms-analytics/insight.min.js'
     });
     return resolved;
-}
-export { linkedinInsights, linkedinInsightsManifest };
+};
+export { linkedinInsightsManifest, linkedin_insights_linkedinInsights as linkedinInsights };

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

@@ -4,100 +4,99 @@ import { buildQueuePixelInstall } from "../_shared/install-builders.js";
 import { resolveScriptUrl } from "../_shared/script-url.js";
 const metaPixelManifest = {
     ...vendorManifestContract,
-    vendor: 'meta-pixel',
-    category: 'marketing',
-    persistAfterConsentRevoked: true,
     bootstrap: [
         {
-            type: 'defineStubFunction',
-            name: 'fbq',
-            queue: {
-                property: 'queue'
-            },
-            dispatchProperty: 'callMethod',
-            selfReferences: [
-                'push'
-            ],
             aliases: [
                 '_fbq'
             ],
+            dispatchProperty: 'callMethod',
+            ifUndefined: true,
+            name: 'fbq',
             properties: {
                 loaded: true,
                 version: '2.0'
             },
-            ifUndefined: true
+            queue: {
+                property: 'queue'
+            },
+            selfReferences: [
+                'push'
+            ],
+            type: 'defineStubFunction'
         }
     ],
+    category: 'marketing',
     install: [
         {
-            type: 'callGlobal',
-            global: 'fbq',
             args: [
                 'consent',
                 'grant'
-            ]
+            ],
+            global: 'fbq',
+            type: 'callGlobal'
         },
         {
-            type: 'callGlobal',
-            global: 'fbq',
             args: [
                 'init',
                 '{{pixelId}}'
-            ]
+            ],
+            global: 'fbq',
+            type: 'callGlobal'
         },
         {
-            type: 'callGlobal',
-            global: 'fbq',
             args: [
                 'track',
                 'PageView'
-            ]
+            ],
+            global: 'fbq',
+            type: 'callGlobal'
         },
         {
-            type: 'loadScript',
+            async: true,
             src: "{{scriptSrc}}",
-            async: true
+            type: 'loadScript'
         }
     ],
-    onConsentGranted: [
+    onConsentDenied: [
         {
-            type: 'callGlobal',
-            global: 'fbq',
             args: [
                 'consent',
-                'grant'
-            ]
+                'revoke'
+            ],
+            global: 'fbq',
+            type: 'callGlobal'
         }
     ],
-    onConsentDenied: [
+    onConsentGranted: [
         {
-            type: 'callGlobal',
-            global: 'fbq',
             args: [
                 'consent',
-                'revoke'
-            ]
+                'grant'
+            ],
+            global: 'fbq',
+            type: 'callGlobal'
         }
-    ]
+    ],
+    persistAfterConsentRevoked: true,
+    vendor: 'meta-pixel'
 };
-function metaPixel({ pixelId, initOptions, trackPageView = true, dataProcessingOptions, scriptSrc }) {
-    const install = buildMetaPixelInstall({
-        hasInitOptions: void 0 !== initOptions,
-        trackPageView,
-        dataProcessingOptions
-    });
-    const manifest = {
-        ...metaPixelManifest,
-        install
+const meta_pixel_getMetaPixelDataProcessingArgs = function({ options, country, state }) {
+    const args = [
+        'dataProcessingOptions',
+        options
+    ];
+    if (void 0 !== country || void 0 !== state) args.push(country ?? 0, state ?? 0);
+    return args;
+};
+const meta_pixel_getMetaPixelPageViewStep = function(trackPageView) {
+    if (trackPageView) return {
+        args: [
+            'track',
+            'PageView'
+        ]
     };
-    const resolved = resolveManifest(manifest, {
-        pixelId,
-        initOptions,
-        scriptSrc: resolveScriptUrl(scriptSrc, 'https://connect.facebook.net/en_US/fbevents.js')
-    });
-    return resolved;
-}
-function buildMetaPixelInstall({ hasInitOptions, trackPageView, dataProcessingOptions }) {
+};
+const meta_pixel_buildMetaPixelInstall = function({ hasInitOptions, trackPageView, dataProcessingOptions }) {
     const initArgs = [
         'init',
         '{{pixelId}}'
@@ -106,48 +105,49 @@ function buildMetaPixelInstall({ hasInitOptions, trackPageView, dataProcessingOp
     const install = buildQueuePixelInstall({
         global: 'fbq',
         initArgs,
-        trackStep: getMetaPixelPageViewStep(trackPageView),
-        scriptPlaceholder: "{{scriptSrc}}"
+        scriptPlaceholder: "{{scriptSrc}}",
+        trackStep: meta_pixel_getMetaPixelPageViewStep(trackPageView)
     });
     if (void 0 !== dataProcessingOptions) install.unshift({
-        type: 'callGlobal',
+        args: meta_pixel_getMetaPixelDataProcessingArgs(dataProcessingOptions),
         global: 'fbq',
-        args: getMetaPixelDataProcessingArgs(dataProcessingOptions)
+        type: 'callGlobal'
     });
     install.unshift({
-        type: 'callGlobal',
-        global: 'fbq',
         args: [
             'consent',
             'grant'
-        ]
+        ],
+        global: 'fbq',
+        type: 'callGlobal'
     });
     return install;
-}
-function getMetaPixelDataProcessingArgs({ options, country, state }) {
-    const args = [
-        'dataProcessingOptions',
-        options
-    ];
-    if (void 0 !== country || void 0 !== state) args.push(country ?? 0, state ?? 0);
-    return args;
-}
-function getMetaPixelPageViewStep(trackPageView) {
-    if (trackPageView) return {
-        args: [
-            'track',
-            'PageView'
-        ]
+};
+const meta_pixel_metaPixel = function({ pixelId, initOptions, trackPageView = true, dataProcessingOptions, scriptSrc }) {
+    const install = meta_pixel_buildMetaPixelInstall({
+        dataProcessingOptions,
+        hasInitOptions: void 0 !== initOptions,
+        trackPageView
+    });
+    const manifest = {
+        ...metaPixelManifest,
+        install
     };
-}
-function resolveMetaPixelEventOptions(eventOptions) {
+    const resolved = resolveManifest(manifest, {
+        initOptions,
+        pixelId,
+        scriptSrc: resolveScriptUrl(scriptSrc, 'https://connect.facebook.net/en_US/fbevents.js')
+    });
+    return resolved;
+};
+const meta_pixel_resolveMetaPixelEventOptions = function(eventOptions) {
     if ('string' == typeof eventOptions) return {
         eventID: eventOptions
     };
     return eventOptions;
-}
-const metaPixelEvent = (eventName, params, eventOptions)=>window.fbq('track', eventName, params, resolveMetaPixelEventOptions(eventOptions));
-const metaPixelCustomEvent = (eventName, params, eventOptions)=>window.fbq('trackCustom', eventName, params, resolveMetaPixelEventOptions(eventOptions));
-const metaPixelSingleEvent = (pixelId, eventName, params, eventOptions)=>window.fbq('trackSingle', pixelId, eventName, params, resolveMetaPixelEventOptions(eventOptions));
-const metaPixelSingleCustomEvent = (pixelId, eventName, params, eventOptions)=>window.fbq('trackSingleCustom', pixelId, eventName, params, resolveMetaPixelEventOptions(eventOptions));
-export { metaPixel, metaPixelCustomEvent, metaPixelEvent, metaPixelManifest, metaPixelSingleCustomEvent, metaPixelSingleEvent };
+};
+const metaPixelEvent = (eventName, params, eventOptions)=>window.fbq('track', eventName, params, meta_pixel_resolveMetaPixelEventOptions(eventOptions));
+const metaPixelCustomEvent = (eventName, params, eventOptions)=>window.fbq('trackCustom', eventName, params, meta_pixel_resolveMetaPixelEventOptions(eventOptions));
+const metaPixelSingleEvent = (pixelId, eventName, params, eventOptions)=>window.fbq('trackSingle', pixelId, eventName, params, meta_pixel_resolveMetaPixelEventOptions(eventOptions));
+const metaPixelSingleCustomEvent = (pixelId, eventName, params, eventOptions)=>window.fbq('trackSingleCustom', pixelId, eventName, params, meta_pixel_resolveMetaPixelEventOptions(eventOptions));
+export { metaPixelCustomEvent, metaPixelEvent, metaPixelManifest, metaPixelSingleCustomEvent, metaPixelSingleEvent, meta_pixel_metaPixel as metaPixel };

package/dist/vendors/ads-and-pixels/microsoft-uet.js

@@ -2,109 +2,109 @@ import { resolveManifest } from "../../resolve.js";
 import { vendorManifestContract } from "../../types.js";
 const microsoftUetManifest = {
     ...vendorManifestContract,
-    vendor: 'microsoft-uet',
-    category: 'marketing',
+    afterLoad: [
+        {
+            args: [
+                {
+                    enableAutoSpaTracking: true,
+                    ti: '{{id}}'
+                }
+            ],
+            assignTo: 'uetq',
+            constructor: 'UET',
+            copyAssignedValueToArgProperty: 'q',
+            type: 'constructGlobal'
+        },
+        {
+            args: [
+                'pageLoad'
+            ],
+            global: 'uetq',
+            method: 'push',
+            type: 'callGlobal'
+        }
+    ],
     alwaysLoad: true,
-    persistAfterConsentRevoked: true,
     bootstrap: [
         {
-            type: 'setGlobal',
+            ifUndefined: true,
             name: 'uetq',
-            value: [],
-            ifUndefined: true
+            type: 'setGlobal',
+            value: []
         }
     ],
-    onBeforeLoadGranted: [
+    category: 'marketing',
+    install: [
         {
-            type: 'callGlobal',
-            global: 'uetq',
-            method: 'push',
-            args: [
-                'consent',
-                'default',
-                {
-                    ad_storage: 'granted'
-                }
-            ]
+            async: true,
+            src: "{{scriptSrc}}",
+            type: 'loadScript'
         }
     ],
     onBeforeLoadDenied: [
         {
-            type: 'callGlobal',
-            global: 'uetq',
-            method: 'push',
             args: [
                 'consent',
                 'default',
                 {
                     ad_storage: 'denied'
                 }
-            ]
-        }
-    ],
-    install: [
-        {
-            type: 'loadScript',
-            src: "{{scriptSrc}}",
-            async: true
+            ],
+            global: 'uetq',
+            method: 'push',
+            type: 'callGlobal'
         }
     ],
-    afterLoad: [
+    onBeforeLoadGranted: [
         {
-            type: 'constructGlobal',
-            constructor: 'UET',
-            assignTo: 'uetq',
             args: [
+                'consent',
+                'default',
                 {
-                    ti: '{{id}}',
-                    enableAutoSpaTracking: true
+                    ad_storage: 'granted'
                 }
             ],
-            copyAssignedValueToArgProperty: 'q'
-        },
-        {
-            type: 'callGlobal',
             global: 'uetq',
             method: 'push',
-            args: [
-                'pageLoad'
-            ]
+            type: 'callGlobal'
         }
     ],
-    onConsentGranted: [
+    onConsentDenied: [
         {
-            type: 'callGlobal',
-            global: 'uetq',
-            method: 'push',
             args: [
                 'consent',
                 'update',
                 {
-                    ad_storage: 'granted'
+                    ad_storage: 'denied'
                 }
-            ]
+            ],
+            global: 'uetq',
+            method: 'push',
+            type: 'callGlobal'
         }
     ],
-    onConsentDenied: [
+    onConsentGranted: [
         {
-            type: 'callGlobal',
-            global: 'uetq',
-            method: 'push',
             args: [
                 'consent',
                 'update',
                 {
-                    ad_storage: 'denied'
+                    ad_storage: 'granted'
                 }
-            ]
+            ],
+            global: 'uetq',
+            method: 'push',
+            type: 'callGlobal'
         }
-    ]
+    ],
+    persistAfterConsentRevoked: true,
+    vendor: 'microsoft-uet'
 };
-function microsoftUet({ id, scriptSrc }) {
+const microsoft_uet_microsoftUet = function({ id, scriptSrc }) {
     const resolved = resolveManifest(microsoftUetManifest, {
         id,
         scriptSrc: scriptSrc ?? '//bat.bing.com/bat.js'
     });
     return resolved;
-}
-export { microsoftUet, microsoftUetManifest };
+};
+export { microsoftUetManifest, microsoft_uet_microsoftUet as microsoftUet };

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

@@ -0,0 +1,88 @@
+import { resolveManifest } from "../../resolve.js";
+import { vendorManifestContract } from "../../types.js";
+import { resolveScriptUrl } from "../_shared/script-url.js";
+const openaiPixelManifest = {
+    ...vendorManifestContract,
+    bootstrap: [
+        {
+            ifUndefined: true,
+            name: 'oaiq',
+            queue: {
+                property: 'q'
+            },
+            type: 'defineStubFunction'
+        },
+        {
+            args: [
+                'consent',
+                false
+            ],
+            global: 'oaiq',
+            type: 'callGlobal'
+        }
+    ],
+    category: 'marketing',
+    install: [
+        {
+            args: [
+                'init',
+                '{{initOptions}}'
+            ],
+            global: 'oaiq',
+            type: 'callGlobal'
+        },
+        {
+            async: true,
+            src: "{{scriptSrc}}",
+            type: 'loadScript'
+        }
+    ],
+    onBeforeLoadGranted: [
+        {
+            args: [
+                'consent',
+                true
+            ],
+            global: 'oaiq',
+            type: 'callGlobal'
+        }
+    ],
+    onConsentDenied: [
+        {
+            args: [
+                'consent',
+                false
+            ],
+            global: 'oaiq',
+            type: 'callGlobal'
+        }
+    ],
+    onConsentGranted: [
+        {
+            args: [
+                'consent',
+                true
+            ],
+            global: 'oaiq',
+            type: 'callGlobal'
+        }
+    ],
+    persistAfterConsentRevoked: true,
+    vendor: 'openai-pixel'
+};
+const openai_pixel_openaiPixel = function({ pixelId, debug = false, user, scriptSrc }) {
+    const initOptions = {
+        debug,
+        pixelId
+    };
+    if (void 0 !== user) initOptions.user = user;
+    return resolveManifest(openaiPixelManifest, {
+        initOptions,
+        scriptSrc: resolveScriptUrl(scriptSrc, 'https://bzrcdn.openai.com/sdk/oaiq.min.js')
+    });
+};
+const openai_pixel_openaiPixelEvent = function(...args) {
+    if ("u" < typeof window || 'function' != typeof window.oaiq) return;
+    window.oaiq('measure', ...args);
+};
+export { openaiPixelManifest, openai_pixel_openaiPixel as openaiPixel, openai_pixel_openaiPixelEvent as openaiPixelEvent };