@adobe/alloy 2.32.1-beta.0 → 2.33.0-beta.2

package/src/components/ActivityCollector/createGetClickedElementProperties.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 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/src/components/ActivityCollector/createInjectClickedElementProperties.js

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

package/src/components/ActivityCollector/getLinkName.js

@@ -0,0 +1,145 @@
+/*
+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 (!attributes.ariaLabel) {
+        attributes.ariaLabel = truncateWhiteSpace(
+          supportedNode.getAttribute("aria-label"),
+        );
+      }
+      if (!attributes.name) {
+        attributes.name = truncateWhiteSpace(
+          supportedNode.getAttribute("name"),
+        );
+      }
+    }
+    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 ||
+        attributesMap.ariaLabel ||
+        attributesMap.name;
+    }
+  }
+  return nodeText || "";
+};

package/src/components/ActivityCollector/getLinkRegion.js

@@ -0,0 +1,65 @@
+/*
+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 "@adobe/alloy-core/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";
+};

package/src/components/ActivityCollector/index.js

@@ -0,0 +1,132 @@
+/*
+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 "@adobe/alloy-core/utils";
+
+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/src/components/ActivityCollector/utils/activityMapExtensionEnabled.js

@@ -0,0 +1,16 @@
+/*
+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/src/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/src/components/ActivityCollector/utils/determineLinkType.js

@@ -0,0 +1,27 @@
+/*
+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 "@adobe/alloy-core/utils";
+
+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/src/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/src/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;
+};