@adobe/alloy 2.28.1 → 2.29.0-beta.0

package/libEs5/components/Advertising/identities/collectRampId.js

@@ -0,0 +1,183 @@
+"use strict";
+
+exports.initiateRampIDCall = exports.getRampId = void 0;
+var _index = require("../../../utils/dom/index.js");
+var _index2 = require("../constants/index.js");
+/*
+Copyright 2025 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+const RETRY_CONFIG = {
+  MAX_COUNT: 15,
+  MAX_TIME_MS: 30000,
+  DELAY_BASE_MS: 500,
+  MAX_DELAY_MS: 5000,
+  SHORT_TIMEOUT_MS: 5000
+};
+const state = {
+  rampIdEnv: undefined,
+  rampIdCallInitiated: false,
+  inProgressRampIdPromise: null,
+  scriptLoadingInitiated: false,
+  envelopeRetrievalInProgress: false
+};
+const processEnvelope = (envelope, resolve, cookieManager, logger) => {
+  let parsedEnvelope;
+  try {
+    parsedEnvelope = JSON.parse(envelope).envelope;
+  } catch {
+    parsedEnvelope = envelope;
+  }
+  if (parsedEnvelope && !state.rampIdCallInitiated) {
+    state.rampIdCallInitiated = true;
+    state.rampIdEnv = parsedEnvelope;
+    state.envelopeRetrievalInProgress = false;
+    state.inProgressRampIdPromise = null;
+    cookieManager.setValue(_index2.RAMP_ID, state.rampIdEnv);
+    cookieManager.setValue(_index2.RAMP_ID_EXPIRES, Date.now() + 48 * 60 * 60 * 1000); //expires in 48 hours
+    resolve(state.rampIdEnv);
+  } else {
+    logger.warn("Invalid RampID envelope received", {
+      envelope: parsedEnvelope
+    });
+    state.envelopeRetrievalInProgress = false;
+  }
+};
+const retrieveEnvelopeWithRetries = (resolve, reject, cookieManager, logger) => {
+  let retryCount = RETRY_CONFIG.MAX_COUNT;
+  let timerMultiplier = 1;
+  let totalElapsedTime = 0;
+  const tryToRetrieve = () => {
+    if (state.rampIdEnv) return;
+    if (totalElapsedTime > RETRY_CONFIG.MAX_TIME_MS) {
+      logger.error("Maximum retry time exceeded");
+      state.envelopeRetrievalInProgress = false;
+      reject(new Error("Failed to retrieve RampID - timeout"));
+      state.inProgressRampIdPromise = null;
+      return;
+    }
+    if (retryCount === 0) {
+      logger.error("Maximum retries exceeded");
+      state.envelopeRetrievalInProgress = false;
+      reject(new Error("Failed to retrieve RampID after maximum retries"));
+      state.inProgressRampIdPromise = null;
+      return;
+    }
+    const delay = Math.min(RETRY_CONFIG.DELAY_BASE_MS * timerMultiplier, RETRY_CONFIG.MAX_DELAY_MS);
+    setTimeout(() => {
+      totalElapsedTime += delay;
+      retryCount -= 1;
+      timerMultiplier += 1;
+      if (typeof window.ats !== "undefined" && window.ats !== null && !state.rampIdEnv && !state.envelopeRetrievalInProgress) {
+        state.envelopeRetrievalInProgress = true;
+        window.ats.retrieveEnvelope().then(rampIdResponse => {
+          processEnvelope(rampIdResponse, resolve, cookieManager, logger);
+          if (!state.rampIdEnv) tryToRetrieve();
+        }, () => {
+          logger.warn("Failed to retrieve envelope");
+          state.envelopeRetrievalInProgress = false;
+          tryToRetrieve();
+        });
+      } else {
+        tryToRetrieve();
+      }
+    }, delay);
+  };
+  tryToRetrieve();
+};
+const initiateRampIDCall = (rampIdScriptPath, cookieManager, logger, useShortTimeout = false) => {
+  if (state.inProgressRampIdPromise) {
+    return state.inProgressRampIdPromise;
+  }
+  const timeoutMs = useShortTimeout ? RETRY_CONFIG.SHORT_TIMEOUT_MS : RETRY_CONFIG.MAX_TIME_MS;
+  let timedOut = false;
+  const mainPromise = new Promise((resolve, reject) => {
+    (0, _index.loadScript)(rampIdScriptPath, {
+      onLoad: () => {
+        if (typeof window.ats !== "undefined" && !state.envelopeRetrievalInProgress) {
+          state.envelopeRetrievalInProgress = true;
+          window.ats.retrieveEnvelope().then(envelopeResponse => {
+            if (envelopeResponse) {
+              if (!timedOut) {
+                processEnvelope(envelopeResponse, resolve, cookieManager, logger);
+              }
+            } else {
+              state.envelopeRetrievalInProgress = false;
+              window.addEventListener("lrEnvelopePresent", () => {
+                if (state.envelopeRetrievalInProgress || timedOut) return;
+                state.envelopeRetrievalInProgress = true;
+                window.ats.retrieveEnvelope().then(envelopeResult => {
+                  if (!timedOut) {
+                    processEnvelope(envelopeResult, resolve, cookieManager, logger);
+                  }
+                }, error => {
+                  if (!timedOut) {
+                    logger.error("Failed to retrieve envelope after event", error);
+                    state.envelopeRetrievalInProgress = false;
+                    reject(error);
+                    state.inProgressRampIdPromise = null;
+                  }
+                });
+              });
+            }
+          }).catch(error => {
+            if (!timedOut) {
+              logger.error("Error retrieving envelope", error);
+              state.envelopeRetrievalInProgress = false;
+              reject(error);
+              state.inProgressRampIdPromise = null;
+            }
+          });
+        }
+        retrieveEnvelopeWithRetries(val => {
+          if (!timedOut) resolve(val);
+        }, err => {
+          if (!timedOut) reject(err);
+        }, cookieManager, logger);
+      },
+      onError: error => {
+        if (!timedOut) {
+          reject(error);
+        }
+        state.inProgressRampIdPromise = null;
+      }
+    });
+  });
+  const timeoutPromise = new Promise(resolve => {
+    setTimeout(() => {
+      timedOut = true;
+      resolve(null);
+    }, timeoutMs);
+  });
+  state.inProgressRampIdPromise = Promise.race([mainPromise, timeoutPromise]).finally(() => {
+    state.inProgressRampIdPromise = null;
+  });
+  return state.inProgressRampIdPromise;
+};
+exports.initiateRampIDCall = initiateRampIDCall;
+const getRampId = (logger, rampIdScriptPath, cookieManager, resolveRampIdIfNotAvailable = true, useShortTimeout = false) => {
+  if (state.rampIdEnv) {
+    return Promise.resolve(state.rampIdEnv);
+  }
+  if (cookieManager) {
+    const rampIdFromCookie = cookieManager.getValue(_index2.RAMP_ID);
+    const rampIdExpires = cookieManager.getValue(_index2.RAMP_ID_EXPIRES);
+    if (rampIdFromCookie && rampIdExpires && rampIdExpires > Date.now()) {
+      state.rampIdEnv = rampIdFromCookie;
+      return Promise.resolve(rampIdFromCookie);
+    }
+  }
+  if (!resolveRampIdIfNotAvailable || rampIdScriptPath == null) {
+    return Promise.resolve(null);
+  }
+  return initiateRampIDCall(rampIdScriptPath, cookieManager, logger, useShortTimeout);
+};
+exports.getRampId = getRampId;

package/libEs5/components/Advertising/identities/collectSurferId.js

@@ -0,0 +1,146 @@
+"use strict";
+
+exports.default = void 0;
+var _index = require("../constants/index.js");
+var _createNode = require("../../../utils/dom/createNode.js");
+var _index2 = require("../../../utils/index.js");
+/*
+Copyright 2025 Adobe. All rights reserved.
+This file is licensed under the Apache License, Version 2.0.
+*/
+
+let surferId = "";
+let displayClickCookie = "";
+let inProgressSurferPromise = null;
+const addToDom = element => {
+  if (document.body) {
+    document.body.appendChild(element);
+  } else {
+    window.addEventListener("load", () => {
+      document.body.appendChild(element);
+    }, false);
+  }
+};
+const getInvisibleIframeElement = url => (0, _createNode.default)("iframe", {
+  src: url
+}, {
+  height: 0,
+  width: 0,
+  frameBorder: 0,
+  style: {
+    display: "none"
+  }
+}, []);
+const addListener = fn => window.addEventListener("message", fn, false);
+const removeListener = fn => window.removeEventListener("message", fn, false);
+const initiateAdvertisingIdentityCall = () => {
+  if (inProgressSurferPromise) {
+    return inProgressSurferPromise;
+  }
+  inProgressSurferPromise = new Promise((resolve, reject) => {
+    setTimeout(() => {
+      const scheme = document.location.protocol === "https:" ? "https:" : "http:";
+      const nestedParams = new URLSearchParams({
+        google: "__EFGCK__",
+        gsurfer: "__EFGSURFER__",
+        imsId: "__EFIMSORGID__",
+        is_fb_cookie_synced: "__EFFB__",
+        optout: "__EFOPTOUT__",
+        throttleCookie: "__EFSYNC__",
+        time: "__EFTIME__",
+        ev_lcc: "__LCC__"
+      });
+      const nestedUrl = scheme + "//www.everestjs.net/static/pixel_details.html#" + nestedParams.toString();
+      const mainParams = new URLSearchParams({
+        ev_gb: "0",
+        url: nestedUrl
+      });
+      const pixelDetailsUrl = scheme + "//" + _index.SURFER_PIXEL_HOST + "/" + _index.SURFER_USER_ID + "/gr?" + mainParams.toString();
+      const iframeElement = getInvisibleIframeElement(pixelDetailsUrl);
+      addToDom(iframeElement);
+      const pixelDetailsReceiver = function pixelDetailsReceiver(message) {
+        if (!message.origin.includes(_index.SURFER_TRUSTED_ORIGIN)) {
+          return;
+        }
+        try {
+          const pixelRedirectUri = message.data;
+          const hashIndex = pixelRedirectUri.indexOf("#");
+          if (hashIndex === -1) {
+            resolve({
+              surferId: null,
+              displayClickCookie: null
+            });
+            return;
+          }
+          const hashParams = new URLSearchParams(pixelRedirectUri.substring(hashIndex + 1));
+          let resolvedSurferId;
+          let resolvedDisplayClickCookie;
+          const surferValue = hashParams.get(_index.SURFER_PARAM_KEY);
+          if (surferValue) {
+            resolvedSurferId = surferValue;
+          }
+          const displayClickValue = hashParams.get(_index.DISPLAY_CLICK_COOKIE_KEY);
+          if (displayClickValue && displayClickValue !== "__LCC__") {
+            resolvedDisplayClickCookie = displayClickValue;
+          }
+          removeListener(pixelDetailsReceiver);
+          if (resolvedSurferId) {
+            surferId = resolvedSurferId;
+            displayClickCookie = resolvedDisplayClickCookie;
+            resolve({
+              surferId,
+              displayClickCookie
+            });
+          } else {
+            resolve({
+              surferId: null,
+              displayClickCookie: null
+            });
+          }
+        } catch (err) {
+          reject(err);
+        } finally {
+          inProgressSurferPromise = null;
+        }
+      };
+      addListener(pixelDetailsReceiver);
+    }, _index.SURFER_TIMEOUT_MS);
+  });
+  return inProgressSurferPromise;
+};
+const collectSurferId = function collectSurferId(cookieManager, getBrowser, resolveSurferIdIfNotAvailable = true) {
+  if (getBrowser) {
+    const areThirdPartyCookiesSupportedByDefault = (0, _index2.injectAreThirdPartyCookiesSupportedByDefault)({
+      getBrowser
+    });
+    if (!areThirdPartyCookiesSupportedByDefault()) {
+      return Promise.resolve(null);
+    }
+  }
+  if (surferId && surferId !== "") {
+    return Promise.resolve(surferId);
+  }
+  if (cookieManager) {
+    const cookieSurferId = cookieManager.getValue(_index.SURFER_ID);
+    if (cookieSurferId) {
+      surferId = cookieSurferId;
+      return Promise.resolve(cookieSurferId);
+    }
+  }
+  if (resolveSurferIdIfNotAvailable) {
+    return initiateAdvertisingIdentityCall().then(resolvedId => {
+      if (cookieManager && resolvedId) {
+        if (resolvedId.surferId) {
+          cookieManager.setValue(_index.SURFER_ID, resolvedId.surferId);
+        }
+        if (resolvedId.displayClickCookie) {
+          cookieManager.setValue(_index.DISPLAY_CLICK_COOKIE_KEY, resolvedId.displayClickCookie);
+          cookieManager.setValue(_index.DISPLAY_CLICK_COOKIE_KEY_EXPIRES, Date.now() + 15 * 60 * 1000);
+        }
+      }
+      return resolvedId.surferId;
+    });
+  }
+  return Promise.resolve(null);
+};
+var _default = exports.default = collectSurferId;

