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

package/libEs5/baseCode/index.js

@@ -0,0 +1,61 @@
+"use strict";
+
+exports.default = void 0;
+/*
+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.
+*/
+/* eslint no-param-reassign: 0 */
+/* eslint no-underscore-dangle: 0 */
+/* eslint prefer-rest-params: 0 */
+/* eslint no-var: 0 */
+/* eslint-disable func-names */
+/**
+ * This is the code, once minified, that an Alloy consumer copies and pastes
+ * into their website's HTML. It sets up any global functions the consumer will
+ * use to interact with Alloy. It also provides a queuing mechanism whereby
+ * any function calls made by the consumer before the Alloy library file
+ * loads will be enqueued and later processed by Alloy once the Alloy library
+ * file has loaded. Because each call may be asynchronously processed, a promise
+ * will always be returned to the consumer any time the consumer attempts to
+ * execute a command.
+ *
+ * Along with this base code, a script tag (not shown here) will also be added
+ * to the consumer website's HTML that will load the Alloy library file.
+ *
+ * Take particular care to write well-minifiable code, as consumers are
+ * particularly sensitive to base code size.
+ */
+var _default = exports.default = function _default(window, instanceNames) {
+  instanceNames.forEach(function (instanceName) {
+    if (!window[instanceName]) {
+      // __alloyNS stores a name of each "instance", or in other words, each
+      // global function created that the consumer will use. This array is
+      // what the Alloy library will consult once it is loaded to determine
+      // which global functions have been set up so that is can connect them to
+      // the library's command processing pipeline.
+      (window.__alloyNS = window.__alloyNS || []).push(instanceName);
+      window[instanceName] = function () {
+        var userProvidedArgs = arguments;
+        // Always return a promise, because the command may be executed
+        // asynchronously, especially if the Alloy library has not yet loaded.
+        return new Promise(function (resolve, reject) {
+          // Push required call information into the queue. Once the Alloy
+          // library is loaded, it will process this queue and resolve/reject
+          // the promise we just returned to the consumer. If the Alloy
+          // library has already loaded, then it will have already overridden
+          // q.push and will therefore process the call immediately.
+          window[instanceName].q.push([resolve, reject, userProvidedArgs]);
+        });
+      };
+      window[instanceName].q = [];
+    }
+  });
+};

package/libEs5/components/ActivityCollector/attachClickActivityCollector.js

@@ -0,0 +1,53 @@
+"use strict";
+
+exports.default = void 0;
+var _index = require("../../utils/index.js");
+/*
+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.
+*/
+
+var createClickHandler = function createClickHandler(_ref) {
+  var eventManager = _ref.eventManager,
+    lifecycle = _ref.lifecycle,
+    handleError = _ref.handleError;
+  return function (clickEvent) {
+    // TODO: Consider safeguarding from the same object being clicked multiple times in rapid succession?
+    var clickedElement = clickEvent.target;
+    var event = eventManager.createEvent();
+    // this is to make sure a exit link personalization metric use send beacon
+    event.documentMayUnload();
+    return lifecycle.onClick({
+      event: event,
+      clickedElement: clickedElement
+    }).then(function () {
+      if (event.isEmpty()) {
+        return Promise.resolve();
+      }
+      return eventManager.sendEvent(event);
+    })
+    // eventManager.sendEvent() will return a promise resolved to an
+    // object and we want to avoid returning any value to the customer
+    .then(_index.noop).catch(function (error) {
+      handleError(error, "click collection");
+    });
+  };
+};
+var _default = exports.default = function _default(_ref2) {
+  var eventManager = _ref2.eventManager,
+    lifecycle = _ref2.lifecycle,
+    handleError = _ref2.handleError;
+  var clickHandler = createClickHandler({
+    eventManager: eventManager,
+    lifecycle: lifecycle,
+    handleError: handleError
+  });
+  document.addEventListener("click", clickHandler, true);
+};

package/libEs5/components/ActivityCollector/configValidators.js

@@ -0,0 +1,22 @@
+"use strict";
+
+exports.downloadLinkQualifier = exports.default = void 0;
+var _index = require("../../utils/validation/index.js");
+/*
+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.
+*/
+
+var downloadLinkQualifier = exports.downloadLinkQualifier = (0, _index.string)().regexp().default("\\.(exe|zip|wav|mp3|mov|mpg|avi|wmv|pdf|doc|docx|xls|xlsx|ppt|pptx)$");
+var _default = exports.default = (0, _index.objectOf)({
+  clickCollectionEnabled: (0, _index.boolean)().default(true),
+  onBeforeLinkClickSend: (0, _index.callback)(),
+  downloadLinkQualifier: downloadLinkQualifier
+});

