@blotoutio/edgetag-sdk-browser 1.35.0 → 1.35.2

package/index.js

@@ -509,6 +509,306 @@
         return true;
     };
 
+    /**
+     * Get a nested value from an object using dot notation
+     */
+    const getNestedValue = (obj, path) => {
+        const parts = path.split('.');
+        let current = obj;
+        for (const part of parts) {
+            if (current === null || current === undefined) {
+                return undefined;
+            }
+            if (typeof current !== 'object') {
+                return undefined;
+            }
+            current = current[part];
+        }
+        return current;
+    };
+    /**
+     * Set a nested value in an object using dot notation
+     */
+    const setNestedValue = (obj, path, value) => {
+        const parts = path.split('.');
+        let current = obj;
+        for (let i = 0; i < parts.length - 1; i++) {
+            const part = parts[i];
+            const existing = current[part];
+            if (existing === undefined) {
+                current[part] = {};
+            }
+            else if (existing === null || typeof existing === 'object') {
+                // null can be overwritten with an object
+                // existing objects can be traversed
+                current[part] || (current[part] = {});
+            }
+            else {
+                // existing is a primitive type (string, number, boolean, etc.)
+                console.log(`Cannot set nested path "${path}": "${parts
+                .slice(0, i + 1)
+                .join('.')}" is already a ${typeof existing} and cannot be converted to an object`);
+                return;
+            }
+            current = current[part];
+        }
+        current[parts[parts.length - 1]] = value;
+    };
+    /**
+     * Remove a nested value from an object using dot notation
+     */
+    const removeNestedValue = (obj, path) => {
+        const parts = path.split('.');
+        let current = obj;
+        for (let i = 0; i < parts.length - 1; i++) {
+            const part = parts[i];
+            const existing = current[part];
+            if (existing !== null && typeof existing === 'object') {
+                current = current[part];
+            }
+            else {
+                return;
+            }
+        }
+        delete current[parts[parts.length - 1]];
+    };
+    /**
+     * Evaluate a single condition rule
+     */
+    const evaluateCondition = (condition, payload, userData = {}) => {
+        let fieldValue;
+        if (condition.field.startsWith('user.')) {
+            const userPath = condition.field.replace('user.', '');
+            fieldValue = getNestedValue(userData, userPath);
+        }
+        else if (condition.field.startsWith('payload.')) {
+            const payloadPath = condition.field.replace('payload.', '');
+            if (payloadPath.includes('[]')) {
+                const [arrayPath, arrayField] = payloadPath.split('[]');
+                const arrayValue = getNestedValue(payload, arrayPath);
+                if (Array.isArray(arrayValue)) {
+                    const fieldName = arrayField.startsWith('.')
+                        ? arrayField.slice(1)
+                        : arrayField;
+                    fieldValue = arrayValue.flatMap((item) => typeof item === 'object' && item !== null
+                        ? item[fieldName]
+                        : []);
+                }
+                else {
+                    fieldValue = undefined;
+                }
+            }
+            else {
+                fieldValue = getNestedValue(payload, payloadPath);
+            }
+        }
+        else {
+            fieldValue = getNestedValue(payload.data, condition.field);
+        }
+        const operator = condition.operator;
+        const conditionValue = condition.value;
+        switch (operator) {
+            case 'equals':
+                return fieldValue === conditionValue;
+            case 'notEquals':
+                return fieldValue !== conditionValue;
+            case 'greaterThan':
+                return (typeof fieldValue === 'number' &&
+                    typeof conditionValue === 'number' &&
+                    fieldValue > conditionValue);
+            case 'greaterThanOrEqual':
+                return (typeof fieldValue === 'number' &&
+                    typeof conditionValue === 'number' &&
+                    fieldValue >= conditionValue);
+            case 'lessThan':
+                return (typeof fieldValue === 'number' &&
+                    typeof conditionValue === 'number' &&
+                    fieldValue < conditionValue);
+            case 'lessThanOrEqual':
+                return (typeof fieldValue === 'number' &&
+                    typeof conditionValue === 'number' &&
+                    fieldValue <= conditionValue);
+            case 'contains':
+                if (Array.isArray(fieldValue)) {
+                    // For array fields, check if any item in the array contains the condition value
+                    return (typeof conditionValue === 'string' &&
+                        fieldValue.some((val) => typeof val === 'string' && val === conditionValue));
+                }
+                return (typeof fieldValue === 'string' &&
+                    typeof conditionValue === 'string' &&
+                    fieldValue.includes(conditionValue));
+            case 'notContains':
+                if (Array.isArray(fieldValue)) {
+                    // For array fields, check if no item in the array contains the condition value
+                    return (typeof conditionValue === 'string' &&
+                        !fieldValue.some((val) => typeof val === 'string' && val === conditionValue));
+                }
+                return (typeof fieldValue === 'string' &&
+                    typeof conditionValue === 'string' &&
+                    !fieldValue.includes(conditionValue));
+            case 'in':
+                if (Array.isArray(fieldValue)) {
+                    return (Array.isArray(conditionValue) &&
+                        fieldValue.some((val) => conditionValue.includes(val)));
+                }
+                return (Array.isArray(conditionValue) &&
+                    conditionValue.some((val) => val === fieldValue));
+            case 'notIn':
+                if (Array.isArray(fieldValue)) {
+                    return (Array.isArray(conditionValue) &&
+                        !fieldValue.some((val) => conditionValue.includes(val)));
+                }
+                return (Array.isArray(conditionValue) &&
+                    !conditionValue.some((val) => val === fieldValue));
+            case 'startsWith':
+                return (typeof fieldValue === 'string' &&
+                    typeof conditionValue === 'string' &&
+                    fieldValue.startsWith(conditionValue));
+            case 'endsWith':
+                return (typeof fieldValue === 'string' &&
+                    typeof conditionValue === 'string' &&
+                    fieldValue.endsWith(conditionValue));
+            case 'isNull':
+                return fieldValue === null || fieldValue === undefined;
+            case 'isNotNull':
+                return fieldValue !== null && fieldValue !== undefined;
+            default:
+                return false;
+        }
+    };
+    /**
+     * Evaluate conditions for a simplified rule (no nested groups)
+     */
+    const evaluateConditions = (conditions, logicalOperator, payload, userData = {}) => {
+        if (conditions.length === 0) {
+            return true;
+        }
+        if (logicalOperator === 'AND') {
+            return conditions.every((condition) => evaluateCondition(condition, payload, userData));
+        }
+        else {
+            return conditions.some((condition) => evaluateCondition(condition, payload, userData));
+        }
+    };
+    /**
+     * Apply actions to payload and providers
+     * @param actions - Array of actions to apply
+     * @param payload - The payload to modify
+     * @param providers - Optional separate providers object (if not in payload)
+     * @returns Updated payload, providers, skipEvent flag, and additional event names
+     */
+    const applyActions = (actions, payload, providers) => {
+        var _a;
+        const updatedPayload = structuredClone(payload);
+        if (!updatedPayload.data) {
+            updatedPayload.data = {};
+        }
+        const updatedProviders = ((_a = providers !== null && providers !== void 0 ? providers : updatedPayload.providers) !== null && _a !== void 0 ? _a : { all: true });
+        let skipEvent = false;
+        let skipBrowserEvent = false;
+        const additionalEvents = [];
+        for (const action of actions) {
+            switch (action.type) {
+                case 'skipEvent':
+                    skipEvent = true;
+                    break;
+                case 'skipBrowserEvent':
+                    skipBrowserEvent = true;
+                    break;
+                case 'skipProviders':
+                    if (action.providers && updatedProviders) {
+                        for (const provider of action.providers) {
+                            updatedProviders[provider] = false;
+                        }
+                    }
+                    break;
+                case 'updatePayloadField':
+                    if (action.fieldPath && action.fieldValue !== undefined) {
+                        const path = action.fieldPath.startsWith('data.')
+                            ? action.fieldPath
+                            : `data.${action.fieldPath}`;
+                        setNestedValue(updatedPayload.data, path.replace('data.', ''), action.fieldValue);
+                    }
+                    break;
+                case 'addPayloadField':
+                    if (action.fieldPath && action.fieldValue !== undefined) {
+                        const path = action.fieldPath.startsWith('data.')
+                            ? action.fieldPath
+                            : `data.${action.fieldPath}`;
+                        setNestedValue(updatedPayload.data, path.replace('data.', ''), action.fieldValue);
+                    }
+                    break;
+                case 'removePayloadField':
+                    if (action.fieldPath) {
+                        const path = action.fieldPath.startsWith('data.')
+                            ? action.fieldPath
+                            : `data.${action.fieldPath}`;
+                        removeNestedValue(updatedPayload.data, path.replace('data.', ''));
+                    }
+                    break;
+                case 'createAdditionalEvents':
+                    if (action.additionalEvents) {
+                        additionalEvents.push(...action.additionalEvents);
+                    }
+                    break;
+            }
+        }
+        if (updatedProviders !== undefined) {
+            updatedPayload.providers = updatedProviders;
+        }
+        return {
+            updatedPayload,
+            updatedProviders,
+            skipEvent,
+            skipBrowserEvent,
+            additionalEvents,
+        };
+    };
+    /**
+     * Evaluate all event rules and apply actions
+     * @param rules - Array of event rules to evaluate
+     * @param payload - The payload to evaluate and modify
+     * @param providers - Optional separate providers object (if not in payload)
+     * @param userData - Optional user data for user.* field access
+     * @returns Updated payload, providers, skipEvent flag, and additional event names
+     */
+    const evaluateEventRules = (rules, payload, providers, userData = {}) => {
+        var _a;
+        let updatedPayload = payload;
+        let updatedProviders = ((_a = providers !== null && providers !== void 0 ? providers : payload.providers) !== null && _a !== void 0 ? _a : { all: true });
+        let skipEvent = false;
+        let skipBrowserEvent = false;
+        const allAdditionalEvents = [];
+        try {
+            for (const rule of rules) {
+                const conditionMatches = evaluateConditions(rule.conditions || [], rule.logicalOperator || 'AND', updatedPayload, userData);
+                if (conditionMatches) {
+                    const actions = rule.actions || [];
+                    const result = applyActions(actions, updatedPayload, updatedProviders);
+                    updatedPayload = result.updatedPayload;
+                    updatedProviders = result.updatedProviders;
+                    allAdditionalEvents.push(...result.additionalEvents);
+                    if (result.skipEvent) {
+                        skipEvent = true;
+                    }
+                    if (result.skipBrowserEvent) {
+                        skipBrowserEvent = true;
+                    }
+                }
+            }
+        }
+        catch (error) {
+            console.error('Error evaluating event rules:', error);
+        }
+        return {
+            updatedPayload,
+            updatedProviders,
+            skipEvent,
+            skipBrowserEvent,
+            additionalEvents: allAdditionalEvents,
+        };
+    };
+
     // eslint-disable-next-line @nx/enforce-module-boundaries
     const getGlobalSettings = () => {
         var _a;
@@ -665,6 +965,15 @@
         }
         return true;
     };