package/libEs5/components/Advertising/index.js

@@ -0,0 +1,52 @@
+"use strict";
+
+exports.default = void 0;
+var _createComponent = require("./createComponent.js");
+var _configValidators = require("./configValidators.js");
+var _index = require("../../utils/request/index.js");
+var _createAdConversionHandler = require("./handlers/createAdConversionHandler.js");
+var _advertisingCookieManager = require("./utils/advertisingCookieManager.js");
+/*
+Copyright 2023 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+const createAdvertising = ({
+  logger,
+  config,
+  eventManager,
+  sendEdgeNetworkRequest,
+  consent,
+  getBrowser
+}) => {
+  const cookieManager = (0, _advertisingCookieManager.default)({
+    orgId: config.orgId,
+    logger
+  });
+  const adConversionHandler = (0, _createAdConversionHandler.default)({
+    eventManager,
+    sendEdgeNetworkRequest,
+    consent,
+    createDataCollectionRequest: _index.createDataCollectionRequest,
+    createDataCollectionRequestPayload: _index.createDataCollectionRequestPayload,
+    logger
+  });
+  return (0, _createComponent.default)({
+    logger,
+    config,
+    eventManager,
+    cookieManager,
+    adConversionHandler,
+    getBrowser
+  });
+};
+createAdvertising.namespace = "Advertising";
+createAdvertising.configValidators = _configValidators.default;
+var _default = exports.default = createAdvertising;

package/libEs5/components/Advertising/utils/advertisingCookieManager.js

@@ -0,0 +1,80 @@
+"use strict";
+
+exports.default = void 0;
+var _index = require("../../../utils/index.js");
+var _createLoggingCookieJar = require("../../../utils/createLoggingCookieJar.js");
+var _index2 = require("../constants/index.js");
+/*
+Copyright 2025 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+var _default = ({
+  orgId,
+  logger
+}) => {
+  const loggingCookieJar = (0, _createLoggingCookieJar.default)({
+    logger,
+    cookieJar: _index.cookieJar
+  });
+  const getCookieName = (key, useNamespace = true) => useNamespace ? (0, _index.getNamespacedCookieName)(orgId, key) : key;
+  const getDefaultExpiration = (minutes = _index2.DEFAULT_THROTTLE_MINUTES) => new Date(Date.now() + minutes * 60 * 1000);
+  const safeJsonParse = value => {
+    try {
+      if (value?.startsWith("%7B") || value?.startsWith("{")) {
+        return JSON.parse(decodeURIComponent(value));
+      }
+    } catch {
+      // pass
+    }
+    return value;
+  };
+  const safeJsonStringify = value => typeof value === "object" && value !== null ? encodeURIComponent(JSON.stringify(value)) : value;
+  const readCookie = (key, useNamespace = true) => {
+    try {
+      const name = getCookieName(key, useNamespace);
+      const value = loggingCookieJar.get(name);
+      return value ? safeJsonParse(value) : null;
+    } catch (error) {
+      logger.error("Error reading cookie: " + key, error);
+      return null;
+    }
+  };
+  const writeCookie = (key, value, options = {}, useNamespace = true) => {
+    try {
+      const name = getCookieName(key, useNamespace);
+      const storedValue = safeJsonStringify(value);
+      loggingCookieJar.set(name, storedValue, options);
+      return true;
+    } catch (error) {
+      logger.error("Error writing cookie: " + key, error);
+      return false;
+    }
+  };
+  const setValue = (key, value, options = {}) => {
+    const existing = readCookie(_index2.ADVERTISING_COOKIE_KEY) || {};
+    const updated = {
+      ...existing,
+      [key]: value
+    };
+    return writeCookie(_index2.ADVERTISING_COOKIE_KEY, updated, {
+      expires: getDefaultExpiration(_index2.DEFAULT_COOKIE_EXPIRATION_MINUTES),
+      ...options
+    });
+  };
+  const getValue = key => {
+    const data = readCookie(_index2.ADVERTISING_COOKIE_KEY) || {};
+    return data[key];
+  };
+  return {
+    setValue,
+    getValue
+  };
+};
+exports.default = _default;

package/libEs5/components/Advertising/utils/helpers.js

@@ -0,0 +1,123 @@
+"use strict";
+
+exports.shouldThrottle = exports.normalizeAdvertiser = exports.markIdsAsConverted = exports.isThrottled = exports.isAnyIdUnused = exports.getUrlParams = exports.createManagedAsyncOperation = exports.appendAdvertisingIdQueryToEvent = void 0;
+var _index = require("../constants/index.js");
+var _index2 = require("../../../utils/index.js");
+/*
+Copyright 2025 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+const getUrlParams = () => {
+  const parsedParams = _index2.queryString.parse(window.location.search);
+  return {
+    skwcid: parsedParams[_index.SKWCID_PARAM],
+    // "s_kwcid"
+    efid: parsedParams[_index.EFID_PARAM] // "ef_id"
+  };
+};
+
+/**
+ * Manages a single, ongoing asynchronous operation to prevent redundant calls.
+ * @param {string} operationName - A name for the operation for logging purposes.
+ * @param {Function} workerFn - A function that returns a Promise to be executed.
+ * @returns {Function} A function that, when called, will either start the worker or return the in-progress promise.
+ */
+exports.getUrlParams = getUrlParams;
+const createManagedAsyncOperation = (operationName, workerFn) => {
+  let inProgressPromise = null;
+  return (...args) => {
+    if (inProgressPromise) {
+      return inProgressPromise;
+    }
+    inProgressPromise = workerFn(...args).finally(() => {
+      inProgressPromise = null;
+    });
+    return inProgressPromise;
+  };
+};
+
+/**
+ * Normalizes advertiser settings - extracts enabled advertiser IDs
+ * @param {Object[]} advertiserSettings - Array of advertiserSettings objects with advertiserId and enabled properties
+ * @returns {string} Comma-separated string of enabled advertiser IDs
+ */
+exports.createManagedAsyncOperation = createManagedAsyncOperation;
+const normalizeAdvertiser = advertiserSettings => {
+  if (!advertiserSettings || !Array.isArray(advertiserSettings)) {
+    return _index.UNKNOWN_ADVERTISER;
+  }
+  return advertiserSettings.filter(item => item && item.enabled === true && item.advertiserId).map(item => item.advertiserId).join(", ");
+};
+exports.normalizeAdvertiser = normalizeAdvertiser;
+const appendAdvertisingIdQueryToEvent = (idsToInclude, event, cookieManager, componentConfig, addEventType = false) => {
+  const searchClickData = cookieManager.getValue(_index.LAST_CLICK_COOKIE_KEY);
+  let displayClickCookie = null;
+  const displayClickCookieExpires = cookieManager.getValue(_index.DISPLAY_CLICK_COOKIE_KEY_EXPIRES);
+  if (displayClickCookieExpires && displayClickCookieExpires > Date.now()) {
+    displayClickCookie = cookieManager.getValue(_index.DISPLAY_CLICK_COOKIE_KEY);
+  }
+  const query = {
+    advertising: {
+      ...(searchClickData?.click_time && {
+        lastSearchClick: searchClickData.click_time
+      }),
+      ...(displayClickCookie && {
+        lastDisplayClick: displayClickCookie
+      }),
+      stitchIds: {
+        ...(idsToInclude[_index.SURFER_ID] && {
+          surferId: idsToInclude[_index.SURFER_ID]
+        }),
+        ...(idsToInclude[_index.ID5_ID] && {
+          id5: idsToInclude[_index.ID5_ID]
+        }),
+        ...(idsToInclude[_index.RAMP_ID] && {
+          rampIdEnv: idsToInclude[_index.RAMP_ID]
+        }),
+        ipAddress: "DUMMY_IP_ADDRESS"
+      },
+      advIds: normalizeAdvertiser(componentConfig.advertiserSettings),
+      ...(addEventType && {
+        eventType: _index.AD_CONVERSION_VIEW_EVENT_TYPE
+      })
+    }
+  };
+  event.mergeQuery(query);
+  return event;
+};
+exports.appendAdvertisingIdQueryToEvent = appendAdvertisingIdQueryToEvent;
+const isAnyIdUnused = (availableIds, conversionCalled) => {
+  return Object.entries(availableIds).some(([idType]) => {
+    return !conversionCalled[idType];
+  });
+};
+exports.isAnyIdUnused = isAnyIdUnused;
+const markIdsAsConverted = (idTypes, conversionCalled, cookieManager, logger) => {
+  const now = Date.now();
+  idTypes.forEach(idType => {
+    conversionCalled[idType] = true;
+    cookieManager.setValue(idType + "_last_conversion", now);
+    logger.info(_index.LOG_ID_CONVERSION_SUCCESS.replace("{0}", idType));
+  });
+  cookieManager.setValue(_index.LAST_CONVERSION_TIME_KEY, now);
+};
+exports.markIdsAsConverted = markIdsAsConverted;
+const isThrottled = (idType, cookieManager) => {
+  const now = Date.now();
+  const THROTTLE_WINDOW = 30 * 60 * 1000; // 30 minutes
+  const lastSuccessfulConversion = cookieManager.getValue(idType + "_last_conversion");
+  return Boolean(lastSuccessfulConversion && now - lastSuccessfulConversion < THROTTLE_WINDOW);
+};
+exports.isThrottled = isThrottled;
+const shouldThrottle = (idType, cookieManager) => {
+  return isThrottled(idType, cookieManager);
+};
+exports.shouldThrottle = shouldThrottle;

