@adobe/alloy 2.28.0 → 2.28.1-beta.0

package/libEs6/components/Personalization/handlers/createProcessPropositions.js

@@ -0,0 +1,214 @@
+/*
+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 "../../../utils/index.js";
+export default ({
+  schemaProcessors,
+  logger
+}) => {
+  const wrapRenderWithLogging = (render, item) => () => {
+    return Promise.resolve().then(render).then(() => {
+      if (logger.enabled) {
+        logger.info(`Action ${item.toString()} executed.`);
+      }
+      return item.toJSON();
+    }).catch(error => {
+      const {
+        message,
+        stack
+      } = error;
+      const warning = `Failed to execute action ${item.toString()}. ${message} ${stack}`;
+      logger.logOnContentRendering({
+        status: "rendering-failed",
+        detail: {
+          propositionDetails: item.getProposition().getNotification(),
+          item: item.toJSON()
+        },
+        error,
+        message: warning,
+        logLevel: "warn"
+      });
+      return undefined;
+    });
+  };
+  const renderItems = async (renderers, meta) => {
+    const results = await Promise.allSettled(renderers.map(renderer => renderer()));
+    const successes = results.filter(result => result.status === "fulfilled").map(result => result.value);
+    // as long as at least one renderer succeeds, we want to add the notification
+    // to the display notifications
+    if (meta && isNonEmptyArray(successes)) {
+      return {
+        ...meta,
+        items: successes
+      };
+    }
+    return undefined;
+  };
+  const processItem = item => {
+    const processor = schemaProcessors[item.getSchema()];
+    if (!processor) {
+      return {};
+    }
+    return processor(item);
+  };
+  const processItems = ({
+    renderers: existingRenderers,
+    returnedPropositions: existingReturnedPropositions,
+    returnedDecisions: existingReturnedDecisions,
+    items,
+    proposition
+  }) => {
+    let renderers = [...existingRenderers];
+    let returnedPropositions = [...existingReturnedPropositions];
+    let returnedDecisions = [...existingReturnedDecisions];
+    let renderedItems = [];
+    let nonRenderedItems = [];
+    let itemRenderers = [];
+    let atLeastOneWithNotification = false;
+    let render;
+    let setRenderAttempted;
+    let includeInNotification;
+    let onlyRenderThis = false;
+    let i = 0;
+    let item;
+    while (items.length > i) {
+      item = items[i];
+      ({
+        render,
+        setRenderAttempted,
+        includeInNotification,
+        onlyRenderThis
+      } = processItem(item));
+      if (onlyRenderThis) {
+        returnedPropositions = [];
+        returnedDecisions = [];
+        if (setRenderAttempted) {
+          renderedItems = [item];
+          nonRenderedItems = [];
+        } else {
+          renderedItems = [];
+          nonRenderedItems = [item];
+        }
+        renderers = [];
+        itemRenderers = [render];
+        atLeastOneWithNotification = includeInNotification;
+        break;
+      }
+      if (render) {
+        itemRenderers.push(wrapRenderWithLogging(render, item));
+      }
+      if (includeInNotification) {
+        atLeastOneWithNotification = true;
+      }
+      if (setRenderAttempted) {
+        renderedItems.push(item);
+      } else {
+        nonRenderedItems.push(item);
+      }
+      i += 1;
+    }
+    if (itemRenderers.length > 0) {
+      const meta = atLeastOneWithNotification ? proposition.getNotification() : undefined;
+      renderers.push(() => renderItems(itemRenderers, meta));
+    } else if (atLeastOneWithNotification) {
+      renderers.push(() => Promise.resolve(proposition.getNotification()));
+    }
+    if (renderedItems.length > 0) {
+      proposition.addToReturnValues(returnedPropositions, returnedDecisions, renderedItems, true);
+    }
+    if (nonRenderedItems.length > 0) {
+      proposition.addToReturnValues(returnedPropositions, returnedDecisions, nonRenderedItems, false);
+    }
+    return {
+      renderers,
+      returnedPropositions,
+      returnedDecisions,
+      onlyRenderThis
+    };
+  };
+  return (renderPropositions, nonRenderPropositions = []) => {
+    let renderers = [];
+    let returnedPropositions = [];
+    let returnedDecisions = [];
+    let onlyRenderThis;
+    let i = 0;
+    let proposition;
+    let items;
+    while (renderPropositions.length > i) {
+      proposition = renderPropositions[i];
+      items = proposition.getItems();
+      ({
+        renderers,
+        returnedPropositions,
+        returnedDecisions,
+        onlyRenderThis
+      } = processItems({
+        renderers,
+        returnedPropositions,
+        returnedDecisions,
+        items,
+        proposition
+      }));
+      if (onlyRenderThis) {
+        break;
+      }
+      i += 1;
+    }
+    if (onlyRenderThis) {
+      // if onlyRenderThis is true, that means returnedPropositions and returnedDecisions
+      // only contains the proposition that triggered only rendering this. We need to
+      // add the other propositions to the returnedPropositions and returnedDecisions.
+      renderPropositions.forEach((p, index) => {
+        if (index !== i) {
+          p.addToReturnValues(returnedPropositions, returnedDecisions, p.getItems(), false);
+        }
+      });
+    }
+    nonRenderPropositions.forEach(p => {
+      p.addToReturnValues(returnedPropositions, returnedDecisions, p.getItems(), false);
+    });
+    const render = () => {
+      return Promise.all(renderers.map(renderer => renderer())).then(metas => {
+        const propositions = metas.filter(meta => meta);
+        const renderedPropositions = propositions.map(prop => {
+          const {
+            id,
+            scope,
+            scopeDetails
+          } = prop;
+          return {
+            id,
+            scope,
+            scopeDetails
+          };
+        });
+        if (isNonEmptyArray(propositions)) {
+          const propsByScope = groupBy(propositions, p => p.scope);
+          logger.logOnContentRendering({
+            status: "rendering-succeeded",
+            detail: {
+              ...propsByScope
+            },
+            message: `Scopes: ${JSON.stringify(propsByScope)} successfully executed.`,
+            logLevel: "info"
+          });
+        }
+        return renderedPropositions;
+      });
+    };
+    return {
+      returnedPropositions,
+      returnedDecisions,
+      render
+    };
+  };
+};

package/libEs6/components/Personalization/handlers/createProcessRedirect.js

@@ -0,0 +1,56 @@
+/*
+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 { hideElements, showElements } from "../flicker/index.js";
+const REDIRECT_HIDING_ELEMENT = "BODY";
+export default ({
+  logger,
+  executeRedirect,
+  collect
+}) => item => {
+  const {
+    content
+  } = item.getData() || {};
+  if (!content) {
+    logger.warn("Invalid Redirect data", item.getData());
+    return {};
+  }
+  const render = () => {
+    hideElements(REDIRECT_HIDING_ELEMENT);
+    return collect({
+      decisionsMeta: [item.getProposition().getNotification()],
+      documentMayUnload: true
+    }).then(() => {
+      logger.logOnContentRendering({
+        status: "rendering-redirect",
+        detail: {
+          propositionDetails: item.getProposition().getNotification(),
+          redirect: content
+        },
+        message: `Redirect action ${item.toString()} executed.`,
+        logLevel: "info"
+      });
+      return executeRedirect(content);
+      // Execute redirect will never resolve. If there are bottom of page events that are waiting
+      // for display notifications from this request, they will never run because this promise will
+      // not resolve. This is intentional because we don't want to run bottom of page events if
+      // there is a redirect.
+    }).catch(error => {
+      showElements(REDIRECT_HIDING_ELEMENT);
+      throw error;
+    });
+  };
+  return {
+    render,
+    setRenderAttempted: true,
+    onlyRenderThis: true
+  };
+};

package/libEs6/components/Personalization/handlers/createRenderStatusHandler.js

@@ -0,0 +1,56 @@
+/*
+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.
+*/
+import { VIEW_SCOPE_TYPE } from "../constants/scopeType.js";
+
+/**
+ * Creates a handler to manage the rendering status of elements in personalization
+ *
+ * @param {string} scopeType - The type of scope (e.g. 'view', 'page')
+ * @param {string} itemId - The unique identifier for the item being rendered
+ */
+export default (scopeType, itemId) => {
+  // We only care about tracking renders for view scope
+  if (scopeType !== VIEW_SCOPE_TYPE) {
+    return {
+      shouldRender: () => true,
+      markAsRendered: () => {}
+    };
+  }
+  return {
+    /**
+     * Determines if an element should be rendered based on scopeType and previous render status
+     *
+     * @param {Element|null} propositionContainer - The DOM element to check
+     * @returns {boolean} True if the element should be rendered, false otherwise
+     */
+    shouldRender: propositionContainer => {
+      if (!propositionContainer) {
+        return true;
+      }
+      const previouslyRendered = (propositionContainer.dataset.adobePropositionIds ?? "").split(",");
+      return !previouslyRendered.includes(itemId);
+    },
+    /**
+     * Marks an element as rendered by setting a data attribute
+     *
+     * @param {Element} propositionContainer - The DOM element to mark as rendered
+     * @returns {void}
+     */
+    markAsRendered: propositionContainer => {
+      const previouslyRendered = (propositionContainer.dataset.adobePropositionIds ?? "").split(",");
+      if (!previouslyRendered.includes(itemId)) {
+        previouslyRendered.push(itemId);
+      }
+      propositionContainer.dataset.adobePropositionIds = previouslyRendered.sort().join(",");
+    }
+  };
+};

