1987 lines
72 KiB
JavaScript
1987 lines
72 KiB
JavaScript
"use strict";
|
|
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.$ZodMap = exports.$ZodRecord = exports.$ZodTuple = exports.$ZodIntersection = exports.$ZodDiscriminatedUnion = exports.$ZodUnion = exports.$ZodObjectJIT = exports.$ZodObject = exports.$ZodArray = exports.$ZodDate = exports.$ZodVoid = exports.$ZodNever = exports.$ZodUnknown = exports.$ZodAny = exports.$ZodNull = exports.$ZodUndefined = exports.$ZodSymbol = exports.$ZodBigIntFormat = exports.$ZodBigInt = exports.$ZodBoolean = exports.$ZodNumberFormat = exports.$ZodNumber = exports.$ZodCustomStringFormat = exports.$ZodJWT = exports.$ZodE164 = exports.$ZodBase64URL = exports.$ZodBase64 = exports.$ZodCIDRv6 = exports.$ZodCIDRv4 = exports.$ZodIPv6 = exports.$ZodIPv4 = exports.$ZodISODuration = exports.$ZodISOTime = exports.$ZodISODate = exports.$ZodISODateTime = exports.$ZodKSUID = exports.$ZodXID = exports.$ZodULID = exports.$ZodCUID2 = exports.$ZodCUID = exports.$ZodNanoID = exports.$ZodEmoji = exports.$ZodURL = exports.$ZodEmail = exports.$ZodUUID = exports.$ZodGUID = exports.$ZodStringFormat = exports.$ZodString = exports.clone = exports.$ZodType = void 0;
|
|
exports.$ZodCustom = exports.$ZodLazy = exports.$ZodPromise = exports.$ZodFunction = exports.$ZodTemplateLiteral = exports.$ZodReadonly = exports.$ZodCodec = exports.$ZodPipe = exports.$ZodNaN = exports.$ZodCatch = exports.$ZodSuccess = exports.$ZodNonOptional = exports.$ZodPrefault = exports.$ZodDefault = exports.$ZodNullable = exports.$ZodOptional = exports.$ZodTransform = exports.$ZodFile = exports.$ZodLiteral = exports.$ZodEnum = exports.$ZodSet = void 0;
|
|
exports.isValidBase64 = isValidBase64;
|
|
exports.isValidBase64URL = isValidBase64URL;
|
|
exports.isValidJWT = isValidJWT;
|
|
const checks = __importStar(require("./checks.cjs"));
|
|
const core = __importStar(require("./core.cjs"));
|
|
const doc_js_1 = require("./doc.cjs");
|
|
const parse_js_1 = require("./parse.cjs");
|
|
const regexes = __importStar(require("./regexes.cjs"));
|
|
const util = __importStar(require("./util.cjs"));
|
|
const versions_js_1 = require("./versions.cjs");
|
|
exports.$ZodType = core.$constructor("$ZodType", (inst, def) => {
|
|
var _a;
|
|
inst ?? (inst = {});
|
|
inst._zod.def = def; // set _def property
|
|
inst._zod.bag = inst._zod.bag || {}; // initialize _bag object
|
|
inst._zod.version = versions_js_1.version;
|
|
const checks = [...(inst._zod.def.checks ?? [])];
|
|
// if inst is itself a checks.$ZodCheck, run it as a check
|
|
if (inst._zod.traits.has("$ZodCheck")) {
|
|
checks.unshift(inst);
|
|
}
|
|
for (const ch of checks) {
|
|
for (const fn of ch._zod.onattach) {
|
|
fn(inst);
|
|
}
|
|
}
|
|
if (checks.length === 0) {
|
|
// deferred initializer
|
|
// inst._zod.parse is not yet defined
|
|
(_a = inst._zod).deferred ?? (_a.deferred = []);
|
|
inst._zod.deferred?.push(() => {
|
|
inst._zod.run = inst._zod.parse;
|
|
});
|
|
}
|
|
else {
|
|
const runChecks = (payload, checks, ctx) => {
|
|
let isAborted = util.aborted(payload);
|
|
let asyncResult;
|
|
for (const ch of checks) {
|
|
if (ch._zod.def.when) {
|
|
const shouldRun = ch._zod.def.when(payload);
|
|
if (!shouldRun)
|
|
continue;
|
|
}
|
|
else if (isAborted) {
|
|
continue;
|
|
}
|
|
const currLen = payload.issues.length;
|
|
const _ = ch._zod.check(payload);
|
|
if (_ instanceof Promise && ctx?.async === false) {
|
|
throw new core.$ZodAsyncError();
|
|
}
|
|
if (asyncResult || _ instanceof Promise) {
|
|
asyncResult = (asyncResult ?? Promise.resolve()).then(async () => {
|
|
await _;
|
|
const nextLen = payload.issues.length;
|
|
if (nextLen === currLen)
|
|
return;
|
|
if (!isAborted)
|
|
isAborted = util.aborted(payload, currLen);
|
|
});
|
|
}
|
|
else {
|
|
const nextLen = payload.issues.length;
|
|
if (nextLen === currLen)
|
|
continue;
|
|
if (!isAborted)
|
|
isAborted = util.aborted(payload, currLen);
|
|
}
|
|
}
|
|
if (asyncResult) {
|
|
return asyncResult.then(() => {
|
|
return payload;
|
|
});
|
|
}
|
|
return payload;
|
|
};
|
|
// const handleChecksResult = (
|
|
// checkResult: ParsePayload,
|
|
// originalResult: ParsePayload,
|
|
// ctx: ParseContextInternal
|
|
// ): util.MaybeAsync<ParsePayload> => {
|
|
// // if the checks mutated the value && there are no issues, re-parse the result
|
|
// if (checkResult.value !== originalResult.value && !checkResult.issues.length)
|
|
// return inst._zod.parse(checkResult, ctx);
|
|
// return originalResult;
|
|
// };
|
|
const handleCanaryResult = (canary, payload, ctx) => {
|
|
// abort if the canary is aborted
|
|
if (util.aborted(canary)) {
|
|
canary.aborted = true;
|
|
return canary;
|
|
}
|
|
// run checks first, then
|
|
const checkResult = runChecks(payload, checks, ctx);
|
|
if (checkResult instanceof Promise) {
|
|
if (ctx.async === false)
|
|
throw new core.$ZodAsyncError();
|
|
return checkResult.then((checkResult) => inst._zod.parse(checkResult, ctx));
|
|
}
|
|
return inst._zod.parse(checkResult, ctx);
|
|
};
|
|
inst._zod.run = (payload, ctx) => {
|
|
if (ctx.skipChecks) {
|
|
return inst._zod.parse(payload, ctx);
|
|
}
|
|
if (ctx.direction === "backward") {
|
|
// run canary
|
|
// initial pass (no checks)
|
|
const canary = inst._zod.parse({ value: payload.value, issues: [] }, { ...ctx, skipChecks: true });
|
|
if (canary instanceof Promise) {
|
|
return canary.then((canary) => {
|
|
return handleCanaryResult(canary, payload, ctx);
|
|
});
|
|
}
|
|
return handleCanaryResult(canary, payload, ctx);
|
|
}
|
|
// forward
|
|
const result = inst._zod.parse(payload, ctx);
|
|
if (result instanceof Promise) {
|
|
if (ctx.async === false)
|
|
throw new core.$ZodAsyncError();
|
|
return result.then((result) => runChecks(result, checks, ctx));
|
|
}
|
|
return runChecks(result, checks, ctx);
|
|
};
|
|
}
|
|
inst["~standard"] = {
|
|
validate: (value) => {
|
|
try {
|
|
const r = (0, parse_js_1.safeParse)(inst, value);
|
|
return r.success ? { value: r.data } : { issues: r.error?.issues };
|
|
}
|
|
catch (_) {
|
|
return (0, parse_js_1.safeParseAsync)(inst, value).then((r) => (r.success ? { value: r.data } : { issues: r.error?.issues }));
|
|
}
|
|
},
|
|
vendor: "zod",
|
|
version: 1,
|
|
};
|
|
});
|
|
var util_js_1 = require("./util.cjs");
|
|
Object.defineProperty(exports, "clone", { enumerable: true, get: function () { return util_js_1.clone; } });
|
|
exports.$ZodString = core.$constructor("$ZodString", (inst, def) => {
|
|
exports.$ZodType.init(inst, def);
|
|
inst._zod.pattern = [...(inst?._zod.bag?.patterns ?? [])].pop() ?? regexes.string(inst._zod.bag);
|
|
inst._zod.parse = (payload, _) => {
|
|
if (def.coerce)
|
|
try {
|
|
payload.value = String(payload.value);
|
|
}
|
|
catch (_) { }
|
|
if (typeof payload.value === "string")
|
|
return payload;
|
|
payload.issues.push({
|
|
expected: "string",
|
|
code: "invalid_type",
|
|
input: payload.value,
|
|
inst,
|
|
});
|
|
return payload;
|
|
};
|
|
});
|
|
exports.$ZodStringFormat = core.$constructor("$ZodStringFormat", (inst, def) => {
|
|
// check initialization must come first
|
|
checks.$ZodCheckStringFormat.init(inst, def);
|
|
exports.$ZodString.init(inst, def);
|
|
});
|
|
exports.$ZodGUID = core.$constructor("$ZodGUID", (inst, def) => {
|
|
def.pattern ?? (def.pattern = regexes.guid);
|
|
exports.$ZodStringFormat.init(inst, def);
|
|
});
|
|
exports.$ZodUUID = core.$constructor("$ZodUUID", (inst, def) => {
|
|
if (def.version) {
|
|
const versionMap = {
|
|
v1: 1,
|
|
v2: 2,
|
|
v3: 3,
|
|
v4: 4,
|
|
v5: 5,
|
|
v6: 6,
|
|
v7: 7,
|
|
v8: 8,
|
|
};
|
|
const v = versionMap[def.version];
|
|
if (v === undefined)
|
|
throw new Error(`Invalid UUID version: "${def.version}"`);
|
|
def.pattern ?? (def.pattern = regexes.uuid(v));
|
|
}
|
|
else
|
|
def.pattern ?? (def.pattern = regexes.uuid());
|
|
exports.$ZodStringFormat.init(inst, def);
|
|
});
|
|
exports.$ZodEmail = core.$constructor("$ZodEmail", (inst, def) => {
|
|
def.pattern ?? (def.pattern = regexes.email);
|
|
exports.$ZodStringFormat.init(inst, def);
|
|
});
|
|
exports.$ZodURL = core.$constructor("$ZodURL", (inst, def) => {
|
|
exports.$ZodStringFormat.init(inst, def);
|
|
inst._zod.check = (payload) => {
|
|
try {
|
|
// Trim whitespace from input
|
|
const trimmed = payload.value.trim();
|
|
// @ts-ignore
|
|
const url = new URL(trimmed);
|
|
if (def.hostname) {
|
|
def.hostname.lastIndex = 0;
|
|
if (!def.hostname.test(url.hostname)) {
|
|
payload.issues.push({
|
|
code: "invalid_format",
|
|
format: "url",
|
|
note: "Invalid hostname",
|
|
pattern: regexes.hostname.source,
|
|
input: payload.value,
|
|
inst,
|
|
continue: !def.abort,
|
|
});
|
|
}
|
|
}
|
|
if (def.protocol) {
|
|
def.protocol.lastIndex = 0;
|
|
if (!def.protocol.test(url.protocol.endsWith(":") ? url.protocol.slice(0, -1) : url.protocol)) {
|
|
payload.issues.push({
|
|
code: "invalid_format",
|
|
format: "url",
|
|
note: "Invalid protocol",
|
|
pattern: def.protocol.source,
|
|
input: payload.value,
|
|
inst,
|
|
continue: !def.abort,
|
|
});
|
|
}
|
|
}
|
|
// Set the output value based on normalize flag
|
|
if (def.normalize) {
|
|
// Use normalized URL
|
|
payload.value = url.href;
|
|
}
|
|
else {
|
|
// Preserve the original input (trimmed)
|
|
payload.value = trimmed;
|
|
}
|
|
return;
|
|
}
|
|
catch (_) {
|
|
payload.issues.push({
|
|
code: "invalid_format",
|
|
format: "url",
|
|
input: payload.value,
|
|
inst,
|
|
continue: !def.abort,
|
|
});
|
|
}
|
|
};
|
|
});
|
|
exports.$ZodEmoji = core.$constructor("$ZodEmoji", (inst, def) => {
|
|
def.pattern ?? (def.pattern = regexes.emoji());
|
|
exports.$ZodStringFormat.init(inst, def);
|
|
});
|
|
exports.$ZodNanoID = core.$constructor("$ZodNanoID", (inst, def) => {
|
|
def.pattern ?? (def.pattern = regexes.nanoid);
|
|
exports.$ZodStringFormat.init(inst, def);
|
|
});
|
|
exports.$ZodCUID = core.$constructor("$ZodCUID", (inst, def) => {
|
|
def.pattern ?? (def.pattern = regexes.cuid);
|
|
exports.$ZodStringFormat.init(inst, def);
|
|
});
|
|
exports.$ZodCUID2 = core.$constructor("$ZodCUID2", (inst, def) => {
|
|
def.pattern ?? (def.pattern = regexes.cuid2);
|
|
exports.$ZodStringFormat.init(inst, def);
|
|
});
|
|
exports.$ZodULID = core.$constructor("$ZodULID", (inst, def) => {
|
|
def.pattern ?? (def.pattern = regexes.ulid);
|
|
exports.$ZodStringFormat.init(inst, def);
|
|
});
|
|
exports.$ZodXID = core.$constructor("$ZodXID", (inst, def) => {
|
|
def.pattern ?? (def.pattern = regexes.xid);
|
|
exports.$ZodStringFormat.init(inst, def);
|
|
});
|
|
exports.$ZodKSUID = core.$constructor("$ZodKSUID", (inst, def) => {
|
|
def.pattern ?? (def.pattern = regexes.ksuid);
|
|
exports.$ZodStringFormat.init(inst, def);
|
|
});
|
|
exports.$ZodISODateTime = core.$constructor("$ZodISODateTime", (inst, def) => {
|
|
def.pattern ?? (def.pattern = regexes.datetime(def));
|
|
exports.$ZodStringFormat.init(inst, def);
|
|
});
|
|
exports.$ZodISODate = core.$constructor("$ZodISODate", (inst, def) => {
|
|
def.pattern ?? (def.pattern = regexes.date);
|
|
exports.$ZodStringFormat.init(inst, def);
|
|
});
|
|
exports.$ZodISOTime = core.$constructor("$ZodISOTime", (inst, def) => {
|
|
def.pattern ?? (def.pattern = regexes.time(def));
|
|
exports.$ZodStringFormat.init(inst, def);
|
|
});
|
|
exports.$ZodISODuration = core.$constructor("$ZodISODuration", (inst, def) => {
|
|
def.pattern ?? (def.pattern = regexes.duration);
|
|
exports.$ZodStringFormat.init(inst, def);
|
|
});
|
|
exports.$ZodIPv4 = core.$constructor("$ZodIPv4", (inst, def) => {
|
|
def.pattern ?? (def.pattern = regexes.ipv4);
|
|
exports.$ZodStringFormat.init(inst, def);
|
|
inst._zod.onattach.push((inst) => {
|
|
const bag = inst._zod.bag;
|
|
bag.format = `ipv4`;
|
|
});
|
|
});
|
|
exports.$ZodIPv6 = core.$constructor("$ZodIPv6", (inst, def) => {
|
|
def.pattern ?? (def.pattern = regexes.ipv6);
|
|
exports.$ZodStringFormat.init(inst, def);
|
|
inst._zod.onattach.push((inst) => {
|
|
const bag = inst._zod.bag;
|
|
bag.format = `ipv6`;
|
|
});
|
|
inst._zod.check = (payload) => {
|
|
try {
|
|
// @ts-ignore
|
|
new URL(`http://[${payload.value}]`);
|
|
// return;
|
|
}
|
|
catch {
|
|
payload.issues.push({
|
|
code: "invalid_format",
|
|
format: "ipv6",
|
|
input: payload.value,
|
|
inst,
|
|
continue: !def.abort,
|
|
});
|
|
}
|
|
};
|
|
});
|
|
exports.$ZodCIDRv4 = core.$constructor("$ZodCIDRv4", (inst, def) => {
|
|
def.pattern ?? (def.pattern = regexes.cidrv4);
|
|
exports.$ZodStringFormat.init(inst, def);
|
|
});
|
|
exports.$ZodCIDRv6 = core.$constructor("$ZodCIDRv6", (inst, def) => {
|
|
def.pattern ?? (def.pattern = regexes.cidrv6); // not used for validation
|
|
exports.$ZodStringFormat.init(inst, def);
|
|
inst._zod.check = (payload) => {
|
|
const parts = payload.value.split("/");
|
|
try {
|
|
if (parts.length !== 2)
|
|
throw new Error();
|
|
const [address, prefix] = parts;
|
|
if (!prefix)
|
|
throw new Error();
|
|
const prefixNum = Number(prefix);
|
|
if (`${prefixNum}` !== prefix)
|
|
throw new Error();
|
|
if (prefixNum < 0 || prefixNum > 128)
|
|
throw new Error();
|
|
// @ts-ignore
|
|
new URL(`http://[${address}]`);
|
|
}
|
|
catch {
|
|
payload.issues.push({
|
|
code: "invalid_format",
|
|
format: "cidrv6",
|
|
input: payload.value,
|
|
inst,
|
|
continue: !def.abort,
|
|
});
|
|
}
|
|
};
|
|
});
|
|
////////////////////////////// ZodBase64 //////////////////////////////
|
|
function isValidBase64(data) {
|
|
if (data === "")
|
|
return true;
|
|
if (data.length % 4 !== 0)
|
|
return false;
|
|
try {
|
|
// @ts-ignore
|
|
atob(data);
|
|
return true;
|
|
}
|
|
catch {
|
|
return false;
|
|
}
|
|
}
|
|
exports.$ZodBase64 = core.$constructor("$ZodBase64", (inst, def) => {
|
|
def.pattern ?? (def.pattern = regexes.base64);
|
|
exports.$ZodStringFormat.init(inst, def);
|
|
inst._zod.onattach.push((inst) => {
|
|
inst._zod.bag.contentEncoding = "base64";
|
|
});
|
|
inst._zod.check = (payload) => {
|
|
if (isValidBase64(payload.value))
|
|
return;
|
|
payload.issues.push({
|
|
code: "invalid_format",
|
|
format: "base64",
|
|
input: payload.value,
|
|
inst,
|
|
continue: !def.abort,
|
|
});
|
|
};
|
|
});
|
|
////////////////////////////// ZodBase64 //////////////////////////////
|
|
function isValidBase64URL(data) {
|
|
if (!regexes.base64url.test(data))
|
|
return false;
|
|
const base64 = data.replace(/[-_]/g, (c) => (c === "-" ? "+" : "/"));
|
|
const padded = base64.padEnd(Math.ceil(base64.length / 4) * 4, "=");
|
|
return isValidBase64(padded);
|
|
}
|
|
exports.$ZodBase64URL = core.$constructor("$ZodBase64URL", (inst, def) => {
|
|
def.pattern ?? (def.pattern = regexes.base64url);
|
|
exports.$ZodStringFormat.init(inst, def);
|
|
inst._zod.onattach.push((inst) => {
|
|
inst._zod.bag.contentEncoding = "base64url";
|
|
});
|
|
inst._zod.check = (payload) => {
|
|
if (isValidBase64URL(payload.value))
|
|
return;
|
|
payload.issues.push({
|
|
code: "invalid_format",
|
|
format: "base64url",
|
|
input: payload.value,
|
|
inst,
|
|
continue: !def.abort,
|
|
});
|
|
};
|
|
});
|
|
exports.$ZodE164 = core.$constructor("$ZodE164", (inst, def) => {
|
|
def.pattern ?? (def.pattern = regexes.e164);
|
|
exports.$ZodStringFormat.init(inst, def);
|
|
});
|
|
////////////////////////////// ZodJWT //////////////////////////////
|
|
function isValidJWT(token, algorithm = null) {
|
|
try {
|
|
const tokensParts = token.split(".");
|
|
if (tokensParts.length !== 3)
|
|
return false;
|
|
const [header] = tokensParts;
|
|
if (!header)
|
|
return false;
|
|
// @ts-ignore
|
|
const parsedHeader = JSON.parse(atob(header));
|
|
if ("typ" in parsedHeader && parsedHeader?.typ !== "JWT")
|
|
return false;
|
|
if (!parsedHeader.alg)
|
|
return false;
|
|
if (algorithm && (!("alg" in parsedHeader) || parsedHeader.alg !== algorithm))
|
|
return false;
|
|
return true;
|
|
}
|
|
catch {
|
|
return false;
|
|
}
|
|
}
|
|
exports.$ZodJWT = core.$constructor("$ZodJWT", (inst, def) => {
|
|
exports.$ZodStringFormat.init(inst, def);
|
|
inst._zod.check = (payload) => {
|
|
if (isValidJWT(payload.value, def.alg))
|
|
return;
|
|
payload.issues.push({
|
|
code: "invalid_format",
|
|
format: "jwt",
|
|
input: payload.value,
|
|
inst,
|
|
continue: !def.abort,
|
|
});
|
|
};
|
|
});
|
|
exports.$ZodCustomStringFormat = core.$constructor("$ZodCustomStringFormat", (inst, def) => {
|
|
exports.$ZodStringFormat.init(inst, def);
|
|
inst._zod.check = (payload) => {
|
|
if (def.fn(payload.value))
|
|
return;
|
|
payload.issues.push({
|
|
code: "invalid_format",
|
|
format: def.format,
|
|
input: payload.value,
|
|
inst,
|
|
continue: !def.abort,
|
|
});
|
|
};
|
|
});
|
|
exports.$ZodNumber = core.$constructor("$ZodNumber", (inst, def) => {
|
|
exports.$ZodType.init(inst, def);
|
|
inst._zod.pattern = inst._zod.bag.pattern ?? regexes.number;
|
|
inst._zod.parse = (payload, _ctx) => {
|
|
if (def.coerce)
|
|
try {
|
|
payload.value = Number(payload.value);
|
|
}
|
|
catch (_) { }
|
|
const input = payload.value;
|
|
if (typeof input === "number" && !Number.isNaN(input) && Number.isFinite(input)) {
|
|
return payload;
|
|
}
|
|
const received = typeof input === "number"
|
|
? Number.isNaN(input)
|
|
? "NaN"
|
|
: !Number.isFinite(input)
|
|
? "Infinity"
|
|
: undefined
|
|
: undefined;
|
|
payload.issues.push({
|
|
expected: "number",
|
|
code: "invalid_type",
|
|
input,
|
|
inst,
|
|
...(received ? { received } : {}),
|
|
});
|
|
return payload;
|
|
};
|
|
});
|
|
exports.$ZodNumberFormat = core.$constructor("$ZodNumber", (inst, def) => {
|
|
checks.$ZodCheckNumberFormat.init(inst, def);
|
|
exports.$ZodNumber.init(inst, def); // no format checksp
|
|
});
|
|
exports.$ZodBoolean = core.$constructor("$ZodBoolean", (inst, def) => {
|
|
exports.$ZodType.init(inst, def);
|
|
inst._zod.pattern = regexes.boolean;
|
|
inst._zod.parse = (payload, _ctx) => {
|
|
if (def.coerce)
|
|
try {
|
|
payload.value = Boolean(payload.value);
|
|
}
|
|
catch (_) { }
|
|
const input = payload.value;
|
|
if (typeof input === "boolean")
|
|
return payload;
|
|
payload.issues.push({
|
|
expected: "boolean",
|
|
code: "invalid_type",
|
|
input,
|
|
inst,
|
|
});
|
|
return payload;
|
|
};
|
|
});
|
|
exports.$ZodBigInt = core.$constructor("$ZodBigInt", (inst, def) => {
|
|
exports.$ZodType.init(inst, def);
|
|
inst._zod.pattern = regexes.bigint;
|
|
inst._zod.parse = (payload, _ctx) => {
|
|
if (def.coerce)
|
|
try {
|
|
payload.value = BigInt(payload.value);
|
|
}
|
|
catch (_) { }
|
|
if (typeof payload.value === "bigint")
|
|
return payload;
|
|
payload.issues.push({
|
|
expected: "bigint",
|
|
code: "invalid_type",
|
|
input: payload.value,
|
|
inst,
|
|
});
|
|
return payload;
|
|
};
|
|
});
|
|
exports.$ZodBigIntFormat = core.$constructor("$ZodBigInt", (inst, def) => {
|
|
checks.$ZodCheckBigIntFormat.init(inst, def);
|
|
exports.$ZodBigInt.init(inst, def); // no format checks
|
|
});
|
|
exports.$ZodSymbol = core.$constructor("$ZodSymbol", (inst, def) => {
|
|
exports.$ZodType.init(inst, def);
|
|
inst._zod.parse = (payload, _ctx) => {
|
|
const input = payload.value;
|
|
if (typeof input === "symbol")
|
|
return payload;
|
|
payload.issues.push({
|
|
expected: "symbol",
|
|
code: "invalid_type",
|
|
input,
|
|
inst,
|
|
});
|
|
return payload;
|
|
};
|
|
});
|
|
exports.$ZodUndefined = core.$constructor("$ZodUndefined", (inst, def) => {
|
|
exports.$ZodType.init(inst, def);
|
|
inst._zod.pattern = regexes.undefined;
|
|
inst._zod.values = new Set([undefined]);
|
|
inst._zod.optin = "optional";
|
|
inst._zod.optout = "optional";
|
|
inst._zod.parse = (payload, _ctx) => {
|
|
const input = payload.value;
|
|
if (typeof input === "undefined")
|
|
return payload;
|
|
payload.issues.push({
|
|
expected: "undefined",
|
|
code: "invalid_type",
|
|
input,
|
|
inst,
|
|
});
|
|
return payload;
|
|
};
|
|
});
|
|
exports.$ZodNull = core.$constructor("$ZodNull", (inst, def) => {
|
|
exports.$ZodType.init(inst, def);
|
|
inst._zod.pattern = regexes.null;
|
|
inst._zod.values = new Set([null]);
|
|
inst._zod.parse = (payload, _ctx) => {
|
|
const input = payload.value;
|
|
if (input === null)
|
|
return payload;
|
|
payload.issues.push({
|
|
expected: "null",
|
|
code: "invalid_type",
|
|
input,
|
|
inst,
|
|
});
|
|
return payload;
|
|
};
|
|
});
|
|
exports.$ZodAny = core.$constructor("$ZodAny", (inst, def) => {
|
|
exports.$ZodType.init(inst, def);
|
|
inst._zod.parse = (payload) => payload;
|
|
});
|
|
exports.$ZodUnknown = core.$constructor("$ZodUnknown", (inst, def) => {
|
|
exports.$ZodType.init(inst, def);
|
|
inst._zod.parse = (payload) => payload;
|
|
});
|
|
exports.$ZodNever = core.$constructor("$ZodNever", (inst, def) => {
|
|
exports.$ZodType.init(inst, def);
|
|
inst._zod.parse = (payload, _ctx) => {
|
|
payload.issues.push({
|
|
expected: "never",
|
|
code: "invalid_type",
|
|
input: payload.value,
|
|
inst,
|
|
});
|
|
return payload;
|
|
};
|
|
});
|
|
exports.$ZodVoid = core.$constructor("$ZodVoid", (inst, def) => {
|
|
exports.$ZodType.init(inst, def);
|
|
inst._zod.parse = (payload, _ctx) => {
|
|
const input = payload.value;
|
|
if (typeof input === "undefined")
|
|
return payload;
|
|
payload.issues.push({
|
|
expected: "void",
|
|
code: "invalid_type",
|
|
input,
|
|
inst,
|
|
});
|
|
return payload;
|
|
};
|
|
});
|
|
exports.$ZodDate = core.$constructor("$ZodDate", (inst, def) => {
|
|
exports.$ZodType.init(inst, def);
|
|
inst._zod.parse = (payload, _ctx) => {
|
|
if (def.coerce) {
|
|
try {
|
|
payload.value = new Date(payload.value);
|
|
}
|
|
catch (_err) { }
|
|
}
|
|
const input = payload.value;
|
|
const isDate = input instanceof Date;
|
|
const isValidDate = isDate && !Number.isNaN(input.getTime());
|
|
if (isValidDate)
|
|
return payload;
|
|
payload.issues.push({
|
|
expected: "date",
|
|
code: "invalid_type",
|
|
input,
|
|
...(isDate ? { received: "Invalid Date" } : {}),
|
|
inst,
|
|
});
|
|
return payload;
|
|
};
|
|
});
|
|
function handleArrayResult(result, final, index) {
|
|
if (result.issues.length) {
|
|
final.issues.push(...util.prefixIssues(index, result.issues));
|
|
}
|
|
final.value[index] = result.value;
|
|
}
|
|
exports.$ZodArray = core.$constructor("$ZodArray", (inst, def) => {
|
|
exports.$ZodType.init(inst, def);
|
|
inst._zod.parse = (payload, ctx) => {
|
|
const input = payload.value;
|
|
if (!Array.isArray(input)) {
|
|
payload.issues.push({
|
|
expected: "array",
|
|
code: "invalid_type",
|
|
input,
|
|
inst,
|
|
});
|
|
return payload;
|
|
}
|
|
payload.value = Array(input.length);
|
|
const proms = [];
|
|
for (let i = 0; i < input.length; i++) {
|
|
const item = input[i];
|
|
const result = def.element._zod.run({
|
|
value: item,
|
|
issues: [],
|
|
}, ctx);
|
|
if (result instanceof Promise) {
|
|
proms.push(result.then((result) => handleArrayResult(result, payload, i)));
|
|
}
|
|
else {
|
|
handleArrayResult(result, payload, i);
|
|
}
|
|
}
|
|
if (proms.length) {
|
|
return Promise.all(proms).then(() => payload);
|
|
}
|
|
return payload; //handleArrayResultsAsync(parseResults, final);
|
|
};
|
|
});
|
|
function handlePropertyResult(result, final, key, input) {
|
|
if (result.issues.length) {
|
|
final.issues.push(...util.prefixIssues(key, result.issues));
|
|
}
|
|
if (result.value === undefined) {
|
|
if (key in input) {
|
|
final.value[key] = undefined;
|
|
}
|
|
}
|
|
else {
|
|
final.value[key] = result.value;
|
|
}
|
|
}
|
|
function normalizeDef(def) {
|
|
const keys = Object.keys(def.shape);
|
|
for (const k of keys) {
|
|
if (!def.shape?.[k]?._zod?.traits?.has("$ZodType")) {
|
|
throw new Error(`Invalid element at key "${k}": expected a Zod schema`);
|
|
}
|
|
}
|
|
const okeys = util.optionalKeys(def.shape);
|
|
return {
|
|
...def,
|
|
keys,
|
|
keySet: new Set(keys),
|
|
numKeys: keys.length,
|
|
optionalKeys: new Set(okeys),
|
|
};
|
|
}
|
|
function handleCatchall(proms, input, payload, ctx, def, inst) {
|
|
const unrecognized = [];
|
|
// iterate over input keys
|
|
const keySet = def.keySet;
|
|
const _catchall = def.catchall._zod;
|
|
const t = _catchall.def.type;
|
|
for (const key of Object.keys(input)) {
|
|
if (keySet.has(key))
|
|
continue;
|
|
if (t === "never") {
|
|
unrecognized.push(key);
|
|
continue;
|
|
}
|
|
const r = _catchall.run({ value: input[key], issues: [] }, ctx);
|
|
if (r instanceof Promise) {
|
|
proms.push(r.then((r) => handlePropertyResult(r, payload, key, input)));
|
|
}
|
|
else {
|
|
handlePropertyResult(r, payload, key, input);
|
|
}
|
|
}
|
|
if (unrecognized.length) {
|
|
payload.issues.push({
|
|
code: "unrecognized_keys",
|
|
keys: unrecognized,
|
|
input,
|
|
inst,
|
|
});
|
|
}
|
|
if (!proms.length)
|
|
return payload;
|
|
return Promise.all(proms).then(() => {
|
|
return payload;
|
|
});
|
|
}
|
|
exports.$ZodObject = core.$constructor("$ZodObject", (inst, def) => {
|
|
// requires cast because technically $ZodObject doesn't extend
|
|
exports.$ZodType.init(inst, def);
|
|
// const sh = def.shape;
|
|
const desc = Object.getOwnPropertyDescriptor(def, "shape");
|
|
if (!desc?.get) {
|
|
const sh = def.shape;
|
|
Object.defineProperty(def, "shape", {
|
|
get: () => {
|
|
const newSh = { ...sh };
|
|
Object.defineProperty(def, "shape", {
|
|
value: newSh,
|
|
});
|
|
return newSh;
|
|
},
|
|
});
|
|
}
|
|
const _normalized = util.cached(() => normalizeDef(def));
|
|
util.defineLazy(inst._zod, "propValues", () => {
|
|
const shape = def.shape;
|
|
const propValues = {};
|
|
for (const key in shape) {
|
|
const field = shape[key]._zod;
|
|
if (field.values) {
|
|
propValues[key] ?? (propValues[key] = new Set());
|
|
for (const v of field.values)
|
|
propValues[key].add(v);
|
|
}
|
|
}
|
|
return propValues;
|
|
});
|
|
const isObject = util.isObject;
|
|
const catchall = def.catchall;
|
|
let value;
|
|
inst._zod.parse = (payload, ctx) => {
|
|
value ?? (value = _normalized.value);
|
|
const input = payload.value;
|
|
if (!isObject(input)) {
|
|
payload.issues.push({
|
|
expected: "object",
|
|
code: "invalid_type",
|
|
input,
|
|
inst,
|
|
});
|
|
return payload;
|
|
}
|
|
payload.value = {};
|
|
const proms = [];
|
|
const shape = value.shape;
|
|
for (const key of value.keys) {
|
|
const el = shape[key];
|
|
const r = el._zod.run({ value: input[key], issues: [] }, ctx);
|
|
if (r instanceof Promise) {
|
|
proms.push(r.then((r) => handlePropertyResult(r, payload, key, input)));
|
|
}
|
|
else {
|
|
handlePropertyResult(r, payload, key, input);
|
|
}
|
|
}
|
|
if (!catchall) {
|
|
return proms.length ? Promise.all(proms).then(() => payload) : payload;
|
|
}
|
|
return handleCatchall(proms, input, payload, ctx, _normalized.value, inst);
|
|
};
|
|
});
|
|
exports.$ZodObjectJIT = core.$constructor("$ZodObjectJIT", (inst, def) => {
|
|
// requires cast because technically $ZodObject doesn't extend
|
|
exports.$ZodObject.init(inst, def);
|
|
const superParse = inst._zod.parse;
|
|
const _normalized = util.cached(() => normalizeDef(def));
|
|
const generateFastpass = (shape) => {
|
|
const doc = new doc_js_1.Doc(["shape", "payload", "ctx"]);
|
|
const normalized = _normalized.value;
|
|
const parseStr = (key) => {
|
|
const k = util.esc(key);
|
|
return `shape[${k}]._zod.run({ value: input[${k}], issues: [] }, ctx)`;
|
|
};
|
|
doc.write(`const input = payload.value;`);
|
|
const ids = Object.create(null);
|
|
let counter = 0;
|
|
for (const key of normalized.keys) {
|
|
ids[key] = `key_${counter++}`;
|
|
}
|
|
// A: preserve key order {
|
|
doc.write(`const newResult = {};`);
|
|
for (const key of normalized.keys) {
|
|
const id = ids[key];
|
|
const k = util.esc(key);
|
|
doc.write(`const ${id} = ${parseStr(key)};`);
|
|
doc.write(`
|
|
if (${id}.issues.length) {
|
|
payload.issues = payload.issues.concat(${id}.issues.map(iss => ({
|
|
...iss,
|
|
path: iss.path ? [${k}, ...iss.path] : [${k}]
|
|
})));
|
|
}
|
|
|
|
|
|
if (${id}.value === undefined) {
|
|
if (${k} in input) {
|
|
newResult[${k}] = undefined;
|
|
}
|
|
} else {
|
|
newResult[${k}] = ${id}.value;
|
|
}
|
|
|
|
`);
|
|
}
|
|
doc.write(`payload.value = newResult;`);
|
|
doc.write(`return payload;`);
|
|
const fn = doc.compile();
|
|
return (payload, ctx) => fn(shape, payload, ctx);
|
|
};
|
|
let fastpass;
|
|
const isObject = util.isObject;
|
|
const jit = !core.globalConfig.jitless;
|
|
const allowsEval = util.allowsEval;
|
|
const fastEnabled = jit && allowsEval.value; // && !def.catchall;
|
|
const catchall = def.catchall;
|
|
let value;
|
|
inst._zod.parse = (payload, ctx) => {
|
|
value ?? (value = _normalized.value);
|
|
const input = payload.value;
|
|
if (!isObject(input)) {
|
|
payload.issues.push({
|
|
expected: "object",
|
|
code: "invalid_type",
|
|
input,
|
|
inst,
|
|
});
|
|
return payload;
|
|
}
|
|
if (jit && fastEnabled && ctx?.async === false && ctx.jitless !== true) {
|
|
// always synchronous
|
|
if (!fastpass)
|
|
fastpass = generateFastpass(def.shape);
|
|
payload = fastpass(payload, ctx);
|
|
if (!catchall)
|
|
return payload;
|
|
return handleCatchall([], input, payload, ctx, value, inst);
|
|
}
|
|
return superParse(payload, ctx);
|
|
};
|
|
});
|
|
function handleUnionResults(results, final, inst, ctx) {
|
|
for (const result of results) {
|
|
if (result.issues.length === 0) {
|
|
final.value = result.value;
|
|
return final;
|
|
}
|
|
}
|
|
const nonaborted = results.filter((r) => !util.aborted(r));
|
|
if (nonaborted.length === 1) {
|
|
final.value = nonaborted[0].value;
|
|
return nonaborted[0];
|
|
}
|
|
final.issues.push({
|
|
code: "invalid_union",
|
|
input: final.value,
|
|
inst,
|
|
errors: results.map((result) => result.issues.map((iss) => util.finalizeIssue(iss, ctx, core.config()))),
|
|
});
|
|
return final;
|
|
}
|
|
exports.$ZodUnion = core.$constructor("$ZodUnion", (inst, def) => {
|
|
exports.$ZodType.init(inst, def);
|
|
util.defineLazy(inst._zod, "optin", () => def.options.some((o) => o._zod.optin === "optional") ? "optional" : undefined);
|
|
util.defineLazy(inst._zod, "optout", () => def.options.some((o) => o._zod.optout === "optional") ? "optional" : undefined);
|
|
util.defineLazy(inst._zod, "values", () => {
|
|
if (def.options.every((o) => o._zod.values)) {
|
|
return new Set(def.options.flatMap((option) => Array.from(option._zod.values)));
|
|
}
|
|
return undefined;
|
|
});
|
|
util.defineLazy(inst._zod, "pattern", () => {
|
|
if (def.options.every((o) => o._zod.pattern)) {
|
|
const patterns = def.options.map((o) => o._zod.pattern);
|
|
return new RegExp(`^(${patterns.map((p) => util.cleanRegex(p.source)).join("|")})$`);
|
|
}
|
|
return undefined;
|
|
});
|
|
const single = def.options.length === 1;
|
|
const first = def.options[0]._zod.run;
|
|
inst._zod.parse = (payload, ctx) => {
|
|
if (single) {
|
|
return first(payload, ctx);
|
|
}
|
|
let async = false;
|
|
const results = [];
|
|
for (const option of def.options) {
|
|
const result = option._zod.run({
|
|
value: payload.value,
|
|
issues: [],
|
|
}, ctx);
|
|
if (result instanceof Promise) {
|
|
results.push(result);
|
|
async = true;
|
|
}
|
|
else {
|
|
if (result.issues.length === 0)
|
|
return result;
|
|
results.push(result);
|
|
}
|
|
}
|
|
if (!async)
|
|
return handleUnionResults(results, payload, inst, ctx);
|
|
return Promise.all(results).then((results) => {
|
|
return handleUnionResults(results, payload, inst, ctx);
|
|
});
|
|
};
|
|
});
|
|
exports.$ZodDiscriminatedUnion =
|
|
/*@__PURE__*/
|
|
core.$constructor("$ZodDiscriminatedUnion", (inst, def) => {
|
|
exports.$ZodUnion.init(inst, def);
|
|
const _super = inst._zod.parse;
|
|
util.defineLazy(inst._zod, "propValues", () => {
|
|
const propValues = {};
|
|
for (const option of def.options) {
|
|
const pv = option._zod.propValues;
|
|
if (!pv || Object.keys(pv).length === 0)
|
|
throw new Error(`Invalid discriminated union option at index "${def.options.indexOf(option)}"`);
|
|
for (const [k, v] of Object.entries(pv)) {
|
|
if (!propValues[k])
|
|
propValues[k] = new Set();
|
|
for (const val of v) {
|
|
propValues[k].add(val);
|
|
}
|
|
}
|
|
}
|
|
return propValues;
|
|
});
|
|
const disc = util.cached(() => {
|
|
const opts = def.options;
|
|
const map = new Map();
|
|
for (const o of opts) {
|
|
const values = o._zod.propValues?.[def.discriminator];
|
|
if (!values || values.size === 0)
|
|
throw new Error(`Invalid discriminated union option at index "${def.options.indexOf(o)}"`);
|
|
for (const v of values) {
|
|
if (map.has(v)) {
|
|
throw new Error(`Duplicate discriminator value "${String(v)}"`);
|
|
}
|
|
map.set(v, o);
|
|
}
|
|
}
|
|
return map;
|
|
});
|
|
inst._zod.parse = (payload, ctx) => {
|
|
const input = payload.value;
|
|
if (!util.isObject(input)) {
|
|
payload.issues.push({
|
|
code: "invalid_type",
|
|
expected: "object",
|
|
input,
|
|
inst,
|
|
});
|
|
return payload;
|
|
}
|
|
const opt = disc.value.get(input?.[def.discriminator]);
|
|
if (opt) {
|
|
return opt._zod.run(payload, ctx);
|
|
}
|
|
if (def.unionFallback) {
|
|
return _super(payload, ctx);
|
|
}
|
|
// no matching discriminator
|
|
payload.issues.push({
|
|
code: "invalid_union",
|
|
errors: [],
|
|
note: "No matching discriminator",
|
|
discriminator: def.discriminator,
|
|
input,
|
|
path: [def.discriminator],
|
|
inst,
|
|
});
|
|
return payload;
|
|
};
|
|
});
|
|
exports.$ZodIntersection = core.$constructor("$ZodIntersection", (inst, def) => {
|
|
exports.$ZodType.init(inst, def);
|
|
inst._zod.parse = (payload, ctx) => {
|
|
const input = payload.value;
|
|
const left = def.left._zod.run({ value: input, issues: [] }, ctx);
|
|
const right = def.right._zod.run({ value: input, issues: [] }, ctx);
|
|
const async = left instanceof Promise || right instanceof Promise;
|
|
if (async) {
|
|
return Promise.all([left, right]).then(([left, right]) => {
|
|
return handleIntersectionResults(payload, left, right);
|
|
});
|
|
}
|
|
return handleIntersectionResults(payload, left, right);
|
|
};
|
|
});
|
|
function mergeValues(a, b) {
|
|
// const aType = parse.t(a);
|
|
// const bType = parse.t(b);
|
|
if (a === b) {
|
|
return { valid: true, data: a };
|
|
}
|
|
if (a instanceof Date && b instanceof Date && +a === +b) {
|
|
return { valid: true, data: a };
|
|
}
|
|
if (util.isPlainObject(a) && util.isPlainObject(b)) {
|
|
const bKeys = Object.keys(b);
|
|
const sharedKeys = Object.keys(a).filter((key) => bKeys.indexOf(key) !== -1);
|
|
const newObj = { ...a, ...b };
|
|
for (const key of sharedKeys) {
|
|
const sharedValue = mergeValues(a[key], b[key]);
|
|
if (!sharedValue.valid) {
|
|
return {
|
|
valid: false,
|
|
mergeErrorPath: [key, ...sharedValue.mergeErrorPath],
|
|
};
|
|
}
|
|
newObj[key] = sharedValue.data;
|
|
}
|
|
return { valid: true, data: newObj };
|
|
}
|
|
if (Array.isArray(a) && Array.isArray(b)) {
|
|
if (a.length !== b.length) {
|
|
return { valid: false, mergeErrorPath: [] };
|
|
}
|
|
const newArray = [];
|
|
for (let index = 0; index < a.length; index++) {
|
|
const itemA = a[index];
|
|
const itemB = b[index];
|
|
const sharedValue = mergeValues(itemA, itemB);
|
|
if (!sharedValue.valid) {
|
|
return {
|
|
valid: false,
|
|
mergeErrorPath: [index, ...sharedValue.mergeErrorPath],
|
|
};
|
|
}
|
|
newArray.push(sharedValue.data);
|
|
}
|
|
return { valid: true, data: newArray };
|
|
}
|
|
return { valid: false, mergeErrorPath: [] };
|
|
}
|
|
function handleIntersectionResults(result, left, right) {
|
|
if (left.issues.length) {
|
|
result.issues.push(...left.issues);
|
|
}
|
|
if (right.issues.length) {
|
|
result.issues.push(...right.issues);
|
|
}
|
|
if (util.aborted(result))
|
|
return result;
|
|
const merged = mergeValues(left.value, right.value);
|
|
if (!merged.valid) {
|
|
throw new Error(`Unmergable intersection. Error path: ` + `${JSON.stringify(merged.mergeErrorPath)}`);
|
|
}
|
|
result.value = merged.data;
|
|
return result;
|
|
}
|
|
exports.$ZodTuple = core.$constructor("$ZodTuple", (inst, def) => {
|
|
exports.$ZodType.init(inst, def);
|
|
const items = def.items;
|
|
const optStart = items.length - [...items].reverse().findIndex((item) => item._zod.optin !== "optional");
|
|
inst._zod.parse = (payload, ctx) => {
|
|
const input = payload.value;
|
|
if (!Array.isArray(input)) {
|
|
payload.issues.push({
|
|
input,
|
|
inst,
|
|
expected: "tuple",
|
|
code: "invalid_type",
|
|
});
|
|
return payload;
|
|
}
|
|
payload.value = [];
|
|
const proms = [];
|
|
if (!def.rest) {
|
|
const tooBig = input.length > items.length;
|
|
const tooSmall = input.length < optStart - 1;
|
|
if (tooBig || tooSmall) {
|
|
payload.issues.push({
|
|
...(tooBig ? { code: "too_big", maximum: items.length } : { code: "too_small", minimum: items.length }),
|
|
input,
|
|
inst,
|
|
origin: "array",
|
|
});
|
|
return payload;
|
|
}
|
|
}
|
|
let i = -1;
|
|
for (const item of items) {
|
|
i++;
|
|
if (i >= input.length)
|
|
if (i >= optStart)
|
|
continue;
|
|
const result = item._zod.run({
|
|
value: input[i],
|
|
issues: [],
|
|
}, ctx);
|
|
if (result instanceof Promise) {
|
|
proms.push(result.then((result) => handleTupleResult(result, payload, i)));
|
|
}
|
|
else {
|
|
handleTupleResult(result, payload, i);
|
|
}
|
|
}
|
|
if (def.rest) {
|
|
const rest = input.slice(items.length);
|
|
for (const el of rest) {
|
|
i++;
|
|
const result = def.rest._zod.run({
|
|
value: el,
|
|
issues: [],
|
|
}, ctx);
|
|
if (result instanceof Promise) {
|
|
proms.push(result.then((result) => handleTupleResult(result, payload, i)));
|
|
}
|
|
else {
|
|
handleTupleResult(result, payload, i);
|
|
}
|
|
}
|
|
}
|
|
if (proms.length)
|
|
return Promise.all(proms).then(() => payload);
|
|
return payload;
|
|
};
|
|
});
|
|
function handleTupleResult(result, final, index) {
|
|
if (result.issues.length) {
|
|
final.issues.push(...util.prefixIssues(index, result.issues));
|
|
}
|
|
final.value[index] = result.value;
|
|
}
|
|
exports.$ZodRecord = core.$constructor("$ZodRecord", (inst, def) => {
|
|
exports.$ZodType.init(inst, def);
|
|
inst._zod.parse = (payload, ctx) => {
|
|
const input = payload.value;
|
|
if (!util.isPlainObject(input)) {
|
|
payload.issues.push({
|
|
expected: "record",
|
|
code: "invalid_type",
|
|
input,
|
|
inst,
|
|
});
|
|
return payload;
|
|
}
|
|
const proms = [];
|
|
if (def.keyType._zod.values) {
|
|
const values = def.keyType._zod.values;
|
|
payload.value = {};
|
|
for (const key of values) {
|
|
if (typeof key === "string" || typeof key === "number" || typeof key === "symbol") {
|
|
const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
|
|
if (result instanceof Promise) {
|
|
proms.push(result.then((result) => {
|
|
if (result.issues.length) {
|
|
payload.issues.push(...util.prefixIssues(key, result.issues));
|
|
}
|
|
payload.value[key] = result.value;
|
|
}));
|
|
}
|
|
else {
|
|
if (result.issues.length) {
|
|
payload.issues.push(...util.prefixIssues(key, result.issues));
|
|
}
|
|
payload.value[key] = result.value;
|
|
}
|
|
}
|
|
}
|
|
let unrecognized;
|
|
for (const key in input) {
|
|
if (!values.has(key)) {
|
|
unrecognized = unrecognized ?? [];
|
|
unrecognized.push(key);
|
|
}
|
|
}
|
|
if (unrecognized && unrecognized.length > 0) {
|
|
payload.issues.push({
|
|
code: "unrecognized_keys",
|
|
input,
|
|
inst,
|
|
keys: unrecognized,
|
|
});
|
|
}
|
|
}
|
|
else {
|
|
payload.value = {};
|
|
for (const key of Reflect.ownKeys(input)) {
|
|
if (key === "__proto__")
|
|
continue;
|
|
const keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx);
|
|
if (keyResult instanceof Promise) {
|
|
throw new Error("Async schemas not supported in object keys currently");
|
|
}
|
|
if (keyResult.issues.length) {
|
|
payload.issues.push({
|
|
code: "invalid_key",
|
|
origin: "record",
|
|
issues: keyResult.issues.map((iss) => util.finalizeIssue(iss, ctx, core.config())),
|
|
input: key,
|
|
path: [key],
|
|
inst,
|
|
});
|
|
payload.value[keyResult.value] = keyResult.value;
|
|
continue;
|
|
}
|
|
const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
|
|
if (result instanceof Promise) {
|
|
proms.push(result.then((result) => {
|
|
if (result.issues.length) {
|
|
payload.issues.push(...util.prefixIssues(key, result.issues));
|
|
}
|
|
payload.value[keyResult.value] = result.value;
|
|
}));
|
|
}
|
|
else {
|
|
if (result.issues.length) {
|
|
payload.issues.push(...util.prefixIssues(key, result.issues));
|
|
}
|
|
payload.value[keyResult.value] = result.value;
|
|
}
|
|
}
|
|
}
|
|
if (proms.length) {
|
|
return Promise.all(proms).then(() => payload);
|
|
}
|
|
return payload;
|
|
};
|
|
});
|
|
exports.$ZodMap = core.$constructor("$ZodMap", (inst, def) => {
|
|
exports.$ZodType.init(inst, def);
|
|
inst._zod.parse = (payload, ctx) => {
|
|
const input = payload.value;
|
|
if (!(input instanceof Map)) {
|
|
payload.issues.push({
|
|
expected: "map",
|
|
code: "invalid_type",
|
|
input,
|
|
inst,
|
|
});
|
|
return payload;
|
|
}
|
|
const proms = [];
|
|
payload.value = new Map();
|
|
for (const [key, value] of input) {
|
|
const keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx);
|
|
const valueResult = def.valueType._zod.run({ value: value, issues: [] }, ctx);
|
|
if (keyResult instanceof Promise || valueResult instanceof Promise) {
|
|
proms.push(Promise.all([keyResult, valueResult]).then(([keyResult, valueResult]) => {
|
|
handleMapResult(keyResult, valueResult, payload, key, input, inst, ctx);
|
|
}));
|
|
}
|
|
else {
|
|
handleMapResult(keyResult, valueResult, payload, key, input, inst, ctx);
|
|
}
|
|
}
|
|
if (proms.length)
|
|
return Promise.all(proms).then(() => payload);
|
|
return payload;
|
|
};
|
|
});
|
|
function handleMapResult(keyResult, valueResult, final, key, input, inst, ctx) {
|
|
if (keyResult.issues.length) {
|
|
if (util.propertyKeyTypes.has(typeof key)) {
|
|
final.issues.push(...util.prefixIssues(key, keyResult.issues));
|
|
}
|
|
else {
|
|
final.issues.push({
|
|
code: "invalid_key",
|
|
origin: "map",
|
|
input,
|
|
inst,
|
|
issues: keyResult.issues.map((iss) => util.finalizeIssue(iss, ctx, core.config())),
|
|
});
|
|
}
|
|
}
|
|
if (valueResult.issues.length) {
|
|
if (util.propertyKeyTypes.has(typeof key)) {
|
|
final.issues.push(...util.prefixIssues(key, valueResult.issues));
|
|
}
|
|
else {
|
|
final.issues.push({
|
|
origin: "map",
|
|
code: "invalid_element",
|
|
input,
|
|
inst,
|
|
key: key,
|
|
issues: valueResult.issues.map((iss) => util.finalizeIssue(iss, ctx, core.config())),
|
|
});
|
|
}
|
|
}
|
|
final.value.set(keyResult.value, valueResult.value);
|
|
}
|
|
exports.$ZodSet = core.$constructor("$ZodSet", (inst, def) => {
|
|
exports.$ZodType.init(inst, def);
|
|
inst._zod.parse = (payload, ctx) => {
|
|
const input = payload.value;
|
|
if (!(input instanceof Set)) {
|
|
payload.issues.push({
|
|
input,
|
|
inst,
|
|
expected: "set",
|
|
code: "invalid_type",
|
|
});
|
|
return payload;
|
|
}
|
|
const proms = [];
|
|
payload.value = new Set();
|
|
for (const item of input) {
|
|
const result = def.valueType._zod.run({ value: item, issues: [] }, ctx);
|
|
if (result instanceof Promise) {
|
|
proms.push(result.then((result) => handleSetResult(result, payload)));
|
|
}
|
|
else
|
|
handleSetResult(result, payload);
|
|
}
|
|
if (proms.length)
|
|
return Promise.all(proms).then(() => payload);
|
|
return payload;
|
|
};
|
|
});
|
|
function handleSetResult(result, final) {
|
|
if (result.issues.length) {
|
|
final.issues.push(...result.issues);
|
|
}
|
|
final.value.add(result.value);
|
|
}
|
|
exports.$ZodEnum = core.$constructor("$ZodEnum", (inst, def) => {
|
|
exports.$ZodType.init(inst, def);
|
|
const values = util.getEnumValues(def.entries);
|
|
const valuesSet = new Set(values);
|
|
inst._zod.values = valuesSet;
|
|
inst._zod.pattern = new RegExp(`^(${values
|
|
.filter((k) => util.propertyKeyTypes.has(typeof k))
|
|
.map((o) => (typeof o === "string" ? util.escapeRegex(o) : o.toString()))
|
|
.join("|")})$`);
|
|
inst._zod.parse = (payload, _ctx) => {
|
|
const input = payload.value;
|
|
if (valuesSet.has(input)) {
|
|
return payload;
|
|
}
|
|
payload.issues.push({
|
|
code: "invalid_value",
|
|
values,
|
|
input,
|
|
inst,
|
|
});
|
|
return payload;
|
|
};
|
|
});
|
|
exports.$ZodLiteral = core.$constructor("$ZodLiteral", (inst, def) => {
|
|
exports.$ZodType.init(inst, def);
|
|
if (def.values.length === 0) {
|
|
throw new Error("Cannot create literal schema with no valid values");
|
|
}
|
|
inst._zod.values = new Set(def.values);
|
|
inst._zod.pattern = new RegExp(`^(${def.values
|
|
.map((o) => (typeof o === "string" ? util.escapeRegex(o) : o ? util.escapeRegex(o.toString()) : String(o)))
|
|
.join("|")})$`);
|
|
inst._zod.parse = (payload, _ctx) => {
|
|
const input = payload.value;
|
|
if (inst._zod.values.has(input)) {
|
|
return payload;
|
|
}
|
|
payload.issues.push({
|
|
code: "invalid_value",
|
|
values: def.values,
|
|
input,
|
|
inst,
|
|
});
|
|
return payload;
|
|
};
|
|
});
|
|
exports.$ZodFile = core.$constructor("$ZodFile", (inst, def) => {
|
|
exports.$ZodType.init(inst, def);
|
|
inst._zod.parse = (payload, _ctx) => {
|
|
const input = payload.value;
|
|
// @ts-ignore
|
|
if (input instanceof File)
|
|
return payload;
|
|
payload.issues.push({
|
|
expected: "file",
|
|
code: "invalid_type",
|
|
input,
|
|
inst,
|
|
});
|
|
return payload;
|
|
};
|
|
});
|
|
exports.$ZodTransform = core.$constructor("$ZodTransform", (inst, def) => {
|
|
exports.$ZodType.init(inst, def);
|
|
inst._zod.parse = (payload, ctx) => {
|
|
if (ctx.direction === "backward") {
|
|
throw new core.$ZodEncodeError(inst.constructor.name);
|
|
}
|
|
const _out = def.transform(payload.value, payload);
|
|
if (ctx.async) {
|
|
const output = _out instanceof Promise ? _out : Promise.resolve(_out);
|
|
return output.then((output) => {
|
|
payload.value = output;
|
|
return payload;
|
|
});
|
|
}
|
|
if (_out instanceof Promise) {
|
|
throw new core.$ZodAsyncError();
|
|
}
|
|
payload.value = _out;
|
|
return payload;
|
|
};
|
|
});
|
|
function handleOptionalResult(result, input) {
|
|
if (result.issues.length && input === undefined) {
|
|
return { issues: [], value: undefined };
|
|
}
|
|
return result;
|
|
}
|
|
exports.$ZodOptional = core.$constructor("$ZodOptional", (inst, def) => {
|
|
exports.$ZodType.init(inst, def);
|
|
inst._zod.optin = "optional";
|
|
inst._zod.optout = "optional";
|
|
util.defineLazy(inst._zod, "values", () => {
|
|
return def.innerType._zod.values ? new Set([...def.innerType._zod.values, undefined]) : undefined;
|
|
});
|
|
util.defineLazy(inst._zod, "pattern", () => {
|
|
const pattern = def.innerType._zod.pattern;
|
|
return pattern ? new RegExp(`^(${util.cleanRegex(pattern.source)})?$`) : undefined;
|
|
});
|
|
inst._zod.parse = (payload, ctx) => {
|
|
if (def.innerType._zod.optin === "optional") {
|
|
const result = def.innerType._zod.run(payload, ctx);
|
|
if (result instanceof Promise)
|
|
return result.then((r) => handleOptionalResult(r, payload.value));
|
|
return handleOptionalResult(result, payload.value);
|
|
}
|
|
if (payload.value === undefined) {
|
|
return payload;
|
|
}
|
|
return def.innerType._zod.run(payload, ctx);
|
|
};
|
|
});
|
|
exports.$ZodNullable = core.$constructor("$ZodNullable", (inst, def) => {
|
|
exports.$ZodType.init(inst, def);
|
|
util.defineLazy(inst._zod, "optin", () => def.innerType._zod.optin);
|
|
util.defineLazy(inst._zod, "optout", () => def.innerType._zod.optout);
|
|
util.defineLazy(inst._zod, "pattern", () => {
|
|
const pattern = def.innerType._zod.pattern;
|
|
return pattern ? new RegExp(`^(${util.cleanRegex(pattern.source)}|null)$`) : undefined;
|
|
});
|
|
util.defineLazy(inst._zod, "values", () => {
|
|
return def.innerType._zod.values ? new Set([...def.innerType._zod.values, null]) : undefined;
|
|
});
|
|
inst._zod.parse = (payload, ctx) => {
|
|
// Forward direction (decode): allow null to pass through
|
|
if (payload.value === null)
|
|
return payload;
|
|
return def.innerType._zod.run(payload, ctx);
|
|
};
|
|
});
|
|
exports.$ZodDefault = core.$constructor("$ZodDefault", (inst, def) => {
|
|
exports.$ZodType.init(inst, def);
|
|
// inst._zod.qin = "true";
|
|
inst._zod.optin = "optional";
|
|
util.defineLazy(inst._zod, "values", () => def.innerType._zod.values);
|
|
inst._zod.parse = (payload, ctx) => {
|
|
if (ctx.direction === "backward") {
|
|
return def.innerType._zod.run(payload, ctx);
|
|
}
|
|
// Forward direction (decode): apply defaults for undefined input
|
|
if (payload.value === undefined) {
|
|
payload.value = def.defaultValue;
|
|
/**
|
|
* $ZodDefault returns the default value immediately in forward direction.
|
|
* It doesn't pass the default value into the validator ("prefault"). There's no reason to pass the default value through validation. The validity of the default is enforced by TypeScript statically. Otherwise, it's the responsibility of the user to ensure the default is valid. In the case of pipes with divergent in/out types, you can specify the default on the `in` schema of your ZodPipe to set a "prefault" for the pipe. */
|
|
return payload;
|
|
}
|
|
// Forward direction: continue with default handling
|
|
const result = def.innerType._zod.run(payload, ctx);
|
|
if (result instanceof Promise) {
|
|
return result.then((result) => handleDefaultResult(result, def));
|
|
}
|
|
return handleDefaultResult(result, def);
|
|
};
|
|
});
|
|
function handleDefaultResult(payload, def) {
|
|
if (payload.value === undefined) {
|
|
payload.value = def.defaultValue;
|
|
}
|
|
return payload;
|
|
}
|
|
exports.$ZodPrefault = core.$constructor("$ZodPrefault", (inst, def) => {
|
|
exports.$ZodType.init(inst, def);
|
|
inst._zod.optin = "optional";
|
|
util.defineLazy(inst._zod, "values", () => def.innerType._zod.values);
|
|
inst._zod.parse = (payload, ctx) => {
|
|
if (ctx.direction === "backward") {
|
|
return def.innerType._zod.run(payload, ctx);
|
|
}
|
|
// Forward direction (decode): apply prefault for undefined input
|
|
if (payload.value === undefined) {
|
|
payload.value = def.defaultValue;
|
|
}
|
|
return def.innerType._zod.run(payload, ctx);
|
|
};
|
|
});
|
|
exports.$ZodNonOptional = core.$constructor("$ZodNonOptional", (inst, def) => {
|
|
exports.$ZodType.init(inst, def);
|
|
util.defineLazy(inst._zod, "values", () => {
|
|
const v = def.innerType._zod.values;
|
|
return v ? new Set([...v].filter((x) => x !== undefined)) : undefined;
|
|
});
|
|
inst._zod.parse = (payload, ctx) => {
|
|
const result = def.innerType._zod.run(payload, ctx);
|
|
if (result instanceof Promise) {
|
|
return result.then((result) => handleNonOptionalResult(result, inst));
|
|
}
|
|
return handleNonOptionalResult(result, inst);
|
|
};
|
|
});
|
|
function handleNonOptionalResult(payload, inst) {
|
|
if (!payload.issues.length && payload.value === undefined) {
|
|
payload.issues.push({
|
|
code: "invalid_type",
|
|
expected: "nonoptional",
|
|
input: payload.value,
|
|
inst,
|
|
});
|
|
}
|
|
return payload;
|
|
}
|
|
exports.$ZodSuccess = core.$constructor("$ZodSuccess", (inst, def) => {
|
|
exports.$ZodType.init(inst, def);
|
|
inst._zod.parse = (payload, ctx) => {
|
|
if (ctx.direction === "backward") {
|
|
throw new core.$ZodEncodeError("ZodSuccess");
|
|
}
|
|
const result = def.innerType._zod.run(payload, ctx);
|
|
if (result instanceof Promise) {
|
|
return result.then((result) => {
|
|
payload.value = result.issues.length === 0;
|
|
return payload;
|
|
});
|
|
}
|
|
payload.value = result.issues.length === 0;
|
|
return payload;
|
|
};
|
|
});
|
|
exports.$ZodCatch = core.$constructor("$ZodCatch", (inst, def) => {
|
|
exports.$ZodType.init(inst, def);
|
|
util.defineLazy(inst._zod, "optin", () => def.innerType._zod.optin);
|
|
util.defineLazy(inst._zod, "optout", () => def.innerType._zod.optout);
|
|
util.defineLazy(inst._zod, "values", () => def.innerType._zod.values);
|
|
inst._zod.parse = (payload, ctx) => {
|
|
if (ctx.direction === "backward") {
|
|
return def.innerType._zod.run(payload, ctx);
|
|
}
|
|
// Forward direction (decode): apply catch logic
|
|
const result = def.innerType._zod.run(payload, ctx);
|
|
if (result instanceof Promise) {
|
|
return result.then((result) => {
|
|
payload.value = result.value;
|
|
if (result.issues.length) {
|
|
payload.value = def.catchValue({
|
|
...payload,
|
|
error: {
|
|
issues: result.issues.map((iss) => util.finalizeIssue(iss, ctx, core.config())),
|
|
},
|
|
input: payload.value,
|
|
});
|
|
payload.issues = [];
|
|
}
|
|
return payload;
|
|
});
|
|
}
|
|
payload.value = result.value;
|
|
if (result.issues.length) {
|
|
payload.value = def.catchValue({
|
|
...payload,
|
|
error: {
|
|
issues: result.issues.map((iss) => util.finalizeIssue(iss, ctx, core.config())),
|
|
},
|
|
input: payload.value,
|
|
});
|
|
payload.issues = [];
|
|
}
|
|
return payload;
|
|
};
|
|
});
|
|
exports.$ZodNaN = core.$constructor("$ZodNaN", (inst, def) => {
|
|
exports.$ZodType.init(inst, def);
|
|
inst._zod.parse = (payload, _ctx) => {
|
|
if (typeof payload.value !== "number" || !Number.isNaN(payload.value)) {
|
|
payload.issues.push({
|
|
input: payload.value,
|
|
inst,
|
|
expected: "nan",
|
|
code: "invalid_type",
|
|
});
|
|
return payload;
|
|
}
|
|
return payload;
|
|
};
|
|
});
|
|
exports.$ZodPipe = core.$constructor("$ZodPipe", (inst, def) => {
|
|
exports.$ZodType.init(inst, def);
|
|
util.defineLazy(inst._zod, "values", () => def.in._zod.values);
|
|
util.defineLazy(inst._zod, "optin", () => def.in._zod.optin);
|
|
util.defineLazy(inst._zod, "optout", () => def.out._zod.optout);
|
|
util.defineLazy(inst._zod, "propValues", () => def.in._zod.propValues);
|
|
inst._zod.parse = (payload, ctx) => {
|
|
if (ctx.direction === "backward") {
|
|
const right = def.out._zod.run(payload, ctx);
|
|
if (right instanceof Promise) {
|
|
return right.then((right) => handlePipeResult(right, def.in, ctx));
|
|
}
|
|
return handlePipeResult(right, def.in, ctx);
|
|
}
|
|
const left = def.in._zod.run(payload, ctx);
|
|
if (left instanceof Promise) {
|
|
return left.then((left) => handlePipeResult(left, def.out, ctx));
|
|
}
|
|
return handlePipeResult(left, def.out, ctx);
|
|
};
|
|
});
|
|
function handlePipeResult(left, next, ctx) {
|
|
if (left.issues.length) {
|
|
// prevent further checks
|
|
left.aborted = true;
|
|
return left;
|
|
}
|
|
return next._zod.run({ value: left.value, issues: left.issues }, ctx);
|
|
}
|
|
exports.$ZodCodec = core.$constructor("$ZodCodec", (inst, def) => {
|
|
exports.$ZodType.init(inst, def);
|
|
util.defineLazy(inst._zod, "values", () => def.in._zod.values);
|
|
util.defineLazy(inst._zod, "optin", () => def.in._zod.optin);
|
|
util.defineLazy(inst._zod, "optout", () => def.out._zod.optout);
|
|
util.defineLazy(inst._zod, "propValues", () => def.in._zod.propValues);
|
|
inst._zod.parse = (payload, ctx) => {
|
|
const direction = ctx.direction || "forward";
|
|
if (direction === "forward") {
|
|
const left = def.in._zod.run(payload, ctx);
|
|
if (left instanceof Promise) {
|
|
return left.then((left) => handleCodecAResult(left, def, ctx));
|
|
}
|
|
return handleCodecAResult(left, def, ctx);
|
|
}
|
|
else {
|
|
const right = def.out._zod.run(payload, ctx);
|
|
if (right instanceof Promise) {
|
|
return right.then((right) => handleCodecAResult(right, def, ctx));
|
|
}
|
|
return handleCodecAResult(right, def, ctx);
|
|
}
|
|
};
|
|
});
|
|
function handleCodecAResult(result, def, ctx) {
|
|
if (result.issues.length) {
|
|
// prevent further checks
|
|
result.aborted = true;
|
|
return result;
|
|
}
|
|
const direction = ctx.direction || "forward";
|
|
if (direction === "forward") {
|
|
const transformed = def.transform(result.value, result);
|
|
if (transformed instanceof Promise) {
|
|
return transformed.then((value) => handleCodecTxResult(result, value, def.out, ctx));
|
|
}
|
|
return handleCodecTxResult(result, transformed, def.out, ctx);
|
|
}
|
|
else {
|
|
const transformed = def.reverseTransform(result.value, result);
|
|
if (transformed instanceof Promise) {
|
|
return transformed.then((value) => handleCodecTxResult(result, value, def.in, ctx));
|
|
}
|
|
return handleCodecTxResult(result, transformed, def.in, ctx);
|
|
}
|
|
}
|
|
function handleCodecTxResult(left, value, nextSchema, ctx) {
|
|
// Check if transform added any issues
|
|
if (left.issues.length) {
|
|
left.aborted = true;
|
|
return left;
|
|
}
|
|
return nextSchema._zod.run({ value, issues: left.issues }, ctx);
|
|
}
|
|
exports.$ZodReadonly = core.$constructor("$ZodReadonly", (inst, def) => {
|
|
exports.$ZodType.init(inst, def);
|
|
util.defineLazy(inst._zod, "propValues", () => def.innerType._zod.propValues);
|
|
util.defineLazy(inst._zod, "values", () => def.innerType._zod.values);
|
|
util.defineLazy(inst._zod, "optin", () => def.innerType._zod.optin);
|
|
util.defineLazy(inst._zod, "optout", () => def.innerType._zod.optout);
|
|
inst._zod.parse = (payload, ctx) => {
|
|
if (ctx.direction === "backward") {
|
|
return def.innerType._zod.run(payload, ctx);
|
|
}
|
|
const result = def.innerType._zod.run(payload, ctx);
|
|
if (result instanceof Promise) {
|
|
return result.then(handleReadonlyResult);
|
|
}
|
|
return handleReadonlyResult(result);
|
|
};
|
|
});
|
|
function handleReadonlyResult(payload) {
|
|
payload.value = Object.freeze(payload.value);
|
|
return payload;
|
|
}
|
|
exports.$ZodTemplateLiteral = core.$constructor("$ZodTemplateLiteral", (inst, def) => {
|
|
exports.$ZodType.init(inst, def);
|
|
const regexParts = [];
|
|
for (const part of def.parts) {
|
|
if (typeof part === "object" && part !== null) {
|
|
// is Zod schema
|
|
if (!part._zod.pattern) {
|
|
// if (!source)
|
|
throw new Error(`Invalid template literal part, no pattern found: ${[...part._zod.traits].shift()}`);
|
|
}
|
|
const source = part._zod.pattern instanceof RegExp ? part._zod.pattern.source : part._zod.pattern;
|
|
if (!source)
|
|
throw new Error(`Invalid template literal part: ${part._zod.traits}`);
|
|
const start = source.startsWith("^") ? 1 : 0;
|
|
const end = source.endsWith("$") ? source.length - 1 : source.length;
|
|
regexParts.push(source.slice(start, end));
|
|
}
|
|
else if (part === null || util.primitiveTypes.has(typeof part)) {
|
|
regexParts.push(util.escapeRegex(`${part}`));
|
|
}
|
|
else {
|
|
throw new Error(`Invalid template literal part: ${part}`);
|
|
}
|
|
}
|
|
inst._zod.pattern = new RegExp(`^${regexParts.join("")}$`);
|
|
inst._zod.parse = (payload, _ctx) => {
|
|
if (typeof payload.value !== "string") {
|
|
payload.issues.push({
|
|
input: payload.value,
|
|
inst,
|
|
expected: "template_literal",
|
|
code: "invalid_type",
|
|
});
|
|
return payload;
|
|
}
|
|
inst._zod.pattern.lastIndex = 0;
|
|
if (!inst._zod.pattern.test(payload.value)) {
|
|
payload.issues.push({
|
|
input: payload.value,
|
|
inst,
|
|
code: "invalid_format",
|
|
format: def.format ?? "template_literal",
|
|
pattern: inst._zod.pattern.source,
|
|
});
|
|
return payload;
|
|
}
|
|
return payload;
|
|
};
|
|
});
|
|
exports.$ZodFunction = core.$constructor("$ZodFunction", (inst, def) => {
|
|
exports.$ZodType.init(inst, def);
|
|
inst._def = def;
|
|
inst._zod.def = def;
|
|
inst.implement = (func) => {
|
|
if (typeof func !== "function") {
|
|
throw new Error("implement() must be called with a function");
|
|
}
|
|
return function (...args) {
|
|
const parsedArgs = inst._def.input ? (0, parse_js_1.parse)(inst._def.input, args) : args;
|
|
const result = Reflect.apply(func, this, parsedArgs);
|
|
if (inst._def.output) {
|
|
return (0, parse_js_1.parse)(inst._def.output, result);
|
|
}
|
|
return result;
|
|
};
|
|
};
|
|
inst.implementAsync = (func) => {
|
|
if (typeof func !== "function") {
|
|
throw new Error("implementAsync() must be called with a function");
|
|
}
|
|
return async function (...args) {
|
|
const parsedArgs = inst._def.input ? await (0, parse_js_1.parseAsync)(inst._def.input, args) : args;
|
|
const result = await Reflect.apply(func, this, parsedArgs);
|
|
if (inst._def.output) {
|
|
return await (0, parse_js_1.parseAsync)(inst._def.output, result);
|
|
}
|
|
return result;
|
|
};
|
|
};
|
|
inst._zod.parse = (payload, _ctx) => {
|
|
if (typeof payload.value !== "function") {
|
|
payload.issues.push({
|
|
code: "invalid_type",
|
|
expected: "function",
|
|
input: payload.value,
|
|
inst,
|
|
});
|
|
return payload;
|
|
}
|
|
// Check if output is a promise type to determine if we should use async implementation
|
|
const hasPromiseOutput = inst._def.output && inst._def.output._zod.def.type === "promise";
|
|
if (hasPromiseOutput) {
|
|
payload.value = inst.implementAsync(payload.value);
|
|
}
|
|
else {
|
|
payload.value = inst.implement(payload.value);
|
|
}
|
|
return payload;
|
|
};
|
|
inst.input = (...args) => {
|
|
const F = inst.constructor;
|
|
if (Array.isArray(args[0])) {
|
|
return new F({
|
|
type: "function",
|
|
input: new exports.$ZodTuple({
|
|
type: "tuple",
|
|
items: args[0],
|
|
rest: args[1],
|
|
}),
|
|
output: inst._def.output,
|
|
});
|
|
}
|
|
return new F({
|
|
type: "function",
|
|
input: args[0],
|
|
output: inst._def.output,
|
|
});
|
|
};
|
|
inst.output = (output) => {
|
|
const F = inst.constructor;
|
|
return new F({
|
|
type: "function",
|
|
input: inst._def.input,
|
|
output,
|
|
});
|
|
};
|
|
return inst;
|
|
});
|
|
exports.$ZodPromise = core.$constructor("$ZodPromise", (inst, def) => {
|
|
exports.$ZodType.init(inst, def);
|
|
inst._zod.parse = (payload, ctx) => {
|
|
return Promise.resolve(payload.value).then((inner) => def.innerType._zod.run({ value: inner, issues: [] }, ctx));
|
|
};
|
|
});
|
|
exports.$ZodLazy = core.$constructor("$ZodLazy", (inst, def) => {
|
|
exports.$ZodType.init(inst, def);
|
|
// let _innerType!: any;
|
|
// util.defineLazy(def, "getter", () => {
|
|
// if (!_innerType) {
|
|
// _innerType = def.getter();
|
|
// }
|
|
// return () => _innerType;
|
|
// });
|
|
util.defineLazy(inst._zod, "innerType", () => def.getter());
|
|
util.defineLazy(inst._zod, "pattern", () => inst._zod.innerType._zod.pattern);
|
|
util.defineLazy(inst._zod, "propValues", () => inst._zod.innerType._zod.propValues);
|
|
util.defineLazy(inst._zod, "optin", () => inst._zod.innerType._zod.optin ?? undefined);
|
|
util.defineLazy(inst._zod, "optout", () => inst._zod.innerType._zod.optout ?? undefined);
|
|
inst._zod.parse = (payload, ctx) => {
|
|
const inner = inst._zod.innerType;
|
|
return inner._zod.run(payload, ctx);
|
|
};
|
|
});
|
|
exports.$ZodCustom = core.$constructor("$ZodCustom", (inst, def) => {
|
|
checks.$ZodCheck.init(inst, def);
|
|
exports.$ZodType.init(inst, def);
|
|
inst._zod.parse = (payload, _) => {
|
|
return payload;
|
|
};
|
|
inst._zod.check = (payload) => {
|
|
const input = payload.value;
|
|
const r = def.fn(input);
|
|
if (r instanceof Promise) {
|
|
return r.then((r) => handleRefineResult(r, payload, input, inst));
|
|
}
|
|
handleRefineResult(r, payload, input, inst);
|
|
return;
|
|
};
|
|
});
|
|
function handleRefineResult(result, payload, input, inst) {
|
|
if (!result) {
|
|
const _iss = {
|
|
code: "custom",
|
|
input,
|
|
inst, // incorporates params.error into issue reporting
|
|
path: [...(inst._zod.def.path ?? [])], // incorporates params.error into issue reporting
|
|
continue: !inst._zod.def.abort,
|
|
// params: inst._zod.def.params,
|
|
};
|
|
if (inst._zod.def.params)
|
|
_iss.params = inst._zod.def.params;
|
|
payload.issues.push(util.issue(_iss));
|
|
}
|
|
}
|