@c15t/scripts 2.0.0-rc.1 → 2.0.0

package/dist/engine/runtime.js

@@ -0,0 +1,345 @@
+import { emitScriptDebugEvent } from "c15t";
+function cloneStepValue(value) {
+    if (value instanceof Date) return new Date(value);
+    if (Array.isArray(value)) return value.map((item)=>cloneStepValue(item));
+    if (null !== value && 'object' == typeof value) return Object.fromEntries(Object.entries(value).map(([key, nestedValue])=>[
+            key,
+            cloneStepValue(nestedValue)
+        ]));
+    return value;
+}
+function isRecord(value) {
+    return null !== value && 'object' == typeof value && !Array.isArray(value);
+}
+function getPathTarget(root, path) {
+    if (0 === path.length) return;
+    let target = root;
+    for (const segment of path.slice(0, -1)){
+        const next = target[segment];
+        if (null === next || 'object' != typeof next) return;
+        target = next;
+    }
+    return {
+        target,
+        key: path[path.length - 1]
+    };
+}
+function resolveQueueTarget(root, queue, owner) {
+    if ('global' in queue && 'string' == typeof queue.global) {
+        const queueTarget = root[queue.global];
+        return Array.isArray(queueTarget) ? queueTarget : void 0;
+    }
+    if (!owner) return;
+    const queueProperty = queue.property;
+    const queueTarget = owner[queueProperty];
+    return Array.isArray(queueTarget) ? queueTarget : void 0;
+}
+function executeStep(step) {
+    const win = window;
+    switch(step.type){
+        case 'setGlobal':
+            {
+                const shouldSet = false !== step.ifUndefined;
+                if (shouldSet && void 0 !== win[step.name]) break;
+                win[step.name] = cloneStepValue(step.value);
+                break;
+            }
+        case 'defineQueueFunction':
+            {
+                const shouldSet = false !== step.ifUndefined;
+                if (shouldSet && void 0 !== win[step.name]) break;
+                win[step.name] = function(...args) {
+                    const queueTarget = win[step.queue];
+                    if (!Array.isArray(queueTarget)) return;
+                    queueTarget.push('array' === step.pushStyle ? [
+                        ...args
+                    ] : args);
+                };
+                break;
+            }
+        case 'defineStubFunction':
+            {
+                const shouldSet = false !== step.ifUndefined;
+                if (shouldSet && void 0 !== win[step.name]) break;
+                const stub = function(...args) {
+                    const self = win[step.name];
+                    const dispatcher = self && step.dispatchProperty ? self[step.dispatchProperty] : void 0;
+                    if ('function' == typeof dispatcher) return void dispatcher.apply(self, args);
+                    const queueTarget = resolveQueueTarget(win, step.queue, self);
+                    if (!queueTarget) return;
+                    queueTarget.push('array' === step.queueFormat ? [
+                        ...args
+                    ] : args);
+                };
+                win[step.name] = stub;
+                const stubRecord = stub;
+                if ('property' in step.queue && 'string' == typeof step.queue.property) {
+                    const queueProperty = step.queue.property;
+                    if (void 0 === stubRecord[queueProperty]) stubRecord[queueProperty] = [];
+                }
+                for (const alias of step.aliases ?? [])win[alias] = stub;
+                for (const selfReference of step.selfReferences ?? [])stubRecord[selfReference] = stub;
+                for (const [key, value] of Object.entries(step.properties ?? {}))stubRecord[key] = cloneStepValue(value);
+                break;
+            }
+        case 'callGlobal':
+            {
+                const target = win[step.global];
+                if (!target) break;
+                const args = (step.args ?? []).map((arg)=>cloneStepValue(arg));
+                if (step.method) {
+                    const objectTarget = target;
+                    const method = objectTarget[step.method];
+                    if ('function' == typeof method) method.apply(objectTarget, args);
+                } else if ('function' == typeof target) target(...args);
+                break;
+            }
+        case 'pushToQueue':
+            {
+                const queueTarget = win[step.queue];
+                if (Array.isArray(queueTarget)) queueTarget.push(cloneStepValue(step.value));
+                break;
+            }
+        case 'setGlobalPath':
+            {
+                const pathTarget = getPathTarget(win, step.path);
+                if (!pathTarget) break;
+                pathTarget.target[pathTarget.key] = cloneStepValue(step.value);
+                break;
+            }
+        case 'defineQueueMethods':
+            {
+                const target = win[step.target];
+                if (null === target || 'object' != typeof target && 'function' != typeof target) break;
+                const targetRecord = target;
+                for (const methodName of step.methods)targetRecord[methodName] = (...args)=>{
+                    const queueTarget = resolveQueueTarget(win, step.queue ?? {
+                        global: step.target
+                    }, targetRecord);
+                    if (!queueTarget) return;
+                    queueTarget.push([
+                        methodName,
+                        ...args
+                    ]);
+                };
+                break;
+            }
+        case 'defineGlobalMethods':
+            {
+                const target = win[step.target];
+                if (null === target || 'object' != typeof target && 'function' != typeof target) break;
+                const targetRecord = target;
+                for (const method of step.methods)targetRecord[method.name] = 'return' === method.behavior ? ()=>cloneStepValue(method.value) : ()=>{};
+                break;
+            }
+        case 'constructGlobal':
+            {
+                const Constructor = win[step.constructor];
+                if ('function' != typeof Constructor) break;
+                const args = (step.args ?? []).map((arg)=>cloneStepValue(arg));
+                if (step.copyAssignedValueToArgProperty) {
+                    const firstArg = args[0];
+                    const targetOptions = isRecord(firstArg) ? firstArg : {};
+                    targetOptions[step.copyAssignedValueToArgProperty] = win[step.assignTo];
+                    if (!isRecord(firstArg)) args.unshift(targetOptions);
+                }
+                win[step.assignTo] = new Constructor(...args);
+                break;
+            }
+        case 'loadScript':
+            break;
+    }
+}
+function executePhaseSteps(steps, context) {
+    if (0 === steps.length) return;
+    emitScriptDebugEvent({
+        source: 'manifest-runtime',
+        scope: 'phase',
+        action: 'phase_start',
+        message: `Manifest phase ${context.phase} started`,
+        scriptId: context.scriptId,
+        elementId: context.elementId,
+        hasConsent: context.hasConsent,
+        callback: context.callback,
+        phase: context.phase,
+        data: {
+            stepCount: steps.length
+        }
+    });
+    for (const [stepIndex, step] of steps.entries())try {
+        executeStep(step);
+        emitScriptDebugEvent({
+            source: 'manifest-runtime',
+            scope: 'step',
+            action: 'step_executed',
+            message: `Executed ${step.type}`,
+            scriptId: context.scriptId,
+            elementId: context.elementId,
+            hasConsent: context.hasConsent,
+            callback: context.callback,
+            phase: context.phase,
+            stepType: step.type,
+            stepIndex
+        });
+    } catch (error) {
+        emitScriptDebugEvent({
+            source: 'manifest-runtime',
+            scope: 'step',
+            action: 'step_error',
+            message: `Failed to execute ${step.type}`,
+            scriptId: context.scriptId,
+            elementId: context.elementId,
+            hasConsent: context.hasConsent,
+            callback: context.callback,
+            phase: context.phase,
+            stepType: step.type,
+            stepIndex,
+            data: {
+                error: error instanceof Error ? error.message : 'string' == typeof error ? error : 'Unknown error'
+            }
+        });
+        throw error;
+    }
+    emitScriptDebugEvent({
+        source: 'manifest-runtime',
+        scope: 'phase',
+        action: 'phase_complete',
+        message: `Manifest phase ${context.phase} completed`,
+        scriptId: context.scriptId,
+        elementId: context.elementId,
+        hasConsent: context.hasConsent,
+        callback: context.callback,
+        phase: context.phase,
+        data: {
+            stepCount: steps.length
+        }
+    });
+}
+function mapConsentState(mapping, consents) {
+    const result = {};
+    for (const [c15tCategory, vendorTypes] of Object.entries(mapping)){
+        const isGranted = consents[c15tCategory];
+        for (const vendorType of vendorTypes)result[vendorType] = isGranted ? 'granted' : 'denied';
+    }
+    return result;
+}
+function getConsentSignalSteps(resolvedManifest, mode, consents) {
+    if (!resolvedManifest.consentMapping || !resolvedManifest.consentSignal) return [];
+    const mapped = mapConsentState(resolvedManifest.consentMapping, consents);
+    switch(resolvedManifest.consentSignal){
+        case 'gtag':
+            return [
+                {
+                    type: 'callGlobal',
+                    global: resolvedManifest.consentSignalTarget ?? 'gtag',
+                    args: [
+                        'consent',
+                        mode,
+                        mapped
+                    ]
+                }
+            ];
+    }
+}
+function resolvedManifestToScript(resolvedManifest) {
+    const hasConsentMapping = !!(resolvedManifest.consentMapping && resolvedManifest.consentSignal);
+    const hasLoadConsentBranches = !!(resolvedManifest.onLoadGrantedSteps.length > 0 || resolvedManifest.onLoadDeniedSteps.length > 0);
+    const hasConsentLifecycle = !!(resolvedManifest.onConsentChangeSteps.length > 0 || resolvedManifest.onConsentGrantedSteps.length > 0 || resolvedManifest.onConsentDeniedSteps.length > 0 || hasConsentMapping);
+    const script = {
+        id: resolvedManifest.vendor,
+        category: resolvedManifest.category,
+        alwaysLoad: resolvedManifest.alwaysLoad,
+        persistAfterConsentRevoked: resolvedManifest.persistAfterConsentRevoked,
+        callbackOnly: resolvedManifest.loadScript ? void 0 : true,
+        src: resolvedManifest.loadScript?.src,
+        async: resolvedManifest.loadScript?.async,
+        defer: resolvedManifest.loadScript?.defer,
+        attributes: resolvedManifest.loadScript?.attributes
+    };
+    if (resolvedManifest.bootstrapSteps.length > 0 || resolvedManifest.setupSteps.length > 0 || resolvedManifest.onBeforeLoadGrantedSteps.length > 0 || resolvedManifest.onBeforeLoadDeniedSteps.length > 0 || hasConsentMapping) script.onBeforeLoad = (info)=>{
+        const baseContext = {
+            scriptId: resolvedManifest.vendor,
+            elementId: info.elementId,
+            hasConsent: info.hasConsent,
+            callback: 'onBeforeLoad'
+        };
+        executePhaseSteps(resolvedManifest.bootstrapSteps, {
+            ...baseContext,
+            phase: 'bootstrap'
+        });
+        executePhaseSteps(getConsentSignalSteps(resolvedManifest, 'default', info.consents), {
+            ...baseContext,
+            phase: 'consent-default'
+        });
+        executePhaseSteps(resolvedManifest.setupSteps, {
+            ...baseContext,
+            phase: 'setup'
+        });
+        executePhaseSteps(info.hasConsent ? resolvedManifest.onBeforeLoadGrantedSteps : resolvedManifest.onBeforeLoadDeniedSteps, {
+            ...baseContext,
+            phase: info.hasConsent ? 'onBeforeLoadGranted' : 'onBeforeLoadDenied'
+        });
+    };
+    if (resolvedManifest.afterLoadSteps.length > 0) script.onLoad = (info)=>{
+        const baseContext = {
+            scriptId: resolvedManifest.vendor,
+            elementId: info.elementId,
+            hasConsent: info.hasConsent,
+            callback: 'onLoad'
+        };
+        executePhaseSteps(resolvedManifest.afterLoadSteps, {
+            ...baseContext,
+            phase: 'afterLoad'
+        });
+        if (info.hasConsent && resolvedManifest.onLoadGrantedSteps.length > 0) executePhaseSteps(resolvedManifest.onLoadGrantedSteps, {
+            ...baseContext,
+            phase: 'onLoadGranted'
+        });
+        else if (!info.hasConsent && resolvedManifest.onLoadDeniedSteps.length > 0) executePhaseSteps(resolvedManifest.onLoadDeniedSteps, {
+            ...baseContext,
+            phase: 'onLoadDenied'
+        });
+    };
+    else if (hasLoadConsentBranches) script.onLoad = (info)=>{
+        const baseContext = {
+            scriptId: resolvedManifest.vendor,
+            elementId: info.elementId,
+            hasConsent: info.hasConsent,
+            callback: 'onLoad'
+        };
+        if (info.hasConsent && resolvedManifest.onLoadGrantedSteps.length > 0) executePhaseSteps(resolvedManifest.onLoadGrantedSteps, {
+            ...baseContext,
+            phase: 'onLoadGranted'
+        });
+        else if (!info.hasConsent && resolvedManifest.onLoadDeniedSteps.length > 0) executePhaseSteps(resolvedManifest.onLoadDeniedSteps, {
+            ...baseContext,
+            phase: 'onLoadDenied'
+        });
+    };
+    if (hasConsentLifecycle) script.onConsentChange = (info)=>{
+        const baseContext = {
+            scriptId: resolvedManifest.vendor,
+            elementId: info.elementId,
+            hasConsent: info.hasConsent,
+            callback: 'onConsentChange'
+        };
+        executePhaseSteps(getConsentSignalSteps(resolvedManifest, 'update', info.consents), {
+            ...baseContext,
+            phase: 'consent-update'
+        });
+        if (resolvedManifest.onConsentChangeSteps.length > 0) executePhaseSteps(resolvedManifest.onConsentChangeSteps, {
+            ...baseContext,
+            phase: 'onConsentChange'
+        });
+        if (info.hasConsent && resolvedManifest.onConsentGrantedSteps.length > 0) executePhaseSteps(resolvedManifest.onConsentGrantedSteps, {
+            ...baseContext,
+            phase: 'onConsentGranted'
+        });
+        else if (!info.hasConsent && resolvedManifest.onConsentDeniedSteps.length > 0) executePhaseSteps(resolvedManifest.onConsentDeniedSteps, {
+            ...baseContext,
+            phase: 'onConsentDenied'
+        });
+    };
+    return script;
+}
+export { resolvedManifestToScript };

