@c15t/scripts 2.2.0 → 3.0.0-alpha.1

package/dist/engine/runtime.js

@@ -1,16 +1,16 @@
-import { emitScriptDebugEvent } from "c15t";
+import { emitScriptDebugEvent } from "@c15t/core";
 import { RUNTIME_VALUE_KIND } from "../types.js";
-function isRuntimeValue(value) {
+const runtime_isRuntimeValue = function(value) {
     if (null === value || 'object' != typeof value || Array.isArray(value)) return false;
     const candidate = value;
     return candidate.kind === RUNTIME_VALUE_KIND && ('date' === candidate.value || 'timestamp' === candidate.value);
-}
-function resolveRuntimeValue(value) {
+};
+const runtime_resolveRuntimeValue = function(value) {
     if ('date' === value.value) return new Date();
     return Date.now();
-}
-function cloneStepValue(value) {
-    if (isRuntimeValue(value)) return resolveRuntimeValue(value);
+};
+const runtime_cloneStepValue = function cloneStepValue(value) {
+    if (runtime_isRuntimeValue(value)) return runtime_resolveRuntimeValue(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])=>[
@@ -18,11 +18,11 @@ function cloneStepValue(value) {
             cloneStepValue(nestedValue)
         ]));
     return value;
-}
-function isRecord(value) {
+};
+const runtime_isRecord = function(value) {
     return null !== value && 'object' == typeof value && !Array.isArray(value);
-}
-function getPathTarget(root, path) {
+};
+const runtime_getPathTarget = function(root, path) {
     if (0 === path.length) return;
     let target = root;
     for (const segment of path.slice(0, -1)){
@@ -31,11 +31,11 @@ function getPathTarget(root, path) {
         target = next;
     }
     return {
-        target,
-        key: path[path.length - 1]
+        key: path[path.length - 1],
+        target
     };
-}
-function resolveQueueTarget(root, queue, owner) {
+};
+const runtime_resolveQueueTarget = function(root, queue, owner) {
     if ('global' in queue && 'string' == typeof queue.global) {
         const queueTarget = root[queue.global];
         return Array.isArray(queueTarget) ? queueTarget : void 0;
@@ -44,15 +44,15 @@ function resolveQueueTarget(root, queue, owner) {
     const queueProperty = queue.property;
     const queueTarget = owner[queueProperty];
     return Array.isArray(queueTarget) ? queueTarget : void 0;
-}
-function executeStep(step) {
+};
+const runtime_executeStep = function(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);
+                win[step.name] = runtime_cloneStepValue(step.value);
                 break;
             }
         case 'defineQueueFunction':
@@ -76,7 +76,7 @@ function executeStep(step) {
                     const dispatcher = self && step.dispatchProperty ? self[step.dispatchProperty] : void 0;
                     const runtimeArgs = Array.from(arguments);
                     if ('function' == typeof dispatcher) return void dispatcher.apply(self, runtimeArgs);
-                    const queueTarget = resolveQueueTarget(win, step.queue, self);
+                    const queueTarget = runtime_resolveQueueTarget(win, step.queue, self);
                     if (!queueTarget) return;
                     if ('array' === step.queueFormat) return void queueTarget.push(runtimeArgs);
                     queueTarget.push(arguments);
@@ -89,14 +89,14 @@ function executeStep(step) {
                 }
                 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);
+                for (const [key, value] of Object.entries(step.properties ?? {}))stubRecord[key] = runtime_cloneStepValue(value);
                 break;
             }
         case 'callGlobal':
             {
                 const target = win[step.global];
                 if (!target) break;
-                const args = (step.args ?? []).map((arg)=>cloneStepValue(arg));
+                const args = (step.args ?? []).map((arg)=>runtime_cloneStepValue(arg));
                 if (step.method) {
                     const objectTarget = target;
                     const method = objectTarget[step.method];
@@ -107,16 +107,16 @@ function executeStep(step) {
         case 'pushToQueue':
             {
                 const queueTarget = win[step.queue];
-                if (Array.isArray(queueTarget)) queueTarget.push(cloneStepValue(step.value));
+                if (Array.isArray(queueTarget)) queueTarget.push(runtime_cloneStepValue(step.value));
                 break;
             }
         case 'setGlobalPath':
             {
-                const rootGlobal = step.path[0];
+                const [rootGlobal] = step.path;
                 if (step.ifGlobalIsQueue && (!rootGlobal || !Array.isArray(win[rootGlobal]))) break;
-                const pathTarget = getPathTarget(win, step.path);
+                const pathTarget = runtime_getPathTarget(win, step.path);
                 if (!pathTarget) break;
-                pathTarget.target[pathTarget.key] = cloneStepValue(step.value);
+                pathTarget.target[pathTarget.key] = runtime_cloneStepValue(step.value);
                 break;
             }
         case 'defineQueueMethods':
@@ -126,15 +126,15 @@ function executeStep(step) {
                 if (!step.queue && !Array.isArray(target)) break;
                 const targetRecord = target;
                 for (const methodName of step.methods)targetRecord[methodName] = (...args)=>{
-                    const queueTarget = resolveQueueTarget(win, step.queue ?? {
+                    const queueTarget = runtime_resolveQueueTarget(win, step.queue ?? {
                         global: step.target
                     }, targetRecord);
                     if (!queueTarget) return;
                     if ('methodCall' === step.queueFormat || 'wrappedMethodCall' === step.queueFormat || 'voidMethodCall' === step.queueFormat) {
                         const promise = new Promise((resolve)=>{
                             queueTarget.push({
-                                name: methodName,
                                 args,
+                                name: methodName,
                                 resolve
                             });
                         });
@@ -145,13 +145,13 @@ function executeStep(step) {
                         return promise;
                     }
                     if ('callback' === step.queueFormat) return void queueTarget.push({
-                        name: methodName,
                         fn: ()=>{
                             const latestTarget = win[step.target];
                             if (null === latestTarget || 'object' != typeof latestTarget && 'function' != typeof latestTarget) return;
                             const method = latestTarget[methodName];
                             if ('function' == typeof method) method.apply(latestTarget, args);
-                        }
+                        },
+                        name: methodName
                     });
                     queueTarget.push([
                         methodName,
@@ -172,8 +172,8 @@ function executeStep(step) {
                 for (const methodName of step.methods)prototype[methodName] = function(...args) {
                     const queueTarget = this[queueProperty];
                     if (Array.isArray(queueTarget)) queueTarget.push({
-                        name: methodName,
-                        args
+                        args,
+                        name: methodName
                     });
                     return this;
                 };
@@ -186,19 +186,19 @@ function executeStep(step) {
                 if (null === target || 'object' != typeof target && 'function' != typeof target) break;
                 if (step.ifGlobalIsQueue && !Array.isArray(target)) break;
                 const targetRecord = target;
-                for (const method of step.methods)targetRecord[method.name] = 'return' === method.behavior ? ()=>cloneStepValue(method.value) : ()=>{};
+                for (const method of step.methods)targetRecord[method.name] = 'return' === method.behavior ? ()=>runtime_cloneStepValue(method.value) : ()=>{};
                 break;
             }
         case 'constructGlobal':
             {
                 const Constructor = win[step.constructor];
                 if ('function' != typeof Constructor) break;
-                const args = (step.args ?? []).map((arg)=>cloneStepValue(arg));
+                const args = (step.args ?? []).map((arg)=>runtime_cloneStepValue(arg));
                 if (step.copyAssignedValueToArgProperty) {
                     const firstArg = args[0];
-                    const targetOptions = isRecord(firstArg) ? firstArg : {};
+                    const targetOptions = runtime_isRecord(firstArg) ? firstArg : {};
                     targetOptions[step.copyAssignedValueToArgProperty] = win[step.assignTo];
-                    if (!isRecord(firstArg)) args.unshift(targetOptions);
+                    if (!runtime_isRecord(firstArg)) args.unshift(targetOptions);
                 }
                 win[step.assignTo] = new Constructor(...args);
                 break;
@@ -206,81 +206,81 @@ function executeStep(step) {
         case 'loadScript':
             break;
     }
-}
-function executePhaseSteps(steps, context) {
+};
+const runtime_executePhaseSteps = function(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
-        }
+        },
+        elementId: context.elementId,
+        hasConsent: context.hasConsent,
+        message: `Manifest phase ${context.phase} started`,
+        phase: context.phase,
+        scope: 'phase',
+        scriptId: context.scriptId,
+        source: 'manifest-runtime'
     });
     for (const [stepIndex, step] of steps.entries())try {
-        executeStep(step);
+        runtime_executeStep(step);
         emitScriptDebugEvent({
-            source: 'manifest-runtime',
-            scope: 'step',
             action: 'step_executed',
-            message: `Executed ${step.type}`,
-            scriptId: context.scriptId,
+            callback: context.callback,
             elementId: context.elementId,
             hasConsent: context.hasConsent,
-            callback: context.callback,
+            message: `Executed ${step.type}`,
             phase: context.phase,
-            stepType: step.type,
-            stepIndex
+            scope: 'step',
+            scriptId: context.scriptId,
+            source: 'manifest-runtime',
+            stepIndex,
+            stepType: step.type
         });
     } catch (error) {
         emitScriptDebugEvent({
-            source: 'manifest-runtime',
-            scope: 'step',
             action: 'step_error',
-            message: `Failed to execute ${step.type}`,
-            scriptId: context.scriptId,
+            callback: context.callback,
+            data: {
+                error: error instanceof Error ? error.message : 'string' == typeof error ? error : 'Unknown error'
+            },
             elementId: context.elementId,
             hasConsent: context.hasConsent,
-            callback: context.callback,
+            message: `Failed to execute ${step.type}`,
             phase: context.phase,
-            stepType: step.type,
+            scope: 'step',
+            scriptId: context.scriptId,
+            source: 'manifest-runtime',
             stepIndex,
-            data: {
-                error: error instanceof Error ? error.message : 'string' == typeof error ? error : 'Unknown error'
-            }
+            stepType: step.type
         });
         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
-        }
+        },
+        elementId: context.elementId,
+        hasConsent: context.hasConsent,
+        message: `Manifest phase ${context.phase} completed`,
+        phase: context.phase,
+        scope: 'phase',
+        scriptId: context.scriptId,
+        source: 'manifest-runtime'
     });
-}
-function mapConsentState(mapping, consents) {
+};
+const runtime_mapConsentState = function(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 partitionConsentIds(mapping, consents) {
+};
+const runtime_partitionConsentIds = function(mapping, consents) {
     const allowedConsentIds = [];
     const deniedConsentIds = [];
     for (const [c15tCategory, consentIds] of Object.entries(mapping)){
@@ -291,147 +291,158 @@ function partitionConsentIds(mapping, consents) {
         allowedConsentIds,
         deniedConsentIds
     };
-}
-function getConsentSignalSteps(resolvedManifest, mode, consents) {
+};
+const ALL_DENIED = {
+    experience: false,
+    functionality: false,
+    marketing: false,
+    measurement: false,
+    necessary: true
+};
+const runtime_signalConsents = function(info) {
+    return info.vendor?.granted === false ? ALL_DENIED : info.consents;
+};
+const runtime_getConsentSignalSteps = function(resolvedManifest, mode, consents) {
     if (!resolvedManifest.consentMapping || !resolvedManifest.consentSignal) return [];
     switch(resolvedManifest.consentSignal){
         case 'gtag':
             {
-                const mapped = mapConsentState(resolvedManifest.consentMapping, consents);
+                const mapped = runtime_mapConsentState(resolvedManifest.consentMapping, consents);
                 return [
                     {
-                        type: 'callGlobal',
-                        global: resolvedManifest.consentSignalTarget ?? 'gtag',
                         args: [
                             'consent',
                             mode,
                             mapped
-                        ]
+                        ],
+                        global: resolvedManifest.consentSignalTarget ?? 'gtag',
+                        type: 'callGlobal'
                     }
                 ];
             }
         case 'rudderstack':
             {
-                const partition = partitionConsentIds(resolvedManifest.consentMapping, consents);
+                const partition = runtime_partitionConsentIds(resolvedManifest.consentMapping, consents);
                 return [
                     {
-                        type: 'callGlobal',
-                        global: resolvedManifest.consentSignalTarget ?? 'rudderanalytics',
-                        method: 'consent',
                         args: [
                             {
                                 consentManagement: {
-                                    enabled: true,
-                                    provider: 'custom',
                                     allowedConsentIds: partition.allowedConsentIds,
-                                    deniedConsentIds: partition.deniedConsentIds
+                                    deniedConsentIds: partition.deniedConsentIds,
+                                    enabled: true,
+                                    provider: 'custom'
                                 }
                             }
-                        ]
+                        ],
+                        global: resolvedManifest.consentSignalTarget ?? 'rudderanalytics',
+                        method: 'consent',
+                        type: 'callGlobal'
                     }
                 ];
             }
     }
-}
-function resolvedManifestToScript(resolvedManifest) {
+};
+const runtime_resolvedManifestToScript = function(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,
+        attributes: resolvedManifest.loadScript?.attributes,
+        callbackOnly: resolvedManifest.loadScript ? void 0 : true,
+        category: resolvedManifest.category,
         defer: resolvedManifest.loadScript?.defer,
-        attributes: resolvedManifest.loadScript?.attributes
+        id: resolvedManifest.vendor,
+        persistAfterConsentRevoked: resolvedManifest.persistAfterConsentRevoked,
+        src: resolvedManifest.loadScript?.src,
+        vendor: resolvedManifest.vendor
     };
     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,
+            callback: 'onBeforeLoad',
             elementId: info.elementId,
             hasConsent: info.hasConsent,
-            callback: 'onBeforeLoad'
+            scriptId: resolvedManifest.vendor
         };
-        executePhaseSteps(resolvedManifest.bootstrapSteps, {
+        runtime_executePhaseSteps(resolvedManifest.bootstrapSteps, {
             ...baseContext,
             phase: 'bootstrap'
         });
-        executePhaseSteps(getConsentSignalSteps(resolvedManifest, 'default', info.consents), {
+        runtime_executePhaseSteps(runtime_getConsentSignalSteps(resolvedManifest, 'default', runtime_signalConsents(info)), {
             ...baseContext,
             phase: 'consent-default'
         });
-        executePhaseSteps(resolvedManifest.setupSteps, {
+        runtime_executePhaseSteps(resolvedManifest.setupSteps, {
             ...baseContext,
             phase: 'setup'
         });
-        executePhaseSteps(info.hasConsent ? resolvedManifest.onBeforeLoadGrantedSteps : resolvedManifest.onBeforeLoadDeniedSteps, {
+        runtime_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,
+            callback: 'onLoad',
             elementId: info.elementId,
             hasConsent: info.hasConsent,
-            callback: 'onLoad'
+            scriptId: resolvedManifest.vendor
         };
-        executePhaseSteps(resolvedManifest.afterLoadSteps, {
+        runtime_executePhaseSteps(resolvedManifest.afterLoadSteps, {
             ...baseContext,
             phase: 'afterLoad'
         });
-        if (info.hasConsent && resolvedManifest.onLoadGrantedSteps.length > 0) executePhaseSteps(resolvedManifest.onLoadGrantedSteps, {
+        if (info.hasConsent && resolvedManifest.onLoadGrantedSteps.length > 0) runtime_executePhaseSteps(resolvedManifest.onLoadGrantedSteps, {
             ...baseContext,
             phase: 'onLoadGranted'
         });
-        else if (!info.hasConsent && resolvedManifest.onLoadDeniedSteps.length > 0) executePhaseSteps(resolvedManifest.onLoadDeniedSteps, {
+        else if (!info.hasConsent && resolvedManifest.onLoadDeniedSteps.length > 0) runtime_executePhaseSteps(resolvedManifest.onLoadDeniedSteps, {
             ...baseContext,
             phase: 'onLoadDenied'
         });
     };
     else if (hasLoadConsentBranches) script.onLoad = (info)=>{
         const baseContext = {
-            scriptId: resolvedManifest.vendor,
+            callback: 'onLoad',
             elementId: info.elementId,
             hasConsent: info.hasConsent,
-            callback: 'onLoad'
+            scriptId: resolvedManifest.vendor
         };
-        if (info.hasConsent && resolvedManifest.onLoadGrantedSteps.length > 0) executePhaseSteps(resolvedManifest.onLoadGrantedSteps, {
+        if (info.hasConsent && resolvedManifest.onLoadGrantedSteps.length > 0) runtime_executePhaseSteps(resolvedManifest.onLoadGrantedSteps, {
             ...baseContext,
             phase: 'onLoadGranted'
         });
-        else if (!info.hasConsent && resolvedManifest.onLoadDeniedSteps.length > 0) executePhaseSteps(resolvedManifest.onLoadDeniedSteps, {
+        else if (!info.hasConsent && resolvedManifest.onLoadDeniedSteps.length > 0) runtime_executePhaseSteps(resolvedManifest.onLoadDeniedSteps, {
             ...baseContext,
             phase: 'onLoadDenied'
         });
     };
     if (hasConsentLifecycle) script.onConsentChange = (info)=>{
         const baseContext = {
-            scriptId: resolvedManifest.vendor,
+            callback: 'onConsentChange',
             elementId: info.elementId,
             hasConsent: info.hasConsent,
-            callback: 'onConsentChange'
+            scriptId: resolvedManifest.vendor
         };
-        executePhaseSteps(getConsentSignalSteps(resolvedManifest, 'update', info.consents), {
+        runtime_executePhaseSteps(runtime_getConsentSignalSteps(resolvedManifest, 'update', runtime_signalConsents(info)), {
             ...baseContext,
             phase: 'consent-update'
         });
-        if (resolvedManifest.onConsentChangeSteps.length > 0) executePhaseSteps(resolvedManifest.onConsentChangeSteps, {
+        if (resolvedManifest.onConsentChangeSteps.length > 0) runtime_executePhaseSteps(resolvedManifest.onConsentChangeSteps, {
             ...baseContext,
             phase: 'onConsentChange'
         });
-        if (info.hasConsent && resolvedManifest.onConsentGrantedSteps.length > 0) executePhaseSteps(resolvedManifest.onConsentGrantedSteps, {
+        if (info.hasConsent && resolvedManifest.onConsentGrantedSteps.length > 0) runtime_executePhaseSteps(resolvedManifest.onConsentGrantedSteps, {
             ...baseContext,
             phase: 'onConsentGranted'
         });
-        else if (!info.hasConsent && resolvedManifest.onConsentDeniedSteps.length > 0) executePhaseSteps(resolvedManifest.onConsentDeniedSteps, {
+        else if (!info.hasConsent && resolvedManifest.onConsentDeniedSteps.length > 0) runtime_executePhaseSteps(resolvedManifest.onConsentDeniedSteps, {
             ...baseContext,
             phase: 'onConsentDenied'
         });
     };
     return script;
-}
-export { resolvedManifestToScript };
+};
+export { runtime_resolvedManifestToScript as resolvedManifestToScript };