+    const getInitData = (edgeURL, manifestResult) => ({
+        destination: edgeURL,
+        userId: manifestResult.userId,
+        isNewUser: manifestResult.isNewUser,
+        consent: manifestResult.consent,
+        consentCategories: manifestResult.consentCategories,
+        consentSetting: manifestResult.consentSetting,
+        session: manifestResult.session,
+    });
 
     const tagStorage = 'edgeTag';
     const consentKey = 'consent';
@@ -956,7 +1265,7 @@
             referrer: getReferrer(destination),
             search: getSearch(destination),
             locale: getLocale(),
-            sdkVersion: "1.35.0" ,
+            sdkVersion: "1.35.2" ,
             ...(payload || {}),
         };
         let storage = {};
@@ -1130,13 +1439,14 @@
         processGetData(instances[0], keys, callback);
     };
 
-    const sendTag = (destination, { eventName, eventId, data, providerData, providers, options }) => {
+    const sendTag = (destination, { eventName, eventId, data, providerData, providers, options, configuratorProcessed, }) => {
         const payload = {
             eventName,
             eventId,
             timestamp: Date.now(),
             data,
             providerData,
+            configuratorProcessed,
         };
         if (providers) {
             payload.providers = providers;
@@ -1169,64 +1479,93 @@
         const consentCategory = getConsentCategories(destination);
         const consentSettings = getSetting(destination, 'consentSetting');
         const userConsent = { consentChannel, consentCategory, consentSettings };
+        const userProperties = getSetting(destination, 'userProperties');
         if (skipZeroPurchaseEvent && isZeroPurchaseEvent({ eventName, data })) {
             return;
         }
-        const conversion = preparePayloadWithConversion(JSON.parse(JSON.stringify(data)), getSetting(destination, 'currency'));
-        for (const pkg of providerPackages) {
-            if (!pkg || !pkg.name || !pkg.tag) {
-                continue;
+        const originalData = structuredClone(data);
+        const originalProviders = structuredClone(providers);
+        const rules = (getSetting(destination, 'configuratorSetting') ||
+            []);
+        const rulesResult = evaluateEventRules(rules, structuredClone({ eventName, data }), providers !== null && providers !== void 0 ? providers : undefined, userProperties || {});
+        if (!rulesResult.skipEvent) {
+            if (rulesResult.updatedPayload) {
+                // eslint-disable-next-line no-param-reassign
+                data = rulesResult.updatedPayload.data;
             }
-            if (!configuredTags.has(pkg.name)) {
-                logger.log(`Provider ${pkg.name} is not in allow list`);
-                continue;
+            if (rulesResult.updatedProviders) {
+                // eslint-disable-next-line no-param-reassign
+                providers = rulesResult.updatedProviders;
             }
-            const variables = getProviderVariables(destination, pkg.name);
-            const result = {};
-            const executionContext = new Map();
-            for (const variable of variables) {
-                if (!isProviderInstanceAllowed(providers, pkg.name, variable.tagName)) {
-                    logger.log(`Provider instance is not allowed (${pkg.name}: ${variable.tagName})`);
-                    continue;
-                }
-                if (!hasUserConsent(userConsent, pkg.name, variable.tagName)) {
-                    logger.log(`Consent is missing (${pkg.name}: ${variable.tagName})`);
-                    continue;
-                }
-                if (!doesGeoRequestMatchList(requestCountry, requestRegion, isEURequest, variable.geoRegions)) {
-                    logger.log('GEO request region does not match the filter, skiping');
-                    continue;
+            if (!rulesResult.skipBrowserEvent) {
+                const conversion = preparePayloadWithConversion(JSON.parse(JSON.stringify(data)), getSetting(destination, 'currency'));
+                for (const pkg of providerPackages) {
+                    if (!pkg || !pkg.name || !pkg.tag) {
+                        continue;
+                    }
+                    if (!configuredTags.has(pkg.name)) {
+                        logger.log(`Provider ${pkg.name} is not in allow list`);
+                        continue;
+                    }
+                    const variables = getProviderVariables(destination, pkg.name);
+                    const result = {};
+                    const executionContext = new Map();
+                    for (const variable of variables) {
+                        if (!isProviderInstanceAllowed(providers, pkg.name, variable.tagName)) {
+                            logger.log(`Provider instance is not allowed (${pkg.name}: ${variable.tagName})`);
+                            continue;
+                        }
+                        if (!hasUserConsent(userConsent, pkg.name, variable.tagName)) {
+                            logger.log(`Consent is missing (${pkg.name}: ${variable.tagName})`);
+                            continue;
+                        }
+                        if (!doesGeoRequestMatchList(requestCountry, requestRegion, isEURequest, variable.geoRegions)) {
+                            logger.log('GEO request region does not match the filter, skiping');
+                            continue;
+                        }
+                        const payload = ((_a = conversion === null || conversion === void 0 ? void 0 : conversion.providers) === null || _a === void 0 ? void 0 : _a.length) === 0 ||
+                            ((_b = conversion === null || conversion === void 0 ? void 0 : conversion.providers) === null || _b === void 0 ? void 0 : _b.includes(pkg.name))
+                            ? conversion.payload
+                            : data;
+                        result[variable.tagName] = pkg.tag({
+                            userId,
+                            sessionId,
+                            eventName,
+                            eventId,
+                            data: JSON.parse(JSON.stringify(payload)),
+                            sendTag: sendTag.bind(null, destination),
+                            getEdgeData: processGetData.bind(null, destination),
+                            manifestVariables: variable.variableSet,
+                            executionContext,
+                            destination,
+                        });
+                    }
+                    providerData[pkg.name] = result;
                 }
-                const payload = ((_a = conversion === null || conversion === void 0 ? void 0 : conversion.providers) === null || _a === void 0 ? void 0 : _a.length) === 0 ||
-                    ((_b = conversion === null || conversion === void 0 ? void 0 : conversion.providers) === null || _b === void 0 ? void 0 : _b.includes(pkg.name))
-                    ? conversion.payload
-                    : data;
-                result[variable.tagName] = pkg.tag({
-                    userId,
-                    sessionId,
-                    eventName,
-                    eventId,
-                    data: JSON.parse(JSON.stringify(payload)),
-                    sendTag: sendTag.bind(null, destination),
-                    getEdgeData: processGetData.bind(null, destination),
-                    manifestVariables: variable.variableSet,
-                    executionContext,
-                    destination,
-                });
             }
-            providerData[pkg.name] = result;
+            else {
+                logger.log('Browser events skipped by event rules, sending tag to server only');
+            }
+            if (!hasAllowedManifestTags(configuredTags, userConsent, providers)) {
+                return;
+            }
+            sendTag(destination, {
+                configuratorProcessed: true,
+                eventName,
+                eventId,
+                data,
+                providerData,
+                providers,
+                options,
+            });
         }
-        if (!hasAllowedManifestTags(configuredTags, userConsent, providers)) {
-            return;
+        else {
+            logger.log('Event skipped by event rules');
+        }
+        const additionalEvents = rulesResult.additionalEvents || [];
+        for (const additionalEventName of additionalEvents) {
+            handleTag(additionalEventName, structuredClone(originalData || {}), originalProviders, options);
         }
-        sendTag(destination, {
-            eventName,
-            eventId,
-            data,
-            providerData,
-            providers,
-            options,
-        });
     };
     const handleTag = (eventName, data = {}, providers, options) => {
         if (options === null || options === void 0 ? void 0 : options.destination) {
@@ -1623,6 +1962,17 @@
         setSetting(destination, {
             initialized: true,
         });
+        // we fire this event to process the initial consent settings before firing
+        // the rest of the stubs. this will provide the ability to enqueue the consent
+        // call before the rest of the events so that consent is applied correctly for
+        // queued events.
+        try {
+            const detail = getInitData(destination, response);
+            window.dispatchEvent(new CustomEvent('edgetag-boot', { detail }));
+        }
+        catch {
+            // do nothing
+        }
         processStubs(destination);
     };
 
@@ -1747,24 +2097,16 @@
                 geoRegion: result.geoRegion,
                 isEURequest: result.isEURequest,
                 consentSetting: result.consentSetting,
+                configuratorSetting: result.configuratorSetting,
+                userProperties: result.userProperties,
             });
             if (result.storageId != null) {
                 savePerKey(preferences.edgeURL, 'local', tagStorage, result.storageId, storageIdKey);
             }
             handleManifest(preferences.edgeURL, result);
             try {
-                const detail = {
-                    destination: preferences.edgeURL,
-                    userId: result.userId,
-                    isNewUser: result.isNewUser,
-                    consent: result.consent,
-                    consentCategories: result.consentCategories,
-                    consentSetting: result.consentSetting,
-                    session: result.session,
-                };
-                window.dispatchEvent(new CustomEvent('edgetag-initialized', {
-                    detail,
-                }));
+                const detail = getInitData(preferences.edgeURL, result);
+                window.dispatchEvent(new CustomEvent('edgetag-initialized', { detail }));
                 onReady(detail);
             }
             catch {
@@ -2054,6 +2396,21 @@
         });
       };
 
+      const addConsentToDestination = (destination, consent) => {
+        if (!window.edgetag.destinations[destination]) {
+          window.edgetag.destinations[destination] = {};
+        }
+
+        if (!window.edgetag.destinations[destination].consents) {
+          window.edgetag.destinations[destination].consents = [];
+        }
+
+        window.edgetag.destinations[destination].consents.push({
+          name: 'consent',
+          arguments: consent,
+        });
+      };
+
       const handleInit = (args) => {
         if (!args?.length) {
           console.error('EdgeTag SDK: Init event is missing arguments');
@@ -2072,26 +2429,38 @@
         }
 
         const tags = [];
+        const consents = [];
+
+        window.edgetag.destinations['all'] =
+          window.edgetag.destinations['all'] || {};
+
+        if (!window.edgetag.destinations['all'].resolvedInits?.has(destination)) {
+          if (window.edgetag.destinations?.['all']?.tags) {
+            const destinationTags = window.edgetag.destinations['all'].tags.map(
+              (tag) => {
+                const newTag = structuredClone(tag);
+                newTag['arguments'][3] = { ...newTag['arguments'][3], destination };
+                return newTag
+              }
+            );
+            tags.push(...destinationTags);
+          }
+
+          if (window.edgetag.destinations?.['all']?.consents) {
+            const destinationConsents = window.edgetag.destinations[
+              'all'
+            ].consents.map((consent) => {
+              const newConsent = structuredClone(consent);
+              newConsent.arguments[2] = { ...newConsent.arguments[2], destination };
+              return newConsent
+            });
+            consents.push(...destinationConsents);
+          }
 
-        if (
-          window.edgetag.destinations?.['all']?.tags &&
-          !window.edgetag.destinations['all']?.resolvedInits?.has(destination)
-        ) {
-          const destinationTags = window.edgetag.destinations['all'].tags.map(
-            (tag) => {
-              const newTag = structuredClone(tag);
-              newTag['arguments'][3] = {
-                ...newTag['arguments'][3],
-                destination,
-              };
-
-              return newTag
-            }
-          );
-          tags.push(...destinationTags);
           if (!window.edgetag.destinations['all'].resolvedInits) {
             window.edgetag.destinations['all'].resolvedInits = new Set();
           }
+
           window.edgetag.destinations['all'].resolvedInits.add(destination);
         }
 
@@ -2100,8 +2469,13 @@
           window.edgetag.destinations[destination].tags = [];
         }
 
-        if (tags.length) {
-          args[0]['afterManifestEvents'] = tags;
+        if (window.edgetag.destinations[destination].consents) {
+          consents.push(...window.edgetag.destinations[destination].consents);
+          window.edgetag.destinations[destination].consents = [];
+        }
+
+        if (consents.length + tags.length > 0) {
+          args[0]['afterManifestEvents'] = [...consents, ...tags];
         }
 
         library.init(...args);
@@ -2188,6 +2562,7 @@
 
       const inits = [];
       const tags = [];
+      const consents = [];
       const otherStubs = [];
 
       stubs.forEach((stub) => {
@@ -2211,6 +2586,11 @@
           return
         }
 
+        if (name === 'consent') {
+          consents.push(args);
+          return
+        }
+
         if (name === 'tag') {
           tags.push(args);
           return
@@ -2232,6 +2612,7 @@
         if (!window.edgetag.destinations['all']) {
           window.edgetag.destinations['all'] = {
             tags: [],
+            consents: [],
             resolvedInits: new Set(),
           };
         }
@@ -2242,6 +2623,31 @@
         });
       });
 
+      consents.forEach((consent) => {
+        const destination = getTagDestination(consent);
+        if (destination) {
+          addConsentToDestination(destination, consent);
+          return
+        }
+
+        if (!window.edgetag.destinations['all']) {
+          window.edgetag.destinations['all'] = {
+            tags: [],
+            consents: [],
+            resolvedInits: new Set(),
+          };
+        }
+
+        if (!window.edgetag.destinations['all'].consents) {
+          window.edgetag.destinations['all'].consents = [];
+        }
+
+        window.edgetag.destinations['all'].consents.push({
+          name: 'consent',
+          arguments: consent,
+        });
+      });
+
       inits.forEach((init) => {
         window.edgetag.stubs.push(['init', ...init]);
       });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blotoutio/edgetag-sdk-browser",
-  "version": "1.35.0",
+  "version": "1.35.2",
   "description": "Browser SDK for EdgeTag",
   "author": "Blotout",
   "license": "MIT",