@c15t/scripts 2.0.0-rc.1 → 2.0.1

package/dist/engine/compile.js

@@ -0,0 +1,89 @@
+import { VENDOR_MANIFEST_KIND, VENDOR_MANIFEST_SCHEMA_VERSION } from "../types.js";
+const EXACT_PLACEHOLDER_PATTERN = /^\{\{([A-Za-z0-9_]+)\}\}$/;
+const PLACEHOLDER_PATTERN = /\{\{([A-Za-z0-9_]+)\}\}/g;
+function getConfigValue(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;
+}
+function stringifyInterpolatedValue(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);
+}
+function interpolateString(template, config) {
+    const exactMatch = template.match(EXACT_PLACEHOLDER_PATTERN);
+    if (exactMatch) return getConfigValue(config, exactMatch[1]);
+    return template.replace(PLACEHOLDER_PATTERN, (_match, key)=>{
+        const value = getConfigValue(config, key);
+        return stringifyInterpolatedValue(value, key);
+    });
+}
+function interpolateValue(value, config) {
+    if ('string' == typeof value) return 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;
+}
+function interpolateSteps(steps, config) {
+    if (!steps) return [];
+    return steps.map((step)=>interpolateValue(step, config));
+}
+function extractInstallArtifacts(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
+    };
+}
+function validateManifestContract(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}'.`);
+}
+function compileManifest(manifest, config = {}) {
+    validateManifestContract(manifest);
+    const bootstrapSteps = interpolateSteps(manifest.bootstrap, config);
+    const install = interpolateSteps(manifest.install, config);
+    const { loadScript, setupSteps } = extractInstallArtifacts(install);
+    return {
+        kind: manifest.kind,
+        schemaVersion: manifest.schemaVersion,
+        vendor: manifest.vendor,
+        category: interpolateValue(manifest.category, config),
+        alwaysLoad: void 0 === manifest.alwaysLoad ? void 0 : interpolateValue(manifest.alwaysLoad, config),
+        persistAfterConsentRevoked: void 0 === manifest.persistAfterConsentRevoked ? void 0 : interpolateValue(manifest.persistAfterConsentRevoked, config),
+        bootstrapSteps,
+        setupSteps,
+        loadScript,
+        afterLoadSteps: interpolateSteps(manifest.afterLoad, config),
+        onBeforeLoadGrantedSteps: interpolateSteps(manifest.onBeforeLoadGranted, config),
+        onBeforeLoadDeniedSteps: interpolateSteps(manifest.onBeforeLoadDenied, config),
+        onLoadGrantedSteps: interpolateSteps(manifest.onLoadGranted, config),
+        onLoadDeniedSteps: interpolateSteps(manifest.onLoadDenied, config),
+        onConsentChangeSteps: interpolateSteps(manifest.onConsentChange, config),
+        onConsentGrantedSteps: interpolateSteps(manifest.onConsentGranted, config),
+        onConsentDeniedSteps: interpolateSteps(manifest.onConsentDenied, config),
+        consentMapping: manifest.consentMapping ? interpolateValue(manifest.consentMapping, config) : void 0,
+        consentSignal: manifest.consentSignal,
+        consentSignalTarget: 'string' == typeof manifest.consentSignalTarget ? interpolateValue(manifest.consentSignalTarget, config) : manifest.consentSignalTarget
+    };
+}
+export { compileManifest, interpolateValue };

package/dist/engine/runtime.cjs

@@ -0,0 +1,378 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    resolvedManifestToScript: ()=>resolvedManifestToScript
+});
+const external_c15t_namespaceObject = require("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() {
+                    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 = 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] = 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;
+    (0, external_c15t_namespaceObject.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);
+        (0, external_c15t_namespaceObject.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) {
+        (0, external_c15t_namespaceObject.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;
+    }
+    (0, external_c15t_namespaceObject.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;
+}
+exports.resolvedManifestToScript = __webpack_exports__.resolvedManifestToScript;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "resolvedManifestToScript"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});