517 lines
19 KiB
JavaScript
517 lines
19 KiB
JavaScript
// import { $ZodType } from "./schemas.js";
|
|
import * as core from "./core.js";
|
|
import * as regexes from "./regexes.js";
|
|
import * as util from "./util.js";
|
|
export const $ZodCheck = /*@__PURE__*/ core.$constructor("$ZodCheck", (inst, def) => {
|
|
var _a;
|
|
inst._zod ?? (inst._zod = {});
|
|
inst._zod.def = def;
|
|
(_a = inst._zod).onattach ?? (_a.onattach = []);
|
|
});
|
|
/** Default `when` for size-based checks: run only on non-nullish values with a `size`. */
|
|
const _whenHasSize = (payload) => {
|
|
const val = payload.value;
|
|
return !util.nullish(val) && val.size !== undefined;
|
|
};
|
|
/** Default `when` for length-based checks: run only on non-nullish values with a `length`. */
|
|
const _whenHasLength = (payload) => {
|
|
const val = payload.value;
|
|
return !util.nullish(val) && val.length !== undefined;
|
|
};
|
|
const numericOriginMap = {
|
|
number: "number",
|
|
bigint: "bigint",
|
|
object: "date",
|
|
};
|
|
export const $ZodCheckLessThan = /*@__PURE__*/ core.$constructor("$ZodCheckLessThan", (inst, def) => {
|
|
$ZodCheck.init(inst, def);
|
|
const origin = numericOriginMap[typeof def.value];
|
|
inst._zod.check = (payload) => {
|
|
if (def.inclusive ? payload.value <= def.value : payload.value < def.value) {
|
|
return;
|
|
}
|
|
payload.issues.push({
|
|
origin: numericOriginMap[typeof payload.value] ?? origin,
|
|
code: "too_big",
|
|
maximum: typeof def.value === "object" ? def.value.getTime() : def.value,
|
|
input: payload.value,
|
|
inclusive: def.inclusive,
|
|
inst,
|
|
continue: !def.abort,
|
|
});
|
|
};
|
|
});
|
|
export const $ZodCheckGreaterThan = /*@__PURE__*/ core.$constructor("$ZodCheckGreaterThan", (inst, def) => {
|
|
$ZodCheck.init(inst, def);
|
|
const origin = numericOriginMap[typeof def.value];
|
|
inst._zod.check = (payload) => {
|
|
if (def.inclusive ? payload.value >= def.value : payload.value > def.value) {
|
|
return;
|
|
}
|
|
payload.issues.push({
|
|
origin: numericOriginMap[typeof payload.value] ?? origin,
|
|
code: "too_small",
|
|
minimum: typeof def.value === "object" ? def.value.getTime() : def.value,
|
|
input: payload.value,
|
|
inclusive: def.inclusive,
|
|
inst,
|
|
continue: !def.abort,
|
|
});
|
|
};
|
|
});
|
|
export const $ZodCheckMultipleOf =
|
|
/*@__PURE__*/ core.$constructor("$ZodCheckMultipleOf", (inst, def) => {
|
|
$ZodCheck.init(inst, def);
|
|
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"
|
|
? // `value % 0n` throws, and nothing is a multiple of zero — the number branch already fails this way via NaN
|
|
def.value !== BigInt(0) && 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,
|
|
});
|
|
};
|
|
});
|
|
export const $ZodCheckNumberFormat = /*@__PURE__*/ core.$constructor("$ZodCheckNumberFormat", (inst, def) => {
|
|
$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.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,
|
|
inclusive: true,
|
|
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,
|
|
inclusive: true,
|
|
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,
|
|
inclusive: true,
|
|
inst,
|
|
continue: !def.abort,
|
|
});
|
|
}
|
|
};
|
|
});
|
|
export const $ZodCheckBigIntFormat = /*@__PURE__*/ core.$constructor("$ZodCheckBigIntFormat", (inst, def) => {
|
|
$ZodCheck.init(inst, def); // no format checks
|
|
const [minimum, maximum] = util.BIGINT_FORMAT_RANGES[def.format];
|
|
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,
|
|
inclusive: true,
|
|
inst,
|
|
continue: !def.abort,
|
|
});
|
|
}
|
|
};
|
|
});
|
|
export const $ZodCheckMaxSize = /*@__PURE__*/ core.$constructor("$ZodCheckMaxSize", (inst, def) => {
|
|
var _a;
|
|
$ZodCheck.init(inst, def);
|
|
(_a = inst._zod.def).when ?? (_a.when = _whenHasSize);
|
|
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,
|
|
inclusive: true,
|
|
input,
|
|
inst,
|
|
continue: !def.abort,
|
|
});
|
|
};
|
|
});
|
|
export const $ZodCheckMinSize = /*@__PURE__*/ core.$constructor("$ZodCheckMinSize", (inst, def) => {
|
|
var _a;
|
|
$ZodCheck.init(inst, def);
|
|
(_a = inst._zod.def).when ?? (_a.when = _whenHasSize);
|
|
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,
|
|
inclusive: true,
|
|
input,
|
|
inst,
|
|
continue: !def.abort,
|
|
});
|
|
};
|
|
});
|
|
export const $ZodCheckSizeEquals = /*@__PURE__*/ core.$constructor("$ZodCheckSizeEquals", (inst, def) => {
|
|
var _a;
|
|
$ZodCheck.init(inst, def);
|
|
(_a = inst._zod.def).when ?? (_a.when = _whenHasSize);
|
|
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,
|
|
});
|
|
};
|
|
});
|
|
export const $ZodCheckMaxLength = /*@__PURE__*/ core.$constructor("$ZodCheckMaxLength", (inst, def) => {
|
|
var _a;
|
|
$ZodCheck.init(inst, def);
|
|
(_a = inst._zod.def).when ?? (_a.when = _whenHasLength);
|
|
inst._zod.check = (payload) => {
|
|
const input = payload.value;
|
|
const units = input.length;
|
|
// Strings are measured in Unicode code points, not UTF-16 units. A code point is at most two units, so a string that already fits in units fits in code points; only an overflow has to be counted.
|
|
const length = typeof input === "string" && units > def.maximum ? util.codePointLength(input) : units;
|
|
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,
|
|
});
|
|
};
|
|
});
|
|
export const $ZodCheckMinLength = /*@__PURE__*/ core.$constructor("$ZodCheckMinLength", (inst, def) => {
|
|
var _a;
|
|
$ZodCheck.init(inst, def);
|
|
(_a = inst._zod.def).when ?? (_a.when = _whenHasLength);
|
|
inst._zod.check = (payload) => {
|
|
const input = payload.value;
|
|
const units = input.length;
|
|
// A code point is one or two UTF-16 units, so fewer units than the floor can never reach it and twice the floor always clears it. Only in between is the exact count in doubt.
|
|
const length = typeof input === "string" && units >= def.minimum && units < def.minimum * 2
|
|
? util.codePointLength(input)
|
|
: units;
|
|
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,
|
|
});
|
|
};
|
|
});
|
|
export const $ZodCheckLengthEquals = /*@__PURE__*/ core.$constructor("$ZodCheckLengthEquals", (inst, def) => {
|
|
var _a;
|
|
$ZodCheck.init(inst, def);
|
|
(_a = inst._zod.def).when ?? (_a.when = _whenHasLength);
|
|
inst._zod.check = (payload) => {
|
|
const input = payload.value;
|
|
const units = input.length;
|
|
// A code point is one or two UTF-16 units, so outside `[length, length * 2]` units the target is missed either way — and missed in the same direction in both measures.
|
|
const length = typeof input === "string" && units >= def.length && units <= def.length * 2
|
|
? util.codePointLength(input)
|
|
: units;
|
|
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,
|
|
});
|
|
};
|
|
});
|
|
export const $ZodCheckStringFormat = /*@__PURE__*/ core.$constructor("$ZodCheckStringFormat", (inst, def) => {
|
|
var _a, _b;
|
|
$ZodCheck.init(inst, def);
|
|
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 = () => { });
|
|
});
|
|
export const $ZodCheckRegex = /*@__PURE__*/ core.$constructor("$ZodCheckRegex", (inst, def) => {
|
|
$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,
|
|
});
|
|
};
|
|
});
|
|
export const $ZodCheckLowerCase = /*@__PURE__*/ core.$constructor("$ZodCheckLowerCase", (inst, def) => {
|
|
def.pattern ?? (def.pattern = regexes.lowercase);
|
|
$ZodCheckStringFormat.init(inst, def);
|
|
});
|
|
export const $ZodCheckUpperCase = /*@__PURE__*/ core.$constructor("$ZodCheckUpperCase", (inst, def) => {
|
|
def.pattern ?? (def.pattern = regexes.uppercase);
|
|
$ZodCheckStringFormat.init(inst, def);
|
|
});
|
|
export const $ZodCheckIncludes = /*@__PURE__*/ core.$constructor("$ZodCheckIncludes", (inst, def) => {
|
|
$ZodCheck.init(inst, def);
|
|
const escapedRegex = util.escapeRegex(def.includes);
|
|
// `String.prototype.includes(sub, position)` matches `sub` at `position`
|
|
// OR LATER, so the pattern must allow at least `position` leading chars
|
|
// (`{N,}`), not exactly `position` chars (`{N}`).
|
|
const pattern = new RegExp(typeof def.position === "number" ? `^.{${def.position},}${escapedRegex}` : escapedRegex);
|
|
def.pattern = 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,
|
|
});
|
|
};
|
|
});
|
|
export const $ZodCheckStartsWith = /*@__PURE__*/ core.$constructor("$ZodCheckStartsWith", (inst, def) => {
|
|
$ZodCheck.init(inst, def);
|
|
const pattern = new RegExp(`^${util.escapeRegex(def.prefix)}.*`);
|
|
def.pattern ?? (def.pattern = 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,
|
|
});
|
|
};
|
|
});
|
|
export const $ZodCheckEndsWith = /*@__PURE__*/ core.$constructor("$ZodCheckEndsWith", (inst, def) => {
|
|
$ZodCheck.init(inst, def);
|
|
const pattern = new RegExp(`.*${util.escapeRegex(def.suffix)}$`);
|
|
def.pattern ?? (def.pattern = 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));
|
|
}
|
|
}
|
|
export const $ZodCheckProperty = /*@__PURE__*/ core.$constructor("$ZodCheckProperty", (inst, def) => {
|
|
$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;
|
|
};
|
|
});
|
|
export const $ZodCheckProperties = /*@__PURE__*/ core.$constructor("$ZodCheckProperties", (inst, def) => {
|
|
$ZodCheck.init(inst, def);
|
|
util.hide(inst, Symbol.iterator, function* () {
|
|
yield inst;
|
|
});
|
|
// key and schema snapshotted together: reading one live and the other cached lets a later mutation of the caller's shape object pair a stale key with a missing schema
|
|
let entries;
|
|
inst._zod.check = (payload) => {
|
|
// the base schema already typed the value, so only a nullish one is rejected here: the properties read on a primitive too, matching z.property() on a string's length
|
|
if (payload.value == null) {
|
|
payload.issues.push({ expected: "object", code: "invalid_type", input: payload.value, inst });
|
|
return undefined;
|
|
}
|
|
entries ?? (entries = Reflect.ownKeys(def.shape).map((key) => [key, def.shape[key]]));
|
|
const input = payload.value;
|
|
let proms;
|
|
for (const [key, schema] of entries) {
|
|
const result = schema._zod.run({ value: input[key], issues: [] }, {});
|
|
if (result instanceof Promise) {
|
|
proms ?? (proms = []);
|
|
proms.push(result.then((result) => handleCheckPropertyResult(result, payload, key)));
|
|
}
|
|
else {
|
|
handleCheckPropertyResult(result, payload, key);
|
|
}
|
|
}
|
|
if (proms)
|
|
return Promise.all(proms).then(() => undefined);
|
|
return undefined;
|
|
};
|
|
});
|
|
export const $ZodCheckMimeType = /*@__PURE__*/ core.$constructor("$ZodCheckMimeType", (inst, def) => {
|
|
$ZodCheck.init(inst, def);
|
|
const mimeSet = new Set(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,
|
|
});
|
|
};
|
|
});
|
|
export const $ZodCheckOverwrite = /*@__PURE__*/ core.$constructor("$ZodCheckOverwrite", (inst, def) => {
|
|
$ZodCheck.init(inst, def);
|
|
inst._zod.check = (payload) => {
|
|
payload.value = def.tx(payload.value);
|
|
};
|
|
});
|