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

package/libEs5/utils/validation/index.js

@@ -0,0 +1,239 @@
+"use strict";
+
+exports.string = exports.objectOf = exports.number = exports.mapOfValues = exports.literal = exports.enumOf = exports.callback = exports.boolean = exports.arrayOf = exports.anything = exports.anyOf = void 0;
+var _utils = require("./utils.js");
+var _booleanValidator = require("./booleanValidator.js");
+var _callbackValidator = require("./callbackValidator.js");
+var _createArrayOfValidator = require("./createArrayOfValidator.js");
+var _createDefaultValidator = require("./createDefaultValidator.js");
+var _createDeprecatedValidator = require("./createDeprecatedValidator.js");
+var _createLiteralValidator = require("./createLiteralValidator.js");
+var _createMapOfValuesValidator = require("./createMapOfValuesValidator.js");
+var _createMinimumValidator = require("./createMinimumValidator.js");
+var _createMaximumValidator = require("./createMaximumValidator.js");
+var _createNoUnknownFieldsValidator = require("./createNoUnknownFieldsValidator.js");
+var _createNonEmptyValidator = require("./createNonEmptyValidator.js");
+var _createObjectOfValidator = require("./createObjectOfValidator.js");
+var _createAnyOfValidator = require("./createAnyOfValidator.js");
+var _createUniqueValidator = require("./createUniqueValidator.js");
+var _createUniqueItemsValidator = require("./createUniqueItemsValidator.js");
+var _domainValidator = require("./domainValidator.js");
+var _integerValidator = require("./integerValidator.js");
+var _numberValidator = require("./numberValidator.js");
+var _regexpValidator = require("./regexpValidator.js");
+var _requiredValidator = require("./requiredValidator.js");
+var _stringValidator = require("./stringValidator.js");
+var _matchesRegexpValidator = require("./matchesRegexpValidator.js");
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); } /*
+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.
+*/ /**
+ * Validators are functions of two parameters (value and path) that return the
+ * computed value if the input is valid, or throw an exception if the input is
+ * invalid. In most cases the returned value is the same as the input value;
+ * however, reference createDefaultValidator.js to see an example where the
+ * computed value is different from the input. Additionally, if we ever wanted
+ * to coerce types (i.e. parse string values into integers) as part of the
+ * validation process we could use the computed value to accomplish that.
+ *
+ * The path parameter is used to generate informative error messages. It is
+ * created by the objectOf, and arrayOf validators so that any error message can
+ * describe which key within the object or array is invalid.
+ *
+ * The validators also have methods to chain additional validation logic. For
+ * example, when you call `string()` to start a validator chain, it returns a
+ * validator function but it also has methods like `required` and `nonEmpty`.
+ * Here you can see that these methods are actually calling `chain`.
+ * Specifically in this function, the leftValidator is called first and then the
+ * return value of that is sent to the rightValidator. For example, when calling
+ * `string().nonEmpty().required()` the following chain is built up:
+ * ```
+ *              *
+ *            /   \
+ *          *     required
+ *        /   \
+ *      *     nonEmpty
+ *    /   \
+ * base   string
+ * ```
+ * Where every * is a call to chain where the two are combined. The individual
+ * validators are called from left to right in the above tree. The base
+ * validator is simply the identity function `value => value`, representing an
+ * optional value.
+ *
+ * After combining the validators, the new validator function is then augmented
+ * with the methods from the leftValidator and from the additionalMethods
+ * parameter. For example, when the string() function is called it chains to the
+ * base validator, but also adds additional methods like (`regexp`, `domain`,
+ * `nonEmpty`, and `unique`). When `nonEmpty` is called, which calls chain
+ * again, the additional methods are carried forward because they are already
+ * defined on the leftValidator.
+ *
+ * The base validator also contains the two methods `required` and `default`, so
+ * these can be used anywhere after any of the exposed validator functions are
+ * called.
+ *
+ * For most validators, we want the validation to be optional (i.e. allow null
+ * or undefined values). To accomplish this, the validator needs to have a check
+ * at the begining of the function, short circuiting the validation logic and
+ * returning value if value is null or undefined. `default` and `required` do
+ * not want this null check though. Indeed, `default` should return the default
+ * value if value is null, and `required` should throw an error if value is
+ * null.
+ *
+ * So to keep from having to have a null check in front of most validators,
+ * nullSafeChain allows you to chain a validator in a null-safe way.
+ */
+// The base validator does no validation and just returns the value unchanged
+var base = function base(value) {
+  return value;
+};
+
+// The 'default', 'required', and 'deprecated' methods are available after any
+// data-type method. Don't use the nullSafeChain on 'default' or 'required'
+// because they need to handle the null or undefined case
+base.default = function _default(defaultValue) {
+  return (0, _utils.chain)(this, (0, _createDefaultValidator.default)(defaultValue));
+};
+base.required = function required() {
+  return (0, _utils.chain)(this, _requiredValidator.default);
+};
+
+// helper validators
+var domain = function domain() {
+  return (0, _utils.nullSafeChain)(this, _domainValidator.default);
+};
+var minimumInteger = function minimumInteger(minValue) {
+  return (0, _utils.nullSafeChain)(this, (0, _createMinimumValidator.default)("an integer", minValue));
+};
+var minimumNumber = function minimumNumber(minValue) {
+  return (0, _utils.nullSafeChain)(this, (0, _createMinimumValidator.default)("a number", minValue));
+};
+var maximumNumber = function maximumNumber(maxValue) {
+  return (0, _utils.nullSafeChain)(this, (0, _createMaximumValidator.default)("a number", maxValue));
+};
+var integer = function integer() {
+  return (0, _utils.nullSafeChain)(this, _integerValidator.default, {
+    minimum: minimumInteger
+  });
+};
+var nonEmptyString = function nonEmptyString() {
+  return (0, _utils.nullSafeChain)(this, (0, _createNonEmptyValidator.default)("a non-empty string"));
+};
+var nonEmptyArray = function nonEmptyArray() {
+  return (0, _utils.nullSafeChain)(this, (0, _createNonEmptyValidator.default)("a non-empty array"));
+};
+var nonEmptyObject = function nonEmptyObject() {
+  return (0, _utils.nullSafeChain)(this, (0, _createNonEmptyValidator.default)("a non-empty object"));
+};
+var regexp = function regexp() {
+  return (0, _utils.nullSafeChain)(this, _regexpValidator.default);
+};
+var matches = function matches(regexpPattern) {
+  return (0, _utils.nullSafeChain)(this, (0, _matchesRegexpValidator.default)(regexpPattern));
+};
+var unique = function createUnique() {
+  return (0, _utils.nullSafeChain)(this, (0, _createUniqueValidator.default)());
+};
+var uniqueItems = function createUniqueItems() {
+  return (0, _utils.nullSafeChain)(this, (0, _createUniqueItemsValidator.default)());
+};
+
+// top-level validators.  These are the first functions that are called to create a validator.
+var anyOf = function anyOf(validators, message) {
+  // use chain here because we don't want to accept null or undefined unless at least
+  // one of the validators accept null or undefined.
+  return (0, _utils.chain)(this, (0, _createAnyOfValidator.default)(validators, message));
+};
+var anything = function anything() {
+  return this;
+};
+var arrayOf = function arrayOf(elementValidator) {
+  return (0, _utils.nullSafeChain)(this, (0, _createArrayOfValidator.default)(elementValidator), {
+    nonEmpty: nonEmptyArray,
+    uniqueItems: uniqueItems
+  });
+};
+var boolean = function boolean() {
+  return (0, _utils.nullSafeChain)(this, _booleanValidator.default);
+};
+var callback = function callback() {
+  return (0, _utils.nullSafeChain)(this, _callbackValidator.default);
+};
+var literal = function literal(literalValue) {
+  return (0, _utils.nullSafeChain)(this, (0, _createLiteralValidator.default)(literalValue));
+};
+var number = function number() {
+  return (0, _utils.nullSafeChain)(this, _numberValidator.default, {
+    minimum: minimumNumber,
+    maximum: maximumNumber,
+    integer: integer,
+    unique: unique
+  });
+};
+var mapOfValues = function mapOfValues(valuesValidator) {
+  return (0, _utils.nullSafeChain)(this, (0, _createMapOfValuesValidator.default)(valuesValidator), {
+    nonEmpty: nonEmptyObject
+  });
+};
+var createObjectOfAdditionalProperties = function createObjectOfAdditionalProperties(schema) {
+  return {
+    noUnknownFields: function noUnknownFields() {
+      return (0, _utils.nullSafeChain)(this, (0, _createNoUnknownFieldsValidator.default)(schema));
+    },
+    nonEmpty: nonEmptyObject,
+    concat: function concat(otherObjectOfValidator) {
+      // combine the schema so that noUnknownFields, and concat have the combined schema
+      var newSchema = _objectSpread(_objectSpread({}, schema), otherObjectOfValidator.schema);
+      return (0, _utils.nullSafeChain)(this, otherObjectOfValidator, createObjectOfAdditionalProperties(newSchema));
+    },
+    deprecated: function deprecated(oldField, oldSchema, newField) {
+      // Run the deprecated validator first so that the deprecated field is removed
+      // before the objectOf validator runs.
+      return (0, _utils.reverseNullSafeChainJoinErrors)(this, (0, _createDeprecatedValidator.default)(oldField, oldSchema, newField));
+    },
+    schema: schema
+  };
+};
+var objectOf = function objectOf(schema) {
+  return (0, _utils.nullSafeChain)(this, (0, _createObjectOfValidator.default)(schema), createObjectOfAdditionalProperties(schema));
+};
+var string = function string() {
+  return (0, _utils.nullSafeChain)(this, _stringValidator.default, {
+    regexp: regexp,
+    domain: domain,
+    nonEmpty: nonEmptyString,
+    unique: unique,
+    matches: matches
+  });
+};
+var boundAnyOf = exports.anyOf = anyOf.bind(base);
+var boundAnything = exports.anything = anything.bind(base);
+var boundArrayOf = exports.arrayOf = arrayOf.bind(base);
+var boundBoolean = exports.boolean = boolean.bind(base);
+var boundCallback = exports.callback = callback.bind(base);
+var boundLiteral = exports.literal = literal.bind(base);
+var boundNumber = exports.number = number.bind(base);
+var boundMapOfValues = exports.mapOfValues = mapOfValues.bind(base);
+var boundObjectOf = exports.objectOf = objectOf.bind(base);
+var boundString = exports.string = string.bind(base);
+
+// compound validators
+var boundEnumOf = exports.enumOf = function boundEnumOf() {
+  for (var _len = arguments.length, values = new Array(_len), _key = 0; _key < _len; _key++) {
+    values[_key] = arguments[_key];
+  }
+  return boundAnyOf(values.map(boundLiteral), "one of these values: [" + JSON.stringify(values) + "]");
+};

