@adobe/alloy 2.28.0-beta.7 → 2.28.1-beta.0

package/libEs6/components/ActivityCollector/createGetClickedElementProperties.js

@@ -0,0 +1,69 @@
+/*
+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 createClickedElementProperties from "./createClickedElementProperties.js";
+export default ({
+  window,
+  getLinkName,
+  getLinkRegion,
+  getAbsoluteUrlFromAnchorElement,
+  findClickableElement,
+  determineLinkType
+}) => {
+  return ({
+    clickedElement,
+    config,
+    logger,
+    clickActivityStorage
+  }) => {
+    const {
+      onBeforeLinkClickSend: optionsFilter,
+      // Deprecated
+      clickCollection
+    } = config;
+    const {
+      filterClickDetails: propertyFilter
+    } = clickCollection;
+    const elementProperties = createClickedElementProperties({
+      logger
+    });
+    if (clickedElement) {
+      const clickableElement = findClickableElement(clickedElement);
+      if (clickableElement) {
+        elementProperties.clickedElement = clickedElement;
+        elementProperties.linkUrl = getAbsoluteUrlFromAnchorElement(window, clickableElement);
+        elementProperties.linkType = determineLinkType(window, config, elementProperties.linkUrl, clickableElement);
+        elementProperties.linkRegion = getLinkRegion(clickableElement);
+        elementProperties.linkName = getLinkName(clickableElement);
+        elementProperties.pageIDType = 0;
+        elementProperties.pageName = window.location.href;
+        // Check if we have a page-name stored from an earlier page view event
+        const storedLinkData = clickActivityStorage.load();
+        if (storedLinkData && storedLinkData.pageName) {
+          elementProperties.pageName = storedLinkData.pageName;
+          // Perhaps pageIDType should be established after customer filter is applied
+          // Like if pageName starts with "http" then pageIDType = 0
+          elementProperties.pageIDType = 1;
+        }
+        // If defined, run user provided filter function
+        if (propertyFilter) {
+          // clickCollection.filterClickDetails
+          elementProperties.applyPropertyFilter(propertyFilter);
+        } else if (optionsFilter) {
+          // onBeforeLinkClickSend
+          elementProperties.applyOptionsFilter(optionsFilter);
+        }
+      }
+    }
+    return elementProperties;
+  };
+};

package/libEs6/components/ActivityCollector/createInjectClickedElementProperties.js

@@ -0,0 +1,69 @@
+/*
+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 activityMapExtensionEnabled from "./utils/activityMapExtensionEnabled.js";
+import isDifferentDomains from "./utils/isDifferentDomains.js";
+const isDissallowedLinkType = (clickCollection, linkType) => {
+  return linkType && (linkType === "download" && !clickCollection.downloadLinkEnabled || linkType === "exit" && !clickCollection.externalLinkEnabled || linkType === "other" && !clickCollection.internalLinkEnabled);
+};
+export default ({
+  config,
+  logger,
+  getClickedElementProperties,
+  clickActivityStorage
+}) => {
+  const {
+    clickCollectionEnabled,
+    clickCollection
+  } = config;
+  if (!clickCollectionEnabled) {
+    return () => undefined;
+  }
+  return ({
+    event,
+    clickedElement
+  }) => {
+    const elementProperties = getClickedElementProperties({
+      clickActivityStorage,
+      clickedElement,
+      config,
+      logger
+    });
+    const linkType = elementProperties.linkType;
+    // Avoid clicks to be collected for the ActivityMap interface
+    if (activityMapExtensionEnabled()) {
+      return;
+    }
+    if (elementProperties.isValidLink() && isDissallowedLinkType(clickCollection, linkType)) {
+      logger.info(`Cancelling link click event due to clickCollection.${linkType}LinkEnabled = false.`);
+    } else if (
+    // Determine if element properties should be sent with event now, or be saved
+    // and grouped with a future page view event.
+    // Event grouping is not supported for the deprecated onBeforeLinkClickSend callback
+    // because only click properties is saved and not XDM and DATA (which could have been modified).
+    // However, if the filterClickDetails callback is available we group events because it takes
+    // priority over onBeforeLinkClickSend and only supports processing click properties.
+    elementProperties.isInternalLink() && clickCollection.eventGroupingEnabled && (!config.onBeforeLinkClickSend || clickCollection.filterClickDetails) && !isDifferentDomains(window.location.hostname, elementProperties.linkUrl)) {
+      clickActivityStorage.save(elementProperties.properties);
+    } else if (elementProperties.isValidLink()) {
+      // Event will be sent
+      event.mergeXdm(elementProperties.xdm);
+      event.mergeData(elementProperties.data);
+      clickActivityStorage.save({
+        pageName: elementProperties.pageName,
+        pageIDType: elementProperties.pageIDType
+      });
+    } else if (elementProperties.isValidActivityMapData()) {
+      clickActivityStorage.save(elementProperties.properties);
+    }
+  };
+};

package/libEs6/components/ActivityCollector/createRecallAndInjectClickedElementProperties.js

@@ -0,0 +1,45 @@
+/*
+Copyright 2024 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 createClickedElementProperties from "./createClickedElementProperties.js";
+import activityMapExtensionEnabled from "./utils/activityMapExtensionEnabled.js";
+export default ({
+  clickActivityStorage
+}) => {
+  return event => {
+    // Avoid clicks to be collected for the ActivityMap interface
+    if (activityMapExtensionEnabled()) {
+      return;
+    }
+    const properties = clickActivityStorage.load();
+    const elementProperties = createClickedElementProperties({
+      properties
+    });
+    if (elementProperties.isValidLink() || elementProperties.isValidActivityMapData()) {
+      if (elementProperties.isValidLink()) {
+        const xdm = elementProperties.xdm;
+        // Have to delete the eventType not to override the page view
+        delete xdm.eventType;
+        event.mergeXdm(xdm);
+      }
+      if (elementProperties.isValidActivityMapData()) {
+        event.mergeData(elementProperties.data);
+      }
+      // NOTE: We can't clear out all the storage here because we might still need to
+      // keep a page-name for multiple link-clicks (e.g. downloads) on the same page.
+      clickActivityStorage.save({
+        pageName: elementProperties.pageName,
+        pageIDType: elementProperties.pageIDType
+      });
+    }
+  };
+};

package/libEs6/components/ActivityCollector/createStorePageViewProperties.js

@@ -0,0 +1,22 @@
+/*
+Copyright 2024 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 ({
+  clickActivityStorage
+}) => {
+  return event => {
+    clickActivityStorage.save({
+      pageName: event.getContent().xdm.web.webPageDetails.name,
+      pageIDType: 1 // 1 = name, 0 = URL
+    });
+  };
+};

package/libEs6/components/ActivityCollector/getLinkName.js

@@ -0,0 +1,122 @@
+/*
+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/truncateWhiteSpace.js";
+import isSupportedTextNode from "./utils/dom/isSupportedTextNode.js";
+
+/**
+ * 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/truncateWhiteSpace.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,128 @@
+/*
+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 createInjectClickedElementProperties from "./createInjectClickedElementProperties.js";
+import createRecallAndInjectClickedElementProperties from "./createRecallAndInjectClickedElementProperties.js";
+import createGetClickedElementProperties from "./createGetClickedElementProperties.js";
+import createClickActivityStorage from "./createClickActivityStorage.js";
+import createStorePageViewProperties from "./createStorePageViewProperties.js";
+import validateClickCollectionConfig from "./validateClickCollectionConfig.js";
+import getLinkName from "./getLinkName.js";
+import getLinkRegion from "./getLinkRegion.js";
+import getAbsoluteUrlFromAnchorElement from "./utils/dom/getAbsoluteUrlFromAnchorElement.js";
+import findClickableElement from "./utils/dom/findClickableElement.js";
+import determineLinkType from "./utils/determineLinkType.js";
+import hasPageName from "./utils/hasPageName.js";
+import createTransientStorage from "./utils/createTransientStorage.js";
+import { injectStorage } from "../../utils/index.js";
+const getClickedElementProperties = createGetClickedElementProperties({
+  window,
+  getLinkName,
+  getLinkRegion,
+  getAbsoluteUrlFromAnchorElement,
+  findClickableElement,
+  determineLinkType
+});
+let clickActivityStorage;
+const initClickActivityStorage = config => {
+  if (!clickActivityStorage) {
+    const createNamespacedStorage = injectStorage(window);
+    const nameSpacedStorage = createNamespacedStorage(config.orgId || "");
+    // Use transient in-memory if sessionStorage is disabled
+    const transientStorage = createTransientStorage();
+    const storage = config.clickCollection.sessionStorageEnabled ? nameSpacedStorage.session : transientStorage;
+    clickActivityStorage = createClickActivityStorage({
+      storage
+    });
+  }
+};
+const createActivityCollector = ({
+  config,
+  eventManager,
+  handleError,
+  logger
+}) => {
+  validateClickCollectionConfig(config, logger);
+  const clickCollection = config.clickCollection;
+  if (!clickActivityStorage) {
+    initClickActivityStorage(config);
+  }
+  const injectClickedElementProperties = createInjectClickedElementProperties({
+    config,
+    logger,
+    clickActivityStorage,
+    getClickedElementProperties
+  });
+  const recallAndInjectClickedElementProperties = createRecallAndInjectClickedElementProperties({
+    clickActivityStorage
+  });
+  const storePageViewProperties = createStorePageViewProperties({
+    clickActivityStorage
+  });
+  return {
+    lifecycle: {
+      onComponentsRegistered(tools) {
+        const {
+          lifecycle
+        } = tools;
+        attachClickActivityCollector({
+          eventManager,
+          lifecycle,
+          handleError
+        });
+        // TODO: createScrollActivityCollector ...
+      },
+      onClick({
+        event,
+        clickedElement
+      }) {
+        injectClickedElementProperties({
+          event,
+          clickedElement
+        });
+      },
+      onBeforeEvent({
+        event
+      }) {
+        if (hasPageName(event)) {
+          if (clickCollection.eventGroupingEnabled) {
+            recallAndInjectClickedElementProperties(event);
+          }
+          storePageViewProperties(event, logger, clickActivityStorage);
+        }
+      }
+    }
+  };
+};
+createActivityCollector.namespace = "ActivityCollector";
+createActivityCollector.configValidators = configValidators;
+createActivityCollector.buildOnInstanceConfiguredExtraParams = ({
+  config,
+  logger
+}) => {
+  if (!clickActivityStorage) {
+    initClickActivityStorage(config);
+  }
+  return {
+    getLinkDetails: targetElement => {
+      return getClickedElementProperties({
+        clickActivityStorage,
+        clickedElement: targetElement,
+        config,
+        logger
+      }).properties;
+    }
+  };
+};
+export default createActivityCollector;

package/libEs6/components/ActivityCollector/utils/activityMapExtensionEnabled.js

@@ -0,0 +1,14 @@
+/*
+Copyright 2024 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 ACTIVITY_MAP_EXTENSION_ID = "cppXYctnr";
+export default (context = document) => context.getElementById(ACTIVITY_MAP_EXTENSION_ID) !== null;

package/libEs6/components/ActivityCollector/utils/createTransientStorage.js

@@ -0,0 +1,26 @@
+/*
+Copyright 2024 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 () => {
+  const storage = {};
+  return {
+    getItem: key => {
+      return storage[key];
+    },
+    setItem: (key, value) => {
+      storage[key] = value;
+    },
+    removeItem: key => {
+      delete storage[key];
+    }
+  };
+};

package/libEs6/components/ActivityCollector/utils/determineLinkType.js

@@ -0,0 +1,26 @@
+/*
+Copyright 2024 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 isDownloadLink from "./dom/isDownloadLink.js";
+import isExitLink from "./dom/isExitLink.js";
+import isNonEmptyString from "../../../utils/isNonEmptyString.js";
+export default (window, config, linkUrl, clickedObj) => {
+  let linkType = "other";
+  if (isNonEmptyString(linkUrl)) {
+    if (isDownloadLink(config.downloadLinkQualifier, linkUrl, clickedObj)) {
+      linkType = "download";
+    } else if (isExitLink(window, linkUrl)) {
+      linkType = "exit";
+    }
+  }
+  return linkType;
+};

package/libEs6/components/ActivityCollector/utils/dom/elementHasClickHandler.js

@@ -0,0 +1,15 @@
+/*
+Copyright 2024 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 element => {
+  return !element ? false : !!element.onclick;
+};

package/libEs6/components/ActivityCollector/utils/dom/extractDomain.js

@@ -0,0 +1,20 @@
+/*
+Copyright 2024 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 uri => {
+  let fullUrl = uri;
+  if (!/^https?:\/\//i.test(fullUrl)) {
+    fullUrl = `${window.location.protocol}//${uri}`;
+  }
+  const url = new URL(fullUrl);
+  return url.hostname;
+};

package/libEs6/components/ActivityCollector/utils/dom/findClickableElement.js

@@ -0,0 +1,26 @@
+/*
+Copyright 2024 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 isSupportedAnchorElement from "./isSupportedAnchorElement.js";
+import elementHasClickHandler from "./elementHasClickHandler.js";
+import isInputSubmitElement from "./isInputSubmitElement.js";
+import isButtonSubmitElement from "./isButtonSubmitElement.js";
+export default element => {
+  let node = element;
+  while (node) {
+    if (isSupportedAnchorElement(node) || elementHasClickHandler(node) || isInputSubmitElement(node) || isButtonSubmitElement(node)) {
+      return node;
+    }
+    node = node.parentNode;
+  }
+  return null;
+};

package/libEs6/components/ActivityCollector/utils/dom/getAbsoluteUrlFromAnchorElement.js

@@ -0,0 +1,25 @@
+/*
+Copyright 2024 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, element) => {
+  const base = window.location.href;
+  let href = element.href || "";
+  // Some objects (like SVG animations) can contain a href object instead of a string
+  if (typeof href !== "string") {
+    href = "";
+  }
+  try {
+    return new URL(href, base).href;
+  } catch {
+    return base;
+  }
+};