package/libEs6/components/Personalization/handlers/injectCreateProposition.js

@@ -0,0 +1,121 @@
+/*
+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 PAGE_WIDE_SCOPE from "../../../constants/pageWideScope.js";
+import { PAGE_SCOPE_TYPE, PROPOSITION_SCOPE_TYPE, VIEW_SCOPE_TYPE } from "../constants/scopeType.js";
+export default ({
+  preprocess,
+  isPageWideSurface
+}) => {
+  const createItem = (item, proposition) => {
+    const {
+      id,
+      schema,
+      data,
+      characteristics: {
+        trackingLabel
+      } = {}
+    } = item;
+    const schemaType = data ? data.type : undefined;
+    const processedData = preprocess(data);
+    return {
+      getId() {
+        return id;
+      },
+      getSchema() {
+        return schema;
+      },
+      getSchemaType() {
+        return schemaType;
+      },
+      getData() {
+        return processedData;
+      },
+      getProposition() {
+        return proposition;
+      },
+      getTrackingLabel() {
+        return trackingLabel;
+      },
+      getOriginalItem() {
+        return item;
+      },
+      toString() {
+        return JSON.stringify(item);
+      },
+      toJSON() {
+        return item;
+      }
+    };
+  };
+  return (payload, visibleInReturnedItems = true, shouldSuppressDisplay = false) => {
+    const {
+      id,
+      scope,
+      scopeDetails,
+      items = []
+    } = payload;
+    const {
+      characteristics: {
+        scopeType
+      } = {}
+    } = scopeDetails || {};
+    return {
+      getScope() {
+        return scope;
+      },
+      getScopeType() {
+        if (scope === PAGE_WIDE_SCOPE || isPageWideSurface(scope)) {
+          return PAGE_SCOPE_TYPE;
+        }
+        if (scopeType === VIEW_SCOPE_TYPE) {
+          return VIEW_SCOPE_TYPE;
+        }
+        return PROPOSITION_SCOPE_TYPE;
+      },
+      getItems() {
+        return items.map(item => createItem(item, this));
+      },
+      getNotification() {
+        return {
+          id,
+          scope,
+          scopeDetails
+        };
+      },
+      getId() {
+        return id;
+      },
+      toJSON() {
+        return payload;
+      },
+      shouldSuppressDisplay() {
+        return shouldSuppressDisplay;
+      },
+      addToReturnValues(propositions, decisions, includedItems, renderAttempted) {
+        if (visibleInReturnedItems) {
+          propositions.push({
+            ...payload,
+            items: includedItems.map(i => i.getOriginalItem()),
+            renderAttempted
+          });
+          if (!renderAttempted) {
+            decisions.push({
+              ...payload,
+              items: includedItems.map(i => i.getOriginalItem())
+            });
+          }
+        }
+      }
+    };
+  };
+};

package/libEs6/components/Personalization/handlers/processDefaultContent.js

@@ -0,0 +1,19 @@
+/*
+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 noop from "../../../utils/noop.js";
+export default () => {
+  return {
+    render: noop,
+    setRenderAttempted: true,
+    includeInNotification: true
+  };
+};