@adobe/alloy 2.28.1 → 2.29.0-beta.0

package/libEs6/components/Advertising/identities/collectID5Id.js

@@ -0,0 +1,108 @@
+/*
+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.
+*/
+import { loadScript } from "../../../utils/dom/index.js";
+import { ID5_SCRIPT_URL } from "../constants/index.js";
+let id5Id = "";
+let inProgressId5Promise = null;
+const SHORT_TIMEOUT_MS = 5000;
+const DEFAULT_TIMEOUT_MS = 30000;
+const initiateID5Call = (partnerId, useShortTimeout, logger) => {
+  partnerId = Math.floor(Number(partnerId));
+  if (inProgressId5Promise) {
+    return inProgressId5Promise;
+  }
+  const timeoutMs = useShortTimeout ? SHORT_TIMEOUT_MS : DEFAULT_TIMEOUT_MS;
+  let iD5TimedOut = false;
+  const id5ResolutionPromise = new Promise((resolve, reject) => {
+    if (!partnerId) {
+      logger.error("Missing partner ID");
+      reject(new Error("ID5 partner ID is required"));
+      return;
+    }
+    const handleId5 = () => {
+      try {
+        if (typeof window.ID5 === "undefined") {
+          reject(new Error("ID5 object not available after script load"));
+          return;
+        }
+        const id5Instance = window.ID5.init({
+          partnerId
+        });
+        id5Id = id5Instance.getUserId();
+        const safeResolve = val => {
+          if (!iD5TimedOut) resolve(val);
+        };
+        if (!id5Id) {
+          window.ID5.init({
+            partnerId
+          }).onAvailable(function firstRetry(retryStatus) {
+            id5Id = retryStatus.getUserId();
+            if (id5Id) {
+              safeResolve(id5Id);
+            } else {
+              window.ID5.init({
+                partnerId
+              }).onAvailable(function secondRetry(secondRetryStatus) {
+                id5Id = secondRetryStatus.getUserId();
+                if (id5Id) {
+                  safeResolve(id5Id);
+                } else {
+                  logger.error("Failed to get ID5 ID after all retries");
+                  safeResolve(null);
+                }
+              });
+            }
+          }, 1000);
+        } else {
+          safeResolve(id5Id);
+        }
+      } catch (error) {
+        logger.error("Error during ID5 initialization", error);
+        reject(error);
+      }
+    };
+    if (typeof window.ID5 !== "undefined") {
+      handleId5();
+    } else {
+      loadScript(ID5_SCRIPT_URL, {
+        onLoad: handleId5,
+        onError: error => {
+          logger.error("Script loading failed", error);
+          reject(error);
+        }
+      });
+    }
+  });
+  const timeoutPromise = new Promise(resolve => {
+    setTimeout(() => {
+      iD5TimedOut = true;
+      resolve(null);
+    }, timeoutMs);
+  });
+  inProgressId5Promise = Promise.race([id5ResolutionPromise, timeoutPromise]).finally(() => {
+    inProgressId5Promise = null;
+  });
+  return inProgressId5Promise;
+};
+const getID5Id = function getID5Id(logger, partnerId, resolveId5IfNotAvailable = true, useShortTimeout = false) {
+  if (id5Id && id5Id !== "") {
+    return Promise.resolve(id5Id);
+  }
+  if (!resolveId5IfNotAvailable) {
+    return Promise.resolve(null);
+  }
+  return initiateID5Call(partnerId, useShortTimeout, logger).then(resolvedId => resolvedId).catch(error => {
+    logger.error("Failed to get ID5 ID", error);
+    throw error;
+  });
+};
+export { getID5Id, initiateID5Call };

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

