@adobe/alloy 2.28.0 → 2.28.1-beta.0

package/libEs5/utils/validation/integerValidator.js

@@ -0,0 +1,21 @@
+"use strict";
+
+exports.default = void 0;
+var _isInteger = require("../isInteger.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 _default = (value, path) => {
+  (0, _utils.assertValid)((0, _isInteger.default)(value), value, path, "an integer");
+  return value;
+};
+exports.default = _default;

package/libEs5/utils/validation/matchesRegexpValidator.js

@@ -0,0 +1,20 @@
+"use strict";
+
+exports.default = void 0;
+var _utils = require("./utils.js");
+/*
+Copyright 2023 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 = regexp => (value, path) => {
+  (0, _utils.assertValid)(regexp.test(value), value, path, "does not match the " + regexp.toString());
+  return value;
+};
+exports.default = _default;

package/libEs5/utils/validation/numberValidator.js

@@ -0,0 +1,21 @@
+"use strict";
+
+exports.default = void 0;
+var _isNumber = require("../isNumber.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 _default = (value, path) => {
+  (0, _utils.assertValid)((0, _isNumber.default)(value), value, path, "a number");
+  return value;
+};
+exports.default = _default;

package/libEs5/utils/validation/regexpValidator.js

@@ -0,0 +1,21 @@
+"use strict";
+
+exports.default = void 0;
+var _utils = require("./utils.js");
+var _isValidRegExp = require("../isValidRegExp.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 _default = (value, path) => {
+  (0, _utils.assertValid)((0, _isValidRegExp.default)(value), value, path, "a regular expression");
+  return value;
+};
+exports.default = _default;

package/libEs5/utils/validation/requiredValidator.js

@@ -0,0 +1,21 @@
+"use strict";
+
+exports.default = void 0;
+/*
+Copyright 2020 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 = (value, path) => {
+  if (value == null) {
+    throw new Error("'" + path + "' is a required option");
+  }
+  return value;
+};
+exports.default = _default;

package/libEs5/utils/validation/stringValidator.js

@@ -0,0 +1,21 @@
+"use strict";
+
+exports.default = void 0;
+var _isString = require("../isString.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 _default = (value, path) => {
+  (0, _utils.assertValid)((0, _isString.default)(value), value, path, "a string");
+  return value;
+};
+exports.default = _default;

package/libEs5/utils/validation/utils.js

@@ -0,0 +1,131 @@
+"use strict";
+
+exports.reverseNullSafeChainJoinErrors = exports.nullSafeChain = exports.chain = exports.assertValid = void 0;
+/*
+Copyright 2023 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.
+*/
+
+/**
+ * Wraps a validator returning the value if it is null or undefined, otherwise
+ * it will call the original validator and return the result.
+ *
+ * @param {function} validator - the validator to call if the value is not null
+ */
+const skipIfNull = validator => function skipIfNullValidator(value, path) {
+  return value == null ? value : validator.call(this, value, path);
+};
+
+/**
+ * Returns a new validator that calls the first validator and then calls the second
+ * validator with the result of the first validator. The result of the second validator
+ * is returned.
+ *
+ * @param {function} firstValidator - validator to call first
+ * @param {function} secondValidator - validator to call second
+ * @returns {function} - a new validator that calls the first and second validators
+ */
+const callSequentially = (firstValidator, secondValidator) => function callSequentiallyValidator(value, path) {
+  return secondValidator.call(this, firstValidator.call(this, value, path), path);
+};
+
+/**
+ * Just like callSequentially, but if either validator throws an error, the errors
+ * are collected and thrown at the end.
+ *
+ * @param {function} firstValidator
+ * @param {function} secondValidator
+ * @returns {function}
+ */
+const callSequentiallyJoinErrors = (firstValidator, secondValidator) => function callSequentiallyJoinErrorsValidator(value, path) {
+  const errors = [];
+  const newValue = [firstValidator, secondValidator].reduce((memo, validator) => {
+    try {
+      return validator.call(this, memo, path);
+    } catch (e) {
+      errors.push(e);
+      return memo;
+    }
+  }, value);
+  if (errors.length) {
+    throw new Error(errors.join("\n"));
+  }
+  return newValue;
+};
+
+/**
+ * Chains two validators together. In addition to calling the validators in
+ * sequence, this will also copy over methods from the base validator to the
+ * resulting validator and include any additional methods.
+ *
+ * @param {function} baseValidator - This validator will be called first, and its
+ * methods will be copied over to the returned validator.
+ * @param {function} newValidator - This validator will be called second.
+ * @param {object} additionalMethods - Additional methods to include on the returned
+ * validator.
+ * @returns {function}
+ */
+const chain = (baseValidator, newValidator, additionalMethods) => {
+  return Object.assign(callSequentially(baseValidator, newValidator), baseValidator, additionalMethods);
+};
+
+/**
+ * Chains two validators together, but skips the second validator if the value
+ * is null. In addition to calling the validators in sequence, this will also
+ * copy over methods from the base validator to the resulting validator and
+ * include any additional methods.
+ *
+ * @param {function} baseValidator - This validator will be called first, and its
+ * methods will be copied over to the returned validator.
+ * @param {function} newValidator - This validator will be called second. If the value
+ * is null after the first validator is called, this validator will not be
+ * called.
+ * @param {object} additionalMethods - Additional methods to include on the returned
+ * validator.
+ * @returns {function}
+ */
+exports.chain = chain;
+const nullSafeChain = (baseValidator, newValidator, additionalMethods) => {
+  return Object.assign(callSequentially(baseValidator, skipIfNull(newValidator)), baseValidator, additionalMethods);
+};
+
+/**
+ * Same as nullSafeChain, but calls the new validator first.
+ *
+ * @param {function} baseValidator - This validator will be called second, and its
+ * methods will be copied over to the returned validator.
+ * @param {function} newValidator - This validator will be called first. If the value
+ * is null, this validator will not be called.
+ * @param {function} additionalMethods - Additional methods to include on the returned
+ * validator.
+ * @returns {function}
+ */
+exports.nullSafeChain = nullSafeChain;
+const reverseNullSafeChainJoinErrors = (baseValidator, newValidator, additionalMethods) => {
+  return Object.assign(callSequentiallyJoinErrors(skipIfNull(newValidator), baseValidator), baseValidator, additionalMethods);
+};
+
+/**
+ * Throws an error if the value is not valid.
+ *
+ * @param {boolean} isValid - Whether or not the value is valid.
+ * @param {*} value - The value to validate.
+ * @param {string} path - The path to the value.
+ * @param {string} message - The expected part of the error message.
+ * @throws {Error} - Throws an error if the value is not valid.
+ * @returns {void}
+ */
+exports.reverseNullSafeChainJoinErrors = reverseNullSafeChainJoinErrors;
+const assertValid = (isValid, value, path, message) => {
+  if (!isValid) {
+    throw new Error("'" + path + "': Expected " + message + ", but got " + JSON.stringify(value) + ".");
+  }
+};
+exports.assertValid = assertValid;

