@adobe/alloy 2.20.0-beta.2 → 2.20.0-beta.4

package/libEs6/components/ActivityCollector/createGetLinkDetails.js

@@ -0,0 +1,70 @@
+/*
+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

@@ -0,0 +1,37 @@
+/*
+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 (({
+  getLinkDetails,
+  config,
+  logger
+}) => {
+  const {
+    clickCollectionEnabled
+  } = config;
+  if (!clickCollectionEnabled) {
+    return () => undefined;
+  }
+  return ({
+    targetElement,
+    event
+  }) => {
+    const linkDetails = getLinkDetails({
+      targetElement,
+      config,
+      logger
+    });
+    if (linkDetails) {
+      event.mergeXdm(linkDetails.xdm);
+      event.setUserData(linkDetails.data);
+    }
+  };
+});

package/libEs6/components/ActivityCollector/getLinkName.js

@@ -0,0 +1,136 @@
+/*
+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.js";
+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,58 @@
+/*
+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.js";
+import { isNonEmptyString } from "../../utils/index.js";
+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";
+});

package/libEs6/components/ActivityCollector/index.js

@@ -0,0 +1,80 @@
+/*
+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.
+*/
+
+import attachClickActivityCollector from "./attachClickActivityCollector.js";
+import configValidators from "./configValidators.js";
+import createLinkClick from "./createLinkClick.js";
+import createGetLinkDetails from "./createGetLinkDetails.js";
+import getLinkName from "./getLinkName.js";
+import getLinkRegion from "./getLinkRegion.js";
+import { determineLinkType, findSupportedAnchorElement, getAbsoluteUrlFromAnchorElement } from "./utils.js";
+const getLinkDetails = createGetLinkDetails({
+  window,
+  getLinkName,
+  getLinkRegion,
+  getAbsoluteUrlFromAnchorElement,
+  findSupportedAnchorElement,
+  determineLinkType
+});
+const createActivityCollector = ({
+  config,
+  eventManager,
+  handleError,
+  logger
+}) => {
+  const linkClick = createLinkClick({
+    getLinkDetails,
+    config,
+    logger
+  });
+  return {
+    lifecycle: {
+      onComponentsRegistered(tools) {
+        const {
+          lifecycle
+        } = tools;
+        attachClickActivityCollector({
+          eventManager,
+          lifecycle,
+          handleError
+        });
+        // TODO: createScrollActivityCollector ...
+      },
+      onClick({
+        event,
+        clickedElement
+      }) {
+        linkClick({
+          targetElement: clickedElement,
+          event
+        });
+      }
+    }
+  };
+};
+createActivityCollector.namespace = "ActivityCollector";
+createActivityCollector.configValidators = configValidators;
+createActivityCollector.buildOnInstanceConfiguredExtraParams = ({
+  config,
+  logger
+}) => {
+  return {
+    getLinkDetails: targetElement => {
+      return getLinkDetails({
+        targetElement,
+        config,
+        logger
+      });
+    }
+  };
+};
+export default createActivityCollector;

package/libEs6/components/ActivityCollector/utils.js

@@ -0,0 +1,104 @@
+/*
+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.
+*/
+
+const urlStartsWithScheme = url => {
+  return url && /^[a-z0-9]+:\/\//i.test(url);
+};
+const getAbsoluteUrlFromAnchorElement = (window, element) => {
+  const loc = window.location;
+  let url = element.href ? element.href : "";
+  let {
+    protocol,
+    host
+  } = element;
+  if (!urlStartsWithScheme(url)) {
+    if (!protocol) {
+      protocol = loc.protocol ? loc.protocol : "";
+    }
+    protocol = protocol ? `${protocol}//` : "";
+    if (!host) {
+      host = loc.host ? loc.host : "";
+    }
+    let path = "";
+    if (url.substring(0, 1) !== "/") {
+      let indx = loc.pathname.lastIndexOf("/");
+      indx = indx < 0 ? 0 : indx;
+      path = loc.pathname.substring(0, indx);
+    }
+    url = `${protocol}${host}${path}/${url}`;
+  }
+  return url;
+};
+const isSupportedAnchorElement = element => {
+  if (element.href && (element.tagName === "A" || element.tagName === "AREA") && (!element.onclick || !element.protocol || element.protocol.toLowerCase().indexOf("javascript") < 0)) {
+    return true;
+  }
+  return false;
+};
+const trimQueryFromUrl = url => {
+  const questionMarkIndex = url.indexOf("?");
+  const hashIndex = url.indexOf("#");
+  if (questionMarkIndex >= 0 && (questionMarkIndex < hashIndex || hashIndex < 0)) {
+    return url.substring(0, questionMarkIndex);
+  }
+  if (hashIndex >= 0) {
+    return url.substring(0, hashIndex);
+  }
+  return url;
+};
+const isDownloadLink = (downloadLinkQualifier, linkUrl, clickedObj) => {
+  const re = new RegExp(downloadLinkQualifier);
+  const trimmedLinkUrl = trimQueryFromUrl(linkUrl).toLowerCase();
+  return clickedObj.download ? true : re.test(trimmedLinkUrl);
+};
+const isExitLink = (window, linkUrl) => {
+  const currentHostname = window.location.hostname.toLowerCase();
+  const trimmedLinkUrl = trimQueryFromUrl(linkUrl).toLowerCase();
+  if (trimmedLinkUrl.indexOf(currentHostname) >= 0) {
+    return false;
+  }
+  return true;
+};
+
+/**
+ * Reduces repeated whitespace within a string. Whitespace surrounding the string
+ * is trimmed and any occurrence of whitespace within the string is replaced with
+ * a single space.
+ * @param {string} str String to be formatted.
+ * @returns {string} Formatted string.
+ */
+const truncateWhiteSpace = str => {
+  return str && str.replace(/\s+/g, " ").trim();
+};
+const isEmptyString = str => {
+  return !str || str.length === 0;
+};
+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;
+  }
+  return null;
+};
+export { urlStartsWithScheme, getAbsoluteUrlFromAnchorElement, isSupportedAnchorElement, isDownloadLink, isEmptyString, isExitLink, trimQueryFromUrl, truncateWhiteSpace, findSupportedAnchorElement, determineLinkType };

