@adobe/alloy 2.20.0-alpha.1 → 2.20.0-beta.2

package/libEs5/utils/validation/index.js

@@ -1,247 +0,0 @@
-"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 _createMaximumValidator = require("./createMaximumValidator");
-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");
-var _matchesRegexpValidator = require("./matchesRegexpValidator");
-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; } /*
-                                                                                                                                                                                                                  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 = anyOf.bind(base);
-exports.anyOf = boundAnyOf;
-var boundAnything = anything.bind(base);
-exports.anything = boundAnything;
-var boundArrayOf = arrayOf.bind(base);
-exports.arrayOf = boundArrayOf;
-var boundBoolean = boolean.bind(base);
-exports.boolean = boundBoolean;
-var boundCallback = callback.bind(base);
-exports.callback = boundCallback;
-var boundLiteral = literal.bind(base);
-exports.literal = boundLiteral;
-var boundNumber = number.bind(base);
-exports.number = boundNumber;
-var boundMapOfValues = mapOfValues.bind(base);
-exports.mapOfValues = boundMapOfValues;
-var boundObjectOf = objectOf.bind(base);
-exports.objectOf = boundObjectOf;
-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,21 +0,0 @@
-"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");
-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 = function _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

@@ -1,22 +0,0 @@
-"use strict";
-
-exports.default = void 0;
-var _utils = require("./utils");
-/*
-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 = function _default(regexp) {
-  return function (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

@@ -1,21 +0,0 @@
-"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");
-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 = 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,21 +0,0 @@
-"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");
-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 = 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,21 +0,0 @@
-"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 = 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,21 +0,0 @@
-"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");
-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 = 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,141 +0,0 @@
-"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");
-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 = 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}
- */
-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.
- *
- * @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;
-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.
- *
- * @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;
-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,26 +0,0 @@
-"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 = function _default(obj) {
-  return Object.keys(obj).map(function (key) {
-    return obj[key];
-  });
-};
-exports.default = _default;

package/libEs6/baseCode/index.js

@@ -1,61 +0,0 @@
-/*
-Copyright 2019 Adobe. All rights reserved.
-This file is licensed to you under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License. You may obtain a copy
-of the License at http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software distributed under
-the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
-OF ANY KIND, either express or implied. See the License for the specific language
-governing permissions and limitations under the License.
-*/
-
-/* eslint no-param-reassign: 0 */
-/* eslint no-underscore-dangle: 0 */
-/* eslint prefer-rest-params: 0 */
-/* eslint no-var: 0 */
-/* eslint-disable func-names */
-
-/**
- * This is the code, once minified, that an Alloy consumer copies and pastes
- * into their website's HTML. It sets up any global functions the consumer will
- * use to interact with Alloy. It also provides a queuing mechanism whereby
- * any function calls made by the consumer before the Alloy library file
- * loads will be enqueued and later processed by Alloy once the Alloy library
- * file has loaded. Because each call may be asynchronously processed, a promise
- * will always be returned to the consumer any time the consumer attempts to
- * execute a command.
- *
- * Along with this base code, a script tag (not shown here) will also be added
- * to the consumer website's HTML that will load the Alloy library file.
- *
- * Take particular care to write well-minifiable code, as consumers are
- * particularly sensitive to base code size.
- */
-
-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 = [];
-    }
-  });
-});