"use strict"; // import { $ZodType } from "./schemas.js"; var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { if (k2 === undefined) k2 = k; var desc = Object.getOwnPropertyDescriptor(m, k); if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { desc = { enumerable: true, get: function() { return m[k]; } }; } Object.defineProperty(o, k2, desc); }) : (function(o, m, k, k2) { if (k2 === undefined) k2 = k; o[k2] = m[k]; })); var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { Object.defineProperty(o, "default", { enumerable: true, value: v }); }) : function(o, v) { o["default"] = v; }); var __importStar = (this && this.__importStar) || function (mod) { if (mod && mod.__esModule) return mod; var result = {}; if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); __setModuleDefault(result, mod); return result; }; Object.defineProperty(exports, "__esModule", { value: true }); exports.$ZodCheckOverwrite = exports.$ZodCheckMimeType = exports.$ZodCheckProperty = exports.$ZodCheckEndsWith = exports.$ZodCheckStartsWith = exports.$ZodCheckIncludes = exports.$ZodCheckUpperCase = exports.$ZodCheckLowerCase = exports.$ZodCheckRegex = exports.$ZodCheckStringFormat = exports.$ZodCheckLengthEquals = exports.$ZodCheckMinLength = exports.$ZodCheckMaxLength = exports.$ZodCheckSizeEquals = exports.$ZodCheckMinSize = exports.$ZodCheckMaxSize = exports.$ZodCheckBigIntFormat = exports.$ZodCheckNumberFormat = exports.$ZodCheckMultipleOf = exports.$ZodCheckGreaterThan = exports.$ZodCheckLessThan = exports.$ZodCheck = void 0; const core = __importStar(require("./core.cjs")); const regexes = __importStar(require("./regexes.cjs")); const util = __importStar(require("./util.cjs")); exports.$ZodCheck = core.$constructor("$ZodCheck", (inst, def) => { var _a; inst._zod ?? (inst._zod = {}); inst._zod.def = def; (_a = inst._zod).onattach ?? (_a.onattach = []); }); const numericOriginMap = { number: "number", bigint: "bigint", object: "date", }; exports.$ZodCheckLessThan = core.$constructor("$ZodCheckLessThan", (inst, def) => { exports.$ZodCheck.init(inst, def); const origin = numericOriginMap[typeof def.value]; inst._zod.onattach.push((inst) => { const bag = inst._zod.bag; const curr = (def.inclusive ? bag.maximum : bag.exclusiveMaximum) ?? Number.POSITIVE_INFINITY; if (def.value < curr) { if (def.inclusive) bag.maximum = def.value; else bag.exclusiveMaximum = def.value; } }); inst._zod.check = (payload) => { if (def.inclusive ? payload.value <= def.value : payload.value < def.value) { return; } payload.issues.push({ origin, code: "too_big", maximum: def.value, input: payload.value, inclusive: def.inclusive, inst, continue: !def.abort, }); }; }); exports.$ZodCheckGreaterThan = core.$constructor("$ZodCheckGreaterThan", (inst, def) => { exports.$ZodCheck.init(inst, def); const origin = numericOriginMap[typeof def.value]; inst._zod.onattach.push((inst) => { const bag = inst._zod.bag; const curr = (def.inclusive ? bag.minimum : bag.exclusiveMinimum) ?? Number.NEGATIVE_INFINITY; if (def.value > curr) { if (def.inclusive) bag.minimum = def.value; else bag.exclusiveMinimum = def.value; } }); inst._zod.check = (payload) => { if (def.inclusive ? payload.value >= def.value : payload.value > def.value) { return; } payload.issues.push({ origin, code: "too_small", minimum: def.value, input: payload.value, inclusive: def.inclusive, inst, continue: !def.abort, }); }; }); exports.$ZodCheckMultipleOf = /*@__PURE__*/ core.$constructor("$ZodCheckMultipleOf", (inst, def) => { exports.$ZodCheck.init(inst, def); inst._zod.onattach.push((inst) => { var _a; (_a = inst._zod.bag).multipleOf ?? (_a.multipleOf = def.value); }); inst._zod.check = (payload) => { if (typeof payload.value !== typeof def.value) throw new Error("Cannot mix number and bigint in multiple_of check."); const isMultiple = typeof payload.value === "bigint" ? payload.value % def.value === BigInt(0) : util.floatSafeRemainder(payload.value, def.value) === 0; if (isMultiple) return; payload.issues.push({ origin: typeof payload.value, code: "not_multiple_of", divisor: def.value, input: payload.value, inst, continue: !def.abort, }); }; }); exports.$ZodCheckNumberFormat = core.$constructor("$ZodCheckNumberFormat", (inst, def) => { exports.$ZodCheck.init(inst, def); // no format checks def.format = def.format || "float64"; const isInt = def.format?.includes("int"); const origin = isInt ? "int" : "number"; const [minimum, maximum] = util.NUMBER_FORMAT_RANGES[def.format]; inst._zod.onattach.push((inst) => { const bag = inst._zod.bag; bag.format = def.format; bag.minimum = minimum; bag.maximum = maximum; if (isInt) bag.pattern = regexes.integer; }); inst._zod.check = (payload) => { const input = payload.value; if (isInt) { if (!Number.isInteger(input)) { // invalid_format issue // payload.issues.push({ // expected: def.format, // format: def.format, // code: "invalid_format", // input, // inst, // }); // invalid_type issue payload.issues.push({ expected: origin, format: def.format, code: "invalid_type", continue: false, input, inst, }); return; // not_multiple_of issue // payload.issues.push({ // code: "not_multiple_of", // origin: "number", // input, // inst, // divisor: 1, // }); } if (!Number.isSafeInteger(input)) { if (input > 0) { // too_big payload.issues.push({ input, code: "too_big", maximum: Number.MAX_SAFE_INTEGER, note: "Integers must be within the safe integer range.", inst, origin, continue: !def.abort, }); } else { // too_small payload.issues.push({ input, code: "too_small", minimum: Number.MIN_SAFE_INTEGER, note: "Integers must be within the safe integer range.", inst, origin, continue: !def.abort, }); } return; } } if (input < minimum) { payload.issues.push({ origin: "number", input, code: "too_small", minimum, inclusive: true, inst, continue: !def.abort, }); } if (input > maximum) { payload.issues.push({ origin: "number", input, code: "too_big", maximum, inst, }); } }; }); exports.$ZodCheckBigIntFormat = core.$constructor("$ZodCheckBigIntFormat", (inst, def) => { exports.$ZodCheck.init(inst, def); // no format checks const [minimum, maximum] = util.BIGINT_FORMAT_RANGES[def.format]; inst._zod.onattach.push((inst) => { const bag = inst._zod.bag; bag.format = def.format; bag.minimum = minimum; bag.maximum = maximum; }); inst._zod.check = (payload) => { const input = payload.value; if (input < minimum) { payload.issues.push({ origin: "bigint", input, code: "too_small", minimum: minimum, inclusive: true, inst, continue: !def.abort, }); } if (input > maximum) { payload.issues.push({ origin: "bigint", input, code: "too_big", maximum, inst, }); } }; }); exports.$ZodCheckMaxSize = core.$constructor("$ZodCheckMaxSize", (inst, def) => { var _a; exports.$ZodCheck.init(inst, def); (_a = inst._zod.def).when ?? (_a.when = (payload) => { const val = payload.value; return !util.nullish(val) && val.size !== undefined; }); inst._zod.onattach.push((inst) => { const curr = (inst._zod.bag.maximum ?? Number.POSITIVE_INFINITY); if (def.maximum < curr) inst._zod.bag.maximum = def.maximum; }); inst._zod.check = (payload) => { const input = payload.value; const size = input.size; if (size <= def.maximum) return; payload.issues.push({ origin: util.getSizableOrigin(input), code: "too_big", maximum: def.maximum, input, inst, continue: !def.abort, }); }; }); exports.$ZodCheckMinSize = core.$constructor("$ZodCheckMinSize", (inst, def) => { var _a; exports.$ZodCheck.init(inst, def); (_a = inst._zod.def).when ?? (_a.when = (payload) => { const val = payload.value; return !util.nullish(val) && val.size !== undefined; }); inst._zod.onattach.push((inst) => { const curr = (inst._zod.bag.minimum ?? Number.NEGATIVE_INFINITY); if (def.minimum > curr) inst._zod.bag.minimum = def.minimum; }); inst._zod.check = (payload) => { const input = payload.value; const size = input.size; if (size >= def.minimum) return; payload.issues.push({ origin: util.getSizableOrigin(input), code: "too_small", minimum: def.minimum, input, inst, continue: !def.abort, }); }; }); exports.$ZodCheckSizeEquals = core.$constructor("$ZodCheckSizeEquals", (inst, def) => { var _a; exports.$ZodCheck.init(inst, def); (_a = inst._zod.def).when ?? (_a.when = (payload) => { const val = payload.value; return !util.nullish(val) && val.size !== undefined; }); inst._zod.onattach.push((inst) => { const bag = inst._zod.bag; bag.minimum = def.size; bag.maximum = def.size; bag.size = def.size; }); inst._zod.check = (payload) => { const input = payload.value; const size = input.size; if (size === def.size) return; const tooBig = size > def.size; payload.issues.push({ origin: util.getSizableOrigin(input), ...(tooBig ? { code: "too_big", maximum: def.size } : { code: "too_small", minimum: def.size }), inclusive: true, exact: true, input: payload.value, inst, continue: !def.abort, }); }; }); exports.$ZodCheckMaxLength = core.$constructor("$ZodCheckMaxLength", (inst, def) => { var _a; exports.$ZodCheck.init(inst, def); (_a = inst._zod.def).when ?? (_a.when = (payload) => { const val = payload.value; return !util.nullish(val) && val.length !== undefined; }); inst._zod.onattach.push((inst) => { const curr = (inst._zod.bag.maximum ?? Number.POSITIVE_INFINITY); if (def.maximum < curr) inst._zod.bag.maximum = def.maximum; }); inst._zod.check = (payload) => { const input = payload.value; const length = input.length; if (length <= def.maximum) return; const origin = util.getLengthableOrigin(input); payload.issues.push({ origin, code: "too_big", maximum: def.maximum, inclusive: true, input, inst, continue: !def.abort, }); }; }); exports.$ZodCheckMinLength = core.$constructor("$ZodCheckMinLength", (inst, def) => { var _a; exports.$ZodCheck.init(inst, def); (_a = inst._zod.def).when ?? (_a.when = (payload) => { const val = payload.value; return !util.nullish(val) && val.length !== undefined; }); inst._zod.onattach.push((inst) => { const curr = (inst._zod.bag.minimum ?? Number.NEGATIVE_INFINITY); if (def.minimum > curr) inst._zod.bag.minimum = def.minimum; }); inst._zod.check = (payload) => { const input = payload.value; const length = input.length; if (length >= def.minimum) return; const origin = util.getLengthableOrigin(input); payload.issues.push({ origin, code: "too_small", minimum: def.minimum, inclusive: true, input, inst, continue: !def.abort, }); }; }); exports.$ZodCheckLengthEquals = core.$constructor("$ZodCheckLengthEquals", (inst, def) => { var _a; exports.$ZodCheck.init(inst, def); (_a = inst._zod.def).when ?? (_a.when = (payload) => { const val = payload.value; return !util.nullish(val) && val.length !== undefined; }); inst._zod.onattach.push((inst) => { const bag = inst._zod.bag; bag.minimum = def.length; bag.maximum = def.length; bag.length = def.length; }); inst._zod.check = (payload) => { const input = payload.value; const length = input.length; if (length === def.length) return; const origin = util.getLengthableOrigin(input); const tooBig = length > def.length; payload.issues.push({ origin, ...(tooBig ? { code: "too_big", maximum: def.length } : { code: "too_small", minimum: def.length }), inclusive: true, exact: true, input: payload.value, inst, continue: !def.abort, }); }; }); exports.$ZodCheckStringFormat = core.$constructor("$ZodCheckStringFormat", (inst, def) => { var _a, _b; exports.$ZodCheck.init(inst, def); inst._zod.onattach.push((inst) => { const bag = inst._zod.bag; bag.format = def.format; if (def.pattern) { bag.patterns ?? (bag.patterns = new Set()); bag.patterns.add(def.pattern); } }); if (def.pattern) (_a = inst._zod).check ?? (_a.check = (payload) => { def.pattern.lastIndex = 0; if (def.pattern.test(payload.value)) return; payload.issues.push({ origin: "string", code: "invalid_format", format: def.format, input: payload.value, ...(def.pattern ? { pattern: def.pattern.toString() } : {}), inst, continue: !def.abort, }); }); else (_b = inst._zod).check ?? (_b.check = () => { }); }); exports.$ZodCheckRegex = core.$constructor("$ZodCheckRegex", (inst, def) => { exports.$ZodCheckStringFormat.init(inst, def); inst._zod.check = (payload) => { def.pattern.lastIndex = 0; if (def.pattern.test(payload.value)) return; payload.issues.push({ origin: "string", code: "invalid_format", format: "regex", input: payload.value, pattern: def.pattern.toString(), inst, continue: !def.abort, }); }; }); exports.$ZodCheckLowerCase = core.$constructor("$ZodCheckLowerCase", (inst, def) => { def.pattern ?? (def.pattern = regexes.lowercase); exports.$ZodCheckStringFormat.init(inst, def); }); exports.$ZodCheckUpperCase = core.$constructor("$ZodCheckUpperCase", (inst, def) => { def.pattern ?? (def.pattern = regexes.uppercase); exports.$ZodCheckStringFormat.init(inst, def); }); exports.$ZodCheckIncludes = core.$constructor("$ZodCheckIncludes", (inst, def) => { exports.$ZodCheck.init(inst, def); const escapedRegex = util.escapeRegex(def.includes); const pattern = new RegExp(typeof def.position === "number" ? `^.{${def.position}}${escapedRegex}` : escapedRegex); def.pattern = pattern; inst._zod.onattach.push((inst) => { const bag = inst._zod.bag; bag.patterns ?? (bag.patterns = new Set()); bag.patterns.add(pattern); }); inst._zod.check = (payload) => { if (payload.value.includes(def.includes, def.position)) return; payload.issues.push({ origin: "string", code: "invalid_format", format: "includes", includes: def.includes, input: payload.value, inst, continue: !def.abort, }); }; }); exports.$ZodCheckStartsWith = core.$constructor("$ZodCheckStartsWith", (inst, def) => { exports.$ZodCheck.init(inst, def); const pattern = new RegExp(`^${util.escapeRegex(def.prefix)}.*`); def.pattern ?? (def.pattern = pattern); inst._zod.onattach.push((inst) => { const bag = inst._zod.bag; bag.patterns ?? (bag.patterns = new Set()); bag.patterns.add(pattern); }); inst._zod.check = (payload) => { if (payload.value.startsWith(def.prefix)) return; payload.issues.push({ origin: "string", code: "invalid_format", format: "starts_with", prefix: def.prefix, input: payload.value, inst, continue: !def.abort, }); }; }); exports.$ZodCheckEndsWith = core.$constructor("$ZodCheckEndsWith", (inst, def) => { exports.$ZodCheck.init(inst, def); const pattern = new RegExp(`.*${util.escapeRegex(def.suffix)}$`); def.pattern ?? (def.pattern = pattern); inst._zod.onattach.push((inst) => { const bag = inst._zod.bag; bag.patterns ?? (bag.patterns = new Set()); bag.patterns.add(pattern); }); inst._zod.check = (payload) => { if (payload.value.endsWith(def.suffix)) return; payload.issues.push({ origin: "string", code: "invalid_format", format: "ends_with", suffix: def.suffix, input: payload.value, inst, continue: !def.abort, }); }; }); /////////////////////////////////// ///// $ZodCheckProperty ///// /////////////////////////////////// function handleCheckPropertyResult(result, payload, property) { if (result.issues.length) { payload.issues.push(...util.prefixIssues(property, result.issues)); } } exports.$ZodCheckProperty = core.$constructor("$ZodCheckProperty", (inst, def) => { exports.$ZodCheck.init(inst, def); inst._zod.check = (payload) => { const result = def.schema._zod.run({ value: payload.value[def.property], issues: [], }, {}); if (result instanceof Promise) { return result.then((result) => handleCheckPropertyResult(result, payload, def.property)); } handleCheckPropertyResult(result, payload, def.property); return; }; }); exports.$ZodCheckMimeType = core.$constructor("$ZodCheckMimeType", (inst, def) => { exports.$ZodCheck.init(inst, def); const mimeSet = new Set(def.mime); inst._zod.onattach.push((inst) => { inst._zod.bag.mime = def.mime; }); inst._zod.check = (payload) => { if (mimeSet.has(payload.value.type)) return; payload.issues.push({ code: "invalid_value", values: def.mime, input: payload.value.type, inst, continue: !def.abort, }); }; }); exports.$ZodCheckOverwrite = core.$constructor("$ZodCheckOverwrite", (inst, def) => { exports.$ZodCheck.init(inst, def); inst._zod.check = (payload) => { payload.value = def.tx(payload.value); }; });