@adobe/alloy 2.28.0 → 2.28.1-beta.0

package/libEs5/components/Personalization/utils/surfaceUtils.js

@@ -0,0 +1,82 @@
+"use strict";
+
+exports.normalizeSurfaces = exports.isPageWideSurface = exports.buildPageSurface = void 0;
+var _surface = require("../constants/surface.js");
+var _index = require("../../../utils/index.js");
+/*
+Copyright 2022 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+const SURFACE_REGEX = /^(\w+):\/\/([^/#]+)(\/[^#]*)?(#.*)?$/;
+const AUTHORITY_REGEX = /^(?:.*@)?(?:[a-z\d\u00a1-\uffff.-]+|\[[a-f\d:]+])(?::\d+)?$/;
+const PATH_REGEX = /^\/(?:[/\w\u00a1-\uffff-.~]|%[a-fA-F\d]{2})*$/;
+const FRAGMENT_REGEX = /^#(?:[/\w\u00a1-\uffff-.~]|%[a-fA-F\d]{2})+$/;
+const normalizePath = (path = "/") => {
+  let end = path.length;
+  while (end > 0 && "/".indexOf(path.charAt(end - 1)) !== -1) {
+    end -= 1;
+  }
+  return path.substring(0, end) || "/";
+};
+const getSurfaceType = surfaceTypeMatch => (0, _index.isNonEmptyString)(surfaceTypeMatch) ? surfaceTypeMatch.toLowerCase() : "";
+const getAuthority = authorityMatch => (0, _index.isNonEmptyString)(authorityMatch) ? authorityMatch.toLowerCase() : "";
+const getPath = pathMatch => (0, _index.isNonEmptyString)(pathMatch) ? normalizePath(pathMatch) : "/";
+const parseSurface = surfaceString => {
+  const matched = surfaceString.match(SURFACE_REGEX);
+  return matched ? {
+    surfaceType: getSurfaceType(matched[1]),
+    authority: getAuthority(matched[2]),
+    path: getPath(matched[3]),
+    fragment: matched[4]
+  } : null;
+};
+const stringifySurface = surface => "" + surface.surfaceType + _surface.SURFACE_TYPE_DELIMITER + surface.authority + (surface.path || "") + (surface.fragment || "");
+const buildPageSurface = getPageLocation => {
+  const location = getPageLocation();
+  const host = location.host.toLowerCase();
+  const path = location.pathname;
+  return _surface.WEB + _surface.SURFACE_TYPE_DELIMITER + host + normalizePath(path);
+};
+exports.buildPageSurface = buildPageSurface;
+const expandFragmentSurface = (surface, getPageLocation) => surface.startsWith(_surface.FRAGMENT_DELIMITER) ? buildPageSurface(getPageLocation) + surface : surface;
+const validateSurface = (surface, getPageLocation, logger) => {
+  const invalidateSurface = validationError => {
+    logger.warn(validationError);
+    return null;
+  };
+  if (!(0, _index.isNonEmptyString)(surface)) {
+    return invalidateSurface("Invalid surface: " + surface);
+  }
+  const expanded = expandFragmentSurface(surface, getPageLocation);
+  const parsed = parseSurface(expanded);
+  if (parsed === null) {
+    return invalidateSurface("Invalid surface: " + surface);
+  }
+  if (![_surface.WEB, _surface.WEBAPP].includes(parsed.surfaceType)) {
+    return invalidateSurface("Unsupported surface type " + parsed.surfaceType + " in surface: " + surface);
+  }
+  if (!parsed.authority || !AUTHORITY_REGEX.test(parsed.authority)) {
+    return invalidateSurface("Invalid authority " + parsed.authority + " in surface: " + surface);
+  }
+  if (parsed.path && !PATH_REGEX.test(parsed.path)) {
+    return invalidateSurface("Invalid path " + parsed.path + " in surface: " + surface);
+  }
+  if (parsed.fragment && !FRAGMENT_REGEX.test(parsed.fragment)) {
+    return invalidateSurface("Invalid fragment " + parsed.fragment + " in surface: " + surface);
+  }
+  return parsed;
+};
+const isPageWideSurface = scope => !!scope && scope.indexOf(_surface.WEB + _surface.SURFACE_TYPE_DELIMITER) === 0 && scope.indexOf(_surface.FRAGMENT_DELIMITER) === -1;
+
+// eslint-disable-next-line default-param-last
+exports.isPageWideSurface = isPageWideSurface;
+const normalizeSurfaces = (surfaces = [], getPageLocation, logger) => surfaces.map(surface => validateSurface(surface, getPageLocation, logger)).filter(surface => !(0, _index.isNil)(surface)).map(stringifySurface);
+exports.normalizeSurfaces = normalizeSurfaces;

package/libEs5/components/Personalization/validateApplyPropositionsOptions.js

@@ -0,0 +1,47 @@
+"use strict";
+
+exports.default = exports.EMPTY_PROPOSITIONS = void 0;
+var _index = require("../../utils/validation/index.js");
+/*
+Copyright 2023 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+const EMPTY_PROPOSITIONS = exports.EMPTY_PROPOSITIONS = {
+  propositions: []
+};
+var _default = ({
+  logger,
+  options
+}) => {
+  const applyPropositionsOptionsValidator = (0, _index.objectOf)({
+    propositions: (0, _index.arrayOf)((0, _index.objectOf)({
+      id: (0, _index.string)().required(),
+      scope: (0, _index.string)().required(),
+      scopeDetails: (0, _index.objectOf)({
+        decisionProvider: (0, _index.string)().required()
+      }).required(),
+      items: (0, _index.arrayOf)((0, _index.objectOf)({
+        id: (0, _index.string)().required(),
+        schema: (0, _index.string)().required(),
+        data: (0, _index.objectOf)((0, _index.anything)())
+      })).nonEmpty().required()
+    }).required()).nonEmpty().required(),
+    metadata: (0, _index.objectOf)((0, _index.anything)()),
+    viewName: (0, _index.string)()
+  }).required();
+  try {
+    return applyPropositionsOptionsValidator(options);
+  } catch (e) {
+    logger.warn("Invalid options for applyPropositions. No propositions will be applied.", e);
+    return EMPTY_PROPOSITIONS;
+  }
+};
+exports.default = _default;

package/libEs5/components/RulesEngine/consequenceAdapters/inAppMessageConsequenceAdapter.js

@@ -0,0 +1,34 @@
+"use strict";
+
+exports.default = void 0;
+var _schema = require("../../../constants/schema.js");
+var _contentType = require("../../../constants/contentType.js");
+/*
+Copyright 2023 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+var _default = (id, type, detail) => {
+  const {
+    html,
+    mobileParameters
+  } = detail;
+  const webParameters = {};
+  return {
+    schema: _schema.MESSAGE_IN_APP,
+    data: {
+      mobileParameters,
+      webParameters,
+      content: html,
+      contentType: _contentType.TEXT_HTML
+    },
+    id
+  };
+};
+exports.default = _default;

package/libEs5/components/RulesEngine/consequenceAdapters/schemaTypeConsequenceAdapter.js

@@ -0,0 +1,27 @@
+"use strict";
+
+exports.default = void 0;
+/*
+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 _default = (id, type, detail) => {
+  const {
+    schema,
+    data,
+    id: detailId
+  } = detail;
+  return {
+    schema,
+    data,
+    id: detailId || id
+  };
+};
+exports.default = _default;

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

@@ -0,0 +1,37 @@
+"use strict";
+
+exports.SCHEMA = exports.INSERT_OPERATION = exports.INSERT_IF_NOT_EXISTS_OPERATION = exports.EVENT_HISTORY_STORAGE_KEY = exports.EVENT_HISTORY_RETENTION_PERIOD = exports.EVENT_HISTORY_MAX_RECORDS = exports.EVENT_HISTORY_MAX_LENGTH = exports.CONTEXT_KEY = exports.CONTEXT_EVENT_TYPE = exports.CONTEXT_EVENT_SOURCE = exports.CJM_IN_APP_MESSAGE_TYPE = void 0;
+/*
+Copyright 2025 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+const EVENT_HISTORY_MAX_RECORDS = exports.EVENT_HISTORY_MAX_RECORDS = 1000;
+const EVENT_HISTORY_RETENTION_PERIOD = exports.EVENT_HISTORY_RETENTION_PERIOD = 30; // 30 days
+const EVENT_HISTORY_STORAGE_KEY = exports.EVENT_HISTORY_STORAGE_KEY = "events";
+const EVENT_HISTORY_MAX_LENGTH = exports.EVENT_HISTORY_MAX_LENGTH = 2 * 1024 * 1024; // 2MB
+
+const CONTEXT_KEY = exports.CONTEXT_KEY = {
+  TYPE: "~type",
+  SOURCE: "~source"
+};
+const CONTEXT_EVENT_TYPE = exports.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"
+};
+const CONTEXT_EVENT_SOURCE = exports.CONTEXT_EVENT_SOURCE = {
+  LAUNCH: "com.adobe.eventSource.applicationLaunch",
+  REQUEST: "com.adobe.eventSource.requestContent"
+};
+const CJM_IN_APP_MESSAGE_TYPE = exports.CJM_IN_APP_MESSAGE_TYPE = "cjmiam";
+const SCHEMA = exports.SCHEMA = "schema";
+const INSERT_OPERATION = exports.INSERT_OPERATION = "insert";
+const INSERT_IF_NOT_EXISTS_OPERATION = exports.INSERT_IF_NOT_EXISTS_OPERATION = "insertIfNotExists";

package/libEs5/components/RulesEngine/createApplyResponse.js

@@ -0,0 +1,43 @@
+"use strict";
+
+exports.default = void 0;
+var _extractPayloadsFromEventHistoryOperations = require("./utils/extractPayloadsFromEventHistoryOperations.js");
+/*
+Copyright 2023 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+var _default = ({
+  lifecycle,
+  eventRegistry
+}) => {
+  return ({
+    renderDecisions = false,
+    propositions = [],
+    event,
+    personalization
+  }) => {
+    if (lifecycle) {
+      // Some propositions may contains event history operations.
+      // We extract them and add the events to the event registry.
+      const eventPayloads = (0, _extractPayloadsFromEventHistoryOperations.default)(propositions);
+      eventRegistry.addEventPayloads(eventPayloads);
+      lifecycle.onDecision({
+        renderDecisions,
+        propositions,
+        event,
+        personalization
+      });
+    }
+    return {
+      propositions
+    };
+  };
+};
+exports.default = _default;

package/libEs5/components/RulesEngine/createConsequenceAdapter.js

@@ -0,0 +1,33 @@
+"use strict";
+
+exports.default = void 0;
+var _inAppMessageConsequenceAdapter = require("./consequenceAdapters/inAppMessageConsequenceAdapter.js");
+var _schemaTypeConsequenceAdapter = require("./consequenceAdapters/schemaTypeConsequenceAdapter.js");
+var _index = require("./constants/index.js");
+/*
+Copyright 2023 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+const adapters = {
+  [_index.CJM_IN_APP_MESSAGE_TYPE]: _inAppMessageConsequenceAdapter.default,
+  [_index.SCHEMA]: _schemaTypeConsequenceAdapter.default
+};
+var _default = () => {
+  return consequence => {
+    const {
+      id,
+      type,
+      detail
+    } = consequence;
+    return typeof adapters[type] === "function" ? adapters[type](id, type, detail) : detail;
+  };
+};
+exports.default = _default;

package/libEs5/components/RulesEngine/createContextProvider.js

@@ -0,0 +1,99 @@
+"use strict";
+
+exports.default = void 0;
+var _parseUrl = require("../../utils/parseUrl.js");
+var _flattenObject = require("../../utils/flattenObject.js");
+var _libraryVersion = require("../../constants/libraryVersion.js");
+/*
+Copyright 2023 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+var _default = ({
+  eventRegistry,
+  window,
+  getBrowser
+}) => {
+  const pageLoadTimestamp = new Date().getTime();
+  const getBrowserContext = () => {
+    return {
+      name: getBrowser()
+    };
+  };
+  const getPageContext = () => {
+    return {
+      title: window.title,
+      url: window.url,
+      ...(0, _parseUrl.default)(window.url)
+    };
+  };
+  const getReferrerContext = () => {
+    return {
+      url: window.referrer,
+      ...(0, _parseUrl.default)(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.default
+    };
+  };
+  const getContext = (addedContext = {}) => {
+    const context = {
+      ...getGlobalContext(),
+      ...addedContext
+    };
+    return {
+      ...(0, _flattenObject.default)(context),
+      events: eventRegistry.toJSON()
+    };
+  };
+  return {
+    getContext
+  };
+};
+exports.default = _default;

package/libEs5/components/RulesEngine/createDecisionProvider.js

@@ -0,0 +1,48 @@
+"use strict";
+
+exports.default = void 0;
+var _createEvaluableRulesetPayload = require("./createEvaluableRulesetPayload.js");
+var _index = require("./utils/index.js");
+/*
+Copyright 2023 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+var _default = ({
+  eventRegistry
+}) => {
+  const payloadsBasedOnActivityId = {};
+  const addPayload = payload => {
+    const activityId = (0, _index.getActivityId)(payload);
+    if (!activityId) {
+      return;
+    }
+    const evaluableRulesetPayload = (0, _createEvaluableRulesetPayload.default)(payload, eventRegistry);
+    if (evaluableRulesetPayload.isEvaluable) {
+      payloadsBasedOnActivityId[activityId] = evaluableRulesetPayload;
+    }
+  };
+  const evaluate = (context = {}) => {
+    const sortedPayloadsBasedOnActivityId = Object.values(payloadsBasedOnActivityId).sort(({
+      rank: rankA
+    }, {
+      rank: rankB
+    }) => rankA - rankB);
+    return sortedPayloadsBasedOnActivityId.map(payload => payload.evaluate(context)).filter(payload => payload.items.length > 0);
+  };
+  const addPayloads = personalizationPayloads => {
+    personalizationPayloads.forEach(addPayload);
+  };
+  return {
+    addPayload,
+    addPayloads,
+    evaluate
+  };
+};
+exports.default = _default;

package/libEs5/components/RulesEngine/createEvaluableRulesetPayload.js

@@ -0,0 +1,90 @@
+"use strict";
+
+exports.default = void 0;
+var _aepRulesEngine = require("@adobe/aep-rules-engine");
+var _schema = require("../../constants/schema.js");
+var _eventType = require("../../constants/eventType.js");
+var _propositionEventType = require("../../constants/propositionEventType.js");
+var _index = require("./utils/index.js");
+var _flattenArray = require("../../utils/flattenArray.js");
+var _createConsequenceAdapter = require("./createConsequenceAdapter.js");
+/*
+Copyright 2023 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+const isRulesetItem = item => {
+  const {
+    schema,
+    data
+  } = item;
+  if (schema === _schema.RULESET_ITEM) {
+    return true;
+  }
+  if (schema !== _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 {
+    return false;
+  }
+};
+var _default = (payload, eventRegistry) => {
+  const consequenceAdapter = (0, _createConsequenceAdapter.default)();
+  const activityId = (0, _index.getActivityId)(payload);
+  const items = [];
+  const addItem = item => {
+    const {
+      data = {},
+      schema
+    } = item;
+    const content = schema === _schema.RULESET_ITEM ? data : data.content;
+    if (!content) {
+      return;
+    }
+    items.push((0, _aepRulesEngine.default)(typeof content === "string" ? JSON.parse(content) : content, {
+      generateEventHash: _index.generateEventHash
+    }));
+  };
+  const evaluate = context => {
+    const displayEvent = eventRegistry.getEvent(_eventType.DISPLAY, activityId);
+    const displayedDate = displayEvent?.timestamps[0];
+    const qualifyingItems = (0, _flattenArray.default)(items.map(item => item.execute(context))).map(consequenceAdapter).map(item => {
+      const event = eventRegistry.addEvent({
+        eventType: _propositionEventType.PropositionEventType.TRIGGER,
+        eventId: activityId
+      });
+      const qualifiedDate = event.timestamps[0];
+      return {
+        ...item,
+        data: {
+          ...item.data,
+          qualifiedDate,
+          displayedDate
+        }
+      };
+    });
+    return {
+      ...payload,
+      items: qualifyingItems
+    };
+  };
+  if (Array.isArray(payload.items)) {
+    payload.items.filter(isRulesetItem).forEach(addItem);
+  }
+  return {
+    rank: payload?.scopeDetails?.rank || Infinity,
+    evaluate,
+    isEvaluable: items.length > 0
+  };
+};
+exports.default = _default;

package/libEs5/components/RulesEngine/createEvaluateRulesetsCommand.js

@@ -0,0 +1,50 @@
+"use strict";
+
+exports.default = void 0;
+var _index = require("../../utils/validation/index.js");
+/*
+Copyright 2023 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+const validateOptions = ({
+  options
+}) => {
+  const validator = (0, _index.objectOf)({
+    renderDecisions: (0, _index.boolean)(),
+    personalization: (0, _index.objectOf)({
+      decisionContext: (0, _index.objectOf)({})
+    })
+  }).noUnknownFields();
+  return validator(options);
+};
+var _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
+  };
+};
+exports.default = _default;