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

package/babel.config.js

@@ -0,0 +1,76 @@
+/*
+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.
+*/
+
+/*
+ * This file is used in 4 scenarios:
+ * 1. Building files specified in rollup.config.js
+ * 2. Building libEs5/ files when publishing to NPM
+ * 3. Building libEs6/ files when publishing to NPM
+ * 4. Testcafe compiling clientFunctions. Unfortunately, there is no configuration I've found
+ *    to tell Testcafe not to use this file.
+ *
+ * Environments:
+ * "rollup" - Used for rollup.config.js
+ * "npmEs5" - Used for building libEs5 files when publishing to NPM
+ * "npmEs6" - Used for building libEs6 files when publishing to NPM
+ */
+import { dirname } from "path";
+import { fileURLToPath } from "url";
+
+const cwd = dirname(fileURLToPath(import.meta.url));
+
+const transformTemplateLiteralsPlugin = [
+  "@babel/plugin-transform-template-literals",
+  {
+    loose: true,
+  },
+];
+const versionPlugin = ["./scripts/helpers/versionBabelPlugin", { cwd }];
+
+const transformModulesCommonjsPlugin = [
+  "@babel/plugin-transform-modules-commonjs",
+  {
+    strict: true,
+    noInterop: true,
+  },
+];
+
+const npmIgnoreFiles = ["src/baseCode.js"];
+
+export default {
+  env: {
+    rollup: {
+      presets: [
+        [
+          "@babel/preset-env",
+          {
+            modules: false,
+          },
+        ],
+      ],
+      plugins: [transformTemplateLiteralsPlugin, versionPlugin],
+    },
+    npmEs5: {
+      presets: [["@babel/preset-env"]],
+      ignore: npmIgnoreFiles,
+      plugins: [
+        transformTemplateLiteralsPlugin,
+        versionPlugin,
+        transformModulesCommonjsPlugin,
+      ],
+    },
+    npmEs6: {
+      ignore: npmIgnoreFiles,
+      plugins: [versionPlugin],
+    },
+  },
+};

package/libEs5/baseCode/index.js

@@ -0,0 +1,62 @@
+"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 = (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 = [];
+    }
+  });
+};
+exports.default = _default;

package/libEs5/components/ActivityCollector/attachClickActivityCollector.js