package/libEs6/baseCode/index.js

@@ -0,0 +1,61 @@
+/*
+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.
+ */
+
+export 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/libEs6/components/ActivityCollector/attachClickActivityCollector.js

@@ -0,0 +1,56 @@
+/*
+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 { noop } from "../../utils/index.js";
+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(noop).catch(error => {
+      handleError(error, "click collection");
+    });
+  };
+};
+export default ({
+  eventManager,
+  lifecycle,
+  handleError
+}) => {
+  const clickHandler = createClickHandler({
+    eventManager,
+    lifecycle,
+    handleError
+  });
+  document.addEventListener("click", clickHandler, true);
+};

package/libEs6/components/ActivityCollector/configValidators.js

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

package/libEs6/components/ActivityCollector/createClickActivityStorage.js

@@ -0,0 +1,34 @@
+/*
+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 { CLICK_ACTIVITY_DATA } from "../../constants/sessionDataKeys.js";
+export default ({
+  storage
+}) => {
+  return {
+    save: data => {
+      const jsonData = JSON.stringify(data);
+      storage.setItem(CLICK_ACTIVITY_DATA, jsonData);
+    },
+    load: () => {
+      let jsonData = null;
+      const data = storage.getItem(CLICK_ACTIVITY_DATA);
+      if (data) {
+        jsonData = JSON.parse(data);
+      }
+      return jsonData;
+    },
+    remove: () => {
+      storage.removeItem(CLICK_ACTIVITY_DATA);
+    }
+  };
+};

package/libEs6/components/ActivityCollector/createClickedElementProperties.js

@@ -0,0 +1,218 @@
+/*
+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;
+      }
+    }
+  }
+};
+export 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;
+};