@justifi/webcomponents 4.2.2 → 4.4.0

package/dist/esm/{index.esm-5624a5ed.js → index.esm-be2cd327.js}

@@ -888,10 +888,10 @@ class Schema {
     }
     return result;
   }
-  _cast(rawValue, _options) {
+  _cast(rawValue, options) {
     let value = rawValue === undefined ? rawValue : this.transforms.reduce((prevValue, fn) => fn.call(this, prevValue, rawValue, this), rawValue);
     if (value === undefined) {
-      value = this.getDefault();
+      value = this.getDefault(options);
     }
     return value;
   }
@@ -1050,18 +1050,18 @@ class Schema {
       throw err;
     }
   }
-  _getDefault() {
+  _getDefault(options) {
     let defaultValue = this.spec.default;
     if (defaultValue == null) {
       return defaultValue;
     }
-    return typeof defaultValue === 'function' ? defaultValue.call(this) : clone(defaultValue);
+    return typeof defaultValue === 'function' ? defaultValue.call(this, options) : clone(defaultValue);
   }
   getDefault(options
   // If schema is defaulted we know it's at least not undefined
   ) {
     let schema = this.resolve(options || {});
-    return schema._getDefault();
+    return schema._getDefault(options);
   }
   default(def) {
     if (arguments.length === 0) {
@@ -1201,8 +1201,9 @@ class Schema {
     next.internalTests.typeError = createValidation({
       message,
       name: 'typeError',
+      skipAbsent: true,
       test(value) {
-        if (!isAbsent(value) && !this.schema._typeCheck(value)) return this.createError({
+        if (!this.schema._typeCheck(value)) return this.createError({
           params: {
             type: this.schema.type
           }
@@ -1310,6 +1311,98 @@ for (const method of ['validate', 'validateSync']) Schema.prototype[`${method}At
 for (const alias of ['equals', 'is']) Schema.prototype[alias] = Schema.prototype.oneOf;
 for (const alias of ['not', 'nope']) Schema.prototype[alias] = Schema.prototype.notOneOf;
 
+const returnsTrue = () => true;
+function create$8(spec) {
+  return new MixedSchema(spec);
+}
+class MixedSchema extends Schema {
+  constructor(spec) {
+    super(typeof spec === 'function' ? {
+      type: 'mixed',
+      check: spec
+    } : Object.assign({
+      type: 'mixed',
+      check: returnsTrue
+    }, spec));
+  }
+}
+create$8.prototype = MixedSchema.prototype;
+
+function create$7() {
+  return new BooleanSchema();
+}
+class BooleanSchema extends Schema {
+  constructor() {
+    super({
+      type: 'boolean',
+      check(v) {
+        if (v instanceof Boolean) v = v.valueOf();
+        return typeof v === 'boolean';
+      }
+    });
+    this.withMutation(() => {
+      this.transform((value, _raw, ctx) => {
+        if (ctx.spec.coerce && !ctx.isType(value)) {
+          if (/^(true|1)$/i.test(String(value))) return true;
+          if (/^(false|0)$/i.test(String(value))) return false;
+        }
+        return value;
+      });
+    });
+  }
+  isTrue(message = boolean.isValue) {
+    return this.test({
+      message,
+      name: 'is-value',
+      exclusive: true,
+      params: {
+        value: 'true'
+      },
+      test(value) {
+        return isAbsent(value) || value === true;
+      }
+    });
+  }
+  isFalse(message = boolean.isValue) {
+    return this.test({
+      message,
+      name: 'is-value',
+      exclusive: true,
+      params: {
+        value: 'false'
+      },
+      test(value) {
+        return isAbsent(value) || value === false;
+      }
+    });
+  }
+  default(def) {
+    return super.default(def);
+  }
+  defined(msg) {
+    return super.defined(msg);
+  }
+  optional() {
+    return super.optional();
+  }
+  required(msg) {
+    return super.required(msg);
+  }
+  notRequired() {
+    return super.notRequired();
+  }
+  nullable() {
+    return super.nullable();
+  }
+  nonNullable(msg) {
+    return super.nonNullable(msg);
+  }
+  strip(v) {
+    return super.strip(v);
+  }
+}
+create$7.prototype = BooleanSchema.prototype;
+
 // Taken from HTML spec: https://html.spec.whatwg.org/multipage/input.html#valid-e-mail-address
 let rEmail =
 // eslint-disable-next-line
@@ -1594,7 +1687,7 @@ class ObjectSchema extends Schema {
     let value = super._cast(_value, options);
 
     //should ignore nulls here
-    if (value === undefined) return this.getDefault();
+    if (value === undefined) return this.getDefault(options);
     if (!this._typeCheck(value)) return value;
     let fields = this.fields;
     let strip = (_options$stripUnknown = options.stripUnknown) != null ? _options$stripUnknown : this.spec.noUnknown;
@@ -1699,11 +1792,13 @@ class ObjectSchema extends Schema {
       const target = nextFields[field];
       nextFields[field] = target === undefined ? schemaOrRef : target;
     }
-    return next.withMutation(s => s.setFields(nextFields, this._excludedEdges));
+    return next.withMutation(s =>
+    // XXX: excludes here is wrong
+    s.setFields(nextFields, [...this._excludedEdges, ...schema._excludedEdges]));
   }
-  _getDefault() {
+  _getDefault(options) {
     if ('default' in this.spec) {
-      return super._getDefault();
+      return super._getDefault(options);
     }
 
     // if there is no default set invent one
@@ -1712,8 +1807,16 @@ class ObjectSchema extends Schema {
     }
     let dft = {};
     this._nodes.forEach(key => {
+      var _innerOptions;
       const field = this.fields[key];
-      dft[key] = field && 'getDefault' in field ? field.getDefault() : undefined;
+      let innerOptions = options;
+      if ((_innerOptions = innerOptions) != null && _innerOptions.value) {
+        innerOptions = Object.assign({}, innerOptions, {
+          parent: innerOptions.value,
+          value: innerOptions.value[key]
+        });
+      }
+      dft[key] = field && 'getDefault' in field ? field.getDefault(innerOptions) : undefined;
     });
     return dft;
   }
@@ -1827,9 +1930,9 @@ class ObjectSchema extends Schema {
     let base = super.describe(options);
     base.fields = {};
     for (const [key, value] of Object.entries(this.fields)) {
-      var _innerOptions;
+      var _innerOptions2;
       let innerOptions = options;
-      if ((_innerOptions = innerOptions) != null && _innerOptions.value) {
+      if ((_innerOptions2 = innerOptions) != null && _innerOptions2.value) {
         innerOptions = Object.assign({}, innerOptions, {
           parent: innerOptions.value,
           value: innerOptions.value[key]
@@ -1842,6 +1945,187 @@ class ObjectSchema extends Schema {
 }
 create$3.prototype = ObjectSchema.prototype;
 
-export { create$6 as a, create$3 as c };
+function create$2(type) {
+  return new ArraySchema(type);
+}
+class ArraySchema extends Schema {
+  constructor(type) {
+    super({
+      type: 'array',
+      spec: {
+        types: type
+      },
+      check(v) {
+        return Array.isArray(v);
+      }
+    });
+
+    // `undefined` specifically means uninitialized, as opposed to "no subtype"
+    this.innerType = void 0;
+    this.innerType = type;
+  }
+  _cast(_value, _opts) {
+    const value = super._cast(_value, _opts);
+
+    // should ignore nulls here
+    if (!this._typeCheck(value) || !this.innerType) {
+      return value;
+    }
+    let isChanged = false;
+    const castArray = value.map((v, idx) => {
+      const castElement = this.innerType.cast(v, Object.assign({}, _opts, {
+        path: `${_opts.path || ''}[${idx}]`
+      }));
+      if (castElement !== v) {
+        isChanged = true;
+      }
+      return castElement;
+    });
+    return isChanged ? castArray : value;
+  }
+  _validate(_value, options = {}, panic, next) {
+    var _options$recursive;
+    // let sync = options.sync;
+    // let path = options.path;
+    let innerType = this.innerType;
+    // let endEarly = options.abortEarly ?? this.spec.abortEarly;
+    let recursive = (_options$recursive = options.recursive) != null ? _options$recursive : this.spec.recursive;
+    super._validate(_value, options, panic, (arrayErrors, value) => {
+      var _options$originalValu2;
+      if (!recursive || !innerType || !this._typeCheck(value)) {
+        next(arrayErrors, value);
+        return;
+      }
+
+      // #950 Ensure that sparse array empty slots are validated
+      let tests = new Array(value.length);
+      for (let index = 0; index < value.length; index++) {
+        var _options$originalValu;
+        tests[index] = innerType.asNestedTest({
+          options,
+          index,
+          parent: value,
+          parentPath: options.path,
+          originalParent: (_options$originalValu = options.originalValue) != null ? _options$originalValu : _value
+        });
+      }
+      this.runTests({
+        value,
+        tests,
+        originalValue: (_options$originalValu2 = options.originalValue) != null ? _options$originalValu2 : _value,
+        options
+      }, panic, innerTypeErrors => next(innerTypeErrors.concat(arrayErrors), value));
+    });
+  }
+  clone(spec) {
+    const next = super.clone(spec);
+    // @ts-expect-error readonly
+    next.innerType = this.innerType;
+    return next;
+  }
+
+  /** Parse an input JSON string to an object */
+  json() {
+    return this.transform(parseJson);
+  }
+  concat(schema) {
+    let next = super.concat(schema);
+
+    // @ts-expect-error readonly
+    next.innerType = this.innerType;
+    if (schema.innerType)
+      // @ts-expect-error readonly
+      next.innerType = next.innerType ?
+      // @ts-expect-error Lazy doesn't have concat and will break
+      next.innerType.concat(schema.innerType) : schema.innerType;
+    return next;
+  }
+  of(schema) {
+    // FIXME: this should return a new instance of array without the default to be
+    let next = this.clone();
+    if (!isSchema(schema)) throw new TypeError('`array.of()` sub-schema must be a valid yup schema not: ' + printValue(schema));
+
+    // @ts-expect-error readonly
+    next.innerType = schema;
+    next.spec = Object.assign({}, next.spec, {
+      types: schema
+    });
+    return next;
+  }
+  length(length, message = array.length) {
+    return this.test({
+      message,
+      name: 'length',
+      exclusive: true,
+      params: {
+        length
+      },
+      skipAbsent: true,
+      test(value) {
+        return value.length === this.resolve(length);
+      }
+    });
+  }
+  min(min, message) {
+    message = message || array.min;
+    return this.test({
+      message,
+      name: 'min',
+      exclusive: true,
+      params: {
+        min
+      },
+      skipAbsent: true,
+      // FIXME(ts): Array<typeof T>
+      test(value) {
+        return value.length >= this.resolve(min);
+      }
+    });
+  }
+  max(max, message) {
+    message = message || array.max;
+    return this.test({
+      message,
+      name: 'max',
+      exclusive: true,
+      params: {
+        max
+      },
+      skipAbsent: true,
+      test(value) {
+        return value.length <= this.resolve(max);
+      }
+    });
+  }
+  ensure() {
+    return this.default(() => []).transform((val, original) => {
+      // We don't want to return `null` for nullable schema
+      if (this._typeCheck(val)) return val;
+      return original == null ? [] : [].concat(original);
+    });
+  }
+  compact(rejector) {
+    let reject = !rejector ? v => !!v : (v, i, a) => !rejector(v, i, a);
+    return this.transform(values => values != null ? values.filter(reject) : values);
+  }
+  describe(options) {
+    let base = super.describe(options);
+    if (this.innerType) {
+      var _innerOptions;
+      let innerOptions = options;
+      if ((_innerOptions = innerOptions) != null && _innerOptions.value) {
+        innerOptions = Object.assign({}, innerOptions, {
+          parent: innerOptions.value,
+          value: innerOptions.value[0]
+        });
+      }
+      base.innerType = this.innerType.describe(innerOptions);
+    }
+    return base;
+  }
+}
+create$2.prototype = ArraySchema.prototype;
+
+export { create$6 as a, create$7 as b, create$3 as c, create$8 as d, create$2 as e };
 
-//# sourceMappingURL=index.esm-5624a5ed.js.map
+//# sourceMappingURL=index.esm-be2cd327.js.map