@adobe/alloy 2.19.0-beta.9 → 2.19.0

package/libEs5/utils/parseUrl.js

@@ -0,0 +1,70 @@
+"use strict";
+
+exports.default = void 0;
+var _parseUri = require("parse-uri");
+var _isString = require("./isString");
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } /*
+                                                                                                                                                                                                                  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.
+                                                                                                                                                                                                                  */
+var parseDomainBasic = function parseDomainBasic(host) {
+  var result = {};
+  var domainParts = host.split(".");
+  switch (domainParts.length) {
+    case 1:
+      result.subdomain = "";
+      result.domain = host;
+      result.topLevelDomain = "";
+      break;
+    case 2:
+      result.subdomain = "";
+      result.domain = host;
+      result.topLevelDomain = domainParts[1];
+      break;
+    case 3:
+      result.subdomain = domainParts[0] === "www" ? "" : domainParts[0];
+      result.domain = host;
+      result.topLevelDomain = domainParts[2];
+      break;
+    case 4:
+      result.subdomain = domainParts[0] === "www" ? "" : domainParts[0];
+      result.domain = host;
+      result.topLevelDomain = domainParts[2] + "." + domainParts[3];
+      break;
+    default:
+      break;
+  }
+  return result;
+};
+var parseUrl = function parseUrl(url) {
+  var parseDomain = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : parseDomainBasic;
+  if (!(0, _isString.default)(url)) {
+    // eslint-disable-next-line no-param-reassign
+    url = "";
+  }
+  var parsed = (0, _parseUri.default)(url) || {};
+  var _parsed$host = parsed.host,
+    host = _parsed$host === void 0 ? "" : _parsed$host,
+    _parsed$path = parsed.path,
+    path = _parsed$path === void 0 ? "" : _parsed$path,
+    _parsed$query = parsed.query,
+    query = _parsed$query === void 0 ? "" : _parsed$query,
+    _parsed$anchor = parsed.anchor,
+    anchor = _parsed$anchor === void 0 ? "" : _parsed$anchor;
+  return _objectSpread({
+    path: path,
+    query: query,
+    fragment: anchor
+  }, parseDomain(host));
+};
+var _default = parseUrl;
+exports.default = _default;

package/libEs6/components/DataCollector/index.js

