fastapi-rtk 2.8.0 → 2.9.0

package/dist/.external/cjs/yup@1.7.1/yup/index.esm.cjs

@@ -186,7 +186,7 @@ let tuple = {
     return ValidationError.formatError(mixed.notType, params);
   }
 };
-var locale = Object.assign(/* @__PURE__ */ Object.create(null), {
+Object.assign(/* @__PURE__ */ Object.create(null), {
   mixed,
   string,
   number,
@@ -236,9 +236,6 @@ const prefixes = {
   context: "$",
   value: "."
 };
-function create$9(key, options) {
-  return new Reference(key, options);
-}
 class Reference {
   constructor(key, options = {}) {
     this.key = void 0;
@@ -428,9 +425,6 @@ function getIn(schema, path, value, context = value) {
     parentPath: lastPart
   };
 }
-function reach(obj, path, value, context) {
-  return getIn(obj, path, value, context).schema;
-}
 class ReferenceSet extends Set {
   describe() {
     const description = [];
@@ -1161,80 +1155,6 @@ class MixedSchema extends Schema {
   }
 }
 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) => {
-        if (this.spec.coerce && !this.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;
 const isoReg = /^(\d{4}|[+-]\d{6})(?:-?(\d{2})(?:-?(\d{2}))?)?(?:[ T]?(\d{2}):?(\d{2})(?::?(\d{2})(?:[,.](\d{1,}))?)?(?:(Z)|([+-])(\d{2})(?::?(\d{2}))?)?)?$/;
 function parseIsoDate(date2) {
   const struct = parseDateStruct(date2);
@@ -1491,121 +1411,8 @@ class StringSchema extends Schema {
   }
 }
 create$6.prototype = StringSchema.prototype;
-let isNaN$1 = (value) => value != +value;
-function create$5() {
-  return new NumberSchema();
-}
-class NumberSchema extends Schema {
-  constructor() {
-    super({
-      type: "number",
-      check(value) {
-        if (value instanceof Number) value = value.valueOf();
-        return typeof value === "number" && !isNaN$1(value);
-      }
-    });
-    this.withMutation(() => {
-      this.transform((value, _raw) => {
-        if (!this.spec.coerce) return value;
-        let parsed = value;
-        if (typeof parsed === "string") {
-          parsed = parsed.replace(/\s/g, "");
-          if (parsed === "") return NaN;
-          parsed = +parsed;
-        }
-        if (this.isType(parsed) || parsed === null) return parsed;
-        return parseFloat(parsed);
-      });
-    });
-  }
-  min(min, message = number.min) {
-    return this.test({
-      message,
-      name: "min",
-      exclusive: true,
-      params: {
-        min
-      },
-      skipAbsent: true,
-      test(value) {
-        return value >= this.resolve(min);
-      }
-    });
-  }
-  max(max, message = number.max) {
-    return this.test({
-      message,
-      name: "max",
-      exclusive: true,
-      params: {
-        max
-      },
-      skipAbsent: true,
-      test(value) {
-        return value <= this.resolve(max);
-      }
-    });
-  }
-  lessThan(less, message = number.lessThan) {
-    return this.test({
-      message,
-      name: "max",
-      exclusive: true,
-      params: {
-        less
-      },
-      skipAbsent: true,
-      test(value) {
-        return value < this.resolve(less);
-      }
-    });
-  }
-  moreThan(more, message = number.moreThan) {
-    return this.test({
-      message,
-      name: "min",
-      exclusive: true,
-      params: {
-        more
-      },
-      skipAbsent: true,
-      test(value) {
-        return value > this.resolve(more);
-      }
-    });
-  }
-  positive(msg = number.positive) {
-    return this.moreThan(0, msg);
-  }
-  negative(msg = number.negative) {
-    return this.lessThan(0, msg);
-  }
-  integer(message = number.integer) {
-    return this.test({
-      name: "integer",
-      message,
-      skipAbsent: true,
-      test: (val) => Number.isInteger(val)
-    });
-  }
-  truncate() {
-    return this.transform((value) => !isAbsent(value) ? value | 0 : value);
-  }
-  round(method) {
-    var _method;
-    let avail = ["ceil", "floor", "round", "trunc"];
-    method = ((_method = method) == null ? void 0 : _method.toLowerCase()) || "round";
-    if (method === "trunc") return this.truncate();
-    if (avail.indexOf(method.toLowerCase()) === -1) throw new TypeError("Only valid options for round() are: " + avail.join(", "));
-    return this.transform((value) => !isAbsent(value) ? Math[method](value) : value);
-  }
-}
-create$5.prototype = NumberSchema.prototype;
 let invalidDate = /* @__PURE__ */ new Date("");
 let isDate = (obj) => Object.prototype.toString.call(obj) === "[object Date]";
-function create$4() {
-  return new DateSchema();
-}
 class DateSchema extends Schema {
   constructor() {
     super({
@@ -1665,8 +1472,6 @@ class DateSchema extends Schema {
   }
 }
 DateSchema.INVALID_DATE = invalidDate;
-create$4.prototype = DateSchema.prototype;
-create$4.INVALID_DATE = invalidDate;
 function sortFields(fields, excludedEdges = []) {
   let edges = [];
   let nodes = /* @__PURE__ */ new Set();
@@ -2212,256 +2017,17 @@ class ArraySchema extends Schema {
   }
 }
 create$2.prototype = ArraySchema.prototype;
-function create$1(schemas) {
-  return new TupleSchema(schemas);
-}
-class TupleSchema extends Schema {
-  constructor(schemas) {
-    super({
-      type: "tuple",
-      spec: {
-        types: schemas
-      },
-      check(v) {
-        const types = this.spec.types;
-        return Array.isArray(v) && v.length === types.length;
-      }
-    });
-    this.withMutation(() => {
-      this.typeError(tuple.notType);
-    });
-  }
-  _cast(inputValue, options) {
-    const {
-      types
-    } = this.spec;
-    const value = super._cast(inputValue, options);
-    if (!this._typeCheck(value)) {
-      return value;
-    }
-    let isChanged = false;
-    const castArray = types.map((type, idx) => {
-      const castElement = type.cast(value[idx], Object.assign({}, options, {
-        path: `${options.path || ""}[${idx}]`,
-        parent: value,
-        originalValue: value[idx],
-        value: value[idx],
-        index: idx
-      }));
-      if (castElement !== value[idx]) isChanged = true;
-      return castElement;
-    });
-    return isChanged ? castArray : value;
-  }
-  _validate(_value, options = {}, panic, next) {
-    let itemTypes = this.spec.types;
-    super._validate(_value, options, panic, (tupleErrors, value) => {
-      var _options$originalValu2;
-      if (!this._typeCheck(value)) {
-        next(tupleErrors, value);
-        return;
-      }
-      let tests = [];
-      for (let [index2, itemSchema] of itemTypes.entries()) {
-        var _options$originalValu;
-        tests[index2] = itemSchema.asNestedTest({
-          options,
-          index: index2,
-          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(tupleErrors), value));
-    });
-  }
-  describe(options) {
-    const next = (options ? this.resolve(options) : this).clone();
-    const base = super.describe(options);
-    base.innerType = next.spec.types.map((schema, index2) => {
-      var _innerOptions;
-      let innerOptions = options;
-      if ((_innerOptions = innerOptions) != null && _innerOptions.value) {
-        innerOptions = Object.assign({}, innerOptions, {
-          parent: innerOptions.value,
-          value: innerOptions.value[index2]
-        });
-      }
-      return schema.describe(innerOptions);
-    });
-    return base;
-  }
-}
-create$1.prototype = TupleSchema.prototype;
-function create(builder) {
-  return new Lazy(builder);
-}
-function catchValidationError(fn) {
-  try {
-    return fn();
-  } catch (err) {
-    if (ValidationError.isError(err)) return Promise.reject(err);
-    throw err;
-  }
-}
-class Lazy {
-  constructor(builder) {
-    this.type = "lazy";
-    this.__isYupSchema__ = true;
-    this.spec = void 0;
-    this._resolve = (value, options = {}) => {
-      let schema = this.builder(value, options);
-      if (!isSchema(schema)) throw new TypeError("lazy() functions must return a valid schema");
-      if (this.spec.optional) schema = schema.optional();
-      return schema.resolve(options);
-    };
-    this.builder = builder;
-    this.spec = {
-      meta: void 0,
-      optional: false
-    };
-  }
-  clone(spec) {
-    const next = new Lazy(this.builder);
-    next.spec = Object.assign({}, this.spec, spec);
-    return next;
-  }
-  optionality(optional) {
-    const next = this.clone({
-      optional
-    });
-    return next;
-  }
-  optional() {
-    return this.optionality(true);
-  }
-  resolve(options) {
-    return this._resolve(options.value, options);
-  }
-  cast(value, options) {
-    return this._resolve(value, options).cast(value, options);
-  }
-  asNestedTest(config) {
-    let {
-      key,
-      index: index2,
-      parent,
-      options
-    } = config;
-    let value = parent[index2 != null ? index2 : key];
-    return this._resolve(value, Object.assign({}, options, {
-      value,
-      parent
-    })).asNestedTest(config);
-  }
-  validate(value, options) {
-    return catchValidationError(() => this._resolve(value, options).validate(value, options));
-  }
-  validateSync(value, options) {
-    return this._resolve(value, options).validateSync(value, options);
-  }
-  validateAt(path, value, options) {
-    return catchValidationError(() => this._resolve(value, options).validateAt(path, value, options));
-  }
-  validateSyncAt(path, value, options) {
-    return this._resolve(value, options).validateSyncAt(path, value, options);
-  }
-  isValid(value, options) {
-    try {
-      return this._resolve(value, options).isValid(value, options);
-    } catch (err) {
-      if (ValidationError.isError(err)) {
-        return Promise.resolve(false);
-      }
-      throw err;
-    }
-  }
-  isValidSync(value, options) {
-    return this._resolve(value, options).isValidSync(value, options);
-  }
-  describe(options) {
-    return options ? this.resolve(options).describe(options) : {
-      type: "lazy",
-      meta: this.spec.meta,
-      label: void 0
-    };
-  }
-  meta(...args) {
-    if (args.length === 0) return this.spec.meta;
-    let next = this.clone();
-    next.spec.meta = Object.assign(next.spec.meta || {}, args[0]);
-    return next;
-  }
-  get ["~standard"]() {
-    const schema = this;
-    const standard = {
-      version: 1,
-      vendor: "yup",
-      async validate(value) {
-        try {
-          const result = await schema.validate(value, {
-            abortEarly: false
-          });
-          return {
-            value: result
-          };
-        } catch (err) {
-          if (ValidationError.isError(err)) {
-            return {
-              issues: issuesFromValidationError(err)
-            };
-          }
-          throw err;
-        }
-      }
-    };
-    return standard;
-  }
-}
-function setLocale(custom) {
-  Object.keys(custom).forEach((type) => {
-    Object.keys(custom[type]).forEach((method) => {
-      locale[type][method] = custom[type][method];
-    });
-  });
-}
-function addMethod(schemaType, name, fn) {
-  if (!schemaType || !isSchema(schemaType.prototype)) throw new TypeError("You must provide a yup schema constructor function");
-  if (typeof name !== "string") throw new TypeError("A Method name must be provided");
-  if (typeof fn !== "function") throw new TypeError("Method function must be provided");
-  schemaType.prototype[name] = fn;
-}
 exports.ArraySchema = ArraySchema;
-exports.BooleanSchema = BooleanSchema;
 exports.DateSchema = DateSchema;
-exports.LazySchema = Lazy;
 exports.MixedSchema = MixedSchema;
-exports.NumberSchema = NumberSchema;
 exports.ObjectSchema = ObjectSchema;
 exports.Schema = Schema;
 exports.StringSchema = StringSchema;
-exports.TupleSchema = TupleSchema;
 exports.ValidationError = ValidationError;
-exports.addMethod = addMethod;
 exports.array = create$2;
-exports.bool = create$7;
-exports.boolean = create$7;
-exports.date = create$4;
-exports.defaultLocale = locale;
 exports.getIn = getIn;
 exports.isSchema = isSchema;
-exports.lazy = create;
 exports.mixed = create$8;
-exports.number = create$5;
 exports.object = create$3;
 exports.printValue = printValue;
-exports.reach = reach;
-exports.ref = create$9;
-exports.setLocale = setLocale;
 exports.string = create$6;
-exports.tuple = create$1;