@c15t/scripts 3.0.0-alpha.2 → 3.0.0-alpha.4

package/dist/engine/compile.js

@@ -1,89 +1,2 @@
-import { VENDOR_MANIFEST_KIND, VENDOR_MANIFEST_SCHEMA_VERSION } from "../types.js";
-const EXACT_PLACEHOLDER_PATTERN = /^\{\{(?<capture1>[A-Za-z0-9_]+)\}\}$/u;
-const PLACEHOLDER_PATTERN = /\{\{(?<capture1>[A-Za-z0-9_]+)\}\}/gu;
-const compile_getConfigValue = function(config, key) {
-    if (!(key in config)) throw new Error(`Missing manifest interpolation value for '${key}'.`);
-    const value = config[key];
-    if ('function' == typeof value) throw new Error(`Manifest interpolation value for '${key}' must be serializable.`);
-    return value;
-};
-const compile_stringifyInterpolatedValue = function(value, key) {
-    if (void 0 === value) throw new Error(`Missing manifest interpolation value for '${key}'.`);
-    if ('string' == typeof value) return value;
-    if (null === value) return 'null';
-    if ('object' == typeof value) return JSON.stringify(value);
-    return String(value);
-};
-const compile_interpolateString = function(template, config) {
-    const exactMatch = template.match(EXACT_PLACEHOLDER_PATTERN);
-    if (exactMatch) return compile_getConfigValue(config, exactMatch[1]);
-    return template.replace(PLACEHOLDER_PATTERN, (_match, key)=>{
-        const value = compile_getConfigValue(config, key);
-        return compile_stringifyInterpolatedValue(value, key);
-    });
-};
-const compile_interpolateValue = function interpolateValue(value, config) {
-    if ('string' == typeof value) return compile_interpolateString(value, config);
-    if (Array.isArray(value)) return value.map((item)=>interpolateValue(item, config));
-    if (null !== value && 'object' == typeof value) {
-        const result = {};
-        for (const [key, nestedValue] of Object.entries(value)){
-            const interpolated = interpolateValue(nestedValue, config);
-            if (void 0 !== interpolated) result[key] = interpolated;
-        }
-        return result;
-    }
-    return value;
-};
-const compile_interpolateSteps = function(steps, config) {
-    if (!steps) return [];
-    return steps.map((step)=>compile_interpolateValue(step, config));
-};
-const compile_extractInstallArtifacts = function(install) {
-    const loadScriptSteps = install.filter((step)=>'loadScript' === step.type);
-    if (loadScriptSteps.length > 1) throw new Error('Vendor manifests may only declare a single loadScript step in install.');
-    if (1 === loadScriptSteps.length) {
-        const loadScript = loadScriptSteps[0];
-        if ('string' != typeof loadScript.src || 0 === loadScript.src.trim().length) throw new Error('loadScript steps must include a non-empty src after manifest interpolation.');
-        return {
-            loadScript,
-            setupSteps: install.filter((step)=>'loadScript' !== step.type)
-        };
-    }
-    return {
-        setupSteps: install
-    };
-};
-const compile_validateManifestContract = function(manifest) {
-    if (manifest.kind !== VENDOR_MANIFEST_KIND) throw new Error(`Unsupported manifest kind '${String(manifest.kind)}'. Expected '${VENDOR_MANIFEST_KIND}'.`);
-    if (manifest.schemaVersion !== VENDOR_MANIFEST_SCHEMA_VERSION) throw new Error(`Unsupported manifest schema version '${String(manifest.schemaVersion)}'. Expected '${VENDOR_MANIFEST_SCHEMA_VERSION}'.`);
-};
-const compile_compileManifest = function(manifest, config = {}) {
-    compile_validateManifestContract(manifest);
-    const bootstrapSteps = compile_interpolateSteps(manifest.bootstrap, config);
-    const install = compile_interpolateSteps(manifest.install, config);
-    const { loadScript, setupSteps } = compile_extractInstallArtifacts(install);
-    return {
-        afterLoadSteps: compile_interpolateSteps(manifest.afterLoad, config),
-        alwaysLoad: void 0 === manifest.alwaysLoad ? void 0 : compile_interpolateValue(manifest.alwaysLoad, config),
-        bootstrapSteps,
-        category: compile_interpolateValue(manifest.category, config),
-        consentMapping: manifest.consentMapping ? compile_interpolateValue(manifest.consentMapping, config) : void 0,
-        consentSignal: manifest.consentSignal,
-        consentSignalTarget: 'string' == typeof manifest.consentSignalTarget ? compile_interpolateValue(manifest.consentSignalTarget, config) : manifest.consentSignalTarget,
-        kind: manifest.kind,
-        loadScript,
-        onBeforeLoadDeniedSteps: compile_interpolateSteps(manifest.onBeforeLoadDenied, config),
-        onBeforeLoadGrantedSteps: compile_interpolateSteps(manifest.onBeforeLoadGranted, config),
-        onConsentChangeSteps: compile_interpolateSteps(manifest.onConsentChange, config),
-        onConsentDeniedSteps: compile_interpolateSteps(manifest.onConsentDenied, config),
-        onConsentGrantedSteps: compile_interpolateSteps(manifest.onConsentGranted, config),
-        onLoadDeniedSteps: compile_interpolateSteps(manifest.onLoadDenied, config),
-        onLoadGrantedSteps: compile_interpolateSteps(manifest.onLoadGranted, config),
-        persistAfterConsentRevoked: void 0 === manifest.persistAfterConsentRevoked ? void 0 : compile_interpolateValue(manifest.persistAfterConsentRevoked, config),
-        schemaVersion: manifest.schemaVersion,
-        setupSteps,
-        vendor: manifest.vendor
-    };
-};
-export { compile_compileManifest as compileManifest, compile_interpolateValue as interpolateValue };
+/** @deprecated Use @c15t/integrations/engine/compile. Compatibility ends in v4. */
+export * from '@c15t/integrations/engine/compile';

