@adobe/alloy 2.19.0-beta.0 → 2.19.0-beta.2

package/libEs5/utils/validation/index.js

@@ -1,144 +1,169 @@
 "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");
-
 var _booleanValidator = require("./booleanValidator");
-
 var _callbackValidator = require("./callbackValidator");
-
 var _createArrayOfValidator = require("./createArrayOfValidator");
-
 var _createDefaultValidator = require("./createDefaultValidator");
-
 var _createDeprecatedValidator = require("./createDeprecatedValidator");
-
 var _createLiteralValidator = require("./createLiteralValidator");
-
 var _createMapOfValuesValidator = require("./createMapOfValuesValidator");
-
 var _createMinimumValidator = require("./createMinimumValidator");
-
 var _createNoUnknownFieldsValidator = require("./createNoUnknownFieldsValidator");
-
 var _createNonEmptyValidator = require("./createNonEmptyValidator");
-
 var _createObjectOfValidator = require("./createObjectOfValidator");
-
 var _createAnyOfValidator = require("./createAnyOfValidator");
-
 var _createUniqueValidator = require("./createUniqueValidator");
-
 var _createUniqueItemsValidator = require("./createUniqueItemsValidator");
-
 var _domainValidator = require("./domainValidator");
-
 var _integerValidator = require("./integerValidator");
-
 var _numberValidator = require("./numberValidator");
-
 var _regexpValidator = require("./regexpValidator");
-
 var _requiredValidator = require("./requiredValidator");
-
 var _stringValidator = require("./stringValidator");
-
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } /*
+                                                                                                                                                                                                                  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
+};
+
+// 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
-
+};
 
+// 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 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 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.
-
+};
 
+// 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,
@@ -146,13 +171,11 @@ var number = function number() {
     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() {
@@ -162,7 +185,6 @@ var createObjectOfAdditionalProperties = function createObjectOfAdditionalProper
     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) {
@@ -173,11 +195,9 @@ var createObjectOfAdditionalProperties = function createObjectOfAdditionalProper
     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,
@@ -186,7 +206,6 @@ var string = function string() {
     unique: unique
   });
 };
-
 var boundAnyOf = anyOf.bind(base);
 exports.anyOf = boundAnyOf;
 var boundAnything = anything.bind(base);
@@ -205,16 +224,14 @@ var boundMapOfValues = mapOfValues.bind(base);
 exports.mapOfValues = boundMapOfValues;
 var boundObjectOf = objectOf.bind(base);
 exports.objectOf = boundObjectOf;
-var boundString = string.bind(base); // compound validators
+var boundString = string.bind(base);
 
+// compound validators
 exports.string = boundString;
-
 var boundEnumOf = 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) + "]");
 };
-
 exports.enumOf = boundEnumOf;

package/libEs5/utils/validation/integerValidator.js

@@ -1,11 +1,8 @@
 "use strict";
 
 exports.default = void 0;
-
 var _isInteger = require("../isInteger");
-
 var _utils = require("./utils");
-
 /*
 Copyright 2019 Adobe. All rights reserved.
 This file is licensed to you under the Apache License, Version 2.0 (the "License");
@@ -21,5 +18,4 @@ var _default = function _default(value, path) {
   (0, _utils.assertValid)((0, _isInteger.default)(value), value, path, "an integer");
   return value;
 };
-
 exports.default = _default;

package/libEs5/utils/validation/numberValidator.js

@@ -1,11 +1,8 @@
 "use strict";
 
 exports.default = void 0;
-
 var _isNumber = require("../isNumber");
-
 var _utils = require("./utils");
-
 /*
 Copyright 2019 Adobe. All rights reserved.
 This file is licensed to you under the Apache License, Version 2.0 (the "License");
@@ -21,5 +18,4 @@ var _default = function _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

@@ -1,11 +1,8 @@
 "use strict";
 
 exports.default = void 0;
-
 var _utils = require("./utils");
-
 var _isValidRegExp = require("../isValidRegExp");
-
 /*
 Copyright 2019 Adobe. All rights reserved.
 This file is licensed to you under the Apache License, Version 2.0 (the "License");
@@ -21,5 +18,4 @@ var _default = function _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

@@ -1,7 +1,6 @@
 "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");
@@ -17,8 +16,6 @@ var _default = function _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

@@ -1,11 +1,8 @@
 "use strict";
 
 exports.default = void 0;
-
 var _isString = require("../isString");
-
 var _utils = require("./utils");
-
 /*
 Copyright 2019 Adobe. All rights reserved.
 This file is licensed to you under the Apache License, Version 2.0 (the "License");
@@ -21,5 +18,4 @@ var _default = function _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

@@ -1,9 +1,7 @@
 "use strict";
 
 exports.reverseNullSafeChainJoinErrors = exports.nullSafeChain = exports.chain = exports.assertValid = void 0;
-
 var _assign = require("../assign");
-
 /*
 Copyright 2023 Adobe. All rights reserved.
 This file is licensed to you under the Apache License, Version 2.0 (the "License");
@@ -15,6 +13,7 @@ the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTA
 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.
 
 /**
@@ -28,6 +27,7 @@ var skipIfNull = function skipIfNull(validator) {
     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
@@ -37,13 +37,12 @@ var skipIfNull = function skipIfNull(validator) {
  * @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.
@@ -52,12 +51,9 @@ var callSequentially = function callSequentially(firstValidator, secondValidator
  * @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 {
@@ -67,14 +63,13 @@ var callSequentiallyJoinErrors = function callSequentiallyJoinErrors(firstValida
         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
@@ -87,11 +82,10 @@ var callSequentiallyJoinErrors = function callSequentiallyJoinErrors(firstValida
  * validator.
  * @returns {function}
  */