package/libEs5/components/ActivityCollector/createGetLinkDetails.js

@@ -0,0 +1,68 @@
+"use strict";
+
+exports.default = void 0;
+/*
+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.
+*/
+var _default = exports.default = function _default(_ref) {
+  var window = _ref.window,
+    getLinkName = _ref.getLinkName,
+    getLinkRegion = _ref.getLinkRegion,
+    getAbsoluteUrlFromAnchorElement = _ref.getAbsoluteUrlFromAnchorElement,
+    findSupportedAnchorElement = _ref.findSupportedAnchorElement,
+    determineLinkType = _ref.determineLinkType;
+  return function (_ref2) {
+    var targetElement = _ref2.targetElement,
+      config = _ref2.config,
+      logger = _ref2.logger;
+    var anchorElement = findSupportedAnchorElement(targetElement);
+    if (!anchorElement) {
+      logger.info("This link click event is not triggered because the HTML element is not an anchor.");
+      return undefined;
+    }
+    var 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;
+    }
+    var linkType = determineLinkType(window, config, linkUrl, anchorElement);
+    var linkRegion = getLinkRegion(anchorElement);
+    var linkName = getLinkName(anchorElement);
+    var onBeforeLinkClickSend = config.onBeforeLinkClickSend;
+    var 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;
+    }
+    var 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/libEs5/components/ActivityCollector/createLinkClick.js

@@ -0,0 +1,38 @@
+"use strict";
+
+exports.default = void 0;
+/*
+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.
+*/
+var _default = exports.default = function _default(_ref) {
+  var getLinkDetails = _ref.getLinkDetails,
+    config = _ref.config,
+    logger = _ref.logger;
+  var clickCollectionEnabled = config.clickCollectionEnabled;
+  if (!clickCollectionEnabled) {
+    return function () {
+      return undefined;
+    };
+  }
+  return function (_ref2) {
+    var targetElement = _ref2.targetElement,
+      event = _ref2.event;
+    var linkDetails = getLinkDetails({
+      targetElement: targetElement,
+      config: config,
+      logger: logger
+    });
+    if (linkDetails) {
+      event.mergeXdm(linkDetails.xdm);
+      event.setUserData(linkDetails.data);
+    }
+  };
+};

package/libEs5/components/ActivityCollector/getLinkName.js

