@adobe/alloy 2.19.0-beta.9 → 2.19.1-beta.0

package/libEs5/utils/flattenObject.js

@@ -0,0 +1,43 @@
+"use strict";
+
+exports.default = void 0;
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(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 isPlainObject = function isPlainObject(obj) {
+  return obj !== null && _typeof(obj) === "object" && Object.getPrototypeOf(obj) === Object.prototype;
+};
+var flattenObject = function flattenObject(obj) {
+  var result = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var keys = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+  Object.keys(obj).forEach(function (key) {
+    if (isPlainObject(obj[key]) || Array.isArray(obj[key])) {
+      flattenObject(obj[key], result, [].concat(_toConsumableArray(keys), [key]));
+    } else {
+      result[[].concat(_toConsumableArray(keys), [key]).join(".")] = obj[key];
+    }
+  });
+  return result;
+};
+var _default = function _default(obj) {
+  if (!isPlainObject(obj)) {
+    return obj;
+  }
+  return flattenObject(obj);
+};
+exports.default = _default;

package/libEs5/utils/index.js

@@ -12,6 +12,12 @@ Object.defineProperty(exports, "assign", {
     return _assign.default;
   }
 });
+Object.defineProperty(exports, "assignConcatArrayValues", {
+  enumerable: true,
+  get: function get() {
+    return _assignConcatArrayValues.default;
+  }
+});
 Object.defineProperty(exports, "assignIf", {
   enumerable: true,
   get: function get() {
@@ -246,6 +252,12 @@ Object.defineProperty(exports, "padStart", {
     return _padStart.default;
   }
 });
+Object.defineProperty(exports, "parseUrl", {
+  enumerable: true,
+  get: function get() {
+    return _parseUrl.default;
+  }
+});
 Object.defineProperty(exports, "prepareConfigOverridesForEdge", {
   enumerable: true,
   get: function get() {
@@ -338,6 +350,7 @@ Object.defineProperty(exports, "values", {
 });
 var _areThirdPartyCookiesSupportedByDefault = require("./areThirdPartyCookiesSupportedByDefault");
 var _assign = require("./assign");
+var _assignConcatArrayValues = require("./assignConcatArrayValues");
 var _assignIf = require("./assignIf");
 var _clone = require("./clone");
 var _cookieJar = require("./cookieJar");
@@ -377,6 +390,7 @@ var _isString = require("./isString");
 var _memoize = require("./memoize");
 var _noop = require("./noop");
 var _padStart = require("./padStart");
+var _parseUrl = require("./parseUrl");
 var _prepareConfigOverridesForEdge = require("./prepareConfigOverridesForEdge");
 var _querystring = require("./querystring");
 var _sanitizeOrgIdForCookieName = require("./sanitizeOrgIdForCookieName");

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
+  };
+});