package/libEs5/components/DataCollector/validateUserEventOptions.js

@@ -3,6 +3,7 @@
 exports.default = void 0;
 var _index = require("../../utils/validation/index.js");
 var _index2 = require("../../utils/index.js");
+var _consentStatus = require("../../constants/consentStatus.js");
 /*
 Copyright 2020 Adobe. All rights reserved.
 This file is licensed to you under the Apache License, Version 2.0 (the "License");
@@ -44,7 +45,10 @@ var _default = ({
     }),
     datasetId: (0, _index.string)(),
     mergeId: (0, _index.string)(),
-    edgeConfigOverrides: _index2.validateConfigOverride
+    edgeConfigOverrides: _index2.validateConfigOverride,
+    advertising: (0, _index.objectOf)({
+      handleAdvertisingData: (0, _index.enumOf)(_consentStatus.DISABLED, _consentStatus.WAIT, _consentStatus.AUTO).default(_consentStatus.DISABLED)
+    })
   }).required().noUnknownFields();
   return eventOptionsValidator(options);
 };

package/libEs5/constants/consentStatus.js

@@ -1,6 +1,6 @@
 "use strict";
 
-exports.PENDING = exports.OUT = exports.IN = void 0;
+exports.WAIT = exports.PENDING = exports.OUT = exports.IN = exports.DISABLED = exports.AUTO = void 0;
 /*
 Copyright 2020 Adobe. All rights reserved.
 This file is licensed to you under the Apache License, Version 2.0 (the "License");
@@ -15,4 +15,7 @@ governing permissions and limitations under the License.
 
 const IN = exports.IN = "in";
 const OUT = exports.OUT = "out";
-const PENDING = exports.PENDING = "pending";
+const PENDING = exports.PENDING = "pending";
+const DISABLED = exports.DISABLED = "disabled";
+const WAIT = exports.WAIT = "wait";
+const AUTO = exports.AUTO = "auto";

package/libEs5/constants/libraryVersion.js

@@ -14,4 +14,4 @@ governing permissions and limitations under the License.
 */
 // The __VERSION__ keyword will be replace at alloy build time with the package.json version.
 // see babel-plugin-version