package/libEs5/utils/validation/integerValidator.js

@@ -0,0 +1,20 @@
+"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 = exports.default = function _default(value, path) {
+  (0, _utils.assertValid)((0, _isInteger.default)(value), value, path, "an integer");
+  return value;
+};

package/libEs5/utils/validation/matchesRegexpValidator.js

@@ -0,0 +1,21 @@
+"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 = exports.default = function _default(regexp) {
+  return function (value, path) {
+    (0, _utils.assertValid)(regexp.test(value), value, path, "does not match the " + regexp.toString());
+    return value;
+  };
+};

package/libEs5/utils/validation/numberValidator.js

@@ -0,0 +1,20 @@
+"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 = exports.default = function _default(value, path) {
+  (0, _utils.assertValid)((0, _isNumber.default)(value), value, path, "a number");
+  return value;
+};

package/libEs5/utils/validation/regexpValidator.js

@@ -0,0 +1,20 @@
+"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 = exports.default = function _default(value, path) {
+  (0, _utils.assertValid)((0, _isValidRegExp.default)(value), value, path, "a regular expression");
+  return value;
+};

package/libEs5/utils/validation/requiredValidator.js

@@ -0,0 +1,20 @@
+"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 = exports.default = function _default(value, path) {
+  if (value == null) {
+    throw new Error("'" + path + "' is a required option");
+  }
+  return value;
+};

