| "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", |
| 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, |
| }); |
| }; |
| }); |
| exports.$ZodCheckOverwrite = core.$constructor("$ZodCheckOverwrite", (inst, def) => { |
| exports.$ZodCheck.init(inst, def); |
| inst._zod.check = (payload) => { |
| payload.value = def.tx(payload.value); |
| }; |
| }); |
