@c15t/scripts 2.2.0 → 3.0.0-alpha.0

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

@@ -4,37 +4,37 @@ import { booleanDataAttribute } from "../_shared/attributes.js";
 import { joinUrlPath } from "../_shared/script-url.js";
 const rybbitAnalyticsManifest = {
     ...vendorManifestContract,
-    vendor: 'rybbit-analytics',
     category: 'measurement',
     install: [
         {
-            type: 'loadScript',
-            src: "{{scriptUrl}}",
-            defer: true,
             attributes: {
-                'data-site-id': '{{siteId}}',
+                'data-api-key': '{{apiKey}}',
                 'data-auto-track-pageview': '{{autoTrackPageview}}',
-                'data-track-spa': '{{trackSpa}}',
-                'data-track-query': '{{trackQuery}}',
-                'data-track-outbound': '{{trackOutbound}}',
-                'data-track-errors': '{{trackErrors}}',
+                'data-debounce': '{{debounce}}',
+                'data-mask-patterns': '{{maskPatterns}}',
                 'data-session-replay': '{{sessionReplay}}',
-                'data-web-vitals': '{{webVitals}}',
+                'data-site-id': '{{siteId}}',
                 'data-skip-patterns': '{{skipPatterns}}',
-                'data-mask-patterns': '{{maskPatterns}}',
-                'data-debounce': '{{debounce}}',
-                'data-api-key': '{{apiKey}}'
-            }
+                'data-track-errors': '{{trackErrors}}',
+                'data-track-outbound': '{{trackOutbound}}',
+                'data-track-query': '{{trackQuery}}',
+                'data-track-spa': '{{trackSpa}}',
+                'data-web-vitals': '{{webVitals}}'
+            },
+            defer: true,
+            src: "{{scriptUrl}}",
+            type: 'loadScript'
         }
-    ]
+    ],
+    vendor: 'rybbit-analytics'
 };
-function getRybbitScriptUrl(options) {
+const rybbit_analytics_getRybbitScriptUrl = function(options) {
     const url = options.scriptUrl?.trim();
     if (url && url.length > 0) return url;
     if (options.analyticsHost) return joinUrlPath(options.analyticsHost, "script.js");
     return "https://app.rybbit.io/api/script.js";
-}
-function rybbitAnalytics(options) {
+};
+const rybbit_analytics_rybbitAnalytics = function(options) {
     let siteId;
     siteId = void 0 === options.siteId || null === options.siteId ? '' : String(options.siteId).trim();
     if (0 === siteId.length) throw new Error('rybbitAnalytics: missing siteId');
@@ -45,19 +45,19 @@ function rybbitAnalytics(options) {
     let maskPatterns;
     if (options.maskPatterns) maskPatterns = JSON.stringify(options.maskPatterns);
     return resolveManifest(rybbitAnalyticsManifest, {
-        scriptUrl: getRybbitScriptUrl(options),
-        siteId,
+        apiKey: options.apiKey,
         autoTrackPageview: booleanDataAttribute(options.autoTrackPageview),
-        trackSpa: booleanDataAttribute(options.trackSpa),
-        trackQuery: booleanDataAttribute(options.trackQuery),
-        trackOutbound: booleanDataAttribute(options.trackOutbound),
-        trackErrors: booleanDataAttribute(options.trackErrors),
+        debounce,
+        maskPatterns,
+        scriptUrl: rybbit_analytics_getRybbitScriptUrl(options),
         sessionReplay: booleanDataAttribute(options.sessionReplay),
-        webVitals: booleanDataAttribute(options.webVitals),
+        siteId,
         skipPatterns,
-        maskPatterns,
-        debounce,
-        apiKey: options.apiKey
+        trackErrors: booleanDataAttribute(options.trackErrors),
+        trackOutbound: booleanDataAttribute(options.trackOutbound),
+        trackQuery: booleanDataAttribute(options.trackQuery),
+        trackSpa: booleanDataAttribute(options.trackSpa),
+        webVitals: booleanDataAttribute(options.webVitals)
     });
-}
-export { rybbitAnalytics, rybbitAnalyticsManifest };
+};
+export { rybbitAnalyticsManifest, rybbit_analytics_rybbitAnalytics as rybbitAnalytics };

package/dist/vendors/analytics/segment.js

@@ -3,18 +3,14 @@ import { vendorManifestContract } from "../../types.js";
 import { resolveScriptUrl } from "../_shared/script-url.js";
 const segmentManifest = {
     ...vendorManifestContract,
-    vendor: 'segment',
-    category: 'measurement',
     bootstrap: [
         {
-            type: 'setGlobal',
+            ifUndefined: true,
             name: 'analytics',
-            value: [],
-            ifUndefined: true
+            type: 'setGlobal',
+            value: []
         },
         {
-            type: 'defineQueueMethods',
-            target: 'analytics',
             methods: [
                 'track',
                 'page',
@@ -22,23 +18,27 @@ const segmentManifest = {
                 'group',
                 'alias',
                 'reset'
-            ]
+            ],
+            target: 'analytics',
+            type: 'defineQueueMethods'
         }
     ],
+    category: 'measurement',
     install: [
         {
-            type: 'callGlobal',
             global: 'analytics',
-            method: 'page'
+            method: 'page',
+            type: 'callGlobal'
         },
         {
-            type: 'loadScript',
+            async: true,
             src: "{{scriptUrl}}",
-            async: true
+            type: 'loadScript'
         }
-    ]
+    ],
+    vendor: 'segment'
 };
