@adobe/alloy 2.28.0 → 2.28.1-beta.0

package/libEs5/components/Personalization/createApplyPropositions.js

@@ -0,0 +1,123 @@
+"use strict";
+
+exports.default = void 0;
+var _index = require("../../utils/index.js");
+var _schema = require("../../constants/schema.js");
+var _pageWideScope = require("../../constants/pageWideScope.js");
+var _initDomActionsModules = require("./dom-actions/initDomActionsModules.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 isInteractionTrackingItem = (schema, actionType) => schema === _schema.JSON_CONTENT_ITEM && actionType === _initDomActionsModules.DOM_ACTION_COLLECT_INTERACTIONS;
+const SUPPORTED_SCHEMAS = {
+  [_schema.DOM_ACTION]: () => true,
+  [_schema.HTML_CONTENT_ITEM]: () => true,
+  [_schema.JSON_CONTENT_ITEM]: isInteractionTrackingItem,
+  [_schema.MESSAGE_IN_APP]: () => true,
+  [_schema.DEFAULT_CONTENT_ITEM]: () => true
+};
+const filterItemsPredicate = (schema, actionType) => typeof SUPPORTED_SCHEMAS[schema] === "function" && SUPPORTED_SCHEMAS[schema](schema, actionType);
+var _default = ({
+  processPropositions,
+  createProposition,
+  renderedPropositions,
+  viewCache
+}) => {
+  const updatePropositionItems = ({
+    items,
+    metadataForScope = {}
+  }) => {
+    const {
+      actionType,
+      selector
+    } = metadataForScope;
+    return items.filter(item => filterItemsPredicate(item.schema, actionType)).map(item => {
+      const {
+        schema
+      } = item;
+      if (schema !== _schema.HTML_CONTENT_ITEM && !isInteractionTrackingItem(schema, actionType)) {
+        return {
+          ...item
+        };
+      }
+      if (!(0, _index.isEmptyObject)(metadataForScope)) {
+        return {
+          ...item,
+          schema: isInteractionTrackingItem(schema, actionType) ? _schema.DOM_ACTION : schema,
+          data: {
+            ...item.data,
+            selector,
+            type: actionType
+          }
+        };
+      }
+      return undefined;
+    }).filter(item => item);
+  };
+  const filterPropositionsPredicate = proposition => {
+    return !(proposition.scope === _pageWideScope.default && proposition.renderAttempted);
+  };
+  const preparePropositions = ({
+    propositions,
+    metadata
+  }) => {
+    return propositions.filter(filterPropositionsPredicate).map(proposition => {
+      if ((0, _index.isNonEmptyArray)(proposition.items)) {
+        const {
+          id,
+          scope,
+          scopeDetails
+        } = proposition;
+        return {
+          id,
+          scope,
+          scopeDetails,
+          items: updatePropositionItems({
+            items: proposition.items,
+            metadataForScope: metadata[proposition.scope]
+          })
+        };
+      }
+      return proposition;
+    }).filter(proposition => (0, _index.isNonEmptyArray)(proposition.items));
+  };
+  return ({
+    propositions = [],
+    metadata = {},
+    viewName
+  }) => {
+    // We need to immediately call concat so that subsequent sendEvent
+    // calls will wait for applyPropositions to complete before executing.
+    const renderedPropositionsDeferred = (0, _index.defer)();
+    renderedPropositions.concat(renderedPropositionsDeferred.promise);
+    const propositionsToExecute = preparePropositions({
+      propositions,
+      metadata
+    }).map(proposition => createProposition(proposition));
+    return Promise.resolve().then(() => {
+      if (viewName) {
+        return viewCache.getView(viewName);
+      }
+      return [];
+    }).then(additionalPropositions => {
+      const {
+        render,
+        returnedPropositions
+      } = processPropositions([...propositionsToExecute, ...additionalPropositions]);
+      render().then(renderedPropositionsDeferred.resolve);
+      return {
+        propositions: returnedPropositions
+      };
+    });
+  };
+};
+exports.default = _default;

package/libEs5/components/Personalization/createClickStorage.js

@@ -0,0 +1,62 @@
+"use strict";
+
+exports.default = void 0;
+/*
+Copyright 2020 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 metasToArray = metas => {
+  return Object.keys(metas).map(key => {
+    return {
+      id: key,
+      ...metas[key]
+    };
+  });
+};
+var _default = () => {
+  const clickStorage = {};
+  const storeClickMeta = ({
+    selector,
+    meta: {
+      id,
+      scope,
+      scopeDetails,
+      trackingLabel,
+      scopeType
+    }
+  }) => {
+    if (!clickStorage[selector]) {
+      clickStorage[selector] = {};
+    }
+    clickStorage[selector][id] = {
+      scope,
+      scopeDetails,
+      trackingLabel,
+      scopeType
+    };
+  };
+  const getClickSelectors = () => {
+    return Object.keys(clickStorage);
+  };
+  const getClickMetas = selector => {
+    const metas = clickStorage[selector];
+    if (!metas) {
+      return {};
+    }
+    return metasToArray(clickStorage[selector]);
+  };
+  return {
+    storeClickMeta,
+    getClickSelectors,
+    getClickMetas
+  };
+};
+exports.default = _default;

package/libEs5/components/Personalization/createComponent.js

@@ -0,0 +1,135 @@
+"use strict";
+
+exports.default = void 0;
+var _index = require("../../utils/index.js");
+var _createPersonalizationDetails = require("./createPersonalizationDetails.js");
+var _loggerMessage = require("./constants/loggerMessage.js");
+var _propositionEventType = require("../../constants/propositionEventType.js");
+var _validateApplyPropositionsOptions = require("./validateApplyPropositionsOptions.js");
+/*
+Copyright 2020 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 = ({
+  getPageLocation,
+  logger,
+  fetchDataHandler,
+  viewChangeHandler,
+  onClickHandler,
+  isAuthoringModeEnabled,
+  mergeQuery,
+  viewCache,
+  showContainers,
+  applyPropositions,
+  setTargetMigration,
+  mergeDecisionsMeta,
+  renderedPropositions,
+  onDecisionHandler,
+  handleConsentFlicker
+}) => {
+  return {
+    lifecycle: {
+      onComponentsRegistered() {
+        handleConsentFlicker();
+      },
+      onDecision: onDecisionHandler,
+      onBeforeRequest({
+        request
+      }) {
+        setTargetMigration(request);
+        return Promise.resolve();
+      },
+      onBeforeEvent({
+        event,
+        renderDecisions,
+        decisionScopes = [],
+        personalization = {},
+        onResponse = _index.noop,
+        onRequestFailure = _index.noop
+      }) {
+        // Include propositions on all responses, overridden with data as needed
+        onResponse(() => ({
+          propositions: []
+        }));
+        onRequestFailure(() => showContainers());
+        if (isAuthoringModeEnabled()) {
+          logger.warn(_loggerMessage.AUTHORING_ENABLED);
+
+          // If we are in authoring mode we disable personalization
+          mergeQuery(event, {
+            enabled: false
+          });
+          return Promise.resolve();
+        }
+        const personalizationDetails = (0, _createPersonalizationDetails.default)({
+          getPageLocation,
+          renderDecisions,
+          decisionScopes,
+          personalization,
+          event,
+          isCacheInitialized: viewCache.isInitialized(),
+          logger
+        });
+        const decisionsMetaPromises = [];
+        if (personalizationDetails.shouldIncludeRenderedPropositions()) {
+          decisionsMetaPromises.push(renderedPropositions.clear());
+        }
+        if (personalizationDetails.shouldFetchData()) {
+          const cacheUpdate = viewCache.createCacheUpdate(personalizationDetails.getViewName());
+          onRequestFailure(() => cacheUpdate.cancel());
+          fetchDataHandler({
+            cacheUpdate,
+            personalizationDetails,
+            event,
+            onResponse
+          });
+        } else if (personalizationDetails.shouldUseCachedData()) {
+          decisionsMetaPromises.push(viewChangeHandler({
+            personalizationDetails,
+            event,
+            onResponse,
+            onRequestFailure
+          }));
+        }
+
+        // This promise.all waits for both the pending display notifications to be resolved
+        // (i.e. the top of page call to finish rendering) and the view change handler to
+        // finish rendering anything for this view.
+        return Promise.all(decisionsMetaPromises).then(decisionsMetas => {
+          // We only want to call mergeDecisionsMeta once, but we can get the propositions
+          // from two places: the pending display notifications and the view change handler.
+          const decisionsMeta = decisionsMetas.flatMap(dms => dms);
+          if ((0, _index.isNonEmptyArray)(decisionsMeta)) {
+            mergeDecisionsMeta(event, decisionsMeta, [_propositionEventType.PropositionEventType.DISPLAY]);
+          }
+        });
+      },
+      onClick({
+        event,
+        clickedElement
+      }) {
+        onClickHandler({
+          event,
+          clickedElement
+        });
+      }
+    },
+    commands: {
+      applyPropositions: {
+        optionsValidator: options => (0, _validateApplyPropositionsOptions.default)({
+          logger,
+          options
+        }),
+        run: applyPropositions
+      }
+    }
+  };
+};
+exports.default = _default;

package/libEs5/components/Personalization/createFetchDataHandler.js

@@ -0,0 +1,123 @@
+"use strict";
+
+exports.default = void 0;
+var _index = require("../../utils/index.js");
+var _pageWideScope = require("../../constants/pageWideScope.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 DECISIONS_HANDLE = "personalization:decisions";
+var _default = ({
+  logger,
+  prehidingStyle,
+  showContainers,
+  hideContainers,
+  mergeQuery,
+  processPropositions,
+  createProposition,
+  notificationHandler,
+  consent
+}) => {
+  return ({
+    cacheUpdate,
+    personalizationDetails,
+    event,
+    onResponse
+  }) => {
+    const {
+      state,
+      wasSet
+    } = consent.current();
+    if (!(state === "out" && wasSet)) {
+      if (personalizationDetails.isRenderDecisions()) {
+        hideContainers(prehidingStyle);
+      } else {
+        showContainers();
+      }
+    }
+    mergeQuery(event, personalizationDetails.createQueryDetails());
+
+    // This needs to be called before the response so that future sendEvent calls
+    // can know to wait until this request is complete for pending display notifications.
+    const handleNotifications = notificationHandler(personalizationDetails.isRenderDecisions(), personalizationDetails.isSendDisplayEvent(), personalizationDetails.getViewName());
+    onResponse(({
+      response
+    }) => {
+      const handles = response.getPayloadsByType(DECISIONS_HANDLE);
+      if (!(0, _index.isNonEmptyArray)(handles)) {
+        logger.logOnContentRendering({
+          status: "no-offers",
+          message: "No offers were returned.",
+          logLevel: "info",
+          detail: {
+            query: personalizationDetails.createQueryDetails()
+          }
+        });
+      }
+      const propositions = handles.map(handle => createProposition(handle));
+      const {
+        page: pagePropositions = [],
+        view: viewPropositions = [],
+        proposition: nonRenderedPropositions = []
+      } = (0, _index.groupBy)(propositions, p => p.getScopeType());
+      const currentViewPropositions = cacheUpdate.update(viewPropositions);
+      let render;
+      let returnedPropositions;
+      let returnedDecisions;
+      if (personalizationDetails.isRenderDecisions()) {
+        ({
+          render,
+          returnedPropositions,
+          returnedDecisions
+        } = processPropositions([...pagePropositions, ...currentViewPropositions], nonRenderedPropositions));
+        if ((0, _index.isNonEmptyArray)(pagePropositions)) {
+          logger.logOnContentRendering({
+            status: "rendering-started",
+            message: "Started rendering propositions for page-wide scope.",
+            logLevel: "info",
+            detail: {
+              scope: _pageWideScope.default,
+              propositions: pagePropositions.map(proposition => proposition.toJSON())
+            }
+          });
+        }
+        if ((0, _index.isNonEmptyArray)(currentViewPropositions)) {
+          logger.logOnContentRendering({
+            status: "rendering-started",
+            message: "Rendering propositions started for view scope - " + personalizationDetails.getViewName() + ".",
+            logLevel: "info",
+            detail: {
+              scope: personalizationDetails.getViewName(),
+              propositions: currentViewPropositions.map(proposition => proposition.toJSON())
+            }
+          });
+        }
+        render().then(handleNotifications);
+
+        // Render could take a long time especially if one of the renders
+        // is waiting for html to appear on the page. We show the containers
+        // immediately, and whatever renders quickly will not have flicker.
+        showContainers();
+      } else {
+        ({
+          returnedPropositions,
+          returnedDecisions
+        } = processPropositions([], [...pagePropositions, ...currentViewPropositions, ...nonRenderedPropositions]));
+      }
+      return {
+        propositions: returnedPropositions,
+        decisions: returnedDecisions
+      };
+    });
+  };
+};
+exports.default = _default;

package/libEs5/components/Personalization/createGetPageLocation.js

@@ -0,0 +1,20 @@
+"use strict";
+
+exports.default = void 0;
+/*
+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.
+*/
+var _default = ({
+  window
+}) => () => {
+  return window.location;
+};
+exports.default = _default;

package/libEs5/components/Personalization/createHandleConsentFlicker.js

@@ -0,0 +1,30 @@
+"use strict";
+
+exports.default = void 0;
+var _consentStatus = require("../../constants/consentStatus.js");
+/*
+Copyright 2024 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 = ({
+  showContainers,
+  consent
+}) => () => {
+  const {
+    state,
+    wasSet
+  } = consent.current();
+  if (state === _consentStatus.OUT && wasSet) {
+    showContainers();
+  } else {
+    consent.awaitConsent().catch(showContainers);
+  }
+};
+exports.default = _default;

package/libEs5/components/Personalization/createInteractionStorage.js

@@ -0,0 +1,87 @@
+"use strict";
+
+exports.default = void 0;
+/*
+Copyright 2020 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 = () => {
+  const clickMetaStorage = {};
+  /*
+        clickMetaStorage example.
+        `abc' and 'def' are proposition IDs.  1 is an interact id.  The object with an id, scope and scopeDetails
+        is the notification.
+           {
+            1: {
+              "abc": { "id": "abc", "scope": "proposition", "scopeDetails": {} },
+              "def": { "id": "def", "scope": "proposition", "scopeDetails": {} }
+            }
+          }
+  */
+
+  const clickItemStorage = {};
+  /*
+        clickItemStorage example.
+        `abc' and 'def' are proposition IDs.  1 is an interact id.  The sets contain proposition-item IDs which
+        are used in notifications that are sent.
+           {
+            1: {
+              abc: new Set(["itemAAA", "itemCCC"]),
+              def: new Set(["itemEEE", "itemFFF"]),
+            },
+          }
+  */
+
+  const storeInteractionMeta = (propositionId, itemId, scopeType, notification, interactId) => {
+    interactId = parseInt(interactId, 10);
+    if (!clickMetaStorage[interactId]) {
+      clickMetaStorage[interactId] = {};
+      clickItemStorage[interactId] = {};
+    }
+    if (!clickItemStorage[interactId][propositionId]) {
+      clickItemStorage[interactId][propositionId] = new Set();
+    }
+    clickItemStorage[interactId][propositionId].add(itemId);
+    clickMetaStorage[interactId][propositionId] = {
+      ...notification,
+      scopeType
+    };
+  };
+  const getInteractionMetas = interactIds => {
+    if (!Array.isArray(interactIds) || interactIds.length === 0) {
+      return [];
+    }
+    return Object.values(interactIds.map(value => parseInt(value, 10)).reduce((metaMap, interactId) => {
+      Object.keys(clickMetaStorage[interactId] || {}).forEach(propositionId => {
+        if (!metaMap[propositionId]) {
+          metaMap[propositionId] = {
+            proposition: clickMetaStorage[interactId][propositionId],
+            items: new Set()
+          };
+        }
+        metaMap[propositionId].items = new Set([...metaMap[propositionId].items, ...clickItemStorage[interactId][propositionId]]);
+      });
+      return metaMap;
+    }, {})).map(({
+      proposition,
+      items
+    }) => ({
+      ...proposition,
+      items: Array.from(items).map(id => ({
+        id
+      }))
+    }));
+  };
+  return {
+    storeInteractionMeta,
+    getInteractionMetas
+  };
+};
+exports.default = _default;

