@adobe/alloy 2.17.0-beta.0 → 2.18.0-beta.0

package/libEs6/utils/request/createRequestParams.js

@@ -0,0 +1,43 @@
+/*
+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.
+*/
+
+/**
+ * @typedef {{ datastreamId: string, [k: string]: Object }} Override
+ * @typedef {Object} RequestPayload
+ * @property {function(Override): void} mergeConfigOverride
+ * @param {Object} params
+ * @param {Override} params.localConfigOverrides
+ * @param {Override} params.globalConfigOverrides
+ * @param {RequestPayload} params.payload
+ * @returns {{ payload: RequestPayload, datastreamIdOverride: string }}
+ */
+export default (({
+  localConfigOverrides,
+  globalConfigOverrides,
+  payload
+}) => {
+  const requestParams = {
+    payload
+  };
+  const {
+    datastreamId,
+    ...localConfigOverridesWithoutDatastreamId
+  } = localConfigOverrides || {};
+
+  if (datastreamId) {
+    requestParams.datastreamIdOverride = datastreamId;
+  }
+
+  payload.mergeConfigOverride(globalConfigOverrides);
+  payload.mergeConfigOverride(localConfigOverridesWithoutDatastreamId);
+  return requestParams;
+});

package/libEs6/utils/request/index.js

@@ -14,5 +14,6 @@ export { default as createDataCollectionRequest } from "./createDataCollectionRe
 export { default as createDataCollectionRequestPayload } from "./createDataCollectionRequestPayload";
 export { default as createHasIdentity } from "./createHasIdentity";
 export { default as createRequest } from "./createRequest";
+export { default as createRequestParams } from "./createRequestParams";
 export { default as createRequestPayload } from "./createRequestPayload";
 export { default as createGetAssuranceValidationTokenParams } from "./createGetAssuranceValidationTokenParams";

package/libEs6/utils/validation/booleanValidator.js

@@ -10,7 +10,7 @@ OF ANY KIND, either express or implied. See the License for the specific languag
 governing permissions and limitations under the License.
 */
 import isBoolean from "../isBoolean";