-function segment({ writeKey, trackPageView = true, scriptUrl }) {
+const segment_segment = function({ writeKey, trackPageView = true, scriptUrl }) {
     let normalizedWriteKey = '';
     if ('string' == typeof writeKey) normalizedWriteKey = writeKey.trim();
     if (0 === normalizedWriteKey.length) throw new Error('segment: missing or invalid writeKey');
@@ -52,5 +52,5 @@ function segment({ writeKey, trackPageView = true, scriptUrl }) {
     return resolveManifest(manifest, {
         scriptUrl: resolveScriptUrl(scriptUrl, defaultScriptUrl)
     });
-}
-export { segment, segmentManifest };
+};
+export { segmentManifest, segment_segment as segment };

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

@@ -4,36 +4,36 @@ import { booleanDataAttribute, listDataAttribute } from "../_shared/attributes.j
 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-before-send': '{{beforeSend}}',
                 'data-domains': '{{domains}}',
+                'data-host-url': '{{hostUrl}}',
                 'data-tag': '{{tag}}',
-                'data-before-send': '{{beforeSend}}'
-            }
+                'data-website-id': '{{websiteId}}'
+            },
+            defer: true,
+            src: "{{scriptUrl}}",
+            type: 'loadScript'
         }
-    ]
+    ],
+    vendor: 'umami-analytics'
 };
-function umamiAnalytics(options) {
+const umami_analytics_umamiAnalytics = function(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),
+        beforeSend: options.beforeSend,
         domains: listDataAttribute(options.domains),
+        hostUrl: options.hostUrl,
+        scriptUrl: resolveScriptUrl(options.scriptUrl, "https://cloud.umami.is/script.js"),
         tag: options.tag,
-        beforeSend: options.beforeSend,
-        scriptUrl: resolveScriptUrl(options.scriptUrl, "https://cloud.umami.is/script.js")
+        websiteId
     });
     return resolved;
-}
-export { umamiAnalytics, umamiAnalyticsManifest };
+};
+export { umamiAnalyticsManifest, umami_analytics_umamiAnalytics as umamiAnalytics };

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

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

package/dist/vendors/functional/crisp.js

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

package/dist/vendors/functional/intercom.js

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

package/dist/vendors/tag-managers/google-tag-manager.js

@@ -3,57 +3,57 @@ 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',
-    category: 'necessary',
     alwaysLoad: 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: 'necessary',
+    consentMapping: GOOGLE_CONSENT_MODE_V2_DEFAULT_MAPPING,
+    consentSignal: 'gtag',
     install: [
         {
-            type: 'pushToQueue',
             queue: 'dataLayer',
+            type: 'pushToQueue',
             value: {
-                'gtm.start': runtimeTimestampValue,
-                event: 'gtm.js'
+                event: 'gtm.js',
+                'gtm.start': runtimeTimestampValue
             }
         },
         {
-            type: 'loadScript',
+            async: true,
             src: 'https://www.googletagmanager.com/gtm.js?id={{id}}',
-            async: true
+            type: 'loadScript'
         }
     ],
     onConsentChange: [
         {
-            type: 'callGlobal',
-            global: 'gtag',
             args: [
                 'event',
                 '{{updateEventName}}'
-            ]
+            ],
+            global: 'gtag',
+            type: 'callGlobal'
         }
     ],
-    consentMapping: GOOGLE_CONSENT_MODE_V2_DEFAULT_MAPPING,
-    consentSignal: 'gtag'
+    vendor: 'google-tag-manager'
 };
-function googleTagManager({ id, updateEventName, consentMapping }) {
+const google_tag_manager_googleTagManager = function({ id, updateEventName, consentMapping }) {
     const manifest = withOptionalConsentMapping(googleTagManagerManifest, consentMapping);
     const resolved = resolveManifest(manifest, {
         id,
         updateEventName: updateEventName ?? 'consent-update'
     });
     return resolved;
-}
-export { googleTagManager, googleTagManagerManifest };
+};
+export { googleTagManagerManifest, google_tag_manager_googleTagManager as googleTagManager };