@@ -82,6 +82,7 @@ const createDataCollector = ({
         run: options => {
           const {
             renderDecisions = false,
+            decisionContext = {},
             responseHeaders = {},
             responseBody = {
               handle: []
@@ -91,6 +92,7 @@ const createDataCollector = ({
           const event = eventManager.createEvent();
           return eventManager.applyResponse(event, {
             renderDecisions,
+            decisionContext,
             responseHeaders,
             responseBody,
             personalization

package/libEs6/components/DataCollector/validateApplyResponse.js

@@ -23,7 +23,8 @@ export default (({
       })).required()
     }).required(),
     personalization: objectOf({
-      sendDisplayEvent: boolean().default(true)
+      sendDisplayEvent: boolean().default(true),
+      decisionContext: objectOf({})
     }).default({
       sendDisplayEvent: true
     })

package/libEs6/components/DataCollector/validateUserEventOptions.js

@@ -35,7 +35,8 @@ export default (({
       surfaces: arrayOf(string()).uniqueItems(),
       sendDisplayEvent: boolean().default(true),
       includeRenderedPropositions: boolean().default(false),
-      requestPersonalization: boolean()
+      defaultPersonalizationEnabled: boolean(),
+      decisionContext: objectOf({})
     }).default({
       sendDisplayEvent: true
     }),

package/libEs6/components/DecisioningEngine/consequenceAdapters/inAppMessageConsequenceAdapter.js

@@ -0,0 +1,30 @@
+/*
+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 { MESSAGE_IN_APP } from "../../../constants/schema";
+import { TEXT_HTML } from "../../../constants/contentType";
+export default ((id, type, detail) => {
+  const {
+    html,
+    mobileParameters
+  } = detail;
+  const webParameters = {};
+  return {
+    schema: MESSAGE_IN_APP,
+    data: {
+      mobileParameters,
+      webParameters,
+      content: html,
+      contentType: TEXT_HTML
+    },
+    id
+  };
+});

package/libEs6/components/DecisioningEngine/consequenceAdapters/schemaTypeConsequenceAdapter.js

@@ -0,0 +1,24 @@
+/*
+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.
+*/
+
+export default ((id, type, detail) => {
+  const {
+    schema,
+    data,
+    id: detailId
+  } = detail;
+  return {
+    schema,
+    data,
+    id: detailId || id
+  };
+});

package/libEs6/components/DecisioningEngine/constants.js

@@ -0,0 +1,25 @@
+/*
+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.
+*/
+export const CONTEXT_KEY = {
+  TYPE: "~type",
+  SOURCE: "~source"
+};
+export const CONTEXT_EVENT_TYPE = {
+  LIFECYCLE: "com.adobe.eventType.lifecycle",
+  TRACK: "com.adobe.eventType.generic.track",
+  EDGE: "com.adobe.eventType.edge",
+  RULES_ENGINE: "com.adobe.eventType.rulesEngine"
+};
+export const CONTEXT_EVENT_SOURCE = {
+  LAUNCH: "com.adobe.eventSource.applicationLaunch",
+  REQUEST: "com.adobe.eventSource.requestContent"
+};

package/libEs6/components/DecisioningEngine/createApplyResponse.js

@@ -0,0 +1,31 @@
+/*
+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.
+*/
+export default (lifecycle => {
+  return ({
+    renderDecisions = false,
+    propositions = [],
+    event,
+    personalization
+  }) => {
+    if (propositions.length > 0 && lifecycle) {
+      lifecycle.onDecision({
+        renderDecisions,
+        propositions,
+        event,
+        personalization
+      });
+    }
+    return {
+      propositions
+    };
+  };
+});

package/libEs6/components/DecisioningEngine/createConsequenceAdapter.js

@@ -0,0 +1,29 @@
+/*
+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 inAppMessageConsequenceAdapter from "./consequenceAdapters/inAppMessageConsequenceAdapter";
+import schemaTypeConsequenceAdapter from "./consequenceAdapters/schemaTypeConsequenceAdapter";
+const CJM_IN_APP_MESSAGE_TYPE = "cjmiam";
+const SCHEMA = "schema";
+const adapters = {
+  [CJM_IN_APP_MESSAGE_TYPE]: inAppMessageConsequenceAdapter,
+  [SCHEMA]: schemaTypeConsequenceAdapter
+};
+export default (() => {
+  return consequence => {
+    const {
+      id,
+      type,
+      detail
+    } = consequence;
+    return typeof adapters[type] === "function" ? adapters[type](id, type, detail) : detail;
+  };
+});

package/libEs6/components/DecisioningEngine/createContextProvider.js

@@ -0,0 +1,95 @@
+/*
+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 getBrowser from "../../utils/getBrowser";
+import parseUrl from "../../utils/parseUrl";
+import flattenObject from "../../utils/flattenObject";
+import libraryVersion from "../../constants/libraryVersion";
+export default (({
+  eventRegistry,
+  window
+}) => {
+  const pageLoadTimestamp = new Date().getTime();
+  const getBrowserContext = () => {
+    return {
+      name: getBrowser(window)
+    };
+  };
+  const getPageContext = () => {
+    return {
+      title: window.title,
+      url: window.url,
+      ...parseUrl(window.url)
+    };
+  };
+  const getReferrerContext = () => {
+    return {
+      url: window.referrer,
+      ...parseUrl(window.referrer)
+    };
+  };
+  const getTimeContext = () => {
+    const now = new Date();
+    const currentTimestamp = now.getTime();
+    return {
+      pageLoadTimestamp,
+      currentTimestamp,
+      currentDate: now.getDate(),
+      // Day of the week starts on Monday as is practiced in ISO 8601, but we want it to start on Sunday to match the authoring UI rule
+      "~state.com.adobe.module.lifecycle/lifecyclecontextdata.dayofweek": now.getDay() + 1,
+      "~state.com.adobe.module.lifecycle/lifecyclecontextdata.hourofday": now.getHours(),
+      currentMinute: now.getMinutes(),
+      currentMonth: now.getMonth(),
+      currentYear: now.getFullYear(),
+      pageVisitDuration: currentTimestamp - pageLoadTimestamp,
+      "~timestampu": currentTimestamp / 1000,
+      "~timestampz": now.toISOString()
+    };
+  };
+  const getWindowContext = () => {
+    const height = window.height;
+    const width = window.width;
+    const scrollY = window.scrollY;
+    const scrollX = window.scrollX;
+    return {
+      height,
+      width,
+      scrollY,
+      scrollX
+    };
+  };
+  const coreGlobalContext = {
+    browser: getBrowserContext(),
+    page: getPageContext(),
+    referringPage: getReferrerContext()
+  };
+  const getGlobalContext = () => {
+    return {
+      ...coreGlobalContext,
+      ...getTimeContext(),
+      window: getWindowContext(),
+      "~sdkver": libraryVersion
+    };
+  };
+  const getContext = (addedContext = {}) => {
+    const context = {
+      ...getGlobalContext(),
+      ...addedContext
+    };
+    return {
+      ...flattenObject(context),
+      events: eventRegistry.toJSON()
+    };
+  };
+  return {
+    getContext
+  };
+});

package/libEs6/components/DecisioningEngine/createDecisionHistory.js

@@ -0,0 +1,25 @@
+/*
+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 { PropositionEventType } from "../../constants/propositionEventType";
+export default (({
+  eventRegistry
+}) => {
+  const recordQualified = id => {
+    if (!id) {
+      return undefined;
+    }
+    return eventRegistry.addEvent({}, PropositionEventType.TRIGGER, id);
+  };
+  return {
+    recordQualified
+  };
+});

package/libEs6/components/DecisioningEngine/createDecisionProvider.js

@@ -0,0 +1,41 @@
+/*
+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 createEvaluableRulesetPayload from "./createEvaluableRulesetPayload";
+import createDecisionHistory from "./createDecisionHistory";
+import { getActivityId } from "./utils";
+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);
+    if (evaluableRulesetPayload.isEvaluable) {
+      payloadsBasedOnActivityId[activityId] = evaluableRulesetPayload;
+    }
+  };
+  const evaluate = (context = {}) => Object.values(payloadsBasedOnActivityId).map(payload => payload.evaluate(context)).filter(payload => payload.items.length > 0);
+  const addPayloads = personalizationPayloads => {
+    personalizationPayloads.forEach(addPayload);
+  };
+  return {
+    addPayload,
+    addPayloads,
+    evaluate
+  };
+});

package/libEs6/components/DecisioningEngine/createEvaluableRulesetPayload.js

@@ -0,0 +1,79 @@
+/*
+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 RulesEngine from "@adobe/aep-rules-engine";
+import { JSON_CONTENT_ITEM, RULESET_ITEM } from "../../constants/schema";
+import { DISPLAY } from "../../constants/eventType";
+import { getActivityId } from "./utils";
+import flattenArray from "../../utils/flattenArray";
+import createConsequenceAdapter from "./createConsequenceAdapter";
+const isRulesetItem = item => {
+  const {
+    schema,
+    data
+  } = item;
+  if (schema === RULESET_ITEM) {
+    return true;
+  }
+  if (schema !== JSON_CONTENT_ITEM) {
+    return false;
+  }
+  try {
+    const content = typeof data.content === "string" ? JSON.parse(data.content) : data.content;
+    return content && Object.prototype.hasOwnProperty.call(content, "version") && Object.prototype.hasOwnProperty.call(content, "rules");
+  } catch (error) {
+    return false;
+  }
+};
+export default ((payload, eventRegistry, decisionHistory) => {
+  const consequenceAdapter = createConsequenceAdapter();
+  const activityId = getActivityId(payload);
+  const items = [];
+  const addItem = item => {
+    const {
+      data = {},
+      schema
+    } = item;
+    const content = schema === RULESET_ITEM ? data : data.content;
+    if (!content) {
+      return;
+    }
+    items.push(RulesEngine(typeof content === "string" ? JSON.parse(content) : content));
+  };
+  const evaluate = context => {
+    const displayEvent = eventRegistry.getEvent(DISPLAY, activityId);
+    const displayedDate = displayEvent ? displayEvent.firstTimestamp : undefined;
+    const qualifyingItems = flattenArray(items.map(item => item.execute(context))).map(consequenceAdapter).map(item => {
+      const {
+        firstTimestamp: qualifiedDate
+      } = decisionHistory.recordQualified(activityId) || {};
+      return {
+        ...item,
+        data: {
+          ...item.data,
+          qualifiedDate,
+          displayedDate
+        }
+      };
+    });
+    return {
+      ...payload,
+      items: qualifyingItems
+    };
+  };
+  if (Array.isArray(payload.items)) {
+    payload.items.filter(isRulesetItem).forEach(addItem);
+  }
+  return {
+    evaluate,
+    isEvaluable: items.length > 0
+  };
+});

package/libEs6/components/DecisioningEngine/createEvaluateRulesetsCommand.js

@@ -0,0 +1,45 @@
+/*
+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 { boolean, objectOf } from "../../utils/validation";
+const validateOptions = ({
+  options
+}) => {
+  const validator = objectOf({
+    renderDecisions: boolean(),
+    personalization: objectOf({
+      decisionContext: objectOf({})
+    })
+  }).noUnknownFields();
+  return validator(options);
+};
+export default (({
+  contextProvider,
+  decisionProvider
+}) => {
+  const run = ({
+    renderDecisions,
+    decisionContext,
+    applyResponse
+  }) => {
+    return applyResponse({
+      renderDecisions,
+      propositions: decisionProvider.evaluate(contextProvider.getContext(decisionContext))
+    });
+  };
+  const optionsValidator = options => validateOptions({
+    options
+  });
+  return {
+    optionsValidator,
+    run
+  };
+});

package/libEs6/components/DecisioningEngine/createEventRegistry.js

@@ -0,0 +1,120 @@
+/*
+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 { createRestoreStorage, createSaveStorage, getExpirationDate, getActivityId, hasExperienceData, getDecisionProvider } from "./utils";
+import { EVENT_TYPE_TRUE } from "../../constants/eventType";
+import { ADOBE_JOURNEY_OPTIMIZER } from "../../constants/decisionProvider";
+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;
+  };
+};
+export default (({
+  storage
+}) => {
+  let currentStorage = storage;
+  let restore;
+  let save;
+  let events;
+  const setStorage = newStorage => {
+    currentStorage = newStorage;
+    restore = createRestoreStorage(currentStorage, STORAGE_KEY);
+    save = createSaveStorage(currentStorage, STORAGE_KEY, createEventPruner(MAX_EVENT_RECORDS, RETENTION_PERIOD));
+    events = restore({});
+  };
+  setStorage(storage);
+  const addEvent = (event, eventType, eventId, action) => {
+    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
+    };
+    save(events);
+    return events[eventType][eventId];
+  };
+  const addExperienceEdgeEvent = event => {
+    const {
+      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 => {
+      propositions.forEach(proposition => {
+        if (getDecisionProvider(proposition) !== ADOBE_JOURNEY_OPTIMIZER) {
+          return;
+        }
+        addEvent({}, propositionEventType, getActivityId(proposition), action);
+      });
+    });
+  };
+  const getEvent = (eventType, eventId) => {
+    if (!events[eventType]) {
+      return undefined;
+    }
+    return events[eventType][eventId];
+  };
+  return {
+    addExperienceEdgeEvent,
+    addEvent,
+    getEvent,
+    toJSON: () => events,
+    setStorage
+  };
+});