@@ -0,0 +1,179 @@
+/*
+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.
+*/
+
+import { loadScript } from "../../../utils/dom/index.js";
+import { RAMP_ID, RAMP_ID_EXPIRES } from "../constants/index.js";
+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(RAMP_ID, state.rampIdEnv);
+    cookieManager.setValue(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) => {
+    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;
+};
+const getRampId = (logger, rampIdScriptPath, cookieManager, resolveRampIdIfNotAvailable = true, useShortTimeout = false) => {
+  if (state.rampIdEnv) {
+    return Promise.resolve(state.rampIdEnv);
+  }
+  if (cookieManager) {
+    const rampIdFromCookie = cookieManager.getValue(RAMP_ID);
+    const rampIdExpires = cookieManager.getValue(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);
+};
+export { getRampId, initiateRampIDCall };

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

@@ -0,0 +1,143 @@
+/*
+Copyright 2025 Adobe. All rights reserved.
+This file is licensed under the Apache License, Version 2.0.
+*/
+
+import { DISPLAY_CLICK_COOKIE_KEY, SURFER_ID, SURFER_PIXEL_HOST, SURFER_USER_ID, SURFER_TIMEOUT_MS, SURFER_TRUSTED_ORIGIN, SURFER_PARAM_KEY, DISPLAY_CLICK_COOKIE_KEY_EXPIRES } from "../constants/index.js";
+import createNode from "../../../utils/dom/createNode.js";
+import { injectAreThirdPartyCookiesSupportedByDefault } from "../../../utils/index.js";
+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 => createNode("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}//${SURFER_PIXEL_HOST}/${SURFER_USER_ID}/gr?${mainParams.toString()}`;
+      const iframeElement = getInvisibleIframeElement(pixelDetailsUrl);
+      addToDom(iframeElement);
+      const pixelDetailsReceiver = function pixelDetailsReceiver(message) {
+        if (!message.origin.includes(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(SURFER_PARAM_KEY);
+          if (surferValue) {
+            resolvedSurferId = surferValue;
+          }
+          const displayClickValue = hashParams.get(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);
+    }, SURFER_TIMEOUT_MS);
+  });
+  return inProgressSurferPromise;
+};
+const collectSurferId = function collectSurferId(cookieManager, getBrowser, resolveSurferIdIfNotAvailable = true) {
+  if (getBrowser) {
+    const areThirdPartyCookiesSupportedByDefault = injectAreThirdPartyCookiesSupportedByDefault({
+      getBrowser
+    });
+    if (!areThirdPartyCookiesSupportedByDefault()) {
+      return Promise.resolve(null);
+    }
+  }
+  if (surferId && surferId !== "") {
+    return Promise.resolve(surferId);
+  }
+  if (cookieManager) {
+    const cookieSurferId = cookieManager.getValue(SURFER_ID);
+    if (cookieSurferId) {
+      surferId = cookieSurferId;
+      return Promise.resolve(cookieSurferId);
+    }
+  }
+  if (resolveSurferIdIfNotAvailable) {
+    return initiateAdvertisingIdentityCall().then(resolvedId => {
+      if (cookieManager && resolvedId) {
+        if (resolvedId.surferId) {
+          cookieManager.setValue(SURFER_ID, resolvedId.surferId);
+        }
+        if (resolvedId.displayClickCookie) {
+          cookieManager.setValue(DISPLAY_CLICK_COOKIE_KEY, resolvedId.displayClickCookie);
+          cookieManager.setValue(DISPLAY_CLICK_COOKIE_KEY_EXPIRES, Date.now() + 15 * 60 * 1000);
+        }
+      }
+      return resolvedId.surferId;
+    });
+  }
+  return Promise.resolve(null);
+};
+export default collectSurferId;

package/libEs6/components/Advertising/index.js

@@ -0,0 +1,49 @@
+/*
+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.
+*/
+
+import createComponent from "./createComponent.js";
+import configValidators from "./configValidators.js";
+import { createDataCollectionRequest, createDataCollectionRequestPayload } from "../../utils/request/index.js";
+import createAdConversionHandler from "./handlers/createAdConversionHandler.js";
+import createCookieManager from "./utils/advertisingCookieManager.js";
+const createAdvertising = ({
+  logger,
+  config,
+  eventManager,
+  sendEdgeNetworkRequest,
+  consent,
+  getBrowser
+}) => {
+  const cookieManager = createCookieManager({
+    orgId: config.orgId,
+    logger
+  });
+  const adConversionHandler = createAdConversionHandler({
+    eventManager,
+    sendEdgeNetworkRequest,
+    consent,
+    createDataCollectionRequest,
+    createDataCollectionRequestPayload,
+    logger
+  });
+  return createComponent({
+    logger,
+    config,
+    eventManager,
+    cookieManager,
+    adConversionHandler,
+    getBrowser
+  });
+};
+createAdvertising.namespace = "Advertising";
+createAdvertising.configValidators = configValidators;
+export default createAdvertising;

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

@@ -0,0 +1,77 @@
+/*
+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.
+*/
+
+import { getNamespacedCookieName, cookieJar } from "../../../utils/index.js";
+import createLoggingCookieJar from "../../../utils/createLoggingCookieJar.js";
+import { ADVERTISING_COOKIE_KEY, DEFAULT_COOKIE_EXPIRATION_MINUTES, DEFAULT_THROTTLE_MINUTES } from "../constants/index.js";
+export default ({
+  orgId,
+  logger
+}) => {
+  const loggingCookieJar = createLoggingCookieJar({
+    logger,
+    cookieJar
+  });
+  const getCookieName = (key, useNamespace = true) => useNamespace ? getNamespacedCookieName(orgId, key) : key;
+  const getDefaultExpiration = (minutes = 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(ADVERTISING_COOKIE_KEY) || {};
+    const updated = {
+      ...existing,
+      [key]: value
+    };
+    return writeCookie(ADVERTISING_COOKIE_KEY, updated, {
+      expires: getDefaultExpiration(DEFAULT_COOKIE_EXPIRATION_MINUTES),
+      ...options
+    });
+  };
+  const getValue = key => {
+    const data = readCookie(ADVERTISING_COOKIE_KEY) || {};
+    return data[key];
+  };
+  return {
+    setValue,
+    getValue
+  };
+};

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