package/dist-types/__tests__/helpers.d.ts

@@ -1,5 +1,5 @@
-import type { ConsentState, Script, ScriptCallbackInfo } from 'c15t';
-import { type BuiltInScriptIntegrationKey } from '../registry';
+import type { ConsentState, Script, ScriptCallbackInfo } from '@c15t/core';
+import type { BuiltInScriptIntegrationKey } from '../registry';
 /**
  * Typed view of `globalThis` used by script helper tests.
  *
@@ -59,9 +59,9 @@ export type CallbackInfoOverrides = Partial<ScriptCallbackInfo> & Pick<ScriptCal
  * Defaults model a denied-consent callback for the same DOM element ID as the
  * script ID, while allowing individual tests to override the relevant fields.
  */
-export declare function createCallbackInfo(overrides: CallbackInfoOverrides): ScriptCallbackInfo;
+export declare const createCallbackInfo: (overrides: CallbackInfoOverrides) => ScriptCallbackInfo;
 export type LifecycleCallbackOverrides = Partial<Omit<ScriptCallbackInfo, 'id'>>;
-export declare function runOnBeforeLoad(script: Pick<Script, 'id' | 'onBeforeLoad'>, overrides?: LifecycleCallbackOverrides): void;
+export declare const runOnBeforeLoad: (script: Pick<Script, 'id' | 'onBeforeLoad'>, overrides?: LifecycleCallbackOverrides) => void;
 /**
  * Returns a mutable test-friendly reference to the global object.
  *
@@ -73,7 +73,7 @@ export declare function runOnBeforeLoad(script: Pick<Script, 'id' | 'onBeforeLoa
  * globalRef.dataLayer = [];
  * ```
  */
-export declare function getTestGlobal(): TestGlobal;
+export declare const getTestGlobal: () => TestGlobal;
 /**
  * Registers browser-like setup and teardown hooks for script helper tests.
  *
@@ -90,7 +90,7 @@ export declare function getTestGlobal(): TestGlobal;
  * });
  * ```
  */
-export declare function setupScriptHelperTest(): void;
+export declare const setupScriptHelperTest: () => void;
 /**
  * Asserts that a helper-generated script matches registry metadata and
  * expected script fields.
@@ -117,7 +117,7 @@ export declare function setupScriptHelperTest(): void;
  * );
  * ```
  */
-export declare function expectScriptMatchesIntegration(key: BuiltInScriptIntegrationKey, script: HelperScriptSnapshot, expected: ExpectedScriptSnapshot): void;
+export declare const expectScriptMatchesIntegration: (key: BuiltInScriptIntegrationKey, script: HelperScriptSnapshot, expected: ExpectedScriptSnapshot) => void;
 /**
  * Converts an array-like value into a plain array.
  *
@@ -136,6 +136,6 @@ export declare function expectScriptMatchesIntegration(key: BuiltInScriptIntegra
  * }
  * ```
  */
-export declare function toArgumentsArray(value: unknown): unknown[];
-export declare function expectGoogleConsentDefault(entry: unknown): void;
-export declare function expectStubCommandQueue(stub: unknown, queueKey: string, commands: unknown[][]): void;
+export declare const toArgumentsArray: (value: unknown) => unknown[];
+export declare const expectGoogleConsentDefault: (entry: unknown) => void;
+export declare const expectStubCommandQueue: (stub: unknown, queueKey: string, commands: unknown[][]) => void;

package/dist-types/engine/compile.d.ts

@@ -1,3 +1,3 @@
 import type { ResolvedManifest, VendorManifest } from '../types';
-export declare function interpolateValue(value: unknown, config: Record<string, unknown>): unknown;
-export declare function compileManifest(manifest: VendorManifest, config?: Record<string, unknown>): ResolvedManifest;
+export declare const interpolateValue: (value: unknown, config: Record<string, unknown>) => unknown;
+export declare const compileManifest: (manifest: VendorManifest, config?: Record<string, unknown>) => ResolvedManifest;

package/dist-types/engine/runtime.d.ts

@@ -1,3 +1,3 @@
-import { type Script } from 'c15t';
-import { type ResolvedManifest } from '../types';
-export declare function resolvedManifestToScript(resolvedManifest: ResolvedManifest): Script;
+import type { Script } from '@c15t/core';
+import type { ResolvedManifest } from '../types';
+export declare const resolvedManifestToScript: (resolvedManifest: ResolvedManifest) => Script;