@adobe/alloy 2.9.0-alpha.3 → 2.9.0-alpha.6

package/libEs6/components/Personalization/createAutoRenderingHandler.js

@@ -10,49 +10,75 @@ OF ANY KIND, either express or implied. See the License for the specific languag
 governing permissions and limitations under the License.
 */
 import addRenderAttemptedToDecisions from "./utils/addRenderAttemptedToDecisions";
+import isNonEmptyArray from "../../utils/isNonEmptyArray";
+
+const getPropositions = ({
+  viewCache,
+  viewName,
+  pageWideScopeDecisions
+}) => {
+  if (!viewName) {
+    return {
+      pageWideScopeDecisions,
+      viewPropositions: []
+    };
+  }
+
+  return viewCache.getView(viewName).then(viewPropositions => {
+    return {
+      pageWideScopeDecisions,
+      viewPropositions
+    };
+  });
+};
+
 export default (({
   viewCache,
   executeDecisions,
-  executeCachedViewDecisions,
-  showContainers
+  showContainers,
+  collect
 }) => {
   return ({
     viewName,
     pageWideScopeDecisions,
     nonAutoRenderableDecisions
   }) => {
-    if (viewName) {
-      return viewCache.getView(viewName).then(currentViewDecisions => {
-        executeDecisions(pageWideScopeDecisions);
-        executeCachedViewDecisions({
-          viewName,
-          viewDecisions: currentViewDecisions
-        });
-        showContainers();
-        return {
-          decisions: [...nonAutoRenderableDecisions],
-          propositions: [...addRenderAttemptedToDecisions({
-            decisions: [...pageWideScopeDecisions, ...currentViewDecisions],
-            renderAttempted: true
-          }), ...addRenderAttemptedToDecisions({
-            decisions: nonAutoRenderableDecisions,
-            renderAttempted: false
-          })]
-        };
+    return Promise.resolve(pageWideScopeDecisions).then(propositions => getPropositions({
+      viewCache,
+      viewName,
+      executeDecisions,
+      pageWideScopeDecisions: propositions
+    })).then(propositions => {
+      executeDecisions(propositions.pageWideScopeDecisions).then(decisionsMeta => {
+        if (isNonEmptyArray(decisionsMeta)) {
+          collect({
+            decisionsMeta
+          });
+        }
       });
-    }
 
-    executeDecisions(pageWideScopeDecisions);
-    showContainers();
-    return {
-      decisions: [...nonAutoRenderableDecisions],
-      propositions: [...addRenderAttemptedToDecisions({
-        decisions: pageWideScopeDecisions,
-        renderAttempted: true
-      }), ...addRenderAttemptedToDecisions({
-        decisions: nonAutoRenderableDecisions,
-        renderAttempted: false
-      })]
-    };
+      if (viewName) {
+        executeDecisions(propositions.viewPropositions).then(decisionsMeta => {
+          collect({
+            decisionsMeta,
+            viewName
+          });
+        });
+      }
+
+      showContainers();
+      return [...propositions.pageWideScopeDecisions, ...propositions.viewPropositions];
+    }).then(renderablePropositions => {
+      return {
+        decisions: [...nonAutoRenderableDecisions],
+        propositions: [...addRenderAttemptedToDecisions({
+          decisions: renderablePropositions,
+          renderAttempted: true
+        }), ...addRenderAttemptedToDecisions({
+          decisions: nonAutoRenderableDecisions,
+          renderAttempted: false
+        })]
+      };
+    });
   };
 });

package/libEs6/components/Personalization/createCollect.js

@@ -10,20 +10,35 @@ OF ANY KIND, either express or implied. See the License for the specific languag
 governing permissions and limitations under the License.
 */
 import { DISPLAY } from "./constants/eventType";
+import { isNonEmptyArray } from "../../utils";
 export default (({
   eventManager,
   mergeDecisionsMeta
 }) => {
-  // Called when a decision is auto-rendered for the __view__ scope (non-SPA view).
+  // Called when a decision is auto-rendered for the __view__ scope or a SPA view(display and empty display notification)
   return ({
-    decisionsMeta,
-    documentMayUnload = false
+    decisionsMeta = [],
+    documentMayUnload = false,
+    viewName
   }) => {
     const event = eventManager.createEvent();
-    event.mergeXdm({
+    const data = {
       eventType: DISPLAY
-    });
-    mergeDecisionsMeta(event, decisionsMeta);
+    };
+
+    if (viewName) {
+      data.web = {
+        webPageDetails: {
+          viewName
+        }
+      };
+    }
+
+    if (isNonEmptyArray(decisionsMeta)) {
+      mergeDecisionsMeta(event, decisionsMeta);
+    }
+
+    event.mergeXdm(data);
 
     if (documentMayUnload) {
       event.documentMayUnload();

package/libEs6/components/Personalization/createComponent.js

@@ -67,8 +67,10 @@ export default (({
         }
 
         if (personalizationDetails.shouldUseCachedData()) {
-          viewChangeHandler({
+          // eslint-disable-next-line consistent-return
+          return viewChangeHandler({
             personalizationDetails,
+            event,
             onResponse,
             onRequestFailure
           });

package/libEs6/components/Personalization/createExecuteDecisions.js

@@ -9,7 +9,8 @@ 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, flatMap, isNonEmptyArray } from "../../utils";
+import { assign, flatMap } from "../../utils";
+const DEFAULT_ACTION_TYPE = "defaultContent";
 
 const identity = item => item;
 
@@ -19,12 +20,14 @@ const buildActions = decision => {
     scope: decision.scope,
     scopeDetails: decision.scopeDetails
   };
-  return decision.items.map(item => assign({}, item.data, {
+  return decision.items.map(item => assign({
+    type: DEFAULT_ACTION_TYPE
+  }, item.data, {
     meta
   }));
 };
 
-const processMetas = (collect, logger, actionResults) => {
+const processMetas = (logger, actionResults) => {
   const results = flatMap(actionResults, identity);
   const finalMetas = [];
   const set = new Set();
@@ -50,27 +53,20 @@ const processMetas = (collect, logger, actionResults) => {
     set.add(meta.id);
     finalMetas.push(meta);
   });
-
-  if (isNonEmptyArray(finalMetas)) {
-    // collect here can either be the function from createCollect or createViewCollect.
-    collect({
-      decisionsMeta: finalMetas
-    });
-  }
+  return finalMetas;
 };
 
 export default (({
   modules,
   logger,
-  executeActions,
-  collect
+  executeActions
 }) => {
   return decisions => {
     const actionResultsPromises = decisions.map(decision => {
       const actions = buildActions(decision);
       return executeActions(actions, modules, logger);
     });
-    return Promise.all(actionResultsPromises).then(results => processMetas(collect, logger, results)).catch(error => {
+    return Promise.all(actionResultsPromises).then(results => processMetas(logger, results)).catch(error => {
       logger.error(error);
     });
   };

package/libEs6/components/Personalization/createPersonalizationDetails.js

@@ -11,7 +11,7 @@ governing permissions and limitations under the License.
 */
 import { includes } from "../../utils";
 import PAGE_WIDE_SCOPE from "./constants/scope";
-import { DOM_ACTION, HTML_CONTENT_ITEM, JSON_CONTENT_ITEM, REDIRECT_ITEM } from "./constants/schema";
+import { DEFAULT_CONTENT_ITEM, DOM_ACTION, HTML_CONTENT_ITEM, JSON_CONTENT_ITEM, REDIRECT_ITEM } from "./constants/schema";
 import isNonEmptyString from "../../utils/isNonEmptyString";
 export default (({
   renderDecisions,
@@ -44,7 +44,7 @@ export default (({
         scopes.push(PAGE_WIDE_SCOPE);
       }
 
-      const schemas = [HTML_CONTENT_ITEM, JSON_CONTENT_ITEM, REDIRECT_ITEM];
+      const schemas = [DEFAULT_CONTENT_ITEM, HTML_CONTENT_ITEM, JSON_CONTENT_ITEM, REDIRECT_ITEM];
 
       if (includes(scopes, PAGE_WIDE_SCOPE)) {
         schemas.push(DOM_ACTION);

package/libEs6/components/Personalization/createViewChangeHandler.js

@@ -9,38 +9,47 @@ 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 addRenderAttemptedToDecisions from "./utils/addRenderAttemptedToDecisions";
+import composePersonalizationResultingObject from "./utils/composePersonalizationResultingObject";
+import { isNonEmptyArray } from "../../utils";
 export default (({
-  executeCachedViewDecisions,
+  mergeDecisionsMeta,
+  collect,
+  executeDecisions,
   viewCache
 }) => {
   return ({
     personalizationDetails,
+    event,
     onResponse
   }) => {
     const viewName = personalizationDetails.getViewName();
-    return viewCache.getView(viewName).then(currentViewDecisions => {
+    return viewCache.getView(viewName).then(viewDecisions => {
       if (personalizationDetails.isRenderDecisions()) {
-        executeCachedViewDecisions({
-          viewName,
-          viewDecisions: currentViewDecisions
+        return executeDecisions(viewDecisions).then(decisionsMeta => {
+          // if there are decisions to be rendered we render them and attach the result in experience.decisions.propositions
+          if (isNonEmptyArray(decisionsMeta)) {
+            mergeDecisionsMeta(event, decisionsMeta);
+            onResponse(() => {
+              return composePersonalizationResultingObject(viewDecisions, true);
+            });
+            return;
+          } // if there are no decisions in cache for this view, we will send a empty notification
+
+
+          onResponse(() => {
+            collect({
+              decisionsMeta: [],
+              viewName
+            });
+            return composePersonalizationResultingObject(viewDecisions, true);
+          });
         });
       }
 
       onResponse(() => {
-        return personalizationDetails.isRenderDecisions() ? {
-          propositions: addRenderAttemptedToDecisions({
-            decisions: currentViewDecisions,
-            renderAttempted: true
-          })
-        } : {
-          decisions: currentViewDecisions,
-          propositions: addRenderAttemptedToDecisions({
-            decisions: currentViewDecisions,
-            renderAttempted: false
-          })
-        };
+        return composePersonalizationResultingObject(viewDecisions, false);
       });
+      return {};
     });
   };
 });

package/libEs6/components/Personalization/dom-actions/initDomActionsModules.js

@@ -28,6 +28,9 @@ export default (store => {
     replaceHtml: createAction(replaceHtml),
     prependHtml: createAction(prependHtml),
     appendHtml: createAction(appendHtml),
-    click: settings => click(settings, store)
+    click: settings => click(settings, store),
+    defaultContent: settings => Promise.resolve({
+      meta: settings.meta
+    })
   };
 });

package/libEs6/components/Personalization/groupDecisions.js

@@ -9,15 +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 { isNonEmptyArray } from "../../utils";
-import { DOM_ACTION, REDIRECT_ITEM } from "./constants/schema";
+import { isNonEmptyArray, includes } from "../../utils";
+import { DOM_ACTION, REDIRECT_ITEM, DEFAULT_CONTENT_ITEM } from "./constants/schema";
+import { VIEW_SCOPE_TYPE } from "./constants/scopeType";
 import PAGE_WIDE_SCOPE from "./constants/scope";
 
-const splitItems = (items, schema) => {
+const splitItems = (items, schemas) => {
   const matched = [];
   const nonMatched = [];
   items.forEach(item => {
-    if (item.schema === schema) {
+    if (includes(schemas, item.schema)) {
       matched.push(item);
     } else {
       nonMatched.push(item);
@@ -35,14 +36,14 @@ const createDecision = (decision, items) => {
   };
 };
 
-const splitDecisions = (decisions, schema) => {
+const splitDecisions = (decisions, ...schemas) => {
   const matchedDecisions = [];
   const unmatchedDecisions = [];
   decisions.forEach(decision => {
     const {
       items = []
     } = decision;
-    const [matchedItems, nonMatchedItems] = splitItems(items, schema);
+    const [matchedItems, nonMatchedItems] = splitItems(items, schemas);
 
     if (isNonEmptyArray(matchedItems)) {
       matchedDecisions.push(createDecision(decision, matchedItems));
@@ -58,42 +59,53 @@ const splitDecisions = (decisions, schema) => {
   };
 };
 
-const extractDecisionsByScope = (decisions, scope) => {
+const appendScopeDecision = (scopeDecisions, decision) => {
+  if (!scopeDecisions[decision.scope]) {
+    scopeDecisions[decision.scope] = [];
+  }
+
+  scopeDecisions[decision.scope].push(decision);
+};
+
+const isViewScope = scopeDetails => scopeDetails.characteristics && scopeDetails.characteristics.scopeType && scopeDetails.characteristics.scopeType === VIEW_SCOPE_TYPE;
+
+const extractDecisionsByScope = decisions => {
   const pageWideScopeDecisions = [];
-  const nonPageWideScopeDecisions = {};
+  const nonPageWideScopeDecisions = [];
+  const viewScopeDecisions = {};
 
   if (isNonEmptyArray(decisions)) {
     decisions.forEach(decision => {
-      if (decision.scope === scope) {
+      if (decision.scope === PAGE_WIDE_SCOPE) {
         pageWideScopeDecisions.push(decision);
+      } else if (isViewScope(decision.scopeDetails)) {
+        appendScopeDecision(viewScopeDecisions, decision);
       } else {
-        if (!nonPageWideScopeDecisions[decision.scope]) {
-          nonPageWideScopeDecisions[decision.scope] = [];
-        }
-
-        nonPageWideScopeDecisions[decision.scope].push(decision);
+        nonPageWideScopeDecisions.push(decision);
       }
     });
   }
 
   return {
     pageWideScopeDecisions,
-    nonPageWideScopeDecisions
+    nonPageWideScopeDecisions,
+    viewScopeDecisions
   };
 };
 
 const groupDecisions = unprocessedDecisions => {
   const decisionsGroupedByRedirectItemSchema = splitDecisions(unprocessedDecisions, REDIRECT_ITEM);
-  const decisionsGroupedByDomActionSchema = splitDecisions(decisionsGroupedByRedirectItemSchema.unmatchedDecisions, DOM_ACTION);
+  const decisionsGroupedByRenderableSchemas = splitDecisions(decisionsGroupedByRedirectItemSchema.unmatchedDecisions, DOM_ACTION, DEFAULT_CONTENT_ITEM);
   const {
     pageWideScopeDecisions,
-    nonPageWideScopeDecisions
-  } = extractDecisionsByScope(decisionsGroupedByDomActionSchema.matchedDecisions, PAGE_WIDE_SCOPE);
+    nonPageWideScopeDecisions,
+    viewScopeDecisions
+  } = extractDecisionsByScope(decisionsGroupedByRenderableSchemas.matchedDecisions);
   return {
     redirectDecisions: decisionsGroupedByRedirectItemSchema.matchedDecisions,
     pageWideScopeDecisions,
-    viewDecisions: nonPageWideScopeDecisions,
-    nonAutoRenderableDecisions: decisionsGroupedByDomActionSchema.unmatchedDecisions
+    viewDecisions: viewScopeDecisions,
+    nonAutoRenderableDecisions: decisionsGroupedByRenderableSchemas.unmatchedDecisions.concat(nonPageWideScopeDecisions)
   };
 };
 

package/libEs6/components/Personalization/index.js

@@ -13,7 +13,6 @@ import { string } from "../../utils/validation";
 import createComponent from "./createComponent";
 import { initDomActionsModules, executeActions } from "./dom-actions";
 import createCollect from "./createCollect";
-import createViewCollect from "./createViewCollect";
 import createExecuteDecisions from "./createExecuteDecisions";
 import { hideContainers, showContainers } from "./flicker";
 import createFetchDataHandler from "./createFetchDataHandler";
@@ -21,7 +20,6 @@ import collectClicks from "./dom-actions/clicks/collectClicks";
 import isAuthoringModeEnabled from "./utils/isAuthoringModeEnabled";
 import { mergeDecisionsMeta, mergeQuery } from "./event";
 import createOnClickHandler from "./createOnClickHandler";
-import createExecuteCachedViewDecisions from "./createExecuteCachedViewDecisions";
 import createViewCacheManager from "./createViewCacheManager";
 import createViewChangeHandler from "./createViewChangeHandler";
 import groupDecisions from "./groupDecisions";
@@ -40,10 +38,6 @@ const createPersonalization = ({
     eventManager,
     mergeDecisionsMeta
   });
-  const viewCollect = createViewCollect({
-    eventManager,
-    mergeDecisionsMeta
-  });
   const {
     getClickMetasBySelector,
     getClickSelectors,
@@ -54,14 +48,7 @@ const createPersonalization = ({
   const executeDecisions = createExecuteDecisions({
     modules,
     logger,
-    executeActions,
-    collect
-  });
-  const executeViewDecisions = createExecuteDecisions({
-    modules,
-    logger,
-    executeActions,
-    collect: viewCollect
+    executeActions
   });
   const handleRedirectDecisions = createRedirectHandler({
     collect,
@@ -69,16 +56,11 @@ const createPersonalization = ({
     logger,
     showContainers
   });
-  const executeCachedViewDecisions = createExecuteCachedViewDecisions({
-    viewCache,
-    executeViewDecisions,
-    collect: viewCollect
-  });
   const autoRenderingHandler = createAutorenderingHandler({
     viewCache,
     executeDecisions,
-    executeCachedViewDecisions,
-    showContainers
+    showContainers,
+    collect
   });
   const nonRenderingHandler = createNonRenderingHandler({
     viewCache
@@ -103,7 +85,9 @@ const createPersonalization = ({
     getClickMetasBySelector
   });
   const viewChangeHandler = createViewChangeHandler({
-    executeCachedViewDecisions,
+    mergeDecisionsMeta,
+    collect,
+    executeDecisions,
     viewCache
   });
   return createComponent({

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

@@ -0,0 +1,15 @@
+import addRenderAttemptedToDecisions from "./addRenderAttemptedToDecisions";
+export default ((decisions = [], renderDecisions) => {
+  const resultingObject = {
+    propositions: addRenderAttemptedToDecisions({
+      decisions,
+      renderAttempted: renderDecisions
+    })
+  };
+
+  if (!renderDecisions) {
+    resultingObject.decisions = decisions;
+  }
+
+  return resultingObject;
+});

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.9.0-alpha.3";
+export default "2.9.0-alpha.6";

package/libEs6/core/buildAndValidateConfig.js

@@ -11,7 +11,7 @@ governing permissions and limitations under the License.
 */
 import { assign } from "../utils";
 import { objectOf } from "../utils/validation";
-const CONFIG_DOC_URI = "https://adobe.ly/2M4ErNE";
+const CONFIG_DOC_URI = "https://adobe.ly/3sHh553";
 
 const buildSchema = (coreConfigValidators, componentCreators) => {
   const schema = {};

package/libEs6/core/validateCommandOptions.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.
 */
-const COMMAND_DOC_URI = "https://adobe.ly/2UH0qO7";
+const COMMAND_DOC_URI = "https://adobe.ly/3sHgQHb";
 export default (({
   command,
   options

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adobe/alloy",
-  "version": "2.9.0-alpha.3",
+  "version": "2.9.0-alpha.6",
   "description": "Adobe Experience Platform Web SDK",
   "main": "libEs5/index.js",
   "module": "libEs6/index.js",
@@ -64,7 +64,7 @@
     "uuid": "^3.3.2"
   },
   "devDependencies": {
-    "@adobe/alloy": "^2.9.0-alpha.2",
+    "@adobe/alloy": "^2.9.0-alpha.5",
     "@babel/cli": "^7.12.8",
     "@babel/core": "^7.2.2",
     "@babel/plugin-proposal-object-rest-spread": "^7.3.2",

package/libEs5/components/Personalization/createExecuteCachedViewDecisions.js

@@ -1,47 +0,0 @@
-"use strict";
-
-exports.default = void 0;
-
-var _isNonEmptyArray = require("../../utils/isNonEmptyArray");
-
-/*
-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 = function _default(_ref) {
-  var executeViewDecisions = _ref.executeViewDecisions,
-      collect = _ref.collect;
-  return function (_ref2) {
-    var viewName = _ref2.viewName,
-        viewDecisions = _ref2.viewDecisions;
-
-    // if there are viewDecisions for current view we will execute them and then send the collect call
-    if ((0, _isNonEmptyArray.default)(viewDecisions)) {
-      executeViewDecisions(viewDecisions);
-      return; // return here is to avoid the following code to be executed, that one is meant for the condition when viewDecisions is empty
-    } // if there are no viewDecisions for current view we will send a collect call
-
-
-    var xdm = {
-      web: {
-        webPageDetails: {
-          viewName: viewName
-        }
-      }
-    }; // This collect function is not from createCollect. It's the function from createViewCollect.
-
-    collect({
-      decisionsMeta: [],
-      xdm: xdm
-    });
-  };
-};
-
-exports.default = _default;

package/libEs5/components/Personalization/createViewCollect.js

@@ -1,48 +0,0 @@
-"use strict";
-
-exports.default = void 0;
-
-var _utils = require("../../utils");
-
-var _eventType = require("./constants/eventType");
-
-/*
-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 = function _default(_ref) {
-  var eventManager = _ref.eventManager,
-      mergeDecisionsMeta = _ref.mergeDecisionsMeta;
-  // Called when an offer for a specific SPA view is auto-rendered.
-  return function (_ref2) {
-    var decisionsMeta = _ref2.decisionsMeta,
-        xdm = _ref2.xdm;
-    var data = {
-      eventType: _eventType.DISPLAY
-    };
-    var event = eventManager.createEvent();
-
-    if ((0, _utils.isNonEmptyArray)(decisionsMeta)) {
-      var viewName = decisionsMeta[0].scope;
-      data.web = {
-        webPageDetails: {
-          viewName: viewName
-        }
-      };
-      mergeDecisionsMeta(event, decisionsMeta);
-    }
-
-    event.mergeXdm(data);
-    event.mergeXdm(xdm);
-    return eventManager.sendEvent(event);
-  };
-};
-
-exports.default = _default;