@adobe/alloy 2.26.0 → 2.27.0-beta.1

package/libEs6/components/Consent/computeConsentHash.js

@@ -10,21 +10,5 @@ OF ANY KIND, either express or implied. See the License for the specific languag
 governing permissions and limitations under the License.
 */
 
-import { crc32 } from "../../utils/index.js";
-
-// serialize an object with a consistent ordering
-const serialize = obj => {
-  if (Array.isArray(obj)) {
-    return obj.map(i => serialize(i));
-  }
-  if (typeof obj === "object" && obj !== null) {
-    return Object.keys(obj).sort().reduce((memo, key) => {
-      memo[key] = serialize(obj[key]);
-      return memo;
-    }, {});
-  }
-  return obj;
-};
-export default obj => {
-  return crc32(JSON.stringify(serialize(obj)));
-};
+import { fnv1a32Hex, sortObjectKeysRecursively } from "../../utils/index.js";
+export default obj => fnv1a32Hex(JSON.stringify(sortObjectKeysRecursively(obj)));

package/libEs6/components/Context/injectHighEntropyUserAgentHints.js

@@ -13,7 +13,7 @@ governing permissions and limitations under the License.
 import { deepAssign, noop } from "../../utils/index.js";
 import highEntropyUserAgentHints from "../../constants/highEntropyUserAgentClientHints.js";
 const browserSupportsUserAgentClientHints = navigator => {
-  return typeof navigator.userAgentData !== "undefined";
+  return "userAgentData" in navigator;
 };
 export default navigator => {
   if (!browserSupportsUserAgentClientHints(navigator)) {
@@ -21,6 +21,7 @@ export default navigator => {
   }
   return (xdm, logger) => {
     try {
+      // eslint-disable-next-line compat/compat -- userAgentData support is checked before calling
       return navigator.userAgentData.getHighEntropyValues(highEntropyUserAgentHints.map(hint => hint[0])).then(hints => {
         const userAgentClientHints = {};
         highEntropyUserAgentHints.forEach(([hintName, hintType]) => {

package/libEs6/components/DataCollector/validateUserEventOptions.js

@@ -42,8 +42,7 @@ export default ({
     }),
     datasetId: string(),
     mergeId: string(),
-    edgeConfigOverrides: validateConfigOverride,
-    initializePersonalization: boolean()
+    edgeConfigOverrides: validateConfigOverride
   }).required().noUnknownFields();
   return eventOptionsValidator(options);
 };

package/libEs6/components/Personalization/dom-actions/action.js

@@ -24,26 +24,62 @@ export { default as setStyles } from "./setStyles.js";
 export { default as setAttributes } from "./setAttributes.js";
 export { default as swapImage } from "./swapImage.js";
 export { default as rearrangeChildren } from "./rearrangeChildren.js";
-const renderContent = (elements, content, decorateProposition, renderFunc) => {
-  const executions = elements.map(element => renderFunc(element, content, decorateProposition));
+
+/**
+ * Renders content into a container element.
+ *
+ * @param {Object} params
+ * @param {Element[]} params.containers
+ * @param {string} params.content
+ * @param {(element: Element) => void} params.decorateProposition
+ * @param {(container: Element, content: string, decorateProposition: (element: Element) => void) => Promise<void>} params.renderFunc
+ * @returns {Promise<void>} A promise that resolves when the content is rendered.
+ */
+const renderContent = ({
+  containers,
+  content,
+  decorateProposition,
+  renderFunc,
+  renderStatusHandler
+}) => {
+  const executions = containers.filter(renderStatusHandler.shouldRender).map(async container => {
+    await renderFunc(container, content, decorateProposition);
+    renderStatusHandler.markAsRendered(container);
+  });
   return Promise.all(executions);
 };
+
+/**
+ * Creates an action function that renders content into a container element.
+ *
+ * @param {Function} renderFunc - The function that performs the rendering.
+ */
 export const createAction = renderFunc => {
-  return (itemData, decorateProposition) => {
+  /**
+   * Renders content into a container element.
+   *
+   * @param {{ selector: string, prehidingSelector: string, content: string }} itemData - The item data containing the container selector and prehiding selector.
+   * @param {(element: Element) => void} createDecorateProposition
+   * @param {{ shouldRender: (element: Element) => boolean, markAsRendered: (element: Element) => void }} renderStatusHandler
+   */
+  return async (itemData, decorateProposition, renderStatusHandler) => {
     const {
-      selector,
+      selector: containerSelector,
       prehidingSelector,
       content
     } = itemData;
     hideElements(prehidingSelector);
-    return awaitSelector(selector, selectNodesWithEq).then(elements => renderContent(elements, content, decorateProposition, renderFunc)).then(() => {
-      // if everything is OK, show elements
-      showElements(prehidingSelector);
-    }, error => {
-      // in case of awaiting timing or error, we need to remove the style tag
-      // hence showing the pre-hidden elements
+    try {
+      const containers = await awaitSelector(containerSelector, selectNodesWithEq);
+      renderContent({
+        containers,
+        content,
+        decorateProposition,
+        renderFunc,
+        renderStatusHandler
+      });
+    } finally {
       showElements(prehidingSelector);
-      throw error;
-    });
+    }
   };
 };

package/libEs6/components/Personalization/dom-actions/clicks/collectInteractions.js

@@ -23,7 +23,7 @@ const getInteractionDetail = clickedElement => {
   const interactIds = new Set();
   let clickLabel;
   let clickToken;
-  while (element && element !== documentElement) {
+  while (element && element !== documentElement && !(element instanceof ShadowRoot)) {
     const interactId = getAttribute(element, INTERACT_ID_DATA_ATTRIBUTE);
     if (interactId) {
       interactIds.add(interactId);

package/libEs6/components/Personalization/handlers/createProcessDomAction.js

@@ -11,6 +11,7 @@ governing permissions and limitations under the License.
 */
 
 import createDecorateProposition from "./createDecorateProposition.js";
+import createRenderStatusHandler from "./createRenderStatusHandler.js";
 import { DOM_ACTION_CLICK } from "../dom-actions/initDomActionsModules.js";
 export default ({
   modules,
@@ -58,9 +59,10 @@ export default ({
       includeInNotification: false
     };
   }
+  const renderStatusHandler = createRenderStatusHandler(item.getProposition().getScopeType(), item.getId());
   const decorateProposition = createDecorateProposition(autoCollectPropositionInteractions, type, item.getProposition().getId(), item.getId(), item.getTrackingLabel(), item.getProposition().getScopeType(), item.getProposition().getNotification(), storeInteractionMeta);
   return {
-    render: () => modules[type](item.getData(), decorateProposition),
+    render: () => modules[type](item.getData(), decorateProposition, renderStatusHandler),
     setRenderAttempted: true,
     includeInNotification: true
   };

package/libEs6/components/Personalization/handlers/createRenderStatusHandler.js

@@ -0,0 +1,56 @@
+/*
+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 { VIEW_SCOPE_TYPE } from "../constants/scopeType.js";
+
+/**
+ * Creates a handler to manage the rendering status of elements in personalization
+ *
+ * @param {string} scopeType - The type of scope (e.g. 'view', 'page')
+ * @param {string} itemId - The unique identifier for the item being rendered
+ */
+export default (scopeType, itemId) => {
+  // We only care about tracking renders for view scope
+  if (scopeType !== VIEW_SCOPE_TYPE) {
+    return {
+      shouldRender: () => true,
+      markAsRendered: () => {}
+    };
+  }
+  return {
+    /**
+     * Determines if an element should be rendered based on scopeType and previous render status
+     *
+     * @param {Element|null} propositionContainer - The DOM element to check
+     * @returns {boolean} True if the element should be rendered, false otherwise
+     */
+    shouldRender: propositionContainer => {
+      if (!propositionContainer) {
+        return true;
+      }
+      const previouslyRendered = (propositionContainer.dataset.adobePropositionIds ?? "").split(",");
+      return !previouslyRendered.includes(itemId);
+    },
+    /**
+     * Marks an element as rendered by setting a data attribute
+     *
+     * @param {Element} propositionContainer - The DOM element to mark as rendered
+     * @returns {void}
+     */
+    markAsRendered: propositionContainer => {
+      const previouslyRendered = (propositionContainer.dataset.adobePropositionIds ?? "").split(",");
+      if (!previouslyRendered.includes(itemId)) {
+        previouslyRendered.push(itemId);
+      }
+      propositionContainer.dataset.adobePropositionIds = previouslyRendered.sort().join(",");
+    }
+  };
+};

package/libEs6/components/Personalization/in-app-message-actions/actions/displayIframeContent.js

@@ -94,10 +94,7 @@ const renderMessage = (iframe, webParameters, container, overlay) => {
       style = {},
       params = {}
     } = webParameters[id];
-    element.style = {
-      ...element.style,
-      ...style
-    };
+    Object.assign(element.style, style);
     const {
       parentElement = "body",
       insertionMethod = "appendChild",

package/libEs6/components/RulesEngine/constants/index.js

@@ -0,0 +1,15 @@
+/*
+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.
+*/
+export const EVENT_HISTORY_MAX_RECORDS = 1000;
+export const EVENT_HISTORY_RETENTION_PERIOD = 30; // 30 days
+export const EVENT_HISTORY_STORAGE_KEY = "events";
+export const EVENT_HISTORY_MAX_LENGTH = 2 * 1024 * 1024; // 2MB

package/libEs6/components/RulesEngine/createDecisionProvider.js

@@ -10,21 +10,17 @@ OF ANY KIND, either express or implied. See the License for the specific languag
 governing permissions and limitations under the License.
 */
 import createEvaluableRulesetPayload from "./createEvaluableRulesetPayload.js";
-import createDecisionHistory from "./createDecisionHistory.js";
-import { getActivityId } from "./utils.js";
+import { getActivityId } from "./utils/index.js";
 export default ({
   eventRegistry
 }) => {
   const payloadsBasedOnActivityId = {};
-  const decisionHistory = createDecisionHistory({
-    eventRegistry
-  });
   const addPayload = payload => {
     const activityId = getActivityId(payload);
     if (!activityId) {
       return;
     }
-    const evaluableRulesetPayload = createEvaluableRulesetPayload(payload, eventRegistry, decisionHistory);
+    const evaluableRulesetPayload = createEvaluableRulesetPayload(payload, eventRegistry);
     if (evaluableRulesetPayload.isEvaluable) {
       payloadsBasedOnActivityId[activityId] = evaluableRulesetPayload;
     }

package/libEs6/components/RulesEngine/createEvaluableRulesetPayload.js

@@ -12,7 +12,8 @@ governing permissions and limitations under the License.
 import RulesEngine from "@adobe/aep-rules-engine";
 import { JSON_CONTENT_ITEM, RULESET_ITEM } from "../../constants/schema.js";
 import { DISPLAY } from "../../constants/eventType.js";
-import { getActivityId } from "./utils.js";
+import { PropositionEventType } from "../../constants/propositionEventType.js";
+import { generateEventHash, getActivityId } from "./utils/index.js";
 import flattenArray from "../../utils/flattenArray.js";
 import createConsequenceAdapter from "./createConsequenceAdapter.js";
 const isRulesetItem = item => {
@@ -33,7 +34,7 @@ const isRulesetItem = item => {
     return false;
   }
 };
-export default (payload, eventRegistry, decisionHistory) => {
+export default (payload, eventRegistry) => {
   const consequenceAdapter = createConsequenceAdapter();
   const activityId = getActivityId(payload);
   const items = [];
@@ -46,15 +47,19 @@ export default (payload, eventRegistry, decisionHistory) => {
     if (!content) {
       return;
     }
-    items.push(RulesEngine(typeof content === "string" ? JSON.parse(content) : content));
+    items.push(RulesEngine(typeof content === "string" ? JSON.parse(content) : content, {
+      generateEventHash
+    }));
   };
   const evaluate = context => {
     const displayEvent = eventRegistry.getEvent(DISPLAY, activityId);
-    const displayedDate = displayEvent ? displayEvent.firstTimestamp : undefined;
+    const displayedDate = displayEvent?.timestamps[0];
     const qualifyingItems = flattenArray(items.map(item => item.execute(context))).map(consequenceAdapter).map(item => {
-      const {
-        firstTimestamp: qualifiedDate
-      } = decisionHistory.recordQualified(activityId) || {};
+      const event = eventRegistry.addEvent({
+        eventType: PropositionEventType.TRIGGER,
+        eventId: activityId
+      });
+      const qualifiedDate = event.timestamps[0];
       return {
         ...item,
         data: {

package/libEs6/components/RulesEngine/createEventRegistry.js

@@ -9,106 +9,92 @@ the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTA
 OF ANY KIND, either express or implied. See the License for the specific language
 governing permissions and limitations under the License.
 */
-import { createRestoreStorage, createSaveStorage, getExpirationDate, getActivityId, hasExperienceData, getDecisionProvider } from "./utils.js";
+import { getActivityId, hasExperienceData, getDecisionProvider, createRestoreStorage, createSaveStorage, createEventPruner, generateEventHash } from "./utils/index.js";
 import { EVENT_TYPE_TRUE } from "../../constants/eventType.js";
 import { ADOBE_JOURNEY_OPTIMIZER } from "../../constants/decisionProvider.js";
-const STORAGE_KEY = "events";
-const MAX_EVENT_RECORDS = 1000;
-const RETENTION_PERIOD = 30;
-const prefixed = key => `iam.${key}`;
-export const createEventPruner = (limit = MAX_EVENT_RECORDS, retentionPeriod = RETENTION_PERIOD) => {
-  return events => {
-    const pruned = {};
-    Object.keys(events).forEach(eventType => {
-      pruned[eventType] = {};
-      Object.values(events[eventType]).filter(entry => new Date(entry.firstTimestamp) >= getExpirationDate(retentionPeriod)).sort((a, b) => a.firstTimestamp - b.firstTimestamp).slice(-1 * limit).forEach(entry => {
-        pruned[eventType][entry.event[prefixed("id")]] = entry;
-      });
-    });
-    return pruned;
-  };
-};
+import { EVENT_HISTORY_STORAGE_KEY, EVENT_HISTORY_MAX_LENGTH } from "./constants/index.js";
 export default ({
-  storage
+  storage,
+  logger
 }) => {
   let currentStorage = storage;
   let restore;
   let save;
   let events;
+  let size;
   const setStorage = newStorage => {
     currentStorage = newStorage;
-    restore = createRestoreStorage(currentStorage, STORAGE_KEY);
-    save = createSaveStorage(currentStorage, STORAGE_KEY, createEventPruner(MAX_EVENT_RECORDS, RETENTION_PERIOD));
-    events = restore({});
+    restore = createRestoreStorage(currentStorage, EVENT_HISTORY_STORAGE_KEY);
+    save = createSaveStorage(currentStorage, EVENT_HISTORY_STORAGE_KEY);
+    [events, size] = restore({});
+    if (size > EVENT_HISTORY_MAX_LENGTH) {
+      const eventPruner = createEventPruner();
+      events = eventPruner(events);
+      save(events);
+    }
   };
   setStorage(storage);
-  const addEvent = (event, eventType, eventId, action) => {
+  const addEvent = (o = {}) => {
+    const {
+      eventType,
+      eventId
+    } = o;
     if (!eventType || !eventId) {
       return undefined;
     }
-    if (!events[eventType]) {
-      events[eventType] = {};
-    }
-    const existingEvent = events[eventType][eventId];
-    const count = existingEvent ? existingEvent.count : 0;
     const timestamp = new Date().getTime();
-    const firstTimestamp = existingEvent ? existingEvent.firstTimestamp || existingEvent.timestamp : timestamp;
-    events[eventType][eventId] = {
-      event: {
-        ...event,
-        [prefixed("id")]: eventId,
-        [prefixed("eventType")]: eventType,
-        [prefixed("action")]: action
-      },
-      firstTimestamp,
-      timestamp,
-      count: count + 1
-    };
+    const eventHash = generateEventHash(o);
+    if (!events[eventHash] || !Array.isArray(events[eventHash].timestamps)) {
+      events[eventHash] = {
+        timestamps: []
+      };
+    }
+    events[eventHash].timestamps.push(timestamp);
+    events[eventHash].timestamps.sort();
+    logger.info("[Event History] Added event for", o, "with hash", eventHash, "and timestamp", timestamp);
     save(events);
-    return events[eventType][eventId];
+    return events[eventHash];
   };
   const addExperienceEdgeEvent = event => {
     const {
-      xdm = {}
+      xdm
     } = event.getContent();
-    const {
-      _experience
-    } = xdm;
     if (!hasExperienceData(xdm)) {
       return;
     }
     const {
-      decisioning = {}
-    } = _experience;
-    const {
-      propositionEventType: propositionEventTypeObj = {},
-      propositionAction = {},
-      propositions = []
-    } = decisioning;
-    const propositionEventTypesList = Object.keys(propositionEventTypeObj);
-
-    // https://wiki.corp.adobe.com/pages/viewpage.action?spaceKey=CJM&title=Proposition+Event+Types
-    if (propositionEventTypesList.length === 0) {
-      return;
-    }
-    const validPropositionEventType = propositionEventType => propositionEventTypeObj[propositionEventType] === EVENT_TYPE_TRUE;
-    const {
-      id: action
-    } = propositionAction;
-    propositionEventTypesList.filter(validPropositionEventType).forEach(propositionEventType => {
+      _experience: {
+        decisioning: {
+          propositionEventType = {},
+          propositionAction: {
+            id: action
+          } = {},
+          propositions = []
+        } = {}
+      }
+    } = xdm;
+    Object.keys(propositionEventType).filter(eventType => propositionEventType[eventType] === EVENT_TYPE_TRUE).forEach(eventType => {
       propositions.forEach(proposition => {
         if (getDecisionProvider(proposition) !== ADOBE_JOURNEY_OPTIMIZER) {
           return;
         }
-        addEvent({}, propositionEventType, getActivityId(proposition), action);
+        addEvent({
+          eventId: getActivityId(proposition),
+          eventType,
+          action
+        });
       });
     });
   };
   const getEvent = (eventType, eventId) => {
-    if (!events[eventType]) {
+    const h = generateEventHash({
+      eventType,
+      eventId
+    });
+    if (!events[h]) {
       return undefined;
     }
-    return events[eventType][eventId];
+    return events[h];
   };
   return {
     addExperienceEdgeEvent,

package/libEs6/components/RulesEngine/index.js

@@ -18,7 +18,7 @@ import createContextProvider from "./createContextProvider.js";
 import createSubscribeRulesetItems from "./createSubscribeRulesetItems.js";
 import { CONTEXT_KEY, CONTEXT_EVENT_SOURCE, CONTEXT_EVENT_TYPE } from "./constants.js";
 import createEvaluateRulesetsCommand from "./createEvaluateRulesetsCommand.js";
-import { clearLocalStorage, createInMemoryStorage } from "./utils.js";
+import { clearLocalStorage, createInMemoryStorage } from "./utils/storage.js";
 import { objectOf, boolean } from "../../utils/validation/index.js";
 import createCollect from "../../utils/createCollect.js";
 import { mergeDecisionsMeta } from "../../utils/event.js";
@@ -27,7 +27,8 @@ const createRulesEngine = ({
   eventManager,
   createNamespacedStorage,
   consent,
-  getBrowser
+  getBrowser,
+  logger
 }) => {
   const {
     orgId,
@@ -42,7 +43,8 @@ const createRulesEngine = ({
     clearLocalStorage(storage.persistent);
   }
   const eventRegistry = createEventRegistry({
-    storage: createInMemoryStorage()
+    storage: createInMemoryStorage(),
+    logger
   });
   const decisionProvider = createDecisionProvider({
     eventRegistry

package/libEs6/components/RulesEngine/utils/createEventPruner.js

@@ -0,0 +1,54 @@
+/*
+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 { EVENT_HISTORY_MAX_RECORDS, EVENT_HISTORY_RETENTION_PERIOD } from "../constants/index.js";
+import getExpirationDate from "./getExpirationDate.js";
+
+/**
+ * Creates an event pruner function that filters events based on retention period and maximum count
+ *
+ * @param {number} [retentionPeriod=EVENT_HISTORY_RETENTION_PERIOD] - The retention period in days
+ * @param {number} [limit=EVENT_HISTORY_MAX_RECORDS] - Maximum number of events to keep
+ * @returns {Function} A function that takes an events object and returns a pruned version of it
+ * @param {Object} events - Object containing events with timestamps
+ * @returns {Object} Pruned events object with events filtered by retention period and limited to max count
+ */
+export default (retentionPeriod = EVENT_HISTORY_RETENTION_PERIOD, limit = EVENT_HISTORY_MAX_RECORDS) => events => {
+  let eventsWithHash = Object.entries(events).reduce((accumulator, [key, {
+    timestamps = []
+  }]) => {
+    timestamps.forEach(timestamp => {
+      accumulator.push({
+        key,
+        timestamp
+      });
+    });
+    return accumulator;
+  }, []);
+  const expirationDate = getExpirationDate(retentionPeriod);
+  eventsWithHash = eventsWithHash.filter(({
+    timestamp
+  }) => timestamp >= expirationDate);
+  eventsWithHash.sort((a, b) => a.timestamp - b.timestamp);
+  eventsWithHash = eventsWithHash.slice(-limit);
+  return eventsWithHash.reduce((accumulator, {
+    key,
+    timestamp
+  }) => {
+    if (!accumulator[key]) {
+      accumulator[key] = {
+        timestamps: []
+      };
+    }
+    accumulator[key].timestamps.push(timestamp);
+    return accumulator;
+  }, {});
+};

package/libEs6/components/RulesEngine/utils/generateEventHash.js

@@ -0,0 +1,33 @@
+/*
+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 fnv1a32Hex from "../../../utils/fnv1a32Hex.js";
+
+/**
+ * Generates an event history hash from an object by removing keys with empty values, sorting the keys,
+ * converting the object to a string, and hashing the string.
+ * @param {Object} o - The object to process.
+ * @returns {string} - The hash of the processed object.
+ */
+export default o => {
+  const obj = structuredClone(o);
+  const objectString = Object.keys(obj).sort().reduce((result, key) => {
+    const value = obj[key];
+
+    // eslint-disable-next-line eqeqeq
+    if (value == undefined || value === "") {
+      return result;
+    }
+    result += `${key}:${value}`;
+    return result;
+  }, "");
+  return fnv1a32Hex(objectString);
+};

package/libEs6/components/RulesEngine/utils/getExpirationDate.js

@@ -0,0 +1,16 @@
+/*
+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.
+*/
+export default retentionPeriod => {
+  const expirationDate = new Date();
+  expirationDate.setDate(expirationDate.getDate() - retentionPeriod);
+  return expirationDate;
+};

package/libEs6/components/RulesEngine/{createDecisionHistory.js → utils/getPropositionData.js}

@@ -9,17 +9,6 @@ the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTA
 OF ANY KIND, either express or implied. See the License for the specific language
 governing permissions and limitations under the License.
 */
-import { PropositionEventType } from "../../constants/propositionEventType.js";
-export default ({
-  eventRegistry
-}) => {
-  const recordQualified = id => {
-    if (!id) {
-      return undefined;
-    }
-    return eventRegistry.addEvent({}, PropositionEventType.TRIGGER, id);
-  };
-  return {
-    recordQualified
-  };
-};
+
+export const getActivityId = proposition => proposition?.scopeDetails?.activity?.id;
+export const getDecisionProvider = proposition => proposition?.scopeDetails?.decisionProvider;

package/libEs6/components/RulesEngine/utils/hasExperienceData.js

@@ -0,0 +1,17 @@
+/*
+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.
+*/
+export default xdm => {
+  const {
+    _experience
+  } = xdm || {};
+  return !!_experience && typeof _experience === "object";
+};