-import assertValid from "./assertValid";
+import { assertValid } from "./utils";
 export default ((value, path) => {
   assertValid(isBoolean(value), value, path, "true or false");
   return value;

package/libEs6/utils/validation/callbackValidator.js

@@ -10,7 +10,7 @@ OF ANY KIND, either express or implied. See the License for the specific languag
 governing permissions and limitations under the License.
 */
 import isFunction from "../isFunction";
-import assertValid from "./assertValid";
+import { assertValid } from "./utils";
 export default ((value, path) => {
   assertValid(isFunction(value), value, path, "a function");
   return value;

package/libEs6/utils/validation/createAnyOfValidator.js

@@ -9,17 +9,18 @@ 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 assertValid from "./assertValid";
+import { assertValid } from "./utils";
 import find from "../find";
-export default ((validators, message) => (value, path) => {
+export default ((validators, message) => function anyOf(value, path) {
+  let newValue;
   const valid = find(validators, validator => {
     try {
-      validator(value, path);
+      newValue = validator.call(this, value, path);
       return true;
     } catch (e) {
       return false;
     }
   });
   assertValid(valid, value, path, message);
-  return value;
+  return newValue;
 });

package/libEs6/utils/validation/createArrayOfValidator.js

@@ -9,13 +9,13 @@ 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 assertValid from "./assertValid";
-export default (elementValidator => (value, path) => {
+import { assertValid } from "./utils";
+export default (elementValidator => function arrayOf(value, path) {
   assertValid(Array.isArray(value), value, path, "an array");
   const errors = [];
   const validatedArray = value.map((subValue, i) => {
     try {
-      return elementValidator(subValue, `${path}[${i}]`);
+      return elementValidator.call(this, subValue, `${path}[${i}]`, value);
     } catch (e) {
       errors.push(e.message);
       return undefined;

package/libEs6/utils/validation/createDeprecatedValidator.js

@@ -0,0 +1,41 @@
+/*
+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.
+*/
+import isObject from "../isObject";
+import { assertValid } from "./utils";
+export default ((oldField, oldSchema, newField) => function deprecated(value, path) {
+  assertValid(isObject(value), value, path, "an object");
+  const {
+    [oldField]: oldValue,
+    [newField]: newValue,
+    ...otherValues
+  } = value;
+  const validatedOldValue = oldSchema(oldValue, path);
+
+  if (validatedOldValue !== undefined) {
+    let message = `The field '${oldField}' is deprecated. Use '${newField}' instead.`;
+
+    if (path) {
+      message = `'${path}': ${message}`;
+    }
+
+    if (newValue !== undefined && newValue !== validatedOldValue) {
+      throw new Error(message);
+    } else if (this && this.logger) {
+      this.logger.warn(message);
+    }
+  }
+
+  return {
+    [newField]: newValue || validatedOldValue,
+    ...otherValues
+  };
+});

package/libEs6/utils/validation/createLiteralValidator.js

@@ -9,7 +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 assertValid from "./assertValid";
+import { assertValid } from "./utils";
 export default (literalValue => (value, path) => {
   assertValid(value === literalValue, value, path, `${literalValue}`);
   return value;

package/libEs6/utils/validation/createMapOfValuesValidator.js

@@ -10,8 +10,8 @@ OF ANY KIND, either express or implied. See the License for the specific languag
 governing permissions and limitations under the License.
 */
 import isObject from "../isObject";
-import assertValid from "./assertValid";
-export default (valueValidator => (value, path) => {
+import { assertValid } from "./utils";
+export default (valueValidator => function mapOfValues(value, path) {
   assertValid(isObject(value), value, path, "an object");
   const errors = [];
   const validatedObject = {};
@@ -20,7 +20,7 @@ export default (valueValidator => (value, path) => {
     const subPath = path ? `${path}.${subKey}` : subKey;
 
     try {
-      const validatedValue = valueValidator(subValue, subPath);
+      const validatedValue = valueValidator.call(this, subValue, subPath);
 
       if (validatedValue !== undefined) {
         validatedObject[subKey] = validatedValue;

package/libEs6/utils/validation/createMinimumValidator.js

@@ -9,7 +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 assertValid from "./assertValid";
+import { assertValid } from "./utils";
 export default ((typeName, minimum) => (value, path) => {
   assertValid(value >= minimum, value, path, `${typeName} greater than or equal to ${minimum}`);
   return value;

package/libEs6/utils/validation/createNonEmptyValidator.js

@@ -9,7 +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 assertValid from "./assertValid";
+import { assertValid } from "./utils";
 import isObject from "../isObject";
 import isEmptyObject from "../isEmptyObject";
 export default (message => (value, path) => {

package/libEs6/utils/validation/createObjectOfValidator.js

@@ -10,8 +10,8 @@ OF ANY KIND, either express or implied. See the License for the specific languag
 governing permissions and limitations under the License.
 */
 import isObject from "../isObject";
-import assertValid from "./assertValid";
-export default (schema => (value, path) => {
+import { assertValid } from "./utils";
+export default (schema => function objectOf(value, path) {
   assertValid(isObject(value), value, path, "an object");
   const errors = [];
   const validatedObject = {};
@@ -21,7 +21,7 @@ export default (schema => (value, path) => {
     const subPath = path ? `${path}.${subKey}` : subKey;
 
     try {
-      const validatedValue = subSchema(subValue, subPath);
+      const validatedValue = subSchema.call(this, subValue, subPath);
 
       if (validatedValue !== undefined) {
         validatedObject[subKey] = validatedValue;

package/libEs6/utils/validation/createUniqueItemsValidator.js

@@ -9,7 +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 assertValid from "./assertValid";
+import { assertValid } from "./utils";
 import isUnique from "../isUnique";
 export default (() => {
   return (value, path) => {

package/libEs6/utils/validation/createUniqueValidator.js

@@ -9,7 +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 assertValid from "./assertValid";
+import { assertValid } from "./utils";
 export default (() => {
   const values = [];
   return (value, path) => {

package/libEs6/utils/validation/domainValidator.js

@@ -9,7 +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 assertValid from "./assertValid";
+import { assertValid } from "./utils";
 const DOMAIN_REGEX = /^[a-z0-9.-]{1,}$/i;
 export default ((value, path) => {
   assertValid(DOMAIN_REGEX.test(value), value, path, "a valid domain");

package/libEs6/utils/validation/index.js

@@ -9,13 +9,70 @@ 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.
 */
-// See comments on chain and nullSafeChain to understand what is going on here.
-import chain from "./chain";
-import nullSafeChain from "./nullSafeChain";
+
+/**
+ * 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.
+ */
+import { chain, nullSafeChain, reverseNullSafeChainJoinErrors } from "./utils";
 import booleanValidator from "./booleanValidator";
 import callbackValidator from "./callbackValidator";
 import createArrayOfValidator from "./createArrayOfValidator";
 import createDefaultValidator from "./createDefaultValidator";
+import createDeprecatedValidator from "./createDeprecatedValidator";
 import createLiteralValidator from "./createLiteralValidator";
 import createMapOfValuesValidator from "./createMapOfValuesValidator";
 import createMinimumValidator from "./createMinimumValidator";
@@ -32,8 +89,9 @@ import regexpValidator from "./regexpValidator";
 import requiredValidator from "./requiredValidator";
 import stringValidator from "./stringValidator"; // The base validator does no validation and just returns the value unchanged
 
-const base = value => value; // The 'default' and 'required' methods are available after any data-type method
-// Don't use the nullSafeChain because they need to handle the null or undefined case
+const base = value => 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) {
@@ -95,7 +153,7 @@ const anyOf = function anyOf(validators, message) {
 };
 
 const anything = function anything() {
-  return nullSafeChain(this, base);
+  return this;
 };
 
 const arrayOf = function arrayOf(elementValidator) {
@@ -131,15 +189,28 @@ const mapOfValues = function mapOfValues(valuesValidator) {
   });
 };
 
-const objectOf = function objectOf(schema) {
-  const noUnknownFields = function noUnknownFields() {
+const createObjectOfAdditionalProperties = schema => ({
+  noUnknownFields: function noUnknownFields() {
     return nullSafeChain(this, createNoUnknownFieldsValidator(schema));
-  };
+  },
+  nonEmpty: nonEmptyObject,
+  concat: function concat(otherObjectOfValidator) {
+    // combine the schema so that noUnknownFields, and concat have the combined schema
+    const newSchema = { ...schema,
+      ...otherObjectOfValidator.schema
+    };
+    return 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 reverseNullSafeChainJoinErrors(this, createDeprecatedValidator(oldField, oldSchema, newField));
+  },
+  schema
+});
 
-  return nullSafeChain(this, createObjectOfValidator(schema), {
-    noUnknownFields,
-    nonEmpty: nonEmptyObject
-  });
+const objectOf = function objectOf(schema) {
+  return nullSafeChain(this, createObjectOfValidator(schema), createObjectOfAdditionalProperties(schema));
 };
 
 const string = function string() {

package/libEs6/utils/validation/integerValidator.js

@@ -10,7 +10,7 @@ OF ANY KIND, either express or implied. See the License for the specific languag
 governing permissions and limitations under the License.
 */
 import isInteger from "../isInteger";
-import assertValid from "./assertValid";
+import { assertValid } from "./utils";
 export default ((value, path) => {
   assertValid(isInteger(value), value, path, "an integer");
   return value;

package/libEs6/utils/validation/numberValidator.js

@@ -10,7 +10,7 @@ OF ANY KIND, either express or implied. See the License for the specific languag
 governing permissions and limitations under the License.
 */
 import isNumber from "../isNumber";
-import assertValid from "./assertValid";
+import { assertValid } from "./utils";
 export default ((value, path) => {
   assertValid(isNumber(value), value, path, "a number");
   return value;

package/libEs6/utils/validation/regexpValidator.js

@@ -9,7 +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 assertValid from "./assertValid";
+import { assertValid } from "./utils";
 import isValidRegExp from "../isValidRegExp";
 export default ((value, path) => {
   assertValid(isValidRegExp(value), value, path, "a regular expression");

package/libEs6/utils/validation/stringValidator.js

@@ -10,7 +10,7 @@ OF ANY KIND, either express or implied. See the License for the specific languag
 governing permissions and limitations under the License.
 */
 import isString from "../isString";
-import assertValid from "./assertValid";
+import { assertValid } from "./utils";
 export default ((value, path) => {
   assertValid(isString(value), value, path, "a string");
   return value;

package/libEs6/utils/validation/utils.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adobe/alloy",
-  "version": "2.17.0-beta.0",
+  "version": "2.18.0-beta.0",
   "description": "Adobe Experience Platform Web SDK",
   "main": "libEs5/index.js",
   "module": "libEs6/index.js",
@@ -18,6 +18,7 @@
     "test:unit:saucelabs:local": "karma start karma.saucelabs.conf.js --single-run",
     "test:unit:coverage": "karma start --single-run --reporters spec,coverage",
     "test:functional": "EDGE_BASE_PATH=\"ee-pre-prd\" ALLOY_ENV=\"int\" testcafe chrome",
+    "test:functional:saucelabs:dev": "NPM_PACKAGE_VERSION=\"2.17.0\" EDGE_BASE_PATH=\"ee-pre-prd\" ALLOY_ENV=\"int\" saucectl run --config ./.sauce/dev.yml",
     "test:functional:watch": "EDGE_BASE_PATH=\"ee-pre-prd\" ALLOY_ENV=\"int\" ./scripts/watchFunctionalTests.js --browsers chrome",
     "test:functional:debug": "EDGE_BASE_PATH=\"ee-pre-prd\" ALLOY_ENV=\"int\" testcafe --inspect-brk chrome",
     "test:functional:build:int": "rollup -c --environment BASE_CODE_MIN,STANDALONE,NPM_PACKAGE_LOCAL",
@@ -65,7 +66,7 @@
     "uuid": "^3.3.2"
   },
   "devDependencies": {
-    "@adobe/alloy": "^2.16.0",
+    "@adobe/alloy": "^2.17.0",
     "@babel/cli": "^7.12.8",
     "@babel/core": "^7.2.2",
     "@babel/plugin-proposal-object-rest-spread": "^7.3.2",
@@ -121,9 +122,10 @@
     "semver": "^7.3.7",
     "staged-git-files": "^1.3.0",
     "start-server-and-test": "^1.10.6",
-    "testcafe": "^2.3.1",
-    "testcafe-browser-provider-saucelabs": "^1.9.0",
+    "testcafe": "^2.6.2",
+    "testcafe-browser-provider-saucelabs": "^2.0.0",
     "testcafe-reporter-junit": "^3.0.2",
+    "testcafe-reporter-saucelabs": "^1.0.1",
     "url-exists-nodejs": "^0.1.0",
     "url-parse": "^1.4.7",
     "yargs": "^16.2.0"

package/libEs5/utils/validation/assertValid.js

@@ -1,22 +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(isValid, value, path, message) {
-  if (!isValid) {
-    throw new Error("'" + path + "': Expected " + message + ", but got " + JSON.stringify(value) + ".");
-  }
-};
-
-exports.default = _default;