package/dist/google-tag-manager.cjs

@@ -13,7 +13,7 @@ var __webpack_require__ = {};
 })();
 (()=>{
     __webpack_require__.r = (exports1)=>{
-        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
             value: 'Module'
         });
         Object.defineProperty(exports1, '__esModule', {
@@ -24,101 +24,93 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    DEFAULT_GTM_CONSENT_CONFIG: ()=>DEFAULT_GTM_CONSENT_CONFIG,
-    googleTagManager: ()=>googleTagManager,
-    mapConsentStateToGTM: ()=>mapConsentStateToGTM
+    googleTagManagerManifest: ()=>googleTagManagerManifest,
+    googleTagManager: ()=>googleTagManager
 });
-const DEFAULT_GTM_CONSENT_CONFIG = {
-    functionality_storage: 'denied',
-    security_storage: 'denied',
-    analytics_storage: 'denied',
-    ad_storage: 'denied',
-    ad_user_data: 'denied',
-    ad_personalization: 'denied',
-    personalization_storage: 'denied'
-};
-const CONSENT_STATE_TO_GTM_MAPPING = {
-    necessary: [
-        'security_storage'
-    ],
-    functionality: [
-        'functionality_storage'
+const external_resolve_cjs_namespaceObject = require("./resolve.cjs");
+const external_types_cjs_namespaceObject = require("./types.cjs");
+const googleTagManagerManifest = {
+    ...external_types_cjs_namespaceObject.vendorManifestContract,
+    vendor: 'google-tag-manager',
+    category: 'necessary',
+    alwaysLoad: true,
+    bootstrap: [
+        {
+            type: 'setGlobal',
+            name: 'dataLayer',
+            value: [],
+            ifUndefined: true
+        },
+        {
+            type: 'defineQueueFunction',
+            name: 'gtag',
+            queue: 'dataLayer',
+            ifUndefined: true
+        }
     ],
-    measurement: [
-        'analytics_storage'
+    install: [
+        {
+            type: 'pushToQueue',
+            queue: 'dataLayer',
+            value: {
+                'gtm.start': '{{loadTime}}',
+                event: 'gtm.js'
+            }
+        },
+        {
+            type: 'loadScript',
+            src: 'https://www.googletagmanager.com/gtm.js?id={{id}}',
+            async: true
+        }
     ],
-    marketing: [
-        'ad_storage',
-        'ad_user_data',
-        'ad_personalization'
+    onConsentChange: [
+        {
+            type: 'callGlobal',
+            global: 'gtag',
+            args: [
+                'event',
+                '{{updateEventName}}'
+            ]
+        }
     ],
-    experience: [
-        'personalization_storage'
-    ]
+    consentMapping: {
+        necessary: [
+            'security_storage'
+        ],
+        functionality: [
+            'functionality_storage'
+        ],
+        measurement: [
+            'analytics_storage'
+        ],
+        marketing: [
+            'ad_storage',
+            'ad_user_data',
+            'ad_personalization'
+        ],
+        experience: [
+            'personalization_storage'
+        ]
+    },
+    consentSignal: 'gtag'
 };
-function mapConsentStateToGTM(consentState) {
-    const gtmConfig = {
-        ...DEFAULT_GTM_CONSENT_CONFIG
-    };
-    for (const consentType of Object.keys(consentState)){
-        const isGranted = consentState[consentType];
-        const gtmConsentTypes = CONSENT_STATE_TO_GTM_MAPPING[consentType];
-        for (const gtmType of gtmConsentTypes)gtmConfig[gtmType] = isGranted ? 'granted' : 'denied';
-    }
-    return gtmConfig;
-}
-function googleTagManager({ id, script, updateEventName }) {
-    return {
-        ...script,
-        id: script?.id ? script.id : 'google-tag-manager',
-        src: script?.src ? script.src : `https://www.googletagmanager.com/gtm.js?id=${id}`,
-        category: script?.category ?? 'necessary',
-        async: script?.async ?? true,
-        alwaysLoad: true,
-        onBeforeLoad: ({ consents, elementId, ...rest })=>{
-            const gtmConsent = consents ? mapConsentStateToGTM(consents) : DEFAULT_GTM_CONSENT_CONFIG;
-            const setupScript = document.createElement("script");
-            setupScript.id = `${elementId}-init`;
-            setupScript.textContent = `
-    window.dataLayer = window.dataLayer || [];
-    window.gtag = function gtag() {
-      window.dataLayer.push(arguments);
-    };
-    window.gtag('consent', 'default', {
-      ...${JSON.stringify(gtmConsent)},
-    });
-    window.dataLayer.push({
-      'gtm.start': Date.now(),
-      event: 'gtm.js',
+function googleTagManager({ id, updateEventName, consentMapping }) {
+    const manifest = consentMapping ? {
+        ...googleTagManagerManifest,
+        consentMapping
+    } : googleTagManagerManifest;
+    const resolved = (0, external_resolve_cjs_namespaceObject.resolveManifest)(manifest, {
+        id,
+        loadTime: Date.now(),
+        updateEventName: updateEventName ?? 'consent-update'
     });
-  `;
-            if (!document.head) throw new Error("Document head is not available for script injection");
-            document.head.appendChild(setupScript);
-            if (script?.onBeforeLoad) script.onBeforeLoad({
-                consents,
-                elementId,
-                ...rest
-            });
-        },
-        onConsentChange ({ consents, ...rest }) {
-            if (window.gtag) {
-                window.gtag('consent', 'update', mapConsentStateToGTM(consents));
-                window.gtag('event', updateEventName ?? 'consent-update');
-            }
-            if (script?.onConsentChange) script.onConsentChange({
-                consents,
-                ...rest
-            });
-        }
-    };
+    return resolved;
 }
-exports.DEFAULT_GTM_CONSENT_CONFIG = __webpack_exports__.DEFAULT_GTM_CONSENT_CONFIG;
 exports.googleTagManager = __webpack_exports__.googleTagManager;
-exports.mapConsentStateToGTM = __webpack_exports__.mapConsentStateToGTM;
+exports.googleTagManagerManifest = __webpack_exports__.googleTagManagerManifest;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "DEFAULT_GTM_CONSENT_CONFIG",
     "googleTagManager",
-    "mapConsentStateToGTM"
+    "googleTagManagerManifest"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true