@@ -0,0 +1,139 @@
+"use strict";
+
+exports.default = void 0;
+var _utils = require("./utils.js");
+/*
+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.
+*/
+
+var 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}
+ */
+var isSupportedTextNode = function 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.
+ */
+var extractSupportedNodes = function extractSupportedNodes(node) {
+  var supportedNodes = [];
+  var includesUnsupportedNodes = false;
+  if (isSupportedTextNode(node)) {
+    supportedNodes.push(node);
+    if (node.childNodes) {
+      var childNodes = Array.prototype.slice.call(node.childNodes);
+      childNodes.forEach(function (childNode) {
+        var nodes = extractSupportedNodes(childNode);
+        supportedNodes = supportedNodes.concat(nodes.supportedNodes);
+        includesUnsupportedNodes = includesUnsupportedNodes || nodes.includesUnsupportedNodes;
+      });
+    }
+  } else {
+    includesUnsupportedNodes = true;
+  }
+  return {
+    supportedNodes: supportedNodes,
+    includesUnsupportedNodes: 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.
+ */
+var getNodeAttributeValue = function getNodeAttributeValue(node, attributeName, nodeName) {
+  var 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.
+ * */
+var getChildrenAttributes = function getChildrenAttributes(nodes) {
+  var attributes = {
+    texts: []
+  };
+  nodes.supportedNodes.forEach(function (supportedNode) {
+    if (supportedNode.getAttribute) {
+      if (!attributes.alt) {
+        attributes.alt = (0, _utils.truncateWhiteSpace)(supportedNode.getAttribute("alt"));
+      }
+      if (!attributes.title) {
+        attributes.title = (0, _utils.truncateWhiteSpace)(supportedNode.getAttribute("title"));
+      }
+      if (!attributes.inputValue) {
+        attributes.inputValue = (0, _utils.truncateWhiteSpace)(getNodeAttributeValue(supportedNode, "value", "INPUT"));
+      }
+      if (!attributes.imgSrc) {
+        attributes.imgSrc = (0, _utils.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.
+ */
+var _default = exports.default = function _default(node) {
+  var nodeText = (0, _utils.truncateWhiteSpace)(node.innerText || node.textContent);
+  var nodes = extractSupportedNodes(node);
+  // if contains unsupported nodes we want children node attributes
+  if (!nodeText || nodes.includesUnsupportedNodes) {
+    var attributesMap = getChildrenAttributes(nodes);
+    nodeText = (0, _utils.truncateWhiteSpace)(attributesMap.texts.join(""));
+    if (!nodeText) {
+      nodeText = attributesMap.alt || attributesMap.title || attributesMap.inputValue || attributesMap.imgSrc;
+    }
+  }
+  return nodeText || "";
+};

package/libEs5/components/ActivityCollector/getLinkRegion.js

@@ -0,0 +1,61 @@
+"use strict";
+
+exports.default = void 0;
+var _utils = require("./utils.js");
+var _index = require("../../utils/index.js");
+/*
+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.
+*/
+
+var semanticElements = /^(HEADER|MAIN|FOOTER|NAV)$/i;
+var getAriaRegionLabel = function getAriaRegionLabel(node) {
+  var regionLabel;
+  if (node.role === "region" && (0, _index.isNonEmptyString)(node["aria-label"])) {
+    regionLabel = node["aria-label"];
+  }
+  return regionLabel;
+};
+var getSectionNodeName = function getSectionNodeName(node) {
+  var 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.
+ */
+var _default = exports.default = function _default(node) {
+  var linkParentNode = node.parentNode;
+  var regionName;
+  while (linkParentNode) {
+    regionName = (0, _utils.truncateWhiteSpace)(linkParentNode.id || getAriaRegionLabel(linkParentNode) || getSectionNodeName(linkParentNode));
+    if (regionName) {
+      return regionName;
+    }
+    linkParentNode = linkParentNode.parentNode;
+  }
+  return "BODY";
+};

package/libEs5/components/ActivityCollector/index.js

@@ -0,0 +1,78 @@
+"use strict";
+
+exports.default = void 0;
+var _attachClickActivityCollector = require("./attachClickActivityCollector.js");
+var _configValidators = require("./configValidators.js");
+var _createLinkClick = require("./createLinkClick.js");
+var _createGetLinkDetails = require("./createGetLinkDetails.js");
+var _getLinkName = require("./getLinkName.js");
+var _getLinkRegion = require("./getLinkRegion.js");
+var _utils = require("./utils.js");
+/*
+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.
+*/
+
+var _getLinkDetails = (0, _createGetLinkDetails.default)({
+  window: window,
+  getLinkName: _getLinkName.default,
+  getLinkRegion: _getLinkRegion.default,
+  getAbsoluteUrlFromAnchorElement: _utils.getAbsoluteUrlFromAnchorElement,
+  findSupportedAnchorElement: _utils.findSupportedAnchorElement,
+  determineLinkType: _utils.determineLinkType
+});
+var createActivityCollector = function createActivityCollector(_ref) {
+  var config = _ref.config,
+    eventManager = _ref.eventManager,
+    handleError = _ref.handleError,
+    logger = _ref.logger;
+  var linkClick = (0, _createLinkClick.default)({
+    getLinkDetails: _getLinkDetails,
+    config: config,
+    logger: logger
+  });
+  return {
+    lifecycle: {
+      onComponentsRegistered: function onComponentsRegistered(tools) {
+        var lifecycle = tools.lifecycle;
+        (0, _attachClickActivityCollector.default)({
+          eventManager: eventManager,
+          lifecycle: lifecycle,
+          handleError: handleError
+        });
+        // TODO: createScrollActivityCollector ...
+      },
+      onClick: function onClick(_ref2) {
+        var event = _ref2.event,
+          clickedElement = _ref2.clickedElement;
+        linkClick({
+          targetElement: clickedElement,
+          event: event
+        });
+      }
+    }
+  };
+};
+createActivityCollector.namespace = "ActivityCollector";
+createActivityCollector.configValidators = _configValidators.default;
+createActivityCollector.buildOnInstanceConfiguredExtraParams = function (_ref3) {
+  var config = _ref3.config,
+    logger = _ref3.logger;
+  return {
+    getLinkDetails: function getLinkDetails(targetElement) {
+      return _getLinkDetails({
+        targetElement: targetElement,
+        config: config,
+        logger: logger
+      });
+    }
+  };
+};
+var _default = exports.default = createActivityCollector;

package/libEs5/components/ActivityCollector/utils.js

@@ -0,0 +1,104 @@
+"use strict";
+
+exports.urlStartsWithScheme = exports.truncateWhiteSpace = exports.trimQueryFromUrl = exports.isSupportedAnchorElement = exports.isExitLink = exports.isEmptyString = exports.isDownloadLink = exports.getAbsoluteUrlFromAnchorElement = exports.findSupportedAnchorElement = exports.determineLinkType = void 0;
+/*
+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.
+*/
+
+var urlStartsWithScheme = exports.urlStartsWithScheme = function urlStartsWithScheme(url) {
+  return url && /^[a-z0-9]+:\/\//i.test(url);
+};
+var getAbsoluteUrlFromAnchorElement = exports.getAbsoluteUrlFromAnchorElement = function getAbsoluteUrlFromAnchorElement(window, element) {
+  var loc = window.location;
+  var url = element.href ? element.href : "";
+  var protocol = element.protocol,
+    host = element.host;
+  if (!urlStartsWithScheme(url)) {
+    if (!protocol) {
+      protocol = loc.protocol ? loc.protocol : "";
+    }
+    protocol = protocol ? protocol + "//" : "";
+    if (!host) {
+      host = loc.host ? loc.host : "";
+    }
+    var path = "";
+    if (url.substring(0, 1) !== "/") {
+      var indx = loc.pathname.lastIndexOf("/");
+      indx = indx < 0 ? 0 : indx;
+      path = loc.pathname.substring(0, indx);
+    }
+    url = "" + protocol + host + path + "/" + url;
+  }
+  return url;
+};
+var isSupportedAnchorElement = exports.isSupportedAnchorElement = function 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;
+};
+var trimQueryFromUrl = exports.trimQueryFromUrl = function trimQueryFromUrl(url) {
+  var questionMarkIndex = url.indexOf("?");
+  var 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;
+};
+var isDownloadLink = exports.isDownloadLink = function isDownloadLink(downloadLinkQualifier, linkUrl, clickedObj) {
+  var re = new RegExp(downloadLinkQualifier);
+  var trimmedLinkUrl = trimQueryFromUrl(linkUrl).toLowerCase();
+  return clickedObj.download ? true : re.test(trimmedLinkUrl);
+};
+var isExitLink = exports.isExitLink = function isExitLink(window, linkUrl) {
+  var currentHostname = window.location.hostname.toLowerCase();
+  var 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.
+ */
+var truncateWhiteSpace = exports.truncateWhiteSpace = function truncateWhiteSpace(str) {
+  return str && str.replace(/\s+/g, " ").trim();
+};
+var isEmptyString = exports.isEmptyString = function isEmptyString(str) {
+  return !str || str.length === 0;
+};
+var determineLinkType = exports.determineLinkType = function determineLinkType(window, config, linkUrl, clickedObj) {
+  var linkType = "other";
+  if (isDownloadLink(config.downloadLinkQualifier, linkUrl, clickedObj)) {
+    linkType = "download";
+  } else if (isExitLink(window, linkUrl)) {
+    linkType = "exit";
+  }
+  return linkType;
+};
+var findSupportedAnchorElement = exports.findSupportedAnchorElement = function findSupportedAnchorElement(targetElement) {
+  var node = targetElement;
+  while (node) {
+    if (isSupportedAnchorElement(node)) {
+      return node;
+    }
+    node = node.parentNode;
+  }
+  return null;
+};

package/libEs5/components/Audiences/index.js

@@ -0,0 +1,49 @@
+"use strict";
+
+exports.default = void 0;
+var _index = require("../../utils/index.js");
+var _injectProcessDestinations = require("./injectProcessDestinations.js");
+var _injectProcessResponse = require("./injectProcessResponse.js");
+/*
+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.
+*/
+
+var createAudiences = function createAudiences(_ref) {
+  var logger = _ref.logger,
+    fireReferrerHideableImage = _ref.fireReferrerHideableImage;
+  // we override the js-cookie converter to encode the cookie value similar on how it is in DIL (PDCL-10238)
+  var cookieJarWithEncoding = _index.cookieJar.withConverter({
+    write: function write(value) {
+      return encodeURIComponent(value);
+    }
+  });
+  var loggingCookieJar = (0, _index.createLoggingCookieJar)({
+    logger: logger,
+    cookieJar: cookieJarWithEncoding
+  });
+  var processDestinations = (0, _injectProcessDestinations.default)({
+    fireReferrerHideableImage: fireReferrerHideableImage,
+    logger: logger,
+    cookieJar: loggingCookieJar,
+    isPageSsl: window.location.protocol === "https:"
+  });
+  var processResponse = (0, _injectProcessResponse.default)({
+    processDestinations: processDestinations
+  });
+  return {
+    lifecycle: {
+      onResponse: processResponse
+    },
+    commands: {}
+  };
+};
+createAudiences.namespace = "Audiences";
+var _default = exports.default = createAudiences;