@adobe/alloy 2.32.1-beta.0 → 2.33.0-beta.2

package/src/components/Personalization/createFetchDataHandler.js

@@ -0,0 +1,149 @@
+/*
+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 { groupBy, isNonEmptyArray } from "@adobe/alloy-core/utils";
+import PAGE_WIDE_SCOPE from "@adobe/alloy-core/constants/pageWideScope.js";
+import { REDIRECT_ITEM } from "@adobe/alloy-core/constants/schema.js";
+
+const DECISIONS_HANDLE = "personalization:decisions";
+
+export default ({
+  logger,
+  prehidingStyle,
+  showContainers,
+  hideContainers,
+  mergeQuery,
+  processPropositions,
+  createProposition,
+  notificationHandler,
+  consent,
+}) => {
+  return ({
+    cacheUpdate,
+    personalizationDetails,
+    event,
+    onResponse,
+    identityMap,
+  }) => {
+    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(),
+      identityMap,
+    );
+
+    onResponse(({ response }) => {
+      const handles = response.getPayloadsByType(DECISIONS_HANDLE);
+      if (!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, true, false, identityMap),
+      );
+      const {
+        page: pagePropositions = [],
+        view: viewPropositions = [],
+        proposition: nonRenderedPropositions = [],
+      } = 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 (isNonEmptyArray(pagePropositions)) {
+          logger.logOnContentRendering({
+            status: "rendering-started",
+            message: "Started rendering propositions for page-wide scope.",
+            logLevel: "info",
+            detail: {
+              scope: PAGE_WIDE_SCOPE,
+              propositions: pagePropositions.map((proposition) =>
+                proposition.toJSON(),
+              ),
+            },
+          });
+        }
+
+        if (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.
+        // However, skip showing containers if there's only one page proposition with a single REDIRECT_ITEM
+        const shouldSkipShowContainers =
+          pagePropositions.length === 1 &&
+          pagePropositions[0]
+            .getItems()
+            .every((p) => p.getSchema() === REDIRECT_ITEM);
+
+        if (!shouldSkipShowContainers) {
+          showContainers();
+        }
+      } else {
+        ({ returnedPropositions, returnedDecisions } = processPropositions(
+          [],
+          [
+            ...pagePropositions,
+            ...currentViewPropositions,
+            ...nonRenderedPropositions,
+          ],
+        ));
+      }
+
+      return {
+        propositions: returnedPropositions,
+        decisions: returnedDecisions,
+      };
+    });
+  };
+};

package/src/components/Personalization/createGetPageLocation.js

@@ -0,0 +1,16 @@
+/*
+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.
+*/
+
+export default ({ window }) =>
+  () => {
+    return window.location;
+  };

package/src/components/Personalization/createHandleConsentFlicker.js

@@ -0,0 +1,22 @@
+/*
+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.
+*/
+import { OUT } from "@adobe/alloy-core/constants/consentStatus.js";
+
+export default ({ showContainers, consent }) =>
+  () => {
+    const { state, wasSet } = consent.current();
+    if (state === OUT && wasSet) {
+      showContainers();
+    } else {
+      consent.awaitConsent().catch(showContainers);
+    }
+  };

package/src/components/Personalization/createInteractionStorage.js

@@ -0,0 +1,104 @@
+/*
+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.
+*/
+
+export 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,
+  };
+};

package/src/components/Personalization/createNotificationHandler.js

