@adobe/alloy 2.18.0 → 2.19.0-beta.1

package/libEs6/components/Personalization/flicker/index.js

@@ -9,13 +9,15 @@ the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTA
 OF ANY KIND, either express or implied. See the License for the specific language
 governing permissions and limitations under the License.
 */
+
 import { createNode, appendNode, removeNode } from "../../../utils/dom";
 import { STYLE } from "../../../constants/tagName";
 import { getElementById, getNonce } from "../dom-actions/dom";
 const PREHIDING_ID = "alloy-prehiding";
-const HIDING_STYLE_DEFINITION = "{ visibility: hidden }"; // Using global is OK since we have a single DOM
-// so storing nodes even for multiple Alloy instances is fine
+const HIDING_STYLE_DEFINITION = "{ visibility: hidden }";
 
+// Using global is OK since we have a single DOM
+// so storing nodes even for multiple Alloy instances is fine
 const styleNodes = {};
 export const hideElements = prehidingSelector => {
   // if we have different events with the same
@@ -24,9 +26,9 @@ export const hideElements = prehidingSelector => {
   if (styleNodes[prehidingSelector]) {
     return;
   }
-
   const nonce = getNonce();
-  const attrs = { ...(nonce && {
+  const attrs = {
+    ...(nonce && {
       nonce
     })
   };
@@ -39,7 +41,6 @@ export const hideElements = prehidingSelector => {
 };
 export const showElements = prehidingSelector => {
   const node = styleNodes[prehidingSelector];
-
   if (node) {
     removeNode(node);
     delete styleNodes[prehidingSelector];
@@ -48,17 +49,15 @@ export const showElements = prehidingSelector => {
 export const hideContainers = prehidingStyle => {
   if (!prehidingStyle) {
     return;
-  } // If containers prehiding style has been added
+  }
+
+  // If containers prehiding style has been added
   // by customer's prehiding snippet we don't
   // want to add the same node
-
-
   const node = getElementById(PREHIDING_ID);
-
   if (node) {
     return;
   }
-
   const nonce = getNonce();
   const attrs = {
     id: PREHIDING_ID,
@@ -76,10 +75,8 @@ export const showContainers = () => {
   // If containers prehiding style exists
   // we will remove it
   const node = getElementById(PREHIDING_ID);
-
   if (!node) {
     return;
   }
-
   removeNode(node);
 };

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

@@ -0,0 +1,48 @@
+/*
+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 (({
+  modules,
+  logger,
+  storeClickMetrics
+}) => item => {
+  const {
+    type,
+    selector
+  } = item.getData() || {};
+  if (!type) {
+    logger.warn("Invalid DOM action data: missing type.", item.getData());
+    return {};
+  }
+  if (type === "click") {
+    if (!selector) {
+      logger.warn("Invalid DOM action data: missing selector.", item.getData());
+      return {};
+    }
+    storeClickMetrics({
+      selector,
+      meta: item.getMeta()
+    });
+    return {
+      setRenderAttempted: true,
+      includeInNotification: false
+    };
+  }
+  if (!modules[type]) {
+    logger.warn("Invalid DOM action data: unknown type.", item.getData());
+    return {};
+  }
+  return {
+    render: () => modules[type](item.getData()),
+    setRenderAttempted: true,
+    includeInNotification: true
+  };
+});

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

@@ -0,0 +1,34 @@
+/*
+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 (({
+  modules,
+  logger
+}) => item => {
+  const {
+    type,
+    selector
+  } = item.getData() || {};
+  if (!selector || !type) {
+    return {};
+  }
+  if (!modules[type]) {
+    logger.warn("Invalid HTML content data", item.getData());
+    return {};
+  }
+  return {
+    render: () => {
+      modules[type](item.getData());
+    },
+    setRenderAttempted: true,
+    includeInNotification: true
+  };
+});

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

@@ -0,0 +1,175 @@
+/*
+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 (({
+  schemaProcessors,
+  logger
+}) => {
+  const wrapRenderWithLogging = (render, item) => () => {
+    return Promise.resolve().then(render).then(() => {
+      if (logger.enabled) {
+        logger.info(`Action ${item.toString()} executed.`);
+      }
+      return true;
+    }).catch(error => {
+      if (logger.enabled) {
+        const {
+          message,
+          stack
+        } = error;
+        const errorMessage = `Failed to execute action ${item.toString()}. ${message} ${stack}`;
+        logger.error(errorMessage);
+      }
+      return false;
+    });
+  };
+  const renderItems = (renderers, meta) => Promise.all(renderers.map(renderer => renderer())).then(successes => {
+    // as long as at least one renderer succeeds, we want to add the notification
+    // to the display notifications
+    if (!successes.includes(true)) {
+      return undefined;
+    }
+    return meta;
+  });
+  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(() => 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 => metas.filter(meta => meta));
+    };
+    return {
+      returnedPropositions,
+      returnedDecisions,
+      render
+    };
+  };
+});

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

@@ -0,0 +1,38 @@
+/*
+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 (({
+  logger,
+  executeRedirect,
+  collect
+}) => item => {
+  const {
+    content
+  } = item.getData() || {};
+  if (!content) {
+    logger.warn("Invalid Redirect data", item.getData());
+    return {};
+  }
+  const render = () => {
+    return collect({
+      decisionsMeta: [item.getMeta()]
+    }).then(() => {
+      executeRedirect(content);
+      // We've already sent the display notification, so don't return anything
+    });
+  };
+
+  return {
+    render,
+    setRenderAttempted: true,
+    onlyRenderThis: true
+  };
+});

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

@@ -0,0 +1,113 @@
+/*
+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";
+export default (({
+  preprocess,
+  isPageWideSurface
+}) => {
+  const createItem = (item, meta) => {
+    const {
+      schema,
+      data,
+      characteristics: {
+        trackingLabel
+      } = {}
+    } = item;
+    const processedData = preprocess(data);
+    if (trackingLabel) {
+      meta.trackingLabel = trackingLabel;
+    }
+    return {
+      getSchema() {
+        return schema;
+      },
+      getData() {
+        return processedData;
+      },
+      getMeta() {
+        return meta;
+      },
+      getOriginalItem() {
+        return item;
+      },
+      toString() {
+        return JSON.stringify(item);
+      },
+      toJSON() {
+        return item;
+      }
+    };
+  };
+  return (payload, visibleInReturnedItems = true) => {
+    const {
+      id,
+      scope,
+      scopeDetails,
+      items = []
+    } = payload;
+    const {
+      characteristics: {
+        scopeType
+      } = {}
+    } = scopeDetails || {};
+    return {
+      getScope() {
+        if (!scope) {
+          return scope;
+        }
+        return scope;
+      },
+      getScopeType() {
+        if (scope === PAGE_WIDE_SCOPE || isPageWideSurface(scope)) {
+          return "page";
+        }
+        if (scopeType === "view") {
+          return "view";
+        }
+        return "proposition";
+      },
+      getItems() {
+        return items.map(item => createItem(item, {
+          id,
+          scope,
+          scopeDetails
+        }));
+      },
+      getNotification() {
+        return {
+          id,
+          scope,
+          scopeDetails
+        };
+      },
+      toJSON() {
+        return payload;
+      },
+      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/{dom-actions/clicks/index.js → handlers/processDefaultContent.js}

@@ -1,5 +1,5 @@
 /*
-Copyright 2019 Adobe. All rights reserved.
+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
@@ -9,5 +9,9 @@ the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTA
 OF ANY KIND, either express or implied. See the License for the specific language
 governing permissions and limitations under the License.
 */
-import collectClicks from "./collectClicks";
-export default collectClicks;
+export default (() => {
+  return {
+    setRenderAttempted: true,
+    includeInNotification: true
+  };
+});

package/libEs6/components/Personalization/index.js

@@ -9,11 +9,11 @@ the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTA
 OF ANY KIND, either express or implied. See the License for the specific language
 governing permissions and limitations under the License.
 */
+
 import { string, boolean, objectOf } from "../../utils/validation";
 import createComponent from "./createComponent";
-import { initDomActionsModules, executeActions } from "./dom-actions";
+import { initDomActionsModules } from "./dom-actions";
 import createCollect from "./createCollect";
-import createExecuteDecisions from "./createExecuteDecisions";
 import { hideContainers, showContainers } from "./flicker";
 import createFetchDataHandler from "./createFetchDataHandler";
 import collectClicks from "./dom-actions/clicks/collectClicks";
@@ -22,16 +22,23 @@ import { mergeDecisionsMeta, mergeQuery } from "./event";
 import createOnClickHandler from "./createOnClickHandler";
 import createViewCacheManager from "./createViewCacheManager";
 import createViewChangeHandler from "./createViewChangeHandler";
-import groupDecisions from "./groupDecisions";
-import createOnResponseHandler from "./createOnResponseHandler";
 import createClickStorage from "./createClickStorage";
-import createRedirectHandler from "./createRedirectHandler";
-import createAutorenderingHandler from "./createAutoRenderingHandler";
-import createNonRenderingHandler from "./createNonRenderingHandler";
 import createApplyPropositions from "./createApplyPropositions";
 import createGetPageLocation from "./createGetPageLocation";
 import createSetTargetMigration from "./createSetTargetMigration";
-
+import remapCustomCodeOffers from "./dom-actions/remapCustomCodeOffers";
+import remapHeadOffers from "./dom-actions/remapHeadOffers";
+import createPreprocess from "./dom-actions/createPreprocess";
+import injectCreateProposition from "./handlers/injectCreateProposition";
+import createAsyncArray from "./utils/createAsyncArray";
+import createPendingNotificationsHandler from "./createPendingNotificationsHandler";
+import * as schema from "./constants/schema";
+import processDefaultContent from "./handlers/processDefaultContent";
+import { isPageWideSurface } from "./utils/surfaceUtils";
+import createProcessDomAction from "./handlers/createProcessDomAction";
+import createProcessHtmlContent from "./handlers/createProcessHtmlContent";
+import createProcessRedirect from "./handlers/createProcessRedirect";
+import createProcessPropositions from "./handlers/createProcessPropositions";
 const createPersonalization = ({
   config,
   logger,
@@ -53,43 +60,50 @@ const createPersonalization = ({
   const getPageLocation = createGetPageLocation({
     window
   });
-  const viewCache = createViewCacheManager();
-  const modules = initDomActionsModules(storeClickMetrics);
-  const executeDecisions = createExecuteDecisions({
-    modules,
-    logger,
-    executeActions
-  });
-  const handleRedirectDecisions = createRedirectHandler({
-    collect,
-    window,
-    logger,
-    showContainers
-  });
-  const autoRenderingHandler = createAutorenderingHandler({
-    viewCache,
-    executeDecisions,
-    showContainers,
-    collect
+  const modules = initDomActionsModules();
+  const preprocess = createPreprocess([remapHeadOffers, remapCustomCodeOffers]);
+  const createProposition = injectCreateProposition({
+    preprocess,
+    isPageWideSurface
   });
-  const applyPropositions = createApplyPropositions({
-    executeDecisions
+  const viewCache = createViewCacheManager({
+    createProposition
   });
-  const nonRenderingHandler = createNonRenderingHandler({
-    viewCache
+  const schemaProcessors = {
+    [schema.DEFAULT_CONTENT_ITEM]: processDefaultContent,
+    [schema.DOM_ACTION]: createProcessDomAction({
+      modules,
+      logger,
+      storeClickMetrics
+    }),
+    [schema.HTML_CONTENT_ITEM]: createProcessHtmlContent({
+      modules,
+      logger
+    }),
+    [schema.REDIRECT_ITEM]: createProcessRedirect({
+      logger,
+      executeRedirect: url => window.location.replace(url),
+      collect
+    })
+  };
+  const processPropositions = createProcessPropositions({
+    schemaProcessors,
+    logger
   });
-  const responseHandler = createOnResponseHandler({
-    autoRenderingHandler,
-    nonRenderingHandler,
-    groupDecisions,
-    handleRedirectDecisions,
-    showContainers
+  const pendingDisplayNotifications = createAsyncArray();
+  const pendingNotificationsHandler = createPendingNotificationsHandler({
+    pendingDisplayNotifications,
+    mergeDecisionsMeta
   });
   const fetchDataHandler = createFetchDataHandler({
     prehidingStyle,
-    responseHandler,
+    showContainers,
     hideContainers,
-    mergeQuery
+    mergeQuery,
+    collect,
+    processPropositions,
+    createProposition,
+    pendingDisplayNotifications
   });
   const onClickHandler = createOnClickHandler({
     mergeDecisionsMeta,
@@ -99,8 +113,13 @@ const createPersonalization = ({
   });
   const viewChangeHandler = createViewChangeHandler({
     mergeDecisionsMeta,
-    collect,
-    executeDecisions,
+    processPropositions,
+    viewCache
+  });
+  const applyPropositions = createApplyPropositions({
+    processPropositions,
+    createProposition,
+    pendingDisplayNotifications,
     viewCache
   });
   const setTargetMigration = createSetTargetMigration({
@@ -117,10 +136,10 @@ const createPersonalization = ({
     viewCache,
     showContainers,
     applyPropositions,
-    setTargetMigration
+    setTargetMigration,
+    pendingNotificationsHandler
   });
 };
-
 createPersonalization.namespace = "Personalization";
 createPersonalization.configValidators = objectOf({
   prehidingStyle: string().nonEmpty(),

package/libEs6/components/Personalization/utils/addRenderAttemptedToDecisions.js

@@ -9,6 +9,7 @@ the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTA
 OF ANY KIND, either express or implied. See the License for the specific language
 governing permissions and limitations under the License.
 */
+
 import { assign } from "../../../utils";
 export default (({
   decisions,

package/libEs6/components/Personalization/utils/createAsyncArray.js

@@ -0,0 +1,35 @@
+/*
+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 (() => {
+  let latest = Promise.resolve([]);
+  return {
+    concat(promise) {
+      latest = latest.then(existingPropositions => {
+        return promise.then(newPropositions => {
+          return existingPropositions.concat(newPropositions);
+        }).catch(() => {
+          return existingPropositions;
+        });
+      });
+    },
+    /**
+     * Clears the saved propositions, waiting until the next propositions are resolved and available.
+     *
+     * @returns {Promise<Array>} A promise that resolves to the latest propositions.
+     */
+    clear() {
+      const oldLatest = latest;
+      latest = Promise.resolve([]);
+      return oldLatest;
+    }
+  };
+});