package/dist/engine/runtime.js

@@ -1,448 +1,2 @@
-import { emitScriptDebugEvent } from "@c15t/core";
-import { RUNTIME_VALUE_KIND } from "../types.js";
-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);
-};
-const runtime_resolveRuntimeValue = function(value) {
-    if ('date' === value.value) return new Date();
-    return Date.now();
-};
-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])=>[
-            key,
-            cloneStepValue(nestedValue)
-        ]));
-    return value;
-};
-const runtime_isRecord = function(value) {
-    return null !== value && 'object' == typeof value && !Array.isArray(value);
-};
-const runtime_getPathTarget = function(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 {
-        key: path[path.length - 1],
-        target
-    };
-};
-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;
-    }
-    if (!owner) return;
-    const queueProperty = queue.property;
-    const queueTarget = owner[queueProperty];
-    return Array.isArray(queueTarget) ? queueTarget : void 0;
-};
-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] = runtime_cloneStepValue(step.value);
-                break;
-            }
-        case 'defineQueueFunction':
-            {
-                const shouldSet = false !== step.ifUndefined;
-                if (shouldSet && void 0 !== win[step.name]) break;
-                win[step.name] = function() {
-                    const queueTarget = win[step.queue];
-                    if (!Array.isArray(queueTarget)) return;
-                    if ('array' === step.pushStyle) return void queueTarget.push(Array.from(arguments));
-                    queueTarget.push(arguments);
-                };
-                break;
-            }
-        case 'defineStubFunction':
-            {
-                const shouldSet = false !== step.ifUndefined;
-                if (shouldSet && void 0 !== win[step.name]) break;
-                const stub = function() {
-                    const self = win[step.name];
-                    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 = runtime_resolveQueueTarget(win, step.queue, self);
-                    if (!queueTarget) return;
-                    if ('array' === step.queueFormat) return void queueTarget.push(runtimeArgs);
-                    queueTarget.push(arguments);
-                };
-                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] = runtime_cloneStepValue(value);
-                break;
-            }
-        case 'callGlobal':
-            {
-                const target = win[step.global];
-                if (!target) break;
-                const args = (step.args ?? []).map((arg)=>runtime_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(runtime_cloneStepValue(step.value));
-                break;
-            }
-        case 'setGlobalPath':
-            {
-                const [rootGlobal] = step.path;
-                if (step.ifGlobalIsQueue && (!rootGlobal || !Array.isArray(win[rootGlobal]))) break;
-                const pathTarget = runtime_getPathTarget(win, step.path);
-                if (!pathTarget) break;
-                pathTarget.target[pathTarget.key] = runtime_cloneStepValue(step.value);
-                break;
-            }
-        case 'defineQueueMethods':
-            {
-                const target = win[step.target];
-                if (null === target || 'object' != typeof target && 'function' != typeof target) break;
-                if (!step.queue && !Array.isArray(target)) break;
-                const targetRecord = target;
-                for (const methodName of step.methods)targetRecord[methodName] = (...args)=>{
-                    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({
-                                args,
-                                name: methodName,
-                                resolve
-                            });
-                        });
-                        if ('wrappedMethodCall' === step.queueFormat) return {
-                            promise
-                        };
-                        if ('voidMethodCall' === step.queueFormat) return;
-                        return promise;
-                    }
-                    if ('callback' === step.queueFormat) return void queueTarget.push({
-                        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,
-                        ...args
-                    ]);
-                };
-                break;
-            }
-        case 'defineQueueClass':
-            {
-                const target = win[step.target];
-                if (null === target || 'object' != typeof target && 'function' != typeof target) break;
-                const queueProperty = step.queueProperty ?? '_q';
-                const QueueClass = function() {
-                    this[queueProperty] = [];
-                };
-                const prototype = QueueClass.prototype;
-                for (const methodName of step.methods)prototype[methodName] = function(...args) {
-                    const queueTarget = this[queueProperty];
-                    if (Array.isArray(queueTarget)) queueTarget.push({
-                        args,
-                        name: methodName
-                    });
-                    return this;
-                };
-                target[step.name] = QueueClass;
-                break;
-            }
-        case 'defineGlobalMethods':
-            {
-                const target = win[step.target];
-                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 ? ()=>runtime_cloneStepValue(method.value) : ()=>{};
-                break;
-            }
-        case 'constructGlobal':
-            {
-                const Constructor = win[step.constructor];
-                if ('function' != typeof Constructor) break;
-                const args = (step.args ?? []).map((arg)=>runtime_cloneStepValue(arg));
-                if (step.copyAssignedValueToArgProperty) {
-                    const firstArg = args[0];
-                    const targetOptions = runtime_isRecord(firstArg) ? firstArg : {};
-                    targetOptions[step.copyAssignedValueToArgProperty] = win[step.assignTo];
-                    if (!runtime_isRecord(firstArg)) args.unshift(targetOptions);
-                }
-                win[step.assignTo] = new Constructor(...args);
-                break;
-            }
-        case 'loadScript':
-            break;
-    }
-};
-const runtime_executePhaseSteps = function(steps, context) {
-    if (0 === steps.length) return;
-    emitScriptDebugEvent({
-        action: 'phase_start',
-        callback: context.callback,
-        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 {
-        runtime_executeStep(step);
-        emitScriptDebugEvent({
-            action: 'step_executed',
-            callback: context.callback,
-            elementId: context.elementId,
-            hasConsent: context.hasConsent,
-            message: `Executed ${step.type}`,
-            phase: context.phase,
-            scope: 'step',
-            scriptId: context.scriptId,
-            source: 'manifest-runtime',
-            stepIndex,
-            stepType: step.type
-        });
-    } catch (error) {
-        emitScriptDebugEvent({
-            action: 'step_error',
-            callback: context.callback,
-            data: {
-                error: error instanceof Error ? error.message : 'string' == typeof error ? error : 'Unknown error'
-            },
-            elementId: context.elementId,
-            hasConsent: context.hasConsent,
-            message: `Failed to execute ${step.type}`,
-            phase: context.phase,
-            scope: 'step',
-            scriptId: context.scriptId,
-            source: 'manifest-runtime',
-            stepIndex,
-            stepType: step.type
-        });
-        throw error;
-    }
-    emitScriptDebugEvent({
-        action: 'phase_complete',
-        callback: context.callback,
-        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'
-    });
-};
-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;
-};
-const runtime_partitionConsentIds = function(mapping, consents) {
-    const allowedConsentIds = [];
-    const deniedConsentIds = [];
-    for (const [c15tCategory, consentIds] of Object.entries(mapping)){
-        const isGranted = consents[c15tCategory];
-        for (const consentId of consentIds)(isGranted ? allowedConsentIds : deniedConsentIds).push(consentId);
-    }
-    return {
-        allowedConsentIds,
-        deniedConsentIds
-    };
-};
-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 = runtime_mapConsentState(resolvedManifest.consentMapping, consents);
-                return [
-                    {
-                        args: [
-                            'consent',
-                            mode,
-                            mapped
-                        ],
-                        global: resolvedManifest.consentSignalTarget ?? 'gtag',
-                        type: 'callGlobal'
-                    }
-                ];
-            }
-        case 'rudderstack':
-            {
-                const partition = runtime_partitionConsentIds(resolvedManifest.consentMapping, consents);
-                return [
-                    {
-                        args: [
-                            {
-                                consentManagement: {
-                                    allowedConsentIds: partition.allowedConsentIds,
-                                    deniedConsentIds: partition.deniedConsentIds,
-                                    enabled: true,
-                                    provider: 'custom'
-                                }
-                            }
-                        ],
-                        global: resolvedManifest.consentSignalTarget ?? 'rudderanalytics',
-                        method: 'consent',
-                        type: 'callGlobal'
-                    }
-                ];
-            }
-    }
-};
-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 = {
-        alwaysLoad: resolvedManifest.alwaysLoad,
-        async: resolvedManifest.loadScript?.async,
-        attributes: resolvedManifest.loadScript?.attributes,
-        callbackOnly: resolvedManifest.loadScript ? void 0 : true,
-        category: resolvedManifest.category,
-        defer: resolvedManifest.loadScript?.defer,
-        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 = {
-            callback: 'onBeforeLoad',
-            elementId: info.elementId,
-            hasConsent: info.hasConsent,
-            scriptId: resolvedManifest.vendor
-        };
-        runtime_executePhaseSteps(resolvedManifest.bootstrapSteps, {
-            ...baseContext,
-            phase: 'bootstrap'
-        });
-        runtime_executePhaseSteps(runtime_getConsentSignalSteps(resolvedManifest, 'default', runtime_signalConsents(info)), {
-            ...baseContext,
-            phase: 'consent-default'
-        });
-        runtime_executePhaseSteps(resolvedManifest.setupSteps, {
-            ...baseContext,
-            phase: 'setup'
-        });
-        runtime_executePhaseSteps(info.hasConsent ? resolvedManifest.onBeforeLoadGrantedSteps : resolvedManifest.onBeforeLoadDeniedSteps, {
-            ...baseContext,
-            phase: info.hasConsent ? 'onBeforeLoadGranted' : 'onBeforeLoadDenied'
-        });
-    };
-    if (resolvedManifest.afterLoadSteps.length > 0) script.onLoad = (info)=>{
-        const baseContext = {
-            callback: 'onLoad',
-            elementId: info.elementId,
-            hasConsent: info.hasConsent,
-            scriptId: resolvedManifest.vendor
-        };
-        runtime_executePhaseSteps(resolvedManifest.afterLoadSteps, {
-            ...baseContext,
-            phase: 'afterLoad'
-        });
-        if (info.hasConsent && resolvedManifest.onLoadGrantedSteps.length > 0) runtime_executePhaseSteps(resolvedManifest.onLoadGrantedSteps, {
-            ...baseContext,
-            phase: 'onLoadGranted'
-        });
-        else if (!info.hasConsent && resolvedManifest.onLoadDeniedSteps.length > 0) runtime_executePhaseSteps(resolvedManifest.onLoadDeniedSteps, {
-            ...baseContext,
-            phase: 'onLoadDenied'
-        });
-    };
-    else if (hasLoadConsentBranches) script.onLoad = (info)=>{
-        const baseContext = {
-            callback: 'onLoad',
-            elementId: info.elementId,
-            hasConsent: info.hasConsent,
-            scriptId: resolvedManifest.vendor
-        };
-        if (info.hasConsent && resolvedManifest.onLoadGrantedSteps.length > 0) runtime_executePhaseSteps(resolvedManifest.onLoadGrantedSteps, {
-            ...baseContext,
-            phase: 'onLoadGranted'
-        });
-        else if (!info.hasConsent && resolvedManifest.onLoadDeniedSteps.length > 0) runtime_executePhaseSteps(resolvedManifest.onLoadDeniedSteps, {
-            ...baseContext,
-            phase: 'onLoadDenied'
-        });
-    };
-    if (hasConsentLifecycle) script.onConsentChange = (info)=>{
-        const baseContext = {
-            callback: 'onConsentChange',
-            elementId: info.elementId,
-            hasConsent: info.hasConsent,
-            scriptId: resolvedManifest.vendor
-        };
-        runtime_executePhaseSteps(runtime_getConsentSignalSteps(resolvedManifest, 'update', runtime_signalConsents(info)), {
-            ...baseContext,
-            phase: 'consent-update'
-        });
-        if (resolvedManifest.onConsentChangeSteps.length > 0) runtime_executePhaseSteps(resolvedManifest.onConsentChangeSteps, {
-            ...baseContext,
-            phase: 'onConsentChange'
-        });
-        if (info.hasConsent && resolvedManifest.onConsentGrantedSteps.length > 0) runtime_executePhaseSteps(resolvedManifest.onConsentGrantedSteps, {
-            ...baseContext,
-            phase: 'onConsentGranted'
-        });
-        else if (!info.hasConsent && resolvedManifest.onConsentDeniedSteps.length > 0) runtime_executePhaseSteps(resolvedManifest.onConsentDeniedSteps, {
-            ...baseContext,
-            phase: 'onConsentDenied'
-        });
-    };
-    return script;
-};
-export { runtime_resolvedManifestToScript as resolvedManifestToScript };
+/** @deprecated Use @c15t/integrations/engine/runtime. Compatibility ends in v4. */
+export * from '@c15t/integrations/engine/runtime';