@@ -0,0 +1,49 @@
+/*
+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 { defer } from "@adobe/alloy-core/utils";
+import { SUPPRESS } from "@adobe/alloy-core/constants/eventType.js";
+import isNonEmptyArray from "@adobe/alloy-core/utils/isNonEmptyArray.js";
+
+export default (collect, renderedPropositions) => {
+  return (isRenderDecisions, isSendDisplayEvent, viewName, identityMap) => {
+    if (!isRenderDecisions) {
+      // If we aren't rendering anything, then we don't need to sendDisplayEvents.
+      return () => undefined;
+    }
+
+    if (!isSendDisplayEvent) {
+      const renderedPropositionsDeferred = defer();
+      renderedPropositions.concat(renderedPropositionsDeferred.promise);
+      return renderedPropositionsDeferred.resolve;
+    }
+
+    return (decisionsMetaDisplay = [], decisionsMetaSuppressed = []) => {
+      if (isNonEmptyArray(decisionsMetaDisplay)) {
+        collect({
+          decisionsMeta: decisionsMetaDisplay,
+          viewName,
+          identityMap,
+        });
+      }
+
+      if (isNonEmptyArray(decisionsMetaSuppressed)) {
+        collect({
+          decisionsMeta: decisionsMetaSuppressed,
+          eventType: SUPPRESS,
+          propositionAction: { reason: "Conflict" },
+          viewName,
+          identityMap,
+        });
+      }
+    };
+  };
+};

package/src/components/Personalization/createOnClickHandler.js

@@ -0,0 +1,102 @@
+/*
+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.
+*/
+
+import { isNonEmptyArray } from "@adobe/alloy-core/utils";
+import { INTERACT } from "@adobe/alloy-core/constants/eventType.js";
+import { PropositionEventType } from "@adobe/alloy-core/constants/propositionEventType.js";
+
+const createPropositionAction = (clickLabel, clickToken) => {
+  if (!clickToken && !clickLabel) {
+    return undefined;
+  }
+
+  const propositionAction = {};
+
+  if (clickLabel) {
+    propositionAction.label = clickLabel;
+  }
+
+  if (clickToken) {
+    propositionAction.tokens = [clickToken];
+  }
+
+  return propositionAction;
+};
+
+export default ({
+  mergeDecisionsMeta,
+  collectInteractions,
+  collectClicks,
+  getInteractionMetas,
+  getClickMetas,
+  getClickSelectors,
+  autoCollectPropositionInteractions,
+}) => {
+  // Called when an element qualifying for conversion within an offer is clicked.
+  return ({ event, clickedElement }) => {
+    const decisionsMeta = [];
+    let propositionActionLabel;
+    let propositionActionToken;
+    let viewName;
+
+    [
+      collectInteractions(
+        clickedElement,
+        getInteractionMetas,
+        autoCollectPropositionInteractions,
+      ),
+      collectClicks(clickedElement, getClickSelectors(), getClickMetas),
+    ].forEach(
+      ({
+        decisionsMeta: curDecisionsMeta,
+        propositionActionLabel: curPropositionActionLabel,
+        propositionActionToken: curPropositionActionToken,
+        viewName: curViewName,
+      }) => {
+        Array.prototype.push.apply(decisionsMeta, curDecisionsMeta);
+
+        if (!propositionActionLabel && curPropositionActionLabel) {
+          propositionActionLabel = curPropositionActionLabel;
+        }
+
+        if (!propositionActionToken && curPropositionActionToken) {
+          propositionActionToken = curPropositionActionToken;
+        }
+
+        if (!viewName && curViewName) {
+          viewName = curViewName;
+        }
+      },
+    );
+
+    if (isNonEmptyArray(decisionsMeta)) {
+      const xdm = { eventType: INTERACT };
+
+      if (viewName) {
+        xdm.web = {
+          webPageDetails: {
+            viewName,
+          },
+        };
+      }
+
+      event.mergeXdm(xdm);
+
+      mergeDecisionsMeta(
+        event,
+        decisionsMeta,
+        [PropositionEventType.INTERACT],
+        createPropositionAction(propositionActionLabel, propositionActionToken),
+      );
+    }
+  };
+};

package/src/components/Personalization/createOnDecisionHandler.js

