import type * as checks from "./checks.js"; import type { $ZodConfig } from "./core.js"; import type * as errors from "./errors.js"; import type * as schemas from "./schemas.js"; // json export type JSONType = string | number | boolean | null | JSONType[] | { [key: string]: JSONType }; export type JWTAlgorithm = | "HS256" | "HS384" | "HS512" | "RS256" | "RS384" | "RS512" | "ES256" | "ES384" | "ES512" | "PS256" | "PS384" | "PS512" | "EdDSA" | (string & {}); export type IPVersion = "v4" | "v6"; export type MimeTypes = | "application/json" | "application/xml" | "application/x-www-form-urlencoded" | "application/javascript" | "application/pdf" | "application/zip" | "application/vnd.ms-excel" | "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" | "application/msword" | "application/vnd.openxmlformats-officedocument.wordprocessingml.document" | "application/vnd.ms-powerpoint" | "application/vnd.openxmlformats-officedocument.presentationml.presentation" | "application/octet-stream" | "application/graphql" | "text/html" | "text/plain" | "text/css" | "text/javascript" | "text/csv" | "image/png" | "image/jpeg" | "image/gif" | "image/svg+xml" | "image/webp" | "audio/mpeg" | "audio/ogg" | "audio/wav" | "audio/webm" | "video/mp4" | "video/webm" | "video/ogg" | "font/woff" | "font/woff2" | "font/ttf" | "font/otf" | "multipart/form-data" | (string & {}); export type ParsedTypes = | "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function" | "file" | "date" | "array" | "map" | "set" | "nan" | "null" | "promise"; // utils export type AssertEqual = (() => V extends T ? 1 : 2) extends () => V extends U ? 1 : 2 ? true : false; export type AssertNotEqual = (() => V extends T ? 1 : 2) extends () => V extends U ? 1 : 2 ? false : true; export type AssertExtends = T extends U ? T : never; export type IsAny = 0 extends 1 & T ? true : false; export type Omit = Pick>; export type OmitKeys = Pick>; export type MakePartial = Omit & InexactPartial>; export type MakeRequired = Omit & Required>; export type Exactly = T & Record, never>; export type NoUndefined = T extends undefined ? never : T; export type Whatever = {} | undefined | null; export type LoosePartial = InexactPartial & { [k: string]: unknown; }; export type Mask = { [K in Keys]?: true }; export type Writeable = { -readonly [P in keyof T]: T[P] } & {}; export type InexactPartial = { [P in keyof T]?: T[P] | undefined; }; export type EmptyObject = Record; export type BuiltIn = | (((...args: any[]) => any) | (new (...args: any[]) => any)) | { readonly [Symbol.toStringTag]: string } | Date | Error | Generator | Promise | RegExp; export type MakeReadonly = T extends Map ? ReadonlyMap : T extends Set ? ReadonlySet : T extends [infer Head, ...infer Tail] ? readonly [Head, ...Tail] : T extends Array ? ReadonlyArray : T extends BuiltIn ? T : Readonly; export type SomeObject = Record; export type Identity = T; export type Flatten = Identity<{ [k in keyof T]: T[k] }>; export type Mapped = { [k in keyof T]: T[k] }; export type Prettify = { [K in keyof T]: T[K]; } & {}; export type NoNeverKeys = { [k in keyof T]: [T[k]] extends [never] ? never : k; }[keyof T]; export type NoNever = Identity<{ [k in NoNeverKeys]: k extends keyof T ? T[k] : never; }>; export type Extend = Flatten< // fast path when there is no keys overlap keyof A & keyof B extends never ? A & B : { [K in keyof A as K extends keyof B ? never : K]: A[K]; } & { [K in keyof B]: B[K]; } >; export type TupleItems = ReadonlyArray; export type AnyFunc = (...args: any[]) => any; export type IsProp = T[K] extends AnyFunc ? never : K; export type MaybeAsync = T | Promise; export type KeyOf = keyof OmitIndexSignature; export type OmitIndexSignature = { [K in keyof T as string extends K ? never : K extends string ? K : never]: T[K]; }; export type ExtractIndexSignature = { [K in keyof T as string extends K ? K : K extends string ? never : K]: T[K]; }; export type Keys = keyof OmitIndexSignature; export type SchemaClass = { new (def: T["_zod"]["def"]): T; }; export type EnumValue = string | number; // | bigint | boolean | symbol; export type EnumLike = Readonly>; export type ToEnum = Flatten<{ [k in T]: k }>; export type KeysEnum = ToEnum>; export type KeysArray = Flatten<(keyof T & string)[]>; export type Literal = string | number | bigint | boolean | null | undefined; export type LiteralArray = Array; export type Primitive = string | number | symbol | bigint | boolean | null | undefined; export type PrimitiveArray = Array; export type HasSize = { size: number }; export type HasLength = { length: number }; // string | Array | Set | File; export type Numeric = number | bigint | Date; export type SafeParseResult = SafeParseSuccess | SafeParseError; export type SafeParseSuccess = { success: true; data: T; error?: never }; export type SafeParseError = { success: false; data?: never; error: errors.$ZodError; }; export type PropValues = Record>; export type PrimitiveSet = Set; // functions export function assertEqual(val: AssertEqual): AssertEqual { return val; } export function assertNotEqual(val: AssertNotEqual): AssertNotEqual { return val; } export function assertIs(_arg: T): void {} export function assertNever(_x: never): never { throw new Error(); } export function assert(_: any): asserts _ is T {} export function getEnumValues(entries: EnumLike): EnumValue[] { const numericValues = Object.values(entries).filter((v) => typeof v === "number"); const values = Object.entries(entries) .filter(([k, _]) => numericValues.indexOf(+k) === -1) .map(([_, v]) => v); return values; } export function joinValues(array: T, separator = "|"): string { return array.map((val) => stringifyPrimitive(val)).join(separator); } export function jsonStringifyReplacer(_: string, value: any): any { if (typeof value === "bigint") return value.toString(); return value; } export function cached(getter: () => T): { value: T } { const set = false; return { get value() { if (!set) { const value = getter(); Object.defineProperty(this, "value", { value }); return value; } throw new Error("cached value already set"); }, }; } export function nullish(input: any): boolean { return input === null || input === undefined; } export function cleanRegex(source: string): string { const start = source.startsWith("^") ? 1 : 0; const end = source.endsWith("$") ? source.length - 1 : source.length; return source.slice(start, end); } export function floatSafeRemainder(val: number, step: number): number { const valDecCount = (val.toString().split(".")[1] || "").length; const stepDecCount = (step.toString().split(".")[1] || "").length; const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount; const valInt = Number.parseInt(val.toFixed(decCount).replace(".", "")); const stepInt = Number.parseInt(step.toFixed(decCount).replace(".", "")); return (valInt % stepInt) / 10 ** decCount; } export function defineLazy(object: T, key: K, getter: () => T[K]): void { const set = false; Object.defineProperty(object, key, { get() { if (!set) { const value = getter(); object[key] = value; return value; } throw new Error("cached value already set"); }, set(v) { Object.defineProperty(object, key, { value: v, // configurable: true, }); // object[key] = v; }, configurable: true, }); } export function assignProp( target: T, prop: K, value: K extends keyof T ? T[K] : any ): void { Object.defineProperty(target, prop, { value, writable: true, enumerable: true, configurable: true, }); } export function getElementAtPath(obj: any, path: (string | number)[] | null | undefined): any { if (!path) return obj; return path.reduce((acc, key) => acc?.[key], obj); } export function promiseAllObject(promisesObj: T): Promise<{ [k in keyof T]: Awaited }> { const keys = Object.keys(promisesObj); const promises = keys.map((key) => (promisesObj as any)[key]); return Promise.all(promises).then((results) => { const resolvedObj: any = {}; for (let i = 0; i < keys.length; i++) { resolvedObj[keys[i]!] = results[i]; } return resolvedObj; }); } export function randomString(length = 10): string { const chars = "abcdefghijklmnopqrstuvwxyz"; let str = ""; for (let i = 0; i < length; i++) { str += chars[Math.floor(Math.random() * chars.length)]; } return str; } export function esc(str: string): string { return JSON.stringify(str); } export const captureStackTrace: (targetObject: object, constructorOpt?: Function) => void = Error.captureStackTrace ? Error.captureStackTrace : (..._args) => {}; export function isObject(data: any): data is Record { return typeof data === "object" && data !== null && !Array.isArray(data); } export const allowsEval: { value: boolean } = cached(() => { if (typeof navigator !== "undefined" && navigator?.userAgent?.includes("Cloudflare")) { return false; } try { const F = Function; new F(""); return true; } catch (_) { return false; } }); export function isPlainObject(o: any): o is Record { if (isObject(o) === false) return false; // modified constructor const ctor = o.constructor; if (ctor === undefined) return true; // modified prototype const prot = ctor.prototype; if (isObject(prot) === false) return false; // ctor doesn't have static `isPrototypeOf` if (Object.prototype.hasOwnProperty.call(prot, "isPrototypeOf") === false) { return false; } return true; } export function numKeys(data: any): number { let keyCount = 0; for (const key in data) { if (Object.prototype.hasOwnProperty.call(data, key)) { keyCount++; } } return keyCount; } export const getParsedType = (data: any): ParsedTypes => { const t = typeof data; switch (t) { case "undefined": return "undefined"; case "string": return "string"; case "number": return Number.isNaN(data) ? "nan" : "number"; case "boolean": return "boolean"; case "function": return "function"; case "bigint": return "bigint"; case "symbol": return "symbol"; case "object": if (Array.isArray(data)) { return "array"; } if (data === null) { return "null"; } if (data.then && typeof data.then === "function" && data.catch && typeof data.catch === "function") { return "promise"; } if (typeof Map !== "undefined" && data instanceof Map) { return "map"; } if (typeof Set !== "undefined" && data instanceof Set) { return "set"; } if (typeof Date !== "undefined" && data instanceof Date) { return "date"; } if (typeof File !== "undefined" && data instanceof File) { return "file"; } return "object"; default: throw new Error(`Unknown data type: ${t}`); } }; export const propertyKeyTypes: Set = new Set(["string", "number", "symbol"]); export const primitiveTypes: Set = new Set(["string", "number", "bigint", "boolean", "symbol", "undefined"]); export function escapeRegex(str: string): string { return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"); } // zod-specific utils export function clone(inst: T, def?: T["_zod"]["def"], params?: { parent: boolean }): T { const cl = new inst._zod.constr(def ?? inst._zod.def); if (!def || params?.parent) cl._zod.parent = inst; return cl as any; } export type EmptyToNever = keyof T extends never ? never : T; export type Normalize = T extends undefined ? never : T extends Record ? Flatten< { [k in keyof Omit]: T[k]; } & ("error" extends keyof T ? { error?: Exclude; // path?: PropertyKey[] | undefined; // message?: string | undefined; } : unknown) > : never; export function normalizeParams(_params: T): Normalize { const params: any = _params; if (!params) return {} as any; if (typeof params === "string") return { error: () => params } as any; if (params?.message !== undefined) { if (params?.error !== undefined) throw new Error("Cannot specify both `message` and `error` params"); params.error = params.message; } delete params.message; if (typeof params.error === "string") return { ...params, error: () => params.error } as any; return params; } export function createTransparentProxy(getter: () => T): T { let target: T; return new Proxy( {}, { get(_, prop, receiver) { target ??= getter(); return Reflect.get(target, prop, receiver); }, set(_, prop, value, receiver) { target ??= getter(); return Reflect.set(target, prop, value, receiver); }, has(_, prop) { target ??= getter(); return Reflect.has(target, prop); }, deleteProperty(_, prop) { target ??= getter(); return Reflect.deleteProperty(target, prop); }, ownKeys(_) { target ??= getter(); return Reflect.ownKeys(target); }, getOwnPropertyDescriptor(_, prop) { target ??= getter(); return Reflect.getOwnPropertyDescriptor(target, prop); }, defineProperty(_, prop, descriptor) { target ??= getter(); return Reflect.defineProperty(target, prop, descriptor); }, } ) as T; } export function stringifyPrimitive(value: any): string { if (typeof value === "bigint") return value.toString() + "n"; if (typeof value === "string") return `"${value}"`; return `${value}`; } export function optionalKeys(shape: schemas.$ZodShape): string[] { return Object.keys(shape).filter((k) => { return shape[k]!._zod.optin === "optional" && shape[k]!._zod.optout === "optional"; }); } export type CleanKey = T extends `?${infer K}` ? K : T extends `${infer K}?` ? K : T; export type ToCleanMap = { [k in keyof T]: k extends `?${infer K}` ? K : k extends `${infer K}?` ? K : k; }; export type FromCleanMap = { [k in keyof T as k extends `?${infer K}` ? K : k extends `${infer K}?` ? K : k]: k; }; export const NUMBER_FORMAT_RANGES: Record = { safeint: [Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER], int32: [-2147483648, 2147483647], uint32: [0, 4294967295], float32: [-3.4028234663852886e38, 3.4028234663852886e38], float64: [-Number.MAX_VALUE, Number.MAX_VALUE], }; export const BIGINT_FORMAT_RANGES: Record = { int64: [/* @__PURE__*/ BigInt("-9223372036854775808"), /* @__PURE__*/ BigInt("9223372036854775807")], uint64: [/* @__PURE__*/ BigInt(0), /* @__PURE__*/ BigInt("18446744073709551615")], }; export function pick(schema: schemas.$ZodObject, mask: Record): any { const newShape: Writeable = {}; const currDef = schema._zod.def; //.shape; for (const key in mask) { if (!(key in currDef.shape)) { throw new Error(`Unrecognized key: "${key}"`); } if (!mask[key]) continue; // pick key newShape[key] = currDef.shape[key]!; } return clone(schema, { ...schema._zod.def, shape: newShape, checks: [], }) as any; } export function omit(schema: schemas.$ZodObject, mask: object): any { const newShape: Writeable = { ...schema._zod.def.shape }; const currDef = schema._zod.def; //.shape; for (const key in mask) { if (!(key in currDef.shape)) { throw new Error(`Unrecognized key: "${key}"`); } if (!(mask as any)[key]) continue; delete newShape[key]; } return clone(schema, { ...schema._zod.def, shape: newShape, checks: [], }); } export function extend(schema: schemas.$ZodObject, shape: schemas.$ZodShape): any { if (!isPlainObject(shape)) { throw new Error("Invalid input to extend: expected a plain object"); } const def = { ...schema._zod.def, get shape() { const _shape = { ...schema._zod.def.shape, ...shape }; assignProp(this, "shape", _shape); // self-caching return _shape; }, checks: [], // delete existing checks } as any; return clone(schema, def) as any; } export function merge(a: schemas.$ZodObject, b: schemas.$ZodObject): any { return clone(a, { ...a._zod.def, get shape() { const _shape = { ...a._zod.def.shape, ...b._zod.def.shape }; assignProp(this, "shape", _shape); // self-caching return _shape; }, catchall: b._zod.def.catchall, checks: [], // delete existing checks }) as any; } export function partial( Class: SchemaClass | null, schema: schemas.$ZodObject, mask: object | undefined ): any { const oldShape = schema._zod.def.shape; const shape: Writeable = { ...oldShape }; if (mask) { for (const key in mask) { if (!(key in oldShape)) { throw new Error(`Unrecognized key: "${key}"`); } if (!(mask as any)[key]) continue; // if (oldShape[key]!._zod.optin === "optional") continue; shape[key] = Class ? new Class({ type: "optional", innerType: oldShape[key]!, }) : oldShape[key]!; } } else { for (const key in oldShape) { // if (oldShape[key]!._zod.optin === "optional") continue; shape[key] = Class ? new Class({ type: "optional", innerType: oldShape[key]!, }) : oldShape[key]!; } } return clone(schema, { ...schema._zod.def, shape, checks: [], }) as any; } export function required( Class: SchemaClass, schema: schemas.$ZodObject, mask: object | undefined ): any { const oldShape = schema._zod.def.shape; const shape: Writeable = { ...oldShape }; if (mask) { for (const key in mask) { if (!(key in shape)) { throw new Error(`Unrecognized key: "${key}"`); } if (!(mask as any)[key]) continue; // overwrite with non-optional shape[key] = new Class({ type: "nonoptional", innerType: oldShape[key]!, }); } } else { for (const key in oldShape) { // overwrite with non-optional shape[key] = new Class({ type: "nonoptional", innerType: oldShape[key]!, }); } } return clone(schema, { ...schema._zod.def, shape, // optional: [], checks: [], }) as any; } export type Constructor = new (...args: Def) => T; export function aborted(x: schemas.ParsePayload, startIndex = 0): boolean { for (let i = startIndex; i < x.issues.length; i++) { if (x.issues[i]?.continue !== true) return true; } return false; } export function prefixIssues(path: PropertyKey, issues: errors.$ZodRawIssue[]): errors.$ZodRawIssue[] { return issues.map((iss) => { (iss as any).path ??= []; (iss as any).path.unshift(path); return iss; }); } export function unwrapMessage(message: string | { message: string } | undefined | null): string | undefined { return typeof message === "string" ? message : message?.message; } export function finalizeIssue( iss: errors.$ZodRawIssue, ctx: schemas.ParseContextInternal | undefined, config: $ZodConfig ): errors.$ZodIssue { const full = { ...iss, path: iss.path ?? [] } as errors.$ZodIssue; // for backwards compatibility if (!iss.message) { const message = unwrapMessage(iss.inst?._zod.def?.error?.(iss as never)) ?? unwrapMessage(ctx?.error?.(iss as never)) ?? unwrapMessage(config.customError?.(iss)) ?? unwrapMessage(config.localeError?.(iss)) ?? "Invalid input"; (full as any).message = message; } // delete (full as any).def; delete (full as any).inst; delete (full as any).continue; if (!ctx?.reportInput) { delete (full as any).input; } return full; } export function getSizableOrigin(input: any): "set" | "map" | "file" | "unknown" { if (input instanceof Set) return "set"; if (input instanceof Map) return "map"; if (input instanceof File) return "file"; return "unknown"; } export function getLengthableOrigin(input: any): "array" | "string" | "unknown" { if (Array.isArray(input)) return "array"; if (typeof input === "string") return "string"; return "unknown"; } ////////// REFINES ////////// export function issue(_iss: string, input: any, inst: any): errors.$ZodRawIssue; export function issue(_iss: errors.$ZodRawIssue): errors.$ZodRawIssue; export function issue(...args: [string | errors.$ZodRawIssue, any?, any?]): errors.$ZodRawIssue { const [iss, input, inst] = args; if (typeof iss === "string") { return { message: iss, code: "custom", input, inst, }; } return { ...iss }; } export function cleanEnum(obj: Record): EnumValue[] { return Object.entries(obj) .filter(([k, _]) => { // return true if NaN, meaning it's not a number, thus a string key return Number.isNaN(Number.parseInt(k, 10)); }) .map((el) => el[1]); } // instanceof export abstract class Class { constructor(..._args: any[]) {} }