@@ -0,0 +1,113 @@
+/*
+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.
+*/
+
+import { SKWCID_PARAM, EFID_PARAM, UNKNOWN_ADVERTISER, LAST_CLICK_COOKIE_KEY, LOG_ID_CONVERSION_SUCCESS, LAST_CONVERSION_TIME_KEY, DISPLAY_CLICK_COOKIE_KEY, AD_CONVERSION_VIEW_EVENT_TYPE, SURFER_ID, ID5_ID, RAMP_ID, DISPLAY_CLICK_COOKIE_KEY_EXPIRES } from "../constants/index.js";
+import { queryString } from "../../../utils/index.js";
+const getUrlParams = () => {
+  const parsedParams = queryString.parse(window.location.search);
+  return {
+    skwcid: parsedParams[SKWCID_PARAM],
+    // "s_kwcid"
+    efid: parsedParams[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.
+ */
+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
+ */
+const normalizeAdvertiser = advertiserSettings => {
+  if (!advertiserSettings || !Array.isArray(advertiserSettings)) {
+    return UNKNOWN_ADVERTISER;
+  }
+  return advertiserSettings.filter(item => item && item.enabled === true && item.advertiserId).map(item => item.advertiserId).join(", ");
+};
+const appendAdvertisingIdQueryToEvent = (idsToInclude, event, cookieManager, componentConfig, addEventType = false) => {
+  const searchClickData = cookieManager.getValue(LAST_CLICK_COOKIE_KEY);
+  let displayClickCookie = null;
+  const displayClickCookieExpires = cookieManager.getValue(DISPLAY_CLICK_COOKIE_KEY_EXPIRES);
+  if (displayClickCookieExpires && displayClickCookieExpires > Date.now()) {
+    displayClickCookie = cookieManager.getValue(DISPLAY_CLICK_COOKIE_KEY);
+  }
+  const query = {
+    advertising: {
+      ...(searchClickData?.click_time && {
+        lastSearchClick: searchClickData.click_time
+      }),
+      ...(displayClickCookie && {
+        lastDisplayClick: displayClickCookie
+      }),
+      stitchIds: {
+        ...(idsToInclude[SURFER_ID] && {
+          surferId: idsToInclude[SURFER_ID]
+        }),
+        ...(idsToInclude[ID5_ID] && {
+          id5: idsToInclude[ID5_ID]
+        }),
+        ...(idsToInclude[RAMP_ID] && {
+          rampIdEnv: idsToInclude[RAMP_ID]
+        }),
+        ipAddress: "DUMMY_IP_ADDRESS"
+      },
+      advIds: normalizeAdvertiser(componentConfig.advertiserSettings),
+      ...(addEventType && {
+        eventType: AD_CONVERSION_VIEW_EVENT_TYPE
+      })
+    }
+  };
+  event.mergeQuery(query);
+  return event;
+};
+const isAnyIdUnused = (availableIds, conversionCalled) => {
+  return Object.entries(availableIds).some(([idType]) => {
+    return !conversionCalled[idType];
+  });
+};
+const markIdsAsConverted = (idTypes, conversionCalled, cookieManager, logger) => {
+  const now = Date.now();
+  idTypes.forEach(idType => {
+    conversionCalled[idType] = true;
+    cookieManager.setValue(`${idType}_last_conversion`, now);
+    logger.info(LOG_ID_CONVERSION_SUCCESS.replace("{0}", idType));
+  });
+  cookieManager.setValue(LAST_CONVERSION_TIME_KEY, now);
+};
+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);
+};
+const shouldThrottle = (idType, cookieManager) => {
+  return isThrottled(idType, cookieManager);
+};
+export { getUrlParams, normalizeAdvertiser, createManagedAsyncOperation, appendAdvertisingIdQueryToEvent, isAnyIdUnused, markIdsAsConverted, isThrottled, shouldThrottle };

package/libEs6/components/DataCollector/validateUserEventOptions.js

@@ -10,8 +10,9 @@ OF ANY KIND, either express or implied. See the License for the specific languag
 governing permissions and limitations under the License.
 */
 
-import { string, objectOf, boolean, arrayOf } from "../../utils/validation/index.js";
+import { string, objectOf, boolean, arrayOf, enumOf } from "../../utils/validation/index.js";
 import { validateConfigOverride, validateIdentityMap } from "../../utils/index.js";
+import { DISABLED, WAIT, AUTO } from "../../constants/consentStatus.js";
 /**
  * Verifies user provided event options.
  * @param {*} options The user event options to validate
@@ -42,7 +43,10 @@ export default ({
     }),
     datasetId: string(),
     mergeId: string(),
-    edgeConfigOverrides: validateConfigOverride
+    edgeConfigOverrides: validateConfigOverride,
+    advertising: objectOf({
+      handleAdvertisingData: enumOf(DISABLED, WAIT, AUTO).default(DISABLED)
+    })
   }).required().noUnknownFields();
   return eventOptionsValidator(options);
 };