@@ -0,0 +1,98 @@
+/*
+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 "@adobe/alloy-core/constants/schema.js";
+
+// When multiple In-App messages propositions are returned, we need to show only one
+// of them (the one with lowest rank). This function keep track of the number of
+// times it was called. It returns false for the first proposition that contains
+// In-App messages items, true afterwards.
+const createShouldSuppressDisplay = () => {
+  let count = 0;
+  return (proposition) => {
+    const { items = [] } = proposition;
+
+    if (!items.some((item) => item.schema === MESSAGE_IN_APP)) {
+      return false;
+    }
+    count += 1;
+
+    return count > 1;
+  };
+};
+
+export default ({
+  processPropositions,
+  createProposition,
+  notificationHandler,
+}) => {
+  return ({
+    renderDecisions,
+    propositions,
+    event,
+    personalization = {},
+    identityMap,
+  }) => {
+    if (!renderDecisions) {
+      return Promise.resolve();
+    }
+
+    const { sendDisplayEvent = true } = personalization;
+    const viewName = event ? event.getViewName() : undefined;
+
+    const shouldSuppressDisplay = createShouldSuppressDisplay();
+
+    const propositionsToExecute = propositions.map((proposition) =>
+      createProposition(
+        proposition,
+        true,
+        shouldSuppressDisplay(proposition),
+        identityMap,
+      ),
+    );
+
+    const { render, returnedPropositions } = processPropositions(
+      propositionsToExecute,
+    );
+
+    const handleNotifications = notificationHandler(
+      renderDecisions,
+      sendDisplayEvent,
+      viewName,
+      identityMap,
+    );
+
+    const propositionsById = propositionsToExecute.reduce(
+      (tot, proposition) => {
+        tot[proposition.getId()] = proposition;
+        return tot;
+      },
+      {},
+    );
+
+    render().then((decisionsMeta) => {
+      const decisionsMetaDisplay = decisionsMeta.filter(
+        (meta) => !propositionsById[meta.id].shouldSuppressDisplay(),
+      );
+
+      const decisionsMetaSuppressed = decisionsMeta.filter((meta) =>
+        propositionsById[meta.id].shouldSuppressDisplay(),
+      );
+
+      handleNotifications(decisionsMetaDisplay, decisionsMetaSuppressed);
+    });
+
+    return Promise.resolve({
+      propositions: returnedPropositions,
+    });
+  };
+};

package/src/components/Personalization/createPersonalizationDetails.js

@@ -0,0 +1,138 @@
+/*
+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.
+*/
+
+import { isNonEmptyString, isNonEmptyArray } from "@adobe/alloy-core/utils";
+import PAGE_WIDE_SCOPE from "@adobe/alloy-core/constants/pageWideScope.js";
+import {
+  DEFAULT_CONTENT_ITEM,
+  DOM_ACTION,
+  HTML_CONTENT_ITEM,
+  MESSAGE_IN_APP,
+  JSON_CONTENT_ITEM,
+  REDIRECT_ITEM,
+  RULESET_ITEM,
+  MESSAGE_CONTENT_CARD,
+} from "@adobe/alloy-core/constants/schema.js";
+import {
+  buildPageSurface,
+  normalizeSurfaces,
+} from "@adobe/alloy-core/utils/surfaceUtils.js";
+
+const addPageWideScope = (scopes) => {
+  if (!scopes.includes(PAGE_WIDE_SCOPE)) {
+    scopes.push(PAGE_WIDE_SCOPE);
+  }
+};
+
+const addPageSurface = (surfaces, getPageLocation) => {
+  const pageSurface = buildPageSurface(getPageLocation);
+  if (!surfaces.includes(pageSurface)) {
+    surfaces.push(pageSurface);
+  }
+};
+
+const dedupe = (array) =>
+  array.filter((item, pos) => array.indexOf(item) === pos);
+
+export default ({
+  getPageLocation,
+  renderDecisions,
+  decisionScopes,
+  personalization,
+  event,
+  isCacheInitialized,
+  logger,
+}) => {
+  const viewName = event.getViewName();
+  return {
+    isRenderDecisions() {
+      return renderDecisions;
+    },
+    isSendDisplayEvent() {
+      return !!personalization.sendDisplayEvent;
+    },
+    shouldIncludeRenderedPropositions() {
+      return !!personalization.includeRenderedPropositions;
+    },
+    getViewName() {
+      return viewName;
+    },
+    hasScopes() {
+      return (
+        decisionScopes.length > 0 ||
+        isNonEmptyArray(personalization.decisionScopes)
+      );
+    },
+    hasSurfaces() {
+      return isNonEmptyArray(personalization.surfaces);
+    },
+    hasViewName() {
+      return isNonEmptyString(viewName);
+    },
+    createQueryDetails() {
+      const scopes = [...decisionScopes];
+      if (isNonEmptyArray(personalization.decisionScopes)) {
+        scopes.push(...personalization.decisionScopes);
+      }
+      const eventSurfaces = normalizeSurfaces(
+        personalization.surfaces,
+        getPageLocation,
+        logger,
+      );
+
+      if (this.shouldRequestDefaultPersonalization()) {
+        addPageWideScope(scopes);
+        addPageSurface(eventSurfaces, getPageLocation);
+      }
+
+      const schemas = [
+        DEFAULT_CONTENT_ITEM,
+        HTML_CONTENT_ITEM,
+        JSON_CONTENT_ITEM,
+        REDIRECT_ITEM,
+        RULESET_ITEM,
+        MESSAGE_IN_APP,
+        MESSAGE_CONTENT_CARD,
+      ];
+
+      if (scopes.includes(PAGE_WIDE_SCOPE)) {
+        schemas.push(DOM_ACTION);
+      }
+
+      return {
+        schemas,
+        decisionScopes: dedupe(scopes),
+        surfaces: dedupe(eventSurfaces),
+      };
+    },
+    isCacheInitialized() {
+      return isCacheInitialized;
+    },
+    shouldFetchData() {
+      return (
+        this.hasScopes() ||
+        this.hasSurfaces() ||
+        this.shouldRequestDefaultPersonalization()
+      );
+    },
+    shouldUseCachedData() {
+      return this.hasViewName() && !this.shouldFetchData();
+    },
+    shouldRequestDefaultPersonalization() {
+      return (
+        personalization.defaultPersonalizationEnabled ||
+        (!this.isCacheInitialized() &&
+          personalization.defaultPersonalizationEnabled !== false)
+      );
+    },
+  };
+};