export namespace util { type AssertEqual = (() => V extends T ? 1 : 2) extends () => V extends U ? 1 : 2 ? true : false; export type isAny = 0 extends 1 & T ? true : false; export const assertEqual = (_: AssertEqual): void => {}; export function assertIs(_arg: T): void {} export function assertNever(_x: never): never { throw new Error(); } export type Omit = Pick>; export type OmitKeys = Pick>; export type MakePartial = Omit & Partial>; export type Exactly = T & Record, never>; export type InexactPartial = { [k in keyof T]?: T[k] | undefined }; export const arrayToEnum = (items: U): { [k in U[number]]: k } => { const obj: any = {}; for (const item of items) { obj[item] = item; } return obj; }; export const getValidEnumValues = (obj: any): any[] => { const validKeys = objectKeys(obj).filter((k: any) => typeof obj[obj[k]] !== "number"); const filtered: any = {}; for (const k of validKeys) { filtered[k] = obj[k]; } return objectValues(filtered); }; export const objectValues = (obj: any): any[] => { return objectKeys(obj).map(function (e) { return obj[e]; }); }; export const objectKeys: ObjectConstructor["keys"] = typeof Object.keys === "function" // eslint-disable-line ban/ban ? (obj: any) => Object.keys(obj) // eslint-disable-line ban/ban : (object: any) => { const keys = []; for (const key in object) { if (Object.prototype.hasOwnProperty.call(object, key)) { keys.push(key); } } return keys; }; export const find = (arr: T[], checker: (arg: T) => any): T | undefined => { for (const item of arr) { if (checker(item)) return item; } return undefined; }; export type identity = objectUtil.identity; export type flatten = objectUtil.flatten; export type noUndefined = T extends undefined ? never : T; export const isInteger: NumberConstructor["isInteger"] = typeof Number.isInteger === "function" ? (val) => Number.isInteger(val) // eslint-disable-line ban/ban : (val) => typeof val === "number" && Number.isFinite(val) && Math.floor(val) === val; export function joinValues(array: T, separator = " | "): string { return array.map((val) => (typeof val === "string" ? `'${val}'` : val)).join(separator); } export const jsonStringifyReplacer = (_: string, value: any): any => { if (typeof value === "bigint") { return value.toString(); } return value; }; } export namespace objectUtil { export type MergeShapes = // fast path when there is no keys overlap keyof U & keyof V extends never ? U & V : { [k in Exclude]: U[k]; } & V; type optionalKeys = { [k in keyof T]: undefined extends T[k] ? k : never; }[keyof T]; type requiredKeys = { [k in keyof T]: undefined extends T[k] ? never : k; }[keyof T]; export type addQuestionMarks = { [K in requiredKeys]: T[K]; } & { [K in optionalKeys]?: T[K]; } & { [k in keyof T]?: unknown }; export type identity = T; export type flatten = identity<{ [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 const mergeShapes = (first: U, second: T): T & U => { return { ...first, ...second, // second overwrites first }; }; export type extendShape = keyof A & keyof B extends never // fast path when there is no keys overlap ? A & B : { [K in keyof A as K extends keyof B ? never : K]: A[K]; } & { [K in keyof B]: B[K]; }; } export const ZodParsedType: { string: "string"; nan: "nan"; number: "number"; integer: "integer"; float: "float"; boolean: "boolean"; date: "date"; bigint: "bigint"; symbol: "symbol"; function: "function"; undefined: "undefined"; null: "null"; array: "array"; object: "object"; unknown: "unknown"; promise: "promise"; void: "void"; never: "never"; map: "map"; set: "set"; } = util.arrayToEnum([ "string", "nan", "number", "integer", "float", "boolean", "date", "bigint", "symbol", "function", "undefined", "null", "array", "object", "unknown", "promise", "void", "never", "map", "set", ]); export type ZodParsedType = keyof typeof ZodParsedType; export const getParsedType = (data: any): ZodParsedType => { const t = typeof data; switch (t) { case "undefined": return ZodParsedType.undefined; case "string": return ZodParsedType.string; case "number": return Number.isNaN(data) ? ZodParsedType.nan : ZodParsedType.number; case "boolean": return ZodParsedType.boolean; case "function": return ZodParsedType.function; case "bigint": return ZodParsedType.bigint; case "symbol": return ZodParsedType.symbol; case "object": if (Array.isArray(data)) { return ZodParsedType.array; } if (data === null) { return ZodParsedType.null; } if (data.then && typeof data.then === "function" && data.catch && typeof data.catch === "function") { return ZodParsedType.promise; } if (typeof Map !== "undefined" && data instanceof Map) { return ZodParsedType.map; } if (typeof Set !== "undefined" && data instanceof Set) { return ZodParsedType.set; } if (typeof Date !== "undefined" && data instanceof Date) { return ZodParsedType.date; } return ZodParsedType.object; default: return ZodParsedType.unknown; } };