@adobe/alloy 2.14.0 → 2.15.0-alpha.1

package/libEs5/components/Personalization/dom-actions/clicks/collectClicks.js

@@ -20,30 +20,81 @@ var getMetasIfMatches = function getMetasIfMatches(clickedElement, selector, get
   var _document = document,
       documentElement = _document.documentElement;
   var element = clickedElement;
+  var i = 0;
 
   while (element && element !== documentElement) {
     if ((0, _matchesSelectorWithEq.default)(selector, element)) {
-      return getClickMetasBySelector(selector);
+      var matchedMetas = getClickMetasBySelector(selector);
+      var foundMetaWithLabel = matchedMetas.find(function (meta) {
+        return meta.trackingLabel;
+      });
+
+      if (foundMetaWithLabel) {
+        return {
+          metas: matchedMetas,
+          label: foundMetaWithLabel.trackingLabel,
+          weight: i
+        };
+      }
+
+      return {
+        metas: matchedMetas
+      };
     }
 
     element = element.parentNode;
+    i += 1;
   }
 
-  return null;
+  return {
+    metas: null
+  };
+};
+
+var cleanMetas = function cleanMetas(metas) {
+  return metas.map(function (meta) {
+    delete meta.trackingLabel;
+    return meta;
+  });
+};
+
+var dedupMetas = function dedupMetas(metas) {
+  return metas.filter(function (meta, index) {
+    var stringifiedMeta = JSON.stringify(meta);
+    return index === metas.findIndex(function (innerMeta) {
+      return JSON.stringify(innerMeta) === stringifiedMeta;
+    });
+  });
 };
 
 var _default = function _default(clickedElement, selectors, getClickMetasBySelector) {
   var result = [];
+  var resultLabel = "";
+  var resultLabelWeight = Number.MAX_SAFE_INTEGER;
+  /* eslint-disable no-continue */
 
   for (var i = 0; i < selectors.length; i += 1) {
-    var metas = getMetasIfMatches(clickedElement, selectors[i], getClickMetasBySelector);
+    var _getMetasIfMatches = getMetasIfMatches(clickedElement, selectors[i], getClickMetasBySelector),
+        metas = _getMetasIfMatches.metas,
+        label = _getMetasIfMatches.label,
+        weight = _getMetasIfMatches.weight;
 
-    if (metas) {
-      result.push.apply(result, _toConsumableArray(metas));
+    if (!metas) {
+      continue;
     }
+
+    if (label && weight <= resultLabelWeight) {
+      resultLabel = label;
+      resultLabelWeight = weight;
+    }
+
+    result.push.apply(result, _toConsumableArray(cleanMetas(metas)));
   }
 
-  return result;
+  return {
+    decisionsMeta: dedupMetas(result),
+    eventLabel: resultLabel
+  };
 };
 
 exports.default = _default;

package/libEs5/components/Personalization/event.js

@@ -20,16 +20,26 @@ OF ANY KIND, either express or implied. See the License for the specific languag
 governing permissions and limitations under the License.
 */
 var EVENT_TYPE_TRUE = 1;
+/* eslint-disable no-underscore-dangle */
 
 var mergeDecisionsMeta = function mergeDecisionsMeta(event, decisionsMeta, eventType) {
-  event.mergeXdm({
+  var eventLabel = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : "";
+  var xdm = {
     _experience: {
       decisioning: {
         propositions: decisionsMeta,
         propositionEventType: _defineProperty({}, eventType, EVENT_TYPE_TRUE)
       }
     }
-  });
+  };
+
+  if (eventLabel) {
+    xdm._experience.decisioning.propositionAction = {
+      label: eventLabel
+    };
+  }
+
+  event.mergeXdm(xdm);
 };
 
 exports.mergeDecisionsMeta = mergeDecisionsMeta;

package/libEs5/constants/libraryVersion.js

@@ -15,5 +15,5 @@ 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
-var _default = "2.14.0";
+var _default = "2.15.0-alpha.1";
 exports.default = _default;

package/libEs5/core/buildAndValidateConfig.js

@@ -6,17 +6,12 @@ var _utils = require("../utils");
 
 var _validation = require("../utils/validation");
 
-/*
-Copyright 2019 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.
-*/
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
 var CONFIG_DOC_URI = "https://adobe.ly/3sHh553";
 
 var buildSchema = function buildSchema(coreConfigValidators, componentCreators) {
@@ -38,21 +33,38 @@ var transformOptions = function transformOptions(schema, options) {
   }
 };
 
-var _default = function _default(_ref) {
-  var options = _ref.options,
-      componentCreators = _ref.componentCreators,
-      coreConfigValidators = _ref.coreConfigValidators,
-      createConfig = _ref.createConfig,
-      logger = _ref.logger,
-      setDebugEnabled = _ref.setDebugEnabled;
+var buildAllOnInstanceConfiguredExtraParams = function buildAllOnInstanceConfiguredExtraParams(config, logger, componentCreators) {
+  return componentCreators.reduce(function (memo, _ref) {
+    var buildOnInstanceConfiguredExtraParams = _ref.buildOnInstanceConfiguredExtraParams;
+
+    if (buildOnInstanceConfiguredExtraParams) {
+      (0, _utils.assign)(memo, buildOnInstanceConfiguredExtraParams({
+        config: config,
+        logger: logger
+      }));
+    }
+
+    return memo;
+  }, {});
+};
+
+var _default = function _default(_ref2) {
+  var options = _ref2.options,
+      componentCreators = _ref2.componentCreators,
+      coreConfigValidators = _ref2.coreConfigValidators,
+      createConfig = _ref2.createConfig,
+      logger = _ref2.logger,
+      setDebugEnabled = _ref2.setDebugEnabled;
   var schema = buildSchema(coreConfigValidators, componentCreators);
   var config = createConfig(transformOptions(schema, options));
   setDebugEnabled(config.debugEnabled, {
     fromConfig: true
-  });
-  logger.logOnInstanceConfigured({
+  }); // eslint-disable-next-line no-underscore-dangle
+
+  var extraParams = buildAllOnInstanceConfiguredExtraParams(config, logger, componentCreators);
+  logger.logOnInstanceConfigured(_objectSpread(_objectSpread({}, extraParams), {}, {
     config: config
-  });
+  }));
   return config;
 };
 