package/libEs6/components/Audiences/index.js

@@ -0,0 +1,47 @@
+/*
+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.
+*/
+
+import { createLoggingCookieJar, cookieJar } from "../../utils/index.js";
+import injectProcessDestinations from "./injectProcessDestinations.js";
+import injectProcessResponse from "./injectProcessResponse.js";
+const createAudiences = ({
+  logger,
+  fireReferrerHideableImage
+}) => {
+  // we override the js-cookie converter to encode the cookie value similar on how it is in DIL (PDCL-10238)
+  const cookieJarWithEncoding = cookieJar.withConverter({
+    write: value => {
+      return encodeURIComponent(value);
+    }
+  });
+  const loggingCookieJar = createLoggingCookieJar({
+    logger,
+    cookieJar: cookieJarWithEncoding
+  });
+  const processDestinations = injectProcessDestinations({
+    fireReferrerHideableImage,
+    logger,
+    cookieJar: loggingCookieJar,
+    isPageSsl: window.location.protocol === "https:"
+  });
+  const processResponse = injectProcessResponse({
+    processDestinations
+  });
+  return {
+    lifecycle: {
+      onResponse: processResponse
+    },
+    commands: {}
+  };
+};
+createAudiences.namespace = "Audiences";
+export default createAudiences;

package/libEs6/components/Audiences/injectProcessDestinations.js

@@ -0,0 +1,60 @@
+/*
+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.
+*/
+
+import { noop } from "../../utils/index.js";
+const createResultLogMessage = (urlDestination, success) => {
+  return `URL destination ${success ? "succeeded" : "failed"}: ${urlDestination.spec.url}`;
+};
+export default (({
+  fireReferrerHideableImage,
+  logger,
+  cookieJar,
+  isPageSsl
+}) => {
+  const extraCookieOptions = isPageSsl ? {
+    sameSite: "none",
+    secure: true
+  } : {};
+  const processCookies = destinations => {
+    const cookieDestinations = destinations.filter(dest => dest.type === "cookie");
+    cookieDestinations.forEach(dest => {
+      const {
+        name,
+        value,
+        domain,
+        ttlDays
+      } = dest.spec;
+      cookieJar.set(name, value || "", {
+        domain: domain || "",
+        expires: ttlDays || 10,
+        // days
+        ...extraCookieOptions
+      });
+    });
+  };
+  const processUrls = destinations => {
+    const urlDestinations = destinations.filter(dest => dest.type === "url");
+    return Promise.all(urlDestinations.map(urlDestination => {
+      return fireReferrerHideableImage(urlDestination.spec).then(() => {
+        logger.info(createResultLogMessage(urlDestination, true));
+      }).catch(() => {
+        // We intentionally do not throw an error if destinations fail. We
+        // consider it a non-critical failure and therefore do not want it to
+        // reject the promise handed back to the customer.
+      });
+    })).then(noop);
+  };
+  return destinations => {
+    processCookies(destinations);
+    return processUrls(destinations);
+  };
+});

package/libEs6/components/Audiences/injectProcessResponse.js

@@ -0,0 +1,38 @@
+/*
+Copyright 2021 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 (({
+  processDestinations
+}) => {
+  const processPushDestinations = ({
+    response
+  }) => {
+    const destinations = response.getPayloadsByType("activation:push");
+    return processDestinations(destinations);
+  };
+  const retrievePullDestinations = ({
+    response
+  }) => {
+    return {
+      destinations: response.getPayloadsByType("activation:pull")
+    };
+  };
+  return ({
+    response
+  }) => {
+    return processPushDestinations({
+      response
+    }).then(() => retrievePullDestinations({
+      response
+    }));
+  };
+});

package/libEs6/components/Context/createComponent.js

@@ -0,0 +1,34 @@
+/*
+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.
+*/
+
+import { flatMap } from "../../utils/index.js";
+export default ((config, logger, optionalContexts, requiredContexts) => {
+  const configuredContexts = config.context;
+  const contexts = flatMap(configuredContexts, (context, i) => {
+    if (optionalContexts[context]) {
+      return [optionalContexts[context]];
+    }
+    logger.warn(`Invalid context[${i}]: '${context}' is not available.`);
+    return [];
+  }).concat(requiredContexts);
+  return {
+    namespace: "Context",
+    lifecycle: {
+      onBeforeEvent({
+        event
+      }) {
+        const xdm = {};
+        return Promise.all(contexts.map(context => Promise.resolve(context(xdm, logger)))).then(() => event.mergeXdm(xdm));
+      }
+    }
+  };
+});