package/libEs5/utils/validation/stringValidator.js

@@ -0,0 +1,20 @@
+"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 = exports.default = function _default(value, path) {
+  (0, _utils.assertValid)((0, _isString.default)(value), value, path, "a string");
+  return value;
+};

package/libEs5/utils/validation/utils.js

@@ -0,0 +1,137 @@
+"use strict";
+
+exports.reverseNullSafeChainJoinErrors = exports.nullSafeChain = exports.chain = exports.assertValid = void 0;
+var _assign = require("../assign.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.
+*/
+
+// This is used to add methods onto a function.
+
+/**
+ * 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
+ */
+var skipIfNull = function skipIfNull(validator) {
+  return 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
+ */
+var callSequentially = function callSequentially(firstValidator, secondValidator) {
+  return 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}
+ */
+var callSequentiallyJoinErrors = function callSequentiallyJoinErrors(firstValidator, secondValidator) {
+  return function callSequentiallyJoinErrorsValidator(value, path) {
+    var _this = this;
+    var errors = [];
+    var newValue = [firstValidator, secondValidator].reduce(function (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}
+ */
+var chain = exports.chain = function chain(baseValidator, newValidator, additionalMethods) {
+  return (0, _assign.default)(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}
+ */
+var nullSafeChain = exports.nullSafeChain = function nullSafeChain(baseValidator, newValidator, additionalMethods) {
+  return (0, _assign.default)(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}
+ */
+var reverseNullSafeChainJoinErrors = exports.reverseNullSafeChainJoinErrors = function reverseNullSafeChainJoinErrors(baseValidator, newValidator, additionalMethods) {
+  return (0, _assign.default)(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}
+ */
+var assertValid = exports.assertValid = function assertValid(isValid, value, path, message) {
+  if (!isValid) {
+    throw new Error("'" + path + "': Expected " + message + ", but got " + JSON.stringify(value) + ".");
+  }
+};

package/libEs5/utils/values.js

@@ -0,0 +1,25 @@
+"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.
+*/
+/**
+ * Returns an array whose items are the provided object's own enumerable
+ * property values.
+ * @param {Object} obj
+ * @returns {Array}
+ */
+var _default = exports.default = function _default(obj) {
+  return Object.keys(obj).map(function (key) {
+    return obj[key];
+  });
+};

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,52 @@
+/*
+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 => {
+    // TODO: Consider safeguarding from the same object being clicked multiple times in rapid succession?
+    const clickedElement = 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,19 @@
+/*
+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";
+export const downloadLinkQualifier = string().regexp().default("\\.(exe|zip|wav|mp3|mov|mpg|avi|wmv|pdf|doc|docx|xls|xlsx|ppt|pptx)$");
+export default objectOf({
+  clickCollectionEnabled: boolean().default(true),
+  onBeforeLinkClickSend: callback(),
+  downloadLinkQualifier
+});