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

package/libEs6/utils/request/createRequestParams.js

@@ -9,7 +9,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.
 */
-
 /**
  * @typedef {{ datastreamId: string, [k: string]: Object }} Override
  * @typedef {Object} RequestPayload
@@ -32,11 +31,9 @@ export default (({
     datastreamId,
     ...localConfigOverridesWithoutDatastreamId
   } = localConfigOverrides || {};
-
   if (datastreamId) {
     requestParams.datastreamIdOverride = datastreamId;
   }
-
   payload.mergeConfigOverride(globalConfigOverrides);
   payload.mergeConfigOverride(localConfigOverridesWithoutDatastreamId);
   return requestParams;

package/libEs6/utils/request/createRequestPayload.js

@@ -9,9 +9,11 @@ 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 { createMerger, prepareConfigOverridesForEdge } from ".."; // This provides the base functionality that all types of
-// request payloads share.
 
+import { createMerger, prepareConfigOverridesForEdge } from "..";
+
+// This provides the base functionality that all types of
+// request payloads share.
 export default (options => {
   const {
     content,
@@ -26,10 +28,8 @@ export default (options => {
     mergeConfigOverride: updates => mergeConfigOverride(prepareConfigOverridesForEdge(updates)),
     addIdentity,
     hasIdentity,
-
     toJSON() {
       return content;
     }
-
   };
 });

package/libEs6/utils/request/index.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.
 */
+
 export { default as createAddIdentity } from "./createAddIdentity";
 export { default as createDataCollectionRequest } from "./createDataCollectionRequest";
 export { default as createDataCollectionRequestPayload } from "./createDataCollectionRequestPayload";

package/libEs6/utils/sanitizeOrgIdForCookieName.js

@@ -9,4 +9,5 @@ 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.
 */
+
 export default (orgId => orgId.replace("@", "_"));

package/libEs6/utils/stackError.js

@@ -9,8 +9,10 @@ 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 toError from "./toError";
 import updateErrorMessage from "./updateErrorMessage";
+
 /**
  * Augments an error's message with additional context as it bubbles up the call stack.
  * @param {String} message The message to be added to the error.
@@ -18,7 +20,6 @@ import updateErrorMessage from "./updateErrorMessage";
  * this is used as the basis for the message of a newly created Error instance.
  * @returns {*}
  */