package/libEs5/components/Personalization/createNotificationHandler.js

@@ -0,0 +1,49 @@
+"use strict";
+
+exports.default = void 0;
+var _index = require("../../utils/index.js");
+var _eventType = require("../../constants/eventType.js");
+var _isNonEmptyArray = require("../../utils/isNonEmptyArray.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 = (collect, renderedPropositions) => {
+  return (isRenderDecisions, isSendDisplayEvent, viewName) => {
+    if (!isRenderDecisions) {
+      // If we aren't rendering anything, then we don't need to sendDisplayEvents.
+      return () => undefined;
+    }
+    if (!isSendDisplayEvent) {
+      const renderedPropositionsDeferred = (0, _index.defer)();
+      renderedPropositions.concat(renderedPropositionsDeferred.promise);
+      return renderedPropositionsDeferred.resolve;
+    }
+    return (decisionsMetaDisplay = [], decisionsMetaSuppressed = []) => {
+      if ((0, _isNonEmptyArray.default)(decisionsMetaDisplay)) {
+        collect({
+          decisionsMeta: decisionsMetaDisplay,
+          viewName
+        });
+      }
+      if ((0, _isNonEmptyArray.default)(decisionsMetaSuppressed)) {
+        collect({
+          decisionsMeta: decisionsMetaSuppressed,
+          eventType: _eventType.SUPPRESS,
+          propositionAction: {
+            reason: "Conflict"
+          },
+          viewName
+        });
+      }
+    };
+  };
+};
+exports.default = _default;