@adobe/alloy 2.18.0 → 2.19.0-beta.0

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

@@ -0,0 +1,202 @@
+/*
+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,39 @@
+/*
+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,129 @@
+/*
+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

@@ -11,9 +11,8 @@ 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,15 +21,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,
@@ -53,43 +60,50 @@ const createPersonalization = ({
   const getPageLocation = createGetPageLocation({
     window
   });
-  const viewCache = createViewCacheManager();
-  const modules = initDomActionsModules(storeClickMetrics);
-  const executeDecisions = createExecuteDecisions({
-    modules,
-    logger,
-    executeActions
+  const modules = initDomActionsModules();
+  const preprocess = createPreprocess([remapHeadOffers, remapCustomCodeOffers]);
+  const createProposition = injectCreateProposition({
+    preprocess,
+    isPageWideSurface
   });
-  const handleRedirectDecisions = createRedirectHandler({
-    collect,
-    window,
-    logger,
-    showContainers
+  const viewCache = createViewCacheManager({
+    createProposition
   });
-  const autoRenderingHandler = createAutorenderingHandler({
-    viewCache,
-    executeDecisions,
-    showContainers,
-    collect
-  });
-  const applyPropositions = createApplyPropositions({
-    executeDecisions
-  });
-  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,7 +136,8 @@ const createPersonalization = ({
     viewCache,
     showContainers,
     applyPropositions,
-    setTargetMigration
+    setTargetMigration,
+    pendingNotificationsHandler
   });
 };
 

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

@@ -0,0 +1,37 @@
+/*
+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;
+    }
+
+  };
+});

package/libEs6/components/Personalization/validateApplyPropositionsOptions.js

@@ -9,7 +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 { anything, objectOf, arrayOf } from "../../utils/validation";
+import { anything, objectOf, arrayOf, string } from "../../utils/validation";
 export const EMPTY_PROPOSITIONS = {
   propositions: []
 };
@@ -18,8 +18,9 @@ export default (({
   options
 }) => {
   const applyPropositionsOptionsValidator = objectOf({
-    propositions: arrayOf(objectOf(anything())).nonEmpty(),
-    metadata: objectOf(anything())
+    propositions: arrayOf(objectOf(anything())),
+    metadata: objectOf(anything()),
+    viewName: string()
   }).required();
 
   try {

package/libEs6/constants/libraryVersion.js

@@ -11,4 +11,4 @@ governing permissions and limitations under the License.
 */
 // The __VERSION__ keyword will be replace at alloy build time with the package.json version.
 // see babel-plugin-version
-export default "2.18.0";
+export default "2.19.0-beta.0";

package/libEs6/core/createEvent.js

@@ -9,7 +9,16 @@ 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 { isEmptyObject, deepAssign } from "../utils";
+import { isEmptyObject, deepAssign, isNonEmptyArray, deduplicateArray } from "../utils";
+
+const getXdmPropositions = xdm => {
+  return xdm && // eslint-disable-next-line no-underscore-dangle
+  xdm._experience && // eslint-disable-next-line no-underscore-dangle
+  xdm._experience.decisioning && // eslint-disable-next-line no-underscore-dangle
+  isNonEmptyArray(xdm._experience.decisioning.propositions) ? // eslint-disable-next-line no-underscore-dangle
+  xdm._experience.decisioning.propositions : [];
+};
+
 export default (() => {
   const content = {};
   let userXdm;
@@ -74,8 +83,15 @@ export default (() => {
         return;
       }
 
+      const newPropositions = deduplicateArray([...getXdmPropositions(userXdm), ...getXdmPropositions(content.xdm)], (a, b) => a === b || a.id && b.id && a.id === b.id && a.scope && b.scope && a.scope === b.scope);
+
       if (userXdm) {
-        event.mergeXdm(userXdm);
+        this.mergeXdm(userXdm);
+      }
+
+      if (newPropositions.length > 0) {
+        // eslint-disable-next-line no-underscore-dangle
+        content.xdm._experience.decisioning.propositions = newPropositions;
       }
 
       if (userData) {
@@ -122,7 +138,7 @@ export default (() => {
     },
 
     getViewName() {
-      if (!userXdm || !userXdm.web || !userXdm.web.webPageDetails) {
+      if (!userXdm || !userXdm.web || !userXdm.web.webPageDetails || !userXdm.web.webPageDetails.viewName) {
         return undefined;
       }
 

package/libEs6/core/createEventManager.js

@@ -116,7 +116,8 @@ export default (({
         responseHeaders = {},
         responseBody = {
           handle: []
-        }
+        },
+        personalization
       } = options;
       const payload = createDataCollectionRequestPayload();
       const request = createDataCollectionRequest({
@@ -127,7 +128,7 @@ export default (({
         event,
         renderDecisions,
         decisionScopes: [PAGE_WIDE_SCOPE],
-        personalization: {},
+        personalization,
         onResponse: onResponseCallbackAggregator.add,
         onRequestFailure: noop
       }).then(() => {

package/libEs6/utils/deduplicateArray.js

@@ -0,0 +1,26 @@
+/*
+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 REFERENCE_EQUALITY = (a, b) => a === b;
+
+const findIndex = (array, item, isEqual) => {
+  for (let i = 0; i < array.length; i += 1) {
+    if (isEqual(array[i], item)) {
+      return i;
+    }
+  }
+
+  return -1;
+};
+
+export default ((array, isEqual = REFERENCE_EQUALITY) => {
+  return array.filter((item, index) => findIndex(array, item, isEqual) === index);
+});