-
 export default (({
   error,
   message

package/libEs6/utils/toArray.js

@@ -9,14 +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.
 */
+
 export default (value => {
   if (Array.isArray(value)) {
     return value;
   }
-
   if (value == null) {
     return [];
   }
-
   return [].slice.call(value);
 });

package/libEs6/utils/toISOStringLocal.js

@@ -11,12 +11,12 @@ governing permissions and limitations under the License.
 */
 import padStart from "./padStart";
 import toInteger from "./toInteger";
+
 /**
  * Formats the date into an ISO date-time string in the local timezone
  * @param {Date} date
  * @returns {string}
  */
-
 export default (date => {
   const YYYY = date.getFullYear();
   const MM = padStart(date.getMonth() + 1, 2, "0");
@@ -24,10 +24,11 @@ export default (date => {
   const hh = padStart(date.getHours(), 2, "0");
   const mm = padStart(date.getMinutes(), 2, "0");
   const ss = padStart(date.getSeconds(), 2, "0");
-  const mmm = padStart(date.getMilliseconds(), 3, "0"); // The time-zone offset is the difference, in minutes, from local time to UTC. Note that this
+  const mmm = padStart(date.getMilliseconds(), 3, "0");
+
+  // The time-zone offset is the difference, in minutes, from local time to UTC. Note that this
   // means that the offset is positive if the local timezone is behind UTC and negative if it is
   // ahead. For example, for time zone UTC+10:00, -600 will be returned.
-
   const timezoneOffset = toInteger(date.getTimezoneOffset(), 0);
   const ts = timezoneOffset > 0 ? "-" : "+";
   const th = padStart(Math.floor(Math.abs(timezoneOffset) / 60), 2, "0");

package/libEs6/utils/toInteger.js

@@ -9,22 +9,22 @@ 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 isNumber from "./isNumber";
 import isString from "./isString";
+
 /*
  * coerce `value` to a number or return `defaultValue` if it cannot be.
  *
  * The coersion is attempted if value is a number or string.
  */
-
 export default ((value, defaultValue) => {
   if (isNumber(value) || isString(value)) {
-    const n = Math.round(Number(value)); // eslint-disable-next-line no-restricted-globals
-
+    const n = Math.round(Number(value));
+    // eslint-disable-next-line no-restricted-globals
     if (!isNaN(n)) {
       return n;
     }
   }
-
   return defaultValue;
 });

package/libEs6/utils/updateErrorMessage.js

@@ -9,13 +9,15 @@ 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.
 */
+
 export default (({
   error,
   message
 }) => {
   try {
     error.message = message;
-  } catch (e) {// We'll set a new message when we can, but some errors, like DOMException,
+  } catch (e) {
+    // We'll set a new message when we can, but some errors, like DOMException,
     // have a read-only message property, which limits our options.
   }
 });

package/libEs6/utils/uuid.js

@@ -9,5 +9,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.
 */
+
 import uuid from "uuid/v4";
 export default uuid;

package/libEs6/utils/validateConfigOverride.js

@@ -9,5 +9,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.
 */
+
 import { objectOf } from "./validation";
 export default objectOf({});

package/libEs6/utils/validateIdentityMap.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 { string, objectOf, boolean, arrayOf, enumOf, mapOfValues } from "./validation/index";
 import { AMBIGUOUS, AUTHENTICATED, LOGGED_OUT } from "../constants/identityMapAuthenticatedState";
 export default mapOfValues(arrayOf(objectOf({

package/libEs6/utils/validation/booleanValidator.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 isBoolean from "../isBoolean";
 import { assertValid } from "./utils";
 export default ((value, path) => {

package/libEs6/utils/validation/createArrayOfValidator.js

@@ -21,10 +21,8 @@ export default (elementValidator => function arrayOf(value, path) {
       return undefined;
     }
   });
-
   if (errors.length) {
     throw new Error(errors.join("\n"));
   }
-
   return validatedArray;
 });

package/libEs6/utils/validation/createDefaultValidator.js

@@ -9,10 +9,10 @@ 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.
 */
+
 export default (defaultValue => value => {
   if (value == null) {
     return defaultValue;
   }
-
   return value;
 });

package/libEs6/utils/validation/createDeprecatedValidator.js

@@ -19,21 +19,17 @@ export default ((oldField, oldSchema, newField) => function deprecated(value, pa
     ...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/createMapOfValuesValidator.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 isObject from "../isObject";
 import { assertValid } from "./utils";
 export default (valueValidator => function mapOfValues(value, path) {
@@ -18,10 +19,8 @@ export default (valueValidator => function mapOfValues(value, path) {
   Object.keys(value).forEach(subKey => {
     const subValue = value[subKey];
     const subPath = path ? `${path}.${subKey}` : subKey;
-
     try {
       const validatedValue = valueValidator.call(this, subValue, subPath);
-
       if (validatedValue !== undefined) {
         validatedObject[subKey] = validatedValue;
       }
@@ -29,10 +28,8 @@ export default (valueValidator => function mapOfValues(value, path) {
       errors.push(e.message);
     }
   });
-
   if (errors.length) {
     throw new Error(errors.join("\n"));
   }
-
   return validatedObject;
 });

package/libEs6/utils/validation/createNoUnknownFieldsValidator.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.
 */
+
 export default (schema => (value, path) => {
   const errors = [];
   Object.keys(value).forEach(subKey => {
@@ -17,10 +18,8 @@ export default (schema => (value, path) => {
       errors.push(`'${subPath}': Unknown field.`);
     }
   });
-
   if (errors.length) {
     throw new Error(errors.join("\n"));
   }
-
   return value;
 });

package/libEs6/utils/validation/createNonEmptyValidator.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 { assertValid } from "./utils";
 import isObject from "../isObject";
 import isEmptyObject from "../isEmptyObject";
@@ -18,6 +19,5 @@ export default (message => (value, path) => {
   } else {
     assertValid(value.length > 0, value, path, message);
   }
-
   return value;
 });

package/libEs6/utils/validation/createObjectOfValidator.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 isObject from "../isObject";
 import { assertValid } from "./utils";
 export default (schema => function objectOf(value, path) {
@@ -19,27 +20,24 @@ export default (schema => function objectOf(value, path) {
     const subValue = value[subKey];
     const subSchema = schema[subKey];
     const subPath = path ? `${path}.${subKey}` : subKey;
-
     try {
       const validatedValue = subSchema.call(this, subValue, subPath);
-
       if (validatedValue !== undefined) {
         validatedObject[subKey] = validatedValue;
       }
     } catch (e) {
       errors.push(e.message);
     }
-  }); // copy over unknown properties
+  });
 
+  // copy over unknown properties
   Object.keys(value).forEach(subKey => {
     if (!Object.prototype.hasOwnProperty.call(validatedObject, subKey)) {
       validatedObject[subKey] = value[subKey];
     }
   });
-
   if (errors.length) {
     throw new Error(errors.join("\n"));
   }
-
   return validatedObject;
 });

package/libEs6/utils/validation/createUniqueValidator.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 { assertValid } from "./utils";
 export default (() => {
   const values = [];

package/libEs6/utils/validation/index.js

@@ -67,6 +67,7 @@ governing permissions and limitations under the License.
  * 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";
@@ -87,94 +88,79 @@ import integerValidator from "./integerValidator";
 import numberValidator from "./numberValidator";
 import regexpValidator from "./regexpValidator";
 import requiredValidator from "./requiredValidator";
-import stringValidator from "./stringValidator"; // The base validator does no validation and just returns the value unchanged
+import stringValidator from "./stringValidator";
+
+// The base validator does no validation and just returns the value unchanged
+const base = value => value;
 
-const base = value => 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 chain(this, createDefaultValidator(defaultValue));
 };
-
 base.required = function required() {
   return chain(this, requiredValidator);
-}; // helper validators
-
+};
 
+// helper validators
 const domain = function domain() {
   return nullSafeChain(this, domainValidator);
 };
-
 const minimumInteger = function minimumInteger(minValue) {
   return nullSafeChain(this, createMinimumValidator("an integer", minValue));
 };
-
 const minimumNumber = function minimumNumber(minValue) {
   return nullSafeChain(this, createMinimumValidator("a number", minValue));
 };
-
 const integer = function integer() {
   return nullSafeChain(this, integerValidator, {
     minimum: minimumInteger
   });
 };
-
 const nonEmptyString = function nonEmptyString() {
   return nullSafeChain(this, createNonEmptyValidator("a non-empty string"));
 };
-
 const nonEmptyArray = function nonEmptyArray() {
   return nullSafeChain(this, createNonEmptyValidator("a non-empty array"));
 };
-
 const nonEmptyObject = function nonEmptyObject() {
   return nullSafeChain(this, createNonEmptyValidator("a non-empty object"));
 };
-
 const regexp = function regexp() {
   return nullSafeChain(this, regexpValidator);
 };
-
 const unique = function createUnique() {
   return nullSafeChain(this, createUniqueValidator());
 };
-
 const uniqueItems = function createUniqueItems() {
   return nullSafeChain(this, createUniqueItemsValidator());
-}; // 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.
 const 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 chain(this, createAnyOfValidator(validators, message));
 };
-
 const anything = function anything() {
   return this;
 };
-
 const arrayOf = function arrayOf(elementValidator) {
   return nullSafeChain(this, createArrayOfValidator(elementValidator), {
     nonEmpty: nonEmptyArray,
     uniqueItems
   });
 };
-
 const boolean = function boolean() {
   return nullSafeChain(this, booleanValidator);
 };
-
 const callback = function callback() {
   return nullSafeChain(this, callbackValidator);
 };
-
 const literal = function literal(literalValue) {
   return nullSafeChain(this, createLiteralValidator(literalValue));
 };
-
 const number = function number() {
   return nullSafeChain(this, numberValidator, {
     minimum: minimumNumber,
@@ -182,13 +168,11 @@ const number = function number() {
     unique
   });
 };
-
 const mapOfValues = function mapOfValues(valuesValidator) {
   return nullSafeChain(this, createMapOfValuesValidator(valuesValidator), {
     nonEmpty: nonEmptyObject
   });
 };
-
 const createObjectOfAdditionalProperties = schema => ({
   noUnknownFields: function noUnknownFields() {
     return nullSafeChain(this, createNoUnknownFieldsValidator(schema));
@@ -196,7 +180,8 @@ const createObjectOfAdditionalProperties = schema => ({
   nonEmpty: nonEmptyObject,
   concat: function concat(otherObjectOfValidator) {
     // combine the schema so that noUnknownFields, and concat have the combined schema
-    const newSchema = { ...schema,
+    const newSchema = {
+      ...schema,
       ...otherObjectOfValidator.schema
     };
     return nullSafeChain(this, otherObjectOfValidator, createObjectOfAdditionalProperties(newSchema));
@@ -208,11 +193,9 @@ const createObjectOfAdditionalProperties = schema => ({
   },
   schema
 });
-
 const objectOf = function objectOf(schema) {
   return nullSafeChain(this, createObjectOfValidator(schema), createObjectOfAdditionalProperties(schema));
 };
-
 const string = function string() {
   return nullSafeChain(this, stringValidator, {
     regexp,
@@ -221,7 +204,6 @@ const string = function string() {
     unique
   });
 };
-
 const boundAnyOf = anyOf.bind(base);
 const boundAnything = anything.bind(base);
 const boundArrayOf = arrayOf.bind(base);
@@ -231,10 +213,10 @@ const boundLiteral = literal.bind(base);
 const boundNumber = number.bind(base);
 const boundMapOfValues = mapOfValues.bind(base);
 const boundObjectOf = objectOf.bind(base);
-const boundString = string.bind(base); // compound validators
+const boundString = string.bind(base);
 
+// compound validators
 const boundEnumOf = function boundEnumOf(...values) {
   return boundAnyOf(values.map(boundLiteral), `one of these values: [${JSON.stringify(values)}]`);
 };
-
 export { boundAnyOf as anyOf, boundAnything as anything, boundArrayOf as arrayOf, boundBoolean as boolean, boundCallback as callback, boundLiteral as literal, boundNumber as number, boundMapOfValues as mapOfValues, boundObjectOf as objectOf, boundString as string, boundEnumOf as enumOf };

package/libEs6/utils/validation/integerValidator.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 isInteger from "../isInteger";
 import { assertValid } from "./utils";
 export default ((value, path) => {

package/libEs6/utils/validation/numberValidator.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 isNumber from "../isNumber";
 import { assertValid } from "./utils";
 export default ((value, path) => {

package/libEs6/utils/validation/regexpValidator.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 { assertValid } from "./utils";
 import isValidRegExp from "../isValidRegExp";
 export default ((value, path) => {

package/libEs6/utils/validation/requiredValidator.js

@@ -9,10 +9,10 @@ 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.
 */
+
 export default ((value, path) => {
   if (value == null) {
     throw new Error(`'${path}' is a required option`);
   }
-
   return value;
 });