-
-
 var 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
@@ -107,13 +101,11 @@ var chain = function chain(baseValidator, newValidator, additionalMethods) {
  * validator.
  * @returns {function}
  */
-
-
 exports.chain = chain;
-
 var 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.
  *
@@ -125,13 +117,11 @@ var nullSafeChain = function nullSafeChain(baseValidator, newValidator, addition
  * validator.
  * @returns {function}
  */
-
-
 exports.nullSafeChain = nullSafeChain;
-
 var 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.
  *
@@ -142,14 +132,10 @@ var reverseNullSafeChainJoinErrors = function reverseNullSafeChainJoinErrors(bas
  * @throws {Error} - Throws an error if the value is not valid.
  * @returns {void}
  */
-
-
 exports.reverseNullSafeChainJoinErrors = reverseNullSafeChainJoinErrors;
-
 var assertValid = function assertValid(isValid, value, path, message) {
   if (!isValid) {
     throw new Error("'" + path + "': Expected " + message + ", but got " + JSON.stringify(value) + ".");
   }
 };
-
 exports.assertValid = assertValid;

package/libEs5/utils/values.js

@@ -1,7 +1,6 @@
 "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");
@@ -13,7 +12,6 @@ the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTA
 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.
@@ -25,5 +23,4 @@ var _default = function _default(obj) {
     return obj[key];
   });
 };
-
 exports.default = _default;

package/libEs6/baseCode/index.js

@@ -11,13 +11,9 @@ 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 */
 
 /**
@@ -36,6 +32,7 @@ governing permissions and limitations under the License.
  * 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]) {
@@ -45,11 +42,10 @@ export default ((window, instanceNames) => {
       // 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
+        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
@@ -59,7 +55,6 @@ export default ((window, instanceNames) => {
           window[instanceName].q.push([resolve, reject, userProvidedArgs]);
         });
       };
-
       window[instanceName].q = [];
     }
   });

package/libEs6/components/ActivityCollector/attachClickActivityCollector.js

@@ -9,8 +9,8 @@ the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTA
 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";
 
+import { noop } from "../../utils";
 const createClickHandler = ({
   eventManager,
   lifecycle,
@@ -19,8 +19,8 @@ const createClickHandler = ({
   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
-
+    const event = eventManager.createEvent();
+    // this is to make sure a exit link personalization metric use send beacon
     event.documentMayUnload();
     return lifecycle.onClick({
       event,
@@ -29,16 +29,15 @@ const createClickHandler = ({
       if (event.isEmpty()) {
         return Promise.resolve();
       }
-
       return eventManager.sendEvent(event);
-    }) // eventManager.sendEvent() will return a promise resolved to an
+    })
+    // 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,

package/libEs6/components/ActivityCollector/configValidators.js

@@ -9,6 +9,7 @@ the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTA
 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";
 export const downloadLinkQualifier = string().regexp().default("\\.(exe|zip|wav|mp3|mov|mpg|avi|wmv|pdf|doc|docx|xls|xlsx|ppt|pptx)$");
 export default objectOf({