@@ -0,0 +1,60 @@
+"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.
+*/
+
+const createClickHandler = ({
+  eventManager,
+  lifecycle,
+  handleError
+}) => {
+  return clickEvent => {
+    // Ignore repropagated clicks from AppMeasurement
+    if (clickEvent.s_fe) {
+      return Promise.resolve();
+    }
+    // TODO: Consider safeguarding from the same object being clicked multiple times in rapid succession?
+    const clickedElement = "composedPath" in clickEvent && clickEvent.composedPath().length > 0 ? clickEvent.composedPath()[0] : clickEvent.target;
+    const event = eventManager.createEvent();
+    // this is to make sure a exit link personalization metric use send beacon
+    event.documentMayUnload();
+    return lifecycle.onClick({
+      event,
+      clickedElement
+    }).then(() => {
+      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(error => {
+      handleError(error, "click collection");
+    });
+  };
+};
+var _default = ({
+  eventManager,
+  lifecycle,
+  handleError
+}) => {
+  const clickHandler = createClickHandler({
+    eventManager,
+    lifecycle,
+    handleError
+  });
+  document.addEventListener("click", clickHandler, true);
+};
+exports.default = _default;

package/libEs5/components/ActivityCollector/configValidators.js

@@ -0,0 +1,41 @@
+"use strict";
+
+exports.downloadLinkQualifier = exports.default = exports.DEFAULT_DOWNLOAD_QUALIFIER = 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.
+*/
+
+const DEFAULT_DOWNLOAD_QUALIFIER = exports.DEFAULT_DOWNLOAD_QUALIFIER = "\\.(exe|zip|wav|mp3|mov|mpg|avi|wmv|pdf|doc|docx|xls|xlsx|ppt|pptx)$";
+const downloadLinkQualifier = exports.downloadLinkQualifier = (0, _index.string)().regexp().default(DEFAULT_DOWNLOAD_QUALIFIER);
+const validators = (0, _index.objectOf)({
+  clickCollectionEnabled: (0, _index.boolean)().default(true),
+  clickCollection: (0, _index.objectOf)({
+    internalLinkEnabled: (0, _index.boolean)().default(true),
+    externalLinkEnabled: (0, _index.boolean)().default(true),
+    downloadLinkEnabled: (0, _index.boolean)().default(true),
+    // TODO: Consider moving downloadLinkQualifier here.
+    sessionStorageEnabled: (0, _index.boolean)().default(false),
+    eventGroupingEnabled: (0, _index.boolean)().default(false),
+    filterClickProperties: (0, _index.callback)()
+  }).default({
+    internalLinkEnabled: true,
+    externalLinkEnabled: true,
+    downloadLinkEnabled: true,
+    sessionStorageEnabled: false,
+    eventGroupingEnabled: false
+  }),
+  downloadLinkQualifier,
+  onBeforeLinkClickSend: (0, _index.callback)().deprecated('The field "onBeforeLinkClickSend" has been deprecated. Use "clickCollection.filterClickDetails" instead.')
+});
+
+// Export both the validators and the default qualifier
+var _default = exports.default = validators;

package/libEs5/components/ActivityCollector/createClickActivityStorage.js

@@ -0,0 +1,37 @@
+"use strict";
+
+exports.default = void 0;
+var _sessionDataKeys = require("../../constants/sessionDataKeys.js");
+/*
+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.
+*/
+var _default = ({
+  storage
+}) => {
+  return {
+    save: data => {
+      const jsonData = JSON.stringify(data);
+      storage.setItem(_sessionDataKeys.CLICK_ACTIVITY_DATA, jsonData);
+    },
+    load: () => {
+      let jsonData = null;
+      const data = storage.getItem(_sessionDataKeys.CLICK_ACTIVITY_DATA);
+      if (data) {
+        jsonData = JSON.parse(data);
+      }
+      return jsonData;
+    },
+    remove: () => {
+      storage.removeItem(_sessionDataKeys.CLICK_ACTIVITY_DATA);
+    }
+  };
+};
+exports.default = _default;

package/libEs5/components/ActivityCollector/createClickedElementProperties.js

@@ -0,0 +1,222 @@
+"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.
+*/
+
+const buildXdmFromClickedElementProperties = props => {
+  return {
+    eventType: "web.webinteraction.linkClicks",
+    web: {
+      webInteraction: {
+        name: props.linkName,
+        region: props.linkRegion,
+        type: props.linkType,
+        URL: props.linkUrl,
+        linkClicks: {
+          value: 1
+        }
+      }
+    }
+  };
+};
+const buildDataFromClickedElementProperties = props => {
+  return {
+    __adobe: {
+      analytics: {
+        contextData: {
+          a: {
+            activitymap: {
+              page: props.pageName,
+              link: props.linkName,
+              region: props.linkRegion,
+              pageIDType: props.pageIDType
+            }
+          }
+        }
+      }
+    }
+  };
+};
+const populateClickedElementPropertiesFromOptions = (options, props) => {
+  const {
+    xdm,
+    data,
+    clickedElement
+  } = options;
+  props.clickedElement = clickedElement;
+  if (xdm && xdm.web && xdm.web.webInteraction) {
+    const {
+      name,
+      region,
+      type,
+      URL
+    } = xdm.web.webInteraction;
+    props.linkName = name;
+    props.linkRegion = region;
+    props.linkType = type;
+    props.linkUrl = URL;
+  }
+  // DATA has priority over XDM
+  /* eslint no-underscore-dangle: 0 */
+  if (data && data.__adobe && data.__adobe.analytics) {
+    const {
+      contextData
+    } = data.__adobe.analytics;
+    if (contextData && contextData.a && contextData.a.activitymap) {
+      // Set the properties if they exists
+      const {
+        page,
+        link,
+        region,
+        pageIDType
+      } = contextData.a.activitymap;
+      props.pageName = page || props.pageName;
+      props.linkName = link || props.linkName;
+      props.linkRegion = region || props.linkRegion;
+      if (pageIDType !== undefined) {
+        props.pageIDType = pageIDType;
+      }
+    }
+  }
+};
+var _default = ({
+  properties,
+  logger
+} = {}) => {
+  let props = properties || {};
+  const clickedElementProperties = {
+    get pageName() {
+      return props.pageName;
+    },
+    set pageName(value) {
+      props.pageName = value;
+    },
+    get linkName() {
+      return props.linkName;
+    },
+    set linkName(value) {
+      props.linkName = value;
+    },
+    get linkRegion() {
+      return props.linkRegion;
+    },
+    set linkRegion(value) {
+      props.linkRegion = value;
+    },
+    get linkType() {
+      return props.linkType;
+    },
+    set linkType(value) {
+      props.linkType = value;
+    },
+    get linkUrl() {
+      return props.linkUrl;
+    },
+    set linkUrl(value) {
+      props.linkUrl = value;
+    },
+    get pageIDType() {
+      return props.pageIDType;
+    },
+    set pageIDType(value) {
+      props.pageIDType = value;
+    },
+    get clickedElement() {
+      return props.clickedElement;
+    },
+    set clickedElement(value) {
+      props.clickedElement = value;
+    },
+    get properties() {
+      return {
+        pageName: props.pageName,
+        linkName: props.linkName,
+        linkRegion: props.linkRegion,
+        linkType: props.linkType,
+        linkUrl: props.linkUrl,
+        pageIDType: props.pageIDType
+      };
+    },
+    isValidLink() {
+      return !!props.linkUrl && !!props.linkType && !!props.linkName && !!props.linkRegion;
+    },
+    isInternalLink() {
+      return this.isValidLink() && props.linkType === "other";
+    },
+    isValidActivityMapData() {
+      return !!props.pageName && !!props.linkName && !!props.linkRegion && props.pageIDType !== undefined;
+    },
+    get xdm() {
+      if (props.filteredXdm) {
+        return props.filteredXdm;
+      }
+      return buildXdmFromClickedElementProperties(this);
+    },
+    get data() {
+      if (props.filteredData) {
+        return props.filteredData;
+      }
+      return buildDataFromClickedElementProperties(this);
+    },
+    applyPropertyFilter(filter) {
+      if (filter && filter(props) === false) {
+        if (logger) {
+          logger.info("Clicked element properties were rejected by filter function: " + JSON.stringify(this.properties, null, 2));
+        }
+        props = {};
+      }
+    },
+    applyOptionsFilter(filter) {
+      const opts = this.options;
+      if (opts && opts.clickedElement && (opts.xdm || opts.data)) {
+        // Properties are rejected if filter is explicitly false.
+        if (filter && filter(opts) === false) {
+          if (logger) {
+            logger.info("Clicked element properties were rejected by filter function: " + JSON.stringify(this.properties, null, 2));
+          }
+          this.options = undefined;
+          return;
+        }
+        this.options = opts;
+        // This is just to ensure that any fields outside clicked element properties
+        // set by the user filter persists.
+        props.filteredXdm = opts.xdm;
+        props.filteredData = opts.data;
+      }
+    },
+    get options() {
+      const opts = {};
+      if (this.isValidLink()) {
+        opts.xdm = this.xdm;
+      }
+      if (this.isValidActivityMapData()) {
+        opts.data = this.data;
+      }
+      if (this.clickedElement) {
+        opts.clickedElement = this.clickedElement;
+      }
+      if (!opts.xdm && !opts.data) {
+        return undefined;
+      }
+      return opts;
+    },
+    set options(value) {
+      props = {};
+      if (value) {
+        populateClickedElementPropertiesFromOptions(value, props);
+      }
+    }
+  };
+  return clickedElementProperties;
+};
+exports.default = _default;

package/libEs5/components/ActivityCollector/createGetClickedElementProperties.js

@@ -0,0 +1,72 @@
+"use strict";
+
+exports.default = void 0;
+var _createClickedElementProperties = require("./createClickedElementProperties.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 _default = ({
+  window,
+  getLinkName,
+  getLinkRegion,
+  getAbsoluteUrlFromAnchorElement,
+  findClickableElement,
+  determineLinkType
+}) => {
+  return ({
+    clickedElement,
+    config,
+    logger,
+    clickActivityStorage
+  }) => {
+    const {
+      onBeforeLinkClickSend: optionsFilter,
+      // Deprecated
+      clickCollection
+    } = config;
+    const {
+      filterClickDetails: propertyFilter
+    } = clickCollection;
+    const elementProperties = (0, _createClickedElementProperties.default)({
+      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;
+  };
+};
+exports.default = _default;

package/libEs5/components/ActivityCollector/createInjectClickedElementProperties.js

@@ -0,0 +1,73 @@
+"use strict";
+
+exports.default = void 0;
+var _activityMapExtensionEnabled = require("./utils/activityMapExtensionEnabled.js");
+var _isDifferentDomains = require("./utils/isDifferentDomains.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.
+*/
+
+const isDissallowedLinkType = (clickCollection, linkType) => {
+  return linkType && (linkType === "download" && !clickCollection.downloadLinkEnabled || linkType === "exit" && !clickCollection.externalLinkEnabled || linkType === "other" && !clickCollection.internalLinkEnabled);
+};
+var _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 ((0, _activityMapExtensionEnabled.default)()) {
+      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) && !(0, _isDifferentDomains.default)(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);
+    }
+  };
+};
+exports.default = _default;