@fairmint/ui 0.3.33 → 0.3.34

package/dist/node_modules/zod/v4/classic/schemas.cjs

@@ -1,16 +1,53 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const jsonSchemaProcessors = require("../core/json-schema-processors.cjs");
+const toJsonSchema = require("../core/to-json-schema.cjs");
+const iso = require("./iso.cjs");
+const parse = require("./parse.cjs");
+const api = require("../core/api.cjs");
 const core = require("../core/core.cjs");
 const util = require("../core/util.cjs");
-const schemas = require("../core/schemas.cjs");
 const checks = require("../core/checks.cjs");
 const regexes = require("../core/regexes.cjs");
+const schemas = require("../core/schemas.cjs");
 const registries = require("../core/registries.cjs");
-const api = require("../core/api.cjs");
-const toJsonSchema = require("../core/to-json-schema.cjs");
-const jsonSchemaProcessors = require("../core/json-schema-processors.cjs");
-const iso = require("./iso.cjs");
-const parse = require("./parse.cjs");
+const _installedGroups = /* @__PURE__ */ new WeakMap();
+function _installLazyMethods(inst, group, methods) {
+  const proto = Object.getPrototypeOf(inst);
+  let installed = _installedGroups.get(proto);
+  if (!installed) {
+    installed = /* @__PURE__ */ new Set();
+    _installedGroups.set(proto, installed);
+  }
+  if (installed.has(group))
+    return;
+  installed.add(group);
+  for (const key in methods) {
+    const fn = methods[key];
+    Object.defineProperty(proto, key, {
+      configurable: true,
+      enumerable: false,
+      get() {
+        const bound = fn.bind(this);
+        Object.defineProperty(this, key, {
+          configurable: true,
+          writable: true,
+          enumerable: true,
+          value: bound
+        });
+        return bound;
+      },
+      set(v) {
+        Object.defineProperty(this, key, {
+          configurable: true,
+          writable: true,
+          enumerable: true,
+          value: v
+        });
+      }
+    });
+  }
+}
 const ZodType = /* @__PURE__ */ core.$constructor("ZodType", (inst, def) => {
   schemas.$ZodType.init(inst, def);
   Object.assign(inst["~standard"], {
@@ -23,23 +60,6 @@ const ZodType = /* @__PURE__ */ core.$constructor("ZodType", (inst, def) => {
   inst.def = def;
   inst.type = def.type;
   Object.defineProperty(inst, "_def", { value: def });
-  inst.check = (...checks2) => {
-    return inst.clone(util.mergeDefs(def, {
-      checks: [
-        ...def.checks ?? [],
-        ...checks2.map((ch) => typeof ch === "function" ? { _zod: { check: ch, def: { check: "custom" }, onattach: [] } } : ch)
-      ]
-    }), {
-      parent: true
-    });
-  };
-  inst.with = inst.check;
-  inst.clone = (def2, params) => util.clone(inst, def2, params);
-  inst.brand = () => inst;
-  inst.register = ((reg, meta2) => {
-    reg.add(inst, meta2);
-    return inst;
-  });
   inst.parse = (data, params) => parse.parse(inst, data, params, { callee: inst.parse });
   inst.safeParse = (data, params) => parse.safeParse(inst, data, params);
   inst.parseAsync = async (data, params) => parse.parseAsync(inst, data, params, { callee: inst.parseAsync });
@@ -53,45 +73,108 @@ const ZodType = /* @__PURE__ */ core.$constructor("ZodType", (inst, def) => {
   inst.safeDecode = (data, params) => parse.safeDecode(inst, data, params);
   inst.safeEncodeAsync = async (data, params) => parse.safeEncodeAsync(inst, data, params);
   inst.safeDecodeAsync = async (data, params) => parse.safeDecodeAsync(inst, data, params);
-  inst.refine = (check2, params) => inst.check(refine(check2, params));
-  inst.superRefine = (refinement) => inst.check(superRefine(refinement));
-  inst.overwrite = (fn) => inst.check(api._overwrite(fn));
-  inst.optional = () => optional(inst);
-  inst.exactOptional = () => exactOptional(inst);
-  inst.nullable = () => nullable(inst);
-  inst.nullish = () => optional(nullable(inst));
-  inst.nonoptional = (params) => nonoptional(inst, params);
-  inst.array = () => array(inst);
-  inst.or = (arg) => union([inst, arg]);
-  inst.and = (arg) => intersection(inst, arg);
-  inst.transform = (tx) => pipe(inst, transform(tx));
-  inst.default = (def2) => _default(inst, def2);
-  inst.prefault = (def2) => prefault(inst, def2);
-  inst.catch = (params) => _catch(inst, params);
-  inst.pipe = (target) => pipe(inst, target);
-  inst.readonly = () => readonly(inst);
-  inst.describe = (description) => {
-    const cl = inst.clone();
-    registries.globalRegistry.add(cl, { description });
-    return cl;
-  };
+  _installLazyMethods(inst, "ZodType", {
+    check(...chks) {
+      const def2 = this.def;
+      return this.clone(util.mergeDefs(def2, {
+        checks: [
+          ...def2.checks ?? [],
+          ...chks.map((ch) => typeof ch === "function" ? { _zod: { check: ch, def: { check: "custom" }, onattach: [] } } : ch)
+        ]
+      }), { parent: true });
+    },
+    with(...chks) {
+      return this.check(...chks);
+    },
+    clone(def2, params) {
+      return util.clone(this, def2, params);
+    },
+    brand() {
+      return this;
+    },
+    register(reg, meta2) {
+      reg.add(this, meta2);
+      return this;
+    },
+    refine(check2, params) {
+      return this.check(refine(check2, params));
+    },
+    superRefine(refinement, params) {
+      return this.check(superRefine(refinement, params));
+    },
+    overwrite(fn) {
+      return this.check(api._overwrite(fn));
+    },
+    optional() {
+      return optional(this);
+    },
+    exactOptional() {
+      return exactOptional(this);
+    },
+    nullable() {
+      return nullable(this);
+    },
+    nullish() {
+      return optional(nullable(this));
+    },
+    nonoptional(params) {
+      return nonoptional(this, params);
+    },
+    array() {
+      return array(this);
+    },
+    or(arg) {
+      return union([this, arg]);
+    },
+    and(arg) {
+      return intersection(this, arg);
+    },
+    transform(tx) {
+      return pipe(this, transform(tx));
+    },
+    default(d) {
+      return _default(this, d);
+    },
+    prefault(d) {
+      return prefault(this, d);
+    },
+    catch(params) {
+      return _catch(this, params);
+    },
+    pipe(target) {
+      return pipe(this, target);
+    },
+    readonly() {
+      return readonly(this);
+    },
+    describe(description) {
+      const cl = this.clone();
+      registries.globalRegistry.add(cl, { description });
+      return cl;
+    },
+    meta(...args) {
+      if (args.length === 0)
+        return registries.globalRegistry.get(this);
+      const cl = this.clone();
+      registries.globalRegistry.add(cl, args[0]);
+      return cl;
+    },
+    isOptional() {
+      return this.safeParse(void 0).success;
+    },
+    isNullable() {
+      return this.safeParse(null).success;
+    },
+    apply(fn) {
+      return fn(this);
+    }
+  });
   Object.defineProperty(inst, "description", {
     get() {
       return registries.globalRegistry.get(inst)?.description;
     },
     configurable: true
   });
-  inst.meta = (...args) => {
-    if (args.length === 0) {
-      return registries.globalRegistry.get(inst);
-    }
-    const cl = inst.clone();
-    registries.globalRegistry.add(cl, args[0]);
-    return cl;
-  };
-  inst.isOptional = () => inst.safeParse(void 0).success;
-  inst.isNullable = () => inst.safeParse(null).success;
-  inst.apply = (fn) => fn(inst);
   return inst;
 });
 const _ZodString = /* @__PURE__ */ core.$constructor("_ZodString", (inst, def) => {
@@ -102,21 +185,53 @@ const _ZodString = /* @__PURE__ */ core.$constructor("_ZodString", (inst, def) =
   inst.format = bag.format ?? null;
   inst.minLength = bag.minimum ?? null;
   inst.maxLength = bag.maximum ?? null;
-  inst.regex = (...args) => inst.check(api._regex(...args));
-  inst.includes = (...args) => inst.check(api._includes(...args));
-  inst.startsWith = (...args) => inst.check(api._startsWith(...args));
-  inst.endsWith = (...args) => inst.check(api._endsWith(...args));
-  inst.min = (...args) => inst.check(api._minLength(...args));
-  inst.max = (...args) => inst.check(api._maxLength(...args));
-  inst.length = (...args) => inst.check(api._length(...args));
-  inst.nonempty = (...args) => inst.check(api._minLength(1, ...args));
-  inst.lowercase = (params) => inst.check(api._lowercase(params));
-  inst.uppercase = (params) => inst.check(api._uppercase(params));
-  inst.trim = () => inst.check(api._trim());
-  inst.normalize = (...args) => inst.check(api._normalize(...args));
-  inst.toLowerCase = () => inst.check(api._toLowerCase());
-  inst.toUpperCase = () => inst.check(api._toUpperCase());
-  inst.slugify = () => inst.check(api._slugify());
+  _installLazyMethods(inst, "_ZodString", {
+    regex(...args) {
+      return this.check(api._regex(...args));
+    },
+    includes(...args) {
+      return this.check(api._includes(...args));
+    },
+    startsWith(...args) {
+      return this.check(api._startsWith(...args));
+    },
+    endsWith(...args) {
+      return this.check(api._endsWith(...args));
+    },
+    min(...args) {
+      return this.check(api._minLength(...args));
+    },
+    max(...args) {
+      return this.check(api._maxLength(...args));
+    },
+    length(...args) {
+      return this.check(api._length(...args));
+    },
+    nonempty(...args) {
+      return this.check(api._minLength(1, ...args));
+    },
+    lowercase(params) {
+      return this.check(api._lowercase(params));
+    },
+    uppercase(params) {
+      return this.check(api._uppercase(params));
+    },
+    trim() {
+      return this.check(api._trim());
+    },
+    normalize(...args) {
+      return this.check(api._normalize(...args));
+    },
+    toLowerCase() {
+      return this.check(api._toLowerCase());
+    },
+    toUpperCase() {
+      return this.check(api._toUpperCase());
+    },
+    slugify() {
+      return this.check(api._slugify());
+    }
+  });
 });
 const ZodString = /* @__PURE__ */ core.$constructor("ZodString", (inst, def) => {
   schemas.$ZodString.init(inst, def);
@@ -195,7 +310,7 @@ function url(params) {
 }
 function httpUrl(params) {
   return api._url(ZodURL, {
-    protocol: /^https?$/,
+    protocol: regexes.httpProtocol,
     hostname: regexes.domain,
     ...util.normalizeParams(params)
   });
@@ -337,21 +452,53 @@ const ZodNumber = /* @__PURE__ */ core.$constructor("ZodNumber", (inst, def) =>
   schemas.$ZodNumber.init(inst, def);
   ZodType.init(inst, def);
   inst._zod.processJSONSchema = (ctx, json2, params) => jsonSchemaProcessors.numberProcessor(inst, ctx, json2);
-  inst.gt = (value, params) => inst.check(api._gt(value, params));
-  inst.gte = (value, params) => inst.check(api._gte(value, params));
-  inst.min = (value, params) => inst.check(api._gte(value, params));
-  inst.lt = (value, params) => inst.check(api._lt(value, params));
-  inst.lte = (value, params) => inst.check(api._lte(value, params));
-  inst.max = (value, params) => inst.check(api._lte(value, params));
-  inst.int = (params) => inst.check(int(params));
-  inst.safe = (params) => inst.check(int(params));
-  inst.positive = (params) => inst.check(api._gt(0, params));
-  inst.nonnegative = (params) => inst.check(api._gte(0, params));
-  inst.negative = (params) => inst.check(api._lt(0, params));
-  inst.nonpositive = (params) => inst.check(api._lte(0, params));
-  inst.multipleOf = (value, params) => inst.check(api._multipleOf(value, params));
-  inst.step = (value, params) => inst.check(api._multipleOf(value, params));
-  inst.finite = () => inst;
+  _installLazyMethods(inst, "ZodNumber", {
+    gt(value, params) {
+      return this.check(api._gt(value, params));
+    },
+    gte(value, params) {
+      return this.check(api._gte(value, params));
+    },
+    min(value, params) {
+      return this.check(api._gte(value, params));
+    },
+    lt(value, params) {
+      return this.check(api._lt(value, params));
+    },
+    lte(value, params) {
+      return this.check(api._lte(value, params));
+    },
+    max(value, params) {
+      return this.check(api._lte(value, params));
+    },
+    int(params) {
+      return this.check(int(params));
+    },
+    safe(params) {
+      return this.check(int(params));
+    },
+    positive(params) {
+      return this.check(api._gt(0, params));
+    },
+    nonnegative(params) {
+      return this.check(api._gte(0, params));
+    },
+    negative(params) {
+      return this.check(api._lt(0, params));
+    },
+    nonpositive(params) {
+      return this.check(api._lte(0, params));
+    },
+    multipleOf(value, params) {
+      return this.check(api._multipleOf(value, params));
+    },
+    step(value, params) {
+      return this.check(api._multipleOf(value, params));
+    },
+    finite() {
+      return this;
+    }
+  });
   const bag = inst._zod.bag;
   inst.minValue = Math.max(bag.minimum ?? Number.NEGATIVE_INFINITY, bag.exclusiveMinimum ?? Number.NEGATIVE_INFINITY) ?? null;
   inst.maxValue = Math.min(bag.maximum ?? Number.POSITIVE_INFINITY, bag.exclusiveMaximum ?? Number.POSITIVE_INFINITY) ?? null;
@@ -498,11 +645,23 @@ const ZodArray = /* @__PURE__ */ core.$constructor("ZodArray", (inst, def) => {
   ZodType.init(inst, def);
   inst._zod.processJSONSchema = (ctx, json2, params) => jsonSchemaProcessors.arrayProcessor(inst, ctx, json2, params);
   inst.element = def.element;
-  inst.min = (minLength, params) => inst.check(api._minLength(minLength, params));
-  inst.nonempty = (params) => inst.check(api._minLength(1, params));
-  inst.max = (maxLength, params) => inst.check(api._maxLength(maxLength, params));
-  inst.length = (len, params) => inst.check(api._length(len, params));
-  inst.unwrap = () => inst.element;
+  _installLazyMethods(inst, "ZodArray", {
+    min(n, params) {
+      return this.check(api._minLength(n, params));
+    },
+    nonempty(params) {
+      return this.check(api._minLength(1, params));
+    },
+    max(n, params) {
+      return this.check(api._maxLength(n, params));
+    },
+    length(n, params) {
+      return this.check(api._length(n, params));
+    },
+    unwrap() {
+      return this.element;
+    }
+  });
 });
 function array(element, params) {
   return api._array(ZodArray, element, params);
@@ -518,23 +677,47 @@ const ZodObject = /* @__PURE__ */ core.$constructor("ZodObject", (inst, def) =>
   util.defineLazy(inst, "shape", () => {
     return def.shape;
   });
-  inst.keyof = () => _enum(Object.keys(inst._zod.def.shape));
-  inst.catchall = (catchall) => inst.clone({ ...inst._zod.def, catchall });
-  inst.passthrough = () => inst.clone({ ...inst._zod.def, catchall: unknown() });
-  inst.loose = () => inst.clone({ ...inst._zod.def, catchall: unknown() });
-  inst.strict = () => inst.clone({ ...inst._zod.def, catchall: never() });
-  inst.strip = () => inst.clone({ ...inst._zod.def, catchall: void 0 });
-  inst.extend = (incoming) => {
-    return util.extend(inst, incoming);
-  };
-  inst.safeExtend = (incoming) => {
-    return util.safeExtend(inst, incoming);
-  };
-  inst.merge = (other) => util.merge(inst, other);
-  inst.pick = (mask) => util.pick(inst, mask);
-  inst.omit = (mask) => util.omit(inst, mask);
-  inst.partial = (...args) => util.partial(ZodOptional, inst, args[0]);
-  inst.required = (...args) => util.required(ZodNonOptional, inst, args[0]);
+  _installLazyMethods(inst, "ZodObject", {
+    keyof() {
+      return _enum(Object.keys(this._zod.def.shape));
+    },
+    catchall(catchall) {
+      return this.clone({ ...this._zod.def, catchall });
+    },
+    passthrough() {
+      return this.clone({ ...this._zod.def, catchall: unknown() });
+    },
+    loose() {
+      return this.clone({ ...this._zod.def, catchall: unknown() });
+    },
+    strict() {
+      return this.clone({ ...this._zod.def, catchall: never() });
+    },
+    strip() {
+      return this.clone({ ...this._zod.def, catchall: void 0 });
+    },
+    extend(incoming) {
+      return util.extend(this, incoming);
+    },
+    safeExtend(incoming) {
+      return util.safeExtend(this, incoming);
+    },
+    merge(other) {
+      return util.merge(this, other);
+    },
+    pick(mask) {
+      return util.pick(this, mask);
+    },
+    omit(mask) {
+      return util.omit(this, mask);
+    },
+    partial(...args) {
+      return util.partial(ZodOptional, this, args[0]);
+    },
+    required(...args) {
+      return util.required(ZodNonOptional, this, args[0]);
+    }
+  });
 });
 function object(shape, params) {
   const def = {
@@ -639,6 +822,14 @@ const ZodRecord = /* @__PURE__ */ core.$constructor("ZodRecord", (inst, def) =>
   inst.valueType = def.valueType;
 });
 function record(keyType, valueType, params) {
+  if (!valueType || !valueType._zod) {
+    return new ZodRecord({
+      type: "record",
+      keyType: string(),
+      valueType: keyType,
+      ...util.normalizeParams(valueType)
+    });
+  }
   return new ZodRecord({
     type: "record",
     keyType,
@@ -810,10 +1001,12 @@ const ZodTransform = /* @__PURE__ */ core.$constructor("ZodTransform", (inst, de
     if (output instanceof Promise) {
       return output.then((output2) => {
         payload.value = output2;
+        payload.fallback = true;
         return payload;
       });
     }
     payload.value = output;
+    payload.fallback = true;
     return payload;
   };
 });
@@ -968,6 +1161,20 @@ function codec(in_, out, params) {
     reverseTransform: params.encode
   });
 }
+function invertCodec(codec2) {
+  const def = codec2._zod.def;
+  return new ZodCodec({
+    type: "pipe",
+    in: def.out,
+    out: def.in,
+    transform: def.reverseTransform,
+    reverseTransform: def.transform
+  });
+}
+const ZodPreprocess = /* @__PURE__ */ core.$constructor("ZodPreprocess", (inst, def) => {
+  ZodPipe.init(inst, def);
+  schemas.$ZodPreprocess.init(inst, def);
+});
 const ZodReadonly = /* @__PURE__ */ core.$constructor("ZodReadonly", (inst, def) => {
   schemas.$ZodReadonly.init(inst, def);
   ZodType.init(inst, def);
@@ -1047,8 +1254,8 @@ function custom(fn, _params) {
 function refine(fn, _params = {}) {
   return api._refine(ZodCustom, fn, _params);
 }
-function superRefine(fn) {
-  return api._superRefine(fn);
+function superRefine(fn, params) {
+  return api._superRefine(fn, params);
 }
 const describe = api.describe;
 const meta = api.meta;
@@ -1086,7 +1293,11 @@ function json(params) {
   return jsonSchema;
 }
 function preprocess(fn, schema) {
-  return pipe(transform(fn), schema);
+  return new ZodPreprocess({
+    type: "pipe",
+    in: transform(fn),
+    out: schema
+  });
 }
 exports.ZodAny = ZodAny;
 exports.ZodArray = ZodArray;
@@ -1135,6 +1346,7 @@ exports.ZodObject = ZodObject;
 exports.ZodOptional = ZodOptional;
 exports.ZodPipe = ZodPipe;
 exports.ZodPrefault = ZodPrefault;
+exports.ZodPreprocess = ZodPreprocess;
 exports.ZodPromise = ZodPromise;
 exports.ZodReadonly = ZodReadonly;
 exports.ZodRecord = ZodRecord;
@@ -1195,6 +1407,7 @@ exports.int = int;
 exports.int32 = int32;
 exports.int64 = int64;
 exports.intersection = intersection;
+exports.invertCodec = invertCodec;
 exports.ipv4 = ipv4;
 exports.ipv6 = ipv6;
 exports.json = json;