package/libEs5/core/componentCreators.js

@@ -33,6 +33,10 @@ 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.
 */
+// This is the only place where core is allowed to import from components.
+// This makes sure that each component could be removed without breaking the library
+
+/* eslint-disable import/no-restricted-paths */
 // TODO: Register the Components here statically for now. They might be registered differently.
 // TODO: Figure out how sub-components will be made available/registered
 var _default = [_DataCollector.default, _ActivityCollector.default, _Identity.default, _Audiences.default, _Personalization.default, _Context.default, _Privacy.default, _EventMerge.default, _LibraryInfo.default, _MachineLearning.default];

package/libEs6/components/ActivityCollector/attachClickActivityCollector.js

@@ -1,5 +1,5 @@
 /*
-Copyright 2019 Adobe. All rights reserved.
+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

package/libEs6/components/ActivityCollector/configValidators.js

@@ -9,8 +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 { string, boolean } from "../../utils/validation";
+import { string, boolean, callback } from "../../utils/validation";
 export default {
   clickCollectionEnabled: boolean().default(true),
-  downloadLinkQualifier: string().regexp().default("\\.(exe|zip|wav|mp3|mov|mpg|avi|wmv|pdf|doc|docx|xls|xlsx|ppt|pptx)$")
+  downloadLinkQualifier: string().regexp().default("\\.(exe|zip|wav|mp3|mov|mpg|avi|wmv|pdf|doc|docx|xls|xlsx|ppt|pptx)$"),
+  onBeforeLinkClickSend: callback()
 };

package/libEs6/components/ActivityCollector/createGetLinkDetails.js

@@ -0,0 +1,77 @@
+/*
+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,
+  getLinkName,
+  getLinkRegion,
+  getAbsoluteUrlFromAnchorElement,
+  findSupportedAnchorElement,
+  determineLinkType
+}) => {
+  return ({
+    targetElement,
+    config,
+    logger
+  }) => {
+    const anchorElement = findSupportedAnchorElement(targetElement);
+
+    if (!anchorElement) {
+      logger.info("This link click event is not triggered because the HTML element is not an anchor.");
+      return undefined;
+    }
+
+    const linkUrl = getAbsoluteUrlFromAnchorElement(window, anchorElement);
+
+    if (!linkUrl) {
+      logger.info("This link click event is not triggered because the HTML element doesn't have an URL.");
+      return undefined;
+    }
+
+    const linkType = determineLinkType(window, config, linkUrl, anchorElement);
+    const linkRegion = getLinkRegion(anchorElement);
+    const linkName = getLinkName(anchorElement);
+    const {
+      onBeforeLinkClickSend
+    } = config;
+    const options = {
+      xdm: {
+        eventType: "web.webinteraction.linkClicks",
+        web: {
+          webInteraction: {
+            name: linkName,
+            region: linkRegion,
+            type: linkType,
+            URL: linkUrl,
+            linkClicks: {
+              value: 1
+            }
+          }
+        }
+      },
+      data: {},
+      clickedElement: targetElement
+    };
+
+    if (!onBeforeLinkClickSend) {
+      return options;
+    }
+
+    const shouldEventBeTracked = onBeforeLinkClickSend(options);
+
+    if (shouldEventBeTracked !== false) {
+      return options;
+    }
+
+    logger.info("This link click event is not triggered because it was canceled in onBeforeLinkClickSend.");
+    return undefined;
+  };
+});

package/libEs6/components/ActivityCollector/createLinkClick.js

@@ -1,5 +1,5 @@
 /*
-Copyright 2019 Adobe. All rights reserved.
+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
@@ -9,72 +9,32 @@ 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 { getAbsoluteUrlFromAnchorElement, isSupportedAnchorElement, isDownloadLink, isExitLink } from "./utils";
-
-const determineLinkType = (window, config, linkUrl, clickedObj) => {
-  let linkType = "other";
-
-  if (isDownloadLink(config.downloadLinkQualifier, linkUrl, clickedObj)) {
-    linkType = "download";
-  } else if (isExitLink(window, linkUrl)) {
-    linkType = "exit";
-  }
-
-  return linkType;
-};
-
-const findSupportedAnchorElement = targetElement => {
-  let node = targetElement;
-
-  while (node) {
-    if (isSupportedAnchorElement(node)) {
-      return node;
-    }
-
-    node = node.parentNode;
+export default (({
+  getLinkDetails,
+  config,
+  logger
+}) => {
+  const {
+    clickCollectionEnabled
+  } = config;
+
+  if (!clickCollectionEnabled) {
+    return () => undefined;
   }
 
-  return null;
-};
-
-export default ((window, config) => {
-  return (event, targetElement) => {
-    const clickCollectionEnabled = config.clickCollectionEnabled;
-
-    if (!clickCollectionEnabled) {
-      return;
-    } // Search parent elements for an anchor element
-    // TODO: Replace with generic DOM tool that can fetch configured properties
-
-
-    const anchorElement = findSupportedAnchorElement(targetElement);
-
-    if (!anchorElement) {
-      return;
-    }
-
-    const linkUrl = getAbsoluteUrlFromAnchorElement(window, anchorElement);
+  return ({
+    targetElement,
+    event
+  }) => {
+    const linkDetails = getLinkDetails({
+      targetElement,
+      config,
+      logger
+    });
 
-    if (!linkUrl) {
-      return;
+    if (linkDetails) {
+      event.mergeXdm(linkDetails.xdm);
+      event.setUserData(linkDetails.data);
     }
-
-    const linkType = determineLinkType(window, config, linkUrl, anchorElement); // TODO: Update link name from the clicked element context
-
-    const linkName = "Link Click";
-    event.documentMayUnload();
-    event.mergeXdm({
-      eventType: "web.webinteraction.linkClicks",
-      web: {
-        webInteraction: {
-          name: linkName,
-          type: linkType,
-          URL: linkUrl,
-          linkClicks: {
-            value: 1
-          }
-        }
-      }
-    });
   };
 });

package/libEs6/components/ActivityCollector/getLinkName.js

@@ -0,0 +1,151 @@
+/*
+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.
+*/
+import { truncateWhiteSpace } from "./utils";
+const unsupportedNodeNames = /^(SCRIPT|STYLE|LINK|CANVAS|NOSCRIPT|#COMMENT)$/i;
+/**
+ * Determines if a node qualifies as a supported link text node.
+ * @param {*} node Node to determine support for.
+ * @returns {boolean}
+ */
+
+const isSupportedTextNode = node => {
+  if (node && node.nodeName) {
+    if (node.nodeName.match(unsupportedNodeNames)) {
+      return false;
+    }
+  }
+
+  return true;
+};
+/**
+ * Orders and returns specified node and its child nodes in arrays of supported
+ * and unsupported nodes.
+ * @param {*} node The node to extract supported and unsupported nodes from.
+ * @returns {{supportedNodes: Array, includesUnsupportedNodes: boolean}} Node support object.
+ */
+
+
+const extractSupportedNodes = node => {
+  let supportedNodes = [];
+  let includesUnsupportedNodes = false;
+
+  if (isSupportedTextNode(node)) {
+    supportedNodes.push(node);
+
+    if (node.childNodes) {
+      const childNodes = Array.prototype.slice.call(node.childNodes);
+      childNodes.forEach(childNode => {
+        const nodes = extractSupportedNodes(childNode);
+        supportedNodes = supportedNodes.concat(nodes.supportedNodes);
+        includesUnsupportedNodes = includesUnsupportedNodes || nodes.includesUnsupportedNodes;
+      });
+    }
+  } else {
+    includesUnsupportedNodes = true;
+  }
+
+  return {
+    supportedNodes,
+    includesUnsupportedNodes
+  };
+};
+/**
+ * Returns the value of a node attribute.
+ * @param {*} node The node holding the attribute.
+ * @param {string} attributeName The name of the attribute.
+ * @param {string} nodeName Optional node name constraint.
+ * @returns {string} Attribute value or undefined.
+ */
+
+
+const getNodeAttributeValue = (node, attributeName, nodeName) => {
+  let attributeValue;
+
+  if (!nodeName || nodeName === node.nodeName.toUpperCase()) {
+    attributeValue = node.getAttribute(attributeName);
+  }
+
+  return attributeValue;
+};
+/**
+ * Extracts the children supported nodes attributes map
+ * @param {*} nodes The nodes array holding the children nodes.
+ * The returned map contains the supported not empty children attributes values.
+ * */
+
+
+const getChildrenAttributes = nodes => {
+  const attributes = {
+    texts: []
+  };
+  nodes.supportedNodes.forEach(supportedNode => {
+    if (supportedNode.getAttribute) {
+      if (!attributes.alt) {
+        attributes.alt = truncateWhiteSpace(supportedNode.getAttribute("alt"));
+      }
+
+      if (!attributes.title) {
+        attributes.title = truncateWhiteSpace(supportedNode.getAttribute("title"));
+      }
+
+      if (!attributes.inputValue) {
+        attributes.inputValue = truncateWhiteSpace(getNodeAttributeValue(supportedNode, "value", "INPUT"));
+      }
+
+      if (!attributes.imgSrc) {
+        attributes.imgSrc = truncateWhiteSpace(getNodeAttributeValue(supportedNode, "src", "IMG"));
+      }
+    }
+
+    if (supportedNode.nodeValue) {
+      attributes.texts.push(supportedNode.nodeValue);
+    }
+  });
+  return attributes;
+};
+/**
+ * Extracts a link-name from a given node.
+ *
+ * The returned link-name is set to one of the following (in order of priority):
+ *
+ * 1. Clicked node innerText
+ * 2. Clicked node textContent
+ * 3. Clicked node and its child nodes nodeValue appended together.
+ * 4. Clicked node alt attribute or node descendant alt attribute.
+ *    Whichever is found first.
+ * 5. Clicked node text attribute or node descendant text attribute.
+ *    Whichever is found first.
+ * 6. Clicked node INPUT descendant value attribute.
+ *    Whichever is found first.
+ * 7. Clicked node IMG descendant src attribute.
+ *    Whichever is found first.
+ *
+ * @param {*} node The node to find link text for.
+ * @returns {string} link-name or an empty string if not link-name is found.
+ */
+
+
+export default (node => {
+  let nodeText = truncateWhiteSpace(node.innerText || node.textContent);
+  const nodes = extractSupportedNodes(node); // if contains unsupported nodes we want children node attributes
+
+  if (!nodeText || nodes.includesUnsupportedNodes) {
+    const attributesMap = getChildrenAttributes(nodes);
+    nodeText = truncateWhiteSpace(attributesMap.texts.join(""));
+
+    if (!nodeText) {
+      nodeText = attributesMap.alt || attributesMap.title || attributesMap.inputValue || attributesMap.imgSrc;
+    }
+  }
+
+  return nodeText || "";
+});

package/libEs6/components/ActivityCollector/getLinkRegion.js

@@ -0,0 +1,68 @@
+/*
+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.
+*/
+import { truncateWhiteSpace } from "./utils";
+import { isNonEmptyString } from "../../utils";
+const semanticElements = /^(HEADER|MAIN|FOOTER|NAV)$/i;
+
+const getAriaRegionLabel = node => {
+  let regionLabel;
+
+  if (node.role === "region" && isNonEmptyString(node["aria-label"])) {
+    regionLabel = node["aria-label"];
+  }
+
+  return regionLabel;
+};
+
+const getSectionNodeName = node => {
+  let nodeName;
+
+  if (node && node.nodeName) {
+    if (node.nodeName.match(semanticElements)) {
+      nodeName = node.nodeName;
+    }
+  }
+
+  return nodeName;
+};
+/**
+ * Extracts a node link-region.
+ *
+ * The link-region is determined by traversing up the DOM
+ * looking for a region that is determined in order of priority:
+ *
+ * 1. element.id
+ * 2. Aria region label
+ * 3. Semantic element name
+ * 4. BODY (if no other link-region is found).
+ *
+ * @param {*} node The node to find link region for.
+ * @returns {string} link-region.
+ */
+
+
+export default (node => {
+  let linkParentNode = node.parentNode;
+  let regionName;
+
+  while (linkParentNode) {
+    regionName = truncateWhiteSpace(linkParentNode.id || getAriaRegionLabel(linkParentNode) || getSectionNodeName(linkParentNode));
+
+    if (regionName) {
+      return regionName;
+    }
+
+    linkParentNode = linkParentNode.parentNode;
+  }
+
+  return "BODY";
+});