@justifi/webcomponents 4.7.4 → 4.7.6

package/dist/cjs/{index.esm-91ec051e.js → index.esm-c08c2adc.js}

@@ -332,7 +332,9 @@ function toArray(value) {
   return value == null ? [] : [].concat(value);
 }
 
+let _Symbol$toStringTag;
 let strReg = /\$\{\s*(\w+)\s*\}/g;
+_Symbol$toStringTag = Symbol.toStringTag;
 class ValidationError extends Error {
   static formatError(message, params) {
     const path = params.label || params.path || 'this';
@@ -346,7 +348,7 @@ class ValidationError extends Error {
   static isError(err) {
     return err && err.name === 'ValidationError';
   }
-  constructor(errorOrErrors, value, field, type) {
+  constructor(errorOrErrors, value, field, type, disableStack) {
     super();
     this.value = void 0;
     this.path = void 0;
@@ -354,6 +356,7 @@ class ValidationError extends Error {
     this.errors = void 0;
     this.params = void 0;
     this.inner = void 0;
+    this[_Symbol$toStringTag] = 'Error';
     this.name = 'ValidationError';
     this.value = value;
     this.path = field;
@@ -363,13 +366,14 @@ class ValidationError extends Error {
     toArray(errorOrErrors).forEach(err => {
       if (ValidationError.isError(err)) {
         this.errors.push(...err.errors);
-        this.inner = this.inner.concat(err.inner.length ? err.inner : err);
+        const innerErrors = err.inner.length ? err.inner : [err];
+        this.inner.push(...innerErrors);
       } else {
         this.errors.push(err);
       }
     });
     this.message = this.errors.length > 1 ? `${this.errors.length} errors occurred` : this.errors[0];
-    if (Error.captureStackTrace) Error.captureStackTrace(this, ValidationError);
+    if (!disableStack && Error.captureStackTrace) Error.captureStackTrace(this, ValidationError);
   }
 }
 
@@ -426,6 +430,21 @@ let array = {
   max: '${path} field must have less than or equal to ${max} items',
   length: '${path} must have ${length} items'
 };
+let tuple = {
+  notType: params => {
+    const {
+      path,
+      value,
+      spec
+    } = params;
+    const typeLen = spec.types.length;
+    if (Array.isArray(value)) {
+      if (value.length < typeLen) return `${path} tuple value has too few items, expected a length of ${typeLen} but got ${value.length} for value: \`${printValue(value, true)}\``;
+      if (value.length > typeLen) return `${path} tuple value has too many items, expected a length of ${typeLen} but got ${value.length} for value: \`${printValue(value, true)}\``;
+    }
+    return ValidationError.formatError(mixed.notType, params);
+  }
+};
 Object.assign(Object.create(null), {
   mixed,
   string,
@@ -433,7 +452,8 @@ Object.assign(Object.create(null), {
   date,
   object,
   array,
-  boolean
+  boolean,
+  tuple
 });
 
 const isSchema = obj => obj && obj.__isYupSchema__;
@@ -555,12 +575,14 @@ function createValidation(config) {
     let {
       parent,
       context,
-      abortEarly = schema.spec.abortEarly
+      abortEarly = schema.spec.abortEarly,
+      disableStackTrace = schema.spec.disableStackTrace
     } = options;
     function resolve(item) {
       return Reference.isRef(item) ? item.getValue(value, parent, context) : item;
     }
     function createError(overrides = {}) {
+      var _overrides$disableSta;
       const nextParams = Object.assign({
         value,
         originalValue,
@@ -569,7 +591,7 @@ function createValidation(config) {
         spec: schema.spec
       }, params, overrides.params);
       for (const key of Object.keys(nextParams)) nextParams[key] = resolve(nextParams[key]);
-      const error = new ValidationError(ValidationError.formatError(overrides.message || message, nextParams), value, nextParams.path, overrides.type || name);
+      const error = new ValidationError(ValidationError.formatError(overrides.message || message, nextParams), value, nextParams.path, overrides.type || name, (_overrides$disableSta = overrides.disableStackTrace) != null ? _overrides$disableSta : disableStackTrace);
       error.params = nextParams;
       return error;
     }
@@ -592,20 +614,18 @@ function createValidation(config) {
       if (ValidationError.isError(err)) invalid(err);else panic(err);
     };
     const shouldSkip = skipAbsent && isAbsent(value);
-    if (!options.sync) {
-      try {
-        Promise.resolve(!shouldSkip ? test.call(ctx, value, ctx) : true).then(handleResult, handleError);
-      } catch (err) {
-        handleError(err);
-      }
-      return;
+    if (shouldSkip) {
+      return handleResult(true);
     }
     let result;
     try {
       var _result;
-      result = !shouldSkip ? test.call(ctx, value, ctx) : true;
+      result = test.call(ctx, value, ctx);
       if (typeof ((_result = result) == null ? void 0 : _result.then) === 'function') {
-        throw new Error(`Validation test of type: "${ctx.type}" returned a Promise during a synchronous validate. ` + `This test will finish after the validate call has returned`);
+        if (options.sync) {
+          throw new Error(`Validation test of type: "${ctx.type}" returned a Promise during a synchronous validate. ` + `This test will finish after the validate call has returned`);
+        }
+        return Promise.resolve(result).then(handleResult, handleError);
       }
     } catch (err) {
       handleError(err);
@@ -730,6 +750,8 @@ function clone(src, seen = new Map()) {
   return copy;
 }
 
+// If `CustomSchemaMeta` isn't extended with any keys, we'll fall back to a
+// loose Record definition allowing free form usage.
 class Schema {
   constructor(options) {
     this.type = void 0;
@@ -756,6 +778,7 @@ class Schema {
       strict: false,
       abortEarly: true,
       recursive: true,
+      disableStackTrace: false,
       nullable: false,
       optional: true,
       coerce: true
@@ -861,12 +884,13 @@ class Schema {
     return schema;
   }
   resolveOptions(options) {
-    var _options$strict, _options$abortEarly, _options$recursive;
+    var _options$strict, _options$abortEarly, _options$recursive, _options$disableStack;
     return Object.assign({}, options, {
       from: options.from || [],
       strict: (_options$strict = options.strict) != null ? _options$strict : this.spec.strict,
       abortEarly: (_options$abortEarly = options.abortEarly) != null ? _options$abortEarly : this.spec.abortEarly,
-      recursive: (_options$recursive = options.recursive) != null ? _options$recursive : this.spec.recursive
+      recursive: (_options$recursive = options.recursive) != null ? _options$recursive : this.spec.recursive,
+      disableStackTrace: (_options$disableStack = options.disableStackTrace) != null ? _options$disableStack : this.spec.disableStackTrace
     });
   }
 
@@ -971,7 +995,7 @@ class Schema {
       const test = tests[i];
       test(args, panicOnce, function finishTestRun(err) {
         if (err) {
-          nestedErrors = nestedErrors.concat(err);
+          Array.isArray(err) ? nestedErrors.push(...err) : nestedErrors.push(err);
         }
         if (--count <= 0) {
           nextOnce(nestedErrors);
@@ -1011,28 +1035,32 @@ class Schema {
     return (_, panic, next) => this.resolve(testOptions)._validate(value, testOptions, panic, next);
   }
   validate(value, options) {
+    var _options$disableStack2;
     let schema = this.resolve(Object.assign({}, options, {
       value
     }));
+    let disableStackTrace = (_options$disableStack2 = options == null ? void 0 : options.disableStackTrace) != null ? _options$disableStack2 : schema.spec.disableStackTrace;
     return new Promise((resolve, reject) => schema._validate(value, options, (error, parsed) => {
       if (ValidationError.isError(error)) error.value = parsed;
       reject(error);
     }, (errors, validated) => {
-      if (errors.length) reject(new ValidationError(errors, validated));else resolve(validated);
+      if (errors.length) reject(new ValidationError(errors, validated, undefined, undefined, disableStackTrace));else resolve(validated);
     }));
   }
   validateSync(value, options) {
+    var _options$disableStack3;
     let schema = this.resolve(Object.assign({}, options, {
       value
     }));
     let result;
+    let disableStackTrace = (_options$disableStack3 = options == null ? void 0 : options.disableStackTrace) != null ? _options$disableStack3 : schema.spec.disableStackTrace;
     schema._validate(value, Object.assign({}, options, {
       sync: true
     }), (error, parsed) => {
       if (ValidationError.isError(error)) error.value = parsed;
       throw error;
     }, (errors, validated) => {
-      if (errors.length) throw new ValidationError(errors, value);
+      if (errors.length) throw new ValidationError(errors, value, undefined, undefined, disableStackTrace);
       result = validated;
     });
     return result;
@@ -1963,14 +1991,15 @@ class ObjectSchema extends Schema {
     for (const key of keys) {
       if (this.fields[key]) picked[key] = this.fields[key];
     }
-    return this.setFields(picked);
+    return this.setFields(picked, this._excludedEdges.filter(([a, b]) => keys.includes(a) && keys.includes(b)));
   }
   omit(keys) {
-    const fields = Object.assign({}, this.fields);
-    for (const key of keys) {
-      delete fields[key];
+    const remaining = [];
+    for (const key of Object.keys(this.fields)) {
+      if (keys.includes(key)) continue;
+      remaining.push(key);
     }
-    return this.setFields(fields);
+    return this.pick(remaining);
   }
   from(from, to, alias) {
     let fromGetter = propertyExpr.getter(from, true);
@@ -2033,9 +2062,10 @@ class ObjectSchema extends Schema {
     return this.transformKeys(key => tinyCase.snakeCase(key).toUpperCase());
   }
   describe(options) {
-    let base = super.describe(options);
+    const next = (options ? this.resolve(options) : this).clone();
+    const base = super.describe(options);
     base.fields = {};
-    for (const [key, value] of Object.entries(this.fields)) {
+    for (const [key, value] of Object.entries(next.fields)) {
       var _innerOptions2;
       let innerOptions = options;
       if ((_innerOptions2 = innerOptions) != null && _innerOptions2.value) {
@@ -2215,8 +2245,9 @@ class ArraySchema extends Schema {
     return this.transform(values => values != null ? values.filter(reject) : values);
   }
   describe(options) {
-    let base = super.describe(options);
-    if (this.innerType) {
+    const next = (options ? this.resolve(options) : this).clone();
+    const base = super.describe(options);
+    if (next.innerType) {
       var _innerOptions;
       let innerOptions = options;
       if ((_innerOptions = innerOptions) != null && _innerOptions.value) {
@@ -2225,7 +2256,7 @@ class ArraySchema extends Schema {
           value: innerOptions.value[0]
         });
       }
-      base.innerType = this.innerType.describe(innerOptions);
+      base.innerType = next.innerType.describe(innerOptions);
     }
     return base;
   }