-var _default = exports.default = "2.28.1";
+var _default = exports.default = "2.29.0-beta.0";

package/libEs5/core/componentCreators.js

@@ -6,6 +6,12 @@ Object.defineProperty(exports, "activityCollector", {
     return _index.default;
   }
 });
+Object.defineProperty(exports, "advertising", {
+  enumerable: true,
+  get: function () {
+    return _index9.default;
+  }
+});
 Object.defineProperty(exports, "audiences", {
   enumerable: true,
   get: function () {
@@ -55,4 +61,5 @@ var _index4 = require("../components/EventMerge/index.js");
 var _index5 = require("../components/MediaAnalyticsBridge/index.js");
 var _index6 = require("../components/Personalization/index.js");
 var _index7 = require("../components/RulesEngine/index.js");
-var _index8 = require("../components/StreamingMedia/index.js");
+var _index8 = require("../components/StreamingMedia/index.js");
+var _index9 = require("../components/Advertising/index.js");

package/libEs5/utils/dom/index.js

@@ -18,6 +18,12 @@ Object.defineProperty(exports, "createNode", {
     return _createNode.default;
   }
 });
+Object.defineProperty(exports, "loadScript", {
+  enumerable: true,
+  get: function () {
+    return _loadScript.default;
+  }
+});
 Object.defineProperty(exports, "matchesSelector", {
   enumerable: true,
   get: function () {
@@ -51,6 +57,7 @@ Object.defineProperty(exports, "selectNodesWithShadow", {
 var _awaitSelector = require("./awaitSelector.js");
 var _appendNode = require("./appendNode.js");
 var _createNode = require("./createNode.js");
+var _loadScript = require("./loadScript.js");
 var _matchesSelector = require("./matchesSelector.js");
 var _querySelectorAll = require("./querySelectorAll.js");
 var _removeNode = require("./removeNode.js");