forked from WikiDeck/wikideck
v2
This commit is contained in:
+1269
File diff suppressed because it is too large
Load Diff
+335
@@ -0,0 +1,335 @@
|
||||
import * as checks from "./checks.cjs";
|
||||
import type * as core from "./core.cjs";
|
||||
import type * as errors from "./errors.cjs";
|
||||
import * as registries from "./registries.cjs";
|
||||
import * as schemas from "./schemas.cjs";
|
||||
import * as util from "./util.cjs";
|
||||
export type Params<T extends schemas.$ZodType | checks.$ZodCheck, IssueTypes extends errors.$ZodIssueBase, OmitKeys extends keyof T["_zod"]["def"] = never> = util.Flatten<Partial<util.EmptyToNever<Omit<T["_zod"]["def"], OmitKeys> & ([IssueTypes] extends [never] ? {} : {
|
||||
error?: string | errors.$ZodErrorMap<IssueTypes> | undefined;
|
||||
/** @deprecated This parameter is deprecated. Use `error` instead. */
|
||||
message?: string | undefined;
|
||||
})>>>;
|
||||
export type TypeParams<T extends schemas.$ZodType = schemas.$ZodType & {
|
||||
_isst: never;
|
||||
}, AlsoOmit extends Exclude<keyof T["_zod"]["def"], "type" | "checks" | "error"> = never> = Params<T, NonNullable<T["_zod"]["isst"]>, "type" | "checks" | "error" | AlsoOmit>;
|
||||
export type CheckParams<T extends checks.$ZodCheck = checks.$ZodCheck, // & { _issc: never },
|
||||
AlsoOmit extends Exclude<keyof T["_zod"]["def"], "check" | "error"> = never> = Params<T, NonNullable<T["_zod"]["issc"]>, "check" | "error" | AlsoOmit>;
|
||||
export type StringFormatParams<T extends schemas.$ZodStringFormat = schemas.$ZodStringFormat, AlsoOmit extends Exclude<keyof T["_zod"]["def"], "type" | "coerce" | "checks" | "error" | "check" | "format"> = never> = Params<T, NonNullable<T["_zod"]["isst"] | T["_zod"]["issc"]>, "type" | "coerce" | "checks" | "error" | "check" | "format" | AlsoOmit>;
|
||||
export type CheckStringFormatParams<T extends schemas.$ZodStringFormat = schemas.$ZodStringFormat, AlsoOmit extends Exclude<keyof T["_zod"]["def"], "type" | "coerce" | "checks" | "error" | "check" | "format"> = never> = Params<T, NonNullable<T["_zod"]["issc"]>, "type" | "coerce" | "checks" | "error" | "check" | "format" | AlsoOmit>;
|
||||
export type CheckTypeParams<T extends schemas.$ZodType & checks.$ZodCheck = schemas.$ZodType & checks.$ZodCheck, AlsoOmit extends Exclude<keyof T["_zod"]["def"], "type" | "checks" | "error" | "check"> = never> = Params<T, NonNullable<T["_zod"]["isst"] | T["_zod"]["issc"]>, "type" | "checks" | "error" | "check" | AlsoOmit>;
|
||||
export type $ZodStringParams = TypeParams<schemas.$ZodString<string>, "coerce"> & {
|
||||
checks?: readonly checks.$ZodCheck<string>[];
|
||||
};
|
||||
export declare function _string<T extends schemas.$ZodString>(Class: util.SchemaClass<T>, params?: string | $ZodStringParams): T;
|
||||
export declare function _coercedString<T extends schemas.$ZodString>(Class: util.SchemaClass<T>, params?: string | $ZodStringParams): T;
|
||||
export type $ZodStringFormatParams = CheckTypeParams<schemas.$ZodStringFormat, "format" | "coerce" | "when" | "pattern">;
|
||||
export type $ZodCheckStringFormatParams = CheckParams<checks.$ZodCheckStringFormat, "format">;
|
||||
export type $ZodEmailParams = StringFormatParams<schemas.$ZodEmail, "when">;
|
||||
export type $ZodCheckEmailParams = CheckStringFormatParams<schemas.$ZodEmail, "when">;
|
||||
export declare function _email<T extends schemas.$ZodEmail>(Class: util.SchemaClass<T>, params?: string | $ZodEmailParams | $ZodCheckEmailParams): T;
|
||||
export type $ZodGUIDParams = StringFormatParams<schemas.$ZodGUID, "pattern" | "when">;
|
||||
export type $ZodCheckGUIDParams = CheckStringFormatParams<schemas.$ZodGUID, "pattern" | "when">;
|
||||
export declare function _guid<T extends schemas.$ZodGUID>(Class: util.SchemaClass<T>, params?: string | $ZodGUIDParams | $ZodCheckGUIDParams): T;
|
||||
export type $ZodUUIDParams = StringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
|
||||
export type $ZodCheckUUIDParams = CheckStringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
|
||||
export declare function _uuid<T extends schemas.$ZodUUID>(Class: util.SchemaClass<T>, params?: string | $ZodUUIDParams | $ZodCheckUUIDParams): T;
|
||||
export type $ZodUUIDv4Params = StringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
|
||||
export type $ZodCheckUUIDv4Params = CheckStringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
|
||||
export declare function _uuidv4<T extends schemas.$ZodUUID>(Class: util.SchemaClass<T>, params?: string | $ZodUUIDv4Params | $ZodCheckUUIDv4Params): T;
|
||||
export type $ZodUUIDv6Params = StringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
|
||||
export type $ZodCheckUUIDv6Params = CheckStringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
|
||||
export declare function _uuidv6<T extends schemas.$ZodUUID>(Class: util.SchemaClass<T>, params?: string | $ZodUUIDv6Params | $ZodCheckUUIDv6Params): T;
|
||||
export type $ZodUUIDv7Params = StringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
|
||||
export type $ZodCheckUUIDv7Params = CheckStringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
|
||||
export declare function _uuidv7<T extends schemas.$ZodUUID>(Class: util.SchemaClass<T>, params?: string | $ZodUUIDv7Params | $ZodCheckUUIDv7Params): T;
|
||||
export type $ZodURLParams = StringFormatParams<schemas.$ZodURL, "when">;
|
||||
export type $ZodCheckURLParams = CheckStringFormatParams<schemas.$ZodURL, "when">;
|
||||
export declare function _url<T extends schemas.$ZodURL>(Class: util.SchemaClass<T>, params?: string | $ZodURLParams | $ZodCheckURLParams): T;
|
||||
export type $ZodEmojiParams = StringFormatParams<schemas.$ZodEmoji, "when">;
|
||||
export type $ZodCheckEmojiParams = CheckStringFormatParams<schemas.$ZodEmoji, "when">;
|
||||
export declare function _emoji<T extends schemas.$ZodEmoji>(Class: util.SchemaClass<T>, params?: string | $ZodEmojiParams | $ZodCheckEmojiParams): T;
|
||||
export type $ZodNanoIDParams = StringFormatParams<schemas.$ZodNanoID, "when" | "pattern">;
|
||||
export type $ZodCheckNanoIDParams = CheckStringFormatParams<schemas.$ZodNanoID, "when" | "pattern">;
|
||||
export declare function _nanoid<T extends schemas.$ZodNanoID>(Class: util.SchemaClass<T>, params?: string | $ZodNanoIDParams | $ZodCheckNanoIDParams): T;
|
||||
/**
|
||||
* @deprecated CUID v1 is deprecated by its authors due to information leakage
|
||||
* (timestamps embedded in the id). Use {@link _cuid2} instead.
|
||||
* See https://github.com/paralleldrive/cuid.
|
||||
*/
|
||||
export type $ZodCUIDParams = StringFormatParams<schemas.$ZodCUID, "when">;
|
||||
/**
|
||||
* @deprecated CUID v1 is deprecated by its authors due to information leakage
|
||||
* (timestamps embedded in the id). Use {@link _cuid2} instead.
|
||||
* See https://github.com/paralleldrive/cuid.
|
||||
*/
|
||||
export type $ZodCheckCUIDParams = CheckStringFormatParams<schemas.$ZodCUID, "when">;
|
||||
/**
|
||||
* @deprecated CUID v1 is deprecated by its authors due to information leakage
|
||||
* (timestamps embedded in the id). Use {@link _cuid2} instead.
|
||||
* See https://github.com/paralleldrive/cuid.
|
||||
*/
|
||||
export declare function _cuid<T extends schemas.$ZodCUID>(Class: util.SchemaClass<T>, params?: string | $ZodCUIDParams | $ZodCheckCUIDParams): T;
|
||||
export type $ZodCUID2Params = StringFormatParams<schemas.$ZodCUID2, "when">;
|
||||
export type $ZodCheckCUID2Params = CheckStringFormatParams<schemas.$ZodCUID2, "when">;
|
||||
export declare function _cuid2<T extends schemas.$ZodCUID2>(Class: util.SchemaClass<T>, params?: string | $ZodCUID2Params | $ZodCheckCUID2Params): T;
|
||||
export type $ZodULIDParams = StringFormatParams<schemas.$ZodULID, "when">;
|
||||
export type $ZodCheckULIDParams = CheckStringFormatParams<schemas.$ZodULID, "when">;
|
||||
export declare function _ulid<T extends schemas.$ZodULID>(Class: util.SchemaClass<T>, params?: string | $ZodULIDParams | $ZodCheckULIDParams): T;
|
||||
export type $ZodXIDParams = StringFormatParams<schemas.$ZodXID, "when">;
|
||||
export type $ZodCheckXIDParams = CheckStringFormatParams<schemas.$ZodXID, "when">;
|
||||
export declare function _xid<T extends schemas.$ZodXID>(Class: util.SchemaClass<T>, params?: string | $ZodXIDParams | $ZodCheckXIDParams): T;
|
||||
export type $ZodKSUIDParams = StringFormatParams<schemas.$ZodKSUID, "when">;
|
||||
export type $ZodCheckKSUIDParams = CheckStringFormatParams<schemas.$ZodKSUID, "when">;
|
||||
export declare function _ksuid<T extends schemas.$ZodKSUID>(Class: util.SchemaClass<T>, params?: string | $ZodKSUIDParams | $ZodCheckKSUIDParams): T;
|
||||
export type $ZodIPv4Params = StringFormatParams<schemas.$ZodIPv4, "pattern" | "when" | "version">;
|
||||
export type $ZodCheckIPv4Params = CheckStringFormatParams<schemas.$ZodIPv4, "pattern" | "when" | "version">;
|
||||
export declare function _ipv4<T extends schemas.$ZodIPv4>(Class: util.SchemaClass<T>, params?: string | $ZodIPv4Params | $ZodCheckIPv4Params): T;
|
||||
export type $ZodIPv6Params = StringFormatParams<schemas.$ZodIPv6, "pattern" | "when" | "version">;
|
||||
export type $ZodCheckIPv6Params = CheckStringFormatParams<schemas.$ZodIPv6, "pattern" | "when" | "version">;
|
||||
export declare function _ipv6<T extends schemas.$ZodIPv6>(Class: util.SchemaClass<T>, params?: string | $ZodIPv6Params | $ZodCheckIPv6Params): T;
|
||||
export type $ZodMACParams = StringFormatParams<schemas.$ZodMAC, "pattern" | "when">;
|
||||
export type $ZodCheckMACParams = CheckStringFormatParams<schemas.$ZodMAC, "pattern" | "when">;
|
||||
export declare function _mac<T extends schemas.$ZodMAC>(Class: util.SchemaClass<T>, params?: string | $ZodMACParams | $ZodCheckMACParams): T;
|
||||
export type $ZodCIDRv4Params = StringFormatParams<schemas.$ZodCIDRv4, "pattern" | "when">;
|
||||
export type $ZodCheckCIDRv4Params = CheckStringFormatParams<schemas.$ZodCIDRv4, "pattern" | "when">;
|
||||
export declare function _cidrv4<T extends schemas.$ZodCIDRv4>(Class: util.SchemaClass<T>, params?: string | $ZodCIDRv4Params | $ZodCheckCIDRv4Params): T;
|
||||
export type $ZodCIDRv6Params = StringFormatParams<schemas.$ZodCIDRv6, "pattern" | "when">;
|
||||
export type $ZodCheckCIDRv6Params = CheckStringFormatParams<schemas.$ZodCIDRv6, "pattern" | "when">;
|
||||
export declare function _cidrv6<T extends schemas.$ZodCIDRv6>(Class: util.SchemaClass<T>, params?: string | $ZodCIDRv6Params | $ZodCheckCIDRv6Params): T;
|
||||
export type $ZodBase64Params = StringFormatParams<schemas.$ZodBase64, "pattern" | "when">;
|
||||
export type $ZodCheckBase64Params = CheckStringFormatParams<schemas.$ZodBase64, "pattern" | "when">;
|
||||
export declare function _base64<T extends schemas.$ZodBase64>(Class: util.SchemaClass<T>, params?: string | $ZodBase64Params | $ZodCheckBase64Params): T;
|
||||
export type $ZodBase64URLParams = StringFormatParams<schemas.$ZodBase64URL, "pattern" | "when">;
|
||||
export type $ZodCheckBase64URLParams = CheckStringFormatParams<schemas.$ZodBase64URL, "pattern" | "when">;
|
||||
export declare function _base64url<T extends schemas.$ZodBase64URL>(Class: util.SchemaClass<T>, params?: string | $ZodBase64URLParams | $ZodCheckBase64URLParams): T;
|
||||
export type $ZodE164Params = StringFormatParams<schemas.$ZodE164, "when">;
|
||||
export type $ZodCheckE164Params = CheckStringFormatParams<schemas.$ZodE164, "when">;
|
||||
export declare function _e164<T extends schemas.$ZodE164>(Class: util.SchemaClass<T>, params?: string | $ZodE164Params | $ZodCheckE164Params): T;
|
||||
export type $ZodCreditCardParams = StringFormatParams<schemas.$ZodCreditCard, "pattern" | "when">;
|
||||
export type $ZodCheckCreditCardParams = CheckStringFormatParams<schemas.$ZodCreditCard, "pattern" | "when">;
|
||||
export declare function _creditCard<T extends schemas.$ZodCreditCard>(Class: util.SchemaClass<T>, params?: string | $ZodCreditCardParams | $ZodCheckCreditCardParams): T;
|
||||
export type $ZodIBANParams = StringFormatParams<schemas.$ZodIBAN, "pattern" | "when">;
|
||||
export type $ZodCheckIBANParams = CheckStringFormatParams<schemas.$ZodIBAN, "pattern" | "when">;
|
||||
export declare function _iban<T extends schemas.$ZodIBAN>(Class: util.SchemaClass<T>, params?: string | $ZodIBANParams | $ZodCheckIBANParams): T;
|
||||
export type $ZodJWTParams = StringFormatParams<schemas.$ZodJWT, "pattern" | "when">;
|
||||
export type $ZodCheckJWTParams = CheckStringFormatParams<schemas.$ZodJWT, "pattern" | "when">;
|
||||
export declare function _jwt<T extends schemas.$ZodJWT>(Class: util.SchemaClass<T>, params?: string | $ZodJWTParams | $ZodCheckJWTParams): T;
|
||||
export declare const TimePrecision: {
|
||||
readonly Any: null;
|
||||
readonly Minute: -1;
|
||||
readonly Second: 0;
|
||||
readonly Millisecond: 3;
|
||||
readonly Microsecond: 6;
|
||||
};
|
||||
export type $ZodISODateTimeParams = StringFormatParams<schemas.$ZodISODateTime, "pattern" | "when">;
|
||||
export type $ZodCheckISODateTimeParams = CheckStringFormatParams<schemas.$ZodISODateTime, "pattern" | "when">;
|
||||
export declare function _isoDateTime<T extends schemas.$ZodISODateTime>(Class: util.SchemaClass<T>, params?: string | $ZodISODateTimeParams | $ZodCheckISODateTimeParams): T;
|
||||
export type $ZodISODateParams = StringFormatParams<schemas.$ZodISODate, "pattern" | "when">;
|
||||
export type $ZodCheckISODateParams = CheckStringFormatParams<schemas.$ZodISODate, "pattern" | "when">;
|
||||
export declare function _isoDate<T extends schemas.$ZodISODate>(Class: util.SchemaClass<T>, params?: string | $ZodISODateParams | $ZodCheckISODateParams): T;
|
||||
export type $ZodISOTimeParams = StringFormatParams<schemas.$ZodISOTime, "pattern" | "when">;
|
||||
export type $ZodCheckISOTimeParams = CheckStringFormatParams<schemas.$ZodISOTime, "pattern" | "when">;
|
||||
export declare function _isoTime<T extends schemas.$ZodISOTime>(Class: util.SchemaClass<T>, params?: string | $ZodISOTimeParams | $ZodCheckISOTimeParams): T;
|
||||
export type $ZodISODurationParams = StringFormatParams<schemas.$ZodISODuration, "when">;
|
||||
export type $ZodCheckISODurationParams = CheckStringFormatParams<schemas.$ZodISODuration, "when">;
|
||||
export declare function _isoDuration<T extends schemas.$ZodISODuration>(Class: util.SchemaClass<T>, params?: string | $ZodISODurationParams | $ZodCheckISODurationParams): T;
|
||||
export type $ZodNumberParams = TypeParams<schemas.$ZodNumber<number>, "coerce"> & {
|
||||
checks?: readonly checks.$ZodCheck<number>[];
|
||||
};
|
||||
export type $ZodNumberFormatParams = CheckTypeParams<schemas.$ZodNumberFormat, "format" | "coerce">;
|
||||
export type $ZodCheckNumberFormatParams = CheckParams<checks.$ZodCheckNumberFormat, "format" | "when">;
|
||||
export declare function _number<T extends schemas.$ZodNumber>(Class: util.SchemaClass<T>, params?: string | $ZodNumberParams): T;
|
||||
export declare function _coercedNumber<T extends schemas.$ZodNumber>(Class: util.SchemaClass<T>, params?: string | $ZodNumberParams): T;
|
||||
export declare function _int<T extends schemas.$ZodNumberFormat>(Class: util.SchemaClass<T>, params?: string | $ZodCheckNumberFormatParams): T;
|
||||
export declare function _float32<T extends schemas.$ZodNumberFormat>(Class: util.SchemaClass<T>, params?: string | $ZodCheckNumberFormatParams): T;
|
||||
export declare function _float64<T extends schemas.$ZodNumberFormat>(Class: util.SchemaClass<T>, params?: string | $ZodCheckNumberFormatParams): T;
|
||||
export declare function _int32<T extends schemas.$ZodNumberFormat>(Class: util.SchemaClass<T>, params?: string | $ZodCheckNumberFormatParams): T;
|
||||
export declare function _uint32<T extends schemas.$ZodNumberFormat>(Class: util.SchemaClass<T>, params?: string | $ZodCheckNumberFormatParams): T;
|
||||
export type $ZodBooleanParams = TypeParams<schemas.$ZodBoolean<boolean>, "coerce">;
|
||||
export declare function _boolean<T extends schemas.$ZodBoolean>(Class: util.SchemaClass<T>, params?: string | $ZodBooleanParams): T;
|
||||
export declare function _coercedBoolean<T extends schemas.$ZodBoolean>(Class: util.SchemaClass<T>, params?: string | $ZodBooleanParams): T;
|
||||
export type $ZodBigIntParams = TypeParams<schemas.$ZodBigInt<bigint>>;
|
||||
export type $ZodBigIntFormatParams = CheckTypeParams<schemas.$ZodBigIntFormat, "format" | "coerce">;
|
||||
export type $ZodCheckBigIntFormatParams = CheckParams<checks.$ZodCheckBigIntFormat, "format" | "when">;
|
||||
export declare function _bigint<T extends schemas.$ZodBigInt>(Class: util.SchemaClass<T>, params?: string | $ZodBigIntParams): T;
|
||||
export declare function _coercedBigint<T extends schemas.$ZodBigInt>(Class: util.SchemaClass<T>, params?: string | $ZodBigIntParams): T;
|
||||
export declare function _int64<T extends schemas.$ZodBigIntFormat>(Class: util.SchemaClass<T>, params?: string | $ZodBigIntFormatParams): T;
|
||||
export declare function _uint64<T extends schemas.$ZodBigIntFormat>(Class: util.SchemaClass<T>, params?: string | $ZodBigIntFormatParams): T;
|
||||
export type $ZodSymbolParams = TypeParams<schemas.$ZodSymbol>;
|
||||
export declare function _symbol<T extends schemas.$ZodSymbol>(Class: util.SchemaClass<T>, params?: string | $ZodSymbolParams): T;
|
||||
export type $ZodUndefinedParams = TypeParams<schemas.$ZodUndefined>;
|
||||
export declare function _undefined<T extends schemas.$ZodUndefined>(Class: util.SchemaClass<T>, params?: string | $ZodUndefinedParams): T;
|
||||
export type $ZodNullParams = TypeParams<schemas.$ZodNull>;
|
||||
export declare function _null<T extends schemas.$ZodNull>(Class: util.SchemaClass<T>, params?: string | $ZodNullParams): T;
|
||||
export type $ZodAnyParams = TypeParams<schemas.$ZodAny>;
|
||||
export declare function _any<T extends schemas.$ZodAny>(Class: util.SchemaClass<T>): T;
|
||||
export type $ZodUnknownParams = TypeParams<schemas.$ZodUnknown>;
|
||||
export declare function _unknown<T extends schemas.$ZodUnknown>(Class: util.SchemaClass<T>): T;
|
||||
export type $ZodNeverParams = TypeParams<schemas.$ZodNever>;
|
||||
export declare function _never<T extends schemas.$ZodNever>(Class: util.SchemaClass<T>, params?: string | $ZodNeverParams): T;
|
||||
export type $ZodVoidParams = TypeParams<schemas.$ZodVoid>;
|
||||
export declare function _void<T extends schemas.$ZodVoid>(Class: util.SchemaClass<T>, params?: string | $ZodVoidParams): T;
|
||||
export type $ZodDateParams = TypeParams<schemas.$ZodDate, "coerce">;
|
||||
export declare function _date<T extends schemas.$ZodDate>(Class: util.SchemaClass<T>, params?: string | $ZodDateParams): T;
|
||||
export declare function _coercedDate<T extends schemas.$ZodDate>(Class: util.SchemaClass<T>, params?: string | $ZodDateParams): T;
|
||||
export type $ZodNaNParams = TypeParams<schemas.$ZodNaN>;
|
||||
export declare function _nan<T extends schemas.$ZodNaN>(Class: util.SchemaClass<T>, params?: string | $ZodNaNParams): T;
|
||||
export type $ZodCheckLessThanParams = CheckParams<checks.$ZodCheckLessThan, "inclusive" | "value" | "when">;
|
||||
export declare function _lt(value: util.Numeric, params?: string | $ZodCheckLessThanParams): checks.$ZodCheckLessThan<util.Numeric>;
|
||||
export declare function _lte(value: util.Numeric, params?: string | $ZodCheckLessThanParams): checks.$ZodCheckLessThan<util.Numeric>;
|
||||
export {
|
||||
/** @deprecated Use `z.lte()` instead. */
|
||||
_lte as _max, };
|
||||
export type $ZodCheckGreaterThanParams = CheckParams<checks.$ZodCheckGreaterThan, "inclusive" | "value" | "when">;
|
||||
export declare function _gt(value: util.Numeric, params?: string | $ZodCheckGreaterThanParams): checks.$ZodCheckGreaterThan;
|
||||
export declare function _gte(value: util.Numeric, params?: string | $ZodCheckGreaterThanParams): checks.$ZodCheckGreaterThan;
|
||||
export {
|
||||
/** @deprecated Use `z.gte()` instead. */
|
||||
_gte as _min, };
|
||||
export declare function _positive(params?: string | $ZodCheckGreaterThanParams): checks.$ZodCheckGreaterThan;
|
||||
export declare function _negative(params?: string | $ZodCheckLessThanParams): checks.$ZodCheckLessThan;
|
||||
export declare function _nonpositive(params?: string | $ZodCheckLessThanParams): checks.$ZodCheckLessThan;
|
||||
export declare function _nonnegative(params?: string | $ZodCheckGreaterThanParams): checks.$ZodCheckGreaterThan;
|
||||
export type $ZodCheckMultipleOfParams = CheckParams<checks.$ZodCheckMultipleOf, "value" | "when">;
|
||||
export declare function _multipleOf(value: number | bigint, params?: string | $ZodCheckMultipleOfParams): checks.$ZodCheckMultipleOf;
|
||||
export type $ZodCheckMaxSizeParams = CheckParams<checks.$ZodCheckMaxSize, "maximum" | "when">;
|
||||
export declare function _maxSize(maximum: number, params?: string | $ZodCheckMaxSizeParams): checks.$ZodCheckMaxSize<util.HasSize>;
|
||||
export type $ZodCheckMinSizeParams = CheckParams<checks.$ZodCheckMinSize, "minimum" | "when">;
|
||||
export declare function _minSize(minimum: number, params?: string | $ZodCheckMinSizeParams): checks.$ZodCheckMinSize<util.HasSize>;
|
||||
export type $ZodCheckSizeEqualsParams = CheckParams<checks.$ZodCheckSizeEquals, "size" | "when">;
|
||||
export declare function _size(size: number, params?: string | $ZodCheckSizeEqualsParams): checks.$ZodCheckSizeEquals<util.HasSize>;
|
||||
export type $ZodCheckMaxLengthParams = CheckParams<checks.$ZodCheckMaxLength, "maximum" | "when">;
|
||||
export declare function _maxLength(maximum: number, params?: string | $ZodCheckMaxLengthParams): checks.$ZodCheckMaxLength<util.HasLength>;
|
||||
export type $ZodCheckMinLengthParams = CheckParams<checks.$ZodCheckMinLength, "minimum" | "when">;
|
||||
export declare function _minLength(minimum: number, params?: string | $ZodCheckMinLengthParams): checks.$ZodCheckMinLength<util.HasLength>;
|
||||
export type $ZodCheckLengthEqualsParams = CheckParams<checks.$ZodCheckLengthEquals, "length" | "when">;
|
||||
export declare function _length(length: number, params?: string | $ZodCheckLengthEqualsParams): checks.$ZodCheckLengthEquals<util.HasLength>;
|
||||
export type $ZodCheckRegexParams = CheckParams<checks.$ZodCheckRegex, "format" | "pattern" | "when">;
|
||||
export declare function _regex(pattern: RegExp, params?: string | $ZodCheckRegexParams): checks.$ZodCheckRegex;
|
||||
export type $ZodCheckLowerCaseParams = CheckParams<checks.$ZodCheckLowerCase, "format" | "when">;
|
||||
export declare function _lowercase(params?: string | $ZodCheckLowerCaseParams): checks.$ZodCheckLowerCase;
|
||||
export type $ZodCheckUpperCaseParams = CheckParams<checks.$ZodCheckUpperCase, "format" | "when">;
|
||||
export declare function _uppercase(params?: string | $ZodCheckUpperCaseParams): checks.$ZodCheckUpperCase;
|
||||
export type $ZodCheckIncludesParams = CheckParams<checks.$ZodCheckIncludes, "includes" | "format" | "when" | "pattern">;
|
||||
export declare function _includes(includes: string, params?: string | $ZodCheckIncludesParams): checks.$ZodCheckIncludes;
|
||||
export type $ZodCheckStartsWithParams = CheckParams<checks.$ZodCheckStartsWith, "prefix" | "format" | "when" | "pattern">;
|
||||
export declare function _startsWith(prefix: string, params?: string | $ZodCheckStartsWithParams): checks.$ZodCheckStartsWith;
|
||||
export type $ZodCheckEndsWithParams = CheckParams<checks.$ZodCheckEndsWith, "suffix" | "format" | "pattern" | "when">;
|
||||
export declare function _endsWith(suffix: string, params?: string | $ZodCheckEndsWithParams): checks.$ZodCheckEndsWith;
|
||||
export type $ZodCheckPropertyParams = CheckParams<checks.$ZodCheckProperty, "property" | "schema" | "when">;
|
||||
export declare function _property<K extends string, T extends schemas.$ZodType>(property: K, schema: T, params?: string | $ZodCheckPropertyParams): checks.$ZodCheckProperty<{
|
||||
[k in K]: util.Widen<core.input<T>>;
|
||||
}>;
|
||||
export type $ZodCheckPropertiesParams = CheckParams<checks.$ZodCheckProperties, "shape" | "when">;
|
||||
export declare function _properties<Shape extends schemas.$ZodShape>(shape: Shape, params?: string | $ZodCheckPropertiesParams): checks.$ZodCheckProperties<Shape>;
|
||||
export type $ZodCheckMimeTypeParams = CheckParams<checks.$ZodCheckMimeType, "mime" | "when">;
|
||||
export declare function _mime(types: util.MimeTypes[], params?: string | $ZodCheckMimeTypeParams): checks.$ZodCheckMimeType;
|
||||
export declare function _overwrite<T>(tx: (input: T) => T): checks.$ZodCheckOverwrite<T>;
|
||||
export declare function _normalize(form?: "NFC" | "NFD" | "NFKC" | "NFKD" | (string & {})): checks.$ZodCheckOverwrite<string>;
|
||||
export declare function _trim(): checks.$ZodCheckOverwrite<string>;
|
||||
export declare function _toLowerCase(): checks.$ZodCheckOverwrite<string>;
|
||||
export declare function _toUpperCase(): checks.$ZodCheckOverwrite<string>;
|
||||
export declare function _slugify(): checks.$ZodCheckOverwrite<string>;
|
||||
export type $ZodArrayParams = TypeParams<schemas.$ZodArray, "element">;
|
||||
export declare function _array<T extends schemas.$ZodType>(Class: util.SchemaClass<schemas.$ZodArray>, element: T, params?: string | $ZodArrayParams): schemas.$ZodArray<T>;
|
||||
export type $ZodObjectParams = TypeParams<schemas.$ZodObject, "shape" | "catchall">;
|
||||
export type $ZodUnionParams = TypeParams<schemas.$ZodUnion, "options">;
|
||||
export declare function _union<const T extends readonly schemas.$ZodObject[]>(Class: util.SchemaClass<schemas.$ZodUnion>, options: T, params?: string | $ZodUnionParams): schemas.$ZodUnion<T>;
|
||||
export type $ZodXorParams = TypeParams<schemas.$ZodXor, "options">;
|
||||
export declare function _xor<const T extends readonly schemas.$ZodObject[]>(Class: util.SchemaClass<schemas.$ZodXor>, options: T, params?: string | $ZodXorParams): schemas.$ZodXor<T>;
|
||||
export interface $ZodTypeDiscriminableInternals<_Disc extends string = string> extends schemas._$ZodTypeInternals {
|
||||
propValues: util.PropValues;
|
||||
}
|
||||
export interface $ZodTypeDiscriminable<_Disc extends string = string> extends schemas.SomeType {
|
||||
_zod: $ZodTypeDiscriminableInternals;
|
||||
}
|
||||
export type $ZodDiscriminatedUnionParams = TypeParams<schemas.$ZodDiscriminatedUnion, "options" | "discriminator">;
|
||||
export declare function _discriminatedUnion<Types extends [$ZodTypeDiscriminable, ...$ZodTypeDiscriminable[]], Disc extends string>(Class: util.SchemaClass<schemas.$ZodDiscriminatedUnion>, discriminator: Disc, options: Types, params?: string | $ZodDiscriminatedUnionParams): schemas.$ZodDiscriminatedUnion<Types, Disc>;
|
||||
export type $ZodIntersectionParams = TypeParams<schemas.$ZodIntersection, "left" | "right">;
|
||||
export declare function _intersection<T extends schemas.$ZodObject, U extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodIntersection>, left: T, right: U): schemas.$ZodIntersection<T, U>;
|
||||
export type $ZodTupleParams = TypeParams<schemas.$ZodTuple, "items" | "rest">;
|
||||
export declare function _tuple<T extends readonly [schemas.$ZodType, ...schemas.$ZodType[]]>(Class: util.SchemaClass<schemas.$ZodTuple>, items: T, params?: string | $ZodTupleParams): schemas.$ZodTuple<T, null>;
|
||||
export declare function _tuple<T extends readonly [schemas.$ZodType, ...schemas.$ZodType[]], Rest extends schemas.$ZodType>(Class: util.SchemaClass<schemas.$ZodTuple>, items: T, rest: Rest, params?: string | $ZodTupleParams): schemas.$ZodTuple<T, Rest>;
|
||||
export type $ZodRecordParams = TypeParams<schemas.$ZodRecord, "keyType" | "valueType" | "partial">;
|
||||
export declare function _record<Key extends schemas.$ZodRecordKey, Value extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodRecord>, keyType: Key, valueType: Value, params?: string | $ZodRecordParams): schemas.$ZodRecord<Key, Value>;
|
||||
export type $ZodMapParams = TypeParams<schemas.$ZodMap, "keyType" | "valueType">;
|
||||
export declare function _map<Key extends schemas.$ZodObject, Value extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodMap>, keyType: Key, valueType: Value, params?: string | $ZodMapParams): schemas.$ZodMap<Key, Value>;
|
||||
export type $ZodSetParams = TypeParams<schemas.$ZodSet, "valueType">;
|
||||
export declare function _set<Value extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodSet>, valueType: Value, params?: string | $ZodSetParams): schemas.$ZodSet<Value>;
|
||||
export type $ZodEnumParams = TypeParams<schemas.$ZodEnum, "entries">;
|
||||
export declare function _enum<const T extends string[]>(Class: util.SchemaClass<schemas.$ZodEnum>, values: T, params?: string | $ZodEnumParams): schemas.$ZodEnum<util.ToEnum<T[number]>>;
|
||||
export declare function _enum<T extends util.EnumLike>(Class: util.SchemaClass<schemas.$ZodEnum>, entries: T, params?: string | $ZodEnumParams): schemas.$ZodEnum<T>;
|
||||
/** @deprecated This API has been merged into `z.enum()`. Use `z.enum()` instead.
|
||||
*
|
||||
* ```ts
|
||||
* enum Colors { red, green, blue }
|
||||
* z.enum(Colors);
|
||||
* ```
|
||||
*/
|
||||
export declare function _nativeEnum<T extends util.EnumLike>(Class: util.SchemaClass<schemas.$ZodEnum>, entries: T, params?: string | $ZodEnumParams): schemas.$ZodEnum<T>;
|
||||
export type $ZodLiteralParams = TypeParams<schemas.$ZodLiteral, "values">;
|
||||
export declare function _literal<const T extends Array<util.Literal>>(Class: util.SchemaClass<schemas.$ZodLiteral>, value: T, params?: string | $ZodLiteralParams): schemas.$ZodLiteral<T[number]>;
|
||||
export declare function _literal<const T extends util.Literal>(Class: util.SchemaClass<schemas.$ZodLiteral>, value: T, params?: string | $ZodLiteralParams): schemas.$ZodLiteral<T>;
|
||||
export type $ZodFileParams = TypeParams<schemas.$ZodFile>;
|
||||
export declare function _file(Class: util.SchemaClass<schemas.$ZodFile>, params?: string | $ZodFileParams): schemas.$ZodFile;
|
||||
export type $ZodTransformParams = TypeParams<schemas.$ZodTransform, "transform">;
|
||||
export declare function _transform<I = unknown, O = I>(Class: util.SchemaClass<schemas.$ZodTransform>, fn: (input: I, ctx?: schemas.ParsePayload) => O): schemas.$ZodTransform<Awaited<O>, I>;
|
||||
export type $ZodOptionalParams = TypeParams<schemas.$ZodOptional, "innerType">;
|
||||
export declare function _optional<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodOptional>, innerType: T): schemas.$ZodOptional<T>;
|
||||
export type $ZodNullableParams = TypeParams<schemas.$ZodNullable, "innerType">;
|
||||
export declare function _nullable<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodNullable>, innerType: T): schemas.$ZodNullable<T>;
|
||||
export type $ZodDefaultParams = TypeParams<schemas.$ZodDefault, "innerType" | "defaultValue">;
|
||||
export declare function _default<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodDefault>, innerType: T, defaultValue: util.NoUndefined<core.output<T>> | (() => util.NoUndefined<core.output<T>>)): schemas.$ZodDefault<T>;
|
||||
export type $ZodNonOptionalParams = TypeParams<schemas.$ZodNonOptional, "innerType">;
|
||||
export declare function _nonoptional<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodNonOptional>, innerType: T, params?: string | $ZodNonOptionalParams): schemas.$ZodNonOptional<T>;
|
||||
export type $ZodSuccessParams = TypeParams<schemas.$ZodSuccess, "innerType">;
|
||||
export declare function _success<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodSuccess>, innerType: T): schemas.$ZodSuccess<T>;
|
||||
export type $ZodCatchParams = TypeParams<schemas.$ZodCatch, "innerType" | "catchValue">;
|
||||
export declare function _catch<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodCatch>, innerType: T, catchValue: core.output<T> | ((ctx: schemas.$ZodCatchCtx) => core.output<T>)): schemas.$ZodCatch<T>;
|
||||
export type $ZodPipeParams = TypeParams<schemas.$ZodPipe, "in" | "out">;
|
||||
export declare function _pipe<const A extends schemas.$ZodType, B extends schemas.$ZodType<unknown, core.output<A>> = schemas.$ZodType<unknown, core.output<A>>>(Class: util.SchemaClass<schemas.$ZodPipe>, in_: A, out: B | schemas.$ZodType<unknown, core.output<A>>): schemas.$ZodPipe<A, B>;
|
||||
export type $ZodReadonlyParams = TypeParams<schemas.$ZodReadonly, "innerType">;
|
||||
export declare function _readonly<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodReadonly>, innerType: T): schemas.$ZodReadonly<T>;
|
||||
export type $ZodTemplateLiteralParams = TypeParams<schemas.$ZodTemplateLiteral, "parts">;
|
||||
export declare function _templateLiteral<const Parts extends schemas.$ZodTemplateLiteralPart[]>(Class: util.SchemaClass<schemas.$ZodTemplateLiteral>, parts: Parts, params?: string | $ZodTemplateLiteralParams): schemas.$ZodTemplateLiteral<schemas.$PartsToTemplateLiteral<Parts>>;
|
||||
export type $ZodLazyParams = TypeParams<schemas.$ZodLazy, "getter">;
|
||||
export declare function _lazy<T extends schemas.$ZodType>(Class: util.SchemaClass<schemas.$ZodLazy>, getter: () => T): schemas.$ZodLazy<T>;
|
||||
export type $ZodPromiseParams = TypeParams<schemas.$ZodPromise, "innerType">;
|
||||
export declare function _promise<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodPromise>, innerType: T): schemas.$ZodPromise<T>;
|
||||
export type $ZodCustomParams = CheckTypeParams<schemas.$ZodCustom, "fn">;
|
||||
export declare function _custom<O = unknown, I = O>(Class: util.SchemaClass<schemas.$ZodCustom>, fn: (data: O) => unknown, _params: string | $ZodCustomParams | undefined): schemas.$ZodCustom<O, I>;
|
||||
export declare function _refine<O = unknown, I = O>(Class: util.SchemaClass<schemas.$ZodCustom>, fn: (data: O) => unknown, _params: string | $ZodCustomParams | undefined): schemas.$ZodCustom<O, I>;
|
||||
export type $ZodSuperRefineIssue<T extends errors.$ZodIssueBase = errors.$ZodIssue> = T extends any ? RawIssue<T> : never;
|
||||
type RawIssue<T extends errors.$ZodIssueBase> = T extends any ? util.Flatten<util.MakePartial<T, "message" | "path"> & {
|
||||
/** The schema or check that originated this issue. */
|
||||
readonly inst?: schemas.$ZodType | checks.$ZodCheck;
|
||||
/** If `true`, Zod will execute subsequent checks/refinements instead of immediately aborting */
|
||||
readonly continue?: boolean | undefined;
|
||||
} & Record<string, unknown>> : never;
|
||||
export interface $RefinementCtx<T = unknown> extends schemas.ParsePayload<T> {
|
||||
addIssue(arg: string | $ZodSuperRefineIssue): void;
|
||||
}
|
||||
export interface $ZodSuperRefineParams {
|
||||
/** If provided, the refinement runs only when this returns `true`. By default, it is skipped if prior parsing produced aborting issues. */
|
||||
when?: ((payload: schemas.ParsePayload) => boolean) | undefined;
|
||||
}
|
||||
export declare function _superRefine<T>(fn: (arg: T, payload: $RefinementCtx<T>) => void | Promise<void>, params?: $ZodSuperRefineParams): checks.$ZodCheck<T>;
|
||||
export declare function _check<O = unknown>(fn: schemas.CheckFn<O>, params?: string | $ZodCustomParams): checks.$ZodCheck<O>;
|
||||
export declare function describe<T>(description: string): checks.$ZodCheck<T>;
|
||||
export declare function meta<T>(metadata: registries.GlobalMeta): checks.$ZodCheck<T>;
|
||||
export interface $ZodStringBoolParams extends TypeParams {
|
||||
truthy?: string[];
|
||||
falsy?: string[];
|
||||
/**
|
||||
* Options: `"sensitive"`, `"insensitive"`
|
||||
*
|
||||
* @default `"insensitive"`
|
||||
*/
|
||||
case?: "sensitive" | "insensitive" | undefined;
|
||||
}
|
||||
export declare function _stringbool(Classes: {
|
||||
Codec?: typeof schemas.$ZodCodec;
|
||||
Boolean?: typeof schemas.$ZodBoolean;
|
||||
String?: typeof schemas.$ZodString;
|
||||
}, _params?: string | $ZodStringBoolParams): schemas.$ZodCodec<schemas.$ZodString, schemas.$ZodBoolean>;
|
||||
export declare function _stringFormat<Format extends string>(Class: typeof schemas.$ZodCustomStringFormat, format: Format, fnOrRegex: ((arg: string) => util.MaybeAsync<unknown>) | RegExp, _params?: string | $ZodStringFormatParams): schemas.$ZodCustomStringFormat<Format>;
|
||||
+335
@@ -0,0 +1,335 @@
|
||||
import * as checks from "./checks.js";
|
||||
import type * as core from "./core.js";
|
||||
import type * as errors from "./errors.js";
|
||||
import * as registries from "./registries.js";
|
||||
import * as schemas from "./schemas.js";
|
||||
import * as util from "./util.js";
|
||||
export type Params<T extends schemas.$ZodType | checks.$ZodCheck, IssueTypes extends errors.$ZodIssueBase, OmitKeys extends keyof T["_zod"]["def"] = never> = util.Flatten<Partial<util.EmptyToNever<Omit<T["_zod"]["def"], OmitKeys> & ([IssueTypes] extends [never] ? {} : {
|
||||
error?: string | errors.$ZodErrorMap<IssueTypes> | undefined;
|
||||
/** @deprecated This parameter is deprecated. Use `error` instead. */
|
||||
message?: string | undefined;
|
||||
})>>>;
|
||||
export type TypeParams<T extends schemas.$ZodType = schemas.$ZodType & {
|
||||
_isst: never;
|
||||
}, AlsoOmit extends Exclude<keyof T["_zod"]["def"], "type" | "checks" | "error"> = never> = Params<T, NonNullable<T["_zod"]["isst"]>, "type" | "checks" | "error" | AlsoOmit>;
|
||||
export type CheckParams<T extends checks.$ZodCheck = checks.$ZodCheck, // & { _issc: never },
|
||||
AlsoOmit extends Exclude<keyof T["_zod"]["def"], "check" | "error"> = never> = Params<T, NonNullable<T["_zod"]["issc"]>, "check" | "error" | AlsoOmit>;
|
||||
export type StringFormatParams<T extends schemas.$ZodStringFormat = schemas.$ZodStringFormat, AlsoOmit extends Exclude<keyof T["_zod"]["def"], "type" | "coerce" | "checks" | "error" | "check" | "format"> = never> = Params<T, NonNullable<T["_zod"]["isst"] | T["_zod"]["issc"]>, "type" | "coerce" | "checks" | "error" | "check" | "format" | AlsoOmit>;
|
||||
export type CheckStringFormatParams<T extends schemas.$ZodStringFormat = schemas.$ZodStringFormat, AlsoOmit extends Exclude<keyof T["_zod"]["def"], "type" | "coerce" | "checks" | "error" | "check" | "format"> = never> = Params<T, NonNullable<T["_zod"]["issc"]>, "type" | "coerce" | "checks" | "error" | "check" | "format" | AlsoOmit>;
|
||||
export type CheckTypeParams<T extends schemas.$ZodType & checks.$ZodCheck = schemas.$ZodType & checks.$ZodCheck, AlsoOmit extends Exclude<keyof T["_zod"]["def"], "type" | "checks" | "error" | "check"> = never> = Params<T, NonNullable<T["_zod"]["isst"] | T["_zod"]["issc"]>, "type" | "checks" | "error" | "check" | AlsoOmit>;
|
||||
export type $ZodStringParams = TypeParams<schemas.$ZodString<string>, "coerce"> & {
|
||||
checks?: readonly checks.$ZodCheck<string>[];
|
||||
};
|
||||
export declare function _string<T extends schemas.$ZodString>(Class: util.SchemaClass<T>, params?: string | $ZodStringParams): T;
|
||||
export declare function _coercedString<T extends schemas.$ZodString>(Class: util.SchemaClass<T>, params?: string | $ZodStringParams): T;
|
||||
export type $ZodStringFormatParams = CheckTypeParams<schemas.$ZodStringFormat, "format" | "coerce" | "when" | "pattern">;
|
||||
export type $ZodCheckStringFormatParams = CheckParams<checks.$ZodCheckStringFormat, "format">;
|
||||
export type $ZodEmailParams = StringFormatParams<schemas.$ZodEmail, "when">;
|
||||
export type $ZodCheckEmailParams = CheckStringFormatParams<schemas.$ZodEmail, "when">;
|
||||
export declare function _email<T extends schemas.$ZodEmail>(Class: util.SchemaClass<T>, params?: string | $ZodEmailParams | $ZodCheckEmailParams): T;
|
||||
export type $ZodGUIDParams = StringFormatParams<schemas.$ZodGUID, "pattern" | "when">;
|
||||
export type $ZodCheckGUIDParams = CheckStringFormatParams<schemas.$ZodGUID, "pattern" | "when">;
|
||||
export declare function _guid<T extends schemas.$ZodGUID>(Class: util.SchemaClass<T>, params?: string | $ZodGUIDParams | $ZodCheckGUIDParams): T;
|
||||
export type $ZodUUIDParams = StringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
|
||||
export type $ZodCheckUUIDParams = CheckStringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
|
||||
export declare function _uuid<T extends schemas.$ZodUUID>(Class: util.SchemaClass<T>, params?: string | $ZodUUIDParams | $ZodCheckUUIDParams): T;
|
||||
export type $ZodUUIDv4Params = StringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
|
||||
export type $ZodCheckUUIDv4Params = CheckStringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
|
||||
export declare function _uuidv4<T extends schemas.$ZodUUID>(Class: util.SchemaClass<T>, params?: string | $ZodUUIDv4Params | $ZodCheckUUIDv4Params): T;
|
||||
export type $ZodUUIDv6Params = StringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
|
||||
export type $ZodCheckUUIDv6Params = CheckStringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
|
||||
export declare function _uuidv6<T extends schemas.$ZodUUID>(Class: util.SchemaClass<T>, params?: string | $ZodUUIDv6Params | $ZodCheckUUIDv6Params): T;
|
||||
export type $ZodUUIDv7Params = StringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
|
||||
export type $ZodCheckUUIDv7Params = CheckStringFormatParams<schemas.$ZodUUID, "pattern" | "when">;
|
||||
export declare function _uuidv7<T extends schemas.$ZodUUID>(Class: util.SchemaClass<T>, params?: string | $ZodUUIDv7Params | $ZodCheckUUIDv7Params): T;
|
||||
export type $ZodURLParams = StringFormatParams<schemas.$ZodURL, "when">;
|
||||
export type $ZodCheckURLParams = CheckStringFormatParams<schemas.$ZodURL, "when">;
|
||||
export declare function _url<T extends schemas.$ZodURL>(Class: util.SchemaClass<T>, params?: string | $ZodURLParams | $ZodCheckURLParams): T;
|
||||
export type $ZodEmojiParams = StringFormatParams<schemas.$ZodEmoji, "when">;
|
||||
export type $ZodCheckEmojiParams = CheckStringFormatParams<schemas.$ZodEmoji, "when">;
|
||||
export declare function _emoji<T extends schemas.$ZodEmoji>(Class: util.SchemaClass<T>, params?: string | $ZodEmojiParams | $ZodCheckEmojiParams): T;
|
||||
export type $ZodNanoIDParams = StringFormatParams<schemas.$ZodNanoID, "when" | "pattern">;
|
||||
export type $ZodCheckNanoIDParams = CheckStringFormatParams<schemas.$ZodNanoID, "when" | "pattern">;
|
||||
export declare function _nanoid<T extends schemas.$ZodNanoID>(Class: util.SchemaClass<T>, params?: string | $ZodNanoIDParams | $ZodCheckNanoIDParams): T;
|
||||
/**
|
||||
* @deprecated CUID v1 is deprecated by its authors due to information leakage
|
||||
* (timestamps embedded in the id). Use {@link _cuid2} instead.
|
||||
* See https://github.com/paralleldrive/cuid.
|
||||
*/
|
||||
export type $ZodCUIDParams = StringFormatParams<schemas.$ZodCUID, "when">;
|
||||
/**
|
||||
* @deprecated CUID v1 is deprecated by its authors due to information leakage
|
||||
* (timestamps embedded in the id). Use {@link _cuid2} instead.
|
||||
* See https://github.com/paralleldrive/cuid.
|
||||
*/
|
||||
export type $ZodCheckCUIDParams = CheckStringFormatParams<schemas.$ZodCUID, "when">;
|
||||
/**
|
||||
* @deprecated CUID v1 is deprecated by its authors due to information leakage
|
||||
* (timestamps embedded in the id). Use {@link _cuid2} instead.
|
||||
* See https://github.com/paralleldrive/cuid.
|
||||
*/
|
||||
export declare function _cuid<T extends schemas.$ZodCUID>(Class: util.SchemaClass<T>, params?: string | $ZodCUIDParams | $ZodCheckCUIDParams): T;
|
||||
export type $ZodCUID2Params = StringFormatParams<schemas.$ZodCUID2, "when">;
|
||||
export type $ZodCheckCUID2Params = CheckStringFormatParams<schemas.$ZodCUID2, "when">;
|
||||
export declare function _cuid2<T extends schemas.$ZodCUID2>(Class: util.SchemaClass<T>, params?: string | $ZodCUID2Params | $ZodCheckCUID2Params): T;
|
||||
export type $ZodULIDParams = StringFormatParams<schemas.$ZodULID, "when">;
|
||||
export type $ZodCheckULIDParams = CheckStringFormatParams<schemas.$ZodULID, "when">;
|
||||
export declare function _ulid<T extends schemas.$ZodULID>(Class: util.SchemaClass<T>, params?: string | $ZodULIDParams | $ZodCheckULIDParams): T;
|
||||
export type $ZodXIDParams = StringFormatParams<schemas.$ZodXID, "when">;
|
||||
export type $ZodCheckXIDParams = CheckStringFormatParams<schemas.$ZodXID, "when">;
|
||||
export declare function _xid<T extends schemas.$ZodXID>(Class: util.SchemaClass<T>, params?: string | $ZodXIDParams | $ZodCheckXIDParams): T;
|
||||
export type $ZodKSUIDParams = StringFormatParams<schemas.$ZodKSUID, "when">;
|
||||
export type $ZodCheckKSUIDParams = CheckStringFormatParams<schemas.$ZodKSUID, "when">;
|
||||
export declare function _ksuid<T extends schemas.$ZodKSUID>(Class: util.SchemaClass<T>, params?: string | $ZodKSUIDParams | $ZodCheckKSUIDParams): T;
|
||||
export type $ZodIPv4Params = StringFormatParams<schemas.$ZodIPv4, "pattern" | "when" | "version">;
|
||||
export type $ZodCheckIPv4Params = CheckStringFormatParams<schemas.$ZodIPv4, "pattern" | "when" | "version">;
|
||||
export declare function _ipv4<T extends schemas.$ZodIPv4>(Class: util.SchemaClass<T>, params?: string | $ZodIPv4Params | $ZodCheckIPv4Params): T;
|
||||
export type $ZodIPv6Params = StringFormatParams<schemas.$ZodIPv6, "pattern" | "when" | "version">;
|
||||
export type $ZodCheckIPv6Params = CheckStringFormatParams<schemas.$ZodIPv6, "pattern" | "when" | "version">;
|
||||
export declare function _ipv6<T extends schemas.$ZodIPv6>(Class: util.SchemaClass<T>, params?: string | $ZodIPv6Params | $ZodCheckIPv6Params): T;
|
||||
export type $ZodMACParams = StringFormatParams<schemas.$ZodMAC, "pattern" | "when">;
|
||||
export type $ZodCheckMACParams = CheckStringFormatParams<schemas.$ZodMAC, "pattern" | "when">;
|
||||
export declare function _mac<T extends schemas.$ZodMAC>(Class: util.SchemaClass<T>, params?: string | $ZodMACParams | $ZodCheckMACParams): T;
|
||||
export type $ZodCIDRv4Params = StringFormatParams<schemas.$ZodCIDRv4, "pattern" | "when">;
|
||||
export type $ZodCheckCIDRv4Params = CheckStringFormatParams<schemas.$ZodCIDRv4, "pattern" | "when">;
|
||||
export declare function _cidrv4<T extends schemas.$ZodCIDRv4>(Class: util.SchemaClass<T>, params?: string | $ZodCIDRv4Params | $ZodCheckCIDRv4Params): T;
|
||||
export type $ZodCIDRv6Params = StringFormatParams<schemas.$ZodCIDRv6, "pattern" | "when">;
|
||||
export type $ZodCheckCIDRv6Params = CheckStringFormatParams<schemas.$ZodCIDRv6, "pattern" | "when">;
|
||||
export declare function _cidrv6<T extends schemas.$ZodCIDRv6>(Class: util.SchemaClass<T>, params?: string | $ZodCIDRv6Params | $ZodCheckCIDRv6Params): T;
|
||||
export type $ZodBase64Params = StringFormatParams<schemas.$ZodBase64, "pattern" | "when">;
|
||||
export type $ZodCheckBase64Params = CheckStringFormatParams<schemas.$ZodBase64, "pattern" | "when">;
|
||||
export declare function _base64<T extends schemas.$ZodBase64>(Class: util.SchemaClass<T>, params?: string | $ZodBase64Params | $ZodCheckBase64Params): T;
|
||||
export type $ZodBase64URLParams = StringFormatParams<schemas.$ZodBase64URL, "pattern" | "when">;
|
||||
export type $ZodCheckBase64URLParams = CheckStringFormatParams<schemas.$ZodBase64URL, "pattern" | "when">;
|
||||
export declare function _base64url<T extends schemas.$ZodBase64URL>(Class: util.SchemaClass<T>, params?: string | $ZodBase64URLParams | $ZodCheckBase64URLParams): T;
|
||||
export type $ZodE164Params = StringFormatParams<schemas.$ZodE164, "when">;
|
||||
export type $ZodCheckE164Params = CheckStringFormatParams<schemas.$ZodE164, "when">;
|
||||
export declare function _e164<T extends schemas.$ZodE164>(Class: util.SchemaClass<T>, params?: string | $ZodE164Params | $ZodCheckE164Params): T;
|
||||
export type $ZodCreditCardParams = StringFormatParams<schemas.$ZodCreditCard, "pattern" | "when">;
|
||||
export type $ZodCheckCreditCardParams = CheckStringFormatParams<schemas.$ZodCreditCard, "pattern" | "when">;
|
||||
export declare function _creditCard<T extends schemas.$ZodCreditCard>(Class: util.SchemaClass<T>, params?: string | $ZodCreditCardParams | $ZodCheckCreditCardParams): T;
|
||||
export type $ZodIBANParams = StringFormatParams<schemas.$ZodIBAN, "pattern" | "when">;
|
||||
export type $ZodCheckIBANParams = CheckStringFormatParams<schemas.$ZodIBAN, "pattern" | "when">;
|
||||
export declare function _iban<T extends schemas.$ZodIBAN>(Class: util.SchemaClass<T>, params?: string | $ZodIBANParams | $ZodCheckIBANParams): T;
|
||||
export type $ZodJWTParams = StringFormatParams<schemas.$ZodJWT, "pattern" | "when">;
|
||||
export type $ZodCheckJWTParams = CheckStringFormatParams<schemas.$ZodJWT, "pattern" | "when">;
|
||||
export declare function _jwt<T extends schemas.$ZodJWT>(Class: util.SchemaClass<T>, params?: string | $ZodJWTParams | $ZodCheckJWTParams): T;
|
||||
export declare const TimePrecision: {
|
||||
readonly Any: null;
|
||||
readonly Minute: -1;
|
||||
readonly Second: 0;
|
||||
readonly Millisecond: 3;
|
||||
readonly Microsecond: 6;
|
||||
};
|
||||
export type $ZodISODateTimeParams = StringFormatParams<schemas.$ZodISODateTime, "pattern" | "when">;
|
||||
export type $ZodCheckISODateTimeParams = CheckStringFormatParams<schemas.$ZodISODateTime, "pattern" | "when">;
|
||||
export declare function _isoDateTime<T extends schemas.$ZodISODateTime>(Class: util.SchemaClass<T>, params?: string | $ZodISODateTimeParams | $ZodCheckISODateTimeParams): T;
|
||||
export type $ZodISODateParams = StringFormatParams<schemas.$ZodISODate, "pattern" | "when">;
|
||||
export type $ZodCheckISODateParams = CheckStringFormatParams<schemas.$ZodISODate, "pattern" | "when">;
|
||||
export declare function _isoDate<T extends schemas.$ZodISODate>(Class: util.SchemaClass<T>, params?: string | $ZodISODateParams | $ZodCheckISODateParams): T;
|
||||
export type $ZodISOTimeParams = StringFormatParams<schemas.$ZodISOTime, "pattern" | "when">;
|
||||
export type $ZodCheckISOTimeParams = CheckStringFormatParams<schemas.$ZodISOTime, "pattern" | "when">;
|
||||
export declare function _isoTime<T extends schemas.$ZodISOTime>(Class: util.SchemaClass<T>, params?: string | $ZodISOTimeParams | $ZodCheckISOTimeParams): T;
|
||||
export type $ZodISODurationParams = StringFormatParams<schemas.$ZodISODuration, "when">;
|
||||
export type $ZodCheckISODurationParams = CheckStringFormatParams<schemas.$ZodISODuration, "when">;
|
||||
export declare function _isoDuration<T extends schemas.$ZodISODuration>(Class: util.SchemaClass<T>, params?: string | $ZodISODurationParams | $ZodCheckISODurationParams): T;
|
||||
export type $ZodNumberParams = TypeParams<schemas.$ZodNumber<number>, "coerce"> & {
|
||||
checks?: readonly checks.$ZodCheck<number>[];
|
||||
};
|
||||
export type $ZodNumberFormatParams = CheckTypeParams<schemas.$ZodNumberFormat, "format" | "coerce">;
|
||||
export type $ZodCheckNumberFormatParams = CheckParams<checks.$ZodCheckNumberFormat, "format" | "when">;
|
||||
export declare function _number<T extends schemas.$ZodNumber>(Class: util.SchemaClass<T>, params?: string | $ZodNumberParams): T;
|
||||
export declare function _coercedNumber<T extends schemas.$ZodNumber>(Class: util.SchemaClass<T>, params?: string | $ZodNumberParams): T;
|
||||
export declare function _int<T extends schemas.$ZodNumberFormat>(Class: util.SchemaClass<T>, params?: string | $ZodCheckNumberFormatParams): T;
|
||||
export declare function _float32<T extends schemas.$ZodNumberFormat>(Class: util.SchemaClass<T>, params?: string | $ZodCheckNumberFormatParams): T;
|
||||
export declare function _float64<T extends schemas.$ZodNumberFormat>(Class: util.SchemaClass<T>, params?: string | $ZodCheckNumberFormatParams): T;
|
||||
export declare function _int32<T extends schemas.$ZodNumberFormat>(Class: util.SchemaClass<T>, params?: string | $ZodCheckNumberFormatParams): T;
|
||||
export declare function _uint32<T extends schemas.$ZodNumberFormat>(Class: util.SchemaClass<T>, params?: string | $ZodCheckNumberFormatParams): T;
|
||||
export type $ZodBooleanParams = TypeParams<schemas.$ZodBoolean<boolean>, "coerce">;
|
||||
export declare function _boolean<T extends schemas.$ZodBoolean>(Class: util.SchemaClass<T>, params?: string | $ZodBooleanParams): T;
|
||||
export declare function _coercedBoolean<T extends schemas.$ZodBoolean>(Class: util.SchemaClass<T>, params?: string | $ZodBooleanParams): T;
|
||||
export type $ZodBigIntParams = TypeParams<schemas.$ZodBigInt<bigint>>;
|
||||
export type $ZodBigIntFormatParams = CheckTypeParams<schemas.$ZodBigIntFormat, "format" | "coerce">;
|
||||
export type $ZodCheckBigIntFormatParams = CheckParams<checks.$ZodCheckBigIntFormat, "format" | "when">;
|
||||
export declare function _bigint<T extends schemas.$ZodBigInt>(Class: util.SchemaClass<T>, params?: string | $ZodBigIntParams): T;
|
||||
export declare function _coercedBigint<T extends schemas.$ZodBigInt>(Class: util.SchemaClass<T>, params?: string | $ZodBigIntParams): T;
|
||||
export declare function _int64<T extends schemas.$ZodBigIntFormat>(Class: util.SchemaClass<T>, params?: string | $ZodBigIntFormatParams): T;
|
||||
export declare function _uint64<T extends schemas.$ZodBigIntFormat>(Class: util.SchemaClass<T>, params?: string | $ZodBigIntFormatParams): T;
|
||||
export type $ZodSymbolParams = TypeParams<schemas.$ZodSymbol>;
|
||||
export declare function _symbol<T extends schemas.$ZodSymbol>(Class: util.SchemaClass<T>, params?: string | $ZodSymbolParams): T;
|
||||
export type $ZodUndefinedParams = TypeParams<schemas.$ZodUndefined>;
|
||||
export declare function _undefined<T extends schemas.$ZodUndefined>(Class: util.SchemaClass<T>, params?: string | $ZodUndefinedParams): T;
|
||||
export type $ZodNullParams = TypeParams<schemas.$ZodNull>;
|
||||
export declare function _null<T extends schemas.$ZodNull>(Class: util.SchemaClass<T>, params?: string | $ZodNullParams): T;
|
||||
export type $ZodAnyParams = TypeParams<schemas.$ZodAny>;
|
||||
export declare function _any<T extends schemas.$ZodAny>(Class: util.SchemaClass<T>): T;
|
||||
export type $ZodUnknownParams = TypeParams<schemas.$ZodUnknown>;
|
||||
export declare function _unknown<T extends schemas.$ZodUnknown>(Class: util.SchemaClass<T>): T;
|
||||
export type $ZodNeverParams = TypeParams<schemas.$ZodNever>;
|
||||
export declare function _never<T extends schemas.$ZodNever>(Class: util.SchemaClass<T>, params?: string | $ZodNeverParams): T;
|
||||
export type $ZodVoidParams = TypeParams<schemas.$ZodVoid>;
|
||||
export declare function _void<T extends schemas.$ZodVoid>(Class: util.SchemaClass<T>, params?: string | $ZodVoidParams): T;
|
||||
export type $ZodDateParams = TypeParams<schemas.$ZodDate, "coerce">;
|
||||
export declare function _date<T extends schemas.$ZodDate>(Class: util.SchemaClass<T>, params?: string | $ZodDateParams): T;
|
||||
export declare function _coercedDate<T extends schemas.$ZodDate>(Class: util.SchemaClass<T>, params?: string | $ZodDateParams): T;
|
||||
export type $ZodNaNParams = TypeParams<schemas.$ZodNaN>;
|
||||
export declare function _nan<T extends schemas.$ZodNaN>(Class: util.SchemaClass<T>, params?: string | $ZodNaNParams): T;
|
||||
export type $ZodCheckLessThanParams = CheckParams<checks.$ZodCheckLessThan, "inclusive" | "value" | "when">;
|
||||
export declare function _lt(value: util.Numeric, params?: string | $ZodCheckLessThanParams): checks.$ZodCheckLessThan<util.Numeric>;
|
||||
export declare function _lte(value: util.Numeric, params?: string | $ZodCheckLessThanParams): checks.$ZodCheckLessThan<util.Numeric>;
|
||||
export {
|
||||
/** @deprecated Use `z.lte()` instead. */
|
||||
_lte as _max, };
|
||||
export type $ZodCheckGreaterThanParams = CheckParams<checks.$ZodCheckGreaterThan, "inclusive" | "value" | "when">;
|
||||
export declare function _gt(value: util.Numeric, params?: string | $ZodCheckGreaterThanParams): checks.$ZodCheckGreaterThan;
|
||||
export declare function _gte(value: util.Numeric, params?: string | $ZodCheckGreaterThanParams): checks.$ZodCheckGreaterThan;
|
||||
export {
|
||||
/** @deprecated Use `z.gte()` instead. */
|
||||
_gte as _min, };
|
||||
export declare function _positive(params?: string | $ZodCheckGreaterThanParams): checks.$ZodCheckGreaterThan;
|
||||
export declare function _negative(params?: string | $ZodCheckLessThanParams): checks.$ZodCheckLessThan;
|
||||
export declare function _nonpositive(params?: string | $ZodCheckLessThanParams): checks.$ZodCheckLessThan;
|
||||
export declare function _nonnegative(params?: string | $ZodCheckGreaterThanParams): checks.$ZodCheckGreaterThan;
|
||||
export type $ZodCheckMultipleOfParams = CheckParams<checks.$ZodCheckMultipleOf, "value" | "when">;
|
||||
export declare function _multipleOf(value: number | bigint, params?: string | $ZodCheckMultipleOfParams): checks.$ZodCheckMultipleOf;
|
||||
export type $ZodCheckMaxSizeParams = CheckParams<checks.$ZodCheckMaxSize, "maximum" | "when">;
|
||||
export declare function _maxSize(maximum: number, params?: string | $ZodCheckMaxSizeParams): checks.$ZodCheckMaxSize<util.HasSize>;
|
||||
export type $ZodCheckMinSizeParams = CheckParams<checks.$ZodCheckMinSize, "minimum" | "when">;
|
||||
export declare function _minSize(minimum: number, params?: string | $ZodCheckMinSizeParams): checks.$ZodCheckMinSize<util.HasSize>;
|
||||
export type $ZodCheckSizeEqualsParams = CheckParams<checks.$ZodCheckSizeEquals, "size" | "when">;
|
||||
export declare function _size(size: number, params?: string | $ZodCheckSizeEqualsParams): checks.$ZodCheckSizeEquals<util.HasSize>;
|
||||
export type $ZodCheckMaxLengthParams = CheckParams<checks.$ZodCheckMaxLength, "maximum" | "when">;
|
||||
export declare function _maxLength(maximum: number, params?: string | $ZodCheckMaxLengthParams): checks.$ZodCheckMaxLength<util.HasLength>;
|
||||
export type $ZodCheckMinLengthParams = CheckParams<checks.$ZodCheckMinLength, "minimum" | "when">;
|
||||
export declare function _minLength(minimum: number, params?: string | $ZodCheckMinLengthParams): checks.$ZodCheckMinLength<util.HasLength>;
|
||||
export type $ZodCheckLengthEqualsParams = CheckParams<checks.$ZodCheckLengthEquals, "length" | "when">;
|
||||
export declare function _length(length: number, params?: string | $ZodCheckLengthEqualsParams): checks.$ZodCheckLengthEquals<util.HasLength>;
|
||||
export type $ZodCheckRegexParams = CheckParams<checks.$ZodCheckRegex, "format" | "pattern" | "when">;
|
||||
export declare function _regex(pattern: RegExp, params?: string | $ZodCheckRegexParams): checks.$ZodCheckRegex;
|
||||
export type $ZodCheckLowerCaseParams = CheckParams<checks.$ZodCheckLowerCase, "format" | "when">;
|
||||
export declare function _lowercase(params?: string | $ZodCheckLowerCaseParams): checks.$ZodCheckLowerCase;
|
||||
export type $ZodCheckUpperCaseParams = CheckParams<checks.$ZodCheckUpperCase, "format" | "when">;
|
||||
export declare function _uppercase(params?: string | $ZodCheckUpperCaseParams): checks.$ZodCheckUpperCase;
|
||||
export type $ZodCheckIncludesParams = CheckParams<checks.$ZodCheckIncludes, "includes" | "format" | "when" | "pattern">;
|
||||
export declare function _includes(includes: string, params?: string | $ZodCheckIncludesParams): checks.$ZodCheckIncludes;
|
||||
export type $ZodCheckStartsWithParams = CheckParams<checks.$ZodCheckStartsWith, "prefix" | "format" | "when" | "pattern">;
|
||||
export declare function _startsWith(prefix: string, params?: string | $ZodCheckStartsWithParams): checks.$ZodCheckStartsWith;
|
||||
export type $ZodCheckEndsWithParams = CheckParams<checks.$ZodCheckEndsWith, "suffix" | "format" | "pattern" | "when">;
|
||||
export declare function _endsWith(suffix: string, params?: string | $ZodCheckEndsWithParams): checks.$ZodCheckEndsWith;
|
||||
export type $ZodCheckPropertyParams = CheckParams<checks.$ZodCheckProperty, "property" | "schema" | "when">;
|
||||
export declare function _property<K extends string, T extends schemas.$ZodType>(property: K, schema: T, params?: string | $ZodCheckPropertyParams): checks.$ZodCheckProperty<{
|
||||
[k in K]: util.Widen<core.input<T>>;
|
||||
}>;
|
||||
export type $ZodCheckPropertiesParams = CheckParams<checks.$ZodCheckProperties, "shape" | "when">;
|
||||
export declare function _properties<Shape extends schemas.$ZodShape>(shape: Shape, params?: string | $ZodCheckPropertiesParams): checks.$ZodCheckProperties<Shape>;
|
||||
export type $ZodCheckMimeTypeParams = CheckParams<checks.$ZodCheckMimeType, "mime" | "when">;
|
||||
export declare function _mime(types: util.MimeTypes[], params?: string | $ZodCheckMimeTypeParams): checks.$ZodCheckMimeType;
|
||||
export declare function _overwrite<T>(tx: (input: T) => T): checks.$ZodCheckOverwrite<T>;
|
||||
export declare function _normalize(form?: "NFC" | "NFD" | "NFKC" | "NFKD" | (string & {})): checks.$ZodCheckOverwrite<string>;
|
||||
export declare function _trim(): checks.$ZodCheckOverwrite<string>;
|
||||
export declare function _toLowerCase(): checks.$ZodCheckOverwrite<string>;
|
||||
export declare function _toUpperCase(): checks.$ZodCheckOverwrite<string>;
|
||||
export declare function _slugify(): checks.$ZodCheckOverwrite<string>;
|
||||
export type $ZodArrayParams = TypeParams<schemas.$ZodArray, "element">;
|
||||
export declare function _array<T extends schemas.$ZodType>(Class: util.SchemaClass<schemas.$ZodArray>, element: T, params?: string | $ZodArrayParams): schemas.$ZodArray<T>;
|
||||
export type $ZodObjectParams = TypeParams<schemas.$ZodObject, "shape" | "catchall">;
|
||||
export type $ZodUnionParams = TypeParams<schemas.$ZodUnion, "options">;
|
||||
export declare function _union<const T extends readonly schemas.$ZodObject[]>(Class: util.SchemaClass<schemas.$ZodUnion>, options: T, params?: string | $ZodUnionParams): schemas.$ZodUnion<T>;
|
||||
export type $ZodXorParams = TypeParams<schemas.$ZodXor, "options">;
|
||||
export declare function _xor<const T extends readonly schemas.$ZodObject[]>(Class: util.SchemaClass<schemas.$ZodXor>, options: T, params?: string | $ZodXorParams): schemas.$ZodXor<T>;
|
||||
export interface $ZodTypeDiscriminableInternals<_Disc extends string = string> extends schemas._$ZodTypeInternals {
|
||||
propValues: util.PropValues;
|
||||
}
|
||||
export interface $ZodTypeDiscriminable<_Disc extends string = string> extends schemas.SomeType {
|
||||
_zod: $ZodTypeDiscriminableInternals;
|
||||
}
|
||||
export type $ZodDiscriminatedUnionParams = TypeParams<schemas.$ZodDiscriminatedUnion, "options" | "discriminator">;
|
||||
export declare function _discriminatedUnion<Types extends [$ZodTypeDiscriminable, ...$ZodTypeDiscriminable[]], Disc extends string>(Class: util.SchemaClass<schemas.$ZodDiscriminatedUnion>, discriminator: Disc, options: Types, params?: string | $ZodDiscriminatedUnionParams): schemas.$ZodDiscriminatedUnion<Types, Disc>;
|
||||
export type $ZodIntersectionParams = TypeParams<schemas.$ZodIntersection, "left" | "right">;
|
||||
export declare function _intersection<T extends schemas.$ZodObject, U extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodIntersection>, left: T, right: U): schemas.$ZodIntersection<T, U>;
|
||||
export type $ZodTupleParams = TypeParams<schemas.$ZodTuple, "items" | "rest">;
|
||||
export declare function _tuple<T extends readonly [schemas.$ZodType, ...schemas.$ZodType[]]>(Class: util.SchemaClass<schemas.$ZodTuple>, items: T, params?: string | $ZodTupleParams): schemas.$ZodTuple<T, null>;
|
||||
export declare function _tuple<T extends readonly [schemas.$ZodType, ...schemas.$ZodType[]], Rest extends schemas.$ZodType>(Class: util.SchemaClass<schemas.$ZodTuple>, items: T, rest: Rest, params?: string | $ZodTupleParams): schemas.$ZodTuple<T, Rest>;
|
||||
export type $ZodRecordParams = TypeParams<schemas.$ZodRecord, "keyType" | "valueType" | "partial">;
|
||||
export declare function _record<Key extends schemas.$ZodRecordKey, Value extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodRecord>, keyType: Key, valueType: Value, params?: string | $ZodRecordParams): schemas.$ZodRecord<Key, Value>;
|
||||
export type $ZodMapParams = TypeParams<schemas.$ZodMap, "keyType" | "valueType">;
|
||||
export declare function _map<Key extends schemas.$ZodObject, Value extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodMap>, keyType: Key, valueType: Value, params?: string | $ZodMapParams): schemas.$ZodMap<Key, Value>;
|
||||
export type $ZodSetParams = TypeParams<schemas.$ZodSet, "valueType">;
|
||||
export declare function _set<Value extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodSet>, valueType: Value, params?: string | $ZodSetParams): schemas.$ZodSet<Value>;
|
||||
export type $ZodEnumParams = TypeParams<schemas.$ZodEnum, "entries">;
|
||||
export declare function _enum<const T extends string[]>(Class: util.SchemaClass<schemas.$ZodEnum>, values: T, params?: string | $ZodEnumParams): schemas.$ZodEnum<util.ToEnum<T[number]>>;
|
||||
export declare function _enum<T extends util.EnumLike>(Class: util.SchemaClass<schemas.$ZodEnum>, entries: T, params?: string | $ZodEnumParams): schemas.$ZodEnum<T>;
|
||||
/** @deprecated This API has been merged into `z.enum()`. Use `z.enum()` instead.
|
||||
*
|
||||
* ```ts
|
||||
* enum Colors { red, green, blue }
|
||||
* z.enum(Colors);
|
||||
* ```
|
||||
*/
|
||||
export declare function _nativeEnum<T extends util.EnumLike>(Class: util.SchemaClass<schemas.$ZodEnum>, entries: T, params?: string | $ZodEnumParams): schemas.$ZodEnum<T>;
|
||||
export type $ZodLiteralParams = TypeParams<schemas.$ZodLiteral, "values">;
|
||||
export declare function _literal<const T extends Array<util.Literal>>(Class: util.SchemaClass<schemas.$ZodLiteral>, value: T, params?: string | $ZodLiteralParams): schemas.$ZodLiteral<T[number]>;
|
||||
export declare function _literal<const T extends util.Literal>(Class: util.SchemaClass<schemas.$ZodLiteral>, value: T, params?: string | $ZodLiteralParams): schemas.$ZodLiteral<T>;
|
||||
export type $ZodFileParams = TypeParams<schemas.$ZodFile>;
|
||||
export declare function _file(Class: util.SchemaClass<schemas.$ZodFile>, params?: string | $ZodFileParams): schemas.$ZodFile;
|
||||
export type $ZodTransformParams = TypeParams<schemas.$ZodTransform, "transform">;
|
||||
export declare function _transform<I = unknown, O = I>(Class: util.SchemaClass<schemas.$ZodTransform>, fn: (input: I, ctx?: schemas.ParsePayload) => O): schemas.$ZodTransform<Awaited<O>, I>;
|
||||
export type $ZodOptionalParams = TypeParams<schemas.$ZodOptional, "innerType">;
|
||||
export declare function _optional<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodOptional>, innerType: T): schemas.$ZodOptional<T>;
|
||||
export type $ZodNullableParams = TypeParams<schemas.$ZodNullable, "innerType">;
|
||||
export declare function _nullable<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodNullable>, innerType: T): schemas.$ZodNullable<T>;
|
||||
export type $ZodDefaultParams = TypeParams<schemas.$ZodDefault, "innerType" | "defaultValue">;
|
||||
export declare function _default<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodDefault>, innerType: T, defaultValue: util.NoUndefined<core.output<T>> | (() => util.NoUndefined<core.output<T>>)): schemas.$ZodDefault<T>;
|
||||
export type $ZodNonOptionalParams = TypeParams<schemas.$ZodNonOptional, "innerType">;
|
||||
export declare function _nonoptional<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodNonOptional>, innerType: T, params?: string | $ZodNonOptionalParams): schemas.$ZodNonOptional<T>;
|
||||
export type $ZodSuccessParams = TypeParams<schemas.$ZodSuccess, "innerType">;
|
||||
export declare function _success<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodSuccess>, innerType: T): schemas.$ZodSuccess<T>;
|
||||
export type $ZodCatchParams = TypeParams<schemas.$ZodCatch, "innerType" | "catchValue">;
|
||||
export declare function _catch<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodCatch>, innerType: T, catchValue: core.output<T> | ((ctx: schemas.$ZodCatchCtx) => core.output<T>)): schemas.$ZodCatch<T>;
|
||||
export type $ZodPipeParams = TypeParams<schemas.$ZodPipe, "in" | "out">;
|
||||
export declare function _pipe<const A extends schemas.$ZodType, B extends schemas.$ZodType<unknown, core.output<A>> = schemas.$ZodType<unknown, core.output<A>>>(Class: util.SchemaClass<schemas.$ZodPipe>, in_: A, out: B | schemas.$ZodType<unknown, core.output<A>>): schemas.$ZodPipe<A, B>;
|
||||
export type $ZodReadonlyParams = TypeParams<schemas.$ZodReadonly, "innerType">;
|
||||
export declare function _readonly<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodReadonly>, innerType: T): schemas.$ZodReadonly<T>;
|
||||
export type $ZodTemplateLiteralParams = TypeParams<schemas.$ZodTemplateLiteral, "parts">;
|
||||
export declare function _templateLiteral<const Parts extends schemas.$ZodTemplateLiteralPart[]>(Class: util.SchemaClass<schemas.$ZodTemplateLiteral>, parts: Parts, params?: string | $ZodTemplateLiteralParams): schemas.$ZodTemplateLiteral<schemas.$PartsToTemplateLiteral<Parts>>;
|
||||
export type $ZodLazyParams = TypeParams<schemas.$ZodLazy, "getter">;
|
||||
export declare function _lazy<T extends schemas.$ZodType>(Class: util.SchemaClass<schemas.$ZodLazy>, getter: () => T): schemas.$ZodLazy<T>;
|
||||
export type $ZodPromiseParams = TypeParams<schemas.$ZodPromise, "innerType">;
|
||||
export declare function _promise<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodPromise>, innerType: T): schemas.$ZodPromise<T>;
|
||||
export type $ZodCustomParams = CheckTypeParams<schemas.$ZodCustom, "fn">;
|
||||
export declare function _custom<O = unknown, I = O>(Class: util.SchemaClass<schemas.$ZodCustom>, fn: (data: O) => unknown, _params: string | $ZodCustomParams | undefined): schemas.$ZodCustom<O, I>;
|
||||
export declare function _refine<O = unknown, I = O>(Class: util.SchemaClass<schemas.$ZodCustom>, fn: (data: O) => unknown, _params: string | $ZodCustomParams | undefined): schemas.$ZodCustom<O, I>;
|
||||
export type $ZodSuperRefineIssue<T extends errors.$ZodIssueBase = errors.$ZodIssue> = T extends any ? RawIssue<T> : never;
|
||||
type RawIssue<T extends errors.$ZodIssueBase> = T extends any ? util.Flatten<util.MakePartial<T, "message" | "path"> & {
|
||||
/** The schema or check that originated this issue. */
|
||||
readonly inst?: schemas.$ZodType | checks.$ZodCheck;
|
||||
/** If `true`, Zod will execute subsequent checks/refinements instead of immediately aborting */
|
||||
readonly continue?: boolean | undefined;
|
||||
} & Record<string, unknown>> : never;
|
||||
export interface $RefinementCtx<T = unknown> extends schemas.ParsePayload<T> {
|
||||
addIssue(arg: string | $ZodSuperRefineIssue): void;
|
||||
}
|
||||
export interface $ZodSuperRefineParams {
|
||||
/** If provided, the refinement runs only when this returns `true`. By default, it is skipped if prior parsing produced aborting issues. */
|
||||
when?: ((payload: schemas.ParsePayload) => boolean) | undefined;
|
||||
}
|
||||
export declare function _superRefine<T>(fn: (arg: T, payload: $RefinementCtx<T>) => void | Promise<void>, params?: $ZodSuperRefineParams): checks.$ZodCheck<T>;
|
||||
export declare function _check<O = unknown>(fn: schemas.CheckFn<O>, params?: string | $ZodCustomParams): checks.$ZodCheck<O>;
|
||||
export declare function describe<T>(description: string): checks.$ZodCheck<T>;
|
||||
export declare function meta<T>(metadata: registries.GlobalMeta): checks.$ZodCheck<T>;
|
||||
export interface $ZodStringBoolParams extends TypeParams {
|
||||
truthy?: string[];
|
||||
falsy?: string[];
|
||||
/**
|
||||
* Options: `"sensitive"`, `"insensitive"`
|
||||
*
|
||||
* @default `"insensitive"`
|
||||
*/
|
||||
case?: "sensitive" | "insensitive" | undefined;
|
||||
}
|
||||
export declare function _stringbool(Classes: {
|
||||
Codec?: typeof schemas.$ZodCodec;
|
||||
Boolean?: typeof schemas.$ZodBoolean;
|
||||
String?: typeof schemas.$ZodString;
|
||||
}, _params?: string | $ZodStringBoolParams): schemas.$ZodCodec<schemas.$ZodString, schemas.$ZodBoolean>;
|
||||
export declare function _stringFormat<Format extends string>(Class: typeof schemas.$ZodCustomStringFormat, format: Format, fnOrRegex: ((arg: string) => util.MaybeAsync<unknown>) | RegExp, _params?: string | $ZodStringFormatParams): schemas.$ZodCustomStringFormat<Format>;
|
||||
+1107
File diff suppressed because it is too large
Load Diff
+561
@@ -0,0 +1,561 @@
|
||||
"use strict";
|
||||
// import { $ZodType } from "./schemas.js";
|
||||
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
|
||||
if (k2 === undefined) k2 = k;
|
||||
var desc = Object.getOwnPropertyDescriptor(m, k);
|
||||
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
|
||||
desc = { enumerable: true, get: function() { return m[k]; } };
|
||||
}
|
||||
Object.defineProperty(o, k2, desc);
|
||||
}) : (function(o, m, k, k2) {
|
||||
if (k2 === undefined) k2 = k;
|
||||
o[k2] = m[k];
|
||||
}));
|
||||
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
|
||||
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
||||
}) : function(o, v) {
|
||||
o["default"] = v;
|
||||
});
|
||||
var __importStar = (this && this.__importStar) || function (mod) {
|
||||
if (mod && mod.__esModule) return mod;
|
||||
var result = {};
|
||||
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
|
||||
__setModuleDefault(result, mod);
|
||||
return result;
|
||||
};
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.$ZodCheckOverwrite = exports.$ZodCheckMimeType = exports.$ZodCheckProperties = exports.$ZodCheckProperty = exports.$ZodCheckEndsWith = exports.$ZodCheckStartsWith = exports.$ZodCheckIncludes = exports.$ZodCheckUpperCase = exports.$ZodCheckLowerCase = exports.$ZodCheckRegex = exports.$ZodCheckStringFormat = exports.$ZodCheckLengthEquals = exports.$ZodCheckMinLength = exports.$ZodCheckMaxLength = exports.$ZodCheckSizeEquals = exports.$ZodCheckMinSize = exports.$ZodCheckMaxSize = exports.$ZodCheckBigIntFormat = exports.$ZodCheckNumberFormat = exports.$ZodCheckMultipleOf = exports.$ZodCheckGreaterThan = exports.$ZodCheckLessThan = exports.$ZodCheck = void 0;
|
||||
const core = __importStar(require("./core.cjs"));
|
||||
const regexes = __importStar(require("./regexes.cjs"));
|
||||
const util = __importStar(require("./util.cjs"));
|
||||
exports.$ZodCheck = core.$constructor("$ZodCheck", (inst, def) => {
|
||||
var _a;
|
||||
inst._zod ?? (inst._zod = {});
|
||||
inst._zod.def = def;
|
||||
(_a = inst._zod).onattach ?? (_a.onattach = []);
|
||||
});
|
||||
/** 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",
|
||||
};
|
||||
exports.$ZodCheckLessThan = core.$constructor("$ZodCheckLessThan", (inst, def) => {
|
||||
exports.$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,
|
||||
});
|
||||
};
|
||||
});
|
||||
exports.$ZodCheckGreaterThan = core.$constructor("$ZodCheckGreaterThan", (inst, def) => {
|
||||
exports.$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,
|
||||
});
|
||||
};
|
||||
});
|
||||
exports.$ZodCheckMultipleOf =
|
||||
/*@__PURE__*/ core.$constructor("$ZodCheckMultipleOf", (inst, def) => {
|
||||
exports.$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,
|
||||
});
|
||||
};
|
||||
});
|
||||
exports.$ZodCheckNumberFormat = core.$constructor("$ZodCheckNumberFormat", (inst, def) => {
|
||||
exports.$ZodCheck.init(inst, def); // no format checks
|
||||
def.format = def.format || "float64";
|
||||
const isInt = def.format?.includes("int");
|
||||
const origin = isInt ? "int" : "number";
|
||||
const [minimum, maximum] = util.NUMBER_FORMAT_RANGES[def.format];
|
||||
inst._zod.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,
|
||||
});
|
||||
}
|
||||
};
|
||||
});
|
||||
exports.$ZodCheckBigIntFormat = core.$constructor("$ZodCheckBigIntFormat", (inst, def) => {
|
||||
exports.$ZodCheck.init(inst, def); // no format checks
|
||||
const [minimum, maximum] = util.BIGINT_FORMAT_RANGES[def.format];
|
||||
inst._zod.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,
|
||||
});
|
||||
}
|
||||
};
|
||||
});
|
||||
exports.$ZodCheckMaxSize = core.$constructor("$ZodCheckMaxSize", (inst, def) => {
|
||||
var _a;
|
||||
exports.$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,
|
||||
});
|
||||
};
|
||||
});
|
||||
exports.$ZodCheckMinSize = core.$constructor("$ZodCheckMinSize", (inst, def) => {
|
||||
var _a;
|
||||
exports.$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,
|
||||
});
|
||||
};
|
||||
});
|
||||
exports.$ZodCheckSizeEquals = core.$constructor("$ZodCheckSizeEquals", (inst, def) => {
|
||||
var _a;
|
||||
exports.$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,
|
||||
});
|
||||
};
|
||||
});
|
||||
exports.$ZodCheckMaxLength = core.$constructor("$ZodCheckMaxLength", (inst, def) => {
|
||||
var _a;
|
||||
exports.$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,
|
||||
});
|
||||
};
|
||||
});
|
||||
exports.$ZodCheckMinLength = core.$constructor("$ZodCheckMinLength", (inst, def) => {
|
||||
var _a;
|
||||
exports.$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,
|
||||
});
|
||||
};
|
||||
});
|
||||
exports.$ZodCheckLengthEquals = core.$constructor("$ZodCheckLengthEquals", (inst, def) => {
|
||||
var _a;
|
||||
exports.$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,
|
||||
});
|
||||
};
|
||||
});
|
||||
exports.$ZodCheckStringFormat = core.$constructor("$ZodCheckStringFormat", (inst, def) => {
|
||||
var _a, _b;
|
||||
exports.$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 = () => { });
|
||||
});
|
||||
exports.$ZodCheckRegex = core.$constructor("$ZodCheckRegex", (inst, def) => {
|
||||
exports.$ZodCheckStringFormat.init(inst, def);
|
||||
inst._zod.check = (payload) => {
|
||||
def.pattern.lastIndex = 0;
|
||||
if (def.pattern.test(payload.value))
|
||||
return;
|
||||
payload.issues.push({
|
||||
origin: "string",
|
||||
code: "invalid_format",
|
||||
format: "regex",
|
||||
input: payload.value,
|
||||
pattern: def.pattern.toString(),
|
||||
inst,
|
||||
continue: !def.abort,
|
||||
});
|
||||
};
|
||||
});
|
||||
exports.$ZodCheckLowerCase = core.$constructor("$ZodCheckLowerCase", (inst, def) => {
|
||||
def.pattern ?? (def.pattern = regexes.lowercase);
|
||||
exports.$ZodCheckStringFormat.init(inst, def);
|
||||
});
|
||||
exports.$ZodCheckUpperCase = core.$constructor("$ZodCheckUpperCase", (inst, def) => {
|
||||
def.pattern ?? (def.pattern = regexes.uppercase);
|
||||
exports.$ZodCheckStringFormat.init(inst, def);
|
||||
});
|
||||
exports.$ZodCheckIncludes = core.$constructor("$ZodCheckIncludes", (inst, def) => {
|
||||
exports.$ZodCheck.init(inst, def);
|
||||
const escapedRegex = util.escapeRegex(def.includes);
|
||||
// `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,
|
||||
});
|
||||
};
|
||||
});
|
||||
exports.$ZodCheckStartsWith = core.$constructor("$ZodCheckStartsWith", (inst, def) => {
|
||||
exports.$ZodCheck.init(inst, def);
|
||||
const pattern = new RegExp(`^${util.escapeRegex(def.prefix)}.*`);
|
||||
def.pattern ?? (def.pattern = pattern);
|
||||
inst._zod.check = (payload) => {
|
||||
if (payload.value.startsWith(def.prefix))
|
||||
return;
|
||||
payload.issues.push({
|
||||
origin: "string",
|
||||
code: "invalid_format",
|
||||
format: "starts_with",
|
||||
prefix: def.prefix,
|
||||
input: payload.value,
|
||||
inst,
|
||||
continue: !def.abort,
|
||||
});
|
||||
};
|
||||
});
|
||||
exports.$ZodCheckEndsWith = core.$constructor("$ZodCheckEndsWith", (inst, def) => {
|
||||
exports.$ZodCheck.init(inst, def);
|
||||
const pattern = new RegExp(`.*${util.escapeRegex(def.suffix)}$`);
|
||||
def.pattern ?? (def.pattern = pattern);
|
||||
inst._zod.check = (payload) => {
|
||||
if (payload.value.endsWith(def.suffix))
|
||||
return;
|
||||
payload.issues.push({
|
||||
origin: "string",
|
||||
code: "invalid_format",
|
||||
format: "ends_with",
|
||||
suffix: def.suffix,
|
||||
input: payload.value,
|
||||
inst,
|
||||
continue: !def.abort,
|
||||
});
|
||||
};
|
||||
});
|
||||
///////////////////////////////////
|
||||
///// $ZodCheckProperty /////
|
||||
///////////////////////////////////
|
||||
function handleCheckPropertyResult(result, payload, property) {
|
||||
if (result.issues.length) {
|
||||
payload.issues.push(...util.prefixIssues(property, result.issues));
|
||||
}
|
||||
}
|
||||
exports.$ZodCheckProperty = core.$constructor("$ZodCheckProperty", (inst, def) => {
|
||||
exports.$ZodCheck.init(inst, def);
|
||||
inst._zod.check = (payload) => {
|
||||
const result = def.schema._zod.run({
|
||||
value: payload.value[def.property],
|
||||
issues: [],
|
||||
}, {});
|
||||
if (result instanceof Promise) {
|
||||
return result.then((result) => handleCheckPropertyResult(result, payload, def.property));
|
||||
}
|
||||
handleCheckPropertyResult(result, payload, def.property);
|
||||
return;
|
||||
};
|
||||
});
|
||||
exports.$ZodCheckProperties = core.$constructor("$ZodCheckProperties", (inst, def) => {
|
||||
exports.$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;
|
||||
};
|
||||
});
|
||||
exports.$ZodCheckMimeType = core.$constructor("$ZodCheckMimeType", (inst, def) => {
|
||||
exports.$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,
|
||||
});
|
||||
};
|
||||
});
|
||||
exports.$ZodCheckOverwrite = core.$constructor("$ZodCheckOverwrite", (inst, def) => {
|
||||
exports.$ZodCheck.init(inst, def);
|
||||
inst._zod.check = (payload) => {
|
||||
payload.value = def.tx(payload.value);
|
||||
};
|
||||
});
|
||||
|
||||
// seal-cjs-exports
|
||||
(function () {
|
||||
var keys = Object.getOwnPropertyNames(exports);
|
||||
for (var i = 0; i < keys.length; i++) {
|
||||
var desc = Object.getOwnPropertyDescriptor(exports, keys[i]);
|
||||
if (!desc || !desc.get || !desc.configurable) continue;
|
||||
var value;
|
||||
try {
|
||||
value = desc.get();
|
||||
} catch (e) {
|
||||
continue;
|
||||
}
|
||||
// a circular require may not have settled this one yet, so leave it live
|
||||
if (value === undefined) continue;
|
||||
Object.defineProperty(exports, keys[i], { value: value, writable: false, enumerable: desc.enumerable, configurable: false });
|
||||
}
|
||||
Object.freeze(exports);
|
||||
})();
|
||||
+294
@@ -0,0 +1,294 @@
|
||||
import * as core from "./core.cjs";
|
||||
import type * as errors from "./errors.cjs";
|
||||
import type * as schemas from "./schemas.cjs";
|
||||
import * as util from "./util.cjs";
|
||||
export interface $ZodCheckDef {
|
||||
check: string;
|
||||
error?: errors.$ZodErrorMap<never> | undefined;
|
||||
/** If true, no later checks will be executed if this check fails. Default `false`. */
|
||||
abort?: boolean | undefined;
|
||||
/** If provided, the check runs only when this returns `true`. By default, it is skipped if prior parsing produced aborting issues. */
|
||||
when?: ((payload: schemas.ParsePayload) => boolean) | undefined;
|
||||
}
|
||||
export interface $ZodCheckInternals<T> {
|
||||
def: $ZodCheckDef;
|
||||
/** The set of issues this check might throw. */
|
||||
issc?: errors.$ZodIssueBase;
|
||||
check(payload: schemas.ParsePayload<T>): util.MaybeAsync<void>;
|
||||
onattach: ((schema: schemas.$ZodType) => void)[];
|
||||
}
|
||||
export interface $ZodCheck<in T = never> {
|
||||
_zod: $ZodCheckInternals<T>;
|
||||
}
|
||||
export declare const $ZodCheck: core.$constructor<$ZodCheck<any>>;
|
||||
export interface $ZodCheckLessThanDef extends $ZodCheckDef {
|
||||
check: "less_than";
|
||||
value: util.Numeric;
|
||||
inclusive: boolean;
|
||||
}
|
||||
export interface $ZodCheckLessThanInternals<T extends util.Numeric = util.Numeric> extends $ZodCheckInternals<T> {
|
||||
def: $ZodCheckLessThanDef;
|
||||
issc: errors.$ZodIssueTooBig<T>;
|
||||
}
|
||||
export interface $ZodCheckLessThan<T extends util.Numeric = util.Numeric> extends $ZodCheck<T> {
|
||||
_zod: $ZodCheckLessThanInternals<T>;
|
||||
}
|
||||
export declare const $ZodCheckLessThan: core.$constructor<$ZodCheckLessThan>;
|
||||
export interface $ZodCheckGreaterThanDef extends $ZodCheckDef {
|
||||
check: "greater_than";
|
||||
value: util.Numeric;
|
||||
inclusive: boolean;
|
||||
}
|
||||
export interface $ZodCheckGreaterThanInternals<T extends util.Numeric = util.Numeric> extends $ZodCheckInternals<T> {
|
||||
def: $ZodCheckGreaterThanDef;
|
||||
issc: errors.$ZodIssueTooSmall<T>;
|
||||
}
|
||||
export interface $ZodCheckGreaterThan<T extends util.Numeric = util.Numeric> extends $ZodCheck<T> {
|
||||
_zod: $ZodCheckGreaterThanInternals<T>;
|
||||
}
|
||||
export declare const $ZodCheckGreaterThan: core.$constructor<$ZodCheckGreaterThan>;
|
||||
export interface $ZodCheckMultipleOfDef<T extends number | bigint = number | bigint> extends $ZodCheckDef {
|
||||
check: "multiple_of";
|
||||
value: T;
|
||||
}
|
||||
export interface $ZodCheckMultipleOfInternals<T extends number | bigint = number | bigint> extends $ZodCheckInternals<T> {
|
||||
def: $ZodCheckMultipleOfDef<T>;
|
||||
issc: errors.$ZodIssueNotMultipleOf;
|
||||
}
|
||||
export interface $ZodCheckMultipleOf<T extends number | bigint = number | bigint> extends $ZodCheck<T> {
|
||||
_zod: $ZodCheckMultipleOfInternals<T>;
|
||||
}
|
||||
export declare const $ZodCheckMultipleOf: core.$constructor<$ZodCheckMultipleOf<number | bigint>>;
|
||||
export type $ZodNumberFormats = "int32" | "uint32" | "float32" | "float64" | "safeint";
|
||||
export interface $ZodCheckNumberFormatDef<Format extends $ZodNumberFormats = $ZodNumberFormats> extends $ZodCheckDef {
|
||||
check: "number_format";
|
||||
format: Format;
|
||||
}
|
||||
export interface $ZodCheckNumberFormatInternals<Format extends $ZodNumberFormats = $ZodNumberFormats> extends $ZodCheckInternals<number> {
|
||||
def: $ZodCheckNumberFormatDef<Format>;
|
||||
issc: errors.$ZodIssueInvalidType | errors.$ZodIssueTooBig<"number"> | errors.$ZodIssueTooSmall<"number">;
|
||||
}
|
||||
export interface $ZodCheckNumberFormat<Format extends $ZodNumberFormats = $ZodNumberFormats> extends $ZodCheck<number> {
|
||||
_zod: $ZodCheckNumberFormatInternals<Format>;
|
||||
}
|
||||
export declare const $ZodCheckNumberFormat: core.$constructor<$ZodCheckNumberFormat>;
|
||||
export type $ZodBigIntFormats = "int64" | "uint64";
|
||||
export interface $ZodCheckBigIntFormatDef<Format extends $ZodBigIntFormats = $ZodBigIntFormats> extends $ZodCheckDef {
|
||||
check: "bigint_format";
|
||||
format: Format;
|
||||
}
|
||||
export interface $ZodCheckBigIntFormatInternals<Format extends $ZodBigIntFormats = $ZodBigIntFormats> extends $ZodCheckInternals<bigint> {
|
||||
def: $ZodCheckBigIntFormatDef<Format>;
|
||||
issc: errors.$ZodIssueTooBig<"bigint"> | errors.$ZodIssueTooSmall<"bigint">;
|
||||
}
|
||||
export interface $ZodCheckBigIntFormat<Format extends $ZodBigIntFormats = $ZodBigIntFormats> extends $ZodCheck<bigint> {
|
||||
_zod: $ZodCheckBigIntFormatInternals<Format>;
|
||||
}
|
||||
export declare const $ZodCheckBigIntFormat: core.$constructor<$ZodCheckBigIntFormat>;
|
||||
export interface $ZodCheckMaxSizeDef extends $ZodCheckDef {
|
||||
check: "max_size";
|
||||
maximum: number;
|
||||
}
|
||||
export interface $ZodCheckMaxSizeInternals<T extends util.HasSize = util.HasSize> extends $ZodCheckInternals<T> {
|
||||
def: $ZodCheckMaxSizeDef;
|
||||
issc: errors.$ZodIssueTooBig<T>;
|
||||
}
|
||||
export interface $ZodCheckMaxSize<T extends util.HasSize = util.HasSize> extends $ZodCheck<T> {
|
||||
_zod: $ZodCheckMaxSizeInternals<T>;
|
||||
}
|
||||
export declare const $ZodCheckMaxSize: core.$constructor<$ZodCheckMaxSize>;
|
||||
export interface $ZodCheckMinSizeDef extends $ZodCheckDef {
|
||||
check: "min_size";
|
||||
minimum: number;
|
||||
}
|
||||
export interface $ZodCheckMinSizeInternals<T extends util.HasSize = util.HasSize> extends $ZodCheckInternals<T> {
|
||||
def: $ZodCheckMinSizeDef;
|
||||
issc: errors.$ZodIssueTooSmall<T>;
|
||||
}
|
||||
export interface $ZodCheckMinSize<T extends util.HasSize = util.HasSize> extends $ZodCheck<T> {
|
||||
_zod: $ZodCheckMinSizeInternals<T>;
|
||||
}
|
||||
export declare const $ZodCheckMinSize: core.$constructor<$ZodCheckMinSize>;
|
||||
export interface $ZodCheckSizeEqualsDef extends $ZodCheckDef {
|
||||
check: "size_equals";
|
||||
size: number;
|
||||
}
|
||||
export interface $ZodCheckSizeEqualsInternals<T extends util.HasSize = util.HasSize> extends $ZodCheckInternals<T> {
|
||||
def: $ZodCheckSizeEqualsDef;
|
||||
issc: errors.$ZodIssueTooBig<T> | errors.$ZodIssueTooSmall<T>;
|
||||
}
|
||||
export interface $ZodCheckSizeEquals<T extends util.HasSize = util.HasSize> extends $ZodCheck<T> {
|
||||
_zod: $ZodCheckSizeEqualsInternals<T>;
|
||||
}
|
||||
export declare const $ZodCheckSizeEquals: core.$constructor<$ZodCheckSizeEquals>;
|
||||
export interface $ZodCheckMaxLengthDef extends $ZodCheckDef {
|
||||
check: "max_length";
|
||||
maximum: number;
|
||||
}
|
||||
export interface $ZodCheckMaxLengthInternals<T extends util.HasLength = util.HasLength> extends $ZodCheckInternals<T> {
|
||||
def: $ZodCheckMaxLengthDef;
|
||||
issc: errors.$ZodIssueTooBig<T>;
|
||||
}
|
||||
export interface $ZodCheckMaxLength<T extends util.HasLength = util.HasLength> extends $ZodCheck<T> {
|
||||
_zod: $ZodCheckMaxLengthInternals<T>;
|
||||
}
|
||||
export declare const $ZodCheckMaxLength: core.$constructor<$ZodCheckMaxLength>;
|
||||
export interface $ZodCheckMinLengthDef extends $ZodCheckDef {
|
||||
check: "min_length";
|
||||
minimum: number;
|
||||
}
|
||||
export interface $ZodCheckMinLengthInternals<T extends util.HasLength = util.HasLength> extends $ZodCheckInternals<T> {
|
||||
def: $ZodCheckMinLengthDef;
|
||||
issc: errors.$ZodIssueTooSmall<T>;
|
||||
}
|
||||
export interface $ZodCheckMinLength<T extends util.HasLength = util.HasLength> extends $ZodCheck<T> {
|
||||
_zod: $ZodCheckMinLengthInternals<T>;
|
||||
}
|
||||
export declare const $ZodCheckMinLength: core.$constructor<$ZodCheckMinLength>;
|
||||
export interface $ZodCheckLengthEqualsDef extends $ZodCheckDef {
|
||||
check: "length_equals";
|
||||
length: number;
|
||||
}
|
||||
export interface $ZodCheckLengthEqualsInternals<T extends util.HasLength = util.HasLength> extends $ZodCheckInternals<T> {
|
||||
def: $ZodCheckLengthEqualsDef;
|
||||
issc: errors.$ZodIssueTooBig<T> | errors.$ZodIssueTooSmall<T>;
|
||||
}
|
||||
export interface $ZodCheckLengthEquals<T extends util.HasLength = util.HasLength> extends $ZodCheck<T> {
|
||||
_zod: $ZodCheckLengthEqualsInternals<T>;
|
||||
}
|
||||
export declare const $ZodCheckLengthEquals: core.$constructor<$ZodCheckLengthEquals>;
|
||||
export type $ZodStringFormats = "email" | "url" | "emoji" | "uuid" | "guid" | "nanoid" | "cuid" | "cuid2" | "ulid" | "xid" | "ksuid" | "datetime" | "date" | "time" | "duration" | "ipv4" | "ipv6" | "cidrv4" | "cidrv6" | "base64" | "base64url" | "json_string" | "e164" | "credit_card" | "iban" | "lowercase" | "uppercase" | "regex" | "jwt" | "starts_with" | "ends_with" | "includes";
|
||||
export interface $ZodCheckStringFormatDef<Format extends string = string> extends $ZodCheckDef {
|
||||
check: "string_format";
|
||||
format: Format;
|
||||
pattern?: RegExp | undefined;
|
||||
}
|
||||
export interface $ZodCheckStringFormatInternals extends $ZodCheckInternals<string> {
|
||||
def: $ZodCheckStringFormatDef;
|
||||
issc: errors.$ZodIssueInvalidStringFormat;
|
||||
}
|
||||
export interface $ZodCheckStringFormat extends $ZodCheck<string> {
|
||||
_zod: $ZodCheckStringFormatInternals;
|
||||
}
|
||||
export declare const $ZodCheckStringFormat: core.$constructor<$ZodCheckStringFormat>;
|
||||
export interface $ZodCheckRegexDef extends $ZodCheckStringFormatDef {
|
||||
format: "regex";
|
||||
pattern: RegExp;
|
||||
}
|
||||
export interface $ZodCheckRegexInternals extends $ZodCheckInternals<string> {
|
||||
def: $ZodCheckRegexDef;
|
||||
issc: errors.$ZodIssueInvalidStringFormat;
|
||||
}
|
||||
export interface $ZodCheckRegex extends $ZodCheck<string> {
|
||||
_zod: $ZodCheckRegexInternals;
|
||||
}
|
||||
export declare const $ZodCheckRegex: core.$constructor<$ZodCheckRegex>;
|
||||
export interface $ZodCheckLowerCaseDef extends $ZodCheckStringFormatDef<"lowercase"> {
|
||||
}
|
||||
export interface $ZodCheckLowerCaseInternals extends $ZodCheckInternals<string> {
|
||||
def: $ZodCheckLowerCaseDef;
|
||||
issc: errors.$ZodIssueInvalidStringFormat;
|
||||
}
|
||||
export interface $ZodCheckLowerCase extends $ZodCheck<string> {
|
||||
_zod: $ZodCheckLowerCaseInternals;
|
||||
}
|
||||
export declare const $ZodCheckLowerCase: core.$constructor<$ZodCheckLowerCase>;
|
||||
export interface $ZodCheckUpperCaseDef extends $ZodCheckStringFormatDef<"uppercase"> {
|
||||
}
|
||||
export interface $ZodCheckUpperCaseInternals extends $ZodCheckInternals<string> {
|
||||
def: $ZodCheckUpperCaseDef;
|
||||
issc: errors.$ZodIssueInvalidStringFormat;
|
||||
}
|
||||
export interface $ZodCheckUpperCase extends $ZodCheck<string> {
|
||||
_zod: $ZodCheckUpperCaseInternals;
|
||||
}
|
||||
export declare const $ZodCheckUpperCase: core.$constructor<$ZodCheckUpperCase>;
|
||||
export interface $ZodCheckIncludesDef extends $ZodCheckStringFormatDef<"includes"> {
|
||||
includes: string;
|
||||
position?: number | undefined;
|
||||
}
|
||||
export interface $ZodCheckIncludesInternals extends $ZodCheckInternals<string> {
|
||||
def: $ZodCheckIncludesDef;
|
||||
issc: errors.$ZodIssueInvalidStringFormat;
|
||||
}
|
||||
export interface $ZodCheckIncludes extends $ZodCheck<string> {
|
||||
_zod: $ZodCheckIncludesInternals;
|
||||
}
|
||||
export declare const $ZodCheckIncludes: core.$constructor<$ZodCheckIncludes>;
|
||||
export interface $ZodCheckStartsWithDef extends $ZodCheckStringFormatDef<"starts_with"> {
|
||||
prefix: string;
|
||||
}
|
||||
export interface $ZodCheckStartsWithInternals extends $ZodCheckInternals<string> {
|
||||
def: $ZodCheckStartsWithDef;
|
||||
issc: errors.$ZodIssueInvalidStringFormat;
|
||||
}
|
||||
export interface $ZodCheckStartsWith extends $ZodCheck<string> {
|
||||
_zod: $ZodCheckStartsWithInternals;
|
||||
}
|
||||
export declare const $ZodCheckStartsWith: core.$constructor<$ZodCheckStartsWith>;
|
||||
export interface $ZodCheckEndsWithDef extends $ZodCheckStringFormatDef<"ends_with"> {
|
||||
suffix: string;
|
||||
}
|
||||
export interface $ZodCheckEndsWithInternals extends $ZodCheckInternals<string> {
|
||||
def: $ZodCheckEndsWithDef;
|
||||
issc: errors.$ZodIssueInvalidStringFormat;
|
||||
}
|
||||
export interface $ZodCheckEndsWith extends $ZodCheckInternals<string> {
|
||||
_zod: $ZodCheckEndsWithInternals;
|
||||
}
|
||||
export declare const $ZodCheckEndsWith: core.$constructor<$ZodCheckEndsWith>;
|
||||
export interface $ZodCheckPropertyDef extends $ZodCheckDef {
|
||||
check: "property";
|
||||
property: string;
|
||||
schema: schemas.$ZodType;
|
||||
}
|
||||
export interface $ZodCheckPropertyInternals<T extends object = object> extends $ZodCheckInternals<T> {
|
||||
def: $ZodCheckPropertyDef;
|
||||
issc: errors.$ZodIssue;
|
||||
}
|
||||
export interface $ZodCheckProperty<T extends object = object> extends $ZodCheck<T> {
|
||||
_zod: $ZodCheckPropertyInternals<T>;
|
||||
}
|
||||
export declare const $ZodCheckProperty: core.$constructor<$ZodCheckProperty>;
|
||||
export interface $ZodCheckPropertiesDef<Shape extends schemas.$ZodShape = schemas.$ZodShape> extends $ZodCheckDef {
|
||||
check: "properties";
|
||||
shape: Shape;
|
||||
}
|
||||
export type $ZodCheckPropertiesInput<Shape extends schemas.$ZodShape = schemas.$ZodShape> = {
|
||||
-readonly [k in keyof Shape]: util.Widen<core.input<Shape[k]>>;
|
||||
};
|
||||
export interface $ZodCheckPropertiesInternals<Shape extends schemas.$ZodShape = schemas.$ZodShape> extends $ZodCheckInternals<$ZodCheckPropertiesInput<Shape>> {
|
||||
def: $ZodCheckPropertiesDef<Shape>;
|
||||
issc: errors.$ZodIssue;
|
||||
}
|
||||
export interface $ZodCheckProperties<Shape extends schemas.$ZodShape = schemas.$ZodShape> extends $ZodCheck<$ZodCheckPropertiesInput<Shape>> {
|
||||
_zod: $ZodCheckPropertiesInternals<Shape>;
|
||||
[Symbol.iterator](): Iterator<this>;
|
||||
}
|
||||
export declare const $ZodCheckProperties: core.$constructor<$ZodCheckProperties>;
|
||||
export interface $ZodCheckMimeTypeDef extends $ZodCheckDef {
|
||||
check: "mime_type";
|
||||
mime: util.MimeTypes[];
|
||||
}
|
||||
export interface $ZodCheckMimeTypeInternals<T extends schemas.File = schemas.File> extends $ZodCheckInternals<T> {
|
||||
def: $ZodCheckMimeTypeDef;
|
||||
issc: errors.$ZodIssueInvalidValue;
|
||||
}
|
||||
export interface $ZodCheckMimeType<T extends schemas.File = schemas.File> extends $ZodCheck<T> {
|
||||
_zod: $ZodCheckMimeTypeInternals<T>;
|
||||
}
|
||||
export declare const $ZodCheckMimeType: core.$constructor<$ZodCheckMimeType>;
|
||||
export interface $ZodCheckOverwriteDef<T = unknown> extends $ZodCheckDef {
|
||||
check: "overwrite";
|
||||
tx(value: T): T;
|
||||
}
|
||||
export interface $ZodCheckOverwriteInternals<T = unknown> extends $ZodCheckInternals<T> {
|
||||
def: $ZodCheckOverwriteDef<T>;
|
||||
issc: never;
|
||||
}
|
||||
export interface $ZodCheckOverwrite<T = unknown> extends $ZodCheck<T> {
|
||||
_zod: $ZodCheckOverwriteInternals<T>;
|
||||
}
|
||||
export declare const $ZodCheckOverwrite: core.$constructor<$ZodCheckOverwrite>;
|
||||
export type $ZodChecks = $ZodCheckLessThan | $ZodCheckGreaterThan | $ZodCheckMultipleOf | $ZodCheckNumberFormat | $ZodCheckBigIntFormat | $ZodCheckMaxSize | $ZodCheckMinSize | $ZodCheckSizeEquals | $ZodCheckMaxLength | $ZodCheckMinLength | $ZodCheckLengthEquals | $ZodCheckStringFormat | $ZodCheckProperty | $ZodCheckMimeType | $ZodCheckOverwrite;
|
||||
export type $ZodStringFormatChecks = $ZodCheckRegex | $ZodCheckLowerCase | $ZodCheckUpperCase | $ZodCheckIncludes | $ZodCheckStartsWith | $ZodCheckEndsWith | schemas.$ZodStringFormatTypes;
|
||||
+294
@@ -0,0 +1,294 @@
|
||||
import * as core from "./core.js";
|
||||
import type * as errors from "./errors.js";
|
||||
import type * as schemas from "./schemas.js";
|
||||
import * as util from "./util.js";
|
||||
export interface $ZodCheckDef {
|
||||
check: string;
|
||||
error?: errors.$ZodErrorMap<never> | undefined;
|
||||
/** If true, no later checks will be executed if this check fails. Default `false`. */
|
||||
abort?: boolean | undefined;
|
||||
/** If provided, the check runs only when this returns `true`. By default, it is skipped if prior parsing produced aborting issues. */
|
||||
when?: ((payload: schemas.ParsePayload) => boolean) | undefined;
|
||||
}
|
||||
export interface $ZodCheckInternals<T> {
|
||||
def: $ZodCheckDef;
|
||||
/** The set of issues this check might throw. */
|
||||
issc?: errors.$ZodIssueBase;
|
||||
check(payload: schemas.ParsePayload<T>): util.MaybeAsync<void>;
|
||||
onattach: ((schema: schemas.$ZodType) => void)[];
|
||||
}
|
||||
export interface $ZodCheck<in T = never> {
|
||||
_zod: $ZodCheckInternals<T>;
|
||||
}
|
||||
export declare const $ZodCheck: core.$constructor<$ZodCheck<any>>;
|
||||
export interface $ZodCheckLessThanDef extends $ZodCheckDef {
|
||||
check: "less_than";
|
||||
value: util.Numeric;
|
||||
inclusive: boolean;
|
||||
}
|
||||
export interface $ZodCheckLessThanInternals<T extends util.Numeric = util.Numeric> extends $ZodCheckInternals<T> {
|
||||
def: $ZodCheckLessThanDef;
|
||||
issc: errors.$ZodIssueTooBig<T>;
|
||||
}
|
||||
export interface $ZodCheckLessThan<T extends util.Numeric = util.Numeric> extends $ZodCheck<T> {
|
||||
_zod: $ZodCheckLessThanInternals<T>;
|
||||
}
|
||||
export declare const $ZodCheckLessThan: core.$constructor<$ZodCheckLessThan>;
|
||||
export interface $ZodCheckGreaterThanDef extends $ZodCheckDef {
|
||||
check: "greater_than";
|
||||
value: util.Numeric;
|
||||
inclusive: boolean;
|
||||
}
|
||||
export interface $ZodCheckGreaterThanInternals<T extends util.Numeric = util.Numeric> extends $ZodCheckInternals<T> {
|
||||
def: $ZodCheckGreaterThanDef;
|
||||
issc: errors.$ZodIssueTooSmall<T>;
|
||||
}
|
||||
export interface $ZodCheckGreaterThan<T extends util.Numeric = util.Numeric> extends $ZodCheck<T> {
|
||||
_zod: $ZodCheckGreaterThanInternals<T>;
|
||||
}
|
||||
export declare const $ZodCheckGreaterThan: core.$constructor<$ZodCheckGreaterThan>;
|
||||
export interface $ZodCheckMultipleOfDef<T extends number | bigint = number | bigint> extends $ZodCheckDef {
|
||||
check: "multiple_of";
|
||||
value: T;
|
||||
}
|
||||
export interface $ZodCheckMultipleOfInternals<T extends number | bigint = number | bigint> extends $ZodCheckInternals<T> {
|
||||
def: $ZodCheckMultipleOfDef<T>;
|
||||
issc: errors.$ZodIssueNotMultipleOf;
|
||||
}
|
||||
export interface $ZodCheckMultipleOf<T extends number | bigint = number | bigint> extends $ZodCheck<T> {
|
||||
_zod: $ZodCheckMultipleOfInternals<T>;
|
||||
}
|
||||
export declare const $ZodCheckMultipleOf: core.$constructor<$ZodCheckMultipleOf<number | bigint>>;
|
||||
export type $ZodNumberFormats = "int32" | "uint32" | "float32" | "float64" | "safeint";
|
||||
export interface $ZodCheckNumberFormatDef<Format extends $ZodNumberFormats = $ZodNumberFormats> extends $ZodCheckDef {
|
||||
check: "number_format";
|
||||
format: Format;
|
||||
}
|
||||
export interface $ZodCheckNumberFormatInternals<Format extends $ZodNumberFormats = $ZodNumberFormats> extends $ZodCheckInternals<number> {
|
||||
def: $ZodCheckNumberFormatDef<Format>;
|
||||
issc: errors.$ZodIssueInvalidType | errors.$ZodIssueTooBig<"number"> | errors.$ZodIssueTooSmall<"number">;
|
||||
}
|
||||
export interface $ZodCheckNumberFormat<Format extends $ZodNumberFormats = $ZodNumberFormats> extends $ZodCheck<number> {
|
||||
_zod: $ZodCheckNumberFormatInternals<Format>;
|
||||
}
|
||||
export declare const $ZodCheckNumberFormat: core.$constructor<$ZodCheckNumberFormat>;
|
||||
export type $ZodBigIntFormats = "int64" | "uint64";
|
||||
export interface $ZodCheckBigIntFormatDef<Format extends $ZodBigIntFormats = $ZodBigIntFormats> extends $ZodCheckDef {
|
||||
check: "bigint_format";
|
||||
format: Format;
|
||||
}
|
||||
export interface $ZodCheckBigIntFormatInternals<Format extends $ZodBigIntFormats = $ZodBigIntFormats> extends $ZodCheckInternals<bigint> {
|
||||
def: $ZodCheckBigIntFormatDef<Format>;
|
||||
issc: errors.$ZodIssueTooBig<"bigint"> | errors.$ZodIssueTooSmall<"bigint">;
|
||||
}
|
||||
export interface $ZodCheckBigIntFormat<Format extends $ZodBigIntFormats = $ZodBigIntFormats> extends $ZodCheck<bigint> {
|
||||
_zod: $ZodCheckBigIntFormatInternals<Format>;
|
||||
}
|
||||
export declare const $ZodCheckBigIntFormat: core.$constructor<$ZodCheckBigIntFormat>;
|
||||
export interface $ZodCheckMaxSizeDef extends $ZodCheckDef {
|
||||
check: "max_size";
|
||||
maximum: number;
|
||||
}
|
||||
export interface $ZodCheckMaxSizeInternals<T extends util.HasSize = util.HasSize> extends $ZodCheckInternals<T> {
|
||||
def: $ZodCheckMaxSizeDef;
|
||||
issc: errors.$ZodIssueTooBig<T>;
|
||||
}
|
||||
export interface $ZodCheckMaxSize<T extends util.HasSize = util.HasSize> extends $ZodCheck<T> {
|
||||
_zod: $ZodCheckMaxSizeInternals<T>;
|
||||
}
|
||||
export declare const $ZodCheckMaxSize: core.$constructor<$ZodCheckMaxSize>;
|
||||
export interface $ZodCheckMinSizeDef extends $ZodCheckDef {
|
||||
check: "min_size";
|
||||
minimum: number;
|
||||
}
|
||||
export interface $ZodCheckMinSizeInternals<T extends util.HasSize = util.HasSize> extends $ZodCheckInternals<T> {
|
||||
def: $ZodCheckMinSizeDef;
|
||||
issc: errors.$ZodIssueTooSmall<T>;
|
||||
}
|
||||
export interface $ZodCheckMinSize<T extends util.HasSize = util.HasSize> extends $ZodCheck<T> {
|
||||
_zod: $ZodCheckMinSizeInternals<T>;
|
||||
}
|
||||
export declare const $ZodCheckMinSize: core.$constructor<$ZodCheckMinSize>;
|
||||
export interface $ZodCheckSizeEqualsDef extends $ZodCheckDef {
|
||||
check: "size_equals";
|
||||
size: number;
|
||||
}
|
||||
export interface $ZodCheckSizeEqualsInternals<T extends util.HasSize = util.HasSize> extends $ZodCheckInternals<T> {
|
||||
def: $ZodCheckSizeEqualsDef;
|
||||
issc: errors.$ZodIssueTooBig<T> | errors.$ZodIssueTooSmall<T>;
|
||||
}
|
||||
export interface $ZodCheckSizeEquals<T extends util.HasSize = util.HasSize> extends $ZodCheck<T> {
|
||||
_zod: $ZodCheckSizeEqualsInternals<T>;
|
||||
}
|
||||
export declare const $ZodCheckSizeEquals: core.$constructor<$ZodCheckSizeEquals>;
|
||||
export interface $ZodCheckMaxLengthDef extends $ZodCheckDef {
|
||||
check: "max_length";
|
||||
maximum: number;
|
||||
}
|
||||
export interface $ZodCheckMaxLengthInternals<T extends util.HasLength = util.HasLength> extends $ZodCheckInternals<T> {
|
||||
def: $ZodCheckMaxLengthDef;
|
||||
issc: errors.$ZodIssueTooBig<T>;
|
||||
}
|
||||
export interface $ZodCheckMaxLength<T extends util.HasLength = util.HasLength> extends $ZodCheck<T> {
|
||||
_zod: $ZodCheckMaxLengthInternals<T>;
|
||||
}
|
||||
export declare const $ZodCheckMaxLength: core.$constructor<$ZodCheckMaxLength>;
|
||||
export interface $ZodCheckMinLengthDef extends $ZodCheckDef {
|
||||
check: "min_length";
|
||||
minimum: number;
|
||||
}
|
||||
export interface $ZodCheckMinLengthInternals<T extends util.HasLength = util.HasLength> extends $ZodCheckInternals<T> {
|
||||
def: $ZodCheckMinLengthDef;
|
||||
issc: errors.$ZodIssueTooSmall<T>;
|
||||
}
|
||||
export interface $ZodCheckMinLength<T extends util.HasLength = util.HasLength> extends $ZodCheck<T> {
|
||||
_zod: $ZodCheckMinLengthInternals<T>;
|
||||
}
|
||||
export declare const $ZodCheckMinLength: core.$constructor<$ZodCheckMinLength>;
|
||||
export interface $ZodCheckLengthEqualsDef extends $ZodCheckDef {
|
||||
check: "length_equals";
|
||||
length: number;
|
||||
}
|
||||
export interface $ZodCheckLengthEqualsInternals<T extends util.HasLength = util.HasLength> extends $ZodCheckInternals<T> {
|
||||
def: $ZodCheckLengthEqualsDef;
|
||||
issc: errors.$ZodIssueTooBig<T> | errors.$ZodIssueTooSmall<T>;
|
||||
}
|
||||
export interface $ZodCheckLengthEquals<T extends util.HasLength = util.HasLength> extends $ZodCheck<T> {
|
||||
_zod: $ZodCheckLengthEqualsInternals<T>;
|
||||
}
|
||||
export declare const $ZodCheckLengthEquals: core.$constructor<$ZodCheckLengthEquals>;
|
||||
export type $ZodStringFormats = "email" | "url" | "emoji" | "uuid" | "guid" | "nanoid" | "cuid" | "cuid2" | "ulid" | "xid" | "ksuid" | "datetime" | "date" | "time" | "duration" | "ipv4" | "ipv6" | "cidrv4" | "cidrv6" | "base64" | "base64url" | "json_string" | "e164" | "credit_card" | "iban" | "lowercase" | "uppercase" | "regex" | "jwt" | "starts_with" | "ends_with" | "includes";
|
||||
export interface $ZodCheckStringFormatDef<Format extends string = string> extends $ZodCheckDef {
|
||||
check: "string_format";
|
||||
format: Format;
|
||||
pattern?: RegExp | undefined;
|
||||
}
|
||||
export interface $ZodCheckStringFormatInternals extends $ZodCheckInternals<string> {
|
||||
def: $ZodCheckStringFormatDef;
|
||||
issc: errors.$ZodIssueInvalidStringFormat;
|
||||
}
|
||||
export interface $ZodCheckStringFormat extends $ZodCheck<string> {
|
||||
_zod: $ZodCheckStringFormatInternals;
|
||||
}
|
||||
export declare const $ZodCheckStringFormat: core.$constructor<$ZodCheckStringFormat>;
|
||||
export interface $ZodCheckRegexDef extends $ZodCheckStringFormatDef {
|
||||
format: "regex";
|
||||
pattern: RegExp;
|
||||
}
|
||||
export interface $ZodCheckRegexInternals extends $ZodCheckInternals<string> {
|
||||
def: $ZodCheckRegexDef;
|
||||
issc: errors.$ZodIssueInvalidStringFormat;
|
||||
}
|
||||
export interface $ZodCheckRegex extends $ZodCheck<string> {
|
||||
_zod: $ZodCheckRegexInternals;
|
||||
}
|
||||
export declare const $ZodCheckRegex: core.$constructor<$ZodCheckRegex>;
|
||||
export interface $ZodCheckLowerCaseDef extends $ZodCheckStringFormatDef<"lowercase"> {
|
||||
}
|
||||
export interface $ZodCheckLowerCaseInternals extends $ZodCheckInternals<string> {
|
||||
def: $ZodCheckLowerCaseDef;
|
||||
issc: errors.$ZodIssueInvalidStringFormat;
|
||||
}
|
||||
export interface $ZodCheckLowerCase extends $ZodCheck<string> {
|
||||
_zod: $ZodCheckLowerCaseInternals;
|
||||
}
|
||||
export declare const $ZodCheckLowerCase: core.$constructor<$ZodCheckLowerCase>;
|
||||
export interface $ZodCheckUpperCaseDef extends $ZodCheckStringFormatDef<"uppercase"> {
|
||||
}
|
||||
export interface $ZodCheckUpperCaseInternals extends $ZodCheckInternals<string> {
|
||||
def: $ZodCheckUpperCaseDef;
|
||||
issc: errors.$ZodIssueInvalidStringFormat;
|
||||
}
|
||||
export interface $ZodCheckUpperCase extends $ZodCheck<string> {
|
||||
_zod: $ZodCheckUpperCaseInternals;
|
||||
}
|
||||
export declare const $ZodCheckUpperCase: core.$constructor<$ZodCheckUpperCase>;
|
||||
export interface $ZodCheckIncludesDef extends $ZodCheckStringFormatDef<"includes"> {
|
||||
includes: string;
|
||||
position?: number | undefined;
|
||||
}
|
||||
export interface $ZodCheckIncludesInternals extends $ZodCheckInternals<string> {
|
||||
def: $ZodCheckIncludesDef;
|
||||
issc: errors.$ZodIssueInvalidStringFormat;
|
||||
}
|
||||
export interface $ZodCheckIncludes extends $ZodCheck<string> {
|
||||
_zod: $ZodCheckIncludesInternals;
|
||||
}
|
||||
export declare const $ZodCheckIncludes: core.$constructor<$ZodCheckIncludes>;
|
||||
export interface $ZodCheckStartsWithDef extends $ZodCheckStringFormatDef<"starts_with"> {
|
||||
prefix: string;
|
||||
}
|
||||
export interface $ZodCheckStartsWithInternals extends $ZodCheckInternals<string> {
|
||||
def: $ZodCheckStartsWithDef;
|
||||
issc: errors.$ZodIssueInvalidStringFormat;
|
||||
}
|
||||
export interface $ZodCheckStartsWith extends $ZodCheck<string> {
|
||||
_zod: $ZodCheckStartsWithInternals;
|
||||
}
|
||||
export declare const $ZodCheckStartsWith: core.$constructor<$ZodCheckStartsWith>;
|
||||
export interface $ZodCheckEndsWithDef extends $ZodCheckStringFormatDef<"ends_with"> {
|
||||
suffix: string;
|
||||
}
|
||||
export interface $ZodCheckEndsWithInternals extends $ZodCheckInternals<string> {
|
||||
def: $ZodCheckEndsWithDef;
|
||||
issc: errors.$ZodIssueInvalidStringFormat;
|
||||
}
|
||||
export interface $ZodCheckEndsWith extends $ZodCheckInternals<string> {
|
||||
_zod: $ZodCheckEndsWithInternals;
|
||||
}
|
||||
export declare const $ZodCheckEndsWith: core.$constructor<$ZodCheckEndsWith>;
|
||||
export interface $ZodCheckPropertyDef extends $ZodCheckDef {
|
||||
check: "property";
|
||||
property: string;
|
||||
schema: schemas.$ZodType;
|
||||
}
|
||||
export interface $ZodCheckPropertyInternals<T extends object = object> extends $ZodCheckInternals<T> {
|
||||
def: $ZodCheckPropertyDef;
|
||||
issc: errors.$ZodIssue;
|
||||
}
|
||||
export interface $ZodCheckProperty<T extends object = object> extends $ZodCheck<T> {
|
||||
_zod: $ZodCheckPropertyInternals<T>;
|
||||
}
|
||||
export declare const $ZodCheckProperty: core.$constructor<$ZodCheckProperty>;
|
||||
export interface $ZodCheckPropertiesDef<Shape extends schemas.$ZodShape = schemas.$ZodShape> extends $ZodCheckDef {
|
||||
check: "properties";
|
||||
shape: Shape;
|
||||
}
|
||||
export type $ZodCheckPropertiesInput<Shape extends schemas.$ZodShape = schemas.$ZodShape> = {
|
||||
-readonly [k in keyof Shape]: util.Widen<core.input<Shape[k]>>;
|
||||
};
|
||||
export interface $ZodCheckPropertiesInternals<Shape extends schemas.$ZodShape = schemas.$ZodShape> extends $ZodCheckInternals<$ZodCheckPropertiesInput<Shape>> {
|
||||
def: $ZodCheckPropertiesDef<Shape>;
|
||||
issc: errors.$ZodIssue;
|
||||
}
|
||||
export interface $ZodCheckProperties<Shape extends schemas.$ZodShape = schemas.$ZodShape> extends $ZodCheck<$ZodCheckPropertiesInput<Shape>> {
|
||||
_zod: $ZodCheckPropertiesInternals<Shape>;
|
||||
[Symbol.iterator](): Iterator<this>;
|
||||
}
|
||||
export declare const $ZodCheckProperties: core.$constructor<$ZodCheckProperties>;
|
||||
export interface $ZodCheckMimeTypeDef extends $ZodCheckDef {
|
||||
check: "mime_type";
|
||||
mime: util.MimeTypes[];
|
||||
}
|
||||
export interface $ZodCheckMimeTypeInternals<T extends schemas.File = schemas.File> extends $ZodCheckInternals<T> {
|
||||
def: $ZodCheckMimeTypeDef;
|
||||
issc: errors.$ZodIssueInvalidValue;
|
||||
}
|
||||
export interface $ZodCheckMimeType<T extends schemas.File = schemas.File> extends $ZodCheck<T> {
|
||||
_zod: $ZodCheckMimeTypeInternals<T>;
|
||||
}
|
||||
export declare const $ZodCheckMimeType: core.$constructor<$ZodCheckMimeType>;
|
||||
export interface $ZodCheckOverwriteDef<T = unknown> extends $ZodCheckDef {
|
||||
check: "overwrite";
|
||||
tx(value: T): T;
|
||||
}
|
||||
export interface $ZodCheckOverwriteInternals<T = unknown> extends $ZodCheckInternals<T> {
|
||||
def: $ZodCheckOverwriteDef<T>;
|
||||
issc: never;
|
||||
}
|
||||
export interface $ZodCheckOverwrite<T = unknown> extends $ZodCheck<T> {
|
||||
_zod: $ZodCheckOverwriteInternals<T>;
|
||||
}
|
||||
export declare const $ZodCheckOverwrite: core.$constructor<$ZodCheckOverwrite>;
|
||||
export type $ZodChecks = $ZodCheckLessThan | $ZodCheckGreaterThan | $ZodCheckMultipleOf | $ZodCheckNumberFormat | $ZodCheckBigIntFormat | $ZodCheckMaxSize | $ZodCheckMinSize | $ZodCheckSizeEquals | $ZodCheckMaxLength | $ZodCheckMinLength | $ZodCheckLengthEquals | $ZodCheckStringFormat | $ZodCheckProperty | $ZodCheckMimeType | $ZodCheckOverwrite;
|
||||
export type $ZodStringFormatChecks = $ZodCheckRegex | $ZodCheckLowerCase | $ZodCheckUpperCase | $ZodCheckIncludes | $ZodCheckStartsWith | $ZodCheckEndsWith | schemas.$ZodStringFormatTypes;
|
||||
+516
@@ -0,0 +1,516 @@
|
||||
// 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);
|
||||
};
|
||||
});
|
||||
+1916
File diff suppressed because it is too large
Load Diff
+65
@@ -0,0 +1,65 @@
|
||||
import type * as core from "./core.cjs";
|
||||
import type { SomeType } from "./schemas.cjs";
|
||||
/** @internal Sentinel the compiled fast path returns when validation fails. */
|
||||
export declare const INVALID: unique symbol;
|
||||
/** @internal */
|
||||
export type INVALID = typeof INVALID;
|
||||
interface CompileFnOptions {
|
||||
debug?: boolean | undefined;
|
||||
/** Emit a validator instead of a parser: skip building the output value where nothing reads it. */
|
||||
assertOnly?: boolean | undefined;
|
||||
}
|
||||
type CompiledFn<T> = ((input: unknown) => T | INVALID) & {
|
||||
code?: string | undefined;
|
||||
/** False when this function's INVALID does not strictly mean "the runtime would reject". */
|
||||
definite?: boolean | undefined;
|
||||
};
|
||||
/** Raised when the schema contains async refinements or transforms. Surfaces only under `compile(schema, { strict: true })`. */
|
||||
export declare class ZodCompileAsyncError extends Error {
|
||||
constructor(message?: string);
|
||||
}
|
||||
/**
|
||||
* Raised when the schema contains a feature whose semantics the fast path
|
||||
* can't fully model. Both the shim in `zod/compile` and the default
|
||||
* `compile()` fall back to the runtime parser for that schema; only
|
||||
* `compile(schema, { strict: true })` lets it surface.
|
||||
*/
|
||||
export declare class ZodCompileUnsupportedError extends Error {
|
||||
/** Whether a container may absorb this refusal by running the child through the runtime (see `compileChild`). False when running only that node on the runtime is not equivalent to running the whole parse there — a runtime island gets no parse context, so a node that *consumes* issues rather than propagating them would finalize them against the wrong error map and still succeed. */
|
||||
readonly islandable: boolean;
|
||||
constructor(feature: string, islandable?: boolean);
|
||||
}
|
||||
export interface CompileOptions {
|
||||
/** Throw the refusal instead of returning the schema uncompiled. */
|
||||
strict?: boolean | undefined;
|
||||
}
|
||||
/**
|
||||
* AOT-compile a Zod schema. Returns a clone whose `_zod.run` calls a generated
|
||||
* fast path first and falls back to the original runtime parser on failure.
|
||||
*
|
||||
* - Forward direction only. Backward (encode), async, and `skipChecks` paths
|
||||
* bypass the fast path and use the runtime directly.
|
||||
* - Never throws. A schema the fast path can't model is returned unchanged and
|
||||
* keeps using the runtime parser. Pass `{ strict: true }` to get the refusal
|
||||
* as a thrown `ZodCompileUnsupportedError` / `ZodCompileAsyncError` instead.
|
||||
* - The original schema is unchanged. The clone shares children by reference.
|
||||
*/
|
||||
export declare function compile<T extends SomeType>(schema: T, options?: CompileOptions): T;
|
||||
/**
|
||||
* Install an already-generated parser as a schema's fast path. Returns a clone; the original is
|
||||
* unchanged.
|
||||
*
|
||||
* The parser takes the input and returns the parsed value, or `INVALID` to hand the parse to the
|
||||
* runtime. It must be synchronous and forward-direction, and it must build fresh output rather than
|
||||
* return its input — Zod cannot check either, and a wrong *success* is returned to the caller as-is.
|
||||
*
|
||||
* `compile()` is the ordinary entry point. This is for a build-time or native compiler that produces
|
||||
* a parser where `new Function` is unavailable.
|
||||
*/
|
||||
export declare function withParser<T extends SomeType>(schema: T, parser: (input: unknown) => core.output<T> | INVALID): T;
|
||||
/**
|
||||
* @internal Generate the standalone compiled function: a parser by default, a validator under
|
||||
* `assertOnly`. Returns the parsed value, `true` where nothing reads the output, or `INVALID`. Consumers use `compile()`.
|
||||
*/
|
||||
export declare function compileFn<T extends SomeType>(schema: T, options?: CompileFnOptions): CompiledFn<core.output<T>>;
|
||||
export {};
|
||||
+65
@@ -0,0 +1,65 @@
|
||||
import type * as core from "./core.js";
|
||||
import type { SomeType } from "./schemas.js";
|
||||
/** @internal Sentinel the compiled fast path returns when validation fails. */
|
||||
export declare const INVALID: unique symbol;
|
||||
/** @internal */
|
||||
export type INVALID = typeof INVALID;
|
||||
interface CompileFnOptions {
|
||||
debug?: boolean | undefined;
|
||||
/** Emit a validator instead of a parser: skip building the output value where nothing reads it. */
|
||||
assertOnly?: boolean | undefined;
|
||||
}
|
||||
type CompiledFn<T> = ((input: unknown) => T | INVALID) & {
|
||||
code?: string | undefined;
|
||||
/** False when this function's INVALID does not strictly mean "the runtime would reject". */
|
||||
definite?: boolean | undefined;
|
||||
};
|
||||
/** Raised when the schema contains async refinements or transforms. Surfaces only under `compile(schema, { strict: true })`. */
|
||||
export declare class ZodCompileAsyncError extends Error {
|
||||
constructor(message?: string);
|
||||
}
|
||||
/**
|
||||
* Raised when the schema contains a feature whose semantics the fast path
|
||||
* can't fully model. Both the shim in `zod/compile` and the default
|
||||
* `compile()` fall back to the runtime parser for that schema; only
|
||||
* `compile(schema, { strict: true })` lets it surface.
|
||||
*/
|
||||
export declare class ZodCompileUnsupportedError extends Error {
|
||||
/** Whether a container may absorb this refusal by running the child through the runtime (see `compileChild`). False when running only that node on the runtime is not equivalent to running the whole parse there — a runtime island gets no parse context, so a node that *consumes* issues rather than propagating them would finalize them against the wrong error map and still succeed. */
|
||||
readonly islandable: boolean;
|
||||
constructor(feature: string, islandable?: boolean);
|
||||
}
|
||||
export interface CompileOptions {
|
||||
/** Throw the refusal instead of returning the schema uncompiled. */
|
||||
strict?: boolean | undefined;
|
||||
}
|
||||
/**
|
||||
* AOT-compile a Zod schema. Returns a clone whose `_zod.run` calls a generated
|
||||
* fast path first and falls back to the original runtime parser on failure.
|
||||
*
|
||||
* - Forward direction only. Backward (encode), async, and `skipChecks` paths
|
||||
* bypass the fast path and use the runtime directly.
|
||||
* - Never throws. A schema the fast path can't model is returned unchanged and
|
||||
* keeps using the runtime parser. Pass `{ strict: true }` to get the refusal
|
||||
* as a thrown `ZodCompileUnsupportedError` / `ZodCompileAsyncError` instead.
|
||||
* - The original schema is unchanged. The clone shares children by reference.
|
||||
*/
|
||||
export declare function compile<T extends SomeType>(schema: T, options?: CompileOptions): T;
|
||||
/**
|
||||
* Install an already-generated parser as a schema's fast path. Returns a clone; the original is
|
||||
* unchanged.
|
||||
*
|
||||
* The parser takes the input and returns the parsed value, or `INVALID` to hand the parse to the
|
||||
* runtime. It must be synchronous and forward-direction, and it must build fresh output rather than
|
||||
* return its input — Zod cannot check either, and a wrong *success* is returned to the caller as-is.
|
||||
*
|
||||
* `compile()` is the ordinary entry point. This is for a build-time or native compiler that produces
|
||||
* a parser where `new Function` is unavailable.
|
||||
*/
|
||||
export declare function withParser<T extends SomeType>(schema: T, parser: (input: unknown) => core.output<T> | INVALID): T;
|
||||
/**
|
||||
* @internal Generate the standalone compiled function: a parser by default, a validator under
|
||||
* `assertOnly`. Returns the parsed value, `true` where nothing reads the output, or `INVALID`. Consumers use `compile()`.
|
||||
*/
|
||||
export declare function compileFn<T extends SomeType>(schema: T, options?: CompileFnOptions): CompiledFn<core.output<T>>;
|
||||
export {};
|
||||
+1866
File diff suppressed because it is too large
Load Diff
+167
@@ -0,0 +1,167 @@
|
||||
"use strict";
|
||||
var _a;
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.globalConfig = exports.$ZodEncodeError = exports.$ZodAsyncError = exports.$brand = exports.NEVER = void 0;
|
||||
exports.$constructor = $constructor;
|
||||
exports.config = config;
|
||||
const util_js_1 = require("./util.cjs");
|
||||
/** A special constant with type `never` */
|
||||
exports.NEVER = Object.freeze({
|
||||
status: "aborted",
|
||||
});
|
||||
/* Shared descriptor for installing `_zod`; defineProperty reads it
|
||||
* synchronously, so reusing one object avoids a per-instance allocation. */
|
||||
const _zodDesc = { value: undefined, enumerable: false };
|
||||
// null where suppressing the capture would be unrecoverable: `parse()` puts the frames back with `captureStackTrace`, so without it the throw would lose its stack. also latched to null once `stackTraceLimit` proves unassignable, which a realm can do at any point by hardening Error
|
||||
let _E = "captureStackTrace" in Error ? Error : null;
|
||||
// v8 captures a stack trace inside the Error constructor, which dominates a failed parse; costs only the frames, and parse() restores those. the constructor must RUN: Object.create is cheaper and passes instanceof, but Error.isError and util.types.isNativeError check an internal slot
|
||||
function newError(Definition) {
|
||||
const E = _E;
|
||||
if (E) {
|
||||
const saved = E.stackTraceLimit;
|
||||
if (typeof saved === "number") {
|
||||
try {
|
||||
E.stackTraceLimit = 0;
|
||||
}
|
||||
catch {
|
||||
_E = null;
|
||||
return new Definition();
|
||||
}
|
||||
try {
|
||||
return new Definition();
|
||||
}
|
||||
finally {
|
||||
E.stackTraceLimit = saved;
|
||||
}
|
||||
}
|
||||
}
|
||||
return new Definition();
|
||||
}
|
||||
function $constructor(name, initializer,
|
||||
/** This trait's members, installed once on every prototype that composes it. They cannot be declared in the initializer above: that runs per instance, and the prototype is shared. */
|
||||
proto, params) {
|
||||
// Prototype for this constructor's `_zod` internals. Lazily-derived fields (`values`, `pattern`, `optin`, …) install here once rather than as an accessor on every instance.
|
||||
const zodProto = {};
|
||||
// Assigning the fields in the constructor body is what gives instances in-object slots; building the object literally and reparenting it costs a second allocation and a generic property copy.
|
||||
function Internals(def) {
|
||||
this.def = def;
|
||||
this.constr = _;
|
||||
this.traits = new Set();
|
||||
}
|
||||
Internals.prototype = zodProto;
|
||||
const protoMembers = proto;
|
||||
// One trait's members land on every prototype whose chain composes it, so the answer is per prototype rather than per trait.
|
||||
const initialized = protoMembers && new WeakSet();
|
||||
function init(inst, def) {
|
||||
if (!inst._zod) {
|
||||
_zodDesc.value = new Internals(def);
|
||||
try {
|
||||
Object.defineProperty(inst, "_zod", _zodDesc);
|
||||
}
|
||||
finally {
|
||||
// Cleared even on throw, so the shared descriptor never leaks one instance's internals into the next.
|
||||
_zodDesc.value = undefined;
|
||||
}
|
||||
}
|
||||
else if (inst._zod.traits.has(name)) {
|
||||
return;
|
||||
}
|
||||
inst._zod.traits.add(name);
|
||||
initializer(inst, def);
|
||||
if (initialized) {
|
||||
// `super(def)` from a user subclass gives `this` a prototype the subclass owns, and installing there would overwrite whatever the subclass declared. `constr` built the instance, so its prototype is the one below the subclass's that should carry the members. A receiver whose chain never reaches that prototype installs on its own, which for a plain object handed straight to `init` means `Object.prototype` — unchanged from before.
|
||||
const own = Object.getPrototypeOf(inst);
|
||||
const ctorProto = inst._zod.constr.prototype;
|
||||
let up = own;
|
||||
while (up && up !== ctorProto)
|
||||
up = Object.getPrototypeOf(up);
|
||||
const target = up ?? own;
|
||||
if (!initialized.has(target)) {
|
||||
initialized.add(target);
|
||||
(0, util_js_1.members)(target, protoMembers);
|
||||
}
|
||||
}
|
||||
// support prototype modifications; for-in avoids the array allocation of Object.keys on the (usually empty) prototype
|
||||
const proto = _.prototype;
|
||||
for (const k in proto) {
|
||||
if (!Object.prototype.hasOwnProperty.call(proto, k))
|
||||
continue;
|
||||
if (!(k in inst)) {
|
||||
inst[k] = proto[k].bind(inst);
|
||||
}
|
||||
}
|
||||
}
|
||||
// doesn't work if Parent has a constructor with arguments
|
||||
const Parent = params?.Parent ?? Object;
|
||||
class Definition extends Parent {
|
||||
}
|
||||
Object.defineProperty(Definition, "name", { value: name });
|
||||
function _(def) {
|
||||
const inst = params?.Parent ? newError(Definition) : this;
|
||||
init(inst, def);
|
||||
const deferred = inst._zod.deferred;
|
||||
if (deferred) {
|
||||
for (const fn of deferred) {
|
||||
fn();
|
||||
}
|
||||
// Released: initializers run once, and the list would otherwise be retained for the schema's lifetime.
|
||||
inst._zod.deferred = undefined;
|
||||
}
|
||||
// Global post-processor hook. Internal: installed by `import "zod/compile"` to enable AOT compilation for every constructed schema. Runs last, once the instance is fully built, because it hands the instance to compile(). The post-processor is expected to be reentrancy-guarded by its own implementation.
|
||||
const pp = globalThis.__zod_globalConfig?.postProcessor;
|
||||
if (pp)
|
||||
pp(inst);
|
||||
return inst;
|
||||
}
|
||||
Object.defineProperty(_, "init", { value: init });
|
||||
Object.defineProperty(_, Symbol.hasInstance, {
|
||||
value: (inst) => {
|
||||
if (params?.Parent && inst instanceof params.Parent)
|
||||
return true;
|
||||
return inst?._zod?.traits?.has(name);
|
||||
},
|
||||
});
|
||||
Object.defineProperty(_, "name", { value: name });
|
||||
return _;
|
||||
}
|
||||
////////////////////////////// UTILITIES ///////////////////////////////////////
|
||||
exports.$brand = Symbol("zod_brand");
|
||||
class $ZodAsyncError extends Error {
|
||||
constructor() {
|
||||
super(`Encountered Promise during synchronous parse. Use .parseAsync() instead.`);
|
||||
}
|
||||
}
|
||||
exports.$ZodAsyncError = $ZodAsyncError;
|
||||
class $ZodEncodeError extends Error {
|
||||
constructor(name) {
|
||||
super(`Encountered unidirectional transform during encode: ${name}`);
|
||||
this.name = "ZodEncodeError";
|
||||
}
|
||||
}
|
||||
exports.$ZodEncodeError = $ZodEncodeError;
|
||||
(_a = globalThis).__zod_globalConfig ?? (_a.__zod_globalConfig = {});
|
||||
exports.globalConfig = globalThis.__zod_globalConfig;
|
||||
function config(newConfig) {
|
||||
if (newConfig)
|
||||
Object.assign(exports.globalConfig, newConfig);
|
||||
return exports.globalConfig;
|
||||
}
|
||||
|
||||
// seal-cjs-exports
|
||||
(function () {
|
||||
var keys = Object.getOwnPropertyNames(exports);
|
||||
for (var i = 0; i < keys.length; i++) {
|
||||
var desc = Object.getOwnPropertyDescriptor(exports, keys[i]);
|
||||
if (!desc || !desc.get || !desc.configurable) continue;
|
||||
var value;
|
||||
try {
|
||||
value = desc.get();
|
||||
} catch (e) {
|
||||
continue;
|
||||
}
|
||||
// a circular require may not have settled this one yet, so leave it live
|
||||
if (value === undefined) continue;
|
||||
Object.defineProperty(exports, keys[i], { value: value, writable: false, enumerable: desc.enumerable, configurable: false });
|
||||
}
|
||||
Object.freeze(exports);
|
||||
})();
|
||||
+82
@@ -0,0 +1,82 @@
|
||||
import type * as errors from "./errors.cjs";
|
||||
import type * as schemas from "./schemas.cjs";
|
||||
import type { Class, ProtoOf } from "./util.cjs";
|
||||
type ZodTrait = {
|
||||
_zod: {
|
||||
def: any;
|
||||
[k: string]: any;
|
||||
};
|
||||
};
|
||||
export interface $constructor<T extends ZodTrait, D = T["_zod"]["def"]> {
|
||||
new (def: D): T;
|
||||
init(inst: T, def: D): asserts inst is T;
|
||||
}
|
||||
export interface $constructorParams {
|
||||
Parent?: typeof Class;
|
||||
}
|
||||
/** A special constant with type `never` */
|
||||
export declare const NEVER: never;
|
||||
export declare function $constructor<T extends ZodTrait, D = T["_zod"]["def"]>(name: string, initializer: (inst: T, def: D) => void,
|
||||
/** This trait's members, installed once on every prototype that composes it. They cannot be declared in the initializer above: that runs per instance, and the prototype is shared. */
|
||||
proto?: ProtoOf<T>, params?: $constructorParams): $constructor<T, D>;
|
||||
export declare const $brand: unique symbol;
|
||||
export type $brand<T extends string | number | symbol = string | number | symbol> = {
|
||||
[$brand]: {
|
||||
[k in T]: true;
|
||||
};
|
||||
};
|
||||
export type $ZodBranded<T extends schemas.SomeType, Brand extends string | number | symbol, Dir extends "in" | "out" | "inout" = "out"> = T & (Dir extends "inout" ? {
|
||||
_zod: {
|
||||
input: input<T> & $brand<Brand>;
|
||||
output: output<T> & $brand<Brand>;
|
||||
};
|
||||
} : Dir extends "in" ? {
|
||||
_zod: {
|
||||
input: input<T> & $brand<Brand>;
|
||||
};
|
||||
} : {
|
||||
_zod: {
|
||||
output: output<T> & $brand<Brand>;
|
||||
};
|
||||
});
|
||||
export type $ZodNarrow<T extends schemas.SomeType, Out> = T & {
|
||||
_zod: {
|
||||
output: Out;
|
||||
};
|
||||
};
|
||||
export declare class $ZodAsyncError extends Error {
|
||||
constructor();
|
||||
}
|
||||
export declare class $ZodEncodeError extends Error {
|
||||
constructor(name: string);
|
||||
}
|
||||
export type input<T> = T extends {
|
||||
_zod: {
|
||||
input: any;
|
||||
};
|
||||
} ? T["_zod"]["input"] : unknown;
|
||||
export type output<T> = T extends {
|
||||
_zod: {
|
||||
output: any;
|
||||
};
|
||||
} ? T["_zod"]["output"] : unknown;
|
||||
export type { output as infer };
|
||||
export interface $ZodConfig {
|
||||
/** Custom error map. Overrides `config().localeError`. */
|
||||
customError?: errors.$ZodErrorMap | undefined;
|
||||
/** Localized error map. Lowest priority. */
|
||||
localeError?: errors.$ZodErrorMap | undefined;
|
||||
/** Disable JIT schema compilation. Useful in environments that disallow `eval`. */
|
||||
jitless?: boolean | undefined;
|
||||
/** Enables parsing input that contains reference cycles. Read when a schema is constructed. */
|
||||
memoizer?: schemas.$ZodMemoizer | undefined;
|
||||
/**
|
||||
* Internal: post-processor invoked on every freshly-constructed schema
|
||||
* instance, after init and deferred fns run. Set by `import "zod/compile"`
|
||||
* to install AOT compilation. Not part of the public API.
|
||||
* @internal
|
||||
*/
|
||||
postProcessor?: ((inst: any) => void) | undefined;
|
||||
}
|
||||
export declare const globalConfig: $ZodConfig;
|
||||
export declare function config(newConfig?: Partial<$ZodConfig>): $ZodConfig;
|
||||
+82
@@ -0,0 +1,82 @@
|
||||
import type * as errors from "./errors.js";
|
||||
import type * as schemas from "./schemas.js";
|
||||
import type { Class, ProtoOf } from "./util.js";
|
||||
type ZodTrait = {
|
||||
_zod: {
|
||||
def: any;
|
||||
[k: string]: any;
|
||||
};
|
||||
};
|
||||
export interface $constructor<T extends ZodTrait, D = T["_zod"]["def"]> {
|
||||
new (def: D): T;
|
||||
init(inst: T, def: D): asserts inst is T;
|
||||
}
|
||||
export interface $constructorParams {
|
||||
Parent?: typeof Class;
|
||||
}
|
||||
/** A special constant with type `never` */
|
||||
export declare const NEVER: never;
|
||||
export declare function $constructor<T extends ZodTrait, D = T["_zod"]["def"]>(name: string, initializer: (inst: T, def: D) => void,
|
||||
/** This trait's members, installed once on every prototype that composes it. They cannot be declared in the initializer above: that runs per instance, and the prototype is shared. */
|
||||
proto?: ProtoOf<T>, params?: $constructorParams): $constructor<T, D>;
|
||||
export declare const $brand: unique symbol;
|
||||
export type $brand<T extends string | number | symbol = string | number | symbol> = {
|
||||
[$brand]: {
|
||||
[k in T]: true;
|
||||
};
|
||||
};
|
||||
export type $ZodBranded<T extends schemas.SomeType, Brand extends string | number | symbol, Dir extends "in" | "out" | "inout" = "out"> = T & (Dir extends "inout" ? {
|
||||
_zod: {
|
||||
input: input<T> & $brand<Brand>;
|
||||
output: output<T> & $brand<Brand>;
|
||||
};
|
||||
} : Dir extends "in" ? {
|
||||
_zod: {
|
||||
input: input<T> & $brand<Brand>;
|
||||
};
|
||||
} : {
|
||||
_zod: {
|
||||
output: output<T> & $brand<Brand>;
|
||||
};
|
||||
});
|
||||
export type $ZodNarrow<T extends schemas.SomeType, Out> = T & {
|
||||
_zod: {
|
||||
output: Out;
|
||||
};
|
||||
};
|
||||
export declare class $ZodAsyncError extends Error {
|
||||
constructor();
|
||||
}
|
||||
export declare class $ZodEncodeError extends Error {
|
||||
constructor(name: string);
|
||||
}
|
||||
export type input<T> = T extends {
|
||||
_zod: {
|
||||
input: any;
|
||||
};
|
||||
} ? T["_zod"]["input"] : unknown;
|
||||
export type output<T> = T extends {
|
||||
_zod: {
|
||||
output: any;
|
||||
};
|
||||
} ? T["_zod"]["output"] : unknown;
|
||||
export type { output as infer };
|
||||
export interface $ZodConfig {
|
||||
/** Custom error map. Overrides `config().localeError`. */
|
||||
customError?: errors.$ZodErrorMap | undefined;
|
||||
/** Localized error map. Lowest priority. */
|
||||
localeError?: errors.$ZodErrorMap | undefined;
|
||||
/** Disable JIT schema compilation. Useful in environments that disallow `eval`. */
|
||||
jitless?: boolean | undefined;
|
||||
/** Enables parsing input that contains reference cycles. Read when a schema is constructed. */
|
||||
memoizer?: schemas.$ZodMemoizer | undefined;
|
||||
/**
|
||||
* Internal: post-processor invoked on every freshly-constructed schema
|
||||
* instance, after init and deferred fns run. Set by `import "zod/compile"`
|
||||
* to install AOT compilation. Not part of the public API.
|
||||
* @internal
|
||||
*/
|
||||
postProcessor?: ((inst: any) => void) | undefined;
|
||||
}
|
||||
export declare const globalConfig: $ZodConfig;
|
||||
export declare function config(newConfig?: Partial<$ZodConfig>): $ZodConfig;
|
||||
+141
@@ -0,0 +1,141 @@
|
||||
var _a;
|
||||
import { members as installMembers } from "./util.js";
|
||||
/** A special constant with type `never` */
|
||||
export const NEVER = /*@__PURE__*/ Object.freeze({
|
||||
status: "aborted",
|
||||
});
|
||||
/* Shared descriptor for installing `_zod`; defineProperty reads it
|
||||
* synchronously, so reusing one object avoids a per-instance allocation. */
|
||||
const _zodDesc = { value: undefined, enumerable: false };
|
||||
// null where suppressing the capture would be unrecoverable: `parse()` puts the frames back with `captureStackTrace`, so without it the throw would lose its stack. also latched to null once `stackTraceLimit` proves unassignable, which a realm can do at any point by hardening Error
|
||||
let _E = "captureStackTrace" in Error ? Error : null;
|
||||
// v8 captures a stack trace inside the Error constructor, which dominates a failed parse; costs only the frames, and parse() restores those. the constructor must RUN: Object.create is cheaper and passes instanceof, but Error.isError and util.types.isNativeError check an internal slot
|
||||
function newError(Definition) {
|
||||
const E = _E;
|
||||
if (E) {
|
||||
const saved = E.stackTraceLimit;
|
||||
if (typeof saved === "number") {
|
||||
try {
|
||||
E.stackTraceLimit = 0;
|
||||
}
|
||||
catch {
|
||||
_E = null;
|
||||
return new Definition();
|
||||
}
|
||||
try {
|
||||
return new Definition();
|
||||
}
|
||||
finally {
|
||||
E.stackTraceLimit = saved;
|
||||
}
|
||||
}
|
||||
}
|
||||
return new Definition();
|
||||
}
|
||||
export /*@__NO_SIDE_EFFECTS__*/ function $constructor(name, initializer,
|
||||
/** This trait's members, installed once on every prototype that composes it. They cannot be declared in the initializer above: that runs per instance, and the prototype is shared. */
|
||||
proto, params) {
|
||||
// Prototype for this constructor's `_zod` internals. Lazily-derived fields (`values`, `pattern`, `optin`, …) install here once rather than as an accessor on every instance.
|
||||
const zodProto = {};
|
||||
// Assigning the fields in the constructor body is what gives instances in-object slots; building the object literally and reparenting it costs a second allocation and a generic property copy.
|
||||
function Internals(def) {
|
||||
this.def = def;
|
||||
this.constr = _;
|
||||
this.traits = new Set();
|
||||
}
|
||||
Internals.prototype = zodProto;
|
||||
const protoMembers = proto;
|
||||
// One trait's members land on every prototype whose chain composes it, so the answer is per prototype rather than per trait.
|
||||
const initialized = protoMembers && new WeakSet();
|
||||
function init(inst, def) {
|
||||
if (!inst._zod) {
|
||||
_zodDesc.value = new Internals(def);
|
||||
try {
|
||||
Object.defineProperty(inst, "_zod", _zodDesc);
|
||||
}
|
||||
finally {
|
||||
// Cleared even on throw, so the shared descriptor never leaks one instance's internals into the next.
|
||||
_zodDesc.value = undefined;
|
||||
}
|
||||
}
|
||||
else if (inst._zod.traits.has(name)) {
|
||||
return;
|
||||
}
|
||||
inst._zod.traits.add(name);
|
||||
initializer(inst, def);
|
||||
if (initialized) {
|
||||
// `super(def)` from a user subclass gives `this` a prototype the subclass owns, and installing there would overwrite whatever the subclass declared. `constr` built the instance, so its prototype is the one below the subclass's that should carry the members. A receiver whose chain never reaches that prototype installs on its own, which for a plain object handed straight to `init` means `Object.prototype` — unchanged from before.
|
||||
const own = Object.getPrototypeOf(inst);
|
||||
const ctorProto = inst._zod.constr.prototype;
|
||||
let up = own;
|
||||
while (up && up !== ctorProto)
|
||||
up = Object.getPrototypeOf(up);
|
||||
const target = up ?? own;
|
||||
if (!initialized.has(target)) {
|
||||
initialized.add(target);
|
||||
installMembers(target, protoMembers);
|
||||
}
|
||||
}
|
||||
// support prototype modifications; for-in avoids the array allocation of Object.keys on the (usually empty) prototype
|
||||
const proto = _.prototype;
|
||||
for (const k in proto) {
|
||||
if (!Object.prototype.hasOwnProperty.call(proto, k))
|
||||
continue;
|
||||
if (!(k in inst)) {
|
||||
inst[k] = proto[k].bind(inst);
|
||||
}
|
||||
}
|
||||
}
|
||||
// doesn't work if Parent has a constructor with arguments
|
||||
const Parent = params?.Parent ?? Object;
|
||||
class Definition extends Parent {
|
||||
}
|
||||
Object.defineProperty(Definition, "name", { value: name });
|
||||
function _(def) {
|
||||
const inst = params?.Parent ? newError(Definition) : this;
|
||||
init(inst, def);
|
||||
const deferred = inst._zod.deferred;
|
||||
if (deferred) {
|
||||
for (const fn of deferred) {
|
||||
fn();
|
||||
}
|
||||
// Released: initializers run once, and the list would otherwise be retained for the schema's lifetime.
|
||||
inst._zod.deferred = undefined;
|
||||
}
|
||||
// Global post-processor hook. Internal: installed by `import "zod/compile"` to enable AOT compilation for every constructed schema. Runs last, once the instance is fully built, because it hands the instance to compile(). The post-processor is expected to be reentrancy-guarded by its own implementation.
|
||||
const pp = globalThis.__zod_globalConfig?.postProcessor;
|
||||
if (pp)
|
||||
pp(inst);
|
||||
return inst;
|
||||
}
|
||||
Object.defineProperty(_, "init", { value: init });
|
||||
Object.defineProperty(_, Symbol.hasInstance, {
|
||||
value: (inst) => {
|
||||
if (params?.Parent && inst instanceof params.Parent)
|
||||
return true;
|
||||
return inst?._zod?.traits?.has(name);
|
||||
},
|
||||
});
|
||||
Object.defineProperty(_, "name", { value: name });
|
||||
return _;
|
||||
}
|
||||
////////////////////////////// UTILITIES ///////////////////////////////////////
|
||||
export const $brand = /*@__PURE__*/ Symbol("zod_brand");
|
||||
export class $ZodAsyncError extends Error {
|
||||
constructor() {
|
||||
super(`Encountered Promise during synchronous parse. Use .parseAsync() instead.`);
|
||||
}
|
||||
}
|
||||
export class $ZodEncodeError extends Error {
|
||||
constructor(name) {
|
||||
super(`Encountered unidirectional transform during encode: ${name}`);
|
||||
this.name = "ZodEncodeError";
|
||||
}
|
||||
}
|
||||
(_a = globalThis).__zod_globalConfig ?? (_a.__zod_globalConfig = {});
|
||||
export const globalConfig = globalThis.__zod_globalConfig;
|
||||
export function config(newConfig) {
|
||||
if (newConfig)
|
||||
Object.assign(globalConfig, newConfig);
|
||||
return globalConfig;
|
||||
}
|
||||
+61
@@ -0,0 +1,61 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.Doc = void 0;
|
||||
class Doc {
|
||||
constructor(args = [], closed = {}) {
|
||||
this.content = [];
|
||||
this.indent = 0;
|
||||
this.args = args;
|
||||
this.closed = closed;
|
||||
}
|
||||
// the compiler catches a child's throw and keeps writing into this doc, so the indent has to unwind with it
|
||||
indented(fn) {
|
||||
this.indent += 1;
|
||||
try {
|
||||
fn(this);
|
||||
}
|
||||
finally {
|
||||
this.indent -= 1;
|
||||
}
|
||||
}
|
||||
write(arg) {
|
||||
if (typeof arg === "function") {
|
||||
arg(this, { execution: "sync" });
|
||||
arg(this, { execution: "async" });
|
||||
return;
|
||||
}
|
||||
const content = arg;
|
||||
const lines = content.split("\n").filter((x) => x);
|
||||
const minIndent = Math.min(...lines.map((x) => x.length - x.trimStart().length));
|
||||
const dedented = lines.map((x) => x.slice(minIndent)).map((x) => " ".repeat(this.indent * 2) + x);
|
||||
for (const line of dedented) {
|
||||
this.content.push(line);
|
||||
}
|
||||
}
|
||||
compile() {
|
||||
const F = Function;
|
||||
const content = this?.content ?? [``];
|
||||
const factory = new F(...Object.keys(this.closed), `return function (${this.args.join(", ")}) {\n${content.join("\n")}\n};`);
|
||||
return factory(...Object.values(this.closed));
|
||||
}
|
||||
}
|
||||
exports.Doc = Doc;
|
||||
|
||||
// seal-cjs-exports
|
||||
(function () {
|
||||
var keys = Object.getOwnPropertyNames(exports);
|
||||
for (var i = 0; i < keys.length; i++) {
|
||||
var desc = Object.getOwnPropertyDescriptor(exports, keys[i]);
|
||||
if (!desc || !desc.get || !desc.configurable) continue;
|
||||
var value;
|
||||
try {
|
||||
value = desc.get();
|
||||
} catch (e) {
|
||||
continue;
|
||||
}
|
||||
// a circular require may not have settled this one yet, so leave it live
|
||||
if (value === undefined) continue;
|
||||
Object.defineProperty(exports, keys[i], { value: value, writable: false, enumerable: desc.enumerable, configurable: false });
|
||||
}
|
||||
Object.freeze(exports);
|
||||
})();
|
||||
+16
@@ -0,0 +1,16 @@
|
||||
type ModeWriter = (doc: Doc, modes: {
|
||||
execution: "sync" | "async";
|
||||
}) => void;
|
||||
export declare class Doc {
|
||||
args: string[];
|
||||
/** Bindings the compiled function closes over, by name. */
|
||||
closed: Record<string, unknown>;
|
||||
content: string[];
|
||||
indent: number;
|
||||
constructor(args?: string[], closed?: Record<string, unknown>);
|
||||
indented(fn: (doc: Doc) => void): void;
|
||||
write(fn: ModeWriter): void;
|
||||
write(line: string): void;
|
||||
compile(): any;
|
||||
}
|
||||
export {};
|
||||
+16
@@ -0,0 +1,16 @@
|
||||
type ModeWriter = (doc: Doc, modes: {
|
||||
execution: "sync" | "async";
|
||||
}) => void;
|
||||
export declare class Doc {
|
||||
args: string[];
|
||||
/** Bindings the compiled function closes over, by name. */
|
||||
closed: Record<string, unknown>;
|
||||
content: string[];
|
||||
indent: number;
|
||||
constructor(args?: string[], closed?: Record<string, unknown>);
|
||||
indented(fn: (doc: Doc) => void): void;
|
||||
write(fn: ModeWriter): void;
|
||||
write(line: string): void;
|
||||
compile(): any;
|
||||
}
|
||||
export {};
|
||||
+38
@@ -0,0 +1,38 @@
|
||||
export class Doc {
|
||||
constructor(args = [], closed = {}) {
|
||||
this.content = [];
|
||||
this.indent = 0;
|
||||
this.args = args;
|
||||
this.closed = closed;
|
||||
}
|
||||
// the compiler catches a child's throw and keeps writing into this doc, so the indent has to unwind with it
|
||||
indented(fn) {
|
||||
this.indent += 1;
|
||||
try {
|
||||
fn(this);
|
||||
}
|
||||
finally {
|
||||
this.indent -= 1;
|
||||
}
|
||||
}
|
||||
write(arg) {
|
||||
if (typeof arg === "function") {
|
||||
arg(this, { execution: "sync" });
|
||||
arg(this, { execution: "async" });
|
||||
return;
|
||||
}
|
||||
const content = arg;
|
||||
const lines = content.split("\n").filter((x) => x);
|
||||
const minIndent = Math.min(...lines.map((x) => x.length - x.trimStart().length));
|
||||
const dedented = lines.map((x) => x.slice(minIndent)).map((x) => " ".repeat(this.indent * 2) + x);
|
||||
for (const line of dedented) {
|
||||
this.content.push(line);
|
||||
}
|
||||
}
|
||||
compile() {
|
||||
const F = Function;
|
||||
const content = this?.content ?? [``];
|
||||
const factory = new F(...Object.keys(this.closed), `return function (${this.args.join(", ")}) {\n${content.join("\n")}\n};`);
|
||||
return factory(...Object.values(this.closed));
|
||||
}
|
||||
}
|
||||
+317
@@ -0,0 +1,317 @@
|
||||
"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.$ZodRealError = exports.$ZodError = void 0;
|
||||
exports.flattenError = flattenError;
|
||||
exports.formatError = formatError;
|
||||
exports.treeifyError = treeifyError;
|
||||
exports.toDotPath = toDotPath;
|
||||
exports.prettifyError = prettifyError;
|
||||
const core_js_1 = require("./core.cjs");
|
||||
const util = __importStar(require("./util.cjs"));
|
||||
/* Computing the message eagerly is expensive (pretty-printed JSON of all
|
||||
* issues), so defer it until first read. The accessor functions and
|
||||
* descriptors are shared across instances to keep error construction
|
||||
* cheap; the computed message is cached on the internals object. The
|
||||
* setter preserves plain assignment semantics for consumers that
|
||||
* overwrite `message`. */
|
||||
function _getMessage() {
|
||||
const internals = this._zod;
|
||||
internals.message ?? (internals.message = JSON.stringify(internals.def, util.jsonStringifyReplacer, 2));
|
||||
return internals.message;
|
||||
}
|
||||
function _setMessage(value) {
|
||||
this._zod.message = value;
|
||||
}
|
||||
const _messageDesc = {
|
||||
get: _getMessage,
|
||||
set: _setMessage,
|
||||
enumerable: true,
|
||||
configurable: true,
|
||||
};
|
||||
const _issuesDesc = { value: undefined, enumerable: false };
|
||||
/* Prototypes that already carry the lazy `toString`. Seeded with the
|
||||
* intrinsics so that `init` on a foreign object — it accepts any object —
|
||||
* can never install an accessor onto a prototype we do not own. */
|
||||
const _installedToString = /* @__PURE__ */ new WeakSet([Object.prototype, Error.prototype]);
|
||||
const initializer = (inst, def) => {
|
||||
inst.name = "$ZodError";
|
||||
// `_zod` is already non-enumerable: $constructor's init defined it with this same descriptor
|
||||
_issuesDesc.value = def;
|
||||
Object.defineProperty(inst, "issues", _issuesDesc);
|
||||
// Clear the shared slot; a retained `value` pins the last error's issues.
|
||||
_issuesDesc.value = undefined;
|
||||
Object.defineProperty(inst, "message", _messageDesc);
|
||||
/* `toString` lives as a non-enumerable lazy getter on the shared
|
||||
* prototype; on first access it caches a per-instance closure so
|
||||
* detached usage still works. */
|
||||
const proto = Object.getPrototypeOf(inst);
|
||||
if (!_installedToString.has(proto)) {
|
||||
_installedToString.add(proto);
|
||||
Object.defineProperty(proto, "toString", {
|
||||
configurable: true,
|
||||
enumerable: false,
|
||||
get() {
|
||||
const value = () => this.message;
|
||||
Object.defineProperty(this, "toString", { value, configurable: true, writable: true });
|
||||
return value;
|
||||
},
|
||||
set(value) {
|
||||
Object.defineProperty(this, "toString", { value, configurable: true, writable: true });
|
||||
},
|
||||
});
|
||||
}
|
||||
};
|
||||
exports.$ZodError = (0, core_js_1.$constructor)("$ZodError", initializer);
|
||||
exports.$ZodRealError = (0, core_js_1.$constructor)("$ZodError", initializer, undefined, {
|
||||
Parent: Error,
|
||||
});
|
||||
/** Get-or-create `obj[key]` as an own data property. A path segment naming an inherited member
|
||||
* ("toString", "constructor") would otherwise read through to the prototype, and assigning
|
||||
* "__proto__" would hit the setter instead of creating a key. */
|
||||
function node(obj, key, make) {
|
||||
if (!Object.prototype.hasOwnProperty.call(obj, key)) {
|
||||
if (key === "__proto__") {
|
||||
Object.defineProperty(obj, key, { value: make(), writable: true, enumerable: true, configurable: true });
|
||||
}
|
||||
else {
|
||||
obj[key] = make();
|
||||
}
|
||||
}
|
||||
return obj[key];
|
||||
}
|
||||
function flattenError(error, mapper = (issue) => issue.message) {
|
||||
const fieldErrors = {};
|
||||
const formErrors = [];
|
||||
for (const sub of error.issues) {
|
||||
if (sub.path.length > 0) {
|
||||
node(fieldErrors, sub.path[0], () => []).push(mapper(sub));
|
||||
}
|
||||
else {
|
||||
formErrors.push(mapper(sub));
|
||||
}
|
||||
}
|
||||
return { formErrors, fieldErrors };
|
||||
}
|
||||
function formatError(error, mapper = (issue) => issue.message) {
|
||||
const fieldErrors = { _errors: [] };
|
||||
const processError = (error, path = []) => {
|
||||
for (const issue of error.issues) {
|
||||
if (issue.code === "invalid_union" && issue.errors.length) {
|
||||
issue.errors.map((issues) => processError({ issues }, [...path, ...issue.path]));
|
||||
}
|
||||
else if (issue.code === "invalid_key") {
|
||||
processError({ issues: issue.issues }, [...path, ...issue.path]);
|
||||
}
|
||||
else if (issue.code === "invalid_element") {
|
||||
processError({ issues: issue.issues }, [...path, ...issue.path]);
|
||||
}
|
||||
else {
|
||||
const fullpath = [...path, ...issue.path];
|
||||
if (fullpath.length === 0) {
|
||||
fieldErrors._errors.push(mapper(issue));
|
||||
}
|
||||
else {
|
||||
let curr = fieldErrors;
|
||||
let i = 0;
|
||||
while (i < fullpath.length) {
|
||||
const el = fullpath[i];
|
||||
const terminal = i === fullpath.length - 1;
|
||||
// `_errors` is reserved by this legacy format, so merge a matching path segment into the current node instead of treating its array as a child.
|
||||
if (el === "_errors") {
|
||||
if (terminal)
|
||||
curr._errors.push(mapper(issue));
|
||||
i++;
|
||||
continue;
|
||||
}
|
||||
// A path element may collide with an inherited property name such as
|
||||
// "__proto__" or "constructor". Truthiness checks read the prototype
|
||||
// (so no node is created, then ._errors.push throws), and bracket
|
||||
// assignment of "__proto__" hits the setter instead of creating an
|
||||
// own key. Guard the read with hasOwnProperty and create the node
|
||||
// with defineProperty so any path element becomes a real own key.
|
||||
if (!Object.prototype.hasOwnProperty.call(curr, el)) {
|
||||
Object.defineProperty(curr, el, {
|
||||
value: { _errors: [] },
|
||||
enumerable: true,
|
||||
writable: true,
|
||||
configurable: true,
|
||||
});
|
||||
}
|
||||
const node = curr[el];
|
||||
if (terminal) {
|
||||
node._errors.push(mapper(issue));
|
||||
}
|
||||
curr = node;
|
||||
i++;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
processError(error);
|
||||
return fieldErrors;
|
||||
}
|
||||
function treeifyError(error, mapper = (issue) => issue.message) {
|
||||
const result = { errors: [] };
|
||||
const processError = (error, path = []) => {
|
||||
var _a;
|
||||
for (const issue of error.issues) {
|
||||
if (issue.code === "invalid_union" && issue.errors.length) {
|
||||
// regular union error
|
||||
issue.errors.map((issues) => processError({ issues }, [...path, ...issue.path]));
|
||||
}
|
||||
else if (issue.code === "invalid_key") {
|
||||
processError({ issues: issue.issues }, [...path, ...issue.path]);
|
||||
}
|
||||
else if (issue.code === "invalid_element") {
|
||||
processError({ issues: issue.issues }, [...path, ...issue.path]);
|
||||
}
|
||||
else {
|
||||
const fullpath = [...path, ...issue.path];
|
||||
if (fullpath.length === 0) {
|
||||
result.errors.push(mapper(issue));
|
||||
continue;
|
||||
}
|
||||
let curr = result;
|
||||
let i = 0;
|
||||
while (i < fullpath.length) {
|
||||
const el = fullpath[i];
|
||||
const terminal = i === fullpath.length - 1;
|
||||
if (typeof el === "string") {
|
||||
curr.properties ?? (curr.properties = {});
|
||||
// el may collide with an inherited property name ("__proto__",
|
||||
// "constructor", ...); ??= reads the prototype so the node is never
|
||||
// created and curr.errors.push throws. Guard with hasOwnProperty and
|
||||
// create the node with defineProperty so "__proto__" becomes a real
|
||||
// own key rather than invoking the prototype setter.
|
||||
if (!Object.prototype.hasOwnProperty.call(curr.properties, el)) {
|
||||
Object.defineProperty(curr.properties, el, {
|
||||
value: { errors: [] },
|
||||
enumerable: true,
|
||||
writable: true,
|
||||
configurable: true,
|
||||
});
|
||||
}
|
||||
curr = curr.properties[el];
|
||||
}
|
||||
else {
|
||||
curr.items ?? (curr.items = []);
|
||||
(_a = curr.items)[el] ?? (_a[el] = { errors: [] });
|
||||
curr = curr.items[el];
|
||||
}
|
||||
if (terminal) {
|
||||
curr.errors.push(mapper(issue));
|
||||
}
|
||||
i++;
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
processError(error);
|
||||
return result;
|
||||
}
|
||||
/** Format a ZodError as a human-readable string in the following form.
|
||||
*
|
||||
* From
|
||||
*
|
||||
* ```ts
|
||||
* ZodError {
|
||||
* issues: [
|
||||
* {
|
||||
* expected: 'string',
|
||||
* code: 'invalid_type',
|
||||
* path: [ 'username' ],
|
||||
* message: 'Invalid input: expected string'
|
||||
* },
|
||||
* {
|
||||
* expected: 'number',
|
||||
* code: 'invalid_type',
|
||||
* path: [ 'favoriteNumbers', 1 ],
|
||||
* message: 'Invalid input: expected number'
|
||||
* }
|
||||
* ];
|
||||
* }
|
||||
* ```
|
||||
*
|
||||
* to
|
||||
*
|
||||
* ```
|
||||
* username
|
||||
* ✖ Expected number, received string at "username
|
||||
* favoriteNumbers[0]
|
||||
* ✖ Invalid input: expected number
|
||||
* ```
|
||||
*/
|
||||
function toDotPath(_path) {
|
||||
const segs = [];
|
||||
const path = _path.map((seg) => (typeof seg === "object" ? seg.key : seg));
|
||||
for (const seg of path) {
|
||||
if (typeof seg === "number")
|
||||
segs.push(`[${seg}]`);
|
||||
else if (typeof seg === "symbol")
|
||||
segs.push(`[${JSON.stringify(String(seg))}]`);
|
||||
else if (/[^\w$]/.test(seg))
|
||||
segs.push(`[${JSON.stringify(seg)}]`);
|
||||
else {
|
||||
if (segs.length)
|
||||
segs.push(".");
|
||||
segs.push(seg);
|
||||
}
|
||||
}
|
||||
return segs.join("");
|
||||
}
|
||||
function prettifyError(error) {
|
||||
const lines = [];
|
||||
// sort by path length
|
||||
const issues = [...error.issues].sort((a, b) => (a.path ?? []).length - (b.path ?? []).length);
|
||||
// Process each issue
|
||||
for (const issue of issues) {
|
||||
lines.push(`✖ ${issue.message}`);
|
||||
if (issue.path?.length)
|
||||
lines.push(` → at ${toDotPath(issue.path)}`);
|
||||
}
|
||||
// Convert Map to formatted string
|
||||
return lines.join("\n");
|
||||
}
|
||||
|
||||
// seal-cjs-exports
|
||||
(function () {
|
||||
var keys = Object.getOwnPropertyNames(exports);
|
||||
for (var i = 0; i < keys.length; i++) {
|
||||
var desc = Object.getOwnPropertyDescriptor(exports, keys[i]);
|
||||
if (!desc || !desc.get || !desc.configurable) continue;
|
||||
var value;
|
||||
try {
|
||||
value = desc.get();
|
||||
} catch (e) {
|
||||
continue;
|
||||
}
|
||||
// a circular require may not have settled this one yet, so leave it live
|
||||
if (value === undefined) continue;
|
||||
Object.defineProperty(exports, keys[i], { value: value, writable: false, enumerable: desc.enumerable, configurable: false });
|
||||
}
|
||||
Object.freeze(exports);
|
||||
})();
|
||||
+225
@@ -0,0 +1,225 @@
|
||||
import type { $ZodCheck, $ZodStringFormats } from "./checks.cjs";
|
||||
import { $constructor } from "./core.cjs";
|
||||
import type { $ZodType } from "./schemas.cjs";
|
||||
import type { StandardSchemaV1 } from "./standard-schema.cjs";
|
||||
import * as util from "./util.cjs";
|
||||
export interface $ZodIssueBase {
|
||||
readonly code?: string;
|
||||
readonly input?: unknown;
|
||||
readonly path: PropertyKey[];
|
||||
readonly message: string;
|
||||
}
|
||||
export type $ZodInvalidTypeExpected = "string" | "number" | "int" | "boolean" | "bigint" | "symbol" | "undefined" | "null" | "never" | "void" | "date" | "array" | "object" | "tuple" | "record" | "map" | "set" | "file" | "nonoptional" | "nan" | "function" | (string & {});
|
||||
export interface $ZodIssueInvalidType<Input = unknown> extends $ZodIssueBase {
|
||||
readonly code: "invalid_type";
|
||||
readonly expected: $ZodInvalidTypeExpected;
|
||||
readonly input?: Input;
|
||||
}
|
||||
export interface $ZodIssueTooBig<Input = unknown> extends $ZodIssueBase {
|
||||
readonly code: "too_big";
|
||||
readonly origin: "number" | "int" | "bigint" | "date" | "string" | "array" | "set" | "file" | (string & {});
|
||||
readonly maximum: number | bigint;
|
||||
readonly inclusive?: boolean;
|
||||
readonly exact?: boolean;
|
||||
readonly input?: Input;
|
||||
}
|
||||
export interface $ZodIssueTooSmall<Input = unknown> extends $ZodIssueBase {
|
||||
readonly code: "too_small";
|
||||
readonly origin: "number" | "int" | "bigint" | "date" | "string" | "array" | "set" | "file" | (string & {});
|
||||
readonly minimum: number | bigint;
|
||||
/** True if the allowable range includes the minimum */
|
||||
readonly inclusive?: boolean;
|
||||
/** True if the allowed value is fixed (e.g.` z.length(5)`), not a range (`z.minLength(5)`) */
|
||||
readonly exact?: boolean;
|
||||
readonly input?: Input;
|
||||
}
|
||||
export interface $ZodIssueInvalidStringFormat extends $ZodIssueBase {
|
||||
readonly code: "invalid_format";
|
||||
readonly format: $ZodStringFormats | (string & {});
|
||||
readonly pattern?: string;
|
||||
readonly input?: string;
|
||||
}
|
||||
export interface $ZodIssueNotMultipleOf<Input extends number | bigint = number | bigint> extends $ZodIssueBase {
|
||||
readonly code: "not_multiple_of";
|
||||
readonly divisor: number;
|
||||
readonly input?: Input;
|
||||
}
|
||||
export interface $ZodIssueUnrecognizedKeys extends $ZodIssueBase {
|
||||
readonly code: "unrecognized_keys";
|
||||
readonly keys: string[];
|
||||
readonly input?: Record<string, unknown>;
|
||||
}
|
||||
interface $ZodIssueInvalidUnionNoMatch extends $ZodIssueBase {
|
||||
readonly code: "invalid_union";
|
||||
readonly errors: $ZodIssue[][];
|
||||
readonly input?: unknown;
|
||||
readonly discriminator?: string | undefined;
|
||||
readonly options?: util.Primitive[];
|
||||
readonly inclusive?: true;
|
||||
}
|
||||
interface $ZodIssueInvalidUnionMultipleMatch extends $ZodIssueBase {
|
||||
readonly code: "invalid_union";
|
||||
readonly errors: [];
|
||||
readonly input?: unknown;
|
||||
readonly discriminator?: string | undefined;
|
||||
readonly inclusive: false;
|
||||
/** Indices of the options that matched */
|
||||
readonly matches: number[];
|
||||
}
|
||||
export type $ZodIssueInvalidUnion = $ZodIssueInvalidUnionNoMatch | $ZodIssueInvalidUnionMultipleMatch;
|
||||
export interface $ZodIssueInvalidKey<Input = unknown> extends $ZodIssueBase {
|
||||
readonly code: "invalid_key";
|
||||
readonly origin: "map" | "record";
|
||||
readonly issues: $ZodIssue[];
|
||||
readonly input?: Input;
|
||||
}
|
||||
export interface $ZodIssueInvalidElement<Input = unknown> extends $ZodIssueBase {
|
||||
readonly code: "invalid_element";
|
||||
readonly origin: "map" | "set";
|
||||
readonly key: unknown;
|
||||
readonly issues: $ZodIssue[];
|
||||
readonly input?: Input;
|
||||
}
|
||||
export interface $ZodIssueInvalidValue<Input = unknown> extends $ZodIssueBase {
|
||||
readonly code: "invalid_value";
|
||||
readonly values: util.Primitive[];
|
||||
readonly input?: Input;
|
||||
}
|
||||
export interface $ZodIssueCustom extends $ZodIssueBase {
|
||||
readonly code: "custom";
|
||||
readonly params?: Record<string, any> | undefined;
|
||||
readonly input?: unknown;
|
||||
}
|
||||
export interface $ZodIssueStringCommonFormats extends $ZodIssueInvalidStringFormat {
|
||||
format: Exclude<$ZodStringFormats, "regex" | "jwt" | "starts_with" | "ends_with" | "includes">;
|
||||
}
|
||||
export interface $ZodIssueStringInvalidRegex extends $ZodIssueInvalidStringFormat {
|
||||
format: "regex";
|
||||
pattern: string;
|
||||
}
|
||||
export interface $ZodIssueStringInvalidJWT extends $ZodIssueInvalidStringFormat {
|
||||
format: "jwt";
|
||||
algorithm?: string;
|
||||
}
|
||||
export interface $ZodIssueStringStartsWith extends $ZodIssueInvalidStringFormat {
|
||||
format: "starts_with";
|
||||
prefix: string;
|
||||
}
|
||||
export interface $ZodIssueStringEndsWith extends $ZodIssueInvalidStringFormat {
|
||||
format: "ends_with";
|
||||
suffix: string;
|
||||
}
|
||||
export interface $ZodIssueStringIncludes extends $ZodIssueInvalidStringFormat {
|
||||
format: "includes";
|
||||
includes: string;
|
||||
}
|
||||
export type $ZodStringFormatIssues = $ZodIssueStringCommonFormats | $ZodIssueStringInvalidRegex | $ZodIssueStringInvalidJWT | $ZodIssueStringStartsWith | $ZodIssueStringEndsWith | $ZodIssueStringIncludes;
|
||||
export type $ZodIssue = $ZodIssueInvalidType | $ZodIssueTooBig | $ZodIssueTooSmall | $ZodIssueInvalidStringFormat | $ZodIssueNotMultipleOf | $ZodIssueUnrecognizedKeys | $ZodIssueInvalidUnion | $ZodIssueInvalidKey | $ZodIssueInvalidElement | $ZodIssueInvalidValue | $ZodIssueCustom;
|
||||
export type $ZodIssueCode = $ZodIssue["code"];
|
||||
export type $ZodInternalIssue<T extends $ZodIssueBase = $ZodIssue> = T extends any ? RawIssue<T> : never;
|
||||
type RawIssue<T extends $ZodIssueBase> = T extends any ? util.Flatten<util.MakePartial<T, "message" | "path"> & {
|
||||
/** The input data */
|
||||
readonly input: unknown;
|
||||
/** The schema or check that originated this issue. */
|
||||
readonly inst?: $ZodType | $ZodCheck;
|
||||
/** The schema that owns the issue. Equal to `inst` when a schema originated the issue, and the schema the check was attached to when a check did. */
|
||||
readonly schema?: $ZodType | undefined;
|
||||
/** If `true`, Zod will continue executing checks/refinements after this issue. */
|
||||
readonly continue?: boolean | undefined;
|
||||
} & Record<string, unknown>> : never;
|
||||
export type $ZodRawIssue<T extends $ZodIssueBase = $ZodIssue> = $ZodInternalIssue<T>;
|
||||
export interface $ZodErrorMap<T extends $ZodIssueBase = $ZodIssue> {
|
||||
(issue: $ZodRawIssue<T>): {
|
||||
message: string;
|
||||
} | string | undefined | null;
|
||||
}
|
||||
export interface $ZodError<T = unknown> extends Error {
|
||||
type: T;
|
||||
issues: $ZodIssue[];
|
||||
_zod: {
|
||||
output: T;
|
||||
def: $ZodIssue[];
|
||||
};
|
||||
stack?: string;
|
||||
name: string;
|
||||
}
|
||||
export declare const $ZodError: $constructor<$ZodError>;
|
||||
interface $ZodRealError<T = any> extends $ZodError<T> {
|
||||
}
|
||||
export declare const $ZodRealError: $constructor<$ZodRealError>;
|
||||
export type $ZodFlattenedError<T, U = string> = _FlattenedError<T, U>;
|
||||
type _FlattenedError<T, U = string> = {
|
||||
formErrors: U[];
|
||||
fieldErrors: {
|
||||
[P in keyof T]?: U[];
|
||||
};
|
||||
};
|
||||
export declare function flattenError<T>(error: $ZodError<T>): _FlattenedError<T>;
|
||||
export declare function flattenError<T, U>(error: $ZodError<T>, mapper?: (issue: $ZodIssue) => U): _FlattenedError<T, U>;
|
||||
type _ZodFormattedError<T, U = string> = T extends [any, ...any[]] ? {
|
||||
[K in keyof T]?: $ZodFormattedError<T[K], U>;
|
||||
} : T extends any[] ? {
|
||||
[k: number]: $ZodFormattedError<T[number], U>;
|
||||
} : T extends object ? util.Flatten<{
|
||||
[K in keyof T]?: $ZodFormattedError<T[K], U>;
|
||||
}> : any;
|
||||
export type $ZodFormattedError<T, U = string> = {
|
||||
_errors: U[];
|
||||
} & util.Flatten<_ZodFormattedError<T, U>>;
|
||||
export declare function formatError<T>(error: $ZodError<T>): $ZodFormattedError<T>;
|
||||
export declare function formatError<T, U>(error: $ZodError<T>, mapper?: (issue: $ZodIssue) => U): $ZodFormattedError<T, U>;
|
||||
export type $ZodErrorTree<T, U = string> = T extends util.Primitive ? {
|
||||
errors: U[];
|
||||
} : T extends [any, ...any[]] ? {
|
||||
errors: U[];
|
||||
items?: {
|
||||
[K in keyof T]?: $ZodErrorTree<T[K], U>;
|
||||
};
|
||||
} : T extends any[] ? {
|
||||
errors: U[];
|
||||
items?: Array<$ZodErrorTree<T[number], U>>;
|
||||
} : T extends object ? {
|
||||
errors: U[];
|
||||
properties?: {
|
||||
[K in keyof T]?: $ZodErrorTree<T[K], U>;
|
||||
};
|
||||
} : {
|
||||
errors: U[];
|
||||
};
|
||||
export declare function treeifyError<T>(error: $ZodError<T>): $ZodErrorTree<T>;
|
||||
export declare function treeifyError<T, U>(error: $ZodError<T>, mapper?: (issue: $ZodIssue) => U): $ZodErrorTree<T, U>;
|
||||
/** Format a ZodError as a human-readable string in the following form.
|
||||
*
|
||||
* From
|
||||
*
|
||||
* ```ts
|
||||
* ZodError {
|
||||
* issues: [
|
||||
* {
|
||||
* expected: 'string',
|
||||
* code: 'invalid_type',
|
||||
* path: [ 'username' ],
|
||||
* message: 'Invalid input: expected string'
|
||||
* },
|
||||
* {
|
||||
* expected: 'number',
|
||||
* code: 'invalid_type',
|
||||
* path: [ 'favoriteNumbers', 1 ],
|
||||
* message: 'Invalid input: expected number'
|
||||
* }
|
||||
* ];
|
||||
* }
|
||||
* ```
|
||||
*
|
||||
* to
|
||||
*
|
||||
* ```
|
||||
* username
|
||||
* ✖ Expected number, received string at "username
|
||||
* favoriteNumbers[0]
|
||||
* ✖ Invalid input: expected number
|
||||
* ```
|
||||
*/
|
||||
export declare function toDotPath(_path: readonly (string | number | symbol | StandardSchemaV1.PathSegment)[]): string;
|
||||
export declare function prettifyError(error: StandardSchemaV1.FailureResult): string;
|
||||
export {};
|
||||
+225
@@ -0,0 +1,225 @@
|
||||
import type { $ZodCheck, $ZodStringFormats } from "./checks.js";
|
||||
import { $constructor } from "./core.js";
|
||||
import type { $ZodType } from "./schemas.js";
|
||||
import type { StandardSchemaV1 } from "./standard-schema.js";
|
||||
import * as util from "./util.js";
|
||||
export interface $ZodIssueBase {
|
||||
readonly code?: string;
|
||||
readonly input?: unknown;
|
||||
readonly path: PropertyKey[];
|
||||
readonly message: string;
|
||||
}
|
||||
export type $ZodInvalidTypeExpected = "string" | "number" | "int" | "boolean" | "bigint" | "symbol" | "undefined" | "null" | "never" | "void" | "date" | "array" | "object" | "tuple" | "record" | "map" | "set" | "file" | "nonoptional" | "nan" | "function" | (string & {});
|
||||
export interface $ZodIssueInvalidType<Input = unknown> extends $ZodIssueBase {
|
||||
readonly code: "invalid_type";
|
||||
readonly expected: $ZodInvalidTypeExpected;
|
||||
readonly input?: Input;
|
||||
}
|
||||
export interface $ZodIssueTooBig<Input = unknown> extends $ZodIssueBase {
|
||||
readonly code: "too_big";
|
||||
readonly origin: "number" | "int" | "bigint" | "date" | "string" | "array" | "set" | "file" | (string & {});
|
||||
readonly maximum: number | bigint;
|
||||
readonly inclusive?: boolean;
|
||||
readonly exact?: boolean;
|
||||
readonly input?: Input;
|
||||
}
|
||||
export interface $ZodIssueTooSmall<Input = unknown> extends $ZodIssueBase {
|
||||
readonly code: "too_small";
|
||||
readonly origin: "number" | "int" | "bigint" | "date" | "string" | "array" | "set" | "file" | (string & {});
|
||||
readonly minimum: number | bigint;
|
||||
/** True if the allowable range includes the minimum */
|
||||
readonly inclusive?: boolean;
|
||||
/** True if the allowed value is fixed (e.g.` z.length(5)`), not a range (`z.minLength(5)`) */
|
||||
readonly exact?: boolean;
|
||||
readonly input?: Input;
|
||||
}
|
||||
export interface $ZodIssueInvalidStringFormat extends $ZodIssueBase {
|
||||
readonly code: "invalid_format";
|
||||
readonly format: $ZodStringFormats | (string & {});
|
||||
readonly pattern?: string;
|
||||
readonly input?: string;
|
||||
}
|
||||
export interface $ZodIssueNotMultipleOf<Input extends number | bigint = number | bigint> extends $ZodIssueBase {
|
||||
readonly code: "not_multiple_of";
|
||||
readonly divisor: number;
|
||||
readonly input?: Input;
|
||||
}
|
||||
export interface $ZodIssueUnrecognizedKeys extends $ZodIssueBase {
|
||||
readonly code: "unrecognized_keys";
|
||||
readonly keys: string[];
|
||||
readonly input?: Record<string, unknown>;
|
||||
}
|
||||
interface $ZodIssueInvalidUnionNoMatch extends $ZodIssueBase {
|
||||
readonly code: "invalid_union";
|
||||
readonly errors: $ZodIssue[][];
|
||||
readonly input?: unknown;
|
||||
readonly discriminator?: string | undefined;
|
||||
readonly options?: util.Primitive[];
|
||||
readonly inclusive?: true;
|
||||
}
|
||||
interface $ZodIssueInvalidUnionMultipleMatch extends $ZodIssueBase {
|
||||
readonly code: "invalid_union";
|
||||
readonly errors: [];
|
||||
readonly input?: unknown;
|
||||
readonly discriminator?: string | undefined;
|
||||
readonly inclusive: false;
|
||||
/** Indices of the options that matched */
|
||||
readonly matches: number[];
|
||||
}
|
||||
export type $ZodIssueInvalidUnion = $ZodIssueInvalidUnionNoMatch | $ZodIssueInvalidUnionMultipleMatch;
|
||||
export interface $ZodIssueInvalidKey<Input = unknown> extends $ZodIssueBase {
|
||||
readonly code: "invalid_key";
|
||||
readonly origin: "map" | "record";
|
||||
readonly issues: $ZodIssue[];
|
||||
readonly input?: Input;
|
||||
}
|
||||
export interface $ZodIssueInvalidElement<Input = unknown> extends $ZodIssueBase {
|
||||
readonly code: "invalid_element";
|
||||
readonly origin: "map" | "set";
|
||||
readonly key: unknown;
|
||||
readonly issues: $ZodIssue[];
|
||||
readonly input?: Input;
|
||||
}
|
||||
export interface $ZodIssueInvalidValue<Input = unknown> extends $ZodIssueBase {
|
||||
readonly code: "invalid_value";
|
||||
readonly values: util.Primitive[];
|
||||
readonly input?: Input;
|
||||
}
|
||||
export interface $ZodIssueCustom extends $ZodIssueBase {
|
||||
readonly code: "custom";
|
||||
readonly params?: Record<string, any> | undefined;
|
||||
readonly input?: unknown;
|
||||
}
|
||||
export interface $ZodIssueStringCommonFormats extends $ZodIssueInvalidStringFormat {
|
||||
format: Exclude<$ZodStringFormats, "regex" | "jwt" | "starts_with" | "ends_with" | "includes">;
|
||||
}
|
||||
export interface $ZodIssueStringInvalidRegex extends $ZodIssueInvalidStringFormat {
|
||||
format: "regex";
|
||||
pattern: string;
|
||||
}
|
||||
export interface $ZodIssueStringInvalidJWT extends $ZodIssueInvalidStringFormat {
|
||||
format: "jwt";
|
||||
algorithm?: string;
|
||||
}
|
||||
export interface $ZodIssueStringStartsWith extends $ZodIssueInvalidStringFormat {
|
||||
format: "starts_with";
|
||||
prefix: string;
|
||||
}
|
||||
export interface $ZodIssueStringEndsWith extends $ZodIssueInvalidStringFormat {
|
||||
format: "ends_with";
|
||||
suffix: string;
|
||||
}
|
||||
export interface $ZodIssueStringIncludes extends $ZodIssueInvalidStringFormat {
|
||||
format: "includes";
|
||||
includes: string;
|
||||
}
|
||||
export type $ZodStringFormatIssues = $ZodIssueStringCommonFormats | $ZodIssueStringInvalidRegex | $ZodIssueStringInvalidJWT | $ZodIssueStringStartsWith | $ZodIssueStringEndsWith | $ZodIssueStringIncludes;
|
||||
export type $ZodIssue = $ZodIssueInvalidType | $ZodIssueTooBig | $ZodIssueTooSmall | $ZodIssueInvalidStringFormat | $ZodIssueNotMultipleOf | $ZodIssueUnrecognizedKeys | $ZodIssueInvalidUnion | $ZodIssueInvalidKey | $ZodIssueInvalidElement | $ZodIssueInvalidValue | $ZodIssueCustom;
|
||||
export type $ZodIssueCode = $ZodIssue["code"];
|
||||
export type $ZodInternalIssue<T extends $ZodIssueBase = $ZodIssue> = T extends any ? RawIssue<T> : never;
|
||||
type RawIssue<T extends $ZodIssueBase> = T extends any ? util.Flatten<util.MakePartial<T, "message" | "path"> & {
|
||||
/** The input data */
|
||||
readonly input: unknown;
|
||||
/** The schema or check that originated this issue. */
|
||||
readonly inst?: $ZodType | $ZodCheck;
|
||||
/** The schema that owns the issue. Equal to `inst` when a schema originated the issue, and the schema the check was attached to when a check did. */
|
||||
readonly schema?: $ZodType | undefined;
|
||||
/** If `true`, Zod will continue executing checks/refinements after this issue. */
|
||||
readonly continue?: boolean | undefined;
|
||||
} & Record<string, unknown>> : never;
|
||||
export type $ZodRawIssue<T extends $ZodIssueBase = $ZodIssue> = $ZodInternalIssue<T>;
|
||||
export interface $ZodErrorMap<T extends $ZodIssueBase = $ZodIssue> {
|
||||
(issue: $ZodRawIssue<T>): {
|
||||
message: string;
|
||||
} | string | undefined | null;
|
||||
}
|
||||
export interface $ZodError<T = unknown> extends Error {
|
||||
type: T;
|
||||
issues: $ZodIssue[];
|
||||
_zod: {
|
||||
output: T;
|
||||
def: $ZodIssue[];
|
||||
};
|
||||
stack?: string;
|
||||
name: string;
|
||||
}
|
||||
export declare const $ZodError: $constructor<$ZodError>;
|
||||
interface $ZodRealError<T = any> extends $ZodError<T> {
|
||||
}
|
||||
export declare const $ZodRealError: $constructor<$ZodRealError>;
|
||||
export type $ZodFlattenedError<T, U = string> = _FlattenedError<T, U>;
|
||||
type _FlattenedError<T, U = string> = {
|
||||
formErrors: U[];
|
||||
fieldErrors: {
|
||||
[P in keyof T]?: U[];
|
||||
};
|
||||
};
|
||||
export declare function flattenError<T>(error: $ZodError<T>): _FlattenedError<T>;
|
||||
export declare function flattenError<T, U>(error: $ZodError<T>, mapper?: (issue: $ZodIssue) => U): _FlattenedError<T, U>;
|
||||
type _ZodFormattedError<T, U = string> = T extends [any, ...any[]] ? {
|
||||
[K in keyof T]?: $ZodFormattedError<T[K], U>;
|
||||
} : T extends any[] ? {
|
||||
[k: number]: $ZodFormattedError<T[number], U>;
|
||||
} : T extends object ? util.Flatten<{
|
||||
[K in keyof T]?: $ZodFormattedError<T[K], U>;
|
||||
}> : any;
|
||||
export type $ZodFormattedError<T, U = string> = {
|
||||
_errors: U[];
|
||||
} & util.Flatten<_ZodFormattedError<T, U>>;
|
||||
export declare function formatError<T>(error: $ZodError<T>): $ZodFormattedError<T>;
|
||||
export declare function formatError<T, U>(error: $ZodError<T>, mapper?: (issue: $ZodIssue) => U): $ZodFormattedError<T, U>;
|
||||
export type $ZodErrorTree<T, U = string> = T extends util.Primitive ? {
|
||||
errors: U[];
|
||||
} : T extends [any, ...any[]] ? {
|
||||
errors: U[];
|
||||
items?: {
|
||||
[K in keyof T]?: $ZodErrorTree<T[K], U>;
|
||||
};
|
||||
} : T extends any[] ? {
|
||||
errors: U[];
|
||||
items?: Array<$ZodErrorTree<T[number], U>>;
|
||||
} : T extends object ? {
|
||||
errors: U[];
|
||||
properties?: {
|
||||
[K in keyof T]?: $ZodErrorTree<T[K], U>;
|
||||
};
|
||||
} : {
|
||||
errors: U[];
|
||||
};
|
||||
export declare function treeifyError<T>(error: $ZodError<T>): $ZodErrorTree<T>;
|
||||
export declare function treeifyError<T, U>(error: $ZodError<T>, mapper?: (issue: $ZodIssue) => U): $ZodErrorTree<T, U>;
|
||||
/** Format a ZodError as a human-readable string in the following form.
|
||||
*
|
||||
* From
|
||||
*
|
||||
* ```ts
|
||||
* ZodError {
|
||||
* issues: [
|
||||
* {
|
||||
* expected: 'string',
|
||||
* code: 'invalid_type',
|
||||
* path: [ 'username' ],
|
||||
* message: 'Invalid input: expected string'
|
||||
* },
|
||||
* {
|
||||
* expected: 'number',
|
||||
* code: 'invalid_type',
|
||||
* path: [ 'favoriteNumbers', 1 ],
|
||||
* message: 'Invalid input: expected number'
|
||||
* }
|
||||
* ];
|
||||
* }
|
||||
* ```
|
||||
*
|
||||
* to
|
||||
*
|
||||
* ```
|
||||
* username
|
||||
* ✖ Expected number, received string at "username
|
||||
* favoriteNumbers[0]
|
||||
* ✖ Invalid input: expected number
|
||||
* ```
|
||||
*/
|
||||
export declare function toDotPath(_path: readonly (string | number | symbol | StandardSchemaV1.PathSegment)[]): string;
|
||||
export declare function prettifyError(error: StandardSchemaV1.FailureResult): string;
|
||||
export {};
|
||||
+267
@@ -0,0 +1,267 @@
|
||||
import { $constructor } from "./core.js";
|
||||
import * as util from "./util.js";
|
||||
/* Computing the message eagerly is expensive (pretty-printed JSON of all
|
||||
* issues), so defer it until first read. The accessor functions and
|
||||
* descriptors are shared across instances to keep error construction
|
||||
* cheap; the computed message is cached on the internals object. The
|
||||
* setter preserves plain assignment semantics for consumers that
|
||||
* overwrite `message`. */
|
||||
function _getMessage() {
|
||||
const internals = this._zod;
|
||||
internals.message ?? (internals.message = JSON.stringify(internals.def, util.jsonStringifyReplacer, 2));
|
||||
return internals.message;
|
||||
}
|
||||
function _setMessage(value) {
|
||||
this._zod.message = value;
|
||||
}
|
||||
const _messageDesc = {
|
||||
get: _getMessage,
|
||||
set: _setMessage,
|
||||
enumerable: true,
|
||||
configurable: true,
|
||||
};
|
||||
const _issuesDesc = { value: undefined, enumerable: false };
|
||||
/* Prototypes that already carry the lazy `toString`. Seeded with the
|
||||
* intrinsics so that `init` on a foreign object — it accepts any object —
|
||||
* can never install an accessor onto a prototype we do not own. */
|
||||
const _installedToString = /* @__PURE__ */ new WeakSet([Object.prototype, Error.prototype]);
|
||||
const initializer = (inst, def) => {
|
||||
inst.name = "$ZodError";
|
||||
// `_zod` is already non-enumerable: $constructor's init defined it with this same descriptor
|
||||
_issuesDesc.value = def;
|
||||
Object.defineProperty(inst, "issues", _issuesDesc);
|
||||
// Clear the shared slot; a retained `value` pins the last error's issues.
|
||||
_issuesDesc.value = undefined;
|
||||
Object.defineProperty(inst, "message", _messageDesc);
|
||||
/* `toString` lives as a non-enumerable lazy getter on the shared
|
||||
* prototype; on first access it caches a per-instance closure so
|
||||
* detached usage still works. */
|
||||
const proto = Object.getPrototypeOf(inst);
|
||||
if (!_installedToString.has(proto)) {
|
||||
_installedToString.add(proto);
|
||||
Object.defineProperty(proto, "toString", {
|
||||
configurable: true,
|
||||
enumerable: false,
|
||||
get() {
|
||||
const value = () => this.message;
|
||||
Object.defineProperty(this, "toString", { value, configurable: true, writable: true });
|
||||
return value;
|
||||
},
|
||||
set(value) {
|
||||
Object.defineProperty(this, "toString", { value, configurable: true, writable: true });
|
||||
},
|
||||
});
|
||||
}
|
||||
};
|
||||
export const $ZodError = $constructor("$ZodError", initializer);
|
||||
export const $ZodRealError = $constructor("$ZodError", initializer, undefined, {
|
||||
Parent: Error,
|
||||
});
|
||||
/** Get-or-create `obj[key]` as an own data property. A path segment naming an inherited member
|
||||
* ("toString", "constructor") would otherwise read through to the prototype, and assigning
|
||||
* "__proto__" would hit the setter instead of creating a key. */
|
||||
function node(obj, key, make) {
|
||||
if (!Object.prototype.hasOwnProperty.call(obj, key)) {
|
||||
if (key === "__proto__") {
|
||||
Object.defineProperty(obj, key, { value: make(), writable: true, enumerable: true, configurable: true });
|
||||
}
|
||||
else {
|
||||
obj[key] = make();
|
||||
}
|
||||
}
|
||||
return obj[key];
|
||||
}
|
||||
export function flattenError(error, mapper = (issue) => issue.message) {
|
||||
const fieldErrors = {};
|
||||
const formErrors = [];
|
||||
for (const sub of error.issues) {
|
||||
if (sub.path.length > 0) {
|
||||
node(fieldErrors, sub.path[0], () => []).push(mapper(sub));
|
||||
}
|
||||
else {
|
||||
formErrors.push(mapper(sub));
|
||||
}
|
||||
}
|
||||
return { formErrors, fieldErrors };
|
||||
}
|
||||
export function formatError(error, mapper = (issue) => issue.message) {
|
||||
const fieldErrors = { _errors: [] };
|
||||
const processError = (error, path = []) => {
|
||||
for (const issue of error.issues) {
|
||||
if (issue.code === "invalid_union" && issue.errors.length) {
|
||||
issue.errors.map((issues) => processError({ issues }, [...path, ...issue.path]));
|
||||
}
|
||||
else if (issue.code === "invalid_key") {
|
||||
processError({ issues: issue.issues }, [...path, ...issue.path]);
|
||||
}
|
||||
else if (issue.code === "invalid_element") {
|
||||
processError({ issues: issue.issues }, [...path, ...issue.path]);
|
||||
}
|
||||
else {
|
||||
const fullpath = [...path, ...issue.path];
|
||||
if (fullpath.length === 0) {
|
||||
fieldErrors._errors.push(mapper(issue));
|
||||
}
|
||||
else {
|
||||
let curr = fieldErrors;
|
||||
let i = 0;
|
||||
while (i < fullpath.length) {
|
||||
const el = fullpath[i];
|
||||
const terminal = i === fullpath.length - 1;
|
||||
// `_errors` is reserved by this legacy format, so merge a matching path segment into the current node instead of treating its array as a child.
|
||||
if (el === "_errors") {
|
||||
if (terminal)
|
||||
curr._errors.push(mapper(issue));
|
||||
i++;
|
||||
continue;
|
||||
}
|
||||
// A path element may collide with an inherited property name such as
|
||||
// "__proto__" or "constructor". Truthiness checks read the prototype
|
||||
// (so no node is created, then ._errors.push throws), and bracket
|
||||
// assignment of "__proto__" hits the setter instead of creating an
|
||||
// own key. Guard the read with hasOwnProperty and create the node
|
||||
// with defineProperty so any path element becomes a real own key.
|
||||
if (!Object.prototype.hasOwnProperty.call(curr, el)) {
|
||||
Object.defineProperty(curr, el, {
|
||||
value: { _errors: [] },
|
||||
enumerable: true,
|
||||
writable: true,
|
||||
configurable: true,
|
||||
});
|
||||
}
|
||||
const node = curr[el];
|
||||
if (terminal) {
|
||||
node._errors.push(mapper(issue));
|
||||
}
|
||||
curr = node;
|
||||
i++;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
processError(error);
|
||||
return fieldErrors;
|
||||
}
|
||||
export function treeifyError(error, mapper = (issue) => issue.message) {
|
||||
const result = { errors: [] };
|
||||
const processError = (error, path = []) => {
|
||||
var _a;
|
||||
for (const issue of error.issues) {
|
||||
if (issue.code === "invalid_union" && issue.errors.length) {
|
||||
// regular union error
|
||||
issue.errors.map((issues) => processError({ issues }, [...path, ...issue.path]));
|
||||
}
|
||||
else if (issue.code === "invalid_key") {
|
||||
processError({ issues: issue.issues }, [...path, ...issue.path]);
|
||||
}
|
||||
else if (issue.code === "invalid_element") {
|
||||
processError({ issues: issue.issues }, [...path, ...issue.path]);
|
||||
}
|
||||
else {
|
||||
const fullpath = [...path, ...issue.path];
|
||||
if (fullpath.length === 0) {
|
||||
result.errors.push(mapper(issue));
|
||||
continue;
|
||||
}
|
||||
let curr = result;
|
||||
let i = 0;
|
||||
while (i < fullpath.length) {
|
||||
const el = fullpath[i];
|
||||
const terminal = i === fullpath.length - 1;
|
||||
if (typeof el === "string") {
|
||||
curr.properties ?? (curr.properties = {});
|
||||
// el may collide with an inherited property name ("__proto__",
|
||||
// "constructor", ...); ??= reads the prototype so the node is never
|
||||
// created and curr.errors.push throws. Guard with hasOwnProperty and
|
||||
// create the node with defineProperty so "__proto__" becomes a real
|
||||
// own key rather than invoking the prototype setter.
|
||||
if (!Object.prototype.hasOwnProperty.call(curr.properties, el)) {
|
||||
Object.defineProperty(curr.properties, el, {
|
||||
value: { errors: [] },
|
||||
enumerable: true,
|
||||
writable: true,
|
||||
configurable: true,
|
||||
});
|
||||
}
|
||||
curr = curr.properties[el];
|
||||
}
|
||||
else {
|
||||
curr.items ?? (curr.items = []);
|
||||
(_a = curr.items)[el] ?? (_a[el] = { errors: [] });
|
||||
curr = curr.items[el];
|
||||
}
|
||||
if (terminal) {
|
||||
curr.errors.push(mapper(issue));
|
||||
}
|
||||
i++;
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
processError(error);
|
||||
return result;
|
||||
}
|
||||
/** Format a ZodError as a human-readable string in the following form.
|
||||
*
|
||||
* From
|
||||
*
|
||||
* ```ts
|
||||
* ZodError {
|
||||
* issues: [
|
||||
* {
|
||||
* expected: 'string',
|
||||
* code: 'invalid_type',
|
||||
* path: [ 'username' ],
|
||||
* message: 'Invalid input: expected string'
|
||||
* },
|
||||
* {
|
||||
* expected: 'number',
|
||||
* code: 'invalid_type',
|
||||
* path: [ 'favoriteNumbers', 1 ],
|
||||
* message: 'Invalid input: expected number'
|
||||
* }
|
||||
* ];
|
||||
* }
|
||||
* ```
|
||||
*
|
||||
* to
|
||||
*
|
||||
* ```
|
||||
* username
|
||||
* ✖ Expected number, received string at "username
|
||||
* favoriteNumbers[0]
|
||||
* ✖ Invalid input: expected number
|
||||
* ```
|
||||
*/
|
||||
export function toDotPath(_path) {
|
||||
const segs = [];
|
||||
const path = _path.map((seg) => (typeof seg === "object" ? seg.key : seg));
|
||||
for (const seg of path) {
|
||||
if (typeof seg === "number")
|
||||
segs.push(`[${seg}]`);
|
||||
else if (typeof seg === "symbol")
|
||||
segs.push(`[${JSON.stringify(String(seg))}]`);
|
||||
else if (/[^\w$]/.test(seg))
|
||||
segs.push(`[${JSON.stringify(seg)}]`);
|
||||
else {
|
||||
if (segs.length)
|
||||
segs.push(".");
|
||||
segs.push(seg);
|
||||
}
|
||||
}
|
||||
return segs.join("");
|
||||
}
|
||||
export function prettifyError(error) {
|
||||
const lines = [];
|
||||
// sort by path length
|
||||
const issues = [...error.issues].sort((a, b) => (a.path ?? []).length - (b.path ?? []).length);
|
||||
// Process each issue
|
||||
for (const issue of issues) {
|
||||
lines.push(`✖ ${issue.message}`);
|
||||
if (issue.path?.length)
|
||||
lines.push(` → at ${toDotPath(issue.path)}`);
|
||||
}
|
||||
// Convert Map to formatted string
|
||||
return lines.join("\n");
|
||||
}
|
||||
+70
@@ -0,0 +1,70 @@
|
||||
"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
|
||||
for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
|
||||
};
|
||||
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.JSONSchema = exports.JSONSchemaGenerator = exports.toJSONSchema = exports.locales = exports.regexes = exports.toZod = exports.util = void 0;
|
||||
__exportStar(require("./core.cjs"), exports);
|
||||
__exportStar(require("./parse.cjs"), exports);
|
||||
__exportStar(require("./errors.cjs"), exports);
|
||||
__exportStar(require("./schemas.cjs"), exports);
|
||||
__exportStar(require("./memoizer.cjs"), exports);
|
||||
__exportStar(require("./checks.cjs"), exports);
|
||||
__exportStar(require("./versions.cjs"), exports);
|
||||
exports.util = __importStar(require("./util.cjs"));
|
||||
var util_js_1 = require("./util.cjs");
|
||||
Object.defineProperty(exports, "toZod", { enumerable: true, get: function () { return util_js_1.toZod; } });
|
||||
exports.regexes = __importStar(require("./regexes.cjs"));
|
||||
exports.locales = __importStar(require("../locales/index.cjs"));
|
||||
__exportStar(require("./registries.cjs"), exports);
|
||||
__exportStar(require("./doc.cjs"), exports);
|
||||
__exportStar(require("./compile.cjs"), exports);
|
||||
__exportStar(require("./api.cjs"), exports);
|
||||
__exportStar(require("./to-json-schema.cjs"), exports);
|
||||
var json_schema_processors_js_1 = require("./json-schema-processors.cjs");
|
||||
Object.defineProperty(exports, "toJSONSchema", { enumerable: true, get: function () { return json_schema_processors_js_1.toJSONSchema; } });
|
||||
var json_schema_generator_js_1 = require("./json-schema-generator.cjs");
|
||||
Object.defineProperty(exports, "JSONSchemaGenerator", { enumerable: true, get: function () { return json_schema_generator_js_1.JSONSchemaGenerator; } });
|
||||
exports.JSONSchema = __importStar(require("./json-schema.cjs"));
|
||||
|
||||
// seal-cjs-exports
|
||||
(function () {
|
||||
var keys = Object.getOwnPropertyNames(exports);
|
||||
for (var i = 0; i < keys.length; i++) {
|
||||
var desc = Object.getOwnPropertyDescriptor(exports, keys[i]);
|
||||
if (!desc || !desc.get || !desc.configurable) continue;
|
||||
var value;
|
||||
try {
|
||||
value = desc.get();
|
||||
} catch (e) {
|
||||
continue;
|
||||
}
|
||||
// a circular require may not have settled this one yet, so leave it live
|
||||
if (value === undefined) continue;
|
||||
Object.defineProperty(exports, keys[i], { value: value, writable: false, enumerable: desc.enumerable, configurable: false });
|
||||
}
|
||||
Object.freeze(exports);
|
||||
})();
|
||||
+19
@@ -0,0 +1,19 @@
|
||||
export * from "./core.cjs";
|
||||
export * from "./parse.cjs";
|
||||
export * from "./errors.cjs";
|
||||
export * from "./schemas.cjs";
|
||||
export * from "./memoizer.cjs";
|
||||
export * from "./checks.cjs";
|
||||
export * from "./versions.cjs";
|
||||
export * as util from "./util.cjs";
|
||||
export { toZod } from "./util.cjs";
|
||||
export * as regexes from "./regexes.cjs";
|
||||
export * as locales from "../locales/index.cjs";
|
||||
export * from "./registries.cjs";
|
||||
export * from "./doc.cjs";
|
||||
export * from "./compile.cjs";
|
||||
export * from "./api.cjs";
|
||||
export * from "./to-json-schema.cjs";
|
||||
export { toJSONSchema } from "./json-schema-processors.cjs";
|
||||
export { JSONSchemaGenerator } from "./json-schema-generator.cjs";
|
||||
export * as JSONSchema from "./json-schema.cjs";
|
||||
+19
@@ -0,0 +1,19 @@
|
||||
export * from "./core.js";
|
||||
export * from "./parse.js";
|
||||
export * from "./errors.js";
|
||||
export * from "./schemas.js";
|
||||
export * from "./memoizer.js";
|
||||
export * from "./checks.js";
|
||||
export * from "./versions.js";
|
||||
export * as util from "./util.js";
|
||||
export { toZod } from "./util.js";
|
||||
export * as regexes from "./regexes.js";
|
||||
export * as locales from "../locales/index.js";
|
||||
export * from "./registries.js";
|
||||
export * from "./doc.js";
|
||||
export * from "./compile.js";
|
||||
export * from "./api.js";
|
||||
export * from "./to-json-schema.js";
|
||||
export { toJSONSchema } from "./json-schema-processors.js";
|
||||
export { JSONSchemaGenerator } from "./json-schema-generator.js";
|
||||
export * as JSONSchema from "./json-schema.js";
|
||||
+19
@@ -0,0 +1,19 @@
|
||||
export * from "./core.js";
|
||||
export * from "./parse.js";
|
||||
export * from "./errors.js";
|
||||
export * from "./schemas.js";
|
||||
export * from "./memoizer.js";
|
||||
export * from "./checks.js";
|
||||
export * from "./versions.js";
|
||||
export * as util from "./util.js";
|
||||
export { toZod } from "./util.js";
|
||||
export * as regexes from "./regexes.js";
|
||||
export * as locales from "../locales/index.js";
|
||||
export * from "./registries.js";
|
||||
export * from "./doc.js";
|
||||
export * from "./compile.js";
|
||||
export * from "./api.js";
|
||||
export * from "./to-json-schema.js";
|
||||
export { toJSONSchema } from "./json-schema-processors.js";
|
||||
export { JSONSchemaGenerator } from "./json-schema-generator.js";
|
||||
export * as JSONSchema from "./json-schema.js";
|
||||
+122
@@ -0,0 +1,122 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.JSONSchemaGenerator = void 0;
|
||||
const json_schema_processors_js_1 = require("./json-schema-processors.cjs");
|
||||
const to_json_schema_js_1 = require("./to-json-schema.cjs");
|
||||
/**
|
||||
* Legacy class-based interface for JSON Schema generation.
|
||||
* This class wraps the new functional implementation to provide backward compatibility.
|
||||
*
|
||||
* @deprecated Use the `toJSONSchema` function instead for new code.
|
||||
*
|
||||
* @example
|
||||
* ```typescript
|
||||
* // Legacy usage (still supported)
|
||||
* const gen = new JSONSchemaGenerator({ target: "draft-07" });
|
||||
* gen.process(schema);
|
||||
* const result = gen.emit(schema);
|
||||
*
|
||||
* // Preferred modern usage
|
||||
* const result = toJSONSchema(schema, { target: "draft-07" });
|
||||
* ```
|
||||
*/
|
||||
class JSONSchemaGenerator {
|
||||
/** @deprecated Access via ctx instead */
|
||||
get metadataRegistry() {
|
||||
return this.ctx.metadataRegistry;
|
||||
}
|
||||
/** @deprecated Access via ctx instead */
|
||||
get target() {
|
||||
return this.ctx.target;
|
||||
}
|
||||
// annotated so the .d.cts emits an indexed access rather than an inline `import()` of an ESM path
|
||||
/** @deprecated Access via ctx instead */
|
||||
get unrepresentable() {
|
||||
return this.ctx.unrepresentable;
|
||||
}
|
||||
/** @deprecated Access via ctx instead */
|
||||
get override() {
|
||||
return this.ctx.override;
|
||||
}
|
||||
/** @deprecated Access via ctx instead */
|
||||
get io() {
|
||||
return this.ctx.io;
|
||||
}
|
||||
/** @deprecated Access via ctx instead */
|
||||
get counter() {
|
||||
return this.ctx.counter;
|
||||
}
|
||||
set counter(value) {
|
||||
this.ctx.counter = value;
|
||||
}
|
||||
/** @deprecated Access via ctx instead */
|
||||
get seen() {
|
||||
return this.ctx.seen;
|
||||
}
|
||||
constructor(params) {
|
||||
// Normalize target for internal context
|
||||
let normalizedTarget = params?.target ?? "draft-2020-12";
|
||||
if (normalizedTarget === "draft-4")
|
||||
normalizedTarget = "draft-04";
|
||||
if (normalizedTarget === "draft-7")
|
||||
normalizedTarget = "draft-07";
|
||||
this.ctx = (0, to_json_schema_js_1.initializeContext)({
|
||||
processors: json_schema_processors_js_1.allProcessors,
|
||||
target: normalizedTarget,
|
||||
...(params?.metadata && { metadata: params.metadata }),
|
||||
...(params?.unrepresentable && { unrepresentable: params.unrepresentable }),
|
||||
...(params?.override && { override: params.override }),
|
||||
...(params?.io && { io: params.io }),
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Process a schema to prepare it for JSON Schema generation.
|
||||
* This must be called before emit().
|
||||
*/
|
||||
process(schema, _params = { path: [], schemaPath: [] }) {
|
||||
return (0, to_json_schema_js_1.processSchema)(schema, this.ctx, _params);
|
||||
}
|
||||
/**
|
||||
* Emit the final JSON Schema after processing.
|
||||
* Must call process() first.
|
||||
*/
|
||||
emit(schema, _params) {
|
||||
// Apply emit params to the context
|
||||
if (_params) {
|
||||
if (_params.cycles)
|
||||
this.ctx.cycles = _params.cycles;
|
||||
if (_params.reused)
|
||||
this.ctx.reused = _params.reused;
|
||||
if (_params.external)
|
||||
this.ctx.external = _params.external;
|
||||
}
|
||||
// extractDefs/finalize skip their whole-map passes when they have already run for this `external`, but they also branch on `cycles`, `reused`, `seen.count` and the metadata registry — any of which can change between emits, including with no params at all. Drop the guards so the passes re-run. The registry conversion calls extractDefs/finalize directly and never routes through here, so it keeps skipping them.
|
||||
this.ctx.sharedDefsExtractedFor = undefined;
|
||||
this.ctx.sharedEmitDoneFor = undefined;
|
||||
(0, to_json_schema_js_1.extractDefs)(this.ctx, schema);
|
||||
const result = (0, to_json_schema_js_1.finalize)(this.ctx, schema);
|
||||
// Strip ~standard property to match old implementation's return type
|
||||
const { "~standard": _, ...plainResult } = result;
|
||||
return plainResult;
|
||||
}
|
||||
}
|
||||
exports.JSONSchemaGenerator = JSONSchemaGenerator;
|
||||
|
||||
// seal-cjs-exports
|
||||
(function () {
|
||||
var keys = Object.getOwnPropertyNames(exports);
|
||||
for (var i = 0; i < keys.length; i++) {
|
||||
var desc = Object.getOwnPropertyDescriptor(exports, keys[i]);
|
||||
if (!desc || !desc.get || !desc.configurable) continue;
|
||||
var value;
|
||||
try {
|
||||
value = desc.get();
|
||||
} catch (e) {
|
||||
continue;
|
||||
}
|
||||
// a circular require may not have settled this one yet, so leave it live
|
||||
if (value === undefined) continue;
|
||||
Object.defineProperty(exports, keys[i], { value: value, writable: false, enumerable: desc.enumerable, configurable: false });
|
||||
}
|
||||
Object.freeze(exports);
|
||||
})();
|
||||
+65
@@ -0,0 +1,65 @@
|
||||
import type * as JSONSchema from "./json-schema.cjs";
|
||||
import type { $ZodRegistry } from "./registries.cjs";
|
||||
import type * as schemas from "./schemas.cjs";
|
||||
import { type JSONSchemaGeneratorParams, type ProcessParams, type Seen, type ToJSONSchemaContext } from "./to-json-schema.cjs";
|
||||
/**
|
||||
* Parameters for the emit method of JSONSchemaGenerator.
|
||||
* @deprecated Use toJSONSchema function instead
|
||||
*/
|
||||
export type EmitParams = Pick<JSONSchemaGeneratorParams, "cycles" | "reused" | "external">;
|
||||
/**
|
||||
* Parameters for JSONSchemaGenerator constructor.
|
||||
* @deprecated Use toJSONSchema function instead
|
||||
*/
|
||||
type JSONSchemaGeneratorConstructorParams = Pick<JSONSchemaGeneratorParams, "metadata" | "target" | "unrepresentable" | "override" | "io">;
|
||||
/**
|
||||
* Legacy class-based interface for JSON Schema generation.
|
||||
* This class wraps the new functional implementation to provide backward compatibility.
|
||||
*
|
||||
* @deprecated Use the `toJSONSchema` function instead for new code.
|
||||
*
|
||||
* @example
|
||||
* ```typescript
|
||||
* // Legacy usage (still supported)
|
||||
* const gen = new JSONSchemaGenerator({ target: "draft-07" });
|
||||
* gen.process(schema);
|
||||
* const result = gen.emit(schema);
|
||||
*
|
||||
* // Preferred modern usage
|
||||
* const result = toJSONSchema(schema, { target: "draft-07" });
|
||||
* ```
|
||||
*/
|
||||
export declare class JSONSchemaGenerator {
|
||||
private ctx;
|
||||
/** @deprecated Access via ctx instead */
|
||||
get metadataRegistry(): $ZodRegistry<Record<string, any>>;
|
||||
/** @deprecated Access via ctx instead */
|
||||
get target(): ({} & string) | "draft-2020-12" | "draft-07" | "openapi-3.0" | "draft-04";
|
||||
/** @deprecated Access via ctx instead */
|
||||
get unrepresentable(): ToJSONSchemaContext["unrepresentable"];
|
||||
/** @deprecated Access via ctx instead */
|
||||
get override(): (ctx: {
|
||||
zodSchema: schemas.$ZodType;
|
||||
jsonSchema: JSONSchema.BaseSchema;
|
||||
path: (string | number)[];
|
||||
}) => void;
|
||||
/** @deprecated Access via ctx instead */
|
||||
get io(): "input" | "output";
|
||||
/** @deprecated Access via ctx instead */
|
||||
get counter(): number;
|
||||
set counter(value: number);
|
||||
/** @deprecated Access via ctx instead */
|
||||
get seen(): Map<schemas.$ZodType, Seen>;
|
||||
constructor(params?: JSONSchemaGeneratorConstructorParams);
|
||||
/**
|
||||
* Process a schema to prepare it for JSON Schema generation.
|
||||
* This must be called before emit().
|
||||
*/
|
||||
process(schema: schemas.$ZodType, _params?: ProcessParams): JSONSchema.BaseSchema;
|
||||
/**
|
||||
* Emit the final JSON Schema after processing.
|
||||
* Must call process() first.
|
||||
*/
|
||||
emit(schema: schemas.$ZodType, _params?: EmitParams): JSONSchema.BaseSchema;
|
||||
}
|
||||
export {};
|
||||
+65
@@ -0,0 +1,65 @@
|
||||
import type * as JSONSchema from "./json-schema.js";
|
||||
import type { $ZodRegistry } from "./registries.js";
|
||||
import type * as schemas from "./schemas.js";
|
||||
import { type JSONSchemaGeneratorParams, type ProcessParams, type Seen, type ToJSONSchemaContext } from "./to-json-schema.js";
|
||||
/**
|
||||
* Parameters for the emit method of JSONSchemaGenerator.
|
||||
* @deprecated Use toJSONSchema function instead
|
||||
*/
|
||||
export type EmitParams = Pick<JSONSchemaGeneratorParams, "cycles" | "reused" | "external">;
|
||||
/**
|
||||
* Parameters for JSONSchemaGenerator constructor.
|
||||
* @deprecated Use toJSONSchema function instead
|
||||
*/
|
||||
type JSONSchemaGeneratorConstructorParams = Pick<JSONSchemaGeneratorParams, "metadata" | "target" | "unrepresentable" | "override" | "io">;
|
||||
/**
|
||||
* Legacy class-based interface for JSON Schema generation.
|
||||
* This class wraps the new functional implementation to provide backward compatibility.
|
||||
*
|
||||
* @deprecated Use the `toJSONSchema` function instead for new code.
|
||||
*
|
||||
* @example
|
||||
* ```typescript
|
||||
* // Legacy usage (still supported)
|
||||
* const gen = new JSONSchemaGenerator({ target: "draft-07" });
|
||||
* gen.process(schema);
|
||||
* const result = gen.emit(schema);
|
||||
*
|
||||
* // Preferred modern usage
|
||||
* const result = toJSONSchema(schema, { target: "draft-07" });
|
||||
* ```
|
||||
*/
|
||||
export declare class JSONSchemaGenerator {
|
||||
private ctx;
|
||||
/** @deprecated Access via ctx instead */
|
||||
get metadataRegistry(): $ZodRegistry<Record<string, any>>;
|
||||
/** @deprecated Access via ctx instead */
|
||||
get target(): ({} & string) | "draft-2020-12" | "draft-07" | "openapi-3.0" | "draft-04";
|
||||
/** @deprecated Access via ctx instead */
|
||||
get unrepresentable(): ToJSONSchemaContext["unrepresentable"];
|
||||
/** @deprecated Access via ctx instead */
|
||||
get override(): (ctx: {
|
||||
zodSchema: schemas.$ZodType;
|
||||
jsonSchema: JSONSchema.BaseSchema;
|
||||
path: (string | number)[];
|
||||
}) => void;
|
||||
/** @deprecated Access via ctx instead */
|
||||
get io(): "input" | "output";
|
||||
/** @deprecated Access via ctx instead */
|
||||
get counter(): number;
|
||||
set counter(value: number);
|
||||
/** @deprecated Access via ctx instead */
|
||||
get seen(): Map<schemas.$ZodType, Seen>;
|
||||
constructor(params?: JSONSchemaGeneratorConstructorParams);
|
||||
/**
|
||||
* Process a schema to prepare it for JSON Schema generation.
|
||||
* This must be called before emit().
|
||||
*/
|
||||
process(schema: schemas.$ZodType, _params?: ProcessParams): JSONSchema.BaseSchema;
|
||||
/**
|
||||
* Emit the final JSON Schema after processing.
|
||||
* Must call process() first.
|
||||
*/
|
||||
emit(schema: schemas.$ZodType, _params?: EmitParams): JSONSchema.BaseSchema;
|
||||
}
|
||||
export {};
|
||||
+99
@@ -0,0 +1,99 @@
|
||||
import { allProcessors } from "./json-schema-processors.js";
|
||||
import { extractDefs, finalize, initializeContext, processSchema, } from "./to-json-schema.js";
|
||||
/**
|
||||
* Legacy class-based interface for JSON Schema generation.
|
||||
* This class wraps the new functional implementation to provide backward compatibility.
|
||||
*
|
||||
* @deprecated Use the `toJSONSchema` function instead for new code.
|
||||
*
|
||||
* @example
|
||||
* ```typescript
|
||||
* // Legacy usage (still supported)
|
||||
* const gen = new JSONSchemaGenerator({ target: "draft-07" });
|
||||
* gen.process(schema);
|
||||
* const result = gen.emit(schema);
|
||||
*
|
||||
* // Preferred modern usage
|
||||
* const result = toJSONSchema(schema, { target: "draft-07" });
|
||||
* ```
|
||||
*/
|
||||
export class JSONSchemaGenerator {
|
||||
/** @deprecated Access via ctx instead */
|
||||
get metadataRegistry() {
|
||||
return this.ctx.metadataRegistry;
|
||||
}
|
||||
/** @deprecated Access via ctx instead */
|
||||
get target() {
|
||||
return this.ctx.target;
|
||||
}
|
||||
// annotated so the .d.cts emits an indexed access rather than an inline `import()` of an ESM path
|
||||
/** @deprecated Access via ctx instead */
|
||||
get unrepresentable() {
|
||||
return this.ctx.unrepresentable;
|
||||
}
|
||||
/** @deprecated Access via ctx instead */
|
||||
get override() {
|
||||
return this.ctx.override;
|
||||
}
|
||||
/** @deprecated Access via ctx instead */
|
||||
get io() {
|
||||
return this.ctx.io;
|
||||
}
|
||||
/** @deprecated Access via ctx instead */
|
||||
get counter() {
|
||||
return this.ctx.counter;
|
||||
}
|
||||
set counter(value) {
|
||||
this.ctx.counter = value;
|
||||
}
|
||||
/** @deprecated Access via ctx instead */
|
||||
get seen() {
|
||||
return this.ctx.seen;
|
||||
}
|
||||
constructor(params) {
|
||||
// Normalize target for internal context
|
||||
let normalizedTarget = params?.target ?? "draft-2020-12";
|
||||
if (normalizedTarget === "draft-4")
|
||||
normalizedTarget = "draft-04";
|
||||
if (normalizedTarget === "draft-7")
|
||||
normalizedTarget = "draft-07";
|
||||
this.ctx = initializeContext({
|
||||
processors: allProcessors,
|
||||
target: normalizedTarget,
|
||||
...(params?.metadata && { metadata: params.metadata }),
|
||||
...(params?.unrepresentable && { unrepresentable: params.unrepresentable }),
|
||||
...(params?.override && { override: params.override }),
|
||||
...(params?.io && { io: params.io }),
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Process a schema to prepare it for JSON Schema generation.
|
||||
* This must be called before emit().
|
||||
*/
|
||||
process(schema, _params = { path: [], schemaPath: [] }) {
|
||||
return processSchema(schema, this.ctx, _params);
|
||||
}
|
||||
/**
|
||||
* Emit the final JSON Schema after processing.
|
||||
* Must call process() first.
|
||||
*/
|
||||
emit(schema, _params) {
|
||||
// Apply emit params to the context
|
||||
if (_params) {
|
||||
if (_params.cycles)
|
||||
this.ctx.cycles = _params.cycles;
|
||||
if (_params.reused)
|
||||
this.ctx.reused = _params.reused;
|
||||
if (_params.external)
|
||||
this.ctx.external = _params.external;
|
||||
}
|
||||
// extractDefs/finalize skip their whole-map passes when they have already run for this `external`, but they also branch on `cycles`, `reused`, `seen.count` and the metadata registry — any of which can change between emits, including with no params at all. Drop the guards so the passes re-run. The registry conversion calls extractDefs/finalize directly and never routes through here, so it keeps skipping them.
|
||||
this.ctx.sharedDefsExtractedFor = undefined;
|
||||
this.ctx.sharedEmitDoneFor = undefined;
|
||||
extractDefs(this.ctx, schema);
|
||||
const result = finalize(this.ctx, schema);
|
||||
// Strip ~standard property to match old implementation's return type
|
||||
const { "~standard": _, ...plainResult } = result;
|
||||
return plainResult;
|
||||
}
|
||||
}
|
||||
+929
@@ -0,0 +1,929 @@
|
||||
"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.allProcessors = exports.lazyProcessor = exports.optionalProcessor = exports.promiseProcessor = exports.readonlyProcessor = exports.pipeProcessor = exports.catchProcessor = exports.prefaultProcessor = exports.defaultProcessor = exports.nonoptionalProcessor = exports.nullableProcessor = exports.recordProcessor = exports.tupleProcessor = exports.intersectionProcessor = exports.unionProcessor = exports.objectProcessor = exports.arrayProcessor = exports.setProcessor = exports.mapProcessor = exports.transformProcessor = exports.functionProcessor = exports.customProcessor = exports.successProcessor = exports.fileProcessor = exports.templateLiteralProcessor = exports.nanProcessor = exports.literalProcessor = exports.enumProcessor = exports.dateProcessor = exports.unknownProcessor = exports.anyProcessor = exports.neverProcessor = exports.voidProcessor = exports.undefinedProcessor = exports.nullProcessor = exports.symbolProcessor = exports.bigintProcessor = exports.booleanProcessor = exports.numberProcessor = exports.stringProcessor = void 0;
|
||||
exports.aggregateChecks = aggregateChecks;
|
||||
exports.toJSONSchema = toJSONSchema;
|
||||
const regexes = __importStar(require("./regexes.cjs"));
|
||||
const schemas_js_1 = require("./schemas.cjs");
|
||||
const to_json_schema_js_1 = require("./to-json-schema.cjs");
|
||||
const util_js_1 = require("./util.cjs");
|
||||
const narrowMin = (agg, key, value) => {
|
||||
if (agg[key] === undefined || value > agg[key])
|
||||
agg[key] = value;
|
||||
};
|
||||
const narrowMax = (agg, key, value) => {
|
||||
if (agg[key] === undefined || value < agg[key])
|
||||
agg[key] = value;
|
||||
};
|
||||
const narrowBoth = (agg, value) => {
|
||||
narrowMin(agg, "minimum", value);
|
||||
narrowMax(agg, "maximum", value);
|
||||
};
|
||||
const addDivisor = (agg, value) => {
|
||||
agg.multipleOf ?? (agg.multipleOf = []);
|
||||
if (!agg.multipleOf.includes(value))
|
||||
agg.multipleOf.push(value);
|
||||
};
|
||||
const addPattern = (agg, pattern) => {
|
||||
agg.patterns ?? (agg.patterns = new Set());
|
||||
agg.patterns.add(pattern);
|
||||
};
|
||||
const intersectMime = (agg, mime) => {
|
||||
agg.mime = agg.mime ? agg.mime.filter((m) => mime.includes(m)) : [...mime];
|
||||
};
|
||||
// last-wins, matching the bag's historical write order; the flag keeps an integer format from being lost to a later float one
|
||||
const setFormat = (agg, format) => {
|
||||
agg.format = format;
|
||||
if (format.includes("int"))
|
||||
agg.isInt = true;
|
||||
};
|
||||
const minContributor = (agg, def) => narrowMin(agg, "minimum", def.minimum);
|
||||
const maxContributor = (agg, def) => narrowMax(agg, "maximum", def.maximum);
|
||||
const formatContributor = (ranges) => (agg, def) => {
|
||||
setFormat(agg, def.format);
|
||||
const [minimum, maximum] = ranges[def.format];
|
||||
narrowMin(agg, "minimum", minimum);
|
||||
narrowMax(agg, "maximum", maximum);
|
||||
};
|
||||
const contributors = {
|
||||
greater_than: (agg, def) => narrowMin(agg, def.inclusive ? "minimum" : "exclusiveMinimum", def.value),
|
||||
less_than: (agg, def) => narrowMax(agg, def.inclusive ? "maximum" : "exclusiveMaximum", def.value),
|
||||
multiple_of: (agg, def) => addDivisor(agg, def.value),
|
||||
number_format: formatContributor(util_js_1.NUMBER_FORMAT_RANGES),
|
||||
bigint_format: formatContributor(util_js_1.BIGINT_FORMAT_RANGES),
|
||||
min_length: minContributor,
|
||||
max_length: maxContributor,
|
||||
length_equals: (agg, def) => narrowBoth(agg, def.length),
|
||||
min_size: minContributor,
|
||||
max_size: maxContributor,
|
||||
size_equals: (agg, def) => narrowBoth(agg, def.size),
|
||||
string_format: (agg, def) => {
|
||||
setFormat(agg, def.format);
|
||||
if (def.pattern)
|
||||
addPattern(agg, def.pattern);
|
||||
if (def.format === "base64" || def.format === "base64url")
|
||||
agg.contentEncoding = def.format;
|
||||
if (def.local || def.precision === -1)
|
||||
agg.laxFormat = true;
|
||||
},
|
||||
mime_type: (agg, def) => intersectMime(agg, def.mime),
|
||||
};
|
||||
function aggregateChecks(schema) {
|
||||
const agg = {};
|
||||
const def = schema._zod.def;
|
||||
// a format schema is its own first check, same rule as $ZodType init
|
||||
const list = schema._zod.traits.has("$ZodCheck")
|
||||
? [schema, ...(def.checks ?? [])]
|
||||
: (def.checks ?? []);
|
||||
for (const ch of list)
|
||||
contributors[ch._zod.def.check]?.(agg, ch._zod.def);
|
||||
// reconcile with the bag so third-party onattach contributions still land; first-party residue is never tighter than the fold, so merging it back is idempotent for one and additive for the other
|
||||
const bag = schema._zod.bag;
|
||||
if (bag.minimum !== undefined)
|
||||
narrowMin(agg, "minimum", bag.minimum);
|
||||
if (bag.exclusiveMinimum !== undefined)
|
||||
narrowMin(agg, "exclusiveMinimum", bag.exclusiveMinimum);
|
||||
if (bag.maximum !== undefined)
|
||||
narrowMax(agg, "maximum", bag.maximum);
|
||||
if (bag.exclusiveMaximum !== undefined)
|
||||
narrowMax(agg, "exclusiveMaximum", bag.exclusiveMaximum);
|
||||
if (bag.multipleOf !== undefined)
|
||||
addDivisor(agg, bag.multipleOf);
|
||||
if (bag.format !== undefined) {
|
||||
agg.format ?? (agg.format = bag.format);
|
||||
if (bag.format.includes("int"))
|
||||
agg.isInt = true;
|
||||
}
|
||||
if (bag.mime)
|
||||
intersectMime(agg, bag.mime);
|
||||
for (const pattern of bag.patterns ?? [])
|
||||
addPattern(agg, pattern);
|
||||
return agg;
|
||||
}
|
||||
const formatMap = {
|
||||
guid: "uuid",
|
||||
url: "uri",
|
||||
datetime: "date-time",
|
||||
json_string: "json-string",
|
||||
regex: "", // do not set
|
||||
};
|
||||
// ==================== SIMPLE TYPE PROCESSORS ====================
|
||||
// the runtime patterns are lax so parse paths never overflow the regex stack; the emitted schema swaps in the exact block forms, which zod itself never executes
|
||||
const exactPatterns = new Map([
|
||||
[schemas_js_1.base64Charset, regexes.base64],
|
||||
[schemas_js_1.base64urlCharset, regexes.base64url],
|
||||
]);
|
||||
const exactPattern = (p) => exactPatterns.get(p) ?? p;
|
||||
const stringProcessor = (schema, ctx, _json, _params) => {
|
||||
const json = _json;
|
||||
json.type = "string";
|
||||
const { minimum, maximum, format, patterns, contentEncoding, laxFormat } = aggregateChecks(schema);
|
||||
if (typeof minimum === "number")
|
||||
json.minLength = minimum;
|
||||
if (typeof maximum === "number")
|
||||
json.maxLength = maximum;
|
||||
// custom pattern overrides format
|
||||
if (format) {
|
||||
json.format = formatMap[format] ?? format;
|
||||
if (json.format === "")
|
||||
delete json.format; // empty format is not valid
|
||||
// `z.iso.time()` is never full-time, and `laxFormat` carries the datetime shapes that also accept what their keyword forbids
|
||||
if (format === "time" || laxFormat) {
|
||||
delete json.format;
|
||||
}
|
||||
}
|
||||
if (contentEncoding)
|
||||
json.contentEncoding = contentEncoding;
|
||||
if (patterns && patterns.size > 0) {
|
||||
const patternList = [...patterns].map(exactPattern);
|
||||
if (patternList.length === 1)
|
||||
json.pattern = patternList[0].source;
|
||||
else if (patternList.length > 1) {
|
||||
json.allOf = [
|
||||
...patternList.map((regex) => ({
|
||||
...(ctx.target === "draft-07" || ctx.target === "draft-04" || ctx.target === "openapi-3.0"
|
||||
? { type: "string" }
|
||||
: {}),
|
||||
pattern: regex.source,
|
||||
})),
|
||||
];
|
||||
}
|
||||
}
|
||||
};
|
||||
exports.stringProcessor = stringProcessor;
|
||||
const numberProcessor = (schema, ctx, _json, params) => {
|
||||
const json = _json;
|
||||
const { minimum, maximum, multipleOf, exclusiveMaximum, exclusiveMinimum, isInt } = aggregateChecks(schema);
|
||||
json.type = isInt ? "integer" : "number";
|
||||
// when both minimum and exclusiveMinimum exist, pick the more restrictive one
|
||||
const exMin = typeof exclusiveMinimum === "number" && exclusiveMinimum >= (minimum ?? Number.NEGATIVE_INFINITY);
|
||||
const exMax = typeof exclusiveMaximum === "number" && exclusiveMaximum <= (maximum ?? Number.POSITIVE_INFINITY);
|
||||
const legacy = ctx.target === "draft-04" || ctx.target === "openapi-3.0";
|
||||
if (exMin) {
|
||||
if (legacy) {
|
||||
json.minimum = exclusiveMinimum;
|
||||
json.exclusiveMinimum = true;
|
||||
}
|
||||
else {
|
||||
json.exclusiveMinimum = exclusiveMinimum;
|
||||
}
|
||||
}
|
||||
else if (typeof minimum === "number") {
|
||||
json.minimum = minimum;
|
||||
}
|
||||
if (exMax) {
|
||||
if (legacy) {
|
||||
json.maximum = exclusiveMaximum;
|
||||
json.exclusiveMaximum = true;
|
||||
}
|
||||
else {
|
||||
json.exclusiveMaximum = exclusiveMaximum;
|
||||
}
|
||||
}
|
||||
else if (typeof maximum === "number") {
|
||||
json.maximum = maximum;
|
||||
}
|
||||
if (multipleOf) {
|
||||
// JSON Schema requires a divisor strictly greater than zero, and a non-finite one does not survive JSON at all. A negative divisor accepts exactly what its absolute value accepts, so it still maps; zero, NaN and Infinity have no keyword form.
|
||||
const divisors = new Set();
|
||||
for (const divisor of multipleOf) {
|
||||
if (Number.isFinite(divisor) && divisor !== 0)
|
||||
divisors.add(Math.abs(divisor));
|
||||
else
|
||||
(0, to_json_schema_js_1.handleUnrepresentable)(schema, ctx, json, params, `A multipleOf divisor of ${divisor} cannot be represented in JSON Schema`);
|
||||
}
|
||||
// chained divisors are a conjunction the keyword cannot carry alone, so extras ride an allOf, same as stacked patterns
|
||||
const [first, ...rest] = divisors;
|
||||
if (first !== undefined)
|
||||
json.multipleOf = first;
|
||||
if (rest.length)
|
||||
json.allOf = [...(json.allOf ?? []), ...rest.map((m) => ({ multipleOf: m }))];
|
||||
}
|
||||
};
|
||||
exports.numberProcessor = numberProcessor;
|
||||
const booleanProcessor = (_schema, _ctx, json, _params) => {
|
||||
json.type = "boolean";
|
||||
};
|
||||
exports.booleanProcessor = booleanProcessor;
|
||||
const bigintProcessor = (schema, ctx, json, params) => {
|
||||
(0, to_json_schema_js_1.handleUnrepresentable)(schema, ctx, json, params, "BigInt cannot be represented in JSON Schema");
|
||||
};
|
||||
exports.bigintProcessor = bigintProcessor;
|
||||
const symbolProcessor = (schema, ctx, json, params) => {
|
||||
(0, to_json_schema_js_1.handleUnrepresentable)(schema, ctx, json, params, "Symbols cannot be represented in JSON Schema");
|
||||
};
|
||||
exports.symbolProcessor = symbolProcessor;
|
||||
const nullProcessor = (_schema, ctx, json, _params) => {
|
||||
if (ctx.target === "openapi-3.0") {
|
||||
json.type = "string";
|
||||
json.nullable = true;
|
||||
json.enum = [null];
|
||||
}
|
||||
else {
|
||||
json.type = "null";
|
||||
}
|
||||
};
|
||||
exports.nullProcessor = nullProcessor;
|
||||
const undefinedProcessor = (schema, ctx, json, params) => {
|
||||
(0, to_json_schema_js_1.handleUnrepresentable)(schema, ctx, json, params, "Undefined cannot be represented in JSON Schema");
|
||||
};
|
||||
exports.undefinedProcessor = undefinedProcessor;
|
||||
const voidProcessor = (schema, ctx, json, params) => {
|
||||
(0, to_json_schema_js_1.handleUnrepresentable)(schema, ctx, json, params, "Void cannot be represented in JSON Schema");
|
||||
};
|
||||
exports.voidProcessor = voidProcessor;
|
||||
const neverProcessor = (_schema, _ctx, json, _params) => {
|
||||
json.not = {};
|
||||
};
|
||||
exports.neverProcessor = neverProcessor;
|
||||
const anyProcessor = (_schema, _ctx, _json, _params) => {
|
||||
// empty schema accepts anything
|
||||
};
|
||||
exports.anyProcessor = anyProcessor;
|
||||
const unknownProcessor = (_schema, _ctx, _json, _params) => {
|
||||
// empty schema accepts anything
|
||||
};
|
||||
exports.unknownProcessor = unknownProcessor;
|
||||
const dateProcessor = (schema, ctx, json, params) => {
|
||||
(0, to_json_schema_js_1.handleUnrepresentable)(schema, ctx, json, params, "Date cannot be represented in JSON Schema");
|
||||
};
|
||||
exports.dateProcessor = dateProcessor;
|
||||
const enumProcessor = (schema, _ctx, json, _params) => {
|
||||
const def = schema._zod.def;
|
||||
const values = (0, util_js_1.getEnumValues)(def.entries);
|
||||
// an empty enum accepts nothing, same as z.never()
|
||||
if (values.length === 0) {
|
||||
json.not = {};
|
||||
return;
|
||||
}
|
||||
// Number enums can have both string and number values
|
||||
if (values.every((v) => typeof v === "number"))
|
||||
json.type = "number";
|
||||
if (values.every((v) => typeof v === "string"))
|
||||
json.type = "string";
|
||||
json.enum = values;
|
||||
};
|
||||
exports.enumProcessor = enumProcessor;
|
||||
const literalProcessor = (schema, ctx, json, params) => {
|
||||
const def = schema._zod.def;
|
||||
// a literal with no values accepts nothing, same as z.never()
|
||||
if (def.values.length === 0) {
|
||||
json.not = {};
|
||||
return;
|
||||
}
|
||||
const vals = [];
|
||||
for (const val of def.values) {
|
||||
if (val === undefined) {
|
||||
// a custom schema replaces the whole literal, so there is nothing left to accumulate
|
||||
if ((0, to_json_schema_js_1.handleUnrepresentable)(schema, ctx, json, params, "Literal `undefined` cannot be represented in JSON Schema"))
|
||||
return;
|
||||
// otherwise do not add to vals
|
||||
}
|
||||
else if (typeof val === "bigint") {
|
||||
if ((0, to_json_schema_js_1.handleUnrepresentable)(schema, ctx, json, params, "BigInt literals cannot be represented in JSON Schema"))
|
||||
return;
|
||||
vals.push(Number(val));
|
||||
}
|
||||
else {
|
||||
vals.push(val);
|
||||
}
|
||||
}
|
||||
if (vals.length === 0) {
|
||||
// do nothing (an undefined literal was stripped)
|
||||
}
|
||||
else if (vals.length === 1) {
|
||||
const val = vals[0];
|
||||
json.type = val === null ? "null" : typeof val;
|
||||
if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") {
|
||||
json.enum = [val];
|
||||
}
|
||||
else {
|
||||
json.const = val;
|
||||
}
|
||||
}
|
||||
else {
|
||||
if (vals.every((v) => typeof v === "number"))
|
||||
json.type = "number";
|
||||
if (vals.every((v) => typeof v === "string"))
|
||||
json.type = "string";
|
||||
if (vals.every((v) => typeof v === "boolean"))
|
||||
json.type = "boolean";
|
||||
if (vals.every((v) => v === null))
|
||||
json.type = "null";
|
||||
json.enum = vals;
|
||||
}
|
||||
};
|
||||
exports.literalProcessor = literalProcessor;
|
||||
const nanProcessor = (schema, ctx, json, params) => {
|
||||
(0, to_json_schema_js_1.handleUnrepresentable)(schema, ctx, json, params, "NaN cannot be represented in JSON Schema");
|
||||
};
|
||||
exports.nanProcessor = nanProcessor;
|
||||
const templateLiteralProcessor = (schema, _ctx, json, _params) => {
|
||||
const _json = json;
|
||||
const pattern = schema._zod.pattern;
|
||||
if (!pattern)
|
||||
throw new Error("Pattern not found in template literal");
|
||||
_json.type = "string";
|
||||
_json.pattern = pattern.source;
|
||||
};
|
||||
exports.templateLiteralProcessor = templateLiteralProcessor;
|
||||
const fileProcessor = (schema, _ctx, json, _params) => {
|
||||
const _json = json;
|
||||
_json.type = "string";
|
||||
_json.format = "binary";
|
||||
_json.contentEncoding = "binary";
|
||||
const { minimum, maximum, mime } = aggregateChecks(schema);
|
||||
if (minimum !== undefined)
|
||||
_json.minLength = minimum;
|
||||
if (maximum !== undefined)
|
||||
_json.maxLength = maximum;
|
||||
if (!mime)
|
||||
return;
|
||||
// an empty intersection means the mime checks share no value, so nothing passes at runtime; `anyOf` must be non-empty, so the false schema is `not: {}`
|
||||
if (mime.length === 0)
|
||||
_json.not = {};
|
||||
else if (mime.length === 1)
|
||||
_json.contentMediaType = mime[0];
|
||||
// only contentMediaType differs, so the shared props stay at the root
|
||||
else
|
||||
_json.anyOf = mime.map((m) => ({ contentMediaType: m }));
|
||||
};
|
||||
exports.fileProcessor = fileProcessor;
|
||||
const successProcessor = (_schema, _ctx, json, _params) => {
|
||||
json.type = "boolean";
|
||||
};
|
||||
exports.successProcessor = successProcessor;
|
||||
const customProcessor = (schema, ctx, json, params) => {
|
||||
(0, to_json_schema_js_1.handleUnrepresentable)(schema, ctx, json, params, "Custom types cannot be represented in JSON Schema");
|
||||
};
|
||||
exports.customProcessor = customProcessor;
|
||||
const functionProcessor = (schema, ctx, json, params) => {
|
||||
(0, to_json_schema_js_1.handleUnrepresentable)(schema, ctx, json, params, "Function types cannot be represented in JSON Schema");
|
||||
};
|
||||
exports.functionProcessor = functionProcessor;
|
||||
const transformProcessor = (schema, ctx, json, params) => {
|
||||
(0, to_json_schema_js_1.handleUnrepresentable)(schema, ctx, json, params, "Transforms cannot be represented in JSON Schema");
|
||||
};
|
||||
exports.transformProcessor = transformProcessor;
|
||||
const mapProcessor = (schema, ctx, json, params) => {
|
||||
(0, to_json_schema_js_1.handleUnrepresentable)(schema, ctx, json, params, "Map cannot be represented in JSON Schema");
|
||||
};
|
||||
exports.mapProcessor = mapProcessor;
|
||||
const setProcessor = (schema, ctx, json, params) => {
|
||||
(0, to_json_schema_js_1.handleUnrepresentable)(schema, ctx, json, params, "Set cannot be represented in JSON Schema");
|
||||
};
|
||||
exports.setProcessor = setProcessor;
|
||||
// ==================== COMPOSITE TYPE PROCESSORS ====================
|
||||
const arrayProcessor = (schema, ctx, _json, params) => {
|
||||
const json = _json;
|
||||
const def = schema._zod.def;
|
||||
const { minimum, maximum } = aggregateChecks(schema);
|
||||
if (typeof minimum === "number")
|
||||
json.minItems = minimum;
|
||||
if (typeof maximum === "number")
|
||||
json.maxItems = maximum;
|
||||
json.type = "array";
|
||||
json.items = (0, to_json_schema_js_1.processSchema)(def.element, ctx, {
|
||||
...params,
|
||||
path: [...params.path, "items"],
|
||||
});
|
||||
};
|
||||
exports.arrayProcessor = arrayProcessor;
|
||||
// Transform and catch set `optin = "optional"` at runtime so the parser lets them observe an
|
||||
// absent key, but their declared input type stays required. An input JSON Schema describes the
|
||||
// declared type, so resolve past them to the schema that actually carries the optionality.
|
||||
// Used by both `objectProcessor` (for `required`) and `tupleProcessor` (for `minItems`); see
|
||||
// wiki/optionality.md, "The JSON Schema emitter reads the *static* value".
|
||||
function inputOptin(schema) {
|
||||
const def = schema._zod.def;
|
||||
if (def.type === "pipe" && def.in._zod.traits.has("$ZodTransform")) {
|
||||
return inputOptin(def.out);
|
||||
}
|
||||
if (def.type === "catch") {
|
||||
return inputOptin(def.innerType);
|
||||
}
|
||||
return schema._zod.optin;
|
||||
}
|
||||
const objectProcessor = (schema, ctx, _json, params) => {
|
||||
const json = _json;
|
||||
const def = schema._zod.def;
|
||||
const shape = def.shape;
|
||||
// dropping it while still emitting `additionalProperties: false` would emit a schema that rejects data this one requires
|
||||
const symbolKeys = Object.getOwnPropertySymbols(shape);
|
||||
if (symbolKeys.length &&
|
||||
(0, to_json_schema_js_1.handleUnrepresentable)(schema, ctx, json, params, "Symbol keys cannot be represented in JSON Schema")) {
|
||||
return;
|
||||
}
|
||||
json.type = "object";
|
||||
json.properties = {};
|
||||
for (const key in shape) {
|
||||
// assignProp so a __proto__ key becomes an own property instead of hitting the inherited setter on the plain {} we build into
|
||||
(0, util_js_1.assignProp)(json.properties, key, (0, to_json_schema_js_1.processSchema)(shape[key], ctx, {
|
||||
...params,
|
||||
path: [...params.path, "properties", key],
|
||||
}));
|
||||
}
|
||||
// required keys
|
||||
const requiredKeys = [];
|
||||
for (const key of Object.keys(shape)) {
|
||||
const field = def.shape[key];
|
||||
if (ctx.io === "input" ? inputOptin(field) === undefined : field._zod.optout === undefined) {
|
||||
requiredKeys.push(key);
|
||||
}
|
||||
}
|
||||
if (requiredKeys.length > 0) {
|
||||
json.required = requiredKeys;
|
||||
}
|
||||
// catchall
|
||||
if (def.catchall?._zod.def.type === "never") {
|
||||
// strict
|
||||
json.additionalProperties = false;
|
||||
}
|
||||
else if (!def.catchall) {
|
||||
// regular
|
||||
if (ctx.io === "output")
|
||||
json.additionalProperties = false;
|
||||
}
|
||||
else if (def.catchall) {
|
||||
json.additionalProperties = (0, to_json_schema_js_1.processSchema)(def.catchall, ctx, {
|
||||
...params,
|
||||
path: [...params.path, "additionalProperties"],
|
||||
});
|
||||
}
|
||||
};
|
||||
exports.objectProcessor = objectProcessor;
|
||||
const unionProcessor = (schema, ctx, json, params) => {
|
||||
const def = schema._zod.def;
|
||||
// Exclusive unions (inclusive === false) use oneOf (exactly one match) instead of anyOf (one or more matches). This includes both z.xor() and discriminated unions
|
||||
const isExclusive = def.inclusive === false;
|
||||
const options = def.options.map((x, i) => (0, to_json_schema_js_1.processSchema)(x, ctx, {
|
||||
...params,
|
||||
path: [...params.path, isExclusive ? "oneOf" : "anyOf", i],
|
||||
}));
|
||||
if (isExclusive) {
|
||||
json.oneOf = options;
|
||||
}
|
||||
else {
|
||||
json.anyOf = options;
|
||||
}
|
||||
};
|
||||
exports.unionProcessor = unionProcessor;
|
||||
const intersectionProcessor = (schema, ctx, json, params) => {
|
||||
const def = schema._zod.def;
|
||||
const a = (0, to_json_schema_js_1.processSchema)(def.left, ctx, {
|
||||
...params,
|
||||
path: [...params.path, "allOf", 0],
|
||||
});
|
||||
const b = (0, to_json_schema_js_1.processSchema)(def.right, ctx, {
|
||||
...params,
|
||||
path: [...params.path, "allOf", 1],
|
||||
});
|
||||
const isSimpleIntersection = (val) => "allOf" in val && Object.keys(val).length === 1;
|
||||
const allOf = [
|
||||
...(isSimpleIntersection(a) ? a.allOf : [a]),
|
||||
...(isSimpleIntersection(b) ? b.allOf : [b]),
|
||||
];
|
||||
json.allOf = allOf;
|
||||
// Recorded innermost first, so a nested intersection has already folded by the time this one is considered. The array is the handle rather than the schema, because a wrapper that inherits this schema shares the same array; `finalize` folds every object holding it. See `foldIntersection`.
|
||||
ctx.intersections.push(allOf);
|
||||
};
|
||||
exports.intersectionProcessor = intersectionProcessor;
|
||||
const tupleProcessor = (schema, ctx, _json, params) => {
|
||||
const json = _json;
|
||||
const def = schema._zod.def;
|
||||
json.type = "array";
|
||||
const prefixPath = ctx.target === "draft-2020-12" ? "prefixItems" : "items";
|
||||
const restPath = ctx.target === "draft-2020-12" ? "items" : ctx.target === "openapi-3.0" ? "items" : "additionalItems";
|
||||
const prefixItems = def.items.map((x, i) => (0, to_json_schema_js_1.processSchema)(x, ctx, {
|
||||
...params,
|
||||
path: [...params.path, prefixPath, i],
|
||||
}));
|
||||
const rest = def.rest
|
||||
? (0, to_json_schema_js_1.processSchema)(def.rest, ctx, {
|
||||
...params,
|
||||
path: [...params.path, restPath, ...(ctx.target === "openapi-3.0" ? [def.items.length] : [])],
|
||||
})
|
||||
: null;
|
||||
let minItems = def.items.length;
|
||||
while (minItems > 0) {
|
||||
const item = def.items[minItems - 1];
|
||||
const optional = ctx.io === "input" ? inputOptin(item) !== undefined : item._zod.optout === "optional";
|
||||
if (!optional)
|
||||
break;
|
||||
minItems--;
|
||||
}
|
||||
const maxItems = def.items.length;
|
||||
const isClosed = !def.rest;
|
||||
if (ctx.target === "draft-2020-12") {
|
||||
json.prefixItems = prefixItems;
|
||||
if (isClosed) {
|
||||
json.items = false;
|
||||
}
|
||||
else if (rest) {
|
||||
json.items = rest;
|
||||
}
|
||||
if (minItems > 0)
|
||||
json.minItems = minItems;
|
||||
if (isClosed)
|
||||
json.maxItems = maxItems;
|
||||
}
|
||||
else if (ctx.target === "openapi-3.0") {
|
||||
json.items = {
|
||||
anyOf: prefixItems,
|
||||
};
|
||||
if (rest) {
|
||||
json.items.anyOf.push(rest);
|
||||
}
|
||||
if (minItems > 0)
|
||||
json.minItems = minItems;
|
||||
if (isClosed)
|
||||
json.maxItems = maxItems;
|
||||
}
|
||||
else {
|
||||
json.items = prefixItems;
|
||||
if (isClosed) {
|
||||
json.additionalItems = false;
|
||||
}
|
||||
else if (rest) {
|
||||
json.additionalItems = rest;
|
||||
}
|
||||
if (minItems > 0)
|
||||
json.minItems = minItems;
|
||||
if (isClosed)
|
||||
json.maxItems = maxItems;
|
||||
}
|
||||
// explicit user-defined length checks take precedence
|
||||
const { minimum, maximum } = aggregateChecks(schema);
|
||||
if (typeof minimum === "number")
|
||||
json.minItems = minimum;
|
||||
if (typeof maximum === "number")
|
||||
json.maxItems = maximum;
|
||||
};
|
||||
exports.tupleProcessor = tupleProcessor;
|
||||
/** JSON object keys are always strings, so a numeric record key schema is re-expressed over the
|
||||
* numeric-string form the record parser matches. Deferred to `finalize`, after the flatten: a key
|
||||
* behind a wrapper only carries its own `type` before then, and a union key only has its branches.
|
||||
*
|
||||
* A numeric bound cannot apply to a property name, so `minimum` and its siblings are dropped rather
|
||||
* than carried over: keeping them beside `type: "string"` reproduces the match-nothing schema this
|
||||
* exists to fix. A key that carries one therefore emits wider than the record parses — `z.record(z.number().min(5), V)`
|
||||
* accepts `"3"` — which is the deliberate trade, since throwing on it would reject an ordinary schema
|
||||
* outright. */
|
||||
function stringifyKeyNames(bySchema, json, visited) {
|
||||
// an extracted key that rewrites cannot go on sharing its definition — the string form a key position needs is not the number form every other reference wants — so it inlines. One that does not rewrite keeps the `$ref`.
|
||||
if (json.$ref) {
|
||||
// a recursive key holds its own reference inside its definition, so a node already on the path is left alone rather than resolved again
|
||||
if (visited.has(json))
|
||||
return json;
|
||||
visited.add(json);
|
||||
const def = bySchema.get(json)?.def;
|
||||
if (!def)
|
||||
return json;
|
||||
const inlined = stringifyKeyNames(bySchema, def, visited);
|
||||
return inlined === def ? json : inlined;
|
||||
}
|
||||
for (const keyword of ["anyOf", "oneOf"]) {
|
||||
const branches = json[keyword];
|
||||
if (!Array.isArray(branches))
|
||||
continue;
|
||||
const mapped = branches.map((branch) => stringifyKeyNames(bySchema, branch, visited));
|
||||
// rebuilding regardless would detach a key that had nothing to re-express, dropping its `$ref` and leaking the internal `id`
|
||||
if (mapped.some((branch, i) => branch !== branches[i]))
|
||||
json = { ...json, [keyword]: mapped };
|
||||
}
|
||||
// a member that already admits a string leaves the key unconstrained, so the node's own type re-expresses only when every member is numeric
|
||||
const types = Array.isArray(json.type) ? json.type : [json.type];
|
||||
const numericType = !types.includes("string") && types.some((t) => t === "number" || t === "integer");
|
||||
// a heterogeneous key carries no type at all, so its numeric members are caught here instead
|
||||
const values = json.enum ?? (json.const !== undefined ? [json.const] : undefined);
|
||||
if (!numericType && !values?.some((v) => typeof v === "number"))
|
||||
return json;
|
||||
const { minimum, maximum, exclusiveMinimum, exclusiveMaximum, multipleOf, format, id, ...rest } = json;
|
||||
if (rest.enum)
|
||||
rest.enum = rest.enum.map((v) => (typeof v === "number" ? String(v) : v));
|
||||
else if (typeof rest.const === "number")
|
||||
rest.const = String(rest.const);
|
||||
// a heterogeneous key keeps its absent type: the stringified members already say what a key may be
|
||||
if (!numericType)
|
||||
return rest;
|
||||
rest.type = "string";
|
||||
if (!values)
|
||||
rest.pattern = (types.includes("number") ? regexes.number : regexes.integer).source;
|
||||
return rest;
|
||||
}
|
||||
/** Every record of one conversion, so the carriers are found in a single pass rather than once per record. */
|
||||
const pendingRecords = new WeakMap();
|
||||
function rewriteKeyNames(ctx) {
|
||||
// an extracted key is resolved by the object `extractToDef` left in its place, so the map is built once rather than searched per reference. `_zod.toJSONSchema` can hand the same object to two schemas, so the first entry carrying a body wins, as a search would have found it.
|
||||
const bySchema = new Map();
|
||||
for (const entry of ctx.seen.values()) {
|
||||
if (entry.def && !bySchema.has(entry.schema))
|
||||
bySchema.set(entry.schema, entry);
|
||||
}
|
||||
const rewrites = new Map();
|
||||
for (const record of pendingRecords.get(ctx) ?? []) {
|
||||
const seen = ctx.seen.get(record);
|
||||
const names = (seen?.def ?? seen?.schema)?.propertyNames;
|
||||
if (!names || names === true || rewrites.has(names))
|
||||
continue;
|
||||
const rewritten = stringifyKeyNames(bySchema, names, new Set());
|
||||
if (rewritten !== names)
|
||||
rewrites.set(names, rewritten);
|
||||
}
|
||||
if (!rewrites.size)
|
||||
return;
|
||||
// the flatten has already copied each record's own properties onto every wrapper by reference, and an extracted body is another such copy, so every carrier holding a rewritten key is updated together
|
||||
for (const entry of ctx.seen.values()) {
|
||||
for (const carrier of [entry.schema, entry.def]) {
|
||||
const rewritten = carrier && rewrites.get(carrier.propertyNames);
|
||||
if (rewritten)
|
||||
carrier.propertyNames = rewritten;
|
||||
}
|
||||
}
|
||||
}
|
||||
const recordProcessor = (schema, ctx, _json, params) => {
|
||||
const json = _json;
|
||||
const def = schema._zod.def;
|
||||
json.type = "object";
|
||||
// For looseRecord with regex patterns, use patternProperties. This correctly represents "only validate keys matching the pattern" semantics and composes well with allOf (intersections)
|
||||
const keyType = def.keyType;
|
||||
const patterns = aggregateChecks(keyType).patterns;
|
||||
if (def.mode === "loose" && patterns && patterns.size > 0) {
|
||||
// Use patternProperties for looseRecord with regex patterns
|
||||
const valueSchema = (0, to_json_schema_js_1.processSchema)(def.valueType, ctx, {
|
||||
...params,
|
||||
path: [...params.path, "patternProperties", "*"],
|
||||
});
|
||||
json.patternProperties = {};
|
||||
for (const pattern of patterns) {
|
||||
(0, util_js_1.assignProp)(json.patternProperties, exactPattern(pattern).source, valueSchema);
|
||||
}
|
||||
}
|
||||
else {
|
||||
// Default behavior: use propertyNames + additionalProperties
|
||||
if (ctx.target === "draft-07" || ctx.target === "draft-2020-12") {
|
||||
json.propertyNames = (0, to_json_schema_js_1.processSchema)(def.keyType, ctx, {
|
||||
...params,
|
||||
path: [...params.path, "propertyNames"],
|
||||
});
|
||||
let pending = pendingRecords.get(ctx);
|
||||
if (!pending) {
|
||||
pending = [];
|
||||
pendingRecords.set(ctx, pending);
|
||||
ctx.deferred.push(() => rewriteKeyNames(ctx));
|
||||
}
|
||||
pending.push(schema);
|
||||
}
|
||||
json.additionalProperties = (0, to_json_schema_js_1.processSchema)(def.valueType, ctx, {
|
||||
...params,
|
||||
path: [...params.path, "additionalProperties"],
|
||||
});
|
||||
}
|
||||
// Add required for keys with discrete values (enum, literal, etc.)
|
||||
const keyValues = keyType._zod.values;
|
||||
// Every key shares one value schema, so an optional-in value makes the whole key set omittable on input. Output keeps them: the exhaustive branch assigns every key, even one whose value came back undefined.
|
||||
const omittableOnInput = ctx.io === "input" && inputOptin(def.valueType) !== undefined;
|
||||
if (keyValues && !def.partial && !omittableOnInput) {
|
||||
const validKeyValues = [...keyValues].filter((v) => typeof v === "string" || typeof v === "number");
|
||||
if (validKeyValues.length > 0) {
|
||||
json.required = validKeyValues.map(String);
|
||||
}
|
||||
}
|
||||
};
|
||||
exports.recordProcessor = recordProcessor;
|
||||
const nullableProcessor = (schema, ctx, json, params) => {
|
||||
const def = schema._zod.def;
|
||||
const inner = (0, to_json_schema_js_1.processSchema)(def.innerType, ctx, params);
|
||||
const seen = ctx.seen.get(schema);
|
||||
if (ctx.target === "openapi-3.0") {
|
||||
seen.ref = def.innerType;
|
||||
json.nullable = true;
|
||||
}
|
||||
else {
|
||||
json.anyOf = [inner, { type: "null" }];
|
||||
}
|
||||
};
|
||||
exports.nullableProcessor = nullableProcessor;
|
||||
const nonoptionalProcessor = (schema, ctx, _json, params) => {
|
||||
const def = schema._zod.def;
|
||||
(0, to_json_schema_js_1.processSchema)(def.innerType, ctx, params);
|
||||
const seen = ctx.seen.get(schema);
|
||||
seen.ref = def.innerType;
|
||||
};
|
||||
exports.nonoptionalProcessor = nonoptionalProcessor;
|
||||
/** Round-trips a default value through JSON so the emitted schema is guaranteed to be valid JSON.
|
||||
* A BigInt has no reliable encoding, so it goes through `unrepresentable` like any other
|
||||
* unrepresentable value. Returns a sentinel when the caller must not write a default of its own. */
|
||||
const UNREPRESENTABLE_DEFAULT = Symbol();
|
||||
function serializeDefaultValue(value, schema, ctx, json, params) {
|
||||
let unrepresentable = false;
|
||||
const serialized = JSON.stringify(value, (_, val) => {
|
||||
if (typeof val !== "bigint")
|
||||
return val;
|
||||
unrepresentable = true;
|
||||
return null;
|
||||
});
|
||||
if (!unrepresentable)
|
||||
return JSON.parse(serialized);
|
||||
(0, to_json_schema_js_1.handleUnrepresentable)(schema, ctx, json, params, "BigInt defaults cannot be represented in JSON Schema");
|
||||
return UNREPRESENTABLE_DEFAULT;
|
||||
}
|
||||
const defaultProcessor = (schema, ctx, json, params) => {
|
||||
const def = schema._zod.def;
|
||||
(0, to_json_schema_js_1.processSchema)(def.innerType, ctx, params);
|
||||
const seen = ctx.seen.get(schema);
|
||||
seen.ref = def.innerType;
|
||||
const value = serializeDefaultValue(def.defaultValue, schema, ctx, json, params);
|
||||
if (value !== UNREPRESENTABLE_DEFAULT)
|
||||
json.default = value;
|
||||
};
|
||||
exports.defaultProcessor = defaultProcessor;
|
||||
const prefaultProcessor = (schema, ctx, json, params) => {
|
||||
const def = schema._zod.def;
|
||||
(0, to_json_schema_js_1.processSchema)(def.innerType, ctx, params);
|
||||
const seen = ctx.seen.get(schema);
|
||||
seen.ref = def.innerType;
|
||||
if (ctx.io !== "input")
|
||||
return;
|
||||
const value = serializeDefaultValue(def.defaultValue, schema, ctx, json, params);
|
||||
if (value !== UNREPRESENTABLE_DEFAULT)
|
||||
json._prefault = value;
|
||||
};
|
||||
exports.prefaultProcessor = prefaultProcessor;
|
||||
const catchProcessor = (schema, ctx, json, params) => {
|
||||
const def = schema._zod.def;
|
||||
(0, to_json_schema_js_1.processSchema)(def.innerType, ctx, params);
|
||||
const seen = ctx.seen.get(schema);
|
||||
seen.ref = def.innerType;
|
||||
let catchValue;
|
||||
try {
|
||||
catchValue = def.catchValue(undefined);
|
||||
}
|
||||
catch {
|
||||
(0, to_json_schema_js_1.handleUnrepresentable)(schema, ctx, json, params, "Dynamic catch values are not supported in JSON Schema");
|
||||
return;
|
||||
}
|
||||
json.default = catchValue;
|
||||
};
|
||||
exports.catchProcessor = catchProcessor;
|
||||
const pipeProcessor = (schema, ctx, _json, params) => {
|
||||
const def = schema._zod.def;
|
||||
const inIsTransform = def.in._zod.traits.has("$ZodTransform");
|
||||
const innerType = ctx.io === "input" ? (inIsTransform ? def.out : def.in) : def.out;
|
||||
(0, to_json_schema_js_1.processSchema)(innerType, ctx, params);
|
||||
const seen = ctx.seen.get(schema);
|
||||
seen.ref = innerType;
|
||||
};
|
||||
exports.pipeProcessor = pipeProcessor;
|
||||
const readonlyProcessor = (schema, ctx, json, params) => {
|
||||
const def = schema._zod.def;
|
||||
(0, to_json_schema_js_1.processSchema)(def.innerType, ctx, params);
|
||||
const seen = ctx.seen.get(schema);
|
||||
seen.ref = def.innerType;
|
||||
json.readOnly = true;
|
||||
};
|
||||
exports.readonlyProcessor = readonlyProcessor;
|
||||
const promiseProcessor = (schema, ctx, _json, params) => {
|
||||
const def = schema._zod.def;
|
||||
(0, to_json_schema_js_1.processSchema)(def.innerType, ctx, params);
|
||||
const seen = ctx.seen.get(schema);
|
||||
seen.ref = def.innerType;
|
||||
};
|
||||
exports.promiseProcessor = promiseProcessor;
|
||||
const optionalProcessor = (schema, ctx, _json, params) => {
|
||||
const def = schema._zod.def;
|
||||
(0, to_json_schema_js_1.processSchema)(def.innerType, ctx, params);
|
||||
const seen = ctx.seen.get(schema);
|
||||
seen.ref = def.innerType;
|
||||
};
|
||||
exports.optionalProcessor = optionalProcessor;
|
||||
const lazyProcessor = (schema, ctx, _json, params) => {
|
||||
const innerType = schema._zod.innerType;
|
||||
(0, to_json_schema_js_1.processSchema)(innerType, ctx, params);
|
||||
const seen = ctx.seen.get(schema);
|
||||
seen.ref = innerType;
|
||||
};
|
||||
exports.lazyProcessor = lazyProcessor;
|
||||
// ==================== ALL PROCESSORS ====================
|
||||
exports.allProcessors = {
|
||||
string: exports.stringProcessor,
|
||||
number: exports.numberProcessor,
|
||||
boolean: exports.booleanProcessor,
|
||||
bigint: exports.bigintProcessor,
|
||||
symbol: exports.symbolProcessor,
|
||||
null: exports.nullProcessor,
|
||||
undefined: exports.undefinedProcessor,
|
||||
void: exports.voidProcessor,
|
||||
never: exports.neverProcessor,
|
||||
any: exports.anyProcessor,
|
||||
unknown: exports.unknownProcessor,
|
||||
date: exports.dateProcessor,
|
||||
enum: exports.enumProcessor,
|
||||
literal: exports.literalProcessor,
|
||||
nan: exports.nanProcessor,
|
||||
template_literal: exports.templateLiteralProcessor,
|
||||
file: exports.fileProcessor,
|
||||
success: exports.successProcessor,
|
||||
custom: exports.customProcessor,
|
||||
function: exports.functionProcessor,
|
||||
transform: exports.transformProcessor,
|
||||
map: exports.mapProcessor,
|
||||
set: exports.setProcessor,
|
||||
array: exports.arrayProcessor,
|
||||
object: exports.objectProcessor,
|
||||
union: exports.unionProcessor,
|
||||
intersection: exports.intersectionProcessor,
|
||||
tuple: exports.tupleProcessor,
|
||||
record: exports.recordProcessor,
|
||||
nullable: exports.nullableProcessor,
|
||||
nonoptional: exports.nonoptionalProcessor,
|
||||
default: exports.defaultProcessor,
|
||||
prefault: exports.prefaultProcessor,
|
||||
catch: exports.catchProcessor,
|
||||
pipe: exports.pipeProcessor,
|
||||
readonly: exports.readonlyProcessor,
|
||||
promise: exports.promiseProcessor,
|
||||
optional: exports.optionalProcessor,
|
||||
lazy: exports.lazyProcessor,
|
||||
};
|
||||
function toJSONSchema(input, params) {
|
||||
if ("_idmap" in input) {
|
||||
// Registry case
|
||||
const registry = input;
|
||||
const ctx = (0, to_json_schema_js_1.initializeContext)({ ...params, processors: exports.allProcessors });
|
||||
const defs = {};
|
||||
// First pass: process all schemas to build the seen map
|
||||
for (const entry of registry._idmap.entries()) {
|
||||
const [_, schema] = entry;
|
||||
(0, to_json_schema_js_1.processSchema)(schema, ctx);
|
||||
}
|
||||
const schemas = {};
|
||||
const external = {
|
||||
registry,
|
||||
uri: params?.uri,
|
||||
defs,
|
||||
};
|
||||
// Update the context with external configuration
|
||||
ctx.external = external;
|
||||
// Second pass: emit each schema
|
||||
for (const entry of registry._idmap.entries()) {
|
||||
const [key, schema] = entry;
|
||||
(0, to_json_schema_js_1.extractDefs)(ctx, schema);
|
||||
(0, util_js_1.assignProp)(schemas, key, (0, to_json_schema_js_1.finalize)(ctx, schema));
|
||||
}
|
||||
if (Object.keys(defs).length > 0) {
|
||||
const defsSegment = ctx.target === "draft-2020-12" ? "$defs" : "definitions";
|
||||
schemas.__shared = {
|
||||
[defsSegment]: defs,
|
||||
};
|
||||
}
|
||||
return { schemas };
|
||||
}
|
||||
// Single schema case
|
||||
const ctx = (0, to_json_schema_js_1.initializeContext)({ ...params, processors: exports.allProcessors });
|
||||
(0, to_json_schema_js_1.processSchema)(input, ctx);
|
||||
(0, to_json_schema_js_1.extractDefs)(ctx, input);
|
||||
return (0, to_json_schema_js_1.finalize)(ctx, input);
|
||||
}
|
||||
|
||||
// seal-cjs-exports
|
||||
(function () {
|
||||
var keys = Object.getOwnPropertyNames(exports);
|
||||
for (var i = 0; i < keys.length; i++) {
|
||||
var desc = Object.getOwnPropertyDescriptor(exports, keys[i]);
|
||||
if (!desc || !desc.get || !desc.configurable) continue;
|
||||
var value;
|
||||
try {
|
||||
value = desc.get();
|
||||
} catch (e) {
|
||||
continue;
|
||||
}
|
||||
// a circular require may not have settled this one yet, so leave it live
|
||||
if (value === undefined) continue;
|
||||
Object.defineProperty(exports, keys[i], { value: value, writable: false, enumerable: desc.enumerable, configurable: false });
|
||||
}
|
||||
Object.freeze(exports);
|
||||
})();
|
||||
+65
@@ -0,0 +1,65 @@
|
||||
import type { $ZodRegistry } from "./registries.cjs";
|
||||
import type * as schemas from "./schemas.cjs";
|
||||
import { type Processor, type RegistryToJSONSchemaParams, type ToJSONSchemaParams, type ZodStandardJSONSchemaPayload } from "./to-json-schema.cjs";
|
||||
type Bound = number | bigint | Date;
|
||||
interface CheckAggregate<N extends Bound = Bound> {
|
||||
minimum?: N;
|
||||
maximum?: N;
|
||||
exclusiveMinimum?: N;
|
||||
exclusiveMaximum?: N;
|
||||
multipleOf?: number[];
|
||||
format?: string;
|
||||
isInt?: boolean;
|
||||
patterns?: Set<RegExp>;
|
||||
mime?: string[];
|
||||
contentEncoding?: string;
|
||||
laxFormat?: boolean;
|
||||
}
|
||||
export declare function aggregateChecks<N extends Bound = Bound>(schema: schemas.$ZodType): CheckAggregate<N>;
|
||||
export declare const stringProcessor: Processor<schemas.$ZodString>;
|
||||
export declare const numberProcessor: Processor<schemas.$ZodNumber>;
|
||||
export declare const booleanProcessor: Processor<schemas.$ZodBoolean>;
|
||||
export declare const bigintProcessor: Processor<schemas.$ZodBigInt>;
|
||||
export declare const symbolProcessor: Processor<schemas.$ZodSymbol>;
|
||||
export declare const nullProcessor: Processor<schemas.$ZodNull>;
|
||||
export declare const undefinedProcessor: Processor<schemas.$ZodUndefined>;
|
||||
export declare const voidProcessor: Processor<schemas.$ZodVoid>;
|
||||
export declare const neverProcessor: Processor<schemas.$ZodNever>;
|
||||
export declare const anyProcessor: Processor<schemas.$ZodAny>;
|
||||
export declare const unknownProcessor: Processor<schemas.$ZodUnknown>;
|
||||
export declare const dateProcessor: Processor<schemas.$ZodDate>;
|
||||
export declare const enumProcessor: Processor<schemas.$ZodEnum>;
|
||||
export declare const literalProcessor: Processor<schemas.$ZodLiteral>;
|
||||
export declare const nanProcessor: Processor<schemas.$ZodNaN>;
|
||||
export declare const templateLiteralProcessor: Processor<schemas.$ZodTemplateLiteral>;
|
||||
export declare const fileProcessor: Processor<schemas.$ZodFile>;
|
||||
export declare const successProcessor: Processor<schemas.$ZodSuccess>;
|
||||
export declare const customProcessor: Processor<schemas.$ZodCustom>;
|
||||
export declare const functionProcessor: Processor<schemas.$ZodFunction>;
|
||||
export declare const transformProcessor: Processor<schemas.$ZodTransform>;
|
||||
export declare const mapProcessor: Processor<schemas.$ZodMap>;
|
||||
export declare const setProcessor: Processor<schemas.$ZodSet>;
|
||||
export declare const arrayProcessor: Processor<schemas.$ZodArray>;
|
||||
export declare const objectProcessor: Processor<schemas.$ZodObject>;
|
||||
export declare const unionProcessor: Processor<schemas.$ZodUnion>;
|
||||
export declare const intersectionProcessor: Processor<schemas.$ZodIntersection>;
|
||||
export declare const tupleProcessor: Processor<schemas.$ZodTuple>;
|
||||
export declare const recordProcessor: Processor<schemas.$ZodRecord>;
|
||||
export declare const nullableProcessor: Processor<schemas.$ZodNullable>;
|
||||
export declare const nonoptionalProcessor: Processor<schemas.$ZodNonOptional>;
|
||||
export declare const defaultProcessor: Processor<schemas.$ZodDefault>;
|
||||
export declare const prefaultProcessor: Processor<schemas.$ZodPrefault>;
|
||||
export declare const catchProcessor: Processor<schemas.$ZodCatch>;
|
||||
export declare const pipeProcessor: Processor<schemas.$ZodPipe>;
|
||||
export declare const readonlyProcessor: Processor<schemas.$ZodReadonly>;
|
||||
export declare const promiseProcessor: Processor<schemas.$ZodPromise>;
|
||||
export declare const optionalProcessor: Processor<schemas.$ZodOptional>;
|
||||
export declare const lazyProcessor: Processor<schemas.$ZodLazy>;
|
||||
export declare const allProcessors: Record<string, Processor<any>>;
|
||||
export declare function toJSONSchema<T extends schemas.$ZodType>(schema: T, params?: ToJSONSchemaParams): ZodStandardJSONSchemaPayload<T>;
|
||||
export declare function toJSONSchema(registry: $ZodRegistry<{
|
||||
id?: string | undefined;
|
||||
}>, params?: RegistryToJSONSchemaParams): {
|
||||
schemas: Record<string, ZodStandardJSONSchemaPayload<schemas.$ZodType>>;
|
||||
};
|
||||
export {};
|
||||
+65
@@ -0,0 +1,65 @@
|
||||
import type { $ZodRegistry } from "./registries.js";
|
||||
import type * as schemas from "./schemas.js";
|
||||
import { type Processor, type RegistryToJSONSchemaParams, type ToJSONSchemaParams, type ZodStandardJSONSchemaPayload } from "./to-json-schema.js";
|
||||
type Bound = number | bigint | Date;
|
||||
interface CheckAggregate<N extends Bound = Bound> {
|
||||
minimum?: N;
|
||||
maximum?: N;
|
||||
exclusiveMinimum?: N;
|
||||
exclusiveMaximum?: N;
|
||||
multipleOf?: number[];
|
||||
format?: string;
|
||||
isInt?: boolean;
|
||||
patterns?: Set<RegExp>;
|
||||
mime?: string[];
|
||||
contentEncoding?: string;
|
||||
laxFormat?: boolean;
|
||||
}
|
||||
export declare function aggregateChecks<N extends Bound = Bound>(schema: schemas.$ZodType): CheckAggregate<N>;
|
||||
export declare const stringProcessor: Processor<schemas.$ZodString>;
|
||||
export declare const numberProcessor: Processor<schemas.$ZodNumber>;
|
||||
export declare const booleanProcessor: Processor<schemas.$ZodBoolean>;
|
||||
export declare const bigintProcessor: Processor<schemas.$ZodBigInt>;
|
||||
export declare const symbolProcessor: Processor<schemas.$ZodSymbol>;
|
||||
export declare const nullProcessor: Processor<schemas.$ZodNull>;
|
||||
export declare const undefinedProcessor: Processor<schemas.$ZodUndefined>;
|
||||
export declare const voidProcessor: Processor<schemas.$ZodVoid>;
|
||||
export declare const neverProcessor: Processor<schemas.$ZodNever>;
|
||||
export declare const anyProcessor: Processor<schemas.$ZodAny>;
|
||||
export declare const unknownProcessor: Processor<schemas.$ZodUnknown>;
|
||||
export declare const dateProcessor: Processor<schemas.$ZodDate>;
|
||||
export declare const enumProcessor: Processor<schemas.$ZodEnum>;
|
||||
export declare const literalProcessor: Processor<schemas.$ZodLiteral>;
|
||||
export declare const nanProcessor: Processor<schemas.$ZodNaN>;
|
||||
export declare const templateLiteralProcessor: Processor<schemas.$ZodTemplateLiteral>;
|
||||
export declare const fileProcessor: Processor<schemas.$ZodFile>;
|
||||
export declare const successProcessor: Processor<schemas.$ZodSuccess>;
|
||||
export declare const customProcessor: Processor<schemas.$ZodCustom>;
|
||||
export declare const functionProcessor: Processor<schemas.$ZodFunction>;
|
||||
export declare const transformProcessor: Processor<schemas.$ZodTransform>;
|
||||
export declare const mapProcessor: Processor<schemas.$ZodMap>;
|
||||
export declare const setProcessor: Processor<schemas.$ZodSet>;
|
||||
export declare const arrayProcessor: Processor<schemas.$ZodArray>;
|
||||
export declare const objectProcessor: Processor<schemas.$ZodObject>;
|
||||
export declare const unionProcessor: Processor<schemas.$ZodUnion>;
|
||||
export declare const intersectionProcessor: Processor<schemas.$ZodIntersection>;
|
||||
export declare const tupleProcessor: Processor<schemas.$ZodTuple>;
|
||||
export declare const recordProcessor: Processor<schemas.$ZodRecord>;
|
||||
export declare const nullableProcessor: Processor<schemas.$ZodNullable>;
|
||||
export declare const nonoptionalProcessor: Processor<schemas.$ZodNonOptional>;
|
||||
export declare const defaultProcessor: Processor<schemas.$ZodDefault>;
|
||||
export declare const prefaultProcessor: Processor<schemas.$ZodPrefault>;
|
||||
export declare const catchProcessor: Processor<schemas.$ZodCatch>;
|
||||
export declare const pipeProcessor: Processor<schemas.$ZodPipe>;
|
||||
export declare const readonlyProcessor: Processor<schemas.$ZodReadonly>;
|
||||
export declare const promiseProcessor: Processor<schemas.$ZodPromise>;
|
||||
export declare const optionalProcessor: Processor<schemas.$ZodOptional>;
|
||||
export declare const lazyProcessor: Processor<schemas.$ZodLazy>;
|
||||
export declare const allProcessors: Record<string, Processor<any>>;
|
||||
export declare function toJSONSchema<T extends schemas.$ZodType>(schema: T, params?: ToJSONSchemaParams): ZodStandardJSONSchemaPayload<T>;
|
||||
export declare function toJSONSchema(registry: $ZodRegistry<{
|
||||
id?: string | undefined;
|
||||
}>, params?: RegistryToJSONSchemaParams): {
|
||||
schemas: Record<string, ZodStandardJSONSchemaPayload<schemas.$ZodType>>;
|
||||
};
|
||||
export {};
|
||||
+843
@@ -0,0 +1,843 @@
|
||||
import * as regexes from "./regexes.js";
|
||||
import { base64Charset, base64urlCharset } from "./schemas.js";
|
||||
import { extractDefs, finalize, handleUnrepresentable, initializeContext, processSchema, } from "./to-json-schema.js";
|
||||
import { BIGINT_FORMAT_RANGES, NUMBER_FORMAT_RANGES, assignProp, getEnumValues } from "./util.js";
|
||||
const narrowMin = (agg, key, value) => {
|
||||
if (agg[key] === undefined || value > agg[key])
|
||||
agg[key] = value;
|
||||
};
|
||||
const narrowMax = (agg, key, value) => {
|
||||
if (agg[key] === undefined || value < agg[key])
|
||||
agg[key] = value;
|
||||
};
|
||||
const narrowBoth = (agg, value) => {
|
||||
narrowMin(agg, "minimum", value);
|
||||
narrowMax(agg, "maximum", value);
|
||||
};
|
||||
const addDivisor = (agg, value) => {
|
||||
agg.multipleOf ?? (agg.multipleOf = []);
|
||||
if (!agg.multipleOf.includes(value))
|
||||
agg.multipleOf.push(value);
|
||||
};
|
||||
const addPattern = (agg, pattern) => {
|
||||
agg.patterns ?? (agg.patterns = new Set());
|
||||
agg.patterns.add(pattern);
|
||||
};
|
||||
const intersectMime = (agg, mime) => {
|
||||
agg.mime = agg.mime ? agg.mime.filter((m) => mime.includes(m)) : [...mime];
|
||||
};
|
||||
// last-wins, matching the bag's historical write order; the flag keeps an integer format from being lost to a later float one
|
||||
const setFormat = (agg, format) => {
|
||||
agg.format = format;
|
||||
if (format.includes("int"))
|
||||
agg.isInt = true;
|
||||
};
|
||||
const minContributor = (agg, def) => narrowMin(agg, "minimum", def.minimum);
|
||||
const maxContributor = (agg, def) => narrowMax(agg, "maximum", def.maximum);
|
||||
const formatContributor = (ranges) => (agg, def) => {
|
||||
setFormat(agg, def.format);
|
||||
const [minimum, maximum] = ranges[def.format];
|
||||
narrowMin(agg, "minimum", minimum);
|
||||
narrowMax(agg, "maximum", maximum);
|
||||
};
|
||||
const contributors = {
|
||||
greater_than: (agg, def) => narrowMin(agg, def.inclusive ? "minimum" : "exclusiveMinimum", def.value),
|
||||
less_than: (agg, def) => narrowMax(agg, def.inclusive ? "maximum" : "exclusiveMaximum", def.value),
|
||||
multiple_of: (agg, def) => addDivisor(agg, def.value),
|
||||
number_format: formatContributor(NUMBER_FORMAT_RANGES),
|
||||
bigint_format: formatContributor(BIGINT_FORMAT_RANGES),
|
||||
min_length: minContributor,
|
||||
max_length: maxContributor,
|
||||
length_equals: (agg, def) => narrowBoth(agg, def.length),
|
||||
min_size: minContributor,
|
||||
max_size: maxContributor,
|
||||
size_equals: (agg, def) => narrowBoth(agg, def.size),
|
||||
string_format: (agg, def) => {
|
||||
setFormat(agg, def.format);
|
||||
if (def.pattern)
|
||||
addPattern(agg, def.pattern);
|
||||
if (def.format === "base64" || def.format === "base64url")
|
||||
agg.contentEncoding = def.format;
|
||||
if (def.local || def.precision === -1)
|
||||
agg.laxFormat = true;
|
||||
},
|
||||
mime_type: (agg, def) => intersectMime(agg, def.mime),
|
||||
};
|
||||
export function aggregateChecks(schema) {
|
||||
const agg = {};
|
||||
const def = schema._zod.def;
|
||||
// a format schema is its own first check, same rule as $ZodType init
|
||||
const list = schema._zod.traits.has("$ZodCheck")
|
||||
? [schema, ...(def.checks ?? [])]
|
||||
: (def.checks ?? []);
|
||||
for (const ch of list)
|
||||
contributors[ch._zod.def.check]?.(agg, ch._zod.def);
|
||||
// reconcile with the bag so third-party onattach contributions still land; first-party residue is never tighter than the fold, so merging it back is idempotent for one and additive for the other
|
||||
const bag = schema._zod.bag;
|
||||
if (bag.minimum !== undefined)
|
||||
narrowMin(agg, "minimum", bag.minimum);
|
||||
if (bag.exclusiveMinimum !== undefined)
|
||||
narrowMin(agg, "exclusiveMinimum", bag.exclusiveMinimum);
|
||||
if (bag.maximum !== undefined)
|
||||
narrowMax(agg, "maximum", bag.maximum);
|
||||
if (bag.exclusiveMaximum !== undefined)
|
||||
narrowMax(agg, "exclusiveMaximum", bag.exclusiveMaximum);
|
||||
if (bag.multipleOf !== undefined)
|
||||
addDivisor(agg, bag.multipleOf);
|
||||
if (bag.format !== undefined) {
|
||||
agg.format ?? (agg.format = bag.format);
|
||||
if (bag.format.includes("int"))
|
||||
agg.isInt = true;
|
||||
}
|
||||
if (bag.mime)
|
||||
intersectMime(agg, bag.mime);
|
||||
for (const pattern of bag.patterns ?? [])
|
||||
addPattern(agg, pattern);
|
||||
return agg;
|
||||
}
|
||||
const formatMap = {
|
||||
guid: "uuid",
|
||||
url: "uri",
|
||||
datetime: "date-time",
|
||||
json_string: "json-string",
|
||||
regex: "", // do not set
|
||||
};
|
||||
// ==================== SIMPLE TYPE PROCESSORS ====================
|
||||
// the runtime patterns are lax so parse paths never overflow the regex stack; the emitted schema swaps in the exact block forms, which zod itself never executes
|
||||
const exactPatterns = new Map([
|
||||
[base64Charset, regexes.base64],
|
||||
[base64urlCharset, regexes.base64url],
|
||||
]);
|
||||
const exactPattern = (p) => exactPatterns.get(p) ?? p;
|
||||
export const stringProcessor = (schema, ctx, _json, _params) => {
|
||||
const json = _json;
|
||||
json.type = "string";
|
||||
const { minimum, maximum, format, patterns, contentEncoding, laxFormat } = aggregateChecks(schema);
|
||||
if (typeof minimum === "number")
|
||||
json.minLength = minimum;
|
||||
if (typeof maximum === "number")
|
||||
json.maxLength = maximum;
|
||||
// custom pattern overrides format
|
||||
if (format) {
|
||||
json.format = formatMap[format] ?? format;
|
||||
if (json.format === "")
|
||||
delete json.format; // empty format is not valid
|
||||
// `z.iso.time()` is never full-time, and `laxFormat` carries the datetime shapes that also accept what their keyword forbids
|
||||
if (format === "time" || laxFormat) {
|
||||
delete json.format;
|
||||
}
|
||||
}
|
||||
if (contentEncoding)
|
||||
json.contentEncoding = contentEncoding;
|
||||
if (patterns && patterns.size > 0) {
|
||||
const patternList = [...patterns].map(exactPattern);
|
||||
if (patternList.length === 1)
|
||||
json.pattern = patternList[0].source;
|
||||
else if (patternList.length > 1) {
|
||||
json.allOf = [
|
||||
...patternList.map((regex) => ({
|
||||
...(ctx.target === "draft-07" || ctx.target === "draft-04" || ctx.target === "openapi-3.0"
|
||||
? { type: "string" }
|
||||
: {}),
|
||||
pattern: regex.source,
|
||||
})),
|
||||
];
|
||||
}
|
||||
}
|
||||
};
|
||||
export const numberProcessor = (schema, ctx, _json, params) => {
|
||||
const json = _json;
|
||||
const { minimum, maximum, multipleOf, exclusiveMaximum, exclusiveMinimum, isInt } = aggregateChecks(schema);
|
||||
json.type = isInt ? "integer" : "number";
|
||||
// when both minimum and exclusiveMinimum exist, pick the more restrictive one
|
||||
const exMin = typeof exclusiveMinimum === "number" && exclusiveMinimum >= (minimum ?? Number.NEGATIVE_INFINITY);
|
||||
const exMax = typeof exclusiveMaximum === "number" && exclusiveMaximum <= (maximum ?? Number.POSITIVE_INFINITY);
|
||||
const legacy = ctx.target === "draft-04" || ctx.target === "openapi-3.0";
|
||||
if (exMin) {
|
||||
if (legacy) {
|
||||
json.minimum = exclusiveMinimum;
|
||||
json.exclusiveMinimum = true;
|
||||
}
|
||||
else {
|
||||
json.exclusiveMinimum = exclusiveMinimum;
|
||||
}
|
||||
}
|
||||
else if (typeof minimum === "number") {
|
||||
json.minimum = minimum;
|
||||
}
|
||||
if (exMax) {
|
||||
if (legacy) {
|
||||
json.maximum = exclusiveMaximum;
|
||||
json.exclusiveMaximum = true;
|
||||
}
|
||||
else {
|
||||
json.exclusiveMaximum = exclusiveMaximum;
|
||||
}
|
||||
}
|
||||
else if (typeof maximum === "number") {
|
||||
json.maximum = maximum;
|
||||
}
|
||||
if (multipleOf) {
|
||||
// JSON Schema requires a divisor strictly greater than zero, and a non-finite one does not survive JSON at all. A negative divisor accepts exactly what its absolute value accepts, so it still maps; zero, NaN and Infinity have no keyword form.
|
||||
const divisors = new Set();
|
||||
for (const divisor of multipleOf) {
|
||||
if (Number.isFinite(divisor) && divisor !== 0)
|
||||
divisors.add(Math.abs(divisor));
|
||||
else
|
||||
handleUnrepresentable(schema, ctx, json, params, `A multipleOf divisor of ${divisor} cannot be represented in JSON Schema`);
|
||||
}
|
||||
// chained divisors are a conjunction the keyword cannot carry alone, so extras ride an allOf, same as stacked patterns
|
||||
const [first, ...rest] = divisors;
|
||||
if (first !== undefined)
|
||||
json.multipleOf = first;
|
||||
if (rest.length)
|
||||
json.allOf = [...(json.allOf ?? []), ...rest.map((m) => ({ multipleOf: m }))];
|
||||
}
|
||||
};
|
||||
export const booleanProcessor = (_schema, _ctx, json, _params) => {
|
||||
json.type = "boolean";
|
||||
};
|
||||
export const bigintProcessor = (schema, ctx, json, params) => {
|
||||
handleUnrepresentable(schema, ctx, json, params, "BigInt cannot be represented in JSON Schema");
|
||||
};
|
||||
export const symbolProcessor = (schema, ctx, json, params) => {
|
||||
handleUnrepresentable(schema, ctx, json, params, "Symbols cannot be represented in JSON Schema");
|
||||
};
|
||||
export const nullProcessor = (_schema, ctx, json, _params) => {
|
||||
if (ctx.target === "openapi-3.0") {
|
||||
json.type = "string";
|
||||
json.nullable = true;
|
||||
json.enum = [null];
|
||||
}
|
||||
else {
|
||||
json.type = "null";
|
||||
}
|
||||
};
|
||||
export const undefinedProcessor = (schema, ctx, json, params) => {
|
||||
handleUnrepresentable(schema, ctx, json, params, "Undefined cannot be represented in JSON Schema");
|
||||
};
|
||||
export const voidProcessor = (schema, ctx, json, params) => {
|
||||
handleUnrepresentable(schema, ctx, json, params, "Void cannot be represented in JSON Schema");
|
||||
};
|
||||
export const neverProcessor = (_schema, _ctx, json, _params) => {
|
||||
json.not = {};
|
||||
};
|
||||
export const anyProcessor = (_schema, _ctx, _json, _params) => {
|
||||
// empty schema accepts anything
|
||||
};
|
||||
export const unknownProcessor = (_schema, _ctx, _json, _params) => {
|
||||
// empty schema accepts anything
|
||||
};
|
||||
export const dateProcessor = (schema, ctx, json, params) => {
|
||||
handleUnrepresentable(schema, ctx, json, params, "Date cannot be represented in JSON Schema");
|
||||
};
|
||||
export const enumProcessor = (schema, _ctx, json, _params) => {
|
||||
const def = schema._zod.def;
|
||||
const values = getEnumValues(def.entries);
|
||||
// an empty enum accepts nothing, same as z.never()
|
||||
if (values.length === 0) {
|
||||
json.not = {};
|
||||
return;
|
||||
}
|
||||
// Number enums can have both string and number values
|
||||
if (values.every((v) => typeof v === "number"))
|
||||
json.type = "number";
|
||||
if (values.every((v) => typeof v === "string"))
|
||||
json.type = "string";
|
||||
json.enum = values;
|
||||
};
|
||||
export const literalProcessor = (schema, ctx, json, params) => {
|
||||
const def = schema._zod.def;
|
||||
// a literal with no values accepts nothing, same as z.never()
|
||||
if (def.values.length === 0) {
|
||||
json.not = {};
|
||||
return;
|
||||
}
|
||||
const vals = [];
|
||||
for (const val of def.values) {
|
||||
if (val === undefined) {
|
||||
// a custom schema replaces the whole literal, so there is nothing left to accumulate
|
||||
if (handleUnrepresentable(schema, ctx, json, params, "Literal `undefined` cannot be represented in JSON Schema"))
|
||||
return;
|
||||
// otherwise do not add to vals
|
||||
}
|
||||
else if (typeof val === "bigint") {
|
||||
if (handleUnrepresentable(schema, ctx, json, params, "BigInt literals cannot be represented in JSON Schema"))
|
||||
return;
|
||||
vals.push(Number(val));
|
||||
}
|
||||
else {
|
||||
vals.push(val);
|
||||
}
|
||||
}
|
||||
if (vals.length === 0) {
|
||||
// do nothing (an undefined literal was stripped)
|
||||
}
|
||||
else if (vals.length === 1) {
|
||||
const val = vals[0];
|
||||
json.type = val === null ? "null" : typeof val;
|
||||
if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") {
|
||||
json.enum = [val];
|
||||
}
|
||||
else {
|
||||
json.const = val;
|
||||
}
|
||||
}
|
||||
else {
|
||||
if (vals.every((v) => typeof v === "number"))
|
||||
json.type = "number";
|
||||
if (vals.every((v) => typeof v === "string"))
|
||||
json.type = "string";
|
||||
if (vals.every((v) => typeof v === "boolean"))
|
||||
json.type = "boolean";
|
||||
if (vals.every((v) => v === null))
|
||||
json.type = "null";
|
||||
json.enum = vals;
|
||||
}
|
||||
};
|
||||
export const nanProcessor = (schema, ctx, json, params) => {
|
||||
handleUnrepresentable(schema, ctx, json, params, "NaN cannot be represented in JSON Schema");
|
||||
};
|
||||
export const templateLiteralProcessor = (schema, _ctx, json, _params) => {
|
||||
const _json = json;
|
||||
const pattern = schema._zod.pattern;
|
||||
if (!pattern)
|
||||
throw new Error("Pattern not found in template literal");
|
||||
_json.type = "string";
|
||||
_json.pattern = pattern.source;
|
||||
};
|
||||
export const fileProcessor = (schema, _ctx, json, _params) => {
|
||||
const _json = json;
|
||||
_json.type = "string";
|
||||
_json.format = "binary";
|
||||
_json.contentEncoding = "binary";
|
||||
const { minimum, maximum, mime } = aggregateChecks(schema);
|
||||
if (minimum !== undefined)
|
||||
_json.minLength = minimum;
|
||||
if (maximum !== undefined)
|
||||
_json.maxLength = maximum;
|
||||
if (!mime)
|
||||
return;
|
||||
// an empty intersection means the mime checks share no value, so nothing passes at runtime; `anyOf` must be non-empty, so the false schema is `not: {}`
|
||||
if (mime.length === 0)
|
||||
_json.not = {};
|
||||
else if (mime.length === 1)
|
||||
_json.contentMediaType = mime[0];
|
||||
// only contentMediaType differs, so the shared props stay at the root
|
||||
else
|
||||
_json.anyOf = mime.map((m) => ({ contentMediaType: m }));
|
||||
};
|
||||
export const successProcessor = (_schema, _ctx, json, _params) => {
|
||||
json.type = "boolean";
|
||||
};
|
||||
export const customProcessor = (schema, ctx, json, params) => {
|
||||
handleUnrepresentable(schema, ctx, json, params, "Custom types cannot be represented in JSON Schema");
|
||||
};
|
||||
export const functionProcessor = (schema, ctx, json, params) => {
|
||||
handleUnrepresentable(schema, ctx, json, params, "Function types cannot be represented in JSON Schema");
|
||||
};
|
||||
export const transformProcessor = (schema, ctx, json, params) => {
|
||||
handleUnrepresentable(schema, ctx, json, params, "Transforms cannot be represented in JSON Schema");
|
||||
};
|
||||
export const mapProcessor = (schema, ctx, json, params) => {
|
||||
handleUnrepresentable(schema, ctx, json, params, "Map cannot be represented in JSON Schema");
|
||||
};
|
||||
export const setProcessor = (schema, ctx, json, params) => {
|
||||
handleUnrepresentable(schema, ctx, json, params, "Set cannot be represented in JSON Schema");
|
||||
};
|
||||
// ==================== COMPOSITE TYPE PROCESSORS ====================
|
||||
export const arrayProcessor = (schema, ctx, _json, params) => {
|
||||
const json = _json;
|
||||
const def = schema._zod.def;
|
||||
const { minimum, maximum } = aggregateChecks(schema);
|
||||
if (typeof minimum === "number")
|
||||
json.minItems = minimum;
|
||||
if (typeof maximum === "number")
|
||||
json.maxItems = maximum;
|
||||
json.type = "array";
|
||||
json.items = processSchema(def.element, ctx, {
|
||||
...params,
|
||||
path: [...params.path, "items"],
|
||||
});
|
||||
};
|
||||
// Transform and catch set `optin = "optional"` at runtime so the parser lets them observe an
|
||||
// absent key, but their declared input type stays required. An input JSON Schema describes the
|
||||
// declared type, so resolve past them to the schema that actually carries the optionality.
|
||||
// Used by both `objectProcessor` (for `required`) and `tupleProcessor` (for `minItems`); see
|
||||
// wiki/optionality.md, "The JSON Schema emitter reads the *static* value".
|
||||
function inputOptin(schema) {
|
||||
const def = schema._zod.def;
|
||||
if (def.type === "pipe" && def.in._zod.traits.has("$ZodTransform")) {
|
||||
return inputOptin(def.out);
|
||||
}
|
||||
if (def.type === "catch") {
|
||||
return inputOptin(def.innerType);
|
||||
}
|
||||
return schema._zod.optin;
|
||||
}
|
||||
export const objectProcessor = (schema, ctx, _json, params) => {
|
||||
const json = _json;
|
||||
const def = schema._zod.def;
|
||||
const shape = def.shape;
|
||||
// dropping it while still emitting `additionalProperties: false` would emit a schema that rejects data this one requires
|
||||
const symbolKeys = Object.getOwnPropertySymbols(shape);
|
||||
if (symbolKeys.length &&
|
||||
handleUnrepresentable(schema, ctx, json, params, "Symbol keys cannot be represented in JSON Schema")) {
|
||||
return;
|
||||
}
|
||||
json.type = "object";
|
||||
json.properties = {};
|
||||
for (const key in shape) {
|
||||
// assignProp so a __proto__ key becomes an own property instead of hitting the inherited setter on the plain {} we build into
|
||||
assignProp(json.properties, key, processSchema(shape[key], ctx, {
|
||||
...params,
|
||||
path: [...params.path, "properties", key],
|
||||
}));
|
||||
}
|
||||
// required keys
|
||||
const requiredKeys = [];
|
||||
for (const key of Object.keys(shape)) {
|
||||
const field = def.shape[key];
|
||||
if (ctx.io === "input" ? inputOptin(field) === undefined : field._zod.optout === undefined) {
|
||||
requiredKeys.push(key);
|
||||
}
|
||||
}
|
||||
if (requiredKeys.length > 0) {
|
||||
json.required = requiredKeys;
|
||||
}
|
||||
// catchall
|
||||
if (def.catchall?._zod.def.type === "never") {
|
||||
// strict
|
||||
json.additionalProperties = false;
|
||||
}
|
||||
else if (!def.catchall) {
|
||||
// regular
|
||||
if (ctx.io === "output")
|
||||
json.additionalProperties = false;
|
||||
}
|
||||
else if (def.catchall) {
|
||||
json.additionalProperties = processSchema(def.catchall, ctx, {
|
||||
...params,
|
||||
path: [...params.path, "additionalProperties"],
|
||||
});
|
||||
}
|
||||
};
|
||||
export const unionProcessor = (schema, ctx, json, params) => {
|
||||
const def = schema._zod.def;
|
||||
// Exclusive unions (inclusive === false) use oneOf (exactly one match) instead of anyOf (one or more matches). This includes both z.xor() and discriminated unions
|
||||
const isExclusive = def.inclusive === false;
|
||||
const options = def.options.map((x, i) => processSchema(x, ctx, {
|
||||
...params,
|
||||
path: [...params.path, isExclusive ? "oneOf" : "anyOf", i],
|
||||
}));
|
||||
if (isExclusive) {
|
||||
json.oneOf = options;
|
||||
}
|
||||
else {
|
||||
json.anyOf = options;
|
||||
}
|
||||
};
|
||||
export const intersectionProcessor = (schema, ctx, json, params) => {
|
||||
const def = schema._zod.def;
|
||||
const a = processSchema(def.left, ctx, {
|
||||
...params,
|
||||
path: [...params.path, "allOf", 0],
|
||||
});
|
||||
const b = processSchema(def.right, ctx, {
|
||||
...params,
|
||||
path: [...params.path, "allOf", 1],
|
||||
});
|
||||
const isSimpleIntersection = (val) => "allOf" in val && Object.keys(val).length === 1;
|
||||
const allOf = [
|
||||
...(isSimpleIntersection(a) ? a.allOf : [a]),
|
||||
...(isSimpleIntersection(b) ? b.allOf : [b]),
|
||||
];
|
||||
json.allOf = allOf;
|
||||
// Recorded innermost first, so a nested intersection has already folded by the time this one is considered. The array is the handle rather than the schema, because a wrapper that inherits this schema shares the same array; `finalize` folds every object holding it. See `foldIntersection`.
|
||||
ctx.intersections.push(allOf);
|
||||
};
|
||||
export const tupleProcessor = (schema, ctx, _json, params) => {
|
||||
const json = _json;
|
||||
const def = schema._zod.def;
|
||||
json.type = "array";
|
||||
const prefixPath = ctx.target === "draft-2020-12" ? "prefixItems" : "items";
|
||||
const restPath = ctx.target === "draft-2020-12" ? "items" : ctx.target === "openapi-3.0" ? "items" : "additionalItems";
|
||||
const prefixItems = def.items.map((x, i) => processSchema(x, ctx, {
|
||||
...params,
|
||||
path: [...params.path, prefixPath, i],
|
||||
}));
|
||||
const rest = def.rest
|
||||
? processSchema(def.rest, ctx, {
|
||||
...params,
|
||||
path: [...params.path, restPath, ...(ctx.target === "openapi-3.0" ? [def.items.length] : [])],
|
||||
})
|
||||
: null;
|
||||
let minItems = def.items.length;
|
||||
while (minItems > 0) {
|
||||
const item = def.items[minItems - 1];
|
||||
const optional = ctx.io === "input" ? inputOptin(item) !== undefined : item._zod.optout === "optional";
|
||||
if (!optional)
|
||||
break;
|
||||
minItems--;
|
||||
}
|
||||
const maxItems = def.items.length;
|
||||
const isClosed = !def.rest;
|
||||
if (ctx.target === "draft-2020-12") {
|
||||
json.prefixItems = prefixItems;
|
||||
if (isClosed) {
|
||||
json.items = false;
|
||||
}
|
||||
else if (rest) {
|
||||
json.items = rest;
|
||||
}
|
||||
if (minItems > 0)
|
||||
json.minItems = minItems;
|
||||
if (isClosed)
|
||||
json.maxItems = maxItems;
|
||||
}
|
||||
else if (ctx.target === "openapi-3.0") {
|
||||
json.items = {
|
||||
anyOf: prefixItems,
|
||||
};
|
||||
if (rest) {
|
||||
json.items.anyOf.push(rest);
|
||||
}
|
||||
if (minItems > 0)
|
||||
json.minItems = minItems;
|
||||
if (isClosed)
|
||||
json.maxItems = maxItems;
|
||||
}
|
||||
else {
|
||||
json.items = prefixItems;
|
||||
if (isClosed) {
|
||||
json.additionalItems = false;
|
||||
}
|
||||
else if (rest) {
|
||||
json.additionalItems = rest;
|
||||
}
|
||||
if (minItems > 0)
|
||||
json.minItems = minItems;
|
||||
if (isClosed)
|
||||
json.maxItems = maxItems;
|
||||
}
|
||||
// explicit user-defined length checks take precedence
|
||||
const { minimum, maximum } = aggregateChecks(schema);
|
||||
if (typeof minimum === "number")
|
||||
json.minItems = minimum;
|
||||
if (typeof maximum === "number")
|
||||
json.maxItems = maximum;
|
||||
};
|
||||
/** JSON object keys are always strings, so a numeric record key schema is re-expressed over the
|
||||
* numeric-string form the record parser matches. Deferred to `finalize`, after the flatten: a key
|
||||
* behind a wrapper only carries its own `type` before then, and a union key only has its branches.
|
||||
*
|
||||
* A numeric bound cannot apply to a property name, so `minimum` and its siblings are dropped rather
|
||||
* than carried over: keeping them beside `type: "string"` reproduces the match-nothing schema this
|
||||
* exists to fix. A key that carries one therefore emits wider than the record parses — `z.record(z.number().min(5), V)`
|
||||
* accepts `"3"` — which is the deliberate trade, since throwing on it would reject an ordinary schema
|
||||
* outright. */
|
||||
function stringifyKeyNames(bySchema, json, visited) {
|
||||
// an extracted key that rewrites cannot go on sharing its definition — the string form a key position needs is not the number form every other reference wants — so it inlines. One that does not rewrite keeps the `$ref`.
|
||||
if (json.$ref) {
|
||||
// a recursive key holds its own reference inside its definition, so a node already on the path is left alone rather than resolved again
|
||||
if (visited.has(json))
|
||||
return json;
|
||||
visited.add(json);
|
||||
const def = bySchema.get(json)?.def;
|
||||
if (!def)
|
||||
return json;
|
||||
const inlined = stringifyKeyNames(bySchema, def, visited);
|
||||
return inlined === def ? json : inlined;
|
||||
}
|
||||
for (const keyword of ["anyOf", "oneOf"]) {
|
||||
const branches = json[keyword];
|
||||
if (!Array.isArray(branches))
|
||||
continue;
|
||||
const mapped = branches.map((branch) => stringifyKeyNames(bySchema, branch, visited));
|
||||
// rebuilding regardless would detach a key that had nothing to re-express, dropping its `$ref` and leaking the internal `id`
|
||||
if (mapped.some((branch, i) => branch !== branches[i]))
|
||||
json = { ...json, [keyword]: mapped };
|
||||
}
|
||||
// a member that already admits a string leaves the key unconstrained, so the node's own type re-expresses only when every member is numeric
|
||||
const types = Array.isArray(json.type) ? json.type : [json.type];
|
||||
const numericType = !types.includes("string") && types.some((t) => t === "number" || t === "integer");
|
||||
// a heterogeneous key carries no type at all, so its numeric members are caught here instead
|
||||
const values = json.enum ?? (json.const !== undefined ? [json.const] : undefined);
|
||||
if (!numericType && !values?.some((v) => typeof v === "number"))
|
||||
return json;
|
||||
const { minimum, maximum, exclusiveMinimum, exclusiveMaximum, multipleOf, format, id, ...rest } = json;
|
||||
if (rest.enum)
|
||||
rest.enum = rest.enum.map((v) => (typeof v === "number" ? String(v) : v));
|
||||
else if (typeof rest.const === "number")
|
||||
rest.const = String(rest.const);
|
||||
// a heterogeneous key keeps its absent type: the stringified members already say what a key may be
|
||||
if (!numericType)
|
||||
return rest;
|
||||
rest.type = "string";
|
||||
if (!values)
|
||||
rest.pattern = (types.includes("number") ? regexes.number : regexes.integer).source;
|
||||
return rest;
|
||||
}
|
||||
/** Every record of one conversion, so the carriers are found in a single pass rather than once per record. */
|
||||
const pendingRecords = new WeakMap();
|
||||
function rewriteKeyNames(ctx) {
|
||||
// an extracted key is resolved by the object `extractToDef` left in its place, so the map is built once rather than searched per reference. `_zod.toJSONSchema` can hand the same object to two schemas, so the first entry carrying a body wins, as a search would have found it.
|
||||
const bySchema = new Map();
|
||||
for (const entry of ctx.seen.values()) {
|
||||
if (entry.def && !bySchema.has(entry.schema))
|
||||
bySchema.set(entry.schema, entry);
|
||||
}
|
||||
const rewrites = new Map();
|
||||
for (const record of pendingRecords.get(ctx) ?? []) {
|
||||
const seen = ctx.seen.get(record);
|
||||
const names = (seen?.def ?? seen?.schema)?.propertyNames;
|
||||
if (!names || names === true || rewrites.has(names))
|
||||
continue;
|
||||
const rewritten = stringifyKeyNames(bySchema, names, new Set());
|
||||
if (rewritten !== names)
|
||||
rewrites.set(names, rewritten);
|
||||
}
|
||||
if (!rewrites.size)
|
||||
return;
|
||||
// the flatten has already copied each record's own properties onto every wrapper by reference, and an extracted body is another such copy, so every carrier holding a rewritten key is updated together
|
||||
for (const entry of ctx.seen.values()) {
|
||||
for (const carrier of [entry.schema, entry.def]) {
|
||||
const rewritten = carrier && rewrites.get(carrier.propertyNames);
|
||||
if (rewritten)
|
||||
carrier.propertyNames = rewritten;
|
||||
}
|
||||
}
|
||||
}
|
||||
export const recordProcessor = (schema, ctx, _json, params) => {
|
||||
const json = _json;
|
||||
const def = schema._zod.def;
|
||||
json.type = "object";
|
||||
// For looseRecord with regex patterns, use patternProperties. This correctly represents "only validate keys matching the pattern" semantics and composes well with allOf (intersections)
|
||||
const keyType = def.keyType;
|
||||
const patterns = aggregateChecks(keyType).patterns;
|
||||
if (def.mode === "loose" && patterns && patterns.size > 0) {
|
||||
// Use patternProperties for looseRecord with regex patterns
|
||||
const valueSchema = processSchema(def.valueType, ctx, {
|
||||
...params,
|
||||
path: [...params.path, "patternProperties", "*"],
|
||||
});
|
||||
json.patternProperties = {};
|
||||
for (const pattern of patterns) {
|
||||
assignProp(json.patternProperties, exactPattern(pattern).source, valueSchema);
|
||||
}
|
||||
}
|
||||
else {
|
||||
// Default behavior: use propertyNames + additionalProperties
|
||||
if (ctx.target === "draft-07" || ctx.target === "draft-2020-12") {
|
||||
json.propertyNames = processSchema(def.keyType, ctx, {
|
||||
...params,
|
||||
path: [...params.path, "propertyNames"],
|
||||
});
|
||||
let pending = pendingRecords.get(ctx);
|
||||
if (!pending) {
|
||||
pending = [];
|
||||
pendingRecords.set(ctx, pending);
|
||||
ctx.deferred.push(() => rewriteKeyNames(ctx));
|
||||
}
|
||||
pending.push(schema);
|
||||
}
|
||||
json.additionalProperties = processSchema(def.valueType, ctx, {
|
||||
...params,
|
||||
path: [...params.path, "additionalProperties"],
|
||||
});
|
||||
}
|
||||
// Add required for keys with discrete values (enum, literal, etc.)
|
||||
const keyValues = keyType._zod.values;
|
||||
// Every key shares one value schema, so an optional-in value makes the whole key set omittable on input. Output keeps them: the exhaustive branch assigns every key, even one whose value came back undefined.
|
||||
const omittableOnInput = ctx.io === "input" && inputOptin(def.valueType) !== undefined;
|
||||
if (keyValues && !def.partial && !omittableOnInput) {
|
||||
const validKeyValues = [...keyValues].filter((v) => typeof v === "string" || typeof v === "number");
|
||||
if (validKeyValues.length > 0) {
|
||||
json.required = validKeyValues.map(String);
|
||||
}
|
||||
}
|
||||
};
|
||||
export const nullableProcessor = (schema, ctx, json, params) => {
|
||||
const def = schema._zod.def;
|
||||
const inner = processSchema(def.innerType, ctx, params);
|
||||
const seen = ctx.seen.get(schema);
|
||||
if (ctx.target === "openapi-3.0") {
|
||||
seen.ref = def.innerType;
|
||||
json.nullable = true;
|
||||
}
|
||||
else {
|
||||
json.anyOf = [inner, { type: "null" }];
|
||||
}
|
||||
};
|
||||
export const nonoptionalProcessor = (schema, ctx, _json, params) => {
|
||||
const def = schema._zod.def;
|
||||
processSchema(def.innerType, ctx, params);
|
||||
const seen = ctx.seen.get(schema);
|
||||
seen.ref = def.innerType;
|
||||
};
|
||||
/** Round-trips a default value through JSON so the emitted schema is guaranteed to be valid JSON.
|
||||
* A BigInt has no reliable encoding, so it goes through `unrepresentable` like any other
|
||||
* unrepresentable value. Returns a sentinel when the caller must not write a default of its own. */
|
||||
const UNREPRESENTABLE_DEFAULT = Symbol();
|
||||
function serializeDefaultValue(value, schema, ctx, json, params) {
|
||||
let unrepresentable = false;
|
||||
const serialized = JSON.stringify(value, (_, val) => {
|
||||
if (typeof val !== "bigint")
|
||||
return val;
|
||||
unrepresentable = true;
|
||||
return null;
|
||||
});
|
||||
if (!unrepresentable)
|
||||
return JSON.parse(serialized);
|
||||
handleUnrepresentable(schema, ctx, json, params, "BigInt defaults cannot be represented in JSON Schema");
|
||||
return UNREPRESENTABLE_DEFAULT;
|
||||
}
|
||||
export const defaultProcessor = (schema, ctx, json, params) => {
|
||||
const def = schema._zod.def;
|
||||
processSchema(def.innerType, ctx, params);
|
||||
const seen = ctx.seen.get(schema);
|
||||
seen.ref = def.innerType;
|
||||
const value = serializeDefaultValue(def.defaultValue, schema, ctx, json, params);
|
||||
if (value !== UNREPRESENTABLE_DEFAULT)
|
||||
json.default = value;
|
||||
};
|
||||
export const prefaultProcessor = (schema, ctx, json, params) => {
|
||||
const def = schema._zod.def;
|
||||
processSchema(def.innerType, ctx, params);
|
||||
const seen = ctx.seen.get(schema);
|
||||
seen.ref = def.innerType;
|
||||
if (ctx.io !== "input")
|
||||
return;
|
||||
const value = serializeDefaultValue(def.defaultValue, schema, ctx, json, params);
|
||||
if (value !== UNREPRESENTABLE_DEFAULT)
|
||||
json._prefault = value;
|
||||
};
|
||||
export const catchProcessor = (schema, ctx, json, params) => {
|
||||
const def = schema._zod.def;
|
||||
processSchema(def.innerType, ctx, params);
|
||||
const seen = ctx.seen.get(schema);
|
||||
seen.ref = def.innerType;
|
||||
let catchValue;
|
||||
try {
|
||||
catchValue = def.catchValue(undefined);
|
||||
}
|
||||
catch {
|
||||
handleUnrepresentable(schema, ctx, json, params, "Dynamic catch values are not supported in JSON Schema");
|
||||
return;
|
||||
}
|
||||
json.default = catchValue;
|
||||
};
|
||||
export const pipeProcessor = (schema, ctx, _json, params) => {
|
||||
const def = schema._zod.def;
|
||||
const inIsTransform = def.in._zod.traits.has("$ZodTransform");
|
||||
const innerType = ctx.io === "input" ? (inIsTransform ? def.out : def.in) : def.out;
|
||||
processSchema(innerType, ctx, params);
|
||||
const seen = ctx.seen.get(schema);
|
||||
seen.ref = innerType;
|
||||
};
|
||||
export const readonlyProcessor = (schema, ctx, json, params) => {
|
||||
const def = schema._zod.def;
|
||||
processSchema(def.innerType, ctx, params);
|
||||
const seen = ctx.seen.get(schema);
|
||||
seen.ref = def.innerType;
|
||||
json.readOnly = true;
|
||||
};
|
||||
export const promiseProcessor = (schema, ctx, _json, params) => {
|
||||
const def = schema._zod.def;
|
||||
processSchema(def.innerType, ctx, params);
|
||||
const seen = ctx.seen.get(schema);
|
||||
seen.ref = def.innerType;
|
||||
};
|
||||
export const optionalProcessor = (schema, ctx, _json, params) => {
|
||||
const def = schema._zod.def;
|
||||
processSchema(def.innerType, ctx, params);
|
||||
const seen = ctx.seen.get(schema);
|
||||
seen.ref = def.innerType;
|
||||
};
|
||||
export const lazyProcessor = (schema, ctx, _json, params) => {
|
||||
const innerType = schema._zod.innerType;
|
||||
processSchema(innerType, ctx, params);
|
||||
const seen = ctx.seen.get(schema);
|
||||
seen.ref = innerType;
|
||||
};
|
||||
// ==================== ALL PROCESSORS ====================
|
||||
export const allProcessors = {
|
||||
string: stringProcessor,
|
||||
number: numberProcessor,
|
||||
boolean: booleanProcessor,
|
||||
bigint: bigintProcessor,
|
||||
symbol: symbolProcessor,
|
||||
null: nullProcessor,
|
||||
undefined: undefinedProcessor,
|
||||
void: voidProcessor,
|
||||
never: neverProcessor,
|
||||
any: anyProcessor,
|
||||
unknown: unknownProcessor,
|
||||
date: dateProcessor,
|
||||
enum: enumProcessor,
|
||||
literal: literalProcessor,
|
||||
nan: nanProcessor,
|
||||
template_literal: templateLiteralProcessor,
|
||||
file: fileProcessor,
|
||||
success: successProcessor,
|
||||
custom: customProcessor,
|
||||
function: functionProcessor,
|
||||
transform: transformProcessor,
|
||||
map: mapProcessor,
|
||||
set: setProcessor,
|
||||
array: arrayProcessor,
|
||||
object: objectProcessor,
|
||||
union: unionProcessor,
|
||||
intersection: intersectionProcessor,
|
||||
tuple: tupleProcessor,
|
||||
record: recordProcessor,
|
||||
nullable: nullableProcessor,
|
||||
nonoptional: nonoptionalProcessor,
|
||||
default: defaultProcessor,
|
||||
prefault: prefaultProcessor,
|
||||
catch: catchProcessor,
|
||||
pipe: pipeProcessor,
|
||||
readonly: readonlyProcessor,
|
||||
promise: promiseProcessor,
|
||||
optional: optionalProcessor,
|
||||
lazy: lazyProcessor,
|
||||
};
|
||||
export function toJSONSchema(input, params) {
|
||||
if ("_idmap" in input) {
|
||||
// Registry case
|
||||
const registry = input;
|
||||
const ctx = initializeContext({ ...params, processors: allProcessors });
|
||||
const defs = {};
|
||||
// First pass: process all schemas to build the seen map
|
||||
for (const entry of registry._idmap.entries()) {
|
||||
const [_, schema] = entry;
|
||||
processSchema(schema, ctx);
|
||||
}
|
||||
const schemas = {};
|
||||
const external = {
|
||||
registry,
|
||||
uri: params?.uri,
|
||||
defs,
|
||||
};
|
||||
// Update the context with external configuration
|
||||
ctx.external = external;
|
||||
// Second pass: emit each schema
|
||||
for (const entry of registry._idmap.entries()) {
|
||||
const [key, schema] = entry;
|
||||
extractDefs(ctx, schema);
|
||||
assignProp(schemas, key, finalize(ctx, schema));
|
||||
}
|
||||
if (Object.keys(defs).length > 0) {
|
||||
const defsSegment = ctx.target === "draft-2020-12" ? "$defs" : "definitions";
|
||||
schemas.__shared = {
|
||||
[defsSegment]: defs,
|
||||
};
|
||||
}
|
||||
return { schemas };
|
||||
}
|
||||
// Single schema case
|
||||
const ctx = initializeContext({ ...params, processors: allProcessors });
|
||||
processSchema(input, ctx);
|
||||
extractDefs(ctx, input);
|
||||
return finalize(ctx, input);
|
||||
}
|
||||
+21
@@ -0,0 +1,21 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
|
||||
// seal-cjs-exports
|
||||
(function () {
|
||||
var keys = Object.getOwnPropertyNames(exports);
|
||||
for (var i = 0; i < keys.length; i++) {
|
||||
var desc = Object.getOwnPropertyDescriptor(exports, keys[i]);
|
||||
if (!desc || !desc.get || !desc.configurable) continue;
|
||||
var value;
|
||||
try {
|
||||
value = desc.get();
|
||||
} catch (e) {
|
||||
continue;
|
||||
}
|
||||
// a circular require may not have settled this one yet, so leave it live
|
||||
if (value === undefined) continue;
|
||||
Object.defineProperty(exports, keys[i], { value: value, writable: false, enumerable: desc.enumerable, configurable: false });
|
||||
}
|
||||
Object.freeze(exports);
|
||||
})();
|
||||
+89
@@ -0,0 +1,89 @@
|
||||
export type Schema = ObjectSchema | ArraySchema | StringSchema | NumberSchema | IntegerSchema | BooleanSchema | NullSchema;
|
||||
export type _JSONSchema = boolean | JSONSchema;
|
||||
export type SchemaType = "object" | "array" | "string" | "number" | "boolean" | "null" | "integer";
|
||||
export type JSONSchema = {
|
||||
[k: string]: unknown;
|
||||
$schema?: "https://json-schema.org/draft/2020-12/schema" | "http://json-schema.org/draft-07/schema#" | "http://json-schema.org/draft-04/schema#";
|
||||
$id?: string;
|
||||
$anchor?: string;
|
||||
$ref?: string;
|
||||
$dynamicRef?: string;
|
||||
$dynamicAnchor?: string;
|
||||
$vocabulary?: Record<string, boolean>;
|
||||
$comment?: string;
|
||||
$defs?: Record<string, JSONSchema>;
|
||||
type?: SchemaType | SchemaType[];
|
||||
additionalItems?: _JSONSchema;
|
||||
unevaluatedItems?: _JSONSchema;
|
||||
prefixItems?: _JSONSchema[];
|
||||
items?: _JSONSchema | _JSONSchema[];
|
||||
contains?: _JSONSchema;
|
||||
additionalProperties?: _JSONSchema;
|
||||
unevaluatedProperties?: _JSONSchema;
|
||||
properties?: Record<string, _JSONSchema>;
|
||||
patternProperties?: Record<string, _JSONSchema>;
|
||||
dependentSchemas?: Record<string, _JSONSchema>;
|
||||
propertyNames?: _JSONSchema;
|
||||
if?: _JSONSchema;
|
||||
then?: _JSONSchema;
|
||||
else?: _JSONSchema;
|
||||
allOf?: JSONSchema[];
|
||||
anyOf?: JSONSchema[];
|
||||
oneOf?: JSONSchema[];
|
||||
not?: _JSONSchema;
|
||||
multipleOf?: number;
|
||||
maximum?: number;
|
||||
exclusiveMaximum?: number | boolean;
|
||||
minimum?: number;
|
||||
exclusiveMinimum?: number | boolean;
|
||||
maxLength?: number;
|
||||
minLength?: number;
|
||||
pattern?: string;
|
||||
maxItems?: number;
|
||||
minItems?: number;
|
||||
uniqueItems?: boolean;
|
||||
maxContains?: number;
|
||||
minContains?: number;
|
||||
maxProperties?: number;
|
||||
minProperties?: number;
|
||||
required?: string[];
|
||||
dependentRequired?: Record<string, string[]>;
|
||||
enum?: Array<string | number | boolean | null>;
|
||||
const?: string | number | boolean | null;
|
||||
id?: string;
|
||||
title?: string;
|
||||
description?: string;
|
||||
default?: unknown;
|
||||
deprecated?: boolean;
|
||||
readOnly?: boolean;
|
||||
writeOnly?: boolean;
|
||||
nullable?: boolean;
|
||||
examples?: unknown[];
|
||||
format?: string;
|
||||
contentMediaType?: string;
|
||||
contentEncoding?: string;
|
||||
contentSchema?: JSONSchema;
|
||||
_prefault?: unknown;
|
||||
};
|
||||
export type BaseSchema = JSONSchema;
|
||||
export interface ObjectSchema extends JSONSchema {
|
||||
type: "object";
|
||||
}
|
||||
export interface ArraySchema extends JSONSchema {
|
||||
type: "array";
|
||||
}
|
||||
export interface StringSchema extends JSONSchema {
|
||||
type: "string";
|
||||
}
|
||||
export interface NumberSchema extends JSONSchema {
|
||||
type: "number";
|
||||
}
|
||||
export interface IntegerSchema extends JSONSchema {
|
||||
type: "integer";
|
||||
}
|
||||
export interface BooleanSchema extends JSONSchema {
|
||||
type: "boolean";
|
||||
}
|
||||
export interface NullSchema extends JSONSchema {
|
||||
type: "null";
|
||||
}
|
||||
+89
@@ -0,0 +1,89 @@
|
||||
export type Schema = ObjectSchema | ArraySchema | StringSchema | NumberSchema | IntegerSchema | BooleanSchema | NullSchema;
|
||||
export type _JSONSchema = boolean | JSONSchema;
|
||||
export type SchemaType = "object" | "array" | "string" | "number" | "boolean" | "null" | "integer";
|
||||
export type JSONSchema = {
|
||||
[k: string]: unknown;
|
||||
$schema?: "https://json-schema.org/draft/2020-12/schema" | "http://json-schema.org/draft-07/schema#" | "http://json-schema.org/draft-04/schema#";
|
||||
$id?: string;
|
||||
$anchor?: string;
|
||||
$ref?: string;
|
||||
$dynamicRef?: string;
|
||||
$dynamicAnchor?: string;
|
||||
$vocabulary?: Record<string, boolean>;
|
||||
$comment?: string;
|
||||
$defs?: Record<string, JSONSchema>;
|
||||
type?: SchemaType | SchemaType[];
|
||||
additionalItems?: _JSONSchema;
|
||||
unevaluatedItems?: _JSONSchema;
|
||||
prefixItems?: _JSONSchema[];
|
||||
items?: _JSONSchema | _JSONSchema[];
|
||||
contains?: _JSONSchema;
|
||||
additionalProperties?: _JSONSchema;
|
||||
unevaluatedProperties?: _JSONSchema;
|
||||
properties?: Record<string, _JSONSchema>;
|
||||
patternProperties?: Record<string, _JSONSchema>;
|
||||
dependentSchemas?: Record<string, _JSONSchema>;
|
||||
propertyNames?: _JSONSchema;
|
||||
if?: _JSONSchema;
|
||||
then?: _JSONSchema;
|
||||
else?: _JSONSchema;
|
||||
allOf?: JSONSchema[];
|
||||
anyOf?: JSONSchema[];
|
||||
oneOf?: JSONSchema[];
|
||||
not?: _JSONSchema;
|
||||
multipleOf?: number;
|
||||
maximum?: number;
|
||||
exclusiveMaximum?: number | boolean;
|
||||
minimum?: number;
|
||||
exclusiveMinimum?: number | boolean;
|
||||
maxLength?: number;
|
||||
minLength?: number;
|
||||
pattern?: string;
|
||||
maxItems?: number;
|
||||
minItems?: number;
|
||||
uniqueItems?: boolean;
|
||||
maxContains?: number;
|
||||
minContains?: number;
|
||||
maxProperties?: number;
|
||||
minProperties?: number;
|
||||
required?: string[];
|
||||
dependentRequired?: Record<string, string[]>;
|
||||
enum?: Array<string | number | boolean | null>;
|
||||
const?: string | number | boolean | null;
|
||||
id?: string;
|
||||
title?: string;
|
||||
description?: string;
|
||||
default?: unknown;
|
||||
deprecated?: boolean;
|
||||
readOnly?: boolean;
|
||||
writeOnly?: boolean;
|
||||
nullable?: boolean;
|
||||
examples?: unknown[];
|
||||
format?: string;
|
||||
contentMediaType?: string;
|
||||
contentEncoding?: string;
|
||||
contentSchema?: JSONSchema;
|
||||
_prefault?: unknown;
|
||||
};
|
||||
export type BaseSchema = JSONSchema;
|
||||
export interface ObjectSchema extends JSONSchema {
|
||||
type: "object";
|
||||
}
|
||||
export interface ArraySchema extends JSONSchema {
|
||||
type: "array";
|
||||
}
|
||||
export interface StringSchema extends JSONSchema {
|
||||
type: "string";
|
||||
}
|
||||
export interface NumberSchema extends JSONSchema {
|
||||
type: "number";
|
||||
}
|
||||
export interface IntegerSchema extends JSONSchema {
|
||||
type: "integer";
|
||||
}
|
||||
export interface BooleanSchema extends JSONSchema {
|
||||
type: "boolean";
|
||||
}
|
||||
export interface NullSchema extends JSONSchema {
|
||||
type: "null";
|
||||
}
|
||||
+1
@@ -0,0 +1 @@
|
||||
export {};
|
||||
+360
@@ -0,0 +1,360 @@
|
||||
"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.$ZodCyclicError = void 0;
|
||||
exports.isRecursiveSchema = isRecursiveSchema;
|
||||
exports.memoizer = memoizer;
|
||||
exports.isBackEdge = isBackEdge;
|
||||
const util = __importStar(require("./util.cjs"));
|
||||
class $ZodCyclicError extends Error {
|
||||
constructor() {
|
||||
super(`Cannot parse a reference cycle that closes through a transform`);
|
||||
this.name = "ZodCyclicError";
|
||||
}
|
||||
}
|
||||
exports.$ZodCyclicError = $ZodCyclicError;
|
||||
/** Keyed off the context object every schema in one parse call already shares. */
|
||||
const STATE = "~memo";
|
||||
const NO_ISSUES = [];
|
||||
// a value a cycle can close through
|
||||
function isRef(value) {
|
||||
return value !== null && typeof value === "object";
|
||||
}
|
||||
// Receivers prefix paths in place, so the cache and every hand-out need their own copies.
|
||||
function cloneIssues(issues) {
|
||||
return issues.map((iss) => (iss.path ? { ...iss, path: iss.path.slice() } : { ...iss }));
|
||||
}
|
||||
const recursive = /*@__PURE__*/ new WeakMap();
|
||||
/** What the walk established, in order of certainty: ordered so the strongest answer among children wins. */
|
||||
const NONE = 0;
|
||||
const ASSUMED = 1;
|
||||
const PROVEN = 2;
|
||||
/** Whether this schema's subtree contains a cycle, so one parse can re-enter it. */
|
||||
function isRecursive(inst, stack, resolve) {
|
||||
const cached = recursive.get(inst);
|
||||
if (cached !== undefined)
|
||||
return cached ? PROVEN : NONE;
|
||||
// Relative to the walk in progress, so not cached.
|
||||
if (stack.has(inst))
|
||||
return PROVEN;
|
||||
stack.add(inst);
|
||||
let result = NONE;
|
||||
const check = (child) => {
|
||||
if (result !== PROVEN && child?._zod) {
|
||||
const answer = isRecursive(child, stack, resolve);
|
||||
if (answer > result)
|
||||
result = answer;
|
||||
}
|
||||
};
|
||||
// `Reflect.ownKeys` rather than `Object.keys`, so a cycle through a declared symbol key is still seen
|
||||
const shape = (sh, spread) => {
|
||||
let answer = NONE;
|
||||
for (const key of Reflect.ownKeys(sh)) {
|
||||
const desc = Object.getOwnPropertyDescriptor(sh, key);
|
||||
// an object resolves its shape by spread, so a key it does not enumerate is never parsed; `z.properties` reads every own key and so keeps them all
|
||||
if (spread && !desc.enumerable)
|
||||
continue;
|
||||
// resolving runs user code, and a factory mints a fresh subtree per read, so an edge the walk can't follow counts as a cycle
|
||||
const child = desc.get ? ASSUMED : desc.value?._zod ? isRecursive(desc.value, stack, resolve) : NONE;
|
||||
if (child > answer)
|
||||
answer = child;
|
||||
}
|
||||
return answer;
|
||||
};
|
||||
const merge = (answer) => {
|
||||
if (answer > result)
|
||||
result = answer;
|
||||
};
|
||||
const def = inst._zod.def;
|
||||
const kind = def.type;
|
||||
switch (kind) {
|
||||
case "object": {
|
||||
const raw = util.rawShape(def);
|
||||
// a def with no raw shape answers `shape` from an accessor of its own, and running that can mint a whole fresh subtree
|
||||
merge(raw ? shape(raw, true) : ASSUMED);
|
||||
check(def.catchall);
|
||||
break;
|
||||
}
|
||||
case "array":
|
||||
check(def.element);
|
||||
break;
|
||||
case "tuple":
|
||||
for (const el of def.items)
|
||||
check(el);
|
||||
check(def.rest);
|
||||
break;
|
||||
case "record":
|
||||
case "map":
|
||||
check(def.keyType);
|
||||
check(def.valueType);
|
||||
break;
|
||||
case "set":
|
||||
check(def.valueType);
|
||||
break;
|
||||
case "union":
|
||||
for (const el of def.options)
|
||||
check(el);
|
||||
break;
|
||||
case "intersection":
|
||||
check(def.left);
|
||||
check(def.right);
|
||||
break;
|
||||
case "optional":
|
||||
case "nullable":
|
||||
case "default":
|
||||
case "prefault":
|
||||
case "catch":
|
||||
case "readonly":
|
||||
case "nonoptional":
|
||||
case "promise":
|
||||
case "success":
|
||||
check(def.innerType);
|
||||
break;
|
||||
case "pipe":
|
||||
check(def.in);
|
||||
check(def.out);
|
||||
break;
|
||||
case "function":
|
||||
check(def.input);
|
||||
check(def.output);
|
||||
break;
|
||||
// `$ZodLazy` caches its inner on the def, so a resolved edge is followed exactly
|
||||
case "lazy": {
|
||||
const inner = def._cachedInner ?? (resolve ? inst._zod.innerType : undefined);
|
||||
// walked with resolution off: one hop sees past the deferral, and a lazy that yields only another unresolved lazy is generative, so it stops there
|
||||
merge(inner ? isRecursive(inner, stack, false) : ASSUMED);
|
||||
break;
|
||||
}
|
||||
// a leaf by choice: `parts` are regex fragments, not data positions
|
||||
case "template_literal":
|
||||
// leaves
|
||||
case "string":
|
||||
case "number":
|
||||
case "int":
|
||||
case "boolean":
|
||||
case "bigint":
|
||||
case "symbol":
|
||||
case "undefined":
|
||||
case "null":
|
||||
case "void":
|
||||
case "never":
|
||||
case "any":
|
||||
case "unknown":
|
||||
case "date":
|
||||
case "nan":
|
||||
case "enum":
|
||||
case "literal":
|
||||
case "file":
|
||||
case "transform":
|
||||
case "custom":
|
||||
break;
|
||||
default: {
|
||||
// a new built-in kind becomes a compile error here
|
||||
kind;
|
||||
// a user-defined kind can still hold children, and only its author knows where, so fall back to scanning the def — skipping accessors, since reading one can run user code
|
||||
for (const key in def) {
|
||||
const desc = Object.getOwnPropertyDescriptor(def, key);
|
||||
if (!desc || desc.get)
|
||||
continue;
|
||||
const value = desc.value;
|
||||
if (!value || typeof value !== "object")
|
||||
continue;
|
||||
if (value._zod)
|
||||
check(value);
|
||||
else if (Array.isArray(value))
|
||||
for (const el of value)
|
||||
check(el);
|
||||
}
|
||||
}
|
||||
}
|
||||
stack.delete(inst);
|
||||
return settle(inst, result);
|
||||
}
|
||||
/** An assumed answer must not outlive the resolution that settles it, so only a certain one is cached. */
|
||||
function settle(inst, answer) {
|
||||
if (answer !== ASSUMED)
|
||||
recursive.set(inst, answer === PROVEN);
|
||||
return answer;
|
||||
}
|
||||
/**
|
||||
* Whether one parse can re-enter this schema, i.e. its subtree contains a cycle.
|
||||
* Exported for `z.compile`, which refuses to compile such a schema: cycle
|
||||
* breaking is driven from here off state keyed on the parse context, and a
|
||||
* generated fast path has no context to key on.
|
||||
*/
|
||||
function isRecursiveSchema(inst) {
|
||||
// z.compile never parses, so nothing would ever resolve a lazy for it; it runs once and already treats a throw here as recursive
|
||||
return isRecursive(inst, new Set(), true) !== NONE;
|
||||
}
|
||||
function bucketFor(state, inst) {
|
||||
let bucket = state.buckets.get(inst);
|
||||
if (!bucket) {
|
||||
bucket = new WeakMap();
|
||||
state.buckets.set(inst, bucket);
|
||||
}
|
||||
return bucket;
|
||||
}
|
||||
// Set immediately before delegating to core and cleared immediately after, so `alloc` registers only for a visit this module is driving.
|
||||
let handoff;
|
||||
// Allocated but unfinished entries. `alloc` and the matching pop both happen in the synchronous part of a parse, so they nest even when children are async, and one stack serves every schema.
|
||||
const open = [];
|
||||
const memo = {
|
||||
alloc(_inst, payload, empty) {
|
||||
const bucket = handoff;
|
||||
if (!bucket)
|
||||
return empty;
|
||||
handoff = undefined;
|
||||
const entry = { value: empty, issues: null };
|
||||
bucket.set(payload.value, entry);
|
||||
open.push(entry);
|
||||
return empty;
|
||||
},
|
||||
guard(inst) {
|
||||
var _a;
|
||||
(_a = inst._zod).deferred ?? (_a.deferred = []);
|
||||
inst._zod.deferred.push(() => {
|
||||
const base = inst._zod.parse;
|
||||
const wrapped = (payload, ctx) => {
|
||||
// The value is a placeholder a back-edge is still waiting on, so the cycle closes through this transform. Its output can't exist in time to bind.
|
||||
if (ctx.direction !== "backward" && isBackEdge(ctx, payload.value))
|
||||
throw new $ZodCyclicError();
|
||||
return base(payload, ctx);
|
||||
};
|
||||
inst._zod.parse = wrapped;
|
||||
if (inst._zod.run === base)
|
||||
inst._zod.run = wrapped;
|
||||
});
|
||||
},
|
||||
attach(inst) {
|
||||
var _a;
|
||||
let isRecursiveInst;
|
||||
let rechecked = false;
|
||||
// a recursive schema is re-entered many times per parse and its bucket never changes
|
||||
let lastCtx;
|
||||
let lastBucket;
|
||||
// Wraps `parse` in a deferred so it sees the container's final parse. Core's own deferred copies `parse` into `run` when there are no checks, and it ran first, so `run` is patched to match; with checks, `run` reads `parse` dynamically.
|
||||
(_a = inst._zod).deferred ?? (_a.deferred = []);
|
||||
inst._zod.deferred.push(() => {
|
||||
const base = inst._zod.parse;
|
||||
const wrapped = (payload, ctx) => {
|
||||
if (isRecursiveInst === undefined) {
|
||||
const walked = isRecursive(inst, new Set(), false);
|
||||
if (walked === NONE) {
|
||||
// Nothing here can ever fire, so take it back out.
|
||||
inst._zod.parse = base;
|
||||
if (inst._zod.run === wrapped)
|
||||
inst._zod.run = base;
|
||||
return base(payload, ctx);
|
||||
}
|
||||
// this parse resolves the deferred edges on its own path, so ask once more before latching
|
||||
if (walked === PROVEN || rechecked)
|
||||
isRecursiveInst = true;
|
||||
else
|
||||
rechecked = true;
|
||||
}
|
||||
const input = payload.value;
|
||||
if (!isRef(input))
|
||||
return base(payload, ctx);
|
||||
let state = ctx[STATE];
|
||||
if (!state) {
|
||||
state = { buckets: new WeakMap(), backEdges: undefined };
|
||||
ctx[STATE] = state;
|
||||
}
|
||||
let bucket;
|
||||
if (lastCtx === ctx) {
|
||||
bucket = lastBucket;
|
||||
}
|
||||
else {
|
||||
bucket = bucketFor(state, inst);
|
||||
lastCtx = ctx;
|
||||
lastBucket = bucket;
|
||||
}
|
||||
const hit = bucket.get(input);
|
||||
if (hit) {
|
||||
payload.value = hit.value;
|
||||
if (hit.issues) {
|
||||
if (hit.issues.length)
|
||||
payload.issues.push(...cloneIssues(hit.issues));
|
||||
}
|
||||
else {
|
||||
// Still being parsed: its own checks cover it, so skip them here.
|
||||
payload.memo = true;
|
||||
state.backEdges ?? (state.backEdges = new WeakSet());
|
||||
state.backEdges.add(hit.value);
|
||||
}
|
||||
return payload;
|
||||
}
|
||||
handoff = bucket;
|
||||
const depth = open.length;
|
||||
const result = base(payload, ctx);
|
||||
handoff = undefined;
|
||||
// A container that rejected its input outright allocated nothing.
|
||||
const entry = open.length > depth ? open.pop() : undefined;
|
||||
// Both paths written out so the sync one allocates no closure. It runs once per node, and capturing here cost more than everything else combined.
|
||||
if (result instanceof Promise) {
|
||||
return result.then((r) => {
|
||||
if (entry)
|
||||
entry.issues = r.issues.length ? cloneIssues(r.issues) : NO_ISSUES;
|
||||
return r;
|
||||
});
|
||||
}
|
||||
if (entry)
|
||||
entry.issues = result.issues.length ? cloneIssues(result.issues) : NO_ISSUES;
|
||||
return result;
|
||||
};
|
||||
inst._zod.parse = wrapped;
|
||||
if (inst._zod.run === base)
|
||||
inst._zod.run = wrapped;
|
||||
});
|
||||
},
|
||||
};
|
||||
/** The memoizer that gives containers cycle support. `zod` installs it by default; `zod/mini` opts in with `config({ memoizer: memoizer() })`. */
|
||||
function memoizer() {
|
||||
return memo;
|
||||
}
|
||||
/** Whether this value is a node a back-edge resolved to before it finished. */
|
||||
function isBackEdge(ctx, value) {
|
||||
const backEdges = ctx[STATE]?.backEdges;
|
||||
return backEdges !== undefined && isRef(value) && backEdges.has(value);
|
||||
}
|
||||
|
||||
// seal-cjs-exports
|
||||
(function () {
|
||||
var keys = Object.getOwnPropertyNames(exports);
|
||||
for (var i = 0; i < keys.length; i++) {
|
||||
var desc = Object.getOwnPropertyDescriptor(exports, keys[i]);
|
||||
if (!desc || !desc.get || !desc.configurable) continue;
|
||||
var value;
|
||||
try {
|
||||
value = desc.get();
|
||||
} catch (e) {
|
||||
continue;
|
||||
}
|
||||
// a circular require may not have settled this one yet, so leave it live
|
||||
if (value === undefined) continue;
|
||||
Object.defineProperty(exports, keys[i], { value: value, writable: false, enumerable: desc.enumerable, configurable: false });
|
||||
}
|
||||
Object.freeze(exports);
|
||||
})();
|
||||
+15
@@ -0,0 +1,15 @@
|
||||
import type { $ZodMemoizer, $ZodType } from "./schemas.cjs";
|
||||
export declare class $ZodCyclicError extends Error {
|
||||
constructor();
|
||||
}
|
||||
/**
|
||||
* Whether one parse can re-enter this schema, i.e. its subtree contains a cycle.
|
||||
* Exported for `z.compile`, which refuses to compile such a schema: cycle
|
||||
* breaking is driven from here off state keyed on the parse context, and a
|
||||
* generated fast path has no context to key on.
|
||||
*/
|
||||
export declare function isRecursiveSchema(inst: $ZodType): boolean;
|
||||
/** The memoizer that gives containers cycle support. `zod` installs it by default; `zod/mini` opts in with `config({ memoizer: memoizer() })`. */
|
||||
export declare function memoizer(): $ZodMemoizer;
|
||||
/** Whether this value is a node a back-edge resolved to before it finished. */
|
||||
export declare function isBackEdge(ctx: object, value: unknown): boolean;
|
||||
+15
@@ -0,0 +1,15 @@
|
||||
import type { $ZodMemoizer, $ZodType } from "./schemas.js";
|
||||
export declare class $ZodCyclicError extends Error {
|
||||
constructor();
|
||||
}
|
||||
/**
|
||||
* Whether one parse can re-enter this schema, i.e. its subtree contains a cycle.
|
||||
* Exported for `z.compile`, which refuses to compile such a schema: cycle
|
||||
* breaking is driven from here off state keyed on the parse context, and a
|
||||
* generated fast path has no context to key on.
|
||||
*/
|
||||
export declare function isRecursiveSchema(inst: $ZodType): boolean;
|
||||
/** The memoizer that gives containers cycle support. `zod` installs it by default; `zod/mini` opts in with `config({ memoizer: memoizer() })`. */
|
||||
export declare function memoizer(): $ZodMemoizer;
|
||||
/** Whether this value is a node a back-edge resolved to before it finished. */
|
||||
export declare function isBackEdge(ctx: object, value: unknown): boolean;
|
||||
+311
@@ -0,0 +1,311 @@
|
||||
import * as util from "./util.js";
|
||||
export class $ZodCyclicError extends Error {
|
||||
constructor() {
|
||||
super(`Cannot parse a reference cycle that closes through a transform`);
|
||||
this.name = "ZodCyclicError";
|
||||
}
|
||||
}
|
||||
/** Keyed off the context object every schema in one parse call already shares. */
|
||||
const STATE = "~memo";
|
||||
const NO_ISSUES = [];
|
||||
// a value a cycle can close through
|
||||
function isRef(value) {
|
||||
return value !== null && typeof value === "object";
|
||||
}
|
||||
// Receivers prefix paths in place, so the cache and every hand-out need their own copies.
|
||||
function cloneIssues(issues) {
|
||||
return issues.map((iss) => (iss.path ? { ...iss, path: iss.path.slice() } : { ...iss }));
|
||||
}
|
||||
const recursive = /*@__PURE__*/ new WeakMap();
|
||||
/** What the walk established, in order of certainty: ordered so the strongest answer among children wins. */
|
||||
const NONE = 0;
|
||||
const ASSUMED = 1;
|
||||
const PROVEN = 2;
|
||||
/** Whether this schema's subtree contains a cycle, so one parse can re-enter it. */
|
||||
function isRecursive(inst, stack, resolve) {
|
||||
const cached = recursive.get(inst);
|
||||
if (cached !== undefined)
|
||||
return cached ? PROVEN : NONE;
|
||||
// Relative to the walk in progress, so not cached.
|
||||
if (stack.has(inst))
|
||||
return PROVEN;
|
||||
stack.add(inst);
|
||||
let result = NONE;
|
||||
const check = (child) => {
|
||||
if (result !== PROVEN && child?._zod) {
|
||||
const answer = isRecursive(child, stack, resolve);
|
||||
if (answer > result)
|
||||
result = answer;
|
||||
}
|
||||
};
|
||||
// `Reflect.ownKeys` rather than `Object.keys`, so a cycle through a declared symbol key is still seen
|
||||
const shape = (sh, spread) => {
|
||||
let answer = NONE;
|
||||
for (const key of Reflect.ownKeys(sh)) {
|
||||
const desc = Object.getOwnPropertyDescriptor(sh, key);
|
||||
// an object resolves its shape by spread, so a key it does not enumerate is never parsed; `z.properties` reads every own key and so keeps them all
|
||||
if (spread && !desc.enumerable)
|
||||
continue;
|
||||
// resolving runs user code, and a factory mints a fresh subtree per read, so an edge the walk can't follow counts as a cycle
|
||||
const child = desc.get ? ASSUMED : desc.value?._zod ? isRecursive(desc.value, stack, resolve) : NONE;
|
||||
if (child > answer)
|
||||
answer = child;
|
||||
}
|
||||
return answer;
|
||||
};
|
||||
const merge = (answer) => {
|
||||
if (answer > result)
|
||||
result = answer;
|
||||
};
|
||||
const def = inst._zod.def;
|
||||
const kind = def.type;
|
||||
switch (kind) {
|
||||
case "object": {
|
||||
const raw = util.rawShape(def);
|
||||
// a def with no raw shape answers `shape` from an accessor of its own, and running that can mint a whole fresh subtree
|
||||
merge(raw ? shape(raw, true) : ASSUMED);
|
||||
check(def.catchall);
|
||||
break;
|
||||
}
|
||||
case "array":
|
||||
check(def.element);
|
||||
break;
|
||||
case "tuple":
|
||||
for (const el of def.items)
|
||||
check(el);
|
||||
check(def.rest);
|
||||
break;
|
||||
case "record":
|
||||
case "map":
|
||||
check(def.keyType);
|
||||
check(def.valueType);
|
||||
break;
|
||||
case "set":
|
||||
check(def.valueType);
|
||||
break;
|
||||
case "union":
|
||||
for (const el of def.options)
|
||||
check(el);
|
||||
break;
|
||||
case "intersection":
|
||||
check(def.left);
|
||||
check(def.right);
|
||||
break;
|
||||
case "optional":
|
||||
case "nullable":
|
||||
case "default":
|
||||
case "prefault":
|
||||
case "catch":
|
||||
case "readonly":
|
||||
case "nonoptional":
|
||||
case "promise":
|
||||
case "success":
|
||||
check(def.innerType);
|
||||
break;
|
||||
case "pipe":
|
||||
check(def.in);
|
||||
check(def.out);
|
||||
break;
|
||||
case "function":
|
||||
check(def.input);
|
||||
check(def.output);
|
||||
break;
|
||||
// `$ZodLazy` caches its inner on the def, so a resolved edge is followed exactly
|
||||
case "lazy": {
|
||||
const inner = def._cachedInner ?? (resolve ? inst._zod.innerType : undefined);
|
||||
// walked with resolution off: one hop sees past the deferral, and a lazy that yields only another unresolved lazy is generative, so it stops there
|
||||
merge(inner ? isRecursive(inner, stack, false) : ASSUMED);
|
||||
break;
|
||||
}
|
||||
// a leaf by choice: `parts` are regex fragments, not data positions
|
||||
case "template_literal":
|
||||
// leaves
|
||||
case "string":
|
||||
case "number":
|
||||
case "int":
|
||||
case "boolean":
|
||||
case "bigint":
|
||||
case "symbol":
|
||||
case "undefined":
|
||||
case "null":
|
||||
case "void":
|
||||
case "never":
|
||||
case "any":
|
||||
case "unknown":
|
||||
case "date":
|
||||
case "nan":
|
||||
case "enum":
|
||||
case "literal":
|
||||
case "file":
|
||||
case "transform":
|
||||
case "custom":
|
||||
break;
|
||||
default: {
|
||||
// a new built-in kind becomes a compile error here
|
||||
kind;
|
||||
// a user-defined kind can still hold children, and only its author knows where, so fall back to scanning the def — skipping accessors, since reading one can run user code
|
||||
for (const key in def) {
|
||||
const desc = Object.getOwnPropertyDescriptor(def, key);
|
||||
if (!desc || desc.get)
|
||||
continue;
|
||||
const value = desc.value;
|
||||
if (!value || typeof value !== "object")
|
||||
continue;
|
||||
if (value._zod)
|
||||
check(value);
|
||||
else if (Array.isArray(value))
|
||||
for (const el of value)
|
||||
check(el);
|
||||
}
|
||||
}
|
||||
}
|
||||
stack.delete(inst);
|
||||
return settle(inst, result);
|
||||
}
|
||||
/** An assumed answer must not outlive the resolution that settles it, so only a certain one is cached. */
|
||||
function settle(inst, answer) {
|
||||
if (answer !== ASSUMED)
|
||||
recursive.set(inst, answer === PROVEN);
|
||||
return answer;
|
||||
}
|
||||
/**
|
||||
* Whether one parse can re-enter this schema, i.e. its subtree contains a cycle.
|
||||
* Exported for `z.compile`, which refuses to compile such a schema: cycle
|
||||
* breaking is driven from here off state keyed on the parse context, and a
|
||||
* generated fast path has no context to key on.
|
||||
*/
|
||||
export function isRecursiveSchema(inst) {
|
||||
// z.compile never parses, so nothing would ever resolve a lazy for it; it runs once and already treats a throw here as recursive
|
||||
return isRecursive(inst, new Set(), true) !== NONE;
|
||||
}
|
||||
function bucketFor(state, inst) {
|
||||
let bucket = state.buckets.get(inst);
|
||||
if (!bucket) {
|
||||
bucket = new WeakMap();
|
||||
state.buckets.set(inst, bucket);
|
||||
}
|
||||
return bucket;
|
||||
}
|
||||
// Set immediately before delegating to core and cleared immediately after, so `alloc` registers only for a visit this module is driving.
|
||||
let handoff;
|
||||
// Allocated but unfinished entries. `alloc` and the matching pop both happen in the synchronous part of a parse, so they nest even when children are async, and one stack serves every schema.
|
||||
const open = [];
|
||||
const memo = {
|
||||
alloc(_inst, payload, empty) {
|
||||
const bucket = handoff;
|
||||
if (!bucket)
|
||||
return empty;
|
||||
handoff = undefined;
|
||||
const entry = { value: empty, issues: null };
|
||||
bucket.set(payload.value, entry);
|
||||
open.push(entry);
|
||||
return empty;
|
||||
},
|
||||
guard(inst) {
|
||||
var _a;
|
||||
(_a = inst._zod).deferred ?? (_a.deferred = []);
|
||||
inst._zod.deferred.push(() => {
|
||||
const base = inst._zod.parse;
|
||||
const wrapped = (payload, ctx) => {
|
||||
// The value is a placeholder a back-edge is still waiting on, so the cycle closes through this transform. Its output can't exist in time to bind.
|
||||
if (ctx.direction !== "backward" && isBackEdge(ctx, payload.value))
|
||||
throw new $ZodCyclicError();
|
||||
return base(payload, ctx);
|
||||
};
|
||||
inst._zod.parse = wrapped;
|
||||
if (inst._zod.run === base)
|
||||
inst._zod.run = wrapped;
|
||||
});
|
||||
},
|
||||
attach(inst) {
|
||||
var _a;
|
||||
let isRecursiveInst;
|
||||
let rechecked = false;
|
||||
// a recursive schema is re-entered many times per parse and its bucket never changes
|
||||
let lastCtx;
|
||||
let lastBucket;
|
||||
// Wraps `parse` in a deferred so it sees the container's final parse. Core's own deferred copies `parse` into `run` when there are no checks, and it ran first, so `run` is patched to match; with checks, `run` reads `parse` dynamically.
|
||||
(_a = inst._zod).deferred ?? (_a.deferred = []);
|
||||
inst._zod.deferred.push(() => {
|
||||
const base = inst._zod.parse;
|
||||
const wrapped = (payload, ctx) => {
|
||||
if (isRecursiveInst === undefined) {
|
||||
const walked = isRecursive(inst, new Set(), false);
|
||||
if (walked === NONE) {
|
||||
// Nothing here can ever fire, so take it back out.
|
||||
inst._zod.parse = base;
|
||||
if (inst._zod.run === wrapped)
|
||||
inst._zod.run = base;
|
||||
return base(payload, ctx);
|
||||
}
|
||||
// this parse resolves the deferred edges on its own path, so ask once more before latching
|
||||
if (walked === PROVEN || rechecked)
|
||||
isRecursiveInst = true;
|
||||
else
|
||||
rechecked = true;
|
||||
}
|
||||
const input = payload.value;
|
||||
if (!isRef(input))
|
||||
return base(payload, ctx);
|
||||
let state = ctx[STATE];
|
||||
if (!state) {
|
||||
state = { buckets: new WeakMap(), backEdges: undefined };
|
||||
ctx[STATE] = state;
|
||||
}
|
||||
let bucket;
|
||||
if (lastCtx === ctx) {
|
||||
bucket = lastBucket;
|
||||
}
|
||||
else {
|
||||
bucket = bucketFor(state, inst);
|
||||
lastCtx = ctx;
|
||||
lastBucket = bucket;
|
||||
}
|
||||
const hit = bucket.get(input);
|
||||
if (hit) {
|
||||
payload.value = hit.value;
|
||||
if (hit.issues) {
|
||||
if (hit.issues.length)
|
||||
payload.issues.push(...cloneIssues(hit.issues));
|
||||
}
|
||||
else {
|
||||
// Still being parsed: its own checks cover it, so skip them here.
|
||||
payload.memo = true;
|
||||
state.backEdges ?? (state.backEdges = new WeakSet());
|
||||
state.backEdges.add(hit.value);
|
||||
}
|
||||
return payload;
|
||||
}
|
||||
handoff = bucket;
|
||||
const depth = open.length;
|
||||
const result = base(payload, ctx);
|
||||
handoff = undefined;
|
||||
// A container that rejected its input outright allocated nothing.
|
||||
const entry = open.length > depth ? open.pop() : undefined;
|
||||
// Both paths written out so the sync one allocates no closure. It runs once per node, and capturing here cost more than everything else combined.
|
||||
if (result instanceof Promise) {
|
||||
return result.then((r) => {
|
||||
if (entry)
|
||||
entry.issues = r.issues.length ? cloneIssues(r.issues) : NO_ISSUES;
|
||||
return r;
|
||||
});
|
||||
}
|
||||
if (entry)
|
||||
entry.issues = result.issues.length ? cloneIssues(result.issues) : NO_ISSUES;
|
||||
return result;
|
||||
};
|
||||
inst._zod.parse = wrapped;
|
||||
if (inst._zod.run === base)
|
||||
inst._zod.run = wrapped;
|
||||
});
|
||||
},
|
||||
};
|
||||
/** The memoizer that gives containers cycle support. `zod` installs it by default; `zod/mini` opts in with `config({ memoizer: memoizer() })`. */
|
||||
export function memoizer() {
|
||||
return memo;
|
||||
}
|
||||
/** Whether this value is a node a back-edge resolved to before it finished. */
|
||||
export function isBackEdge(ctx, value) {
|
||||
const backEdges = ctx[STATE]?.backEdges;
|
||||
return backEdges !== undefined && isRef(value) && backEdges.has(value);
|
||||
}
|
||||
+7
@@ -0,0 +1,7 @@
|
||||
{
|
||||
"type": "module",
|
||||
"main": "./index.cjs",
|
||||
"module": "./index.js",
|
||||
"types": "./index.d.cts",
|
||||
"sideEffects": false
|
||||
}
|
||||
+233
@@ -0,0 +1,233 @@
|
||||
"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.safeDecodeAsync = exports._safeDecodeAsync = exports.safeEncodeAsync = exports._safeEncodeAsync = exports.safeDecode = exports._safeDecode = exports.safeEncode = exports._safeEncode = exports.decodeAsync = exports._decodeAsync = exports.encodeAsync = exports._encodeAsync = exports.decode = exports._decode = exports.encode = exports._encode = exports.validateAsync = exports.validate = exports.safeParseAsync = exports._safeParseAsync = exports.safeParse = exports._safeParse = exports.parseAsync = exports._parseAsync = exports.parse = exports._parse = void 0;
|
||||
const core = __importStar(require("./core.cjs"));
|
||||
const errors = __importStar(require("./errors.cjs"));
|
||||
const util = __importStar(require("./util.cjs"));
|
||||
// Always both keys, so the `_params` read site in `_parse` sees one object shape rather than two.
|
||||
function finalizeParams(callee, params) {
|
||||
return { callee: params?.callee ?? callee, Err: params?.Err };
|
||||
}
|
||||
const _parse = (_Err) => {
|
||||
const fn = (schema, value, _ctx, _params) => {
|
||||
const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
|
||||
const result = schema._zod.run({ value, issues: [] }, ctx);
|
||||
if (result instanceof Promise) {
|
||||
throw new core.$ZodAsyncError();
|
||||
}
|
||||
if (result.issues.length) {
|
||||
const e = new (_params?.Err ?? _Err)(result.issues.map((iss) => util.finalizeIssue(iss, ctx, core.config())));
|
||||
util.captureStackTrace(e, _params?.callee ?? fn);
|
||||
throw e;
|
||||
}
|
||||
return result.value;
|
||||
};
|
||||
return fn;
|
||||
};
|
||||
exports._parse = _parse;
|
||||
exports.parse = (0, exports._parse)(errors.$ZodRealError);
|
||||
const _parseAsync = (_Err) => {
|
||||
const fn = async (schema, value, _ctx, params) => {
|
||||
const ctx = _ctx ? { ..._ctx, async: true } : { async: true };
|
||||
let result = schema._zod.run({ value, issues: [] }, ctx);
|
||||
if (result instanceof Promise)
|
||||
result = await result;
|
||||
if (result.issues.length) {
|
||||
const e = new (params?.Err ?? _Err)(result.issues.map((iss) => util.finalizeIssue(iss, ctx, core.config())));
|
||||
util.captureStackTrace(e, params?.callee ?? fn);
|
||||
throw e;
|
||||
}
|
||||
return result.value;
|
||||
};
|
||||
return fn;
|
||||
};
|
||||
exports._parseAsync = _parseAsync;
|
||||
exports.parseAsync = (0, exports._parseAsync)(errors.$ZodRealError);
|
||||
const _safeParse = (_Err) => (schema, value, _ctx) => {
|
||||
const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
|
||||
const result = schema._zod.run({ value, issues: [] }, ctx);
|
||||
if (result instanceof Promise) {
|
||||
throw new core.$ZodAsyncError();
|
||||
}
|
||||
return result.issues.length ? failure(_Err, result.issues, ctx) : { success: true, data: result.value };
|
||||
};
|
||||
exports._safeParse = _safeParse;
|
||||
exports.safeParse = (0, exports._safeParse)(errors.$ZodRealError);
|
||||
// the error is built on the first read of `error`: finalizing the issues and constructing the instance is most of a failing parse, and a caller that only branches on `success` never pays it. a getter in the literal keeps this small; the alternative, one shared accessor descriptor plus a hidden state slot, reads ~15% faster but costs ~75 B gzipped in every bundle
|
||||
function failure(Err, issues, ctx) {
|
||||
let error;
|
||||
return {
|
||||
success: false,
|
||||
get error() {
|
||||
if (!error) {
|
||||
error = new Err(issues.map((iss) => util.finalizeIssue(iss, ctx, core.config())));
|
||||
// finalizeIssue drops `input`, so the built error holds nothing; keeping the raw issues past this point pins the parsed value for the life of the result
|
||||
issues = undefined;
|
||||
ctx = undefined;
|
||||
}
|
||||
return error;
|
||||
},
|
||||
set error(e) {
|
||||
error = e;
|
||||
// a replacement makes the getter's branch unreachable, so the captures have to go here too
|
||||
issues = undefined;
|
||||
ctx = undefined;
|
||||
},
|
||||
};
|
||||
}
|
||||
const _safeParseAsync = (_Err) => async (schema, value, _ctx) => {
|
||||
const ctx = _ctx ? { ..._ctx, async: true } : { async: true };
|
||||
let result = schema._zod.run({ value, issues: [] }, ctx);
|
||||
if (result instanceof Promise)
|
||||
result = await result;
|
||||
return result.issues.length ? failure(_Err, result.issues, ctx) : { success: true, data: result.value };
|
||||
};
|
||||
exports._safeParseAsync = _safeParseAsync;
|
||||
exports.safeParseAsync = (0, exports._safeParseAsync)(errors.$ZodRealError);
|
||||
// registry mirrors of the compiler's sentinels, so this module never imports the compiler
|
||||
const COMPILE_INVALID = /* @__PURE__ */ Symbol.for("zod.compile.invalid");
|
||||
const COMPILE_FALLBACK = /* @__PURE__ */ Symbol.for("zod.compile.fallback");
|
||||
// Deliberately tiny, because v8 will not inline a body carrying the fallback's object literals and throw. Everything that is not the compiled happy path lives in validateFallback, and that split is worth ~35% on a compiled schema.
|
||||
exports.validate = ((schema, value, _ctx) => {
|
||||
const validator = schema._zod.bag.validator;
|
||||
if (validator !== undefined) {
|
||||
if (validator(value) !== COMPILE_INVALID)
|
||||
return true;
|
||||
// a definite sentinel means the runtime would reject, so skip the re-parse; a ctx can still change the answer
|
||||
if (validator.definite === true && _ctx === undefined)
|
||||
return false;
|
||||
}
|
||||
return validateFallback(schema, value, _ctx);
|
||||
});
|
||||
function validateFallback(schema, value, _ctx) {
|
||||
const ctx = _ctx
|
||||
? { ..._ctx, async: false, abortEarly: true }
|
||||
: { async: false, abortEarly: true };
|
||||
const fallbackRun = schema._zod.bag.fallbackRun;
|
||||
let result;
|
||||
if (fallbackRun) {
|
||||
// skip nested fast paths on the fallback, so user callbacks keep the at-most-twice bound
|
||||
ctx[COMPILE_FALLBACK] = true;
|
||||
result = fallbackRun({ value, issues: [] }, ctx);
|
||||
}
|
||||
else {
|
||||
result = schema._zod.run({ value, issues: [] }, ctx);
|
||||
}
|
||||
if (result instanceof Promise) {
|
||||
throw new core.$ZodAsyncError();
|
||||
}
|
||||
return result.issues.length === 0;
|
||||
}
|
||||
// no fast path: the compiler keeps async parses on the runtime, because a promise-returning callback that is not declared async compiles to a throw
|
||||
const validateAsync = async (schema, value, _ctx) => {
|
||||
const ctx = _ctx
|
||||
? { ..._ctx, async: true, abortEarly: true }
|
||||
: { async: true, abortEarly: true };
|
||||
let result = schema._zod.run({ value, issues: [] }, ctx);
|
||||
if (result instanceof Promise)
|
||||
result = await result;
|
||||
return result.issues.length === 0;
|
||||
};
|
||||
exports.validateAsync = validateAsync;
|
||||
const _encode = (_Err) => {
|
||||
const parse = (0, exports._parse)(_Err);
|
||||
const fn = (schema, value, _ctx, _params) => {
|
||||
const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
|
||||
return parse(schema, value, ctx, finalizeParams(fn, _params));
|
||||
};
|
||||
return fn;
|
||||
};
|
||||
exports._encode = _encode;
|
||||
exports.encode = (0, exports._encode)(errors.$ZodRealError);
|
||||
const _decode = (_Err) => {
|
||||
const parse = (0, exports._parse)(_Err);
|
||||
const fn = (schema, value, _ctx, _params) => {
|
||||
return parse(schema, value, _ctx, finalizeParams(fn, _params));
|
||||
};
|
||||
return fn;
|
||||
};
|
||||
exports._decode = _decode;
|
||||
exports.decode = (0, exports._decode)(errors.$ZodRealError);
|
||||
const _encodeAsync = (_Err) => {
|
||||
const parseAsync = (0, exports._parseAsync)(_Err);
|
||||
const fn = async (schema, value, _ctx, _params) => {
|
||||
const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
|
||||
return (await parseAsync(schema, value, ctx, finalizeParams(fn, _params)));
|
||||
};
|
||||
return fn;
|
||||
};
|
||||
exports._encodeAsync = _encodeAsync;
|
||||
exports.encodeAsync = (0, exports._encodeAsync)(errors.$ZodRealError);
|
||||
const _decodeAsync = (_Err) => {
|
||||
const parseAsync = (0, exports._parseAsync)(_Err);
|
||||
const fn = async (schema, value, _ctx, _params) => {
|
||||
return await parseAsync(schema, value, _ctx, finalizeParams(fn, _params));
|
||||
};
|
||||
return fn;
|
||||
};
|
||||
exports._decodeAsync = _decodeAsync;
|
||||
exports.decodeAsync = (0, exports._decodeAsync)(errors.$ZodRealError);
|
||||
const _safeEncode = (_Err) => (schema, value, _ctx) => {
|
||||
const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
|
||||
return (0, exports._safeParse)(_Err)(schema, value, ctx);
|
||||
};
|
||||
exports._safeEncode = _safeEncode;
|
||||
exports.safeEncode = (0, exports._safeEncode)(errors.$ZodRealError);
|
||||
const _safeDecode = (_Err) => (schema, value, _ctx) => {
|
||||
return (0, exports._safeParse)(_Err)(schema, value, _ctx);
|
||||
};
|
||||
exports._safeDecode = _safeDecode;
|
||||
exports.safeDecode = (0, exports._safeDecode)(errors.$ZodRealError);
|
||||
const _safeEncodeAsync = (_Err) => async (schema, value, _ctx) => {
|
||||
const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
|
||||
return (0, exports._safeParseAsync)(_Err)(schema, value, ctx);
|
||||
};
|
||||
exports._safeEncodeAsync = _safeEncodeAsync;
|
||||
exports.safeEncodeAsync = (0, exports._safeEncodeAsync)(errors.$ZodRealError);
|
||||
const _safeDecodeAsync = (_Err) => async (schema, value, _ctx) => {
|
||||
return (0, exports._safeParseAsync)(_Err)(schema, value, _ctx);
|
||||
};
|
||||
exports._safeDecodeAsync = _safeDecodeAsync;
|
||||
exports.safeDecodeAsync = (0, exports._safeDecodeAsync)(errors.$ZodRealError);
|
||||
|
||||
// seal-cjs-exports
|
||||
(function () {
|
||||
var keys = Object.getOwnPropertyNames(exports);
|
||||
for (var i = 0; i < keys.length; i++) {
|
||||
var desc = Object.getOwnPropertyDescriptor(exports, keys[i]);
|
||||
if (!desc || !desc.get || !desc.configurable) continue;
|
||||
var value;
|
||||
try {
|
||||
value = desc.get();
|
||||
} catch (e) {
|
||||
continue;
|
||||
}
|
||||
// a circular require may not have settled this one yet, so leave it live
|
||||
if (value === undefined) continue;
|
||||
Object.defineProperty(exports, keys[i], { value: value, writable: false, enumerable: desc.enumerable, configurable: false });
|
||||
}
|
||||
Object.freeze(exports);
|
||||
})();
|
||||
+52
@@ -0,0 +1,52 @@
|
||||
import * as core from "./core.cjs";
|
||||
import * as errors from "./errors.cjs";
|
||||
import type * as schemas from "./schemas.cjs";
|
||||
import * as util from "./util.cjs";
|
||||
export type $ZodErrorClass = {
|
||||
new (issues: errors.$ZodIssue[]): errors.$ZodError;
|
||||
};
|
||||
type $ParseParams = {
|
||||
callee?: util.AnyFunc;
|
||||
Err?: $ZodErrorClass | undefined;
|
||||
};
|
||||
export type $Parse = <T extends schemas.$ZodType>(schema: T, value: unknown, _ctx?: schemas.ParseContext<errors.$ZodIssue>, _params?: $ParseParams) => core.output<T>;
|
||||
export declare const _parse: (_Err: $ZodErrorClass) => $Parse;
|
||||
export declare const parse: $Parse;
|
||||
export type $ParseAsync = <T extends schemas.$ZodType>(schema: T, value: unknown, _ctx?: schemas.ParseContext<errors.$ZodIssue>, _params?: $ParseParams) => Promise<core.output<T>>;
|
||||
export declare const _parseAsync: (_Err: $ZodErrorClass) => $ParseAsync;
|
||||
export declare const parseAsync: $ParseAsync;
|
||||
export type $SafeParse = <T extends schemas.$ZodType>(schema: T, value: unknown, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => util.SafeParseResult<core.output<T>>;
|
||||
export declare const _safeParse: (_Err: $ZodErrorClass) => $SafeParse;
|
||||
export declare const safeParse: $SafeParse;
|
||||
export type $SafeParseAsync = <T extends schemas.$ZodType>(schema: T, value: unknown, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => Promise<util.SafeParseResult<core.output<T>>>;
|
||||
export declare const _safeParseAsync: (_Err: $ZodErrorClass) => $SafeParseAsync;
|
||||
export declare const safeParseAsync: $SafeParseAsync;
|
||||
export type $Validate = <T extends schemas.$ZodType>(schema: T, value: unknown, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => value is core.input<T>;
|
||||
export declare const validate: $Validate;
|
||||
export type $ValidateAsync = <T extends schemas.$ZodType>(schema: T, value: unknown, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => Promise<boolean>;
|
||||
export declare const validateAsync: $ValidateAsync;
|
||||
export type $Encode = <T extends schemas.$ZodType>(schema: T, value: core.output<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>, _params?: $ParseParams) => core.input<T>;
|
||||
export declare const _encode: (_Err: $ZodErrorClass) => $Encode;
|
||||
export declare const encode: $Encode;
|
||||
export type $Decode = <T extends schemas.$ZodType>(schema: T, value: core.input<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>, _params?: $ParseParams) => core.output<T>;
|
||||
export declare const _decode: (_Err: $ZodErrorClass) => $Decode;
|
||||
export declare const decode: $Decode;
|
||||
export type $EncodeAsync = <T extends schemas.$ZodType>(schema: T, value: core.output<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>, _params?: $ParseParams) => Promise<core.input<T>>;
|
||||
export declare const _encodeAsync: (_Err: $ZodErrorClass) => $EncodeAsync;
|
||||
export declare const encodeAsync: $EncodeAsync;
|
||||
export type $DecodeAsync = <T extends schemas.$ZodType>(schema: T, value: core.input<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>, _params?: $ParseParams) => Promise<core.output<T>>;
|
||||
export declare const _decodeAsync: (_Err: $ZodErrorClass) => $DecodeAsync;
|
||||
export declare const decodeAsync: $DecodeAsync;
|
||||
export type $SafeEncode = <T extends schemas.$ZodType>(schema: T, value: core.output<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => util.SafeParseResult<core.input<T>>;
|
||||
export declare const _safeEncode: (_Err: $ZodErrorClass) => $SafeEncode;
|
||||
export declare const safeEncode: $SafeEncode;
|
||||
export type $SafeDecode = <T extends schemas.$ZodType>(schema: T, value: core.input<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => util.SafeParseResult<core.output<T>>;
|
||||
export declare const _safeDecode: (_Err: $ZodErrorClass) => $SafeDecode;
|
||||
export declare const safeDecode: $SafeDecode;
|
||||
export type $SafeEncodeAsync = <T extends schemas.$ZodType>(schema: T, value: core.output<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => Promise<util.SafeParseResult<core.input<T>>>;
|
||||
export declare const _safeEncodeAsync: (_Err: $ZodErrorClass) => $SafeEncodeAsync;
|
||||
export declare const safeEncodeAsync: $SafeEncodeAsync;
|
||||
export type $SafeDecodeAsync = <T extends schemas.$ZodType>(schema: T, value: core.input<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => Promise<util.SafeParseResult<core.output<T>>>;
|
||||
export declare const _safeDecodeAsync: (_Err: $ZodErrorClass) => $SafeDecodeAsync;
|
||||
export declare const safeDecodeAsync: $SafeDecodeAsync;
|
||||
export {};
|
||||
+52
@@ -0,0 +1,52 @@
|
||||
import * as core from "./core.js";
|
||||
import * as errors from "./errors.js";
|
||||
import type * as schemas from "./schemas.js";
|
||||
import * as util from "./util.js";
|
||||
export type $ZodErrorClass = {
|
||||
new (issues: errors.$ZodIssue[]): errors.$ZodError;
|
||||
};
|
||||
type $ParseParams = {
|
||||
callee?: util.AnyFunc;
|
||||
Err?: $ZodErrorClass | undefined;
|
||||
};
|
||||
export type $Parse = <T extends schemas.$ZodType>(schema: T, value: unknown, _ctx?: schemas.ParseContext<errors.$ZodIssue>, _params?: $ParseParams) => core.output<T>;
|
||||
export declare const _parse: (_Err: $ZodErrorClass) => $Parse;
|
||||
export declare const parse: $Parse;
|
||||
export type $ParseAsync = <T extends schemas.$ZodType>(schema: T, value: unknown, _ctx?: schemas.ParseContext<errors.$ZodIssue>, _params?: $ParseParams) => Promise<core.output<T>>;
|
||||
export declare const _parseAsync: (_Err: $ZodErrorClass) => $ParseAsync;
|
||||
export declare const parseAsync: $ParseAsync;
|
||||
export type $SafeParse = <T extends schemas.$ZodType>(schema: T, value: unknown, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => util.SafeParseResult<core.output<T>>;
|
||||
export declare const _safeParse: (_Err: $ZodErrorClass) => $SafeParse;
|
||||
export declare const safeParse: $SafeParse;
|
||||
export type $SafeParseAsync = <T extends schemas.$ZodType>(schema: T, value: unknown, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => Promise<util.SafeParseResult<core.output<T>>>;
|
||||
export declare const _safeParseAsync: (_Err: $ZodErrorClass) => $SafeParseAsync;
|
||||
export declare const safeParseAsync: $SafeParseAsync;
|
||||
export type $Validate = <T extends schemas.$ZodType>(schema: T, value: unknown, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => value is core.input<T>;
|
||||
export declare const validate: $Validate;
|
||||
export type $ValidateAsync = <T extends schemas.$ZodType>(schema: T, value: unknown, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => Promise<boolean>;
|
||||
export declare const validateAsync: $ValidateAsync;
|
||||
export type $Encode = <T extends schemas.$ZodType>(schema: T, value: core.output<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>, _params?: $ParseParams) => core.input<T>;
|
||||
export declare const _encode: (_Err: $ZodErrorClass) => $Encode;
|
||||
export declare const encode: $Encode;
|
||||
export type $Decode = <T extends schemas.$ZodType>(schema: T, value: core.input<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>, _params?: $ParseParams) => core.output<T>;
|
||||
export declare const _decode: (_Err: $ZodErrorClass) => $Decode;
|
||||
export declare const decode: $Decode;
|
||||
export type $EncodeAsync = <T extends schemas.$ZodType>(schema: T, value: core.output<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>, _params?: $ParseParams) => Promise<core.input<T>>;
|
||||
export declare const _encodeAsync: (_Err: $ZodErrorClass) => $EncodeAsync;
|
||||
export declare const encodeAsync: $EncodeAsync;
|
||||
export type $DecodeAsync = <T extends schemas.$ZodType>(schema: T, value: core.input<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>, _params?: $ParseParams) => Promise<core.output<T>>;
|
||||
export declare const _decodeAsync: (_Err: $ZodErrorClass) => $DecodeAsync;
|
||||
export declare const decodeAsync: $DecodeAsync;
|
||||
export type $SafeEncode = <T extends schemas.$ZodType>(schema: T, value: core.output<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => util.SafeParseResult<core.input<T>>;
|
||||
export declare const _safeEncode: (_Err: $ZodErrorClass) => $SafeEncode;
|
||||
export declare const safeEncode: $SafeEncode;
|
||||
export type $SafeDecode = <T extends schemas.$ZodType>(schema: T, value: core.input<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => util.SafeParseResult<core.output<T>>;
|
||||
export declare const _safeDecode: (_Err: $ZodErrorClass) => $SafeDecode;
|
||||
export declare const safeDecode: $SafeDecode;
|
||||
export type $SafeEncodeAsync = <T extends schemas.$ZodType>(schema: T, value: core.output<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => Promise<util.SafeParseResult<core.input<T>>>;
|
||||
export declare const _safeEncodeAsync: (_Err: $ZodErrorClass) => $SafeEncodeAsync;
|
||||
export declare const safeEncodeAsync: $SafeEncodeAsync;
|
||||
export type $SafeDecodeAsync = <T extends schemas.$ZodType>(schema: T, value: core.input<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => Promise<util.SafeParseResult<core.output<T>>>;
|
||||
export declare const _safeDecodeAsync: (_Err: $ZodErrorClass) => $SafeDecodeAsync;
|
||||
export declare const safeDecodeAsync: $SafeDecodeAsync;
|
||||
export {};
|
||||
+175
@@ -0,0 +1,175 @@
|
||||
import * as core from "./core.js";
|
||||
import * as errors from "./errors.js";
|
||||
import * as util from "./util.js";
|
||||
// Always both keys, so the `_params` read site in `_parse` sees one object shape rather than two.
|
||||
function finalizeParams(callee, params) {
|
||||
return { callee: params?.callee ?? callee, Err: params?.Err };
|
||||
}
|
||||
export const _parse = (_Err) => {
|
||||
const fn = (schema, value, _ctx, _params) => {
|
||||
const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
|
||||
const result = schema._zod.run({ value, issues: [] }, ctx);
|
||||
if (result instanceof Promise) {
|
||||
throw new core.$ZodAsyncError();
|
||||
}
|
||||
if (result.issues.length) {
|
||||
const e = new (_params?.Err ?? _Err)(result.issues.map((iss) => util.finalizeIssue(iss, ctx, core.config())));
|
||||
util.captureStackTrace(e, _params?.callee ?? fn);
|
||||
throw e;
|
||||
}
|
||||
return result.value;
|
||||
};
|
||||
return fn;
|
||||
};
|
||||
export const parse = /* @__PURE__*/ _parse(errors.$ZodRealError);
|
||||
export const _parseAsync = (_Err) => {
|
||||
const fn = async (schema, value, _ctx, params) => {
|
||||
const ctx = _ctx ? { ..._ctx, async: true } : { async: true };
|
||||
let result = schema._zod.run({ value, issues: [] }, ctx);
|
||||
if (result instanceof Promise)
|
||||
result = await result;
|
||||
if (result.issues.length) {
|
||||
const e = new (params?.Err ?? _Err)(result.issues.map((iss) => util.finalizeIssue(iss, ctx, core.config())));
|
||||
util.captureStackTrace(e, params?.callee ?? fn);
|
||||
throw e;
|
||||
}
|
||||
return result.value;
|
||||
};
|
||||
return fn;
|
||||
};
|
||||
export const parseAsync = /* @__PURE__*/ _parseAsync(errors.$ZodRealError);
|
||||
export const _safeParse = (_Err) => (schema, value, _ctx) => {
|
||||
const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
|
||||
const result = schema._zod.run({ value, issues: [] }, ctx);
|
||||
if (result instanceof Promise) {
|
||||
throw new core.$ZodAsyncError();
|
||||
}
|
||||
return result.issues.length ? failure(_Err, result.issues, ctx) : { success: true, data: result.value };
|
||||
};
|
||||
export const safeParse = /* @__PURE__*/ _safeParse(errors.$ZodRealError);
|
||||
// the error is built on the first read of `error`: finalizing the issues and constructing the instance is most of a failing parse, and a caller that only branches on `success` never pays it. a getter in the literal keeps this small; the alternative, one shared accessor descriptor plus a hidden state slot, reads ~15% faster but costs ~75 B gzipped in every bundle
|
||||
function failure(Err, issues, ctx) {
|
||||
let error;
|
||||
return {
|
||||
success: false,
|
||||
get error() {
|
||||
if (!error) {
|
||||
error = new Err(issues.map((iss) => util.finalizeIssue(iss, ctx, core.config())));
|
||||
// finalizeIssue drops `input`, so the built error holds nothing; keeping the raw issues past this point pins the parsed value for the life of the result
|
||||
issues = undefined;
|
||||
ctx = undefined;
|
||||
}
|
||||
return error;
|
||||
},
|
||||
set error(e) {
|
||||
error = e;
|
||||
// a replacement makes the getter's branch unreachable, so the captures have to go here too
|
||||
issues = undefined;
|
||||
ctx = undefined;
|
||||
},
|
||||
};
|
||||
}
|
||||
export const _safeParseAsync = (_Err) => async (schema, value, _ctx) => {
|
||||
const ctx = _ctx ? { ..._ctx, async: true } : { async: true };
|
||||
let result = schema._zod.run({ value, issues: [] }, ctx);
|
||||
if (result instanceof Promise)
|
||||
result = await result;
|
||||
return result.issues.length ? failure(_Err, result.issues, ctx) : { success: true, data: result.value };
|
||||
};
|
||||
export const safeParseAsync = /* @__PURE__*/ _safeParseAsync(errors.$ZodRealError);
|
||||
// registry mirrors of the compiler's sentinels, so this module never imports the compiler
|
||||
const COMPILE_INVALID = /* @__PURE__ */ Symbol.for("zod.compile.invalid");
|
||||
const COMPILE_FALLBACK = /* @__PURE__ */ Symbol.for("zod.compile.fallback");
|
||||
// Deliberately tiny, because v8 will not inline a body carrying the fallback's object literals and throw. Everything that is not the compiled happy path lives in validateFallback, and that split is worth ~35% on a compiled schema.
|
||||
export const validate = ((schema, value, _ctx) => {
|
||||
const validator = schema._zod.bag.validator;
|
||||
if (validator !== undefined) {
|
||||
if (validator(value) !== COMPILE_INVALID)
|
||||
return true;
|
||||
// a definite sentinel means the runtime would reject, so skip the re-parse; a ctx can still change the answer
|
||||
if (validator.definite === true && _ctx === undefined)
|
||||
return false;
|
||||
}
|
||||
return validateFallback(schema, value, _ctx);
|
||||
});
|
||||
function validateFallback(schema, value, _ctx) {
|
||||
const ctx = _ctx
|
||||
? { ..._ctx, async: false, abortEarly: true }
|
||||
: { async: false, abortEarly: true };
|
||||
const fallbackRun = schema._zod.bag.fallbackRun;
|
||||
let result;
|
||||
if (fallbackRun) {
|
||||
// skip nested fast paths on the fallback, so user callbacks keep the at-most-twice bound
|
||||
ctx[COMPILE_FALLBACK] = true;
|
||||
result = fallbackRun({ value, issues: [] }, ctx);
|
||||
}
|
||||
else {
|
||||
result = schema._zod.run({ value, issues: [] }, ctx);
|
||||
}
|
||||
if (result instanceof Promise) {
|
||||
throw new core.$ZodAsyncError();
|
||||
}
|
||||
return result.issues.length === 0;
|
||||
}
|
||||
// no fast path: the compiler keeps async parses on the runtime, because a promise-returning callback that is not declared async compiles to a throw
|
||||
export const validateAsync = async (schema, value, _ctx) => {
|
||||
const ctx = _ctx
|
||||
? { ..._ctx, async: true, abortEarly: true }
|
||||
: { async: true, abortEarly: true };
|
||||
let result = schema._zod.run({ value, issues: [] }, ctx);
|
||||
if (result instanceof Promise)
|
||||
result = await result;
|
||||
return result.issues.length === 0;
|
||||
};
|
||||
export const _encode = (_Err) => {
|
||||
const parse = _parse(_Err);
|
||||
const fn = (schema, value, _ctx, _params) => {
|
||||
const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
|
||||
return parse(schema, value, ctx, finalizeParams(fn, _params));
|
||||
};
|
||||
return fn;
|
||||
};
|
||||
export const encode = /* @__PURE__*/ _encode(errors.$ZodRealError);
|
||||
export const _decode = (_Err) => {
|
||||
const parse = _parse(_Err);
|
||||
const fn = (schema, value, _ctx, _params) => {
|
||||
return parse(schema, value, _ctx, finalizeParams(fn, _params));
|
||||
};
|
||||
return fn;
|
||||
};
|
||||
export const decode = /* @__PURE__*/ _decode(errors.$ZodRealError);
|
||||
export const _encodeAsync = (_Err) => {
|
||||
const parseAsync = _parseAsync(_Err);
|
||||
const fn = async (schema, value, _ctx, _params) => {
|
||||
const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
|
||||
return (await parseAsync(schema, value, ctx, finalizeParams(fn, _params)));
|
||||
};
|
||||
return fn;
|
||||
};
|
||||
export const encodeAsync = /* @__PURE__*/ _encodeAsync(errors.$ZodRealError);
|
||||
export const _decodeAsync = (_Err) => {
|
||||
const parseAsync = _parseAsync(_Err);
|
||||
const fn = async (schema, value, _ctx, _params) => {
|
||||
return await parseAsync(schema, value, _ctx, finalizeParams(fn, _params));
|
||||
};
|
||||
return fn;
|
||||
};
|
||||
export const decodeAsync = /* @__PURE__*/ _decodeAsync(errors.$ZodRealError);
|
||||
export const _safeEncode = (_Err) => (schema, value, _ctx) => {
|
||||
const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
|
||||
return _safeParse(_Err)(schema, value, ctx);
|
||||
};
|
||||
export const safeEncode = /* @__PURE__*/ _safeEncode(errors.$ZodRealError);
|
||||
export const _safeDecode = (_Err) => (schema, value, _ctx) => {
|
||||
return _safeParse(_Err)(schema, value, _ctx);
|
||||
};
|
||||
export const safeDecode = /* @__PURE__*/ _safeDecode(errors.$ZodRealError);
|
||||
export const _safeEncodeAsync = (_Err) => async (schema, value, _ctx) => {
|
||||
const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
|
||||
return _safeParseAsync(_Err)(schema, value, ctx);
|
||||
};
|
||||
export const safeEncodeAsync = /* @__PURE__*/ _safeEncodeAsync(errors.$ZodRealError);
|
||||
export const _safeDecodeAsync = (_Err) => async (schema, value, _ctx) => {
|
||||
return _safeParseAsync(_Err)(schema, value, _ctx);
|
||||
};
|
||||
export const safeDecodeAsync = /* @__PURE__*/ _safeDecodeAsync(errors.$ZodRealError);
|
||||
+209
@@ -0,0 +1,209 @@
|
||||
"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.sha1_base64 = exports.sha1_hex = exports.md5_base64url = exports.md5_base64 = exports.md5_hex = exports.hex = exports.uppercase = exports.lowercase = exports.undefined = exports.null = exports.boolean = exports.number = exports.integer = exports.bigint = exports.string = exports.anyString = exports.date = exports.iban = exports.currencyCode = exports.creditCard = exports.e164 = exports.httpProtocol = exports.domain = exports.hostname = exports.base64url = exports.base64 = exports.cidrv6 = exports.cidrv4 = exports.mac = exports.ipv6 = exports.ipv4 = exports.browserEmail = exports.idnEmail = exports.unicodeEmail = exports.rfc5322Email = exports.html5Email = exports.email = exports.uuid7 = exports.uuid6 = exports.uuid4 = exports.uuid = exports.guid = exports.extendedDuration = exports.duration = exports.nanoid = exports.ksuid = exports.xid = exports.ulid = exports.cuid2 = exports.cuid = void 0;
|
||||
exports.sha512_base64url = exports.sha512_base64 = exports.sha512_hex = exports.sha384_base64url = exports.sha384_base64 = exports.sha384_hex = exports.sha256_base64url = exports.sha256_base64 = exports.sha256_hex = exports.sha1_base64url = void 0;
|
||||
exports.nanoidOfLength = nanoidOfLength;
|
||||
exports.emoji = emoji;
|
||||
exports.time = time;
|
||||
exports.datetime = datetime;
|
||||
const util = __importStar(require("./util.cjs"));
|
||||
/**
|
||||
* @deprecated CUID v1 is deprecated by its authors due to information leakage
|
||||
* (timestamps embedded in the id). Use {@link cuid2} instead.
|
||||
* See https://github.com/paralleldrive/cuid.
|
||||
*/
|
||||
exports.cuid = /^[cC][0-9a-z]{6,}$/;
|
||||
exports.cuid2 = /^[0-9a-z]+$/;
|
||||
exports.ulid = /^[0-7][0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{25}$/;
|
||||
exports.xid = /^[0-9a-vA-V]{20}$/;
|
||||
exports.ksuid = /^[A-Za-z0-9]{27}$/;
|
||||
exports.nanoid = /^[a-zA-Z0-9_-]{21}$/;
|
||||
function nanoidOfLength(length) {
|
||||
return new RegExp(`^[a-zA-Z0-9_-]{${length}}$`);
|
||||
}
|
||||
/** ISO 8601-1 duration regex. Does not support the 8601-2 extensions like negative durations or fractional/negative components. */
|
||||
exports.duration = /^P(?:(\d+W)|(?!.*W)(?=\d|T\d)(\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+([.,]\d+)?S)?)?)$/;
|
||||
/** Implements ISO 8601-2 extensions like explicit +- prefixes, mixing weeks with other units, and fractional/negative components. */
|
||||
exports.extendedDuration = /^[-+]?P(?!$)(?:(?:[-+]?\d+Y)|(?:[-+]?\d+[.,]\d+Y$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:(?:[-+]?\d+W)|(?:[-+]?\d+[.,]\d+W$))?(?:(?:[-+]?\d+D)|(?:[-+]?\d+[.,]\d+D$))?(?:T(?=[\d+-])(?:(?:[-+]?\d+H)|(?:[-+]?\d+[.,]\d+H$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:[-+]?\d+(?:[.,]\d+)?S)?)??$/;
|
||||
/** A regex for any UUID-like identifier: 8-4-4-4-12 hex pattern */
|
||||
exports.guid = /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$/;
|
||||
/** Returns a regex for validating an RFC 9562/4122 UUID.
|
||||
*
|
||||
* @param version Optionally specify a version 1-8. If no version is specified, all versions are supported. */
|
||||
const uuid = (version) => {
|
||||
if (!version)
|
||||
return /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/;
|
||||
return new RegExp(`^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${version}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`);
|
||||
};
|
||||
exports.uuid = uuid;
|
||||
exports.uuid4 = (0, exports.uuid)(4);
|
||||
exports.uuid6 = (0, exports.uuid)(6);
|
||||
exports.uuid7 = (0, exports.uuid)(7);
|
||||
/** Practical email validation */
|
||||
exports.email = /^(?:[A-Za-z0-9_'+\-]+\.)*[A-Za-z0-9_'+\-]*[A-Za-z0-9_+-]@(?:[A-Za-z0-9][A-Za-z0-9\-]*\.)+[A-Za-z]{2,}$/;
|
||||
/** Equivalent to the HTML5 input[type=email] validation implemented by browsers. Source: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input/email */
|
||||
exports.html5Email = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
|
||||
/** The classic emailregex.com regex for RFC 5322-compliant emails */
|
||||
exports.rfc5322Email = /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
|
||||
/** A loose regex that allows Unicode characters, enforces length limits, and that's about it. */
|
||||
exports.unicodeEmail = /^[^\s@"]{1,64}@[^\s@]{1,255}$/u;
|
||||
exports.idnEmail = exports.unicodeEmail;
|
||||
exports.browserEmail = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
|
||||
// from https://thekevinscott.com/emojis-in-javascript/#writing-a-regular-expression
|
||||
// Single character class, not an alternation: the two properties overlap (U+1F9B0-U+1F9B3), so `(A|B)+` backtracks exponentially on a failed match. The leading lookahead then demands one anchor — a pictograph, a regional indicator, or the enclosing keycap — because `\p{Emoji_Component}` on its own covers ASCII digits, `#`, `*`, ZWJ, variation selectors and skin tone modifiers, none of which is an emoji without a base.
|
||||
const _emoji = `^(?=[\\s\\S]*[\\p{Extended_Pictographic}\\p{Regional_Indicator}\\u20E3])[\\p{Extended_Pictographic}\\p{Emoji_Component}]+$`;
|
||||
function emoji() {
|
||||
return new RegExp(_emoji, "u");
|
||||
}
|
||||
exports.ipv4 = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/;
|
||||
exports.ipv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:))$/;
|
||||
const mac = (delimiter) => {
|
||||
const escapedDelim = util.escapeRegex(delimiter ?? ":");
|
||||
return new RegExp(`^(?:[0-9A-F]{2}${escapedDelim}){5}[0-9A-F]{2}$|^(?:[0-9a-f]{2}${escapedDelim}){5}[0-9a-f]{2}$`);
|
||||
};
|
||||
exports.mac = mac;
|
||||
exports.cidrv4 = /^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/([0-9]|[1-2][0-9]|3[0-2])$/;
|
||||
exports.cidrv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:))\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/;
|
||||
// https://stackoverflow.com/questions/7860392/determine-if-string-is-in-base64-using-javascript
|
||||
exports.base64 = /^$|^(?:[0-9a-zA-Z+/]{4})*(?:(?:[0-9a-zA-Z+/]{2}==)|(?:[0-9a-zA-Z+/]{3}=))?$/;
|
||||
exports.base64url = /^(?:[A-Za-z0-9_-]{4})*(?:[A-Za-z0-9_-]{2,3})?$/;
|
||||
// based on https://stackoverflow.com/questions/106179/regular-expression-to-match-dns-hostname-or-ip-address
|
||||
// export const hostname: RegExp = /^([a-zA-Z0-9-]+\.)*[a-zA-Z0-9-]+$/;
|
||||
exports.hostname = /^(?=.{1,253}\.?$)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[-0-9a-zA-Z]{0,61}[0-9a-zA-Z])?)*\.?$/;
|
||||
exports.domain = /^(?=.{1,253}$)([a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,63}$/;
|
||||
exports.httpProtocol = /^https?$/;
|
||||
// https://blog.stevenlevithan.com/archives/validate-phone-number#r4-3 (regex sans spaces) E.164: leading digit must be 1-9; total digits (excluding '+') between 7-15
|
||||
exports.e164 = /^\+[1-9]\d{6,14}$/;
|
||||
// Credit card shape: 12–19 digits, optionally separated by single spaces or single hyphens. ISO/IEC 7812 caps the PAN at 19 digits; 12 is the shortest issued length (Maestro).
|
||||
exports.creditCard = /^\d(?:[ -]?\d){11,18}$/;
|
||||
// ISO 4217 alpha codes from the SIX list, regenerated by scripts/update-iso-4217.ts
|
||||
exports.currencyCode = /^(?:AED|AFN|ALL|AMD|AOA|ARS|AUD|AWG|AZN|BAM|BBD|BDT|BHD|BIF|BMD|BND|BOB|BOV|BRL|BSD|BTN|BWP|BYN|BZD|CAD|CDF|CHE|CHF|CHW|CLF|CLP|CNY|COP|COU|CRC|CUP|CVE|CZK|DJF|DKK|DOP|DZD|EGP|ERN|ETB|EUR|FJD|FKP|GBP|GEL|GHS|GIP|GMD|GNF|GTQ|GYD|HKD|HNL|HTG|HUF|IDR|ILS|INR|IQD|IRR|ISK|JMD|JOD|JPY|KES|KGS|KHR|KMF|KPW|KRW|KWD|KYD|KZT|LAK|LBP|LKR|LRD|LSL|LYD|MAD|MDL|MGA|MKD|MMK|MNT|MOP|MRU|MUR|MVR|MWK|MXN|MXV|MYR|MZN|NAD|NGN|NIO|NOK|NPR|NZD|OMR|PAB|PEN|PGK|PHP|PKR|PLN|PYG|QAR|RON|RSD|RUB|RWF|SAR|SBD|SCR|SDG|SEK|SGD|SHP|SLE|SOS|SRD|SSP|STN|SVC|SYP|SZL|THB|TJS|TMT|TND|TOP|TRY|TTD|TWD|TZS|UAH|UGX|USD|USN|UYI|UYU|UYW|UZS|VED|VES|VND|VUV|WST|XAD|XAF|XAG|XAU|XBA|XBB|XBC|XBD|XCD|XCG|XDR|XOF|XPD|XPF|XPT|XSU|XTS|XUA|XXX|YER|ZAR|ZMW|ZWG)$/;
|
||||
// iban electronic format: 2-letter country, check digits 02-98 (the only values `98 - remainder` can produce), 11-30 bban characters
|
||||
exports.iban = /^[A-Z]{2}(?!00|01|99)\d{2}[A-Z0-9]{11,30}$/;
|
||||
const dateSource = `(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))`;
|
||||
/** Anchors a pattern source. The interpolation lives here rather than at the call site because
|
||||
* esbuild will not drop a `@__PURE__` call whose own argument interpolates a variable, but it
|
||||
* will drop `anchor(dateSource)`. Keeping it inline pinned `date` into every bundle. */
|
||||
function anchor(source) {
|
||||
return new RegExp(`^${source}$`);
|
||||
}
|
||||
exports.date = anchor(dateSource);
|
||||
function timeSource(args) {
|
||||
const hhmm = `(?:[01]\\d|2[0-3]):[0-5]\\d`;
|
||||
const regex = typeof args.precision === "number"
|
||||
? args.precision === -1
|
||||
? `${hhmm}`
|
||||
: args.precision === 0
|
||||
? `${hhmm}:[0-5]\\d`
|
||||
: `${hhmm}:[0-5]\\d\\.\\d{${args.precision}}`
|
||||
: args.seconds
|
||||
? `${hhmm}:[0-5]\\d(?:\\.\\d+)?`
|
||||
: `${hhmm}(?::[0-5]\\d(?:\\.\\d+)?)?`;
|
||||
return regex;
|
||||
}
|
||||
function time(args) {
|
||||
return new RegExp(`^${timeSource(args)}$`);
|
||||
}
|
||||
// Adapted from https://stackoverflow.com/a/3143231
|
||||
function datetime(args) {
|
||||
const opts = ["Z"];
|
||||
// if (args.offset) opts.push(`([+-]\\d{2}:\\d{2})`);
|
||||
if (args.offset)
|
||||
opts.push(`([+-](?:[01]\\d|2[0-3]):[0-5]\\d)`);
|
||||
// RFC 3339 mandates seconds wherever the time carries a `Z` or an offset, so only the unqualified form `local` adds may omit them
|
||||
const qualified = `${timeSource({ precision: args.precision, seconds: true })}(?:${opts.join("|")})`;
|
||||
const timeRegex = args.local ? `${qualified}|${timeSource({ precision: args.precision })}` : qualified;
|
||||
return new RegExp(`^${dateSource}T(?:${timeRegex})$`);
|
||||
}
|
||||
// the unbounded form of `string()` as a literal, so every plain string shares one instance instead of building its own
|
||||
exports.anyString = /^[\s\S]{0,}$/;
|
||||
const string = (params) => {
|
||||
const regex = params ? `[\\s\\S]{${params?.minimum ?? 0},${params?.maximum ?? ""}}` : `[\\s\\S]*`;
|
||||
return new RegExp(`^${regex}$`);
|
||||
};
|
||||
exports.string = string;
|
||||
exports.bigint = /^-?\d+n?$/;
|
||||
exports.integer = /^-?\d+$/;
|
||||
exports.number = /^-?\d+(?:\.\d+)?$/;
|
||||
exports.boolean = /^(?:true|false)$/i;
|
||||
const _null = /^null$/i;
|
||||
exports.null = _null;
|
||||
const _undefined = /^undefined$/i;
|
||||
exports.undefined = _undefined;
|
||||
// regex for string with no uppercase letters
|
||||
exports.lowercase = /^[^A-Z]*$/;
|
||||
// regex for string with no lowercase letters
|
||||
exports.uppercase = /^[^a-z]*$/;
|
||||
// regex for hexadecimal strings (any length)
|
||||
exports.hex = /^[0-9a-fA-F]*$/;
|
||||
// Hash regexes for different algorithms and encodings
|
||||
// Helper function to create base64 regex with exact length and padding
|
||||
function fixedBase64(bodyLength, padding) {
|
||||
return new RegExp(`^[A-Za-z0-9+/]{${bodyLength}}${padding}$`);
|
||||
}
|
||||
// Helper function to create base64url regex with exact length (no padding)
|
||||
function fixedBase64url(length) {
|
||||
return new RegExp(`^[A-Za-z0-9_-]{${length}}$`);
|
||||
}
|
||||
// MD5 (16 bytes): base64 = 24 chars total (22 + "==")
|
||||
exports.md5_hex = /^[0-9a-fA-F]{32}$/;
|
||||
exports.md5_base64 = fixedBase64(22, "==");
|
||||
exports.md5_base64url = fixedBase64url(22);
|
||||
// SHA1 (20 bytes): base64 = 28 chars total (27 + "=")
|
||||
exports.sha1_hex = /^[0-9a-fA-F]{40}$/;
|
||||
exports.sha1_base64 = fixedBase64(27, "=");
|
||||
exports.sha1_base64url = fixedBase64url(27);
|
||||
// SHA256 (32 bytes): base64 = 44 chars total (43 + "=")
|
||||
exports.sha256_hex = /^[0-9a-fA-F]{64}$/;
|
||||
exports.sha256_base64 = fixedBase64(43, "=");
|
||||
exports.sha256_base64url = fixedBase64url(43);
|
||||
// SHA384 (48 bytes): base64 = 64 chars total (no padding)
|
||||
exports.sha384_hex = /^[0-9a-fA-F]{96}$/;
|
||||
exports.sha384_base64 = fixedBase64(64, "");
|
||||
exports.sha384_base64url = fixedBase64url(64);
|
||||
// SHA512 (64 bytes): base64 = 88 chars total (86 + "==")
|
||||
exports.sha512_hex = /^[0-9a-fA-F]{128}$/;
|
||||
exports.sha512_base64 = fixedBase64(86, "==");
|
||||
exports.sha512_base64url = fixedBase64url(86);
|
||||
|
||||
// seal-cjs-exports
|
||||
(function () {
|
||||
var keys = Object.getOwnPropertyNames(exports);
|
||||
for (var i = 0; i < keys.length; i++) {
|
||||
var desc = Object.getOwnPropertyDescriptor(exports, keys[i]);
|
||||
if (!desc || !desc.get || !desc.configurable) continue;
|
||||
var value;
|
||||
try {
|
||||
value = desc.get();
|
||||
} catch (e) {
|
||||
continue;
|
||||
}
|
||||
// a circular require may not have settled this one yet, so leave it live
|
||||
if (value === undefined) continue;
|
||||
Object.defineProperty(exports, keys[i], { value: value, writable: false, enumerable: desc.enumerable, configurable: false });
|
||||
}
|
||||
Object.freeze(exports);
|
||||
})();
|
||||
+90
@@ -0,0 +1,90 @@
|
||||
/**
|
||||
* @deprecated CUID v1 is deprecated by its authors due to information leakage
|
||||
* (timestamps embedded in the id). Use {@link cuid2} instead.
|
||||
* See https://github.com/paralleldrive/cuid.
|
||||
*/
|
||||
export declare const cuid: RegExp;
|
||||
export declare const cuid2: RegExp;
|
||||
export declare const ulid: RegExp;
|
||||
export declare const xid: RegExp;
|
||||
export declare const ksuid: RegExp;
|
||||
export declare const nanoid: RegExp;
|
||||
export declare function nanoidOfLength(length: number): RegExp;
|
||||
/** ISO 8601-1 duration regex. Does not support the 8601-2 extensions like negative durations or fractional/negative components. */
|
||||
export declare const duration: RegExp;
|
||||
/** Implements ISO 8601-2 extensions like explicit +- prefixes, mixing weeks with other units, and fractional/negative components. */
|
||||
export declare const extendedDuration: RegExp;
|
||||
/** A regex for any UUID-like identifier: 8-4-4-4-12 hex pattern */
|
||||
export declare const guid: RegExp;
|
||||
/** Returns a regex for validating an RFC 9562/4122 UUID.
|
||||
*
|
||||
* @param version Optionally specify a version 1-8. If no version is specified, all versions are supported. */
|
||||
export declare const uuid: (version?: number | undefined) => RegExp;
|
||||
export declare const uuid4: RegExp;
|
||||
export declare const uuid6: RegExp;
|
||||
export declare const uuid7: RegExp;
|
||||
/** Practical email validation */
|
||||
export declare const email: RegExp;
|
||||
/** Equivalent to the HTML5 input[type=email] validation implemented by browsers. Source: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input/email */
|
||||
export declare const html5Email: RegExp;
|
||||
/** The classic emailregex.com regex for RFC 5322-compliant emails */
|
||||
export declare const rfc5322Email: RegExp;
|
||||
/** A loose regex that allows Unicode characters, enforces length limits, and that's about it. */
|
||||
export declare const unicodeEmail: RegExp;
|
||||
export declare const idnEmail: RegExp;
|
||||
export declare const browserEmail: RegExp;
|
||||
export declare function emoji(): RegExp;
|
||||
export declare const ipv4: RegExp;
|
||||
export declare const ipv6: RegExp;
|
||||
export declare const mac: (delimiter?: string) => RegExp;
|
||||
export declare const cidrv4: RegExp;
|
||||
export declare const cidrv6: RegExp;
|
||||
export declare const base64: RegExp;
|
||||
export declare const base64url: RegExp;
|
||||
export declare const hostname: RegExp;
|
||||
export declare const domain: RegExp;
|
||||
export declare const httpProtocol: RegExp;
|
||||
export declare const e164: RegExp;
|
||||
export declare const creditCard: RegExp;
|
||||
export declare const currencyCode: RegExp;
|
||||
export declare const iban: RegExp;
|
||||
export declare const date: RegExp;
|
||||
export declare function time(args: {
|
||||
precision?: number | null;
|
||||
}): RegExp;
|
||||
export declare function datetime(args: {
|
||||
precision?: number | null;
|
||||
offset?: boolean;
|
||||
local?: boolean;
|
||||
}): RegExp;
|
||||
export declare const anyString: RegExp;
|
||||
export declare const string: (params?: {
|
||||
minimum?: number | undefined;
|
||||
maximum?: number | undefined;
|
||||
}) => RegExp;
|
||||
export declare const bigint: RegExp;
|
||||
export declare const integer: RegExp;
|
||||
export declare const number: RegExp;
|
||||
export declare const boolean: RegExp;
|
||||
declare const _null: RegExp;
|
||||
export { _null as null };
|
||||
declare const _undefined: RegExp;
|
||||
export { _undefined as undefined };
|
||||
export declare const lowercase: RegExp;
|
||||
export declare const uppercase: RegExp;
|
||||
export declare const hex: RegExp;
|
||||
export declare const md5_hex: RegExp;
|
||||
export declare const md5_base64: RegExp;
|
||||
export declare const md5_base64url: RegExp;
|
||||
export declare const sha1_hex: RegExp;
|
||||
export declare const sha1_base64: RegExp;
|
||||
export declare const sha1_base64url: RegExp;
|
||||
export declare const sha256_hex: RegExp;
|
||||
export declare const sha256_base64: RegExp;
|
||||
export declare const sha256_base64url: RegExp;
|
||||
export declare const sha384_hex: RegExp;
|
||||
export declare const sha384_base64: RegExp;
|
||||
export declare const sha384_base64url: RegExp;
|
||||
export declare const sha512_hex: RegExp;
|
||||
export declare const sha512_base64: RegExp;
|
||||
export declare const sha512_base64url: RegExp;
|
||||
+90
@@ -0,0 +1,90 @@
|
||||
/**
|
||||
* @deprecated CUID v1 is deprecated by its authors due to information leakage
|
||||
* (timestamps embedded in the id). Use {@link cuid2} instead.
|
||||
* See https://github.com/paralleldrive/cuid.
|
||||
*/
|
||||
export declare const cuid: RegExp;
|
||||
export declare const cuid2: RegExp;
|
||||
export declare const ulid: RegExp;
|
||||
export declare const xid: RegExp;
|
||||
export declare const ksuid: RegExp;
|
||||
export declare const nanoid: RegExp;
|
||||
export declare function nanoidOfLength(length: number): RegExp;
|
||||
/** ISO 8601-1 duration regex. Does not support the 8601-2 extensions like negative durations or fractional/negative components. */
|
||||
export declare const duration: RegExp;
|
||||
/** Implements ISO 8601-2 extensions like explicit +- prefixes, mixing weeks with other units, and fractional/negative components. */
|
||||
export declare const extendedDuration: RegExp;
|
||||
/** A regex for any UUID-like identifier: 8-4-4-4-12 hex pattern */
|
||||
export declare const guid: RegExp;
|
||||
/** Returns a regex for validating an RFC 9562/4122 UUID.
|
||||
*
|
||||
* @param version Optionally specify a version 1-8. If no version is specified, all versions are supported. */
|
||||
export declare const uuid: (version?: number | undefined) => RegExp;
|
||||
export declare const uuid4: RegExp;
|
||||
export declare const uuid6: RegExp;
|
||||
export declare const uuid7: RegExp;
|
||||
/** Practical email validation */
|
||||
export declare const email: RegExp;
|
||||
/** Equivalent to the HTML5 input[type=email] validation implemented by browsers. Source: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input/email */
|
||||
export declare const html5Email: RegExp;
|
||||
/** The classic emailregex.com regex for RFC 5322-compliant emails */
|
||||
export declare const rfc5322Email: RegExp;
|
||||
/** A loose regex that allows Unicode characters, enforces length limits, and that's about it. */
|
||||
export declare const unicodeEmail: RegExp;
|
||||
export declare const idnEmail: RegExp;
|
||||
export declare const browserEmail: RegExp;
|
||||
export declare function emoji(): RegExp;
|
||||
export declare const ipv4: RegExp;
|
||||
export declare const ipv6: RegExp;
|
||||
export declare const mac: (delimiter?: string) => RegExp;
|
||||
export declare const cidrv4: RegExp;
|
||||
export declare const cidrv6: RegExp;
|
||||
export declare const base64: RegExp;
|
||||
export declare const base64url: RegExp;
|
||||
export declare const hostname: RegExp;
|
||||
export declare const domain: RegExp;
|
||||
export declare const httpProtocol: RegExp;
|
||||
export declare const e164: RegExp;
|
||||
export declare const creditCard: RegExp;
|
||||
export declare const currencyCode: RegExp;
|
||||
export declare const iban: RegExp;
|
||||
export declare const date: RegExp;
|
||||
export declare function time(args: {
|
||||
precision?: number | null;
|
||||
}): RegExp;
|
||||
export declare function datetime(args: {
|
||||
precision?: number | null;
|
||||
offset?: boolean;
|
||||
local?: boolean;
|
||||
}): RegExp;
|
||||
export declare const anyString: RegExp;
|
||||
export declare const string: (params?: {
|
||||
minimum?: number | undefined;
|
||||
maximum?: number | undefined;
|
||||
}) => RegExp;
|
||||
export declare const bigint: RegExp;
|
||||
export declare const integer: RegExp;
|
||||
export declare const number: RegExp;
|
||||
export declare const boolean: RegExp;
|
||||
declare const _null: RegExp;
|
||||
export { _null as null };
|
||||
declare const _undefined: RegExp;
|
||||
export { _undefined as undefined };
|
||||
export declare const lowercase: RegExp;
|
||||
export declare const uppercase: RegExp;
|
||||
export declare const hex: RegExp;
|
||||
export declare const md5_hex: RegExp;
|
||||
export declare const md5_base64: RegExp;
|
||||
export declare const md5_base64url: RegExp;
|
||||
export declare const sha1_hex: RegExp;
|
||||
export declare const sha1_base64: RegExp;
|
||||
export declare const sha1_base64url: RegExp;
|
||||
export declare const sha256_hex: RegExp;
|
||||
export declare const sha256_base64: RegExp;
|
||||
export declare const sha256_base64url: RegExp;
|
||||
export declare const sha384_hex: RegExp;
|
||||
export declare const sha384_base64: RegExp;
|
||||
export declare const sha384_base64url: RegExp;
|
||||
export declare const sha512_hex: RegExp;
|
||||
export declare const sha512_base64: RegExp;
|
||||
export declare const sha512_base64url: RegExp;
|
||||
+156
@@ -0,0 +1,156 @@
|
||||
import * as util from "./util.js";
|
||||
/**
|
||||
* @deprecated CUID v1 is deprecated by its authors due to information leakage
|
||||
* (timestamps embedded in the id). Use {@link cuid2} instead.
|
||||
* See https://github.com/paralleldrive/cuid.
|
||||
*/
|
||||
export const cuid = /^[cC][0-9a-z]{6,}$/;
|
||||
export const cuid2 = /^[0-9a-z]+$/;
|
||||
export const ulid = /^[0-7][0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{25}$/;
|
||||
export const xid = /^[0-9a-vA-V]{20}$/;
|
||||
export const ksuid = /^[A-Za-z0-9]{27}$/;
|
||||
export const nanoid = /^[a-zA-Z0-9_-]{21}$/;
|
||||
export function nanoidOfLength(length) {
|
||||
return new RegExp(`^[a-zA-Z0-9_-]{${length}}$`);
|
||||
}
|
||||
/** ISO 8601-1 duration regex. Does not support the 8601-2 extensions like negative durations or fractional/negative components. */
|
||||
export const duration = /^P(?:(\d+W)|(?!.*W)(?=\d|T\d)(\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+([.,]\d+)?S)?)?)$/;
|
||||
/** Implements ISO 8601-2 extensions like explicit +- prefixes, mixing weeks with other units, and fractional/negative components. */
|
||||
export const extendedDuration = /^[-+]?P(?!$)(?:(?:[-+]?\d+Y)|(?:[-+]?\d+[.,]\d+Y$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:(?:[-+]?\d+W)|(?:[-+]?\d+[.,]\d+W$))?(?:(?:[-+]?\d+D)|(?:[-+]?\d+[.,]\d+D$))?(?:T(?=[\d+-])(?:(?:[-+]?\d+H)|(?:[-+]?\d+[.,]\d+H$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:[-+]?\d+(?:[.,]\d+)?S)?)??$/;
|
||||
/** A regex for any UUID-like identifier: 8-4-4-4-12 hex pattern */
|
||||
export const guid = /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$/;
|
||||
/** Returns a regex for validating an RFC 9562/4122 UUID.
|
||||
*
|
||||
* @param version Optionally specify a version 1-8. If no version is specified, all versions are supported. */
|
||||
export const uuid = (version) => {
|
||||
if (!version)
|
||||
return /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/;
|
||||
return new RegExp(`^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${version}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`);
|
||||
};
|
||||
export const uuid4 = /*@__PURE__*/ uuid(4);
|
||||
export const uuid6 = /*@__PURE__*/ uuid(6);
|
||||
export const uuid7 = /*@__PURE__*/ uuid(7);
|
||||
/** Practical email validation */
|
||||
export const email = /^(?:[A-Za-z0-9_'+\-]+\.)*[A-Za-z0-9_'+\-]*[A-Za-z0-9_+-]@(?:[A-Za-z0-9][A-Za-z0-9\-]*\.)+[A-Za-z]{2,}$/;
|
||||
/** Equivalent to the HTML5 input[type=email] validation implemented by browsers. Source: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input/email */
|
||||
export const html5Email = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
|
||||
/** The classic emailregex.com regex for RFC 5322-compliant emails */
|
||||
export const rfc5322Email = /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
|
||||
/** A loose regex that allows Unicode characters, enforces length limits, and that's about it. */
|
||||
export const unicodeEmail = /^[^\s@"]{1,64}@[^\s@]{1,255}$/u;
|
||||
export const idnEmail = unicodeEmail;
|
||||
export const browserEmail = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
|
||||
// from https://thekevinscott.com/emojis-in-javascript/#writing-a-regular-expression
|
||||
// Single character class, not an alternation: the two properties overlap (U+1F9B0-U+1F9B3), so `(A|B)+` backtracks exponentially on a failed match. The leading lookahead then demands one anchor — a pictograph, a regional indicator, or the enclosing keycap — because `\p{Emoji_Component}` on its own covers ASCII digits, `#`, `*`, ZWJ, variation selectors and skin tone modifiers, none of which is an emoji without a base.
|
||||
const _emoji = `^(?=[\\s\\S]*[\\p{Extended_Pictographic}\\p{Regional_Indicator}\\u20E3])[\\p{Extended_Pictographic}\\p{Emoji_Component}]+$`;
|
||||
export function emoji() {
|
||||
return new RegExp(_emoji, "u");
|
||||
}
|
||||
export const ipv4 = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/;
|
||||
export const ipv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:))$/;
|
||||
export const mac = (delimiter) => {
|
||||
const escapedDelim = util.escapeRegex(delimiter ?? ":");
|
||||
return new RegExp(`^(?:[0-9A-F]{2}${escapedDelim}){5}[0-9A-F]{2}$|^(?:[0-9a-f]{2}${escapedDelim}){5}[0-9a-f]{2}$`);
|
||||
};
|
||||
export const cidrv4 = /^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/([0-9]|[1-2][0-9]|3[0-2])$/;
|
||||
export const cidrv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:))\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/;
|
||||
// https://stackoverflow.com/questions/7860392/determine-if-string-is-in-base64-using-javascript
|
||||
export const base64 = /^$|^(?:[0-9a-zA-Z+/]{4})*(?:(?:[0-9a-zA-Z+/]{2}==)|(?:[0-9a-zA-Z+/]{3}=))?$/;
|
||||
export const base64url = /^(?:[A-Za-z0-9_-]{4})*(?:[A-Za-z0-9_-]{2,3})?$/;
|
||||
// based on https://stackoverflow.com/questions/106179/regular-expression-to-match-dns-hostname-or-ip-address
|
||||
// export const hostname: RegExp = /^([a-zA-Z0-9-]+\.)*[a-zA-Z0-9-]+$/;
|
||||
export const hostname = /^(?=.{1,253}\.?$)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[-0-9a-zA-Z]{0,61}[0-9a-zA-Z])?)*\.?$/;
|
||||
export const domain = /^(?=.{1,253}$)([a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,63}$/;
|
||||
export const httpProtocol = /^https?$/;
|
||||
// https://blog.stevenlevithan.com/archives/validate-phone-number#r4-3 (regex sans spaces) E.164: leading digit must be 1-9; total digits (excluding '+') between 7-15
|
||||
export const e164 = /^\+[1-9]\d{6,14}$/;
|
||||
// Credit card shape: 12–19 digits, optionally separated by single spaces or single hyphens. ISO/IEC 7812 caps the PAN at 19 digits; 12 is the shortest issued length (Maestro).
|
||||
export const creditCard = /^\d(?:[ -]?\d){11,18}$/;
|
||||
// ISO 4217 alpha codes from the SIX list, regenerated by scripts/update-iso-4217.ts
|
||||
export const currencyCode = /^(?:AED|AFN|ALL|AMD|AOA|ARS|AUD|AWG|AZN|BAM|BBD|BDT|BHD|BIF|BMD|BND|BOB|BOV|BRL|BSD|BTN|BWP|BYN|BZD|CAD|CDF|CHE|CHF|CHW|CLF|CLP|CNY|COP|COU|CRC|CUP|CVE|CZK|DJF|DKK|DOP|DZD|EGP|ERN|ETB|EUR|FJD|FKP|GBP|GEL|GHS|GIP|GMD|GNF|GTQ|GYD|HKD|HNL|HTG|HUF|IDR|ILS|INR|IQD|IRR|ISK|JMD|JOD|JPY|KES|KGS|KHR|KMF|KPW|KRW|KWD|KYD|KZT|LAK|LBP|LKR|LRD|LSL|LYD|MAD|MDL|MGA|MKD|MMK|MNT|MOP|MRU|MUR|MVR|MWK|MXN|MXV|MYR|MZN|NAD|NGN|NIO|NOK|NPR|NZD|OMR|PAB|PEN|PGK|PHP|PKR|PLN|PYG|QAR|RON|RSD|RUB|RWF|SAR|SBD|SCR|SDG|SEK|SGD|SHP|SLE|SOS|SRD|SSP|STN|SVC|SYP|SZL|THB|TJS|TMT|TND|TOP|TRY|TTD|TWD|TZS|UAH|UGX|USD|USN|UYI|UYU|UYW|UZS|VED|VES|VND|VUV|WST|XAD|XAF|XAG|XAU|XBA|XBB|XBC|XBD|XCD|XCG|XDR|XOF|XPD|XPF|XPT|XSU|XTS|XUA|XXX|YER|ZAR|ZMW|ZWG)$/;
|
||||
// iban electronic format: 2-letter country, check digits 02-98 (the only values `98 - remainder` can produce), 11-30 bban characters
|
||||
export const iban = /^[A-Z]{2}(?!00|01|99)\d{2}[A-Z0-9]{11,30}$/;
|
||||
const dateSource = `(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))`;
|
||||
/** Anchors a pattern source. The interpolation lives here rather than at the call site because
|
||||
* esbuild will not drop a `@__PURE__` call whose own argument interpolates a variable, but it
|
||||
* will drop `anchor(dateSource)`. Keeping it inline pinned `date` into every bundle. */
|
||||
function anchor(source) {
|
||||
return new RegExp(`^${source}$`);
|
||||
}
|
||||
export const date = /*@__PURE__*/ anchor(dateSource);
|
||||
function timeSource(args) {
|
||||
const hhmm = `(?:[01]\\d|2[0-3]):[0-5]\\d`;
|
||||
const regex = typeof args.precision === "number"
|
||||
? args.precision === -1
|
||||
? `${hhmm}`
|
||||
: args.precision === 0
|
||||
? `${hhmm}:[0-5]\\d`
|
||||
: `${hhmm}:[0-5]\\d\\.\\d{${args.precision}}`
|
||||
: args.seconds
|
||||
? `${hhmm}:[0-5]\\d(?:\\.\\d+)?`
|
||||
: `${hhmm}(?::[0-5]\\d(?:\\.\\d+)?)?`;
|
||||
return regex;
|
||||
}
|
||||
export function time(args) {
|
||||
return new RegExp(`^${timeSource(args)}$`);
|
||||
}
|
||||
// Adapted from https://stackoverflow.com/a/3143231
|
||||
export function datetime(args) {
|
||||
const opts = ["Z"];
|
||||
// if (args.offset) opts.push(`([+-]\\d{2}:\\d{2})`);
|
||||
if (args.offset)
|
||||
opts.push(`([+-](?:[01]\\d|2[0-3]):[0-5]\\d)`);
|
||||
// RFC 3339 mandates seconds wherever the time carries a `Z` or an offset, so only the unqualified form `local` adds may omit them
|
||||
const qualified = `${timeSource({ precision: args.precision, seconds: true })}(?:${opts.join("|")})`;
|
||||
const timeRegex = args.local ? `${qualified}|${timeSource({ precision: args.precision })}` : qualified;
|
||||
return new RegExp(`^${dateSource}T(?:${timeRegex})$`);
|
||||
}
|
||||
// the unbounded form of `string()` as a literal, so every plain string shares one instance instead of building its own
|
||||
export const anyString = /^[\s\S]{0,}$/;
|
||||
export const string = (params) => {
|
||||
const regex = params ? `[\\s\\S]{${params?.minimum ?? 0},${params?.maximum ?? ""}}` : `[\\s\\S]*`;
|
||||
return new RegExp(`^${regex}$`);
|
||||
};
|
||||
export const bigint = /^-?\d+n?$/;
|
||||
export const integer = /^-?\d+$/;
|
||||
export const number = /^-?\d+(?:\.\d+)?$/;
|
||||
export const boolean = /^(?:true|false)$/i;
|
||||
const _null = /^null$/i;
|
||||
export { _null as null };
|
||||
const _undefined = /^undefined$/i;
|
||||
export { _undefined as undefined };
|
||||
// regex for string with no uppercase letters
|
||||
export const lowercase = /^[^A-Z]*$/;
|
||||
// regex for string with no lowercase letters
|
||||
export const uppercase = /^[^a-z]*$/;
|
||||
// regex for hexadecimal strings (any length)
|
||||
export const hex = /^[0-9a-fA-F]*$/;
|
||||
// Hash regexes for different algorithms and encodings
|
||||
// Helper function to create base64 regex with exact length and padding
|
||||
function fixedBase64(bodyLength, padding) {
|
||||
return new RegExp(`^[A-Za-z0-9+/]{${bodyLength}}${padding}$`);
|
||||
}
|
||||
// Helper function to create base64url regex with exact length (no padding)
|
||||
function fixedBase64url(length) {
|
||||
return new RegExp(`^[A-Za-z0-9_-]{${length}}$`);
|
||||
}
|
||||
// MD5 (16 bytes): base64 = 24 chars total (22 + "==")
|
||||
export const md5_hex = /^[0-9a-fA-F]{32}$/;
|
||||
export const md5_base64 = /*@__PURE__*/ fixedBase64(22, "==");
|
||||
export const md5_base64url = /*@__PURE__*/ fixedBase64url(22);
|
||||
// SHA1 (20 bytes): base64 = 28 chars total (27 + "=")
|
||||
export const sha1_hex = /^[0-9a-fA-F]{40}$/;
|
||||
export const sha1_base64 = /*@__PURE__*/ fixedBase64(27, "=");
|
||||
export const sha1_base64url = /*@__PURE__*/ fixedBase64url(27);
|
||||
// SHA256 (32 bytes): base64 = 44 chars total (43 + "=")
|
||||
export const sha256_hex = /^[0-9a-fA-F]{64}$/;
|
||||
export const sha256_base64 = /*@__PURE__*/ fixedBase64(43, "=");
|
||||
export const sha256_base64url = /*@__PURE__*/ fixedBase64url(43);
|
||||
// SHA384 (48 bytes): base64 = 64 chars total (no padding)
|
||||
export const sha384_hex = /^[0-9a-fA-F]{96}$/;
|
||||
export const sha384_base64 = /*@__PURE__*/ fixedBase64(64, "");
|
||||
export const sha384_base64url = /*@__PURE__*/ fixedBase64url(64);
|
||||
// SHA512 (64 bytes): base64 = 88 chars total (86 + "==")
|
||||
export const sha512_hex = /^[0-9a-fA-F]{128}$/;
|
||||
export const sha512_base64 = /*@__PURE__*/ fixedBase64(86, "==");
|
||||
export const sha512_base64url = /*@__PURE__*/ fixedBase64url(86);
|
||||
+75
@@ -0,0 +1,75 @@
|
||||
"use strict";
|
||||
var _a;
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.globalRegistry = exports.$ZodRegistry = exports.$input = exports.$output = void 0;
|
||||
exports.registry = registry;
|
||||
exports.$output = Symbol("ZodOutput");
|
||||
exports.$input = Symbol("ZodInput");
|
||||
class $ZodRegistry {
|
||||
constructor() {
|
||||
this._map = new WeakMap();
|
||||
this._idmap = new Map();
|
||||
}
|
||||
add(schema, ..._meta) {
|
||||
const meta = _meta[0];
|
||||
this._map.set(schema, meta);
|
||||
if (meta && typeof meta === "object" && "id" in meta) {
|
||||
this._idmap.set(meta.id, schema);
|
||||
}
|
||||
return this;
|
||||
}
|
||||
clear() {
|
||||
this._map = new WeakMap();
|
||||
this._idmap = new Map();
|
||||
return this;
|
||||
}
|
||||
remove(schema) {
|
||||
const meta = this._map.get(schema);
|
||||
if (meta && typeof meta === "object" && "id" in meta) {
|
||||
this._idmap.delete(meta.id);
|
||||
}
|
||||
this._map.delete(schema);
|
||||
return this;
|
||||
}
|
||||
get(schema) {
|
||||
// return this._map.get(schema) as any;
|
||||
// inherit metadata
|
||||
const p = schema._zod.parent;
|
||||
if (p) {
|
||||
const pm = { ...(this.get(p) ?? {}) };
|
||||
delete pm.id; // do not inherit id
|
||||
const f = { ...pm, ...this._map.get(schema) };
|
||||
return Object.keys(f).length ? f : undefined;
|
||||
}
|
||||
return this._map.get(schema);
|
||||
}
|
||||
has(schema) {
|
||||
return this._map.has(schema);
|
||||
}
|
||||
}
|
||||
exports.$ZodRegistry = $ZodRegistry;
|
||||
// registries
|
||||
function registry() {
|
||||
return new $ZodRegistry();
|
||||
}
|
||||
(_a = globalThis).__zod_globalRegistry ?? (_a.__zod_globalRegistry = registry());
|
||||
exports.globalRegistry = globalThis.__zod_globalRegistry;
|
||||
|
||||
// seal-cjs-exports
|
||||
(function () {
|
||||
var keys = Object.getOwnPropertyNames(exports);
|
||||
for (var i = 0; i < keys.length; i++) {
|
||||
var desc = Object.getOwnPropertyDescriptor(exports, keys[i]);
|
||||
if (!desc || !desc.get || !desc.configurable) continue;
|
||||
var value;
|
||||
try {
|
||||
value = desc.get();
|
||||
} catch (e) {
|
||||
continue;
|
||||
}
|
||||
// a circular require may not have settled this one yet, so leave it live
|
||||
if (value === undefined) continue;
|
||||
Object.defineProperty(exports, keys[i], { value: value, writable: false, enumerable: desc.enumerable, configurable: false });
|
||||
}
|
||||
Object.freeze(exports);
|
||||
})();
|
||||
+35
@@ -0,0 +1,35 @@
|
||||
import type * as core from "./core.cjs";
|
||||
import type { $ZodType } from "./schemas.cjs";
|
||||
export declare const $output: unique symbol;
|
||||
export type $output = typeof $output;
|
||||
export declare const $input: unique symbol;
|
||||
export type $input = typeof $input;
|
||||
export type $replace<Meta, S extends $ZodType> = Meta extends $output ? core.output<S> : Meta extends $input ? core.input<S> : Meta extends (infer M)[] ? $replace<M, S>[] : Meta extends (...args: infer P) => infer R ? (...args: {
|
||||
[K in keyof P]: $replace<P[K], S>;
|
||||
}) => $replace<R, S> : Meta extends object ? {
|
||||
[K in keyof Meta]: $replace<Meta[K], S>;
|
||||
} : Meta;
|
||||
type MetadataType = object | undefined;
|
||||
export declare class $ZodRegistry<Meta extends MetadataType = MetadataType, Schema extends $ZodType = $ZodType> {
|
||||
_meta: Meta;
|
||||
_schema: Schema;
|
||||
_map: WeakMap<Schema, $replace<Meta, Schema>>;
|
||||
_idmap: Map<string, Schema>;
|
||||
add<S extends Schema>(schema: S, ..._meta: undefined extends Meta ? [$replace<Meta, S>?] : [$replace<Meta, S>]): this;
|
||||
clear(): this;
|
||||
remove(schema: Schema): this;
|
||||
get<S extends Schema>(schema: S): $replace<Meta, S> | undefined;
|
||||
has(schema: Schema): boolean;
|
||||
}
|
||||
export interface JSONSchemaMeta {
|
||||
id?: string | undefined;
|
||||
title?: string | undefined;
|
||||
description?: string | undefined;
|
||||
deprecated?: boolean | undefined;
|
||||
[k: string]: unknown;
|
||||
}
|
||||
export interface GlobalMeta extends JSONSchemaMeta {
|
||||
}
|
||||
export declare function registry<T extends MetadataType = MetadataType, S extends $ZodType = $ZodType>(): $ZodRegistry<T, S>;
|
||||
export declare const globalRegistry: $ZodRegistry<GlobalMeta>;
|
||||
export {};
|
||||
+35
@@ -0,0 +1,35 @@
|
||||
import type * as core from "./core.js";
|
||||
import type { $ZodType } from "./schemas.js";
|
||||
export declare const $output: unique symbol;
|
||||
export type $output = typeof $output;
|
||||
export declare const $input: unique symbol;
|
||||
export type $input = typeof $input;
|
||||
export type $replace<Meta, S extends $ZodType> = Meta extends $output ? core.output<S> : Meta extends $input ? core.input<S> : Meta extends (infer M)[] ? $replace<M, S>[] : Meta extends (...args: infer P) => infer R ? (...args: {
|
||||
[K in keyof P]: $replace<P[K], S>;
|
||||
}) => $replace<R, S> : Meta extends object ? {
|
||||
[K in keyof Meta]: $replace<Meta[K], S>;
|
||||
} : Meta;
|
||||
type MetadataType = object | undefined;
|
||||
export declare class $ZodRegistry<Meta extends MetadataType = MetadataType, Schema extends $ZodType = $ZodType> {
|
||||
_meta: Meta;
|
||||
_schema: Schema;
|
||||
_map: WeakMap<Schema, $replace<Meta, Schema>>;
|
||||
_idmap: Map<string, Schema>;
|
||||
add<S extends Schema>(schema: S, ..._meta: undefined extends Meta ? [$replace<Meta, S>?] : [$replace<Meta, S>]): this;
|
||||
clear(): this;
|
||||
remove(schema: Schema): this;
|
||||
get<S extends Schema>(schema: S): $replace<Meta, S> | undefined;
|
||||
has(schema: Schema): boolean;
|
||||
}
|
||||
export interface JSONSchemaMeta {
|
||||
id?: string | undefined;
|
||||
title?: string | undefined;
|
||||
description?: string | undefined;
|
||||
deprecated?: boolean | undefined;
|
||||
[k: string]: unknown;
|
||||
}
|
||||
export interface GlobalMeta extends JSONSchemaMeta {
|
||||
}
|
||||
export declare function registry<T extends MetadataType = MetadataType, S extends $ZodType = $ZodType>(): $ZodRegistry<T, S>;
|
||||
export declare const globalRegistry: $ZodRegistry<GlobalMeta>;
|
||||
export {};
|
||||
+51
@@ -0,0 +1,51 @@
|
||||
var _a;
|
||||
export const $output = /*@__PURE__*/ Symbol("ZodOutput");
|
||||
export const $input = /*@__PURE__*/ Symbol("ZodInput");
|
||||
export class $ZodRegistry {
|
||||
constructor() {
|
||||
this._map = new WeakMap();
|
||||
this._idmap = new Map();
|
||||
}
|
||||
add(schema, ..._meta) {
|
||||
const meta = _meta[0];
|
||||
this._map.set(schema, meta);
|
||||
if (meta && typeof meta === "object" && "id" in meta) {
|
||||
this._idmap.set(meta.id, schema);
|
||||
}
|
||||
return this;
|
||||
}
|
||||
clear() {
|
||||
this._map = new WeakMap();
|
||||
this._idmap = new Map();
|
||||
return this;
|
||||
}
|
||||
remove(schema) {
|
||||
const meta = this._map.get(schema);
|
||||
if (meta && typeof meta === "object" && "id" in meta) {
|
||||
this._idmap.delete(meta.id);
|
||||
}
|
||||
this._map.delete(schema);
|
||||
return this;
|
||||
}
|
||||
get(schema) {
|
||||
// return this._map.get(schema) as any;
|
||||
// inherit metadata
|
||||
const p = schema._zod.parent;
|
||||
if (p) {
|
||||
const pm = { ...(this.get(p) ?? {}) };
|
||||
delete pm.id; // do not inherit id
|
||||
const f = { ...pm, ...this._map.get(schema) };
|
||||
return Object.keys(f).length ? f : undefined;
|
||||
}
|
||||
return this._map.get(schema);
|
||||
}
|
||||
has(schema) {
|
||||
return this._map.has(schema);
|
||||
}
|
||||
}
|
||||
// registries
|
||||
export function registry() {
|
||||
return new $ZodRegistry();
|
||||
}
|
||||
(_a = globalThis).__zod_globalRegistry ?? (_a.__zod_globalRegistry = registry());
|
||||
export const globalRegistry = globalThis.__zod_globalRegistry;
|
||||
+2699
File diff suppressed because it is too large
Load Diff
+1275
File diff suppressed because it is too large
Load Diff
+1275
File diff suppressed because it is too large
Load Diff
+2636
File diff suppressed because it is too large
Load Diff
+21
@@ -0,0 +1,21 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
|
||||
// seal-cjs-exports
|
||||
(function () {
|
||||
var keys = Object.getOwnPropertyNames(exports);
|
||||
for (var i = 0; i < keys.length; i++) {
|
||||
var desc = Object.getOwnPropertyDescriptor(exports, keys[i]);
|
||||
if (!desc || !desc.get || !desc.configurable) continue;
|
||||
var value;
|
||||
try {
|
||||
value = desc.get();
|
||||
} catch (e) {
|
||||
continue;
|
||||
}
|
||||
// a circular require may not have settled this one yet, so leave it live
|
||||
if (value === undefined) continue;
|
||||
Object.defineProperty(exports, keys[i], { value: value, writable: false, enumerable: desc.enumerable, configurable: false });
|
||||
}
|
||||
Object.freeze(exports);
|
||||
})();
|
||||
+126
@@ -0,0 +1,126 @@
|
||||
/** The Standard interface. */
|
||||
export interface StandardTypedV1<Input = unknown, Output = Input> {
|
||||
/** The Standard properties. */
|
||||
readonly "~standard": StandardTypedV1.Props<Input, Output>;
|
||||
}
|
||||
export declare namespace StandardTypedV1 {
|
||||
/** The Standard properties interface. */
|
||||
interface Props<Input = unknown, Output = Input> {
|
||||
/** The version number of the standard. */
|
||||
readonly version: 1;
|
||||
/** The vendor name of the schema library. */
|
||||
readonly vendor: string;
|
||||
/** Inferred types associated with the schema. */
|
||||
readonly types?: Types<Input, Output> | undefined;
|
||||
}
|
||||
/** The Standard types interface. */
|
||||
interface Types<Input = unknown, Output = Input> {
|
||||
/** The input type of the schema. */
|
||||
readonly input: Input;
|
||||
/** The output type of the schema. */
|
||||
readonly output: Output;
|
||||
}
|
||||
/** Infers the input type of a Standard. */
|
||||
type InferInput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["input"];
|
||||
/** Infers the output type of a Standard. */
|
||||
type InferOutput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["output"];
|
||||
}
|
||||
/** The Standard Schema interface. */
|
||||
export interface StandardSchemaV1<Input = unknown, Output = Input> {
|
||||
/** The Standard Schema properties. */
|
||||
readonly "~standard": StandardSchemaV1.Props<Input, Output>;
|
||||
}
|
||||
export declare namespace StandardSchemaV1 {
|
||||
/** The Standard Schema properties interface. */
|
||||
interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
|
||||
/** Validates unknown input values. */
|
||||
readonly validate: (value: unknown, options?: StandardSchemaV1.Options | undefined) => Result<Output> | Promise<Result<Output>>;
|
||||
}
|
||||
/** The result interface of the validate function. */
|
||||
type Result<Output> = SuccessResult<Output> | FailureResult;
|
||||
/** The result interface if validation succeeds. */
|
||||
interface SuccessResult<Output> {
|
||||
/** The typed output value. */
|
||||
readonly value: Output;
|
||||
/** The absence of issues indicates success. */
|
||||
readonly issues?: undefined;
|
||||
}
|
||||
interface Options {
|
||||
/** Implicit support for additional vendor-specific parameters, if needed. */
|
||||
readonly libraryOptions?: Record<string, unknown> | undefined;
|
||||
}
|
||||
/** The result interface if validation fails. */
|
||||
interface FailureResult {
|
||||
/** The issues of failed validation. */
|
||||
readonly issues: ReadonlyArray<Issue>;
|
||||
}
|
||||
/** The issue interface of the failure output. */
|
||||
interface Issue {
|
||||
/** The error message of the issue. */
|
||||
readonly message: string;
|
||||
/** The path of the issue, if any. */
|
||||
readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
|
||||
}
|
||||
/** The path segment interface of the issue. */
|
||||
interface PathSegment {
|
||||
/** The key representing a path segment. */
|
||||
readonly key: PropertyKey;
|
||||
}
|
||||
/** The Standard types interface. */
|
||||
interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {
|
||||
}
|
||||
/** Infers the input type of a Standard. */
|
||||
type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
|
||||
/** Infers the output type of a Standard. */
|
||||
type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
|
||||
}
|
||||
/** The Standard JSON Schema interface. */
|
||||
export interface StandardJSONSchemaV1<Input = unknown, Output = Input> {
|
||||
/** The Standard JSON Schema properties. */
|
||||
readonly "~standard": StandardJSONSchemaV1.Props<Input, Output>;
|
||||
}
|
||||
export declare namespace StandardJSONSchemaV1 {
|
||||
/** The Standard JSON Schema properties interface. */
|
||||
interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
|
||||
/** Methods for generating the input/output JSON Schema. */
|
||||
readonly jsonSchema: Converter;
|
||||
}
|
||||
/** The Standard JSON Schema converter interface. */
|
||||
interface Converter {
|
||||
/** Converts the input type to JSON Schema. May throw if conversion is not supported. */
|
||||
readonly input: (options: StandardJSONSchemaV1.Options) => Record<string, unknown>;
|
||||
/** Converts the output type to JSON Schema. May throw if conversion is not supported. */
|
||||
readonly output: (options: StandardJSONSchemaV1.Options) => Record<string, unknown>;
|
||||
}
|
||||
/** The target version of the generated JSON Schema.
|
||||
*
|
||||
* It is *strongly recommended* that implementers support `"draft-2020-12"` and `"draft-07"`, as they are both in wide use.
|
||||
*
|
||||
* The `"openapi-3.0"` target is intended as a standardized specifier for OpenAPI 3.0 which is a superset of JSON Schema `"draft-04"`.
|
||||
*
|
||||
* All other targets can be implemented on a best-effort basis. Libraries should throw if they don't support a specified target.
|
||||
*/
|
||||
type Target = "draft-2020-12" | "draft-07" | "openapi-3.0" | ({} & string);
|
||||
/** The options for the input/output methods. */
|
||||
interface Options {
|
||||
/** Specifies the target version of the generated JSON Schema. Support for all versions is on a best-effort basis. If a given version is not supported, the library should throw. */
|
||||
readonly target: Target;
|
||||
/** Implicit support for additional vendor-specific parameters, if needed. */
|
||||
readonly libraryOptions?: Record<string, unknown> | undefined;
|
||||
}
|
||||
/** The Standard types interface. */
|
||||
interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {
|
||||
}
|
||||
/** Infers the input type of a Standard. */
|
||||
type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
|
||||
/** Infers the output type of a Standard. */
|
||||
type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
|
||||
}
|
||||
export interface StandardSchemaWithJSONProps<Input = unknown, Output = Input> extends StandardSchemaV1.Props<Input, Output>, StandardJSONSchemaV1.Props<Input, Output> {
|
||||
}
|
||||
/**
|
||||
* An interface that combines StandardJSONSchema and StandardSchema.
|
||||
*/
|
||||
export interface StandardSchemaWithJSON<Input = unknown, Output = Input> {
|
||||
"~standard": StandardSchemaWithJSONProps<Input, Output>;
|
||||
}
|
||||
+126
@@ -0,0 +1,126 @@
|
||||
/** The Standard interface. */
|
||||
export interface StandardTypedV1<Input = unknown, Output = Input> {
|
||||
/** The Standard properties. */
|
||||
readonly "~standard": StandardTypedV1.Props<Input, Output>;
|
||||
}
|
||||
export declare namespace StandardTypedV1 {
|
||||
/** The Standard properties interface. */
|
||||
interface Props<Input = unknown, Output = Input> {
|
||||
/** The version number of the standard. */
|
||||
readonly version: 1;
|
||||
/** The vendor name of the schema library. */
|
||||
readonly vendor: string;
|
||||
/** Inferred types associated with the schema. */
|
||||
readonly types?: Types<Input, Output> | undefined;
|
||||
}
|
||||
/** The Standard types interface. */
|
||||
interface Types<Input = unknown, Output = Input> {
|
||||
/** The input type of the schema. */
|
||||
readonly input: Input;
|
||||
/** The output type of the schema. */
|
||||
readonly output: Output;
|
||||
}
|
||||
/** Infers the input type of a Standard. */
|
||||
type InferInput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["input"];
|
||||
/** Infers the output type of a Standard. */
|
||||
type InferOutput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["output"];
|
||||
}
|
||||
/** The Standard Schema interface. */
|
||||
export interface StandardSchemaV1<Input = unknown, Output = Input> {
|
||||
/** The Standard Schema properties. */
|
||||
readonly "~standard": StandardSchemaV1.Props<Input, Output>;
|
||||
}
|
||||
export declare namespace StandardSchemaV1 {
|
||||
/** The Standard Schema properties interface. */
|
||||
interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
|
||||
/** Validates unknown input values. */
|
||||
readonly validate: (value: unknown, options?: StandardSchemaV1.Options | undefined) => Result<Output> | Promise<Result<Output>>;
|
||||
}
|
||||
/** The result interface of the validate function. */
|
||||
type Result<Output> = SuccessResult<Output> | FailureResult;
|
||||
/** The result interface if validation succeeds. */
|
||||
interface SuccessResult<Output> {
|
||||
/** The typed output value. */
|
||||
readonly value: Output;
|
||||
/** The absence of issues indicates success. */
|
||||
readonly issues?: undefined;
|
||||
}
|
||||
interface Options {
|
||||
/** Implicit support for additional vendor-specific parameters, if needed. */
|
||||
readonly libraryOptions?: Record<string, unknown> | undefined;
|
||||
}
|
||||
/** The result interface if validation fails. */
|
||||
interface FailureResult {
|
||||
/** The issues of failed validation. */
|
||||
readonly issues: ReadonlyArray<Issue>;
|
||||
}
|
||||
/** The issue interface of the failure output. */
|
||||
interface Issue {
|
||||
/** The error message of the issue. */
|
||||
readonly message: string;
|
||||
/** The path of the issue, if any. */
|
||||
readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
|
||||
}
|
||||
/** The path segment interface of the issue. */
|
||||
interface PathSegment {
|
||||
/** The key representing a path segment. */
|
||||
readonly key: PropertyKey;
|
||||
}
|
||||
/** The Standard types interface. */
|
||||
interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {
|
||||
}
|
||||
/** Infers the input type of a Standard. */
|
||||
type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
|
||||
/** Infers the output type of a Standard. */
|
||||
type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
|
||||
}
|
||||
/** The Standard JSON Schema interface. */
|
||||
export interface StandardJSONSchemaV1<Input = unknown, Output = Input> {
|
||||
/** The Standard JSON Schema properties. */
|
||||
readonly "~standard": StandardJSONSchemaV1.Props<Input, Output>;
|
||||
}
|
||||
export declare namespace StandardJSONSchemaV1 {
|
||||
/** The Standard JSON Schema properties interface. */
|
||||
interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
|
||||
/** Methods for generating the input/output JSON Schema. */
|
||||
readonly jsonSchema: Converter;
|
||||
}
|
||||
/** The Standard JSON Schema converter interface. */
|
||||
interface Converter {
|
||||
/** Converts the input type to JSON Schema. May throw if conversion is not supported. */
|
||||
readonly input: (options: StandardJSONSchemaV1.Options) => Record<string, unknown>;
|
||||
/** Converts the output type to JSON Schema. May throw if conversion is not supported. */
|
||||
readonly output: (options: StandardJSONSchemaV1.Options) => Record<string, unknown>;
|
||||
}
|
||||
/** The target version of the generated JSON Schema.
|
||||
*
|
||||
* It is *strongly recommended* that implementers support `"draft-2020-12"` and `"draft-07"`, as they are both in wide use.
|
||||
*
|
||||
* The `"openapi-3.0"` target is intended as a standardized specifier for OpenAPI 3.0 which is a superset of JSON Schema `"draft-04"`.
|
||||
*
|
||||
* All other targets can be implemented on a best-effort basis. Libraries should throw if they don't support a specified target.
|
||||
*/
|
||||
type Target = "draft-2020-12" | "draft-07" | "openapi-3.0" | ({} & string);
|
||||
/** The options for the input/output methods. */
|
||||
interface Options {
|
||||
/** Specifies the target version of the generated JSON Schema. Support for all versions is on a best-effort basis. If a given version is not supported, the library should throw. */
|
||||
readonly target: Target;
|
||||
/** Implicit support for additional vendor-specific parameters, if needed. */
|
||||
readonly libraryOptions?: Record<string, unknown> | undefined;
|
||||
}
|
||||
/** The Standard types interface. */
|
||||
interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {
|
||||
}
|
||||
/** Infers the input type of a Standard. */
|
||||
type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
|
||||
/** Infers the output type of a Standard. */
|
||||
type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
|
||||
}
|
||||
export interface StandardSchemaWithJSONProps<Input = unknown, Output = Input> extends StandardSchemaV1.Props<Input, Output>, StandardJSONSchemaV1.Props<Input, Output> {
|
||||
}
|
||||
/**
|
||||
* An interface that combines StandardJSONSchema and StandardSchema.
|
||||
*/
|
||||
export interface StandardSchemaWithJSON<Input = unknown, Output = Input> {
|
||||
"~standard": StandardSchemaWithJSONProps<Input, Output>;
|
||||
}
|
||||
+1
@@ -0,0 +1 @@
|
||||
export {};
|
||||
+681
@@ -0,0 +1,681 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.createStandardJSONSchemaMethod = exports.createToJSONSchemaMethod = void 0;
|
||||
exports.initializeContext = initializeContext;
|
||||
exports.handleUnrepresentable = handleUnrepresentable;
|
||||
exports.processSchema = processSchema;
|
||||
exports.process = processSchema;
|
||||
exports.processSchema = processSchema;
|
||||
exports.process = processSchema;
|
||||
exports.extractDefs = extractDefs;
|
||||
exports.finalize = finalize;
|
||||
const registries_js_1 = require("./registries.cjs");
|
||||
const util_js_1 = require("./util.cjs");
|
||||
function assignProps(target, ...sources) {
|
||||
for (const source of sources) {
|
||||
for (const key of Reflect.ownKeys(source)) {
|
||||
if (Object.prototype.propertyIsEnumerable.call(source, key)) {
|
||||
(0, util_js_1.assignProp)(target, key, source[key]);
|
||||
}
|
||||
}
|
||||
}
|
||||
return target;
|
||||
}
|
||||
// function initializeContext<T extends schemas.$ZodType>(inputs: JSONSchemaGeneratorParams<T>): ToJSONSchemaContext<T> {
|
||||
// return {
|
||||
// processor: inputs.processor,
|
||||
// metadataRegistry: inputs.metadata ?? globalRegistry,
|
||||
// target: inputs.target ?? "draft-2020-12",
|
||||
// unrepresentable: inputs.unrepresentable ?? "throw",
|
||||
// };
|
||||
// }
|
||||
function initializeContext(params) {
|
||||
// Normalize target: convert old non-hyphenated versions to hyphenated versions
|
||||
let target = params?.target ?? "draft-2020-12";
|
||||
if (target === "draft-4")
|
||||
target = "draft-04";
|
||||
if (target === "draft-7")
|
||||
target = "draft-07";
|
||||
return {
|
||||
processors: params.processors ?? {},
|
||||
metadataRegistry: params?.metadata ?? registries_js_1.globalRegistry,
|
||||
target,
|
||||
unrepresentable: params?.unrepresentable ?? "throw",
|
||||
override: params?.override ?? (() => { }),
|
||||
io: params?.io ?? "output",
|
||||
counter: 0,
|
||||
seen: new Map(),
|
||||
sharedDefsExtractedFor: undefined,
|
||||
sharedEmitDoneFor: undefined,
|
||||
cycles: params?.cycles ?? "ref",
|
||||
reused: params?.reused ?? "inline",
|
||||
intersections: [],
|
||||
deferred: [],
|
||||
external: params?.external ?? undefined,
|
||||
};
|
||||
}
|
||||
/**
|
||||
* Applies the `unrepresentable` setting at a site that has no JSON Schema equivalent. Throws
|
||||
* `message` unless the setting (or the handler's return value) says otherwise. Returns `true` if a
|
||||
* custom JSON Schema was written into `json`, in which case the caller must not write its own.
|
||||
*/
|
||||
function handleUnrepresentable(schema, ctx, json, params, message) {
|
||||
const result = typeof ctx.unrepresentable === "function"
|
||||
? ctx.unrepresentable({ zodSchema: schema, path: params.path, message })
|
||||
: ctx.unrepresentable;
|
||||
if (result === "any")
|
||||
return false;
|
||||
if (result === undefined || result === "throw")
|
||||
throw new Error(message);
|
||||
Object.assign(json, result);
|
||||
return true;
|
||||
}
|
||||
// never rename this back to `process`: bundler polyfills inject a top-level `const process` that a lexical declaration of the same name collides with (#6397)
|
||||
function processSchema(schema, ctx, _params = { path: [], schemaPath: [] }) {
|
||||
var _a;
|
||||
const def = schema._zod.def;
|
||||
// check for schema in seens
|
||||
const seen = ctx.seen.get(schema);
|
||||
if (seen) {
|
||||
seen.count++;
|
||||
// check if cycle
|
||||
const isCycle = _params.schemaPath.includes(schema);
|
||||
if (isCycle) {
|
||||
seen.cycle = _params.path;
|
||||
}
|
||||
return seen.schema;
|
||||
}
|
||||
// initialize
|
||||
const result = { schema: {}, count: 1, cycle: undefined, path: _params.path };
|
||||
ctx.seen.set(schema, result);
|
||||
ctx.sharedDefsExtractedFor = undefined;
|
||||
ctx.sharedEmitDoneFor = undefined;
|
||||
// custom method overrides default behavior
|
||||
const overrideSchema = schema._zod.toJSONSchema?.();
|
||||
if (overrideSchema) {
|
||||
result.schema = overrideSchema;
|
||||
}
|
||||
else {
|
||||
const params = {
|
||||
..._params,
|
||||
schemaPath: [..._params.schemaPath, schema],
|
||||
path: _params.path,
|
||||
};
|
||||
if (schema._zod.processJSONSchema) {
|
||||
schema._zod.processJSONSchema(ctx, result.schema, params);
|
||||
}
|
||||
else {
|
||||
const _json = result.schema;
|
||||
const processor = ctx.processors[def.type];
|
||||
if (!processor) {
|
||||
throw new Error(`[toJSONSchema]: Non-representable type encountered: ${def.type}`);
|
||||
}
|
||||
processor(schema, ctx, _json, params);
|
||||
}
|
||||
const parent = schema._zod.parent;
|
||||
if (parent) {
|
||||
// Also set ref if processor didn't (for inheritance)
|
||||
if (!result.ref)
|
||||
result.ref = parent;
|
||||
processSchema(parent, ctx, params);
|
||||
ctx.seen.get(parent).isParent = true;
|
||||
}
|
||||
}
|
||||
// metadata
|
||||
const meta = ctx.metadataRegistry.get(schema);
|
||||
if (meta)
|
||||
assignProps(result.schema, meta);
|
||||
if (ctx.io === "input" && isTransforming(schema)) {
|
||||
// examples/defaults only apply to output type of pipe
|
||||
delete result.schema.examples;
|
||||
delete result.schema.default;
|
||||
}
|
||||
// set prefault as default
|
||||
if (ctx.io === "input" && "_prefault" in result.schema)
|
||||
(_a = result.schema).default ?? (_a.default = result.schema._prefault);
|
||||
delete result.schema._prefault;
|
||||
// pulling fresh from ctx.seen in case it was overwritten
|
||||
const _result = ctx.seen.get(schema);
|
||||
return _result.schema;
|
||||
}
|
||||
// Escape a reference token for use in a JSON Pointer fragment (RFC 6901): `~` becomes `~0` and `/` becomes `~1`. The `~` replacement must run first.
|
||||
function encodeJSONPointerSegment(segment) {
|
||||
return segment.replace(/~/g, "~0").replace(/\//g, "~1");
|
||||
}
|
||||
function extractDefs(ctx, schema
|
||||
// params: EmitParams
|
||||
) {
|
||||
// iterate over seen map;
|
||||
const root = ctx.seen.get(schema);
|
||||
if (!root)
|
||||
throw new Error("Unprocessed schema. This is a bug in Zod.");
|
||||
// With `external` set, every registered schema resolves through the external branch of `makeURI`, so the root branch below produces the same ref the external branch would — this pass is identical whichever schema it is called with, and only needs to run once.
|
||||
if (ctx.external && ctx.sharedDefsExtractedFor === ctx.external)
|
||||
return;
|
||||
// Track ids to detect duplicates across different schemas
|
||||
const idToSchema = new Map();
|
||||
for (const entry of ctx.seen.entries()) {
|
||||
const id = ctx.metadataRegistry.get(entry[0])?.id;
|
||||
if (id) {
|
||||
const existing = idToSchema.get(id);
|
||||
if (existing && existing !== entry[0]) {
|
||||
throw new Error(`Duplicate schema id "${id}" detected during JSON Schema conversion. Two different schemas cannot share the same id when converted together.`);
|
||||
}
|
||||
idToSchema.set(id, entry[0]);
|
||||
}
|
||||
}
|
||||
// returns a ref to the schema defId will be empty if the ref points to an external schema (or #)
|
||||
const makeURI = (entry) => {
|
||||
// comparing the seen objects because sometimes multiple schemas map to the same seen object. e.g. lazy
|
||||
// external is configured
|
||||
const defsSegment = ctx.target === "draft-2020-12" ? "$defs" : "definitions";
|
||||
if (ctx.external) {
|
||||
const externalId = ctx.external.registry.get(entry[0])?.id; // ?? "__shared";// `__schema${ctx.counter++}`;
|
||||
// check if schema is in the external registry
|
||||
const uriGenerator = ctx.external.uri ?? ((id) => id);
|
||||
if (externalId) {
|
||||
return { ref: uriGenerator(externalId) };
|
||||
}
|
||||
// otherwise, add to __shared
|
||||
const id = entry[1].defId ?? entry[1].schema.id ?? `schema${ctx.counter++}`;
|
||||
entry[1].defId = id; // set defId so it will be reused if needed
|
||||
return { defId: id, ref: `${uriGenerator("__shared")}#/${defsSegment}/${encodeJSONPointerSegment(id)}` };
|
||||
}
|
||||
const uriPrefix = `#`;
|
||||
const defUriPrefix = `${uriPrefix}/${defsSegment}/`;
|
||||
// an id-less root has nowhere to be extracted to, so it stays inline and self-references as `#`
|
||||
if (entry[1] === root && !entry[1].schema.id) {
|
||||
return { ref: uriPrefix };
|
||||
}
|
||||
// self-contained schema
|
||||
const defId = entry[1].schema.id ?? `__schema${ctx.counter++}`;
|
||||
return { defId, ref: defUriPrefix + encodeJSONPointerSegment(defId) };
|
||||
};
|
||||
// stored cached version in `def` property remove all properties, set $ref
|
||||
const extractToDef = (entry) => {
|
||||
// if the schema is already a reference, do not extract it
|
||||
if (entry[1].schema.$ref) {
|
||||
return;
|
||||
}
|
||||
const seen = entry[1];
|
||||
const { ref, defId } = makeURI(entry);
|
||||
seen.def = { ...seen.schema };
|
||||
// defId won't be set if the schema is a reference to an external schema or if the schema is the root schema
|
||||
if (defId)
|
||||
seen.defId = defId;
|
||||
// wipe away all properties except $ref
|
||||
const schema = seen.schema;
|
||||
for (const key in schema) {
|
||||
delete schema[key];
|
||||
}
|
||||
schema.$ref = ref;
|
||||
};
|
||||
// throw on cycles
|
||||
// break cycles
|
||||
if (ctx.cycles === "throw") {
|
||||
for (const entry of ctx.seen.entries()) {
|
||||
const seen = entry[1];
|
||||
if (seen.cycle) {
|
||||
throw new Error("Cycle detected: " +
|
||||
`#/${seen.cycle?.join("/")}/<root>` +
|
||||
'\n\nSet the `cycles` parameter to `"ref"` to resolve cyclical schemas with defs.');
|
||||
}
|
||||
}
|
||||
}
|
||||
// extract schemas into $defs
|
||||
for (const entry of ctx.seen.entries()) {
|
||||
const seen = entry[1];
|
||||
// convert root schema to # $ref
|
||||
if (schema === entry[0]) {
|
||||
extractToDef(entry); // this has special handling for the root schema
|
||||
continue;
|
||||
}
|
||||
// extract schemas that are in the external registry
|
||||
if (ctx.external) {
|
||||
const ext = ctx.external.registry.get(entry[0])?.id;
|
||||
if (schema !== entry[0] && ext) {
|
||||
extractToDef(entry);
|
||||
continue;
|
||||
}
|
||||
}
|
||||
// extract schemas with `id` meta
|
||||
const id = ctx.metadataRegistry.get(entry[0])?.id;
|
||||
if (id) {
|
||||
extractToDef(entry);
|
||||
continue;
|
||||
}
|
||||
// break cycles
|
||||
if (seen.cycle) {
|
||||
// any
|
||||
extractToDef(entry);
|
||||
continue;
|
||||
}
|
||||
// extract reused schemas
|
||||
if (seen.count > 1) {
|
||||
if (ctx.reused === "ref") {
|
||||
extractToDef(entry);
|
||||
}
|
||||
}
|
||||
}
|
||||
if (ctx.external)
|
||||
ctx.sharedDefsExtractedFor = ctx.external;
|
||||
}
|
||||
/** Rewrites `anyOf: [{type: "a"}, {type: "b"}]` to `type: ["a", "b"]`, which every JSON Schema draft treats as equivalent and most consumers render far better for the nullable case. Only branches that are a bare type assertion qualify — anything carrying a constraint, `$ref`, `const` or metadata is left alone. Runs after `flattenRef`, so a branch an override decorated or `$defs` extraction turned into a `$ref` is no longer bare and correctly stays in `anyOf`. `oneOf` is excluded: `integer` and `number` overlap, so "exactly one" and "at least one" are not the same there. OpenAPI 3.0 is excluded: its `type` must be a single string. */
|
||||
function compactTypeUnion(schema) {
|
||||
const options = schema.anyOf;
|
||||
if (!Array.isArray(options) || options.length === 0 || schema.type !== undefined)
|
||||
return;
|
||||
const types = [];
|
||||
for (const option of options) {
|
||||
if (!option || typeof option !== "object")
|
||||
return;
|
||||
// A branch that is itself a compactible union folds into this one — nested `anyOf` and a flat `type` array say the same thing. Compacting it first also makes the result independent of the order this pass walks the seen map in.
|
||||
compactTypeUnion(option);
|
||||
const keys = Object.keys(option);
|
||||
if (keys.length !== 1 || keys[0] !== "type")
|
||||
return;
|
||||
const type = option.type;
|
||||
for (const member of Array.isArray(type) ? type : [type]) {
|
||||
if (typeof member !== "string")
|
||||
return;
|
||||
if (!types.includes(member))
|
||||
types.push(member);
|
||||
}
|
||||
}
|
||||
delete schema.anyOf;
|
||||
// A `type` array must be non-empty and unique (metaschema); a single member is spelled as a bare string.
|
||||
schema.type = types.length === 1 ? types[0] : types;
|
||||
}
|
||||
/** Keywords `foldIntersection` knows how to combine. Anything else — `$ref`, `patternProperties`,
|
||||
* an annotation like `description` — makes a member unfoldable, so a constraint this does not
|
||||
* understand leaves the `allOf` alone instead of being silently dropped or misattributed. */
|
||||
const FOLDABLE_KEYS = new Set(["type", "properties", "required", "additionalProperties"]);
|
||||
const UNION_KEYS = ["oneOf", "anyOf"];
|
||||
/** A member's constraint on a key it does not declare itself. A `catchall` states one; `false`, an absent `additionalProperties`, and the empty schema a loose object emits state nothing. */
|
||||
function undeclaredConstraint(member) {
|
||||
const extra = member.additionalProperties;
|
||||
if (extra === undefined || extra === false || typeof extra !== "object" || extra === null)
|
||||
return null;
|
||||
return Object.keys(extra).length ? extra : null;
|
||||
}
|
||||
/** Combines object members into the single object they describe together, or returns `null` if any of them carries a keyword outside {@link FOLDABLE_KEYS}. */
|
||||
function foldObjects(members) {
|
||||
const objects = [];
|
||||
for (const member of members) {
|
||||
// A boolean subschema is legal JSON Schema and carries no keywords to fold.
|
||||
if (typeof member !== "object" || member.type !== "object")
|
||||
return null;
|
||||
for (const key in member) {
|
||||
if (!FOLDABLE_KEYS.has(key))
|
||||
return null;
|
||||
}
|
||||
objects.push(member);
|
||||
}
|
||||
const properties = {};
|
||||
const required = new Set();
|
||||
for (const object of objects) {
|
||||
for (const key in object.properties) {
|
||||
// `in` would report a `__proto__` key as already present via the prototype chain and skip it.
|
||||
if (Object.prototype.hasOwnProperty.call(properties, key))
|
||||
continue;
|
||||
// Every member constrains this key: the ones that declare it say how, and a `catchall` member constrains it too even though it does not name it. The key has to satisfy all of them, which is the same intersection one level down.
|
||||
const parts = [];
|
||||
for (const other of objects) {
|
||||
const part = other.properties?.[key] ?? undeclaredConstraint(other);
|
||||
if (part === null || part === undefined)
|
||||
continue;
|
||||
if (!parts.some((seen) => JSON.stringify(seen) === JSON.stringify(part)))
|
||||
parts.push(part);
|
||||
}
|
||||
const merged = parts.length === 1
|
||||
? parts[0]
|
||||
: (foldObjects(parts) ?? { allOf: parts });
|
||||
(0, util_js_1.assignProp)(properties, key, merged);
|
||||
}
|
||||
for (const key of object.required ?? [])
|
||||
required.add(key);
|
||||
}
|
||||
const folded = { type: "object", properties };
|
||||
if (required.size)
|
||||
folded.required = [...required];
|
||||
// A key no member declares is rejected only when every member rejects it, so the fold is closed only when every member is. Otherwise it carries whatever the `catchall` members demand of such a key.
|
||||
if (objects.every((object) => object.additionalProperties === false)) {
|
||||
folded.additionalProperties = false;
|
||||
}
|
||||
else {
|
||||
const constraints = [];
|
||||
for (const object of objects) {
|
||||
const constraint = undeclaredConstraint(object);
|
||||
if (constraint && !constraints.some((seen) => JSON.stringify(seen) === JSON.stringify(constraint)))
|
||||
constraints.push(constraint);
|
||||
}
|
||||
if (constraints.length === 1)
|
||||
folded.additionalProperties = constraints[0];
|
||||
else if (constraints.length > 1)
|
||||
folded.additionalProperties = { allOf: constraints };
|
||||
}
|
||||
return folded;
|
||||
}
|
||||
/** `additionalProperties` in an `allOf` member sees only that member's own `properties`, so two
|
||||
* closed object members reject each other's keys and the schema validates nothing. Zod's parser
|
||||
* pools the key sets instead — `handleIntersectionResults` reports a key as unrecognized only when
|
||||
* *every* side rejects it — so the emitted schema has to pool them too, and folding the members
|
||||
* into one object is the encoding that says so on every target.
|
||||
*
|
||||
* This runs from `finalize`, after `extractDefs`, which is what keeps it clear of the `$ref`
|
||||
* machinery: a member extracted into `$defs` is already a `$ref` by now and declines to fold, so it
|
||||
* keeps its reference and its own closedness rather than being inlined as a stale copy. */
|
||||
function foldIntersection(json) {
|
||||
const allOf = json.allOf;
|
||||
if (!Array.isArray(allOf) || allOf.length < 2)
|
||||
return;
|
||||
// An `override` runs before this pass and may have written object keywords onto the intersection itself. Those are deliberate, so decline rather than overwrite them.
|
||||
for (const key of FOLDABLE_KEYS)
|
||||
if (key in json)
|
||||
return;
|
||||
// An intersection distributes over a union: `A & (X | Y)` is `(A & X) | (A & Y)`. Only the first union is distributed over; a second one stays among the members every branch folds against, where it fails the object check and declines the whole intersection rather than multiplying out.
|
||||
const unions = allOf.filter((m) => UNION_KEYS.some((k) => Array.isArray(m[k])));
|
||||
let folded = null;
|
||||
if (!unions.length) {
|
||||
folded = foldObjects(allOf);
|
||||
}
|
||||
else {
|
||||
const union = unions[0];
|
||||
const keyword = UNION_KEYS.find((k) => Array.isArray(union[k]));
|
||||
if (Object.keys(union).length !== 1)
|
||||
return;
|
||||
const rest = allOf.filter((m) => m !== union);
|
||||
const branches = union[keyword].map((branch) => foldObjects([...rest, branch]));
|
||||
if (branches.some((b) => !b))
|
||||
return;
|
||||
folded = { [keyword]: branches };
|
||||
}
|
||||
if (!folded)
|
||||
return;
|
||||
delete json.allOf;
|
||||
assignProps(json, folded);
|
||||
}
|
||||
function finalize(ctx, schema) {
|
||||
const root = ctx.seen.get(schema);
|
||||
if (!root)
|
||||
throw new Error("Unprocessed schema. This is a bug in Zod.");
|
||||
// flatten refs - inherit properties from parent schemas
|
||||
const flattenRef = (zodSchema) => {
|
||||
const seen = ctx.seen.get(zodSchema);
|
||||
// already processed
|
||||
if (seen.ref === null)
|
||||
return;
|
||||
const schema = seen.def ?? seen.schema;
|
||||
const _cached = { ...schema };
|
||||
const ref = seen.ref;
|
||||
seen.ref = null; // prevent infinite recursion
|
||||
if (ref) {
|
||||
flattenRef(ref);
|
||||
const refSeen = ctx.seen.get(ref);
|
||||
const refSchema = refSeen.schema;
|
||||
// merge referenced schema into current
|
||||
if (refSchema.$ref && (ctx.target === "draft-07" || ctx.target === "draft-04" || ctx.target === "openapi-3.0")) {
|
||||
// older drafts can't combine $ref with other properties
|
||||
schema.allOf = schema.allOf ?? [];
|
||||
schema.allOf.push(refSchema);
|
||||
}
|
||||
else {
|
||||
assignProps(schema, refSchema);
|
||||
}
|
||||
// restore child's own properties (child wins)
|
||||
assignProps(schema, _cached);
|
||||
const isParentRef = zodSchema._zod.parent === ref;
|
||||
// For parent chain, child is a refinement - remove parent-only properties
|
||||
if (isParentRef) {
|
||||
for (const key in schema) {
|
||||
if (key === "$ref" || key === "allOf")
|
||||
continue;
|
||||
if (!(key in _cached)) {
|
||||
delete schema[key];
|
||||
}
|
||||
}
|
||||
}
|
||||
// When ref was extracted to $defs, remove properties that match the definition
|
||||
if (refSchema.$ref && refSeen.def) {
|
||||
for (const key in schema) {
|
||||
if (key === "$ref" || key === "allOf")
|
||||
continue;
|
||||
if (key in refSeen.def && JSON.stringify(schema[key]) === JSON.stringify(refSeen.def[key])) {
|
||||
delete schema[key];
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
// If parent was extracted (has $ref), propagate $ref to this schema. This handles cases like: readonly().meta({id}).describe() where processor sets ref to innerType but parent should be referenced
|
||||
const parent = zodSchema._zod.parent;
|
||||
if (parent && parent !== ref) {
|
||||
// Ensure parent is processed first so its def has inherited properties
|
||||
flattenRef(parent);
|
||||
const parentSeen = ctx.seen.get(parent);
|
||||
if (parentSeen?.schema.$ref) {
|
||||
schema.$ref = parentSeen.schema.$ref;
|
||||
// De-duplicate with parent's definition
|
||||
if (parentSeen.def) {
|
||||
for (const key in schema) {
|
||||
if (key === "$ref" || key === "allOf")
|
||||
continue;
|
||||
if (key in parentSeen.def && JSON.stringify(schema[key]) === JSON.stringify(parentSeen.def[key])) {
|
||||
delete schema[key];
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
// execute overrides
|
||||
ctx.override({
|
||||
zodSchema: zodSchema,
|
||||
jsonSchema: schema,
|
||||
path: seen.path ?? [],
|
||||
});
|
||||
};
|
||||
// Flattening walks the whole map and clears each `ref` as it goes, so a second call over the same map is a no-op scan. Skip it outright once it has run for a registry conversion.
|
||||
if (!ctx.external || ctx.sharedEmitDoneFor !== ctx.external) {
|
||||
for (const entry of [...ctx.seen.entries()].reverse()) {
|
||||
flattenRef(entry[0]);
|
||||
}
|
||||
if (ctx.target !== "openapi-3.0") {
|
||||
for (const entry of ctx.seen.entries()) {
|
||||
compactTypeUnion(entry[1].def ?? entry[1].schema);
|
||||
}
|
||||
}
|
||||
for (const rewrite of ctx.deferred)
|
||||
rewrite();
|
||||
// After flattening, every member that was extracted is a `$ref`, so the fold sees the final shape. A schema that inherits an intersection — through `z.lazy`, or any `ref` chain — holds the same `allOf` array, so fold by array identity to catch every copy.
|
||||
if (ctx.intersections.length) {
|
||||
const carriers = new Map();
|
||||
for (const seen of ctx.seen.values()) {
|
||||
for (const json of [seen.schema, seen.def]) {
|
||||
const allOf = json?.allOf;
|
||||
if (!Array.isArray(allOf))
|
||||
continue;
|
||||
const existing = carriers.get(allOf);
|
||||
if (existing)
|
||||
existing.push(json);
|
||||
else
|
||||
carriers.set(allOf, [json]);
|
||||
}
|
||||
}
|
||||
for (const allOf of ctx.intersections) {
|
||||
for (const json of carriers.get(allOf) ?? [])
|
||||
foldIntersection(json);
|
||||
}
|
||||
}
|
||||
}
|
||||
const result = {};
|
||||
if (ctx.target === "draft-2020-12") {
|
||||
result.$schema = "https://json-schema.org/draft/2020-12/schema";
|
||||
}
|
||||
else if (ctx.target === "draft-07") {
|
||||
result.$schema = "http://json-schema.org/draft-07/schema#";
|
||||
}
|
||||
else if (ctx.target === "draft-04") {
|
||||
result.$schema = "http://json-schema.org/draft-04/schema#";
|
||||
}
|
||||
else if (ctx.target === "openapi-3.0") {
|
||||
// OpenAPI 3.0 schema objects should not include a $schema property
|
||||
}
|
||||
else {
|
||||
// Arbitrary string values are allowed but won't have a $schema property set
|
||||
}
|
||||
if (ctx.external?.uri) {
|
||||
const id = ctx.external.registry.get(schema)?.id;
|
||||
if (!id)
|
||||
throw new Error("Schema is missing an `id` property");
|
||||
result.$id = ctx.external.uri(id);
|
||||
}
|
||||
// when the root was extracted into $defs, `root.schema` is the `$ref` wrapper and `root.def` is the body that now lives under $defs
|
||||
assignProps(result, root.defId ? root.schema : (root.def ?? root.schema));
|
||||
// The `id` in `.meta()` is a Zod-specific registration tag used to extract schemas into $defs — it is not user-facing JSON Schema metadata. Strip it from the output body where it would otherwise leak. The id is preserved implicitly via the $defs key (and via $ref paths).
|
||||
const rootMetaId = ctx.metadataRegistry.get(schema)?.id;
|
||||
if (rootMetaId !== undefined && result.id === rootMetaId)
|
||||
delete result.id;
|
||||
// build defs object. With `external`, `defs` is the shared object every schema writes into, so the same entries are reassigned on every call. Without it, `defs` is fresh per call and must be rebuilt.
|
||||
const defs = ctx.external?.defs ?? {};
|
||||
if (!ctx.external || ctx.sharedEmitDoneFor !== ctx.external) {
|
||||
for (const entry of ctx.seen.entries()) {
|
||||
const seen = entry[1];
|
||||
if (seen.def && seen.defId) {
|
||||
if (seen.def.id === seen.defId)
|
||||
delete seen.def.id;
|
||||
(0, util_js_1.assignProp)(defs, seen.defId, seen.def);
|
||||
}
|
||||
}
|
||||
}
|
||||
if (ctx.external)
|
||||
ctx.sharedEmitDoneFor = ctx.external;
|
||||
// set definitions in result
|
||||
if (ctx.external) {
|
||||
}
|
||||
else {
|
||||
if (Object.keys(defs).length > 0) {
|
||||
if (ctx.target === "draft-2020-12") {
|
||||
result.$defs = defs;
|
||||
}
|
||||
else {
|
||||
result.definitions = defs;
|
||||
}
|
||||
}
|
||||
}
|
||||
try {
|
||||
// this "finalizes" this schema and ensures all cycles are removed each call to finalize() is functionally independent though the seen map is shared
|
||||
const finalized = JSON.parse(JSON.stringify(result));
|
||||
Object.defineProperty(finalized, "~standard", {
|
||||
value: {
|
||||
...schema["~standard"],
|
||||
jsonSchema: {
|
||||
input: (0, exports.createStandardJSONSchemaMethod)(schema, "input", ctx.processors),
|
||||
output: (0, exports.createStandardJSONSchemaMethod)(schema, "output", ctx.processors),
|
||||
},
|
||||
},
|
||||
enumerable: false,
|
||||
writable: false,
|
||||
});
|
||||
return finalized;
|
||||
}
|
||||
catch (_err) {
|
||||
throw new Error("Error converting schema to JSON.");
|
||||
}
|
||||
}
|
||||
function isTransforming(_schema, _ctx) {
|
||||
const ctx = _ctx ?? { seen: new Set() };
|
||||
if (ctx.seen.has(_schema))
|
||||
return false;
|
||||
ctx.seen.add(_schema);
|
||||
const def = _schema._zod.def;
|
||||
if (def.type === "transform")
|
||||
return true;
|
||||
if (def.type === "array")
|
||||
return isTransforming(def.element, ctx);
|
||||
if (def.type === "set")
|
||||
return isTransforming(def.valueType, ctx);
|
||||
if (def.type === "lazy")
|
||||
return isTransforming(def.getter(), ctx);
|
||||
if (def.type === "promise" ||
|
||||
def.type === "optional" ||
|
||||
def.type === "nonoptional" ||
|
||||
def.type === "nullable" ||
|
||||
def.type === "readonly" ||
|
||||
def.type === "default" ||
|
||||
def.type === "prefault" ||
|
||||
def.type === "catch") {
|
||||
return isTransforming(def.innerType, ctx);
|
||||
}
|
||||
if (def.type === "intersection") {
|
||||
return isTransforming(def.left, ctx) || isTransforming(def.right, ctx);
|
||||
}
|
||||
if (def.type === "record" || def.type === "map") {
|
||||
return isTransforming(def.keyType, ctx) || isTransforming(def.valueType, ctx);
|
||||
}
|
||||
if (def.type === "pipe") {
|
||||
if (_schema._zod.traits.has("$ZodCodec"))
|
||||
return true;
|
||||
return isTransforming(def.in, ctx) || isTransforming(def.out, ctx);
|
||||
}
|
||||
if (def.type === "object") {
|
||||
for (const key in def.shape) {
|
||||
if (isTransforming(def.shape[key], ctx))
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
if (def.type === "union") {
|
||||
for (const option of def.options) {
|
||||
if (isTransforming(option, ctx))
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
if (def.type === "tuple") {
|
||||
for (const item of def.items) {
|
||||
if (isTransforming(item, ctx))
|
||||
return true;
|
||||
}
|
||||
if (def.rest && isTransforming(def.rest, ctx))
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
/**
|
||||
* Creates a toJSONSchema method for a schema instance.
|
||||
* This encapsulates the logic of initializing context, processing, extracting defs, and finalizing.
|
||||
*/
|
||||
const createToJSONSchemaMethod = (schema, processors = {}) => (params) => {
|
||||
const ctx = initializeContext({ ...params, processors });
|
||||
processSchema(schema, ctx);
|
||||
extractDefs(ctx, schema);
|
||||
return finalize(ctx, schema);
|
||||
};
|
||||
exports.createToJSONSchemaMethod = createToJSONSchemaMethod;
|
||||
const createStandardJSONSchemaMethod = (schema, io, processors = {}) => (params) => {
|
||||
const { libraryOptions, target } = params ?? {};
|
||||
const ctx = initializeContext({ ...(libraryOptions ?? {}), target, io, processors });
|
||||
processSchema(schema, ctx);
|
||||
extractDefs(ctx, schema);
|
||||
return finalize(ctx, schema);
|
||||
};
|
||||
exports.createStandardJSONSchemaMethod = createStandardJSONSchemaMethod;
|
||||
|
||||
// seal-cjs-exports
|
||||
(function () {
|
||||
var keys = Object.getOwnPropertyNames(exports);
|
||||
for (var i = 0; i < keys.length; i++) {
|
||||
var desc = Object.getOwnPropertyDescriptor(exports, keys[i]);
|
||||
if (!desc || !desc.get || !desc.configurable) continue;
|
||||
var value;
|
||||
try {
|
||||
value = desc.get();
|
||||
} catch (e) {
|
||||
continue;
|
||||
}
|
||||
// a circular require may not have settled this one yet, so leave it live
|
||||
if (value === undefined) continue;
|
||||
Object.defineProperty(exports, keys[i], { value: value, writable: false, enumerable: desc.enumerable, configurable: false });
|
||||
}
|
||||
Object.freeze(exports);
|
||||
})();
|
||||
+154
@@ -0,0 +1,154 @@
|
||||
import type * as core from "../core/index.cjs";
|
||||
import type * as JSONSchema from "./json-schema.cjs";
|
||||
import { type $ZodRegistry } from "./registries.cjs";
|
||||
import type * as schemas from "./schemas.cjs";
|
||||
import type { StandardJSONSchemaV1, StandardSchemaWithJSONProps } from "./standard-schema.cjs";
|
||||
export type Processor<T extends schemas.$ZodType = schemas.$ZodType> = (schema: T, ctx: ToJSONSchemaContext, json: JSONSchema.BaseSchema, params: ProcessParams) => void;
|
||||
/**
|
||||
* Called for each schema that has no JSON Schema equivalent. Return a JSON Schema to use in its
|
||||
* place, `"any"` to fall back to the `unrepresentable: "any"` behavior, or `"throw"`/`undefined` to
|
||||
* throw the default error. Throwing from the handler propagates, so custom errors work too.
|
||||
*/
|
||||
export type UnrepresentableHandler<T extends schemas.$ZodType = schemas.$ZodType> = (ctx: {
|
||||
zodSchema: T;
|
||||
path: (string | number)[];
|
||||
/** The error Zod would throw. Distinguishes sites that share a `zodSchema`, e.g. an `undefined`
|
||||
* vs a `bigint` member of the same literal. */
|
||||
message: string;
|
||||
}) => JSONSchema.BaseSchema | "throw" | "any" | undefined;
|
||||
export interface JSONSchemaGeneratorParams {
|
||||
processors: Record<string, Processor>;
|
||||
/** A registry used to look up metadata for each schema. Any schema with an `id` property will be extracted as a $def.
|
||||
* @default globalRegistry */
|
||||
metadata?: $ZodRegistry<Record<string, any>>;
|
||||
/** The JSON Schema version to target.
|
||||
* - `"draft-2020-12"` — Default. JSON Schema Draft 2020-12
|
||||
* - `"draft-07"` — JSON Schema Draft 7
|
||||
* - `"draft-04"` — JSON Schema Draft 4
|
||||
* - `"openapi-3.0"` — OpenAPI 3.0 Schema Object */
|
||||
target?: "draft-04" | "draft-07" | "draft-2020-12" | "openapi-3.0" | ({} & string) | undefined;
|
||||
/** How to handle unrepresentable types.
|
||||
* - `"throw"` — Default. Unrepresentable types throw an error
|
||||
* - `"any"` — Unrepresentable types become `{}`
|
||||
* - A function — called once per unrepresentable schema; see {@link UnrepresentableHandler}. */
|
||||
unrepresentable?: "throw" | "any" | UnrepresentableHandler<schemas.$ZodTypes>;
|
||||
/** Arbitrary custom logic that can be used to modify the generated JSON Schema. */
|
||||
override?: (ctx: {
|
||||
zodSchema: schemas.$ZodTypes;
|
||||
jsonSchema: JSONSchema.BaseSchema;
|
||||
path: (string | number)[];
|
||||
}) => void;
|
||||
/** Whether to extract the `"input"` or `"output"` type. Relevant to transforms, defaults, coerced primitives, etc.
|
||||
* - `"output"` — Default. Convert the output schema.
|
||||
* - `"input"` — Convert the input schema. */
|
||||
io?: "input" | "output";
|
||||
cycles?: "ref" | "throw";
|
||||
reused?: "ref" | "inline";
|
||||
external?: {
|
||||
registry: $ZodRegistry<{
|
||||
id?: string | undefined;
|
||||
}>;
|
||||
uri?: ((id: string) => string) | undefined;
|
||||
defs: Record<string, JSONSchema.BaseSchema>;
|
||||
} | undefined;
|
||||
}
|
||||
/**
|
||||
* Parameters for the toJSONSchema function.
|
||||
*/
|
||||
export type ToJSONSchemaParams = Omit<JSONSchemaGeneratorParams, "processors" | "external">;
|
||||
/**
|
||||
* Parameters for the toJSONSchema function when passing a registry.
|
||||
*/
|
||||
export interface RegistryToJSONSchemaParams extends ToJSONSchemaParams {
|
||||
uri?: (id: string) => string;
|
||||
}
|
||||
export interface ProcessParams {
|
||||
schemaPath: schemas.$ZodType[];
|
||||
path: (string | number)[];
|
||||
}
|
||||
export interface Seen {
|
||||
/** JSON Schema result for this Zod schema */
|
||||
schema: JSONSchema.BaseSchema;
|
||||
/** A cached version of the schema that doesn't get overwritten during ref resolution */
|
||||
def?: JSONSchema.BaseSchema;
|
||||
defId?: string | undefined;
|
||||
/** Number of times this schema was encountered during traversal */
|
||||
count: number;
|
||||
/** Cycle path */
|
||||
cycle?: (string | number)[] | undefined;
|
||||
isParent?: boolean | undefined;
|
||||
/** Schema to inherit JSON Schema properties from (set by processor for wrappers) */
|
||||
ref?: schemas.$ZodType | null;
|
||||
/** JSON Schema property path for this schema */
|
||||
path?: (string | number)[] | undefined;
|
||||
}
|
||||
export interface ToJSONSchemaContext {
|
||||
processors: Record<string, Processor>;
|
||||
metadataRegistry: $ZodRegistry<Record<string, any>>;
|
||||
target: "draft-04" | "draft-07" | "draft-2020-12" | "openapi-3.0" | ({} & string);
|
||||
unrepresentable: "throw" | "any" | UnrepresentableHandler;
|
||||
override: (ctx: {
|
||||
zodSchema: schemas.$ZodType;
|
||||
jsonSchema: JSONSchema.BaseSchema;
|
||||
path: (string | number)[];
|
||||
}) => void;
|
||||
io: "input" | "output";
|
||||
counter: number;
|
||||
seen: Map<schemas.$ZodType, Seen>;
|
||||
/** Registry conversions share one `seen` map across every emitted schema. These hold the
|
||||
* `external` the whole-map passes below last ran for, so the passes are not repeated once per
|
||||
* schema — and still re-run if the map grows or `external` is swapped. `sharedEmitDoneFor`
|
||||
* covers both passes in `finalize`: the ref flattening and the `$defs` build.
|
||||
*
|
||||
* The passes are valid only while nothing they read has changed, so both are cleared in
|
||||
* `processSchema()` when the map grows, and in `JSONSchemaGenerator.emit()`, which can also change
|
||||
* the `cycles` and `reused` they branch on.
|
||||
*
|
||||
* One case is deliberately not covered: an `override` callback that writes to
|
||||
* `metadataRegistry` mid-conversion. It runs inside `finalize`, so a registry conversion has
|
||||
* nowhere left to clear the guards, and later schemas keep the ids the first pass saw. That
|
||||
* output was never coherent — before this, whether a shared subschema was inlined or extracted
|
||||
* depended on which registry entry happened to be emitted when the callback fired. */
|
||||
sharedDefsExtractedFor?: ToJSONSchemaContext["external"];
|
||||
sharedEmitDoneFor?: ToJSONSchemaContext["external"];
|
||||
cycles: "ref" | "throw";
|
||||
reused: "ref" | "inline";
|
||||
/** The `allOf` array of each intersection encountered during traversal, innermost first. `finalize` folds every emitted object holding one; see `foldIntersection`. */
|
||||
intersections: JSONSchema.BaseSchema[][];
|
||||
/** Rewrites a processor deferred to `finalize`, where the flatten has resolved every ref and the union branches are in place. */
|
||||
deferred: (() => void)[];
|
||||
external?: {
|
||||
registry: $ZodRegistry<{
|
||||
id?: string | undefined;
|
||||
}>;
|
||||
uri?: ((id: string) => string) | undefined;
|
||||
defs: Record<string, JSONSchema.BaseSchema>;
|
||||
} | undefined;
|
||||
}
|
||||
export declare function initializeContext(params: JSONSchemaGeneratorParams): ToJSONSchemaContext;
|
||||
/**
|
||||
* Applies the `unrepresentable` setting at a site that has no JSON Schema equivalent. Throws
|
||||
* `message` unless the setting (or the handler's return value) says otherwise. Returns `true` if a
|
||||
* custom JSON Schema was written into `json`, in which case the caller must not write its own.
|
||||
*/
|
||||
export declare function handleUnrepresentable(schema: schemas.$ZodType, ctx: ToJSONSchemaContext, json: JSONSchema.BaseSchema, params: ProcessParams, message: string): boolean;
|
||||
export declare function processSchema<T extends schemas.$ZodType>(schema: T, ctx: ToJSONSchemaContext, _params?: ProcessParams): JSONSchema.BaseSchema;
|
||||
/** @deprecated Renamed to `processSchema`. An export alias declares no binding, so it is safe to keep. */
|
||||
export { processSchema as process };
|
||||
export declare function extractDefs<T extends schemas.$ZodType>(ctx: ToJSONSchemaContext, schema: T): void;
|
||||
export declare function finalize<T extends schemas.$ZodType>(ctx: ToJSONSchemaContext, schema: T): ZodStandardJSONSchemaPayload<T>;
|
||||
export type ZodStandardSchemaWithJSON<T> = StandardSchemaWithJSONProps<core.input<T>, core.output<T>>;
|
||||
export interface ZodStandardJSONSchemaPayload<T> extends JSONSchema.BaseSchema {
|
||||
"~standard": ZodStandardSchemaWithJSON<T>;
|
||||
}
|
||||
/**
|
||||
* Creates a toJSONSchema method for a schema instance.
|
||||
* This encapsulates the logic of initializing context, processing, extracting defs, and finalizing.
|
||||
*/
|
||||
export declare const createToJSONSchemaMethod: <T extends schemas.$ZodType>(schema: T, processors?: Record<string, Processor>) => (params?: ToJSONSchemaParams) => ZodStandardJSONSchemaPayload<T>;
|
||||
/**
|
||||
* Creates a toJSONSchema method for a schema instance.
|
||||
* This encapsulates the logic of initializing context, processing, extracting defs, and finalizing.
|
||||
*/
|
||||
type StandardJSONSchemaMethodParams = Parameters<StandardJSONSchemaV1["~standard"]["jsonSchema"]["input"]>[0];
|
||||
export declare const createStandardJSONSchemaMethod: <T extends schemas.$ZodType>(schema: T, io: "input" | "output", processors?: Record<string, Processor>) => (params?: StandardJSONSchemaMethodParams) => JSONSchema.BaseSchema;
|
||||
+154
@@ -0,0 +1,154 @@
|
||||
import type * as core from "../core/index.js";
|
||||
import type * as JSONSchema from "./json-schema.js";
|
||||
import { type $ZodRegistry } from "./registries.js";
|
||||
import type * as schemas from "./schemas.js";
|
||||
import type { StandardJSONSchemaV1, StandardSchemaWithJSONProps } from "./standard-schema.js";
|
||||
export type Processor<T extends schemas.$ZodType = schemas.$ZodType> = (schema: T, ctx: ToJSONSchemaContext, json: JSONSchema.BaseSchema, params: ProcessParams) => void;
|
||||
/**
|
||||
* Called for each schema that has no JSON Schema equivalent. Return a JSON Schema to use in its
|
||||
* place, `"any"` to fall back to the `unrepresentable: "any"` behavior, or `"throw"`/`undefined` to
|
||||
* throw the default error. Throwing from the handler propagates, so custom errors work too.
|
||||
*/
|
||||
export type UnrepresentableHandler<T extends schemas.$ZodType = schemas.$ZodType> = (ctx: {
|
||||
zodSchema: T;
|
||||
path: (string | number)[];
|
||||
/** The error Zod would throw. Distinguishes sites that share a `zodSchema`, e.g. an `undefined`
|
||||
* vs a `bigint` member of the same literal. */
|
||||
message: string;
|
||||
}) => JSONSchema.BaseSchema | "throw" | "any" | undefined;
|
||||
export interface JSONSchemaGeneratorParams {
|
||||
processors: Record<string, Processor>;
|
||||
/** A registry used to look up metadata for each schema. Any schema with an `id` property will be extracted as a $def.
|
||||
* @default globalRegistry */
|
||||
metadata?: $ZodRegistry<Record<string, any>>;
|
||||
/** The JSON Schema version to target.
|
||||
* - `"draft-2020-12"` — Default. JSON Schema Draft 2020-12
|
||||
* - `"draft-07"` — JSON Schema Draft 7
|
||||
* - `"draft-04"` — JSON Schema Draft 4
|
||||
* - `"openapi-3.0"` — OpenAPI 3.0 Schema Object */
|
||||
target?: "draft-04" | "draft-07" | "draft-2020-12" | "openapi-3.0" | ({} & string) | undefined;
|
||||
/** How to handle unrepresentable types.
|
||||
* - `"throw"` — Default. Unrepresentable types throw an error
|
||||
* - `"any"` — Unrepresentable types become `{}`
|
||||
* - A function — called once per unrepresentable schema; see {@link UnrepresentableHandler}. */
|
||||
unrepresentable?: "throw" | "any" | UnrepresentableHandler<schemas.$ZodTypes>;
|
||||
/** Arbitrary custom logic that can be used to modify the generated JSON Schema. */
|
||||
override?: (ctx: {
|
||||
zodSchema: schemas.$ZodTypes;
|
||||
jsonSchema: JSONSchema.BaseSchema;
|
||||
path: (string | number)[];
|
||||
}) => void;
|
||||
/** Whether to extract the `"input"` or `"output"` type. Relevant to transforms, defaults, coerced primitives, etc.
|
||||
* - `"output"` — Default. Convert the output schema.
|
||||
* - `"input"` — Convert the input schema. */
|
||||
io?: "input" | "output";
|
||||
cycles?: "ref" | "throw";
|
||||
reused?: "ref" | "inline";
|
||||
external?: {
|
||||
registry: $ZodRegistry<{
|
||||
id?: string | undefined;
|
||||
}>;
|
||||
uri?: ((id: string) => string) | undefined;
|
||||
defs: Record<string, JSONSchema.BaseSchema>;
|
||||
} | undefined;
|
||||
}
|
||||
/**
|
||||
* Parameters for the toJSONSchema function.
|
||||
*/
|
||||
export type ToJSONSchemaParams = Omit<JSONSchemaGeneratorParams, "processors" | "external">;
|
||||
/**
|
||||
* Parameters for the toJSONSchema function when passing a registry.
|
||||
*/
|
||||
export interface RegistryToJSONSchemaParams extends ToJSONSchemaParams {
|
||||
uri?: (id: string) => string;
|
||||
}
|
||||
export interface ProcessParams {
|
||||
schemaPath: schemas.$ZodType[];
|
||||
path: (string | number)[];
|
||||
}
|
||||
export interface Seen {
|
||||
/** JSON Schema result for this Zod schema */
|
||||
schema: JSONSchema.BaseSchema;
|
||||
/** A cached version of the schema that doesn't get overwritten during ref resolution */
|
||||
def?: JSONSchema.BaseSchema;
|
||||
defId?: string | undefined;
|
||||
/** Number of times this schema was encountered during traversal */
|
||||
count: number;
|
||||
/** Cycle path */
|
||||
cycle?: (string | number)[] | undefined;
|
||||
isParent?: boolean | undefined;
|
||||
/** Schema to inherit JSON Schema properties from (set by processor for wrappers) */
|
||||
ref?: schemas.$ZodType | null;
|
||||
/** JSON Schema property path for this schema */
|
||||
path?: (string | number)[] | undefined;
|
||||
}
|
||||
export interface ToJSONSchemaContext {
|
||||
processors: Record<string, Processor>;
|
||||
metadataRegistry: $ZodRegistry<Record<string, any>>;
|
||||
target: "draft-04" | "draft-07" | "draft-2020-12" | "openapi-3.0" | ({} & string);
|
||||
unrepresentable: "throw" | "any" | UnrepresentableHandler;
|
||||
override: (ctx: {
|
||||
zodSchema: schemas.$ZodType;
|
||||
jsonSchema: JSONSchema.BaseSchema;
|
||||
path: (string | number)[];
|
||||
}) => void;
|
||||
io: "input" | "output";
|
||||
counter: number;
|
||||
seen: Map<schemas.$ZodType, Seen>;
|
||||
/** Registry conversions share one `seen` map across every emitted schema. These hold the
|
||||
* `external` the whole-map passes below last ran for, so the passes are not repeated once per
|
||||
* schema — and still re-run if the map grows or `external` is swapped. `sharedEmitDoneFor`
|
||||
* covers both passes in `finalize`: the ref flattening and the `$defs` build.
|
||||
*
|
||||
* The passes are valid only while nothing they read has changed, so both are cleared in
|
||||
* `processSchema()` when the map grows, and in `JSONSchemaGenerator.emit()`, which can also change
|
||||
* the `cycles` and `reused` they branch on.
|
||||
*
|
||||
* One case is deliberately not covered: an `override` callback that writes to
|
||||
* `metadataRegistry` mid-conversion. It runs inside `finalize`, so a registry conversion has
|
||||
* nowhere left to clear the guards, and later schemas keep the ids the first pass saw. That
|
||||
* output was never coherent — before this, whether a shared subschema was inlined or extracted
|
||||
* depended on which registry entry happened to be emitted when the callback fired. */
|
||||
sharedDefsExtractedFor?: ToJSONSchemaContext["external"];
|
||||
sharedEmitDoneFor?: ToJSONSchemaContext["external"];
|
||||
cycles: "ref" | "throw";
|
||||
reused: "ref" | "inline";
|
||||
/** The `allOf` array of each intersection encountered during traversal, innermost first. `finalize` folds every emitted object holding one; see `foldIntersection`. */
|
||||
intersections: JSONSchema.BaseSchema[][];
|
||||
/** Rewrites a processor deferred to `finalize`, where the flatten has resolved every ref and the union branches are in place. */
|
||||
deferred: (() => void)[];
|
||||
external?: {
|
||||
registry: $ZodRegistry<{
|
||||
id?: string | undefined;
|
||||
}>;
|
||||
uri?: ((id: string) => string) | undefined;
|
||||
defs: Record<string, JSONSchema.BaseSchema>;
|
||||
} | undefined;
|
||||
}
|
||||
export declare function initializeContext(params: JSONSchemaGeneratorParams): ToJSONSchemaContext;
|
||||
/**
|
||||
* Applies the `unrepresentable` setting at a site that has no JSON Schema equivalent. Throws
|
||||
* `message` unless the setting (or the handler's return value) says otherwise. Returns `true` if a
|
||||
* custom JSON Schema was written into `json`, in which case the caller must not write its own.
|
||||
*/
|
||||
export declare function handleUnrepresentable(schema: schemas.$ZodType, ctx: ToJSONSchemaContext, json: JSONSchema.BaseSchema, params: ProcessParams, message: string): boolean;
|
||||
export declare function processSchema<T extends schemas.$ZodType>(schema: T, ctx: ToJSONSchemaContext, _params?: ProcessParams): JSONSchema.BaseSchema;
|
||||
/** @deprecated Renamed to `processSchema`. An export alias declares no binding, so it is safe to keep. */
|
||||
export { processSchema as process };
|
||||
export declare function extractDefs<T extends schemas.$ZodType>(ctx: ToJSONSchemaContext, schema: T): void;
|
||||
export declare function finalize<T extends schemas.$ZodType>(ctx: ToJSONSchemaContext, schema: T): ZodStandardJSONSchemaPayload<T>;
|
||||
export type ZodStandardSchemaWithJSON<T> = StandardSchemaWithJSONProps<core.input<T>, core.output<T>>;
|
||||
export interface ZodStandardJSONSchemaPayload<T> extends JSONSchema.BaseSchema {
|
||||
"~standard": ZodStandardSchemaWithJSON<T>;
|
||||
}
|
||||
/**
|
||||
* Creates a toJSONSchema method for a schema instance.
|
||||
* This encapsulates the logic of initializing context, processing, extracting defs, and finalizing.
|
||||
*/
|
||||
export declare const createToJSONSchemaMethod: <T extends schemas.$ZodType>(schema: T, processors?: Record<string, Processor>) => (params?: ToJSONSchemaParams) => ZodStandardJSONSchemaPayload<T>;
|
||||
/**
|
||||
* Creates a toJSONSchema method for a schema instance.
|
||||
* This encapsulates the logic of initializing context, processing, extracting defs, and finalizing.
|
||||
*/
|
||||
type StandardJSONSchemaMethodParams = Parameters<StandardJSONSchemaV1["~standard"]["jsonSchema"]["input"]>[0];
|
||||
export declare const createStandardJSONSchemaMethod: <T extends schemas.$ZodType>(schema: T, io: "input" | "output", processors?: Record<string, Processor>) => (params?: StandardJSONSchemaMethodParams) => JSONSchema.BaseSchema;
|
||||
+651
@@ -0,0 +1,651 @@
|
||||
import { globalRegistry } from "./registries.js";
|
||||
import { assignProp } from "./util.js";
|
||||
function assignProps(target, ...sources) {
|
||||
for (const source of sources) {
|
||||
for (const key of Reflect.ownKeys(source)) {
|
||||
if (Object.prototype.propertyIsEnumerable.call(source, key)) {
|
||||
assignProp(target, key, source[key]);
|
||||
}
|
||||
}
|
||||
}
|
||||
return target;
|
||||
}
|
||||
// function initializeContext<T extends schemas.$ZodType>(inputs: JSONSchemaGeneratorParams<T>): ToJSONSchemaContext<T> {
|
||||
// return {
|
||||
// processor: inputs.processor,
|
||||
// metadataRegistry: inputs.metadata ?? globalRegistry,
|
||||
// target: inputs.target ?? "draft-2020-12",
|
||||
// unrepresentable: inputs.unrepresentable ?? "throw",
|
||||
// };
|
||||
// }
|
||||
export function initializeContext(params) {
|
||||
// Normalize target: convert old non-hyphenated versions to hyphenated versions
|
||||
let target = params?.target ?? "draft-2020-12";
|
||||
if (target === "draft-4")
|
||||
target = "draft-04";
|
||||
if (target === "draft-7")
|
||||
target = "draft-07";
|
||||
return {
|
||||
processors: params.processors ?? {},
|
||||
metadataRegistry: params?.metadata ?? globalRegistry,
|
||||
target,
|
||||
unrepresentable: params?.unrepresentable ?? "throw",
|
||||
override: params?.override ?? (() => { }),
|
||||
io: params?.io ?? "output",
|
||||
counter: 0,
|
||||
seen: new Map(),
|
||||
sharedDefsExtractedFor: undefined,
|
||||
sharedEmitDoneFor: undefined,
|
||||
cycles: params?.cycles ?? "ref",
|
||||
reused: params?.reused ?? "inline",
|
||||
intersections: [],
|
||||
deferred: [],
|
||||
external: params?.external ?? undefined,
|
||||
};
|
||||
}
|
||||
/**
|
||||
* Applies the `unrepresentable` setting at a site that has no JSON Schema equivalent. Throws
|
||||
* `message` unless the setting (or the handler's return value) says otherwise. Returns `true` if a
|
||||
* custom JSON Schema was written into `json`, in which case the caller must not write its own.
|
||||
*/
|
||||
export function handleUnrepresentable(schema, ctx, json, params, message) {
|
||||
const result = typeof ctx.unrepresentable === "function"
|
||||
? ctx.unrepresentable({ zodSchema: schema, path: params.path, message })
|
||||
: ctx.unrepresentable;
|
||||
if (result === "any")
|
||||
return false;
|
||||
if (result === undefined || result === "throw")
|
||||
throw new Error(message);
|
||||
Object.assign(json, result);
|
||||
return true;
|
||||
}
|
||||
// never rename this back to `process`: bundler polyfills inject a top-level `const process` that a lexical declaration of the same name collides with (#6397)
|
||||
export function processSchema(schema, ctx, _params = { path: [], schemaPath: [] }) {
|
||||
var _a;
|
||||
const def = schema._zod.def;
|
||||
// check for schema in seens
|
||||
const seen = ctx.seen.get(schema);
|
||||
if (seen) {
|
||||
seen.count++;
|
||||
// check if cycle
|
||||
const isCycle = _params.schemaPath.includes(schema);
|
||||
if (isCycle) {
|
||||
seen.cycle = _params.path;
|
||||
}
|
||||
return seen.schema;
|
||||
}
|
||||
// initialize
|
||||
const result = { schema: {}, count: 1, cycle: undefined, path: _params.path };
|
||||
ctx.seen.set(schema, result);
|
||||
ctx.sharedDefsExtractedFor = undefined;
|
||||
ctx.sharedEmitDoneFor = undefined;
|
||||
// custom method overrides default behavior
|
||||
const overrideSchema = schema._zod.toJSONSchema?.();
|
||||
if (overrideSchema) {
|
||||
result.schema = overrideSchema;
|
||||
}
|
||||
else {
|
||||
const params = {
|
||||
..._params,
|
||||
schemaPath: [..._params.schemaPath, schema],
|
||||
path: _params.path,
|
||||
};
|
||||
if (schema._zod.processJSONSchema) {
|
||||
schema._zod.processJSONSchema(ctx, result.schema, params);
|
||||
}
|
||||
else {
|
||||
const _json = result.schema;
|
||||
const processor = ctx.processors[def.type];
|
||||
if (!processor) {
|
||||
throw new Error(`[toJSONSchema]: Non-representable type encountered: ${def.type}`);
|
||||
}
|
||||
processor(schema, ctx, _json, params);
|
||||
}
|
||||
const parent = schema._zod.parent;
|
||||
if (parent) {
|
||||
// Also set ref if processor didn't (for inheritance)
|
||||
if (!result.ref)
|
||||
result.ref = parent;
|
||||
processSchema(parent, ctx, params);
|
||||
ctx.seen.get(parent).isParent = true;
|
||||
}
|
||||
}
|
||||
// metadata
|
||||
const meta = ctx.metadataRegistry.get(schema);
|
||||
if (meta)
|
||||
assignProps(result.schema, meta);
|
||||
if (ctx.io === "input" && isTransforming(schema)) {
|
||||
// examples/defaults only apply to output type of pipe
|
||||
delete result.schema.examples;
|
||||
delete result.schema.default;
|
||||
}
|
||||
// set prefault as default
|
||||
if (ctx.io === "input" && "_prefault" in result.schema)
|
||||
(_a = result.schema).default ?? (_a.default = result.schema._prefault);
|
||||
delete result.schema._prefault;
|
||||
// pulling fresh from ctx.seen in case it was overwritten
|
||||
const _result = ctx.seen.get(schema);
|
||||
return _result.schema;
|
||||
}
|
||||
/** @deprecated Renamed to `processSchema`. An export alias declares no binding, so it is safe to keep. */
|
||||
export { processSchema as process };
|
||||
// Escape a reference token for use in a JSON Pointer fragment (RFC 6901): `~` becomes `~0` and `/` becomes `~1`. The `~` replacement must run first.
|
||||
function encodeJSONPointerSegment(segment) {
|
||||
return segment.replace(/~/g, "~0").replace(/\//g, "~1");
|
||||
}
|
||||
export function extractDefs(ctx, schema
|
||||
// params: EmitParams
|
||||
) {
|
||||
// iterate over seen map;
|
||||
const root = ctx.seen.get(schema);
|
||||
if (!root)
|
||||
throw new Error("Unprocessed schema. This is a bug in Zod.");
|
||||
// With `external` set, every registered schema resolves through the external branch of `makeURI`, so the root branch below produces the same ref the external branch would — this pass is identical whichever schema it is called with, and only needs to run once.
|
||||
if (ctx.external && ctx.sharedDefsExtractedFor === ctx.external)
|
||||
return;
|
||||
// Track ids to detect duplicates across different schemas
|
||||
const idToSchema = new Map();
|
||||
for (const entry of ctx.seen.entries()) {
|
||||
const id = ctx.metadataRegistry.get(entry[0])?.id;
|
||||
if (id) {
|
||||
const existing = idToSchema.get(id);
|
||||
if (existing && existing !== entry[0]) {
|
||||
throw new Error(`Duplicate schema id "${id}" detected during JSON Schema conversion. Two different schemas cannot share the same id when converted together.`);
|
||||
}
|
||||
idToSchema.set(id, entry[0]);
|
||||
}
|
||||
}
|
||||
// returns a ref to the schema defId will be empty if the ref points to an external schema (or #)
|
||||
const makeURI = (entry) => {
|
||||
// comparing the seen objects because sometimes multiple schemas map to the same seen object. e.g. lazy
|
||||
// external is configured
|
||||
const defsSegment = ctx.target === "draft-2020-12" ? "$defs" : "definitions";
|
||||
if (ctx.external) {
|
||||
const externalId = ctx.external.registry.get(entry[0])?.id; // ?? "__shared";// `__schema${ctx.counter++}`;
|
||||
// check if schema is in the external registry
|
||||
const uriGenerator = ctx.external.uri ?? ((id) => id);
|
||||
if (externalId) {
|
||||
return { ref: uriGenerator(externalId) };
|
||||
}
|
||||
// otherwise, add to __shared
|
||||
const id = entry[1].defId ?? entry[1].schema.id ?? `schema${ctx.counter++}`;
|
||||
entry[1].defId = id; // set defId so it will be reused if needed
|
||||
return { defId: id, ref: `${uriGenerator("__shared")}#/${defsSegment}/${encodeJSONPointerSegment(id)}` };
|
||||
}
|
||||
const uriPrefix = `#`;
|
||||
const defUriPrefix = `${uriPrefix}/${defsSegment}/`;
|
||||
// an id-less root has nowhere to be extracted to, so it stays inline and self-references as `#`
|
||||
if (entry[1] === root && !entry[1].schema.id) {
|
||||
return { ref: uriPrefix };
|
||||
}
|
||||
// self-contained schema
|
||||
const defId = entry[1].schema.id ?? `__schema${ctx.counter++}`;
|
||||
return { defId, ref: defUriPrefix + encodeJSONPointerSegment(defId) };
|
||||
};
|
||||
// stored cached version in `def` property remove all properties, set $ref
|
||||
const extractToDef = (entry) => {
|
||||
// if the schema is already a reference, do not extract it
|
||||
if (entry[1].schema.$ref) {
|
||||
return;
|
||||
}
|
||||
const seen = entry[1];
|
||||
const { ref, defId } = makeURI(entry);
|
||||
seen.def = { ...seen.schema };
|
||||
// defId won't be set if the schema is a reference to an external schema or if the schema is the root schema
|
||||
if (defId)
|
||||
seen.defId = defId;
|
||||
// wipe away all properties except $ref
|
||||
const schema = seen.schema;
|
||||
for (const key in schema) {
|
||||
delete schema[key];
|
||||
}
|
||||
schema.$ref = ref;
|
||||
};
|
||||
// throw on cycles
|
||||
// break cycles
|
||||
if (ctx.cycles === "throw") {
|
||||
for (const entry of ctx.seen.entries()) {
|
||||
const seen = entry[1];
|
||||
if (seen.cycle) {
|
||||
throw new Error("Cycle detected: " +
|
||||
`#/${seen.cycle?.join("/")}/<root>` +
|
||||
'\n\nSet the `cycles` parameter to `"ref"` to resolve cyclical schemas with defs.');
|
||||
}
|
||||
}
|
||||
}
|
||||
// extract schemas into $defs
|
||||
for (const entry of ctx.seen.entries()) {
|
||||
const seen = entry[1];
|
||||
// convert root schema to # $ref
|
||||
if (schema === entry[0]) {
|
||||
extractToDef(entry); // this has special handling for the root schema
|
||||
continue;
|
||||
}
|
||||
// extract schemas that are in the external registry
|
||||
if (ctx.external) {
|
||||
const ext = ctx.external.registry.get(entry[0])?.id;
|
||||
if (schema !== entry[0] && ext) {
|
||||
extractToDef(entry);
|
||||
continue;
|
||||
}
|
||||
}
|
||||
// extract schemas with `id` meta
|
||||
const id = ctx.metadataRegistry.get(entry[0])?.id;
|
||||
if (id) {
|
||||
extractToDef(entry);
|
||||
continue;
|
||||
}
|
||||
// break cycles
|
||||
if (seen.cycle) {
|
||||
// any
|
||||
extractToDef(entry);
|
||||
continue;
|
||||
}
|
||||
// extract reused schemas
|
||||
if (seen.count > 1) {
|
||||
if (ctx.reused === "ref") {
|
||||
extractToDef(entry);
|
||||
}
|
||||
}
|
||||
}
|
||||
if (ctx.external)
|
||||
ctx.sharedDefsExtractedFor = ctx.external;
|
||||
}
|
||||
/** Rewrites `anyOf: [{type: "a"}, {type: "b"}]` to `type: ["a", "b"]`, which every JSON Schema draft treats as equivalent and most consumers render far better for the nullable case. Only branches that are a bare type assertion qualify — anything carrying a constraint, `$ref`, `const` or metadata is left alone. Runs after `flattenRef`, so a branch an override decorated or `$defs` extraction turned into a `$ref` is no longer bare and correctly stays in `anyOf`. `oneOf` is excluded: `integer` and `number` overlap, so "exactly one" and "at least one" are not the same there. OpenAPI 3.0 is excluded: its `type` must be a single string. */
|
||||
function compactTypeUnion(schema) {
|
||||
const options = schema.anyOf;
|
||||
if (!Array.isArray(options) || options.length === 0 || schema.type !== undefined)
|
||||
return;
|
||||
const types = [];
|
||||
for (const option of options) {
|
||||
if (!option || typeof option !== "object")
|
||||
return;
|
||||
// A branch that is itself a compactible union folds into this one — nested `anyOf` and a flat `type` array say the same thing. Compacting it first also makes the result independent of the order this pass walks the seen map in.
|
||||
compactTypeUnion(option);
|
||||
const keys = Object.keys(option);
|
||||
if (keys.length !== 1 || keys[0] !== "type")
|
||||
return;
|
||||
const type = option.type;
|
||||
for (const member of Array.isArray(type) ? type : [type]) {
|
||||
if (typeof member !== "string")
|
||||
return;
|
||||
if (!types.includes(member))
|
||||
types.push(member);
|
||||
}
|
||||
}
|
||||
delete schema.anyOf;
|
||||
// A `type` array must be non-empty and unique (metaschema); a single member is spelled as a bare string.
|
||||
schema.type = types.length === 1 ? types[0] : types;
|
||||
}
|
||||
/** Keywords `foldIntersection` knows how to combine. Anything else — `$ref`, `patternProperties`,
|
||||
* an annotation like `description` — makes a member unfoldable, so a constraint this does not
|
||||
* understand leaves the `allOf` alone instead of being silently dropped or misattributed. */
|
||||
const FOLDABLE_KEYS = new Set(["type", "properties", "required", "additionalProperties"]);
|
||||
const UNION_KEYS = ["oneOf", "anyOf"];
|
||||
/** A member's constraint on a key it does not declare itself. A `catchall` states one; `false`, an absent `additionalProperties`, and the empty schema a loose object emits state nothing. */
|
||||
function undeclaredConstraint(member) {
|
||||
const extra = member.additionalProperties;
|
||||
if (extra === undefined || extra === false || typeof extra !== "object" || extra === null)
|
||||
return null;
|
||||
return Object.keys(extra).length ? extra : null;
|
||||
}
|
||||
/** Combines object members into the single object they describe together, or returns `null` if any of them carries a keyword outside {@link FOLDABLE_KEYS}. */
|
||||
function foldObjects(members) {
|
||||
const objects = [];
|
||||
for (const member of members) {
|
||||
// A boolean subschema is legal JSON Schema and carries no keywords to fold.
|
||||
if (typeof member !== "object" || member.type !== "object")
|
||||
return null;
|
||||
for (const key in member) {
|
||||
if (!FOLDABLE_KEYS.has(key))
|
||||
return null;
|
||||
}
|
||||
objects.push(member);
|
||||
}
|
||||
const properties = {};
|
||||
const required = new Set();
|
||||
for (const object of objects) {
|
||||
for (const key in object.properties) {
|
||||
// `in` would report a `__proto__` key as already present via the prototype chain and skip it.
|
||||
if (Object.prototype.hasOwnProperty.call(properties, key))
|
||||
continue;
|
||||
// Every member constrains this key: the ones that declare it say how, and a `catchall` member constrains it too even though it does not name it. The key has to satisfy all of them, which is the same intersection one level down.
|
||||
const parts = [];
|
||||
for (const other of objects) {
|
||||
const part = other.properties?.[key] ?? undeclaredConstraint(other);
|
||||
if (part === null || part === undefined)
|
||||
continue;
|
||||
if (!parts.some((seen) => JSON.stringify(seen) === JSON.stringify(part)))
|
||||
parts.push(part);
|
||||
}
|
||||
const merged = parts.length === 1
|
||||
? parts[0]
|
||||
: (foldObjects(parts) ?? { allOf: parts });
|
||||
assignProp(properties, key, merged);
|
||||
}
|
||||
for (const key of object.required ?? [])
|
||||
required.add(key);
|
||||
}
|
||||
const folded = { type: "object", properties };
|
||||
if (required.size)
|
||||
folded.required = [...required];
|
||||
// A key no member declares is rejected only when every member rejects it, so the fold is closed only when every member is. Otherwise it carries whatever the `catchall` members demand of such a key.
|
||||
if (objects.every((object) => object.additionalProperties === false)) {
|
||||
folded.additionalProperties = false;
|
||||
}
|
||||
else {
|
||||
const constraints = [];
|
||||
for (const object of objects) {
|
||||
const constraint = undeclaredConstraint(object);
|
||||
if (constraint && !constraints.some((seen) => JSON.stringify(seen) === JSON.stringify(constraint)))
|
||||
constraints.push(constraint);
|
||||
}
|
||||
if (constraints.length === 1)
|
||||
folded.additionalProperties = constraints[0];
|
||||
else if (constraints.length > 1)
|
||||
folded.additionalProperties = { allOf: constraints };
|
||||
}
|
||||
return folded;
|
||||
}
|
||||
/** `additionalProperties` in an `allOf` member sees only that member's own `properties`, so two
|
||||
* closed object members reject each other's keys and the schema validates nothing. Zod's parser
|
||||
* pools the key sets instead — `handleIntersectionResults` reports a key as unrecognized only when
|
||||
* *every* side rejects it — so the emitted schema has to pool them too, and folding the members
|
||||
* into one object is the encoding that says so on every target.
|
||||
*
|
||||
* This runs from `finalize`, after `extractDefs`, which is what keeps it clear of the `$ref`
|
||||
* machinery: a member extracted into `$defs` is already a `$ref` by now and declines to fold, so it
|
||||
* keeps its reference and its own closedness rather than being inlined as a stale copy. */
|
||||
function foldIntersection(json) {
|
||||
const allOf = json.allOf;
|
||||
if (!Array.isArray(allOf) || allOf.length < 2)
|
||||
return;
|
||||
// An `override` runs before this pass and may have written object keywords onto the intersection itself. Those are deliberate, so decline rather than overwrite them.
|
||||
for (const key of FOLDABLE_KEYS)
|
||||
if (key in json)
|
||||
return;
|
||||
// An intersection distributes over a union: `A & (X | Y)` is `(A & X) | (A & Y)`. Only the first union is distributed over; a second one stays among the members every branch folds against, where it fails the object check and declines the whole intersection rather than multiplying out.
|
||||
const unions = allOf.filter((m) => UNION_KEYS.some((k) => Array.isArray(m[k])));
|
||||
let folded = null;
|
||||
if (!unions.length) {
|
||||
folded = foldObjects(allOf);
|
||||
}
|
||||
else {
|
||||
const union = unions[0];
|
||||
const keyword = UNION_KEYS.find((k) => Array.isArray(union[k]));
|
||||
if (Object.keys(union).length !== 1)
|
||||
return;
|
||||
const rest = allOf.filter((m) => m !== union);
|
||||
const branches = union[keyword].map((branch) => foldObjects([...rest, branch]));
|
||||
if (branches.some((b) => !b))
|
||||
return;
|
||||
folded = { [keyword]: branches };
|
||||
}
|
||||
if (!folded)
|
||||
return;
|
||||
delete json.allOf;
|
||||
assignProps(json, folded);
|
||||
}
|
||||
export function finalize(ctx, schema) {
|
||||
const root = ctx.seen.get(schema);
|
||||
if (!root)
|
||||
throw new Error("Unprocessed schema. This is a bug in Zod.");
|
||||
// flatten refs - inherit properties from parent schemas
|
||||
const flattenRef = (zodSchema) => {
|
||||
const seen = ctx.seen.get(zodSchema);
|
||||
// already processed
|
||||
if (seen.ref === null)
|
||||
return;
|
||||
const schema = seen.def ?? seen.schema;
|
||||
const _cached = { ...schema };
|
||||
const ref = seen.ref;
|
||||
seen.ref = null; // prevent infinite recursion
|
||||
if (ref) {
|
||||
flattenRef(ref);
|
||||
const refSeen = ctx.seen.get(ref);
|
||||
const refSchema = refSeen.schema;
|
||||
// merge referenced schema into current
|
||||
if (refSchema.$ref && (ctx.target === "draft-07" || ctx.target === "draft-04" || ctx.target === "openapi-3.0")) {
|
||||
// older drafts can't combine $ref with other properties
|
||||
schema.allOf = schema.allOf ?? [];
|
||||
schema.allOf.push(refSchema);
|
||||
}
|
||||
else {
|
||||
assignProps(schema, refSchema);
|
||||
}
|
||||
// restore child's own properties (child wins)
|
||||
assignProps(schema, _cached);
|
||||
const isParentRef = zodSchema._zod.parent === ref;
|
||||
// For parent chain, child is a refinement - remove parent-only properties
|
||||
if (isParentRef) {
|
||||
for (const key in schema) {
|
||||
if (key === "$ref" || key === "allOf")
|
||||
continue;
|
||||
if (!(key in _cached)) {
|
||||
delete schema[key];
|
||||
}
|
||||
}
|
||||
}
|
||||
// When ref was extracted to $defs, remove properties that match the definition
|
||||
if (refSchema.$ref && refSeen.def) {
|
||||
for (const key in schema) {
|
||||
if (key === "$ref" || key === "allOf")
|
||||
continue;
|
||||
if (key in refSeen.def && JSON.stringify(schema[key]) === JSON.stringify(refSeen.def[key])) {
|
||||
delete schema[key];
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
// If parent was extracted (has $ref), propagate $ref to this schema. This handles cases like: readonly().meta({id}).describe() where processor sets ref to innerType but parent should be referenced
|
||||
const parent = zodSchema._zod.parent;
|
||||
if (parent && parent !== ref) {
|
||||
// Ensure parent is processed first so its def has inherited properties
|
||||
flattenRef(parent);
|
||||
const parentSeen = ctx.seen.get(parent);
|
||||
if (parentSeen?.schema.$ref) {
|
||||
schema.$ref = parentSeen.schema.$ref;
|
||||
// De-duplicate with parent's definition
|
||||
if (parentSeen.def) {
|
||||
for (const key in schema) {
|
||||
if (key === "$ref" || key === "allOf")
|
||||
continue;
|
||||
if (key in parentSeen.def && JSON.stringify(schema[key]) === JSON.stringify(parentSeen.def[key])) {
|
||||
delete schema[key];
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
// execute overrides
|
||||
ctx.override({
|
||||
zodSchema: zodSchema,
|
||||
jsonSchema: schema,
|
||||
path: seen.path ?? [],
|
||||
});
|
||||
};
|
||||
// Flattening walks the whole map and clears each `ref` as it goes, so a second call over the same map is a no-op scan. Skip it outright once it has run for a registry conversion.
|
||||
if (!ctx.external || ctx.sharedEmitDoneFor !== ctx.external) {
|
||||
for (const entry of [...ctx.seen.entries()].reverse()) {
|
||||
flattenRef(entry[0]);
|
||||
}
|
||||
if (ctx.target !== "openapi-3.0") {
|
||||
for (const entry of ctx.seen.entries()) {
|
||||
compactTypeUnion(entry[1].def ?? entry[1].schema);
|
||||
}
|
||||
}
|
||||
for (const rewrite of ctx.deferred)
|
||||
rewrite();
|
||||
// After flattening, every member that was extracted is a `$ref`, so the fold sees the final shape. A schema that inherits an intersection — through `z.lazy`, or any `ref` chain — holds the same `allOf` array, so fold by array identity to catch every copy.
|
||||
if (ctx.intersections.length) {
|
||||
const carriers = new Map();
|
||||
for (const seen of ctx.seen.values()) {
|
||||
for (const json of [seen.schema, seen.def]) {
|
||||
const allOf = json?.allOf;
|
||||
if (!Array.isArray(allOf))
|
||||
continue;
|
||||
const existing = carriers.get(allOf);
|
||||
if (existing)
|
||||
existing.push(json);
|
||||
else
|
||||
carriers.set(allOf, [json]);
|
||||
}
|
||||
}
|
||||
for (const allOf of ctx.intersections) {
|
||||
for (const json of carriers.get(allOf) ?? [])
|
||||
foldIntersection(json);
|
||||
}
|
||||
}
|
||||
}
|
||||
const result = {};
|
||||
if (ctx.target === "draft-2020-12") {
|
||||
result.$schema = "https://json-schema.org/draft/2020-12/schema";
|
||||
}
|
||||
else if (ctx.target === "draft-07") {
|
||||
result.$schema = "http://json-schema.org/draft-07/schema#";
|
||||
}
|
||||
else if (ctx.target === "draft-04") {
|
||||
result.$schema = "http://json-schema.org/draft-04/schema#";
|
||||
}
|
||||
else if (ctx.target === "openapi-3.0") {
|
||||
// OpenAPI 3.0 schema objects should not include a $schema property
|
||||
}
|
||||
else {
|
||||
// Arbitrary string values are allowed but won't have a $schema property set
|
||||
}
|
||||
if (ctx.external?.uri) {
|
||||
const id = ctx.external.registry.get(schema)?.id;
|
||||
if (!id)
|
||||
throw new Error("Schema is missing an `id` property");
|
||||
result.$id = ctx.external.uri(id);
|
||||
}
|
||||
// when the root was extracted into $defs, `root.schema` is the `$ref` wrapper and `root.def` is the body that now lives under $defs
|
||||
assignProps(result, root.defId ? root.schema : (root.def ?? root.schema));
|
||||
// The `id` in `.meta()` is a Zod-specific registration tag used to extract schemas into $defs — it is not user-facing JSON Schema metadata. Strip it from the output body where it would otherwise leak. The id is preserved implicitly via the $defs key (and via $ref paths).
|
||||
const rootMetaId = ctx.metadataRegistry.get(schema)?.id;
|
||||
if (rootMetaId !== undefined && result.id === rootMetaId)
|
||||
delete result.id;
|
||||
// build defs object. With `external`, `defs` is the shared object every schema writes into, so the same entries are reassigned on every call. Without it, `defs` is fresh per call and must be rebuilt.
|
||||
const defs = ctx.external?.defs ?? {};
|
||||
if (!ctx.external || ctx.sharedEmitDoneFor !== ctx.external) {
|
||||
for (const entry of ctx.seen.entries()) {
|
||||
const seen = entry[1];
|
||||
if (seen.def && seen.defId) {
|
||||
if (seen.def.id === seen.defId)
|
||||
delete seen.def.id;
|
||||
assignProp(defs, seen.defId, seen.def);
|
||||
}
|
||||
}
|
||||
}
|
||||
if (ctx.external)
|
||||
ctx.sharedEmitDoneFor = ctx.external;
|
||||
// set definitions in result
|
||||
if (ctx.external) {
|
||||
}
|
||||
else {
|
||||
if (Object.keys(defs).length > 0) {
|
||||
if (ctx.target === "draft-2020-12") {
|
||||
result.$defs = defs;
|
||||
}
|
||||
else {
|
||||
result.definitions = defs;
|
||||
}
|
||||
}
|
||||
}
|
||||
try {
|
||||
// this "finalizes" this schema and ensures all cycles are removed each call to finalize() is functionally independent though the seen map is shared
|
||||
const finalized = JSON.parse(JSON.stringify(result));
|
||||
Object.defineProperty(finalized, "~standard", {
|
||||
value: {
|
||||
...schema["~standard"],
|
||||
jsonSchema: {
|
||||
input: createStandardJSONSchemaMethod(schema, "input", ctx.processors),
|
||||
output: createStandardJSONSchemaMethod(schema, "output", ctx.processors),
|
||||
},
|
||||
},
|
||||
enumerable: false,
|
||||
writable: false,
|
||||
});
|
||||
return finalized;
|
||||
}
|
||||
catch (_err) {
|
||||
throw new Error("Error converting schema to JSON.");
|
||||
}
|
||||
}
|
||||
function isTransforming(_schema, _ctx) {
|
||||
const ctx = _ctx ?? { seen: new Set() };
|
||||
if (ctx.seen.has(_schema))
|
||||
return false;
|
||||
ctx.seen.add(_schema);
|
||||
const def = _schema._zod.def;
|
||||
if (def.type === "transform")
|
||||
return true;
|
||||
if (def.type === "array")
|
||||
return isTransforming(def.element, ctx);
|
||||
if (def.type === "set")
|
||||
return isTransforming(def.valueType, ctx);
|
||||
if (def.type === "lazy")
|
||||
return isTransforming(def.getter(), ctx);
|
||||
if (def.type === "promise" ||
|
||||
def.type === "optional" ||
|
||||
def.type === "nonoptional" ||
|
||||
def.type === "nullable" ||
|
||||
def.type === "readonly" ||
|
||||
def.type === "default" ||
|
||||
def.type === "prefault" ||
|
||||
def.type === "catch") {
|
||||
return isTransforming(def.innerType, ctx);
|
||||
}
|
||||
if (def.type === "intersection") {
|
||||
return isTransforming(def.left, ctx) || isTransforming(def.right, ctx);
|
||||
}
|
||||
if (def.type === "record" || def.type === "map") {
|
||||
return isTransforming(def.keyType, ctx) || isTransforming(def.valueType, ctx);
|
||||
}
|
||||
if (def.type === "pipe") {
|
||||
if (_schema._zod.traits.has("$ZodCodec"))
|
||||
return true;
|
||||
return isTransforming(def.in, ctx) || isTransforming(def.out, ctx);
|
||||
}
|
||||
if (def.type === "object") {
|
||||
for (const key in def.shape) {
|
||||
if (isTransforming(def.shape[key], ctx))
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
if (def.type === "union") {
|
||||
for (const option of def.options) {
|
||||
if (isTransforming(option, ctx))
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
if (def.type === "tuple") {
|
||||
for (const item of def.items) {
|
||||
if (isTransforming(item, ctx))
|
||||
return true;
|
||||
}
|
||||
if (def.rest && isTransforming(def.rest, ctx))
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
/**
|
||||
* Creates a toJSONSchema method for a schema instance.
|
||||
* This encapsulates the logic of initializing context, processing, extracting defs, and finalizing.
|
||||
*/
|
||||
export const createToJSONSchemaMethod = (schema, processors = {}) => (params) => {
|
||||
const ctx = initializeContext({ ...params, processors });
|
||||
processSchema(schema, ctx);
|
||||
extractDefs(ctx, schema);
|
||||
return finalize(ctx, schema);
|
||||
};
|
||||
export const createStandardJSONSchemaMethod = (schema, io, processors = {}) => (params) => {
|
||||
const { libraryOptions, target } = params ?? {};
|
||||
const ctx = initializeContext({ ...(libraryOptions ?? {}), target, io, processors });
|
||||
processSchema(schema, ctx);
|
||||
extractDefs(ctx, schema);
|
||||
return finalize(ctx, schema);
|
||||
};
|
||||
+964
@@ -0,0 +1,964 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.CONSTANT_CATCH = exports.Class = exports.BIGINT_FORMAT_RANGES = exports.NUMBER_FORMAT_RANGES = exports.primitiveTypes = exports.propertyKeyTypes = exports.getParsedType = exports.allowsEval = exports.captureStackTrace = void 0;
|
||||
exports.assertEqual = assertEqual;
|
||||
exports.assertNotEqual = assertNotEqual;
|
||||
exports.toZod = toZod;
|
||||
exports.assertIs = assertIs;
|
||||
exports.assertNever = assertNever;
|
||||
exports.assert = assert;
|
||||
exports.getEnumValues = getEnumValues;
|
||||
exports.joinValues = joinValues;
|
||||
exports.jsonStringifyReplacer = jsonStringifyReplacer;
|
||||
exports.cached = cached;
|
||||
exports.nullish = nullish;
|
||||
exports.cleanRegex = cleanRegex;
|
||||
exports.floatSafeRemainder = floatSafeRemainder;
|
||||
exports.defineLazy = defineLazy;
|
||||
exports.objectClone = objectClone;
|
||||
exports.assignProp = assignProp;
|
||||
exports.rawShape = rawShape;
|
||||
exports.mergeDefs = mergeDefs;
|
||||
exports.cloneDef = cloneDef;
|
||||
exports.getElementAtPath = getElementAtPath;
|
||||
exports.promiseAllObject = promiseAllObject;
|
||||
exports.randomString = randomString;
|
||||
exports.esc = esc;
|
||||
exports.slugify = slugify;
|
||||
exports.isObject = isObject;
|
||||
exports.isPlainObject = isPlainObject;
|
||||
exports.shallowClone = shallowClone;
|
||||
exports.numKeys = numKeys;
|
||||
exports.escapeRegex = escapeRegex;
|
||||
exports.clone = clone;
|
||||
exports.normalizeParams = normalizeParams;
|
||||
exports.createTransparentProxy = createTransparentProxy;
|
||||
exports.stringifyPrimitive = stringifyPrimitive;
|
||||
exports.optionalKeys = optionalKeys;
|
||||
exports.pick = pick;
|
||||
exports.omit = omit;
|
||||
exports.extend = extend;
|
||||
exports.safeExtend = safeExtend;
|
||||
exports.merge = merge;
|
||||
exports.partial = partial;
|
||||
exports.required = required;
|
||||
exports.aborted = aborted;
|
||||
exports.explicitlyAborted = explicitlyAborted;
|
||||
exports.prefixIssues = prefixIssues;
|
||||
exports.unwrapMessage = unwrapMessage;
|
||||
exports.sizeCaps = sizeCaps;
|
||||
exports.attachSchema = attachSchema;
|
||||
exports.finalizeIssue = finalizeIssue;
|
||||
exports.getSizableOrigin = getSizableOrigin;
|
||||
exports.codePointLength = codePointLength;
|
||||
exports.getLengthableOrigin = getLengthableOrigin;
|
||||
exports.parsedType = parsedType;
|
||||
exports.issue = issue;
|
||||
exports.cleanEnum = cleanEnum;
|
||||
exports.base64ToUint8Array = base64ToUint8Array;
|
||||
exports.uint8ArrayToBase64 = uint8ArrayToBase64;
|
||||
exports.base64urlToUint8Array = base64urlToUint8Array;
|
||||
exports.uint8ArrayToBase64url = uint8ArrayToBase64url;
|
||||
exports.hexToUint8Array = hexToUint8Array;
|
||||
exports.uint8ArrayToHex = uint8ArrayToHex;
|
||||
exports.members = members;
|
||||
exports.own = own;
|
||||
exports.hide = hide;
|
||||
exports.derived = derived;
|
||||
exports.defineLazyInternal = defineLazyInternal;
|
||||
exports.installLazyProp = installLazyProp;
|
||||
exports.constantCatch = constantCatch;
|
||||
const core_js_1 = require("./core.cjs");
|
||||
// functions
|
||||
function assertEqual(val) {
|
||||
return val;
|
||||
}
|
||||
function assertNotEqual(val) {
|
||||
return val;
|
||||
}
|
||||
function toZod() {
|
||||
return (schema) => schema;
|
||||
}
|
||||
function assertIs(_arg) { }
|
||||
function assertNever(_x) {
|
||||
throw new Error("Unexpected value in exhaustive check");
|
||||
}
|
||||
function assert(_) { }
|
||||
function getEnumValues(entries) {
|
||||
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;
|
||||
}
|
||||
function joinValues(array, separator = "|") {
|
||||
return array.map((val) => stringifyPrimitive(val)).join(separator);
|
||||
}
|
||||
function jsonStringifyReplacer(_, value) {
|
||||
if (typeof value === "bigint")
|
||||
return value.toString();
|
||||
return value;
|
||||
}
|
||||
// the accessor lives on a shared prototype: an own accessor makes every box a dictionary-mode object (~360 B and a slow load per read against ~100 B and an inlined getter here)
|
||||
class Cached {
|
||||
constructor(getter) {
|
||||
this._getter = getter;
|
||||
this._value = undefined;
|
||||
}
|
||||
get value() {
|
||||
const getter = this._getter;
|
||||
if (getter !== undefined) {
|
||||
this._value = getter();
|
||||
this._getter = undefined;
|
||||
}
|
||||
return this._value;
|
||||
}
|
||||
}
|
||||
function cached(getter) {
|
||||
return new Cached(getter);
|
||||
}
|
||||
function nullish(input) {
|
||||
return input === null || input === undefined;
|
||||
}
|
||||
function cleanRegex(source) {
|
||||
const start = source.startsWith("^") ? 1 : 0;
|
||||
const end = source.endsWith("$") ? source.length - 1 : source.length;
|
||||
return source.slice(start, end);
|
||||
}
|
||||
function floatSafeRemainder(val, step) {
|
||||
const ratio = val / step;
|
||||
const roundedRatio = Math.round(ratio);
|
||||
// `val` and `step` each round to a double before the division rounds again, so a true decimal multiple's quotient can sit up to 1.5 of these scaled epsilons from the integer. A 1x tolerance therefore rejected 2.03 as a multiple of 0.07; 4x covers the worst case with margin.
|
||||
const tolerance = 4 * Number.EPSILON * Math.max(Math.abs(ratio), 1);
|
||||
if (Math.abs(ratio - roundedRatio) < tolerance)
|
||||
return 0;
|
||||
return ratio - roundedRatio;
|
||||
}
|
||||
const EVALUATING = /* @__PURE__*/ Symbol("evaluating");
|
||||
function defineLazy(object, key, getter) {
|
||||
let value = undefined;
|
||||
Object.defineProperty(object, key, {
|
||||
get() {
|
||||
if (value === EVALUATING) {
|
||||
// Circular reference detected, return undefined to break the cycle
|
||||
return undefined;
|
||||
}
|
||||
if (value === undefined) {
|
||||
value = EVALUATING;
|
||||
value = getter();
|
||||
}
|
||||
return value;
|
||||
},
|
||||
set(v) {
|
||||
Object.defineProperty(object, key, {
|
||||
value: v,
|
||||
// configurable: true,
|
||||
});
|
||||
// object[key] = v;
|
||||
},
|
||||
configurable: true,
|
||||
});
|
||||
}
|
||||
function objectClone(obj) {
|
||||
return Object.create(Object.getPrototypeOf(obj), Object.getOwnPropertyDescriptors(obj));
|
||||
}
|
||||
function assignProp(target, prop, value) {
|
||||
Object.defineProperty(target, prop, {
|
||||
value,
|
||||
writable: true,
|
||||
enumerable: true,
|
||||
configurable: true,
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Whichever object a def's `shape` currently answers from: the one the caller passed until the first read, the frozen copy after it.
|
||||
*
|
||||
* Its keys and descriptors read without invoking anything, which is what lets a discriminated union check its discriminator, and the cycle walk read a shape, without resolving a getter that references the schema being constructed. A def that answers `shape` from an accessor of its own has none.
|
||||
*/
|
||||
function rawShape(def) {
|
||||
const desc = Object.getOwnPropertyDescriptor(def, "shape");
|
||||
return desc?.get ? desc.get.raw : desc?.value;
|
||||
}
|
||||
// where a builder reads its source's keys and descriptors, resolving only a shape a def answers for itself. A shape resolves by object spread, so only its enumerable keys are ever part of it.
|
||||
function sourceShape(schema) {
|
||||
return rawShape(schema._zod.def) ?? schema._zod.def.shape;
|
||||
}
|
||||
// a key whose value is not settled yet, self-caching so every read after the first gets the same one
|
||||
function deferProp(target, key, getter) {
|
||||
Object.defineProperty(target, key, {
|
||||
get() {
|
||||
const value = getter();
|
||||
assignProp(this, key, value);
|
||||
return value;
|
||||
},
|
||||
enumerable: true,
|
||||
configurable: true,
|
||||
});
|
||||
}
|
||||
// Writes a settled key. A plain assignment is much cheaper than `defineProperty` and produces the same descriptor, but it runs whatever setter already answers to the key — an accessor this shape deferred, or an inherited one, which `__proto__` has on every object and prototype pollution can add for any name.
|
||||
function putProp(target, key, value) {
|
||||
if (key in target)
|
||||
assignProp(target, key, value);
|
||||
else
|
||||
target[key] = value;
|
||||
}
|
||||
/**
|
||||
* Copies `keys` of `source`'s shape onto `target`, each value passed through `wrap`.
|
||||
*
|
||||
* A key the source has resolved is copied through now, so the derived shape states it outright and nothing has to resolve it to learn what it holds. A key the source still defers stays deferred, and reads back through the source's own `shape`, so it resolves once and both shapes get that one schema.
|
||||
*/
|
||||
function mirrorShape(target, source, keys, wrap) {
|
||||
const raw = sourceShape(source);
|
||||
for (const key of keys) {
|
||||
const desc = Object.getOwnPropertyDescriptor(raw, key);
|
||||
if (!desc.enumerable)
|
||||
continue;
|
||||
if (desc.get) {
|
||||
deferProp(target, key, () => {
|
||||
const value = source._zod.def.shape[key];
|
||||
return wrap ? wrap(value, key) : value;
|
||||
});
|
||||
}
|
||||
else
|
||||
putProp(target, key, wrap ? wrap(desc.value, key) : desc.value);
|
||||
}
|
||||
}
|
||||
// same, for a plain shape a caller passed rather than a schema's
|
||||
function mirrorProps(target, source) {
|
||||
for (const key of Reflect.ownKeys(source)) {
|
||||
const desc = Object.getOwnPropertyDescriptor(source, key);
|
||||
if (!desc.enumerable)
|
||||
continue;
|
||||
if (desc.get)
|
||||
deferProp(target, key, () => source[key]);
|
||||
else
|
||||
putProp(target, key, desc.value);
|
||||
}
|
||||
}
|
||||
function mergeDefs(...defs) {
|
||||
const mergedDescriptors = {};
|
||||
for (const def of defs) {
|
||||
const descriptors = Object.getOwnPropertyDescriptors(def);
|
||||
Object.assign(mergedDescriptors, descriptors);
|
||||
}
|
||||
return Object.defineProperties({}, mergedDescriptors);
|
||||
}
|
||||
function cloneDef(schema) {
|
||||
return mergeDefs(schema._zod.def);
|
||||
}
|
||||
function getElementAtPath(obj, path) {
|
||||
if (!path)
|
||||
return obj;
|
||||
return path.reduce((acc, key) => acc?.[key], obj);
|
||||
}
|
||||
function promiseAllObject(promisesObj) {
|
||||
const keys = Object.keys(promisesObj);
|
||||
const promises = keys.map((key) => promisesObj[key]);
|
||||
return Promise.all(promises).then((results) => {
|
||||
const resolvedObj = {};
|
||||
for (let i = 0; i < keys.length; i++) {
|
||||
resolvedObj[keys[i]] = results[i];
|
||||
}
|
||||
return resolvedObj;
|
||||
});
|
||||
}
|
||||
function randomString(length = 10) {
|
||||
const chars = "abcdefghijklmnopqrstuvwxyz";
|
||||
let str = "";
|
||||
for (let i = 0; i < length; i++) {
|
||||
str += chars[Math.floor(Math.random() * chars.length)];
|
||||
}
|
||||
return str;
|
||||
}
|
||||
function esc(str) {
|
||||
return JSON.stringify(str);
|
||||
}
|
||||
function slugify(input) {
|
||||
return input
|
||||
.toLowerCase()
|
||||
.trim()
|
||||
.replace(/[^\w\s-]/g, "")
|
||||
.replace(/[\s_-]+/g, "-")
|
||||
.replace(/^-+|-+$/g, "");
|
||||
}
|
||||
exports.captureStackTrace = ("captureStackTrace" in Error ? Error.captureStackTrace : (..._args) => { });
|
||||
function isObject(data) {
|
||||
return typeof data === "object" && data !== null && !Array.isArray(data);
|
||||
}
|
||||
exports.allowsEval = cached(() => {
|
||||
// Skip the probe under `jitless`: strict CSPs report the caught `new Function` as a `securitypolicyviolation` even though the throw is swallowed.
|
||||
if (core_js_1.globalConfig.jitless) {
|
||||
return false;
|
||||
}
|
||||
// @ts-ignore
|
||||
if (typeof navigator !== "undefined" && navigator?.userAgent?.includes("Cloudflare")) {
|
||||
return false;
|
||||
}
|
||||
try {
|
||||
const F = Function;
|
||||
new F("");
|
||||
return true;
|
||||
}
|
||||
catch (_) {
|
||||
return false;
|
||||
}
|
||||
});
|
||||
function isPlainObject(o) {
|
||||
if (isObject(o) === false)
|
||||
return false;
|
||||
// modified constructor
|
||||
const ctor = o.constructor;
|
||||
if (ctor === undefined)
|
||||
return true;
|
||||
if (typeof ctor !== "function")
|
||||
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;
|
||||
}
|
||||
function shallowClone(o) {
|
||||
if (isPlainObject(o))
|
||||
return { ...o };
|
||||
if (Array.isArray(o))
|
||||
return [...o];
|
||||
if (o instanceof Map)
|
||||
return new Map(o);
|
||||
if (o instanceof Set)
|
||||
return new Set(o);
|
||||
return o;
|
||||
}
|
||||
function numKeys(data) {
|
||||
let keyCount = 0;
|
||||
for (const key in data) {
|
||||
if (Object.prototype.hasOwnProperty.call(data, key)) {
|
||||
keyCount++;
|
||||
}
|
||||
}
|
||||
return keyCount;
|
||||
}
|
||||
const getParsedType = (data) => {
|
||||
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";
|
||||
}
|
||||
// @ts-ignore
|
||||
if (typeof File !== "undefined" && data instanceof File) {
|
||||
return "file";
|
||||
}
|
||||
return "object";
|
||||
default:
|
||||
throw new Error(`Unknown data type: ${t}`);
|
||||
}
|
||||
};
|
||||
exports.getParsedType = getParsedType;
|
||||
exports.propertyKeyTypes = new Set(["string", "number", "symbol"]);
|
||||
exports.primitiveTypes = new Set([
|
||||
"string",
|
||||
"number",
|
||||
"bigint",
|
||||
"boolean",
|
||||
"symbol",
|
||||
"undefined",
|
||||
]);
|
||||
function escapeRegex(str) {
|
||||
return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
|
||||
}
|
||||
// zod-specific utils
|
||||
function clone(inst, def, params) {
|
||||
const cl = new inst._zod.constr(def ?? inst._zod.def);
|
||||
if (!def || params?.parent)
|
||||
cl._zod.parent = inst;
|
||||
return cl;
|
||||
}
|
||||
function normalizeParams(_params) {
|
||||
const params = _params;
|
||||
if (!params)
|
||||
return {};
|
||||
if (typeof params === "string")
|
||||
return { error: () => params };
|
||||
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 };
|
||||
return params;
|
||||
}
|
||||
function createTransparentProxy(getter) {
|
||||
let target;
|
||||
return new Proxy({}, {
|
||||
get(_, prop, receiver) {
|
||||
target ?? (target = getter());
|
||||
return Reflect.get(target, prop, receiver);
|
||||
},
|
||||
set(_, prop, value, receiver) {
|
||||
target ?? (target = getter());
|
||||
return Reflect.set(target, prop, value, receiver);
|
||||
},
|
||||
has(_, prop) {
|
||||
target ?? (target = getter());
|
||||
return Reflect.has(target, prop);
|
||||
},
|
||||
deleteProperty(_, prop) {
|
||||
target ?? (target = getter());
|
||||
return Reflect.deleteProperty(target, prop);
|
||||
},
|
||||
ownKeys(_) {
|
||||
target ?? (target = getter());
|
||||
return Reflect.ownKeys(target);
|
||||
},
|
||||
getOwnPropertyDescriptor(_, prop) {
|
||||
target ?? (target = getter());
|
||||
return Reflect.getOwnPropertyDescriptor(target, prop);
|
||||
},
|
||||
defineProperty(_, prop, descriptor) {
|
||||
target ?? (target = getter());
|
||||
return Reflect.defineProperty(target, prop, descriptor);
|
||||
},
|
||||
});
|
||||
}
|
||||
function stringifyPrimitive(value) {
|
||||
if (typeof value === "bigint")
|
||||
return value.toString() + "n";
|
||||
if (typeof value === "string")
|
||||
return `"${value}"`;
|
||||
return `${value}`;
|
||||
}
|
||||
function optionalKeys(shape) {
|
||||
return Object.keys(shape).filter((k) => {
|
||||
return shape[k]._zod.optin !== undefined && shape[k]._zod.optout === "optional";
|
||||
});
|
||||
}
|
||||
// Wrapped in a `@__PURE__` IIFE: esbuild never tree-shakes a top-level initializer that contains a member access on `Number`, so the bare object literal survived into every bundle.
|
||||
exports.NUMBER_FORMAT_RANGES = (() => ({
|
||||
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],
|
||||
}))();
|
||||
exports.BIGINT_FORMAT_RANGES = {
|
||||
int64: [/* @__PURE__*/ BigInt("-9223372036854775808"), /* @__PURE__*/ BigInt("9223372036854775807")],
|
||||
uint64: [/* @__PURE__*/ BigInt(0), /* @__PURE__*/ BigInt("18446744073709551615")],
|
||||
};
|
||||
function pick(schema, mask) {
|
||||
const currDef = schema._zod.def;
|
||||
const checks = currDef.checks;
|
||||
const hasChecks = checks && checks.length > 0;
|
||||
if (hasChecks) {
|
||||
throw new Error(".pick() cannot be used on object schemas containing refinements");
|
||||
}
|
||||
const newShape = {};
|
||||
mirrorShape(newShape, schema, maskedKeys(schema, mask));
|
||||
return clone(schema, mergeDefs(currDef, { shape: newShape, checks: [] }));
|
||||
}
|
||||
// the mask keys that select something, checked against the source's shape without resolving it
|
||||
function maskedKeys(schema, mask) {
|
||||
const raw = sourceShape(schema);
|
||||
const keys = [];
|
||||
// `for...in` skips symbols, so a symbol in the mask would select nothing
|
||||
for (const key of Reflect.ownKeys(mask)) {
|
||||
if (!Object.getOwnPropertyDescriptor(raw, key)?.enumerable) {
|
||||
throw new Error(`Unrecognized key: "${String(key)}"`);
|
||||
}
|
||||
if (mask[key])
|
||||
keys.push(key);
|
||||
}
|
||||
return keys;
|
||||
}
|
||||
function omit(schema, mask) {
|
||||
const currDef = schema._zod.def;
|
||||
const checks = currDef.checks;
|
||||
const hasChecks = checks && checks.length > 0;
|
||||
if (hasChecks) {
|
||||
throw new Error(".omit() cannot be used on object schemas containing refinements");
|
||||
}
|
||||
const omitted = new Set(maskedKeys(schema, mask));
|
||||
const newShape = {};
|
||||
mirrorShape(newShape, schema, Reflect.ownKeys(sourceShape(schema)).filter((key) => !omitted.has(key)));
|
||||
return clone(schema, mergeDefs(currDef, { shape: newShape, checks: [] }));
|
||||
}
|
||||
function extend(schema, shape) {
|
||||
if (!isPlainObject(shape)) {
|
||||
throw new Error("Invalid input to extend: expected a plain object");
|
||||
}
|
||||
const checks = schema._zod.def.checks;
|
||||
const hasChecks = checks && checks.length > 0;
|
||||
if (hasChecks) {
|
||||
// Only throw if new shape overlaps with existing shape. Use getOwnPropertyDescriptor to check key existence without accessing values
|
||||
const existingShape = sourceShape(schema);
|
||||
for (const key of Reflect.ownKeys(shape)) {
|
||||
if (Object.getOwnPropertyDescriptor(existingShape, key) !== undefined) {
|
||||
throw new Error("Cannot overwrite keys on object schemas containing refinements. Use `.safeExtend()` instead.");
|
||||
}
|
||||
}
|
||||
}
|
||||
return clone(schema, mergeDefs(schema._zod.def, { shape: extended(schema, shape) }));
|
||||
}
|
||||
// the source's keys, then the caller's overlaid on top
|
||||
function extended(schema, shape) {
|
||||
const newShape = {};
|
||||
mirrorShape(newShape, schema, Reflect.ownKeys(sourceShape(schema)));
|
||||
mirrorProps(newShape, shape);
|
||||
return newShape;
|
||||
}
|
||||
function safeExtend(schema, shape) {
|
||||
if (!isPlainObject(shape)) {
|
||||
throw new Error("Invalid input to safeExtend: expected a plain object");
|
||||
}
|
||||
return clone(schema, mergeDefs(schema._zod.def, { shape: extended(schema, shape) }));
|
||||
}
|
||||
function merge(a, b) {
|
||||
if (!b?._zod?.def) {
|
||||
throw new Error("Invalid input to merge: expected an object schema. To merge a plain shape, use `.extend()`.");
|
||||
}
|
||||
if (a._zod.def.checks?.length) {
|
||||
throw new Error(".merge() cannot be used on object schemas containing refinements. Use .safeExtend() instead.");
|
||||
}
|
||||
const newShape = {};
|
||||
mirrorShape(newShape, a, Reflect.ownKeys(sourceShape(a)));
|
||||
mirrorShape(newShape, b, Reflect.ownKeys(sourceShape(b)));
|
||||
const def = mergeDefs(a._zod.def, {
|
||||
shape: newShape,
|
||||
get catchall() {
|
||||
return b._zod.def.catchall;
|
||||
},
|
||||
checks: b._zod.def.checks ?? [],
|
||||
});
|
||||
return clone(a, def);
|
||||
}
|
||||
function partial(Class, schema, mask, name = "partial") {
|
||||
const currDef = schema._zod.def;
|
||||
const checks = currDef.checks;
|
||||
const hasChecks = checks && checks.length > 0;
|
||||
if (hasChecks) {
|
||||
throw new Error(`.${name}() cannot be used on object schemas containing refinements`);
|
||||
}
|
||||
const selected = mask ? new Set(maskedKeys(schema, mask)) : undefined;
|
||||
const newShape = {};
|
||||
mirrorShape(newShape, schema, Reflect.ownKeys(sourceShape(schema)), Class &&
|
||||
((value, key) => (selected && !selected.has(key) ? value : new Class({ type: "optional", innerType: value }))));
|
||||
return clone(schema, mergeDefs(schema._zod.def, { shape: newShape, checks: [] }));
|
||||
}
|
||||
function required(Class, schema, mask) {
|
||||
const selected = mask ? new Set(maskedKeys(schema, mask)) : undefined;
|
||||
const newShape = {};
|
||||
mirrorShape(newShape, schema, Reflect.ownKeys(sourceShape(schema)), (value, key) =>
|
||||
// overwrite with non-optional
|
||||
selected && !selected.has(key) ? value : new Class({ type: "nonoptional", innerType: value }));
|
||||
return clone(schema, mergeDefs(schema._zod.def, { shape: newShape }));
|
||||
}
|
||||
// invalid_type | too_big | too_small | invalid_format | not_multiple_of | unrecognized_keys | invalid_union | invalid_key | invalid_element | invalid_value | custom
|
||||
function aborted(x, startIndex = 0) {
|
||||
if (x.aborted === true)
|
||||
return true;
|
||||
for (let i = startIndex; i < x.issues.length; i++) {
|
||||
if (x.issues[i]?.continue !== true) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
// Checks for explicit abort (continue === false), as opposed to implicit abort (continue === undefined). Used to respect `abort: true` in .refine() even for checks that have a `when` function.
|
||||
function explicitlyAborted(x, startIndex = 0) {
|
||||
if (x.aborted === true)
|
||||
return true;
|
||||
for (let i = startIndex; i < x.issues.length; i++) {
|
||||
if (x.issues[i]?.continue === false) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
function prefixIssues(path, issues) {
|
||||
return issues.map((iss) => {
|
||||
var _a;
|
||||
(_a = iss).path ?? (_a.path = []);
|
||||
iss.path.unshift(path);
|
||||
return iss;
|
||||
});
|
||||
}
|
||||
function unwrapMessage(message) {
|
||||
return typeof message === "string" ? message : message?.message;
|
||||
}
|
||||
/* A check holds no link back to the schema it is attached to — the same check instance is shared by every clone of that schema — so the owner is stamped onto the issues a check just raised, at the only point where both are in scope. Runs on the failure path only; `start` is the issue count from before the check ran. */
|
||||
/** The leading size checks of `defChecks` that set an upper bound, each paired with it. */
|
||||
function sizeCaps(defChecks) {
|
||||
const caps = [];
|
||||
for (const ch of defChecks ?? []) {
|
||||
const d = ch._zod.def;
|
||||
// a later check may rewrite the value
|
||||
if (!/_(length|size)$|_equals$/.test(d.check))
|
||||
break;
|
||||
const max = d.maximum ?? d.length ?? d.size;
|
||||
if (max >= 0)
|
||||
caps.push([max, ch]);
|
||||
}
|
||||
return caps;
|
||||
}
|
||||
function attachSchema(issues, start, inst) {
|
||||
var _a;
|
||||
for (let i = start; i < issues.length; i++) {
|
||||
(_a = issues[i]).schema ?? (_a.schema = inst);
|
||||
}
|
||||
}
|
||||
function finalizeIssue(iss, ctx, config) {
|
||||
var _a;
|
||||
// A schema that raised an issue itself owns it outright, and outranks any stamp an enclosing check left in `attachSchema`. String formats and z.custom() are schema and check at once, so when they act as a check they defer to that stamp instead.
|
||||
const traits = iss.inst?._zod?.traits;
|
||||
if (traits?.has("$ZodType")) {
|
||||
if (traits.has("$ZodCheck"))
|
||||
(_a = iss).schema ?? (_a.schema = iss.inst);
|
||||
else
|
||||
iss.schema = iss.inst;
|
||||
}
|
||||
// Decreasing specificity, first map to return a message wins. `inst` is whatever raised the issue, so a check's own map outranks the owning schema's.
|
||||
const schemaError = iss.schema !== iss.inst ? iss.schema?._zod.def?.error : undefined;
|
||||
const message = iss.message
|
||||
? iss.message
|
||||
: (unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ??
|
||||
unwrapMessage(schemaError?.(iss)) ??
|
||||
unwrapMessage(ctx?.error?.(iss)) ??
|
||||
unwrapMessage(config.customError?.(iss)) ??
|
||||
unwrapMessage(config.localeError?.(iss)) ??
|
||||
"Invalid input");
|
||||
// an explicit own-key copy beats object rest with excluded keys, which v8 routes through a generic runtime call; Object.keys rather than for-in so an issue pushed with a prototype does not leak inherited keys, and an own __proto__ key is dropped rather than assigned through the setter
|
||||
const full = {};
|
||||
for (const k of Object.keys(iss)) {
|
||||
if (k === "inst" || k === "schema" || k === "continue" || k === "input" || k === "__proto__")
|
||||
continue;
|
||||
full[k] = iss[k];
|
||||
}
|
||||
full.path ?? (full.path = []);
|
||||
full.message = message;
|
||||
if (ctx?.reportInput) {
|
||||
full.input = iss.input;
|
||||
}
|
||||
return full;
|
||||
}
|
||||
function getSizableOrigin(input) {
|
||||
if (input instanceof Set)
|
||||
return "set";
|
||||
if (input instanceof Map)
|
||||
return "map";
|
||||
// @ts-ignore
|
||||
if (input instanceof File)
|
||||
return "file";
|
||||
return "unknown";
|
||||
}
|
||||
const highSurrogate = /[\uD800-\uDBFF]/;
|
||||
// Code points in `str`: a surrogate pair counts once, a lone surrogate as itself. Hand-rolled because the string iterator allocates and runs ~250x slower on this path; the regex probe exits ~50x quicker for a string with no astral characters.
|
||||
function codePointLength(str) {
|
||||
const units = str.length;
|
||||
if (!highSurrogate.test(str))
|
||||
return units;
|
||||
let count = units;
|
||||
for (let i = 0; i < units - 1; i++) {
|
||||
if ((str.charCodeAt(i) & 0xfc00) === 0xd800 && (str.charCodeAt(i + 1) & 0xfc00) === 0xdc00) {
|
||||
count--;
|
||||
i++;
|
||||
}
|
||||
}
|
||||
return count;
|
||||
}
|
||||
function getLengthableOrigin(input) {
|
||||
if (Array.isArray(input))
|
||||
return "array";
|
||||
if (typeof input === "string")
|
||||
return "string";
|
||||
return "unknown";
|
||||
}
|
||||
function parsedType(data) {
|
||||
const t = typeof data;
|
||||
switch (t) {
|
||||
case "number": {
|
||||
return Number.isNaN(data) ? "nan" : "number";
|
||||
}
|
||||
case "object": {
|
||||
if (data === null) {
|
||||
return "null";
|
||||
}
|
||||
if (Array.isArray(data)) {
|
||||
return "array";
|
||||
}
|
||||
const obj = data;
|
||||
if (obj && Object.getPrototypeOf(obj) !== Object.prototype && "constructor" in obj && obj.constructor) {
|
||||
return obj.constructor.name;
|
||||
}
|
||||
}
|
||||
}
|
||||
return t;
|
||||
}
|
||||
function issue(...args) {
|
||||
const [iss, input, inst] = args;
|
||||
if (typeof iss === "string") {
|
||||
return {
|
||||
message: iss,
|
||||
code: "custom",
|
||||
input,
|
||||
inst,
|
||||
};
|
||||
}
|
||||
return { ...iss };
|
||||
}
|
||||
function cleanEnum(obj) {
|
||||
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]);
|
||||
}
|
||||
// Codec utility functions
|
||||
function base64ToUint8Array(base64) {
|
||||
const binaryString = atob(base64);
|
||||
const bytes = new Uint8Array(binaryString.length);
|
||||
for (let i = 0; i < binaryString.length; i++) {
|
||||
bytes[i] = binaryString.charCodeAt(i);
|
||||
}
|
||||
return bytes;
|
||||
}
|
||||
function uint8ArrayToBase64(bytes) {
|
||||
let binaryString = "";
|
||||
for (let i = 0; i < bytes.length; i++) {
|
||||
binaryString += String.fromCharCode(bytes[i]);
|
||||
}
|
||||
return btoa(binaryString);
|
||||
}
|
||||
function base64urlToUint8Array(base64url) {
|
||||
const base64 = base64url.replace(/-/g, "+").replace(/_/g, "/");
|
||||
const padding = "=".repeat((4 - (base64.length % 4)) % 4);
|
||||
return base64ToUint8Array(base64 + padding);
|
||||
}
|
||||
function uint8ArrayToBase64url(bytes) {
|
||||
return uint8ArrayToBase64(bytes).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
|
||||
}
|
||||
function hexToUint8Array(hex) {
|
||||
const cleanHex = hex.replace(/^0x/, "");
|
||||
if (cleanHex.length % 2 !== 0) {
|
||||
throw new Error("Invalid hex string length");
|
||||
}
|
||||
const bytes = new Uint8Array(cleanHex.length / 2);
|
||||
for (let i = 0; i < cleanHex.length; i += 2) {
|
||||
bytes[i / 2] = Number.parseInt(cleanHex.slice(i, i + 2), 16);
|
||||
}
|
||||
return bytes;
|
||||
}
|
||||
function uint8ArrayToHex(bytes) {
|
||||
return Array.from(bytes)
|
||||
.map((b) => b.toString(16).padStart(2, "0"))
|
||||
.join("");
|
||||
}
|
||||
// instanceof
|
||||
class Class {
|
||||
constructor(..._args) { }
|
||||
}
|
||||
exports.Class = Class;
|
||||
////////// PROTOTYPE INSTALLERS //////////
|
||||
//
|
||||
// Members live on the prototype and materialize per instance on first read, which keeps own-property count under the step where V8 stops using inline slots. Changing anything here means re-measuring runtime, memory and bundle size together — see "The three axes" in AGENTS.md.
|
||||
/**
|
||||
* Installs a trait's members on its prototype. Each value builds that member for the instance on first read; the built value shadows the accessor as an own property, so a detached `const { parse } = schema` keeps working.
|
||||
*
|
||||
* Call this from a `proto` initializer, which runs once per prototype — never per instance.
|
||||
*/
|
||||
function members(proto, table) {
|
||||
for (const key in table) {
|
||||
const desc = Object.getOwnPropertyDescriptor(table, key);
|
||||
// a getter installs as written, so it stays live: `description` reads through to the registry on every access. not enumerable: an object literal's is, and a prototype member never was
|
||||
if (desc.get)
|
||||
Object.defineProperty(proto, key, { ...desc, enumerable: false });
|
||||
// a method materializes bound on first read, which is what keeps a detached member working: `const opt = schema.optional; opt()`
|
||||
else
|
||||
defineBound(proto, key, desc.value);
|
||||
}
|
||||
}
|
||||
/** Shadows a prototype member with an own value, so a getter that builds from the instance runs once. */
|
||||
function own(inst, key, value, enumerable = true) {
|
||||
Object.defineProperty(inst, key, { configurable: true, writable: true, enumerable, value });
|
||||
return value;
|
||||
}
|
||||
/** Like {@link own}, for a member that was never an own data property and has to stay out of `Object.keys`. */
|
||||
function hide(inst, key, value) {
|
||||
return own(inst, key, value, false);
|
||||
}
|
||||
/** Adds members a table derives from the instance: each builds on first read and shadows as own data, and assignment shadows the same way, as when these were own properties. */
|
||||
function derived(computes, table) {
|
||||
for (const key in computes) {
|
||||
const compute = computes[key];
|
||||
// an object literal's accessor is configurable and enumerable, and `members` copies the descriptor as written
|
||||
Object.defineProperty(table, key, {
|
||||
configurable: true,
|
||||
enumerable: true,
|
||||
get() {
|
||||
return own(this, key, compute(this));
|
||||
},
|
||||
set(value) {
|
||||
own(this, key, value);
|
||||
},
|
||||
});
|
||||
}
|
||||
return table;
|
||||
}
|
||||
function defineBound(proto, key, fn) {
|
||||
Object.defineProperty(proto, key, {
|
||||
configurable: true,
|
||||
get() {
|
||||
// vitest's spyOn calls a prototype getter bare to find the function it wraps, so a nullish receiver answers the raw method
|
||||
return this == null ? fn : own(this, key, fn.bind(this));
|
||||
},
|
||||
set(value) {
|
||||
own(this, key, value);
|
||||
},
|
||||
});
|
||||
}
|
||||
/** Returns the prototype to install on, or `undefined` if this group is already installed on it. */
|
||||
function claim(inst, sentinel) {
|
||||
const proto = Object.getPrototypeOf(inst);
|
||||
// Runs on every construction, so `in` rather than the costlier `hasOwnProperty.call`. Sentinels are keys the group itself defines.
|
||||
return sentinel in proto ? undefined : proto;
|
||||
}
|
||||
// The internals whose init chain is installing. A second call for the same one is a derived constructor overriding its base, so it must not construct another schema in between or the override is dropped.
|
||||
let installing;
|
||||
// Set while a getter is running, so a value that resolved through a recursion break is not memoized. One shared descriptor shadows the key for the duration, which costs no per-key allocation.
|
||||
let broke = false;
|
||||
const breaker = {
|
||||
configurable: true,
|
||||
get() {
|
||||
broke = true;
|
||||
return undefined;
|
||||
},
|
||||
};
|
||||
/**
|
||||
* Installs a lazily-derived internal on the `_zod` prototype of `inst`'s
|
||||
* constructor, computed from the internals object itself and cached there on
|
||||
* first read. One accessor per constructor rather than one per instance.
|
||||
*/
|
||||
function defineLazyInternal(inst, key, compute) {
|
||||
const proto = Object.getPrototypeOf(inst._zod);
|
||||
if (key in proto && installing !== inst._zod) {
|
||||
// A repeat construction: everything is installed already. Cleared here so the reference is not held past the first construction of every type.
|
||||
installing = undefined;
|
||||
return;
|
||||
}
|
||||
installing = inst._zod;
|
||||
Object.defineProperty(proto, key, {
|
||||
configurable: true,
|
||||
get() {
|
||||
// Shadowed before computing so a re-entrant read from a recursive schema resolves to undefined instead of running the getter again.
|
||||
Object.defineProperty(this, key, breaker);
|
||||
const outer = broke;
|
||||
broke = false;
|
||||
try {
|
||||
const value = compute(this);
|
||||
// A result that resolved through a recursion break is recomputed once the graph is complete; everything else memoizes, undefined included.
|
||||
if (broke)
|
||||
delete this[key];
|
||||
else
|
||||
Object.defineProperty(this, key, { configurable: true, writable: true, value });
|
||||
broke = broke || outer;
|
||||
return value;
|
||||
}
|
||||
catch (err) {
|
||||
// A compute that threw memoizes nothing, so a later read runs it again and fails the same way. The shadow goes with it, since leaving it installed would answer undefined for every later read.
|
||||
delete this[key];
|
||||
broke = broke || outer;
|
||||
throw err;
|
||||
}
|
||||
},
|
||||
set(value) {
|
||||
Object.defineProperty(this, key, { configurable: true, writable: true, value });
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Installs `key` on `inst`'s prototype, computed by `make` on first read and cached there as an own
|
||||
* data property. One accessor per constructor rather than one per instance, because an own accessor
|
||||
* puts every instance after the first into v8 dictionary mode. The key doubles as the sentinel.
|
||||
*/
|
||||
function installLazyProp(inst, key, make, enumerable) {
|
||||
const proto = claim(inst, key);
|
||||
if (!proto)
|
||||
return;
|
||||
Object.defineProperty(proto, key, {
|
||||
configurable: true,
|
||||
get() {
|
||||
// Shadowed before computing, so a re-entrant read from a self-referential shape resolves to undefined instead of running the getter again. A data property rather than an accessor: an own accessor is the dictionary-mode transition this exists to avoid.
|
||||
const desc = { configurable: true, writable: true, enumerable, value: undefined };
|
||||
Object.defineProperty(this, key, desc);
|
||||
// a compute that throws leaves the shadow behind, so later reads answer undefined instead of re-throwing; `defineLazy` did the same, and `defineLazyInternal`'s delete-on-catch would cost bytes in every bundle for a case only a throwing user getter reaches
|
||||
desc.value = make(this);
|
||||
Object.defineProperty(this, key, desc);
|
||||
return desc.value;
|
||||
},
|
||||
set(value) {
|
||||
Object.defineProperty(this, key, { configurable: true, writable: true, enumerable, value });
|
||||
},
|
||||
});
|
||||
}
|
||||
/** Marks the thunk `_catch` synthesises for a constant catch value. `Function.length` cannot tell that thunk from a user callback — rest and defaulted parameters both report arity 0 — and a user callback reads `ctx.error`, whose issues only finalize correctly against the caller's per-parse error map. Provenance can say what arity cannot. A plain string key rather than `Symbol.for`, whose call at module scope no bundler can prove pure — the same shape that anchored `urlCanParse` into every build. */
|
||||
exports.CONSTANT_CATCH = "~constantCatch";
|
||||
/** Wraps a constant catch value in a thunk tagged with {@link CONSTANT_CATCH}. */
|
||||
function constantCatch(value) {
|
||||
const fn = () => value;
|
||||
fn[exports.CONSTANT_CATCH] = true;
|
||||
return fn;
|
||||
}
|
||||
|
||||
// seal-cjs-exports
|
||||
(function () {
|
||||
var keys = Object.getOwnPropertyNames(exports);
|
||||
for (var i = 0; i < keys.length; i++) {
|
||||
var desc = Object.getOwnPropertyDescriptor(exports, keys[i]);
|
||||
if (!desc || !desc.get || !desc.configurable) continue;
|
||||
var value;
|
||||
try {
|
||||
value = desc.get();
|
||||
} catch (e) {
|
||||
continue;
|
||||
}
|
||||
// a circular require may not have settled this one yet, so leave it live
|
||||
if (value === undefined) continue;
|
||||
Object.defineProperty(exports, keys[i], { value: value, writable: false, enumerable: desc.enumerable, configurable: false });
|
||||
}
|
||||
Object.freeze(exports);
|
||||
})();
|
||||
+280
@@ -0,0 +1,280 @@
|
||||
import type * as checks from "./checks.cjs";
|
||||
import type { $ZodConfig } from "./core.cjs";
|
||||
import type * as errors from "./errors.cjs";
|
||||
import type * as schemas from "./schemas.cjs";
|
||||
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 HashAlgorithm = "md5" | "sha1" | "sha256" | "sha384" | "sha512";
|
||||
export type HashEncoding = "hex" | "base64" | "base64url";
|
||||
export type HashFormat = `${HashAlgorithm}_${HashEncoding}`;
|
||||
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";
|
||||
export type AssertEqual<T, U> = (<V>() => V extends T ? 1 : 2) extends <V>() => V extends U ? 1 : 2 ? true : false;
|
||||
export type AssertNotEqual<T, U> = (<V>() => V extends T ? 1 : 2) extends <V>() => V extends U ? 1 : 2 ? false : true;
|
||||
export type AssertExtends<T, U> = T extends U ? T : never;
|
||||
type ToZodMismatch<T, S extends schemas.$ZodType> = {
|
||||
"types do not match": {
|
||||
expected: T;
|
||||
received: S["_zod"]["output"];
|
||||
};
|
||||
};
|
||||
type ToZodKeyMismatch<Expected, Received> = schemas.$ZodType & {
|
||||
"types do not match": {
|
||||
expected: Expected;
|
||||
received: Received;
|
||||
};
|
||||
};
|
||||
declare const toZodDummy: unique symbol;
|
||||
type ToZodNormalize<T> = [T] extends [(...args: any[]) => any] ? T : [T] extends [object] ? {
|
||||
[K in keyof T]: ToZodNormalize<T[K]>;
|
||||
} : T | typeof toZodDummy;
|
||||
type ToZodEqual<Output, T> = AssertEqual<Output, T> extends true ? true : IsAny<Output> extends true ? false : IsAny<T> extends true ? false : AssertEqual<ToZodNormalize<Output>, ToZodNormalize<T>>;
|
||||
type ToZodShape<Shape, T> = {
|
||||
[K in keyof Shape]: Shape[K] extends schemas.$ZodType ? K extends keyof T ? ToZodEqual<Shape[K]["_zod"]["output"], T[K]> extends true ? Shape[K] : ToZodKeyMismatch<T[K], Shape[K]["_zod"]["output"]> : ToZodKeyMismatch<never, Shape[K]["_zod"]["output"]> : Shape[K];
|
||||
} & {
|
||||
[K in Exclude<keyof T, keyof Shape>]: ToZodKeyMismatch<T[K], never>;
|
||||
};
|
||||
type ToZodExpand<X> = {
|
||||
[K in keyof X]: X[K];
|
||||
} & {};
|
||||
type ToZodTarget<S extends schemas.$ZodType, T> = S extends schemas.$ZodObject<infer Shape, infer Config> ? T extends object ? AssertEqual<ToZodExpand<ToZodShape<Shape, T>>, ToZodExpand<Shape>> extends true ? S & ToZodMismatch<T, S> : schemas.$ZodObject<ToZodExpand<ToZodShape<Shape, T>>, Config> : S & ToZodMismatch<T, S> : S & ToZodMismatch<T, S>;
|
||||
export type IsAny<T> = 0 extends 1 & T ? true : false;
|
||||
export type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
|
||||
export type OmitKeys<T, K extends string> = Pick<T, Exclude<keyof T, K>>;
|
||||
export type MakePartial<T, K extends keyof T> = Omit<T, K> & InexactPartial<Pick<T, K>>;
|
||||
export type MakeRequired<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>;
|
||||
export type Exactly<T, X> = T & Record<Exclude<keyof X, keyof T>, never>;
|
||||
export type NoUndefined<T> = T extends undefined ? never : T;
|
||||
export type Whatever = {} | undefined | null;
|
||||
export type Widen<T> = T extends string ? string : T extends number ? number : T extends boolean ? boolean : T extends bigint ? bigint : T;
|
||||
export type LoosePartial<T extends object> = InexactPartial<T> & {
|
||||
[k: string]: unknown;
|
||||
};
|
||||
export type Mask<Keys extends PropertyKey> = {
|
||||
[K in Keys]?: true;
|
||||
};
|
||||
export type Writeable<T> = {
|
||||
-readonly [P in keyof T]: T[P];
|
||||
} & {};
|
||||
export type InexactPartial<T> = {
|
||||
[P in keyof T]?: T[P] | undefined;
|
||||
};
|
||||
export type EmptyObject = Record<string, never>;
|
||||
export type BuiltIn = (((...args: any[]) => any) | (new (...args: any[]) => any)) | {
|
||||
readonly [Symbol.toStringTag]: string;
|
||||
} | Date | Error | Generator | Promise<unknown> | RegExp;
|
||||
export type MakeReadonly<T> = T extends Map<infer K, infer V> ? ReadonlyMap<K, V> : T extends Set<infer V> ? ReadonlySet<V> : T extends [infer Head, ...infer Tail] ? readonly [Head, ...Tail] : T extends Array<infer V> ? ReadonlyArray<V> : T extends BuiltIn ? T : Readonly<T>;
|
||||
export type SomeObject = Record<PropertyKey, any>;
|
||||
export type Identity<T> = T;
|
||||
export type Flatten<T> = Identity<{
|
||||
[k in keyof T]: T[k];
|
||||
}>;
|
||||
export type Mapped<T> = {
|
||||
[k in keyof T]: T[k];
|
||||
};
|
||||
export type Prettify<T> = {
|
||||
[K in keyof T]: T[K];
|
||||
} & {};
|
||||
export type NoNeverKeys<T> = {
|
||||
[k in keyof T]: [T[k]] extends [never] ? never : k;
|
||||
}[keyof T];
|
||||
export type NoNever<T> = Identity<{
|
||||
[k in NoNeverKeys<T>]: k extends keyof T ? T[k] : never;
|
||||
}>;
|
||||
export type Extend<A extends SomeObject, B extends SomeObject> = Flatten<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<schemas.SomeType>;
|
||||
export type AnyFunc = (...args: any[]) => any;
|
||||
export type IsProp<T, K extends keyof T> = T[K] extends AnyFunc ? never : K;
|
||||
export type MaybeAsync<T> = T | Promise<T>;
|
||||
export type KeyOf<T> = keyof OmitIndexSignature<T>;
|
||||
export type OmitIndexSignature<T> = {
|
||||
[K in keyof T as string extends K ? never : K extends string ? K : never]: T[K];
|
||||
};
|
||||
export type ExtractIndexSignature<T> = {
|
||||
[K in keyof T as string extends K ? K : K extends string ? never : K]: T[K];
|
||||
};
|
||||
export type Keys<T extends object> = keyof OmitIndexSignature<T>;
|
||||
export type SchemaClass<T extends schemas.SomeType> = {
|
||||
new (def: T["_zod"]["def"]): T;
|
||||
};
|
||||
export type EnumValue = string | number;
|
||||
export type EnumLike = Readonly<Record<string, EnumValue>>;
|
||||
export type ToEnum<T extends EnumValue> = Flatten<{
|
||||
[k in T]: k;
|
||||
}>;
|
||||
export type KeysEnum<T extends object> = ToEnum<Exclude<keyof T, symbol>>;
|
||||
export type KeysArray<T extends object> = Flatten<(keyof T & string)[]>;
|
||||
export type Literal = string | number | bigint | boolean | null | undefined;
|
||||
export type LiteralArray = Array<Literal>;
|
||||
export type Primitive = string | number | symbol | bigint | boolean | null | undefined;
|
||||
export type PrimitiveArray = Array<Primitive>;
|
||||
export type HasSize = {
|
||||
size: number;
|
||||
};
|
||||
export type HasLength = {
|
||||
length: number;
|
||||
};
|
||||
export type Numeric = number | bigint | Date;
|
||||
export type SafeParseResult<T> = SafeParseSuccess<T> | SafeParseError<T>;
|
||||
export type SafeParseSuccess<T> = {
|
||||
success: true;
|
||||
data: T;
|
||||
error?: never;
|
||||
};
|
||||
export type SafeParseError<T> = {
|
||||
success: false;
|
||||
data?: never;
|
||||
error: errors.$ZodError<T>;
|
||||
};
|
||||
export type PropValues = Record<string, Set<Primitive>>;
|
||||
export type PrimitiveSet = Set<Primitive>;
|
||||
export declare function assertEqual<A, B>(val: AssertEqual<A, B>): AssertEqual<A, B>;
|
||||
export declare function assertNotEqual<A, B>(val: AssertNotEqual<A, B>): AssertNotEqual<A, B>;
|
||||
export declare function toZod<T>(): <S extends schemas.$ZodType>(schema: ToZodEqual<S["_zod"]["output"], T> extends true ? S : ToZodTarget<S, T>) => S;
|
||||
export declare function assertIs<T>(_arg: T): void;
|
||||
export declare function assertNever(_x: never): never;
|
||||
export declare function assert<T>(_: any): asserts _ is T;
|
||||
export declare function getEnumValues(entries: EnumLike): EnumValue[];
|
||||
export declare function joinValues<T extends Primitive[]>(array: T, separator?: string): string;
|
||||
export declare function jsonStringifyReplacer(_: string, value: any): any;
|
||||
export declare function cached<T>(getter: () => T): {
|
||||
value: T;
|
||||
};
|
||||
export declare function nullish(input: any): boolean;
|
||||
export declare function cleanRegex(source: string): string;
|
||||
export declare function floatSafeRemainder(val: number, step: number): number;
|
||||
export declare function defineLazy<T, K extends keyof T>(object: T, key: K, getter: () => T[K]): void;
|
||||
export declare function objectClone(obj: object): any;
|
||||
export declare function assignProp<T extends object, K extends PropertyKey>(target: T, prop: K, value: K extends keyof T ? T[K] : any): void;
|
||||
/** A def's `shape` accessor, carrying whichever object it currently answers from. */
|
||||
export interface ShapeGetter {
|
||||
(): Record<PropertyKey, any>;
|
||||
raw: Record<PropertyKey, any>;
|
||||
}
|
||||
/**
|
||||
* Whichever object a def's `shape` currently answers from: the one the caller passed until the first read, the frozen copy after it.
|
||||
*
|
||||
* Its keys and descriptors read without invoking anything, which is what lets a discriminated union check its discriminator, and the cycle walk read a shape, without resolving a getter that references the schema being constructed. A def that answers `shape` from an accessor of its own has none.
|
||||
*/
|
||||
export declare function rawShape(def: any): Record<PropertyKey, any> | undefined;
|
||||
export declare function mergeDefs(...defs: Record<string, any>[]): any;
|
||||
export declare function cloneDef(schema: schemas.$ZodType): any;
|
||||
export declare function getElementAtPath(obj: any, path: (string | number)[] | null | undefined): any;
|
||||
export declare function promiseAllObject<T extends object>(promisesObj: T): Promise<{
|
||||
[k in keyof T]: Awaited<T[k]>;
|
||||
}>;
|
||||
export declare function randomString(length?: number): string;
|
||||
export declare function esc(str: string): string;
|
||||
export declare function slugify(input: string): string;
|
||||
export declare const captureStackTrace: (targetObject: object, constructorOpt?: Function) => void;
|
||||
export declare function isObject(data: any): data is Record<PropertyKey, unknown>;
|
||||
export declare const allowsEval: {
|
||||
value: boolean;
|
||||
};
|
||||
export declare function isPlainObject(o: any): o is Record<PropertyKey, unknown>;
|
||||
export declare function shallowClone(o: any): any;
|
||||
export declare function numKeys(data: any): number;
|
||||
export declare const getParsedType: (data: any) => ParsedTypes;
|
||||
export declare const propertyKeyTypes: Set<string>;
|
||||
export declare const primitiveTypes: Set<string>;
|
||||
export declare function escapeRegex(str: string): string;
|
||||
export declare function clone<T extends schemas.$ZodType>(inst: T, def?: T["_zod"]["def"], params?: {
|
||||
parent: boolean;
|
||||
}): T;
|
||||
export type EmptyToNever<T> = keyof T extends never ? never : T;
|
||||
export type Normalize<T> = T extends undefined ? never : T extends Record<any, any> ? Flatten<{
|
||||
[k in keyof Omit<T, "error" | "message">]: T[k];
|
||||
} & ("error" extends keyof T ? {
|
||||
error?: Exclude<T["error"], string>;
|
||||
} : unknown)> : never;
|
||||
export declare function normalizeParams<T>(_params: T): Normalize<T>;
|
||||
export declare function createTransparentProxy<T extends object>(getter: () => T): T;
|
||||
export declare function stringifyPrimitive(value: any): string;
|
||||
export declare function optionalKeys(shape: schemas.$ZodShape): string[];
|
||||
export type CleanKey<T extends PropertyKey> = T extends `?${infer K}` ? K : T extends `${infer K}?` ? K : T;
|
||||
export type ToCleanMap<T extends schemas.$ZodLooseShape> = {
|
||||
[k in keyof T]: k extends `?${infer K}` ? K : k extends `${infer K}?` ? K : k;
|
||||
};
|
||||
export type FromCleanMap<T extends schemas.$ZodLooseShape> = {
|
||||
[k in keyof T as k extends `?${infer K}` ? K : k extends `${infer K}?` ? K : k]: k;
|
||||
};
|
||||
export declare const NUMBER_FORMAT_RANGES: Record<checks.$ZodNumberFormats, [number, number]>;
|
||||
export declare const BIGINT_FORMAT_RANGES: Record<checks.$ZodBigIntFormats, [bigint, bigint]>;
|
||||
export declare function pick(schema: schemas.$ZodObject, mask: Record<string, unknown>): any;
|
||||
export declare function omit(schema: schemas.$ZodObject, mask: object): any;
|
||||
export declare function extend(schema: schemas.$ZodObject, shape: schemas.$ZodShape): any;
|
||||
export declare function safeExtend(schema: schemas.$ZodObject, shape: schemas.$ZodShape): any;
|
||||
export declare function merge(a: schemas.$ZodObject, b: schemas.$ZodObject): any;
|
||||
export declare function partial(Class: SchemaClass<schemas.$ZodOptional> | null, schema: schemas.$ZodObject, mask: object | undefined, name?: string): any;
|
||||
export declare function required(Class: SchemaClass<schemas.$ZodNonOptional>, schema: schemas.$ZodObject, mask: object | undefined): any;
|
||||
export type Constructor<T, Def extends any[] = any[]> = new (...args: Def) => T;
|
||||
export declare function aborted(x: schemas.ParsePayload, startIndex?: number): boolean;
|
||||
export declare function explicitlyAborted(x: schemas.ParsePayload, startIndex?: number): boolean;
|
||||
export declare function prefixIssues(path: PropertyKey, issues: errors.$ZodRawIssue[]): errors.$ZodRawIssue[];
|
||||
export declare function unwrapMessage(message: string | {
|
||||
message: string;
|
||||
} | undefined | null): string | undefined;
|
||||
/** The leading size checks of `defChecks` that set an upper bound, each paired with it. */
|
||||
export declare function sizeCaps(defChecks: checks.$ZodCheck<never>[] | undefined): [number, checks.$ZodCheck<never>][];
|
||||
export declare function attachSchema(issues: errors.$ZodRawIssue[], start: number, inst: schemas.$ZodType): void;
|
||||
export declare function finalizeIssue(iss: errors.$ZodRawIssue, ctx: schemas.ParseContextInternal | undefined, config: $ZodConfig): errors.$ZodIssue;
|
||||
export declare function getSizableOrigin(input: any): "set" | "map" | "file" | "unknown";
|
||||
export declare function codePointLength(str: string): number;
|
||||
export declare function getLengthableOrigin(input: any): "array" | "string" | "unknown";
|
||||
export declare function parsedType(data: unknown): errors.$ZodInvalidTypeExpected;
|
||||
export declare function issue(_iss: string, input: any, inst: any): errors.$ZodRawIssue;
|
||||
export declare function issue(_iss: errors.$ZodRawIssue): errors.$ZodRawIssue;
|
||||
export declare function cleanEnum(obj: Record<string, EnumValue>): EnumValue[];
|
||||
export declare function base64ToUint8Array(base64: string): InstanceType<typeof Uint8Array>;
|
||||
export declare function uint8ArrayToBase64(bytes: Uint8Array): string;
|
||||
export declare function base64urlToUint8Array(base64url: string): InstanceType<typeof Uint8Array>;
|
||||
export declare function uint8ArrayToBase64url(bytes: Uint8Array): string;
|
||||
export declare function hexToUint8Array(hex: string): InstanceType<typeof Uint8Array>;
|
||||
export declare function uint8ArrayToHex(bytes: Uint8Array): string;
|
||||
export declare abstract class Class {
|
||||
constructor(..._args: any[]);
|
||||
}
|
||||
/**
|
||||
* Installs a trait's members on its prototype. Each value builds that member for the instance on first read; the built value shadows the accessor as an own property, so a detached `const { parse } = schema` keeps working.
|
||||
*
|
||||
* Call this from a `proto` initializer, which runs once per prototype — never per instance.
|
||||
*/
|
||||
export declare function members(proto: object, table: object): void;
|
||||
/** Shadows a prototype member with an own value, so a getter that builds from the instance runs once. */
|
||||
export declare function own<T>(inst: object, key: PropertyKey, value: T, enumerable?: boolean): T;
|
||||
/** Like {@link own}, for a member that was never an own data property and has to stay out of `Object.keys`. */
|
||||
export declare function hide<T>(inst: object, key: PropertyKey, value: T): T;
|
||||
/** Adds members a table derives from the instance: each builds on first read and shadows as own data, and assignment shadows the same way, as when these were own properties. */
|
||||
export declare function derived<T>(computes: {
|
||||
[K in keyof T]?: (inst: T) => T[K];
|
||||
}, table: ProtoOf<T>): ProtoOf<T>;
|
||||
/** A trait's prototype members: a partial view of its own interface, with `this` typed as the instance. */
|
||||
export type ProtoOf<T> = {
|
||||
[K in keyof T]?: (T[K] extends (...args: infer A) => infer R ? (...args: A) => R : T[K]) | undefined;
|
||||
} & ThisType<T>;
|
||||
/**
|
||||
* Installs a lazily-derived internal on the `_zod` prototype of `inst`'s
|
||||
* constructor, computed from the internals object itself and cached there on
|
||||
* first read. One accessor per constructor rather than one per instance.
|
||||
*/
|
||||
export declare function defineLazyInternal<T extends {
|
||||
_zod: any;
|
||||
}>(inst: T, key: string, compute: (zod: T["_zod"]) => unknown): void;
|
||||
/**
|
||||
* Installs `key` on `inst`'s prototype, computed by `make` on first read and cached there as an own
|
||||
* data property. One accessor per constructor rather than one per instance, because an own accessor
|
||||
* puts every instance after the first into v8 dictionary mode. The key doubles as the sentinel.
|
||||
*/
|
||||
export declare function installLazyProp(inst: object, key: string, make: (self: any) => unknown, enumerable: boolean): void;
|
||||
/** Marks the thunk `_catch` synthesises for a constant catch value. `Function.length` cannot tell that thunk from a user callback — rest and defaulted parameters both report arity 0 — and a user callback reads `ctx.error`, whose issues only finalize correctly against the caller's per-parse error map. Provenance can say what arity cannot. A plain string key rather than `Symbol.for`, whose call at module scope no bundler can prove pure — the same shape that anchored `urlCanParse` into every build. */
|
||||
export declare const CONSTANT_CATCH = "~constantCatch";
|
||||
/** Wraps a constant catch value in a thunk tagged with {@link CONSTANT_CATCH}. */
|
||||
export declare function constantCatch<T>(value: T): () => T;
|
||||
export {};
|
||||
+280
@@ -0,0 +1,280 @@
|
||||
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";
|
||||
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 HashAlgorithm = "md5" | "sha1" | "sha256" | "sha384" | "sha512";
|
||||
export type HashEncoding = "hex" | "base64" | "base64url";
|
||||
export type HashFormat = `${HashAlgorithm}_${HashEncoding}`;
|
||||
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";
|
||||
export type AssertEqual<T, U> = (<V>() => V extends T ? 1 : 2) extends <V>() => V extends U ? 1 : 2 ? true : false;
|
||||
export type AssertNotEqual<T, U> = (<V>() => V extends T ? 1 : 2) extends <V>() => V extends U ? 1 : 2 ? false : true;
|
||||
export type AssertExtends<T, U> = T extends U ? T : never;
|
||||
type ToZodMismatch<T, S extends schemas.$ZodType> = {
|
||||
"types do not match": {
|
||||
expected: T;
|
||||
received: S["_zod"]["output"];
|
||||
};
|
||||
};
|
||||
type ToZodKeyMismatch<Expected, Received> = schemas.$ZodType & {
|
||||
"types do not match": {
|
||||
expected: Expected;
|
||||
received: Received;
|
||||
};
|
||||
};
|
||||
declare const toZodDummy: unique symbol;
|
||||
type ToZodNormalize<T> = [T] extends [(...args: any[]) => any] ? T : [T] extends [object] ? {
|
||||
[K in keyof T]: ToZodNormalize<T[K]>;
|
||||
} : T | typeof toZodDummy;
|
||||
type ToZodEqual<Output, T> = AssertEqual<Output, T> extends true ? true : IsAny<Output> extends true ? false : IsAny<T> extends true ? false : AssertEqual<ToZodNormalize<Output>, ToZodNormalize<T>>;
|
||||
type ToZodShape<Shape, T> = {
|
||||
[K in keyof Shape]: Shape[K] extends schemas.$ZodType ? K extends keyof T ? ToZodEqual<Shape[K]["_zod"]["output"], T[K]> extends true ? Shape[K] : ToZodKeyMismatch<T[K], Shape[K]["_zod"]["output"]> : ToZodKeyMismatch<never, Shape[K]["_zod"]["output"]> : Shape[K];
|
||||
} & {
|
||||
[K in Exclude<keyof T, keyof Shape>]: ToZodKeyMismatch<T[K], never>;
|
||||
};
|
||||
type ToZodExpand<X> = {
|
||||
[K in keyof X]: X[K];
|
||||
} & {};
|
||||
type ToZodTarget<S extends schemas.$ZodType, T> = S extends schemas.$ZodObject<infer Shape, infer Config> ? T extends object ? AssertEqual<ToZodExpand<ToZodShape<Shape, T>>, ToZodExpand<Shape>> extends true ? S & ToZodMismatch<T, S> : schemas.$ZodObject<ToZodExpand<ToZodShape<Shape, T>>, Config> : S & ToZodMismatch<T, S> : S & ToZodMismatch<T, S>;
|
||||
export type IsAny<T> = 0 extends 1 & T ? true : false;
|
||||
export type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
|
||||
export type OmitKeys<T, K extends string> = Pick<T, Exclude<keyof T, K>>;
|
||||
export type MakePartial<T, K extends keyof T> = Omit<T, K> & InexactPartial<Pick<T, K>>;
|
||||
export type MakeRequired<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>;
|
||||
export type Exactly<T, X> = T & Record<Exclude<keyof X, keyof T>, never>;
|
||||
export type NoUndefined<T> = T extends undefined ? never : T;
|
||||
export type Whatever = {} | undefined | null;
|
||||
export type Widen<T> = T extends string ? string : T extends number ? number : T extends boolean ? boolean : T extends bigint ? bigint : T;
|
||||
export type LoosePartial<T extends object> = InexactPartial<T> & {
|
||||
[k: string]: unknown;
|
||||
};
|
||||
export type Mask<Keys extends PropertyKey> = {
|
||||
[K in Keys]?: true;
|
||||
};
|
||||
export type Writeable<T> = {
|
||||
-readonly [P in keyof T]: T[P];
|
||||
} & {};
|
||||
export type InexactPartial<T> = {
|
||||
[P in keyof T]?: T[P] | undefined;
|
||||
};
|
||||
export type EmptyObject = Record<string, never>;
|
||||
export type BuiltIn = (((...args: any[]) => any) | (new (...args: any[]) => any)) | {
|
||||
readonly [Symbol.toStringTag]: string;
|
||||
} | Date | Error | Generator | Promise<unknown> | RegExp;
|
||||
export type MakeReadonly<T> = T extends Map<infer K, infer V> ? ReadonlyMap<K, V> : T extends Set<infer V> ? ReadonlySet<V> : T extends [infer Head, ...infer Tail] ? readonly [Head, ...Tail] : T extends Array<infer V> ? ReadonlyArray<V> : T extends BuiltIn ? T : Readonly<T>;
|
||||
export type SomeObject = Record<PropertyKey, any>;
|
||||
export type Identity<T> = T;
|
||||
export type Flatten<T> = Identity<{
|
||||
[k in keyof T]: T[k];
|
||||
}>;
|
||||
export type Mapped<T> = {
|
||||
[k in keyof T]: T[k];
|
||||
};
|
||||
export type Prettify<T> = {
|
||||
[K in keyof T]: T[K];
|
||||
} & {};
|
||||
export type NoNeverKeys<T> = {
|
||||
[k in keyof T]: [T[k]] extends [never] ? never : k;
|
||||
}[keyof T];
|
||||
export type NoNever<T> = Identity<{
|
||||
[k in NoNeverKeys<T>]: k extends keyof T ? T[k] : never;
|
||||
}>;
|
||||
export type Extend<A extends SomeObject, B extends SomeObject> = Flatten<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<schemas.SomeType>;
|
||||
export type AnyFunc = (...args: any[]) => any;
|
||||
export type IsProp<T, K extends keyof T> = T[K] extends AnyFunc ? never : K;
|
||||
export type MaybeAsync<T> = T | Promise<T>;
|
||||
export type KeyOf<T> = keyof OmitIndexSignature<T>;
|
||||
export type OmitIndexSignature<T> = {
|
||||
[K in keyof T as string extends K ? never : K extends string ? K : never]: T[K];
|
||||
};
|
||||
export type ExtractIndexSignature<T> = {
|
||||
[K in keyof T as string extends K ? K : K extends string ? never : K]: T[K];
|
||||
};
|
||||
export type Keys<T extends object> = keyof OmitIndexSignature<T>;
|
||||
export type SchemaClass<T extends schemas.SomeType> = {
|
||||
new (def: T["_zod"]["def"]): T;
|
||||
};
|
||||
export type EnumValue = string | number;
|
||||
export type EnumLike = Readonly<Record<string, EnumValue>>;
|
||||
export type ToEnum<T extends EnumValue> = Flatten<{
|
||||
[k in T]: k;
|
||||
}>;
|
||||
export type KeysEnum<T extends object> = ToEnum<Exclude<keyof T, symbol>>;
|
||||
export type KeysArray<T extends object> = Flatten<(keyof T & string)[]>;
|
||||
export type Literal = string | number | bigint | boolean | null | undefined;
|
||||
export type LiteralArray = Array<Literal>;
|
||||
export type Primitive = string | number | symbol | bigint | boolean | null | undefined;
|
||||
export type PrimitiveArray = Array<Primitive>;
|
||||
export type HasSize = {
|
||||
size: number;
|
||||
};
|
||||
export type HasLength = {
|
||||
length: number;
|
||||
};
|
||||
export type Numeric = number | bigint | Date;
|
||||
export type SafeParseResult<T> = SafeParseSuccess<T> | SafeParseError<T>;
|
||||
export type SafeParseSuccess<T> = {
|
||||
success: true;
|
||||
data: T;
|
||||
error?: never;
|
||||
};
|
||||
export type SafeParseError<T> = {
|
||||
success: false;
|
||||
data?: never;
|
||||
error: errors.$ZodError<T>;
|
||||
};
|
||||
export type PropValues = Record<string, Set<Primitive>>;
|
||||
export type PrimitiveSet = Set<Primitive>;
|
||||
export declare function assertEqual<A, B>(val: AssertEqual<A, B>): AssertEqual<A, B>;
|
||||
export declare function assertNotEqual<A, B>(val: AssertNotEqual<A, B>): AssertNotEqual<A, B>;
|
||||
export declare function toZod<T>(): <S extends schemas.$ZodType>(schema: ToZodEqual<S["_zod"]["output"], T> extends true ? S : ToZodTarget<S, T>) => S;
|
||||
export declare function assertIs<T>(_arg: T): void;
|
||||
export declare function assertNever(_x: never): never;
|
||||
export declare function assert<T>(_: any): asserts _ is T;
|
||||
export declare function getEnumValues(entries: EnumLike): EnumValue[];
|
||||
export declare function joinValues<T extends Primitive[]>(array: T, separator?: string): string;
|
||||
export declare function jsonStringifyReplacer(_: string, value: any): any;
|
||||
export declare function cached<T>(getter: () => T): {
|
||||
value: T;
|
||||
};
|
||||
export declare function nullish(input: any): boolean;
|
||||
export declare function cleanRegex(source: string): string;
|
||||
export declare function floatSafeRemainder(val: number, step: number): number;
|
||||
export declare function defineLazy<T, K extends keyof T>(object: T, key: K, getter: () => T[K]): void;
|
||||
export declare function objectClone(obj: object): any;
|
||||
export declare function assignProp<T extends object, K extends PropertyKey>(target: T, prop: K, value: K extends keyof T ? T[K] : any): void;
|
||||
/** A def's `shape` accessor, carrying whichever object it currently answers from. */
|
||||
export interface ShapeGetter {
|
||||
(): Record<PropertyKey, any>;
|
||||
raw: Record<PropertyKey, any>;
|
||||
}
|
||||
/**
|
||||
* Whichever object a def's `shape` currently answers from: the one the caller passed until the first read, the frozen copy after it.
|
||||
*
|
||||
* Its keys and descriptors read without invoking anything, which is what lets a discriminated union check its discriminator, and the cycle walk read a shape, without resolving a getter that references the schema being constructed. A def that answers `shape` from an accessor of its own has none.
|
||||
*/
|
||||
export declare function rawShape(def: any): Record<PropertyKey, any> | undefined;
|
||||
export declare function mergeDefs(...defs: Record<string, any>[]): any;
|
||||
export declare function cloneDef(schema: schemas.$ZodType): any;
|
||||
export declare function getElementAtPath(obj: any, path: (string | number)[] | null | undefined): any;
|
||||
export declare function promiseAllObject<T extends object>(promisesObj: T): Promise<{
|
||||
[k in keyof T]: Awaited<T[k]>;
|
||||
}>;
|
||||
export declare function randomString(length?: number): string;
|
||||
export declare function esc(str: string): string;
|
||||
export declare function slugify(input: string): string;
|
||||
export declare const captureStackTrace: (targetObject: object, constructorOpt?: Function) => void;
|
||||
export declare function isObject(data: any): data is Record<PropertyKey, unknown>;
|
||||
export declare const allowsEval: {
|
||||
value: boolean;
|
||||
};
|
||||
export declare function isPlainObject(o: any): o is Record<PropertyKey, unknown>;
|
||||
export declare function shallowClone(o: any): any;
|
||||
export declare function numKeys(data: any): number;
|
||||
export declare const getParsedType: (data: any) => ParsedTypes;
|
||||
export declare const propertyKeyTypes: Set<string>;
|
||||
export declare const primitiveTypes: Set<string>;
|
||||
export declare function escapeRegex(str: string): string;
|
||||
export declare function clone<T extends schemas.$ZodType>(inst: T, def?: T["_zod"]["def"], params?: {
|
||||
parent: boolean;
|
||||
}): T;
|
||||
export type EmptyToNever<T> = keyof T extends never ? never : T;
|
||||
export type Normalize<T> = T extends undefined ? never : T extends Record<any, any> ? Flatten<{
|
||||
[k in keyof Omit<T, "error" | "message">]: T[k];
|
||||
} & ("error" extends keyof T ? {
|
||||
error?: Exclude<T["error"], string>;
|
||||
} : unknown)> : never;
|
||||
export declare function normalizeParams<T>(_params: T): Normalize<T>;
|
||||
export declare function createTransparentProxy<T extends object>(getter: () => T): T;
|
||||
export declare function stringifyPrimitive(value: any): string;
|
||||
export declare function optionalKeys(shape: schemas.$ZodShape): string[];
|
||||
export type CleanKey<T extends PropertyKey> = T extends `?${infer K}` ? K : T extends `${infer K}?` ? K : T;
|
||||
export type ToCleanMap<T extends schemas.$ZodLooseShape> = {
|
||||
[k in keyof T]: k extends `?${infer K}` ? K : k extends `${infer K}?` ? K : k;
|
||||
};
|
||||
export type FromCleanMap<T extends schemas.$ZodLooseShape> = {
|
||||
[k in keyof T as k extends `?${infer K}` ? K : k extends `${infer K}?` ? K : k]: k;
|
||||
};
|
||||
export declare const NUMBER_FORMAT_RANGES: Record<checks.$ZodNumberFormats, [number, number]>;
|
||||
export declare const BIGINT_FORMAT_RANGES: Record<checks.$ZodBigIntFormats, [bigint, bigint]>;
|
||||
export declare function pick(schema: schemas.$ZodObject, mask: Record<string, unknown>): any;
|
||||
export declare function omit(schema: schemas.$ZodObject, mask: object): any;
|
||||
export declare function extend(schema: schemas.$ZodObject, shape: schemas.$ZodShape): any;
|
||||
export declare function safeExtend(schema: schemas.$ZodObject, shape: schemas.$ZodShape): any;
|
||||
export declare function merge(a: schemas.$ZodObject, b: schemas.$ZodObject): any;
|
||||
export declare function partial(Class: SchemaClass<schemas.$ZodOptional> | null, schema: schemas.$ZodObject, mask: object | undefined, name?: string): any;
|
||||
export declare function required(Class: SchemaClass<schemas.$ZodNonOptional>, schema: schemas.$ZodObject, mask: object | undefined): any;
|
||||
export type Constructor<T, Def extends any[] = any[]> = new (...args: Def) => T;
|
||||
export declare function aborted(x: schemas.ParsePayload, startIndex?: number): boolean;
|
||||
export declare function explicitlyAborted(x: schemas.ParsePayload, startIndex?: number): boolean;
|
||||
export declare function prefixIssues(path: PropertyKey, issues: errors.$ZodRawIssue[]): errors.$ZodRawIssue[];
|
||||
export declare function unwrapMessage(message: string | {
|
||||
message: string;
|
||||
} | undefined | null): string | undefined;
|
||||
/** The leading size checks of `defChecks` that set an upper bound, each paired with it. */
|
||||
export declare function sizeCaps(defChecks: checks.$ZodCheck<never>[] | undefined): [number, checks.$ZodCheck<never>][];
|
||||
export declare function attachSchema(issues: errors.$ZodRawIssue[], start: number, inst: schemas.$ZodType): void;
|
||||
export declare function finalizeIssue(iss: errors.$ZodRawIssue, ctx: schemas.ParseContextInternal | undefined, config: $ZodConfig): errors.$ZodIssue;
|
||||
export declare function getSizableOrigin(input: any): "set" | "map" | "file" | "unknown";
|
||||
export declare function codePointLength(str: string): number;
|
||||
export declare function getLengthableOrigin(input: any): "array" | "string" | "unknown";
|
||||
export declare function parsedType(data: unknown): errors.$ZodInvalidTypeExpected;
|
||||
export declare function issue(_iss: string, input: any, inst: any): errors.$ZodRawIssue;
|
||||
export declare function issue(_iss: errors.$ZodRawIssue): errors.$ZodRawIssue;
|
||||
export declare function cleanEnum(obj: Record<string, EnumValue>): EnumValue[];
|
||||
export declare function base64ToUint8Array(base64: string): InstanceType<typeof Uint8Array>;
|
||||
export declare function uint8ArrayToBase64(bytes: Uint8Array): string;
|
||||
export declare function base64urlToUint8Array(base64url: string): InstanceType<typeof Uint8Array>;
|
||||
export declare function uint8ArrayToBase64url(bytes: Uint8Array): string;
|
||||
export declare function hexToUint8Array(hex: string): InstanceType<typeof Uint8Array>;
|
||||
export declare function uint8ArrayToHex(bytes: Uint8Array): string;
|
||||
export declare abstract class Class {
|
||||
constructor(..._args: any[]);
|
||||
}
|
||||
/**
|
||||
* Installs a trait's members on its prototype. Each value builds that member for the instance on first read; the built value shadows the accessor as an own property, so a detached `const { parse } = schema` keeps working.
|
||||
*
|
||||
* Call this from a `proto` initializer, which runs once per prototype — never per instance.
|
||||
*/
|
||||
export declare function members(proto: object, table: object): void;
|
||||
/** Shadows a prototype member with an own value, so a getter that builds from the instance runs once. */
|
||||
export declare function own<T>(inst: object, key: PropertyKey, value: T, enumerable?: boolean): T;
|
||||
/** Like {@link own}, for a member that was never an own data property and has to stay out of `Object.keys`. */
|
||||
export declare function hide<T>(inst: object, key: PropertyKey, value: T): T;
|
||||
/** Adds members a table derives from the instance: each builds on first read and shadows as own data, and assignment shadows the same way, as when these were own properties. */
|
||||
export declare function derived<T>(computes: {
|
||||
[K in keyof T]?: (inst: T) => T[K];
|
||||
}, table: ProtoOf<T>): ProtoOf<T>;
|
||||
/** A trait's prototype members: a partial view of its own interface, with `this` typed as the instance. */
|
||||
export type ProtoOf<T> = {
|
||||
[K in keyof T]?: (T[K] extends (...args: infer A) => infer R ? (...args: A) => R : T[K]) | undefined;
|
||||
} & ThisType<T>;
|
||||
/**
|
||||
* Installs a lazily-derived internal on the `_zod` prototype of `inst`'s
|
||||
* constructor, computed from the internals object itself and cached there on
|
||||
* first read. One accessor per constructor rather than one per instance.
|
||||
*/
|
||||
export declare function defineLazyInternal<T extends {
|
||||
_zod: any;
|
||||
}>(inst: T, key: string, compute: (zod: T["_zod"]) => unknown): void;
|
||||
/**
|
||||
* Installs `key` on `inst`'s prototype, computed by `make` on first read and cached there as an own
|
||||
* data property. One accessor per constructor rather than one per instance, because an own accessor
|
||||
* puts every instance after the first into v8 dictionary mode. The key doubles as the sentinel.
|
||||
*/
|
||||
export declare function installLazyProp(inst: object, key: string, make: (self: any) => unknown, enumerable: boolean): void;
|
||||
/** Marks the thunk `_catch` synthesises for a constant catch value. `Function.length` cannot tell that thunk from a user callback — rest and defaulted parameters both report arity 0 — and a user callback reads `ctx.error`, whose issues only finalize correctly against the caller's per-parse error map. Provenance can say what arity cannot. A plain string key rather than `Symbol.for`, whose call at module scope no bundler can prove pure — the same shape that anchored `urlCanParse` into every build. */
|
||||
export declare const CONSTANT_CATCH = "~constantCatch";
|
||||
/** Wraps a constant catch value in a thunk tagged with {@link CONSTANT_CATCH}. */
|
||||
export declare function constantCatch<T>(value: T): () => T;
|
||||
export {};
|
||||
+873
@@ -0,0 +1,873 @@
|
||||
import { globalConfig } from "./core.js";
|
||||
// functions
|
||||
export function assertEqual(val) {
|
||||
return val;
|
||||
}
|
||||
export function assertNotEqual(val) {
|
||||
return val;
|
||||
}
|
||||
export function toZod() {
|
||||
return (schema) => schema;
|
||||
}
|
||||
export function assertIs(_arg) { }
|
||||
export function assertNever(_x) {
|
||||
throw new Error("Unexpected value in exhaustive check");
|
||||
}
|
||||
export function assert(_) { }
|
||||
export function getEnumValues(entries) {
|
||||
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, separator = "|") {
|
||||
return array.map((val) => stringifyPrimitive(val)).join(separator);
|
||||
}
|
||||
export function jsonStringifyReplacer(_, value) {
|
||||
if (typeof value === "bigint")
|
||||
return value.toString();
|
||||
return value;
|
||||
}
|
||||
// the accessor lives on a shared prototype: an own accessor makes every box a dictionary-mode object (~360 B and a slow load per read against ~100 B and an inlined getter here)
|
||||
class Cached {
|
||||
constructor(getter) {
|
||||
this._getter = getter;
|
||||
this._value = undefined;
|
||||
}
|
||||
get value() {
|
||||
const getter = this._getter;
|
||||
if (getter !== undefined) {
|
||||
this._value = getter();
|
||||
this._getter = undefined;
|
||||
}
|
||||
return this._value;
|
||||
}
|
||||
}
|
||||
export function cached(getter) {
|
||||
return new Cached(getter);
|
||||
}
|
||||
export function nullish(input) {
|
||||
return input === null || input === undefined;
|
||||
}
|
||||
export function cleanRegex(source) {
|
||||
const start = source.startsWith("^") ? 1 : 0;
|
||||
const end = source.endsWith("$") ? source.length - 1 : source.length;
|
||||
return source.slice(start, end);
|
||||
}
|
||||
export function floatSafeRemainder(val, step) {
|
||||
const ratio = val / step;
|
||||
const roundedRatio = Math.round(ratio);
|
||||
// `val` and `step` each round to a double before the division rounds again, so a true decimal multiple's quotient can sit up to 1.5 of these scaled epsilons from the integer. A 1x tolerance therefore rejected 2.03 as a multiple of 0.07; 4x covers the worst case with margin.
|
||||
const tolerance = 4 * Number.EPSILON * Math.max(Math.abs(ratio), 1);
|
||||
if (Math.abs(ratio - roundedRatio) < tolerance)
|
||||
return 0;
|
||||
return ratio - roundedRatio;
|
||||
}
|
||||
const EVALUATING = /* @__PURE__*/ Symbol("evaluating");
|
||||
export function defineLazy(object, key, getter) {
|
||||
let value = undefined;
|
||||
Object.defineProperty(object, key, {
|
||||
get() {
|
||||
if (value === EVALUATING) {
|
||||
// Circular reference detected, return undefined to break the cycle
|
||||
return undefined;
|
||||
}
|
||||
if (value === undefined) {
|
||||
value = EVALUATING;
|
||||
value = getter();
|
||||
}
|
||||
return value;
|
||||
},
|
||||
set(v) {
|
||||
Object.defineProperty(object, key, {
|
||||
value: v,
|
||||
// configurable: true,
|
||||
});
|
||||
// object[key] = v;
|
||||
},
|
||||
configurable: true,
|
||||
});
|
||||
}
|
||||
export function objectClone(obj) {
|
||||
return Object.create(Object.getPrototypeOf(obj), Object.getOwnPropertyDescriptors(obj));
|
||||
}
|
||||
export function assignProp(target, prop, value) {
|
||||
Object.defineProperty(target, prop, {
|
||||
value,
|
||||
writable: true,
|
||||
enumerable: true,
|
||||
configurable: true,
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Whichever object a def's `shape` currently answers from: the one the caller passed until the first read, the frozen copy after it.
|
||||
*
|
||||
* Its keys and descriptors read without invoking anything, which is what lets a discriminated union check its discriminator, and the cycle walk read a shape, without resolving a getter that references the schema being constructed. A def that answers `shape` from an accessor of its own has none.
|
||||
*/
|
||||
export function rawShape(def) {
|
||||
const desc = Object.getOwnPropertyDescriptor(def, "shape");
|
||||
return desc?.get ? desc.get.raw : desc?.value;
|
||||
}
|
||||
// where a builder reads its source's keys and descriptors, resolving only a shape a def answers for itself. A shape resolves by object spread, so only its enumerable keys are ever part of it.
|
||||
function sourceShape(schema) {
|
||||
return rawShape(schema._zod.def) ?? schema._zod.def.shape;
|
||||
}
|
||||
// a key whose value is not settled yet, self-caching so every read after the first gets the same one
|
||||
function deferProp(target, key, getter) {
|
||||
Object.defineProperty(target, key, {
|
||||
get() {
|
||||
const value = getter();
|
||||
assignProp(this, key, value);
|
||||
return value;
|
||||
},
|
||||
enumerable: true,
|
||||
configurable: true,
|
||||
});
|
||||
}
|
||||
// Writes a settled key. A plain assignment is much cheaper than `defineProperty` and produces the same descriptor, but it runs whatever setter already answers to the key — an accessor this shape deferred, or an inherited one, which `__proto__` has on every object and prototype pollution can add for any name.
|
||||
function putProp(target, key, value) {
|
||||
if (key in target)
|
||||
assignProp(target, key, value);
|
||||
else
|
||||
target[key] = value;
|
||||
}
|
||||
/**
|
||||
* Copies `keys` of `source`'s shape onto `target`, each value passed through `wrap`.
|
||||
*
|
||||
* A key the source has resolved is copied through now, so the derived shape states it outright and nothing has to resolve it to learn what it holds. A key the source still defers stays deferred, and reads back through the source's own `shape`, so it resolves once and both shapes get that one schema.
|
||||
*/
|
||||
function mirrorShape(target, source, keys, wrap) {
|
||||
const raw = sourceShape(source);
|
||||
for (const key of keys) {
|
||||
const desc = Object.getOwnPropertyDescriptor(raw, key);
|
||||
if (!desc.enumerable)
|
||||
continue;
|
||||
if (desc.get) {
|
||||
deferProp(target, key, () => {
|
||||
const value = source._zod.def.shape[key];
|
||||
return wrap ? wrap(value, key) : value;
|
||||
});
|
||||
}
|
||||
else
|
||||
putProp(target, key, wrap ? wrap(desc.value, key) : desc.value);
|
||||
}
|
||||
}
|
||||
// same, for a plain shape a caller passed rather than a schema's
|
||||
function mirrorProps(target, source) {
|
||||
for (const key of Reflect.ownKeys(source)) {
|
||||
const desc = Object.getOwnPropertyDescriptor(source, key);
|
||||
if (!desc.enumerable)
|
||||
continue;
|
||||
if (desc.get)
|
||||
deferProp(target, key, () => source[key]);
|
||||
else
|
||||
putProp(target, key, desc.value);
|
||||
}
|
||||
}
|
||||
export function mergeDefs(...defs) {
|
||||
const mergedDescriptors = {};
|
||||
for (const def of defs) {
|
||||
const descriptors = Object.getOwnPropertyDescriptors(def);
|
||||
Object.assign(mergedDescriptors, descriptors);
|
||||
}
|
||||
return Object.defineProperties({}, mergedDescriptors);
|
||||
}
|
||||
export function cloneDef(schema) {
|
||||
return mergeDefs(schema._zod.def);
|
||||
}
|
||||
export function getElementAtPath(obj, path) {
|
||||
if (!path)
|
||||
return obj;
|
||||
return path.reduce((acc, key) => acc?.[key], obj);
|
||||
}
|
||||
export function promiseAllObject(promisesObj) {
|
||||
const keys = Object.keys(promisesObj);
|
||||
const promises = keys.map((key) => promisesObj[key]);
|
||||
return Promise.all(promises).then((results) => {
|
||||
const resolvedObj = {};
|
||||
for (let i = 0; i < keys.length; i++) {
|
||||
resolvedObj[keys[i]] = results[i];
|
||||
}
|
||||
return resolvedObj;
|
||||
});
|
||||
}
|
||||
export function randomString(length = 10) {
|
||||
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) {
|
||||
return JSON.stringify(str);
|
||||
}
|
||||
export function slugify(input) {
|
||||
return input
|
||||
.toLowerCase()
|
||||
.trim()
|
||||
.replace(/[^\w\s-]/g, "")
|
||||
.replace(/[\s_-]+/g, "-")
|
||||
.replace(/^-+|-+$/g, "");
|
||||
}
|
||||
export const captureStackTrace = ("captureStackTrace" in Error ? Error.captureStackTrace : (..._args) => { });
|
||||
export function isObject(data) {
|
||||
return typeof data === "object" && data !== null && !Array.isArray(data);
|
||||
}
|
||||
export const allowsEval = /* @__PURE__*/ cached(() => {
|
||||
// Skip the probe under `jitless`: strict CSPs report the caught `new Function` as a `securitypolicyviolation` even though the throw is swallowed.
|
||||
if (globalConfig.jitless) {
|
||||
return false;
|
||||
}
|
||||
// @ts-ignore
|
||||
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) {
|
||||
if (isObject(o) === false)
|
||||
return false;
|
||||
// modified constructor
|
||||
const ctor = o.constructor;
|
||||
if (ctor === undefined)
|
||||
return true;
|
||||
if (typeof ctor !== "function")
|
||||
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 shallowClone(o) {
|
||||
if (isPlainObject(o))
|
||||
return { ...o };
|
||||
if (Array.isArray(o))
|
||||
return [...o];
|
||||
if (o instanceof Map)
|
||||
return new Map(o);
|
||||
if (o instanceof Set)
|
||||
return new Set(o);
|
||||
return o;
|
||||
}
|
||||
export function numKeys(data) {
|
||||
let keyCount = 0;
|
||||
for (const key in data) {
|
||||
if (Object.prototype.hasOwnProperty.call(data, key)) {
|
||||
keyCount++;
|
||||
}
|
||||
}
|
||||
return keyCount;
|
||||
}
|
||||
export const getParsedType = (data) => {
|
||||
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";
|
||||
}
|
||||
// @ts-ignore
|
||||
if (typeof File !== "undefined" && data instanceof File) {
|
||||
return "file";
|
||||
}
|
||||
return "object";
|
||||
default:
|
||||
throw new Error(`Unknown data type: ${t}`);
|
||||
}
|
||||
};
|
||||
export const propertyKeyTypes = /* @__PURE__*/ new Set(["string", "number", "symbol"]);
|
||||
export const primitiveTypes = /* @__PURE__*/ new Set([
|
||||
"string",
|
||||
"number",
|
||||
"bigint",
|
||||
"boolean",
|
||||
"symbol",
|
||||
"undefined",
|
||||
]);
|
||||
export function escapeRegex(str) {
|
||||
return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
|
||||
}
|
||||
// zod-specific utils
|
||||
export function clone(inst, def, params) {
|
||||
const cl = new inst._zod.constr(def ?? inst._zod.def);
|
||||
if (!def || params?.parent)
|
||||
cl._zod.parent = inst;
|
||||
return cl;
|
||||
}
|
||||
export function normalizeParams(_params) {
|
||||
const params = _params;
|
||||
if (!params)
|
||||
return {};
|
||||
if (typeof params === "string")
|
||||
return { error: () => params };
|
||||
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 };
|
||||
return params;
|
||||
}
|
||||
export function createTransparentProxy(getter) {
|
||||
let target;
|
||||
return new Proxy({}, {
|
||||
get(_, prop, receiver) {
|
||||
target ?? (target = getter());
|
||||
return Reflect.get(target, prop, receiver);
|
||||
},
|
||||
set(_, prop, value, receiver) {
|
||||
target ?? (target = getter());
|
||||
return Reflect.set(target, prop, value, receiver);
|
||||
},
|
||||
has(_, prop) {
|
||||
target ?? (target = getter());
|
||||
return Reflect.has(target, prop);
|
||||
},
|
||||
deleteProperty(_, prop) {
|
||||
target ?? (target = getter());
|
||||
return Reflect.deleteProperty(target, prop);
|
||||
},
|
||||
ownKeys(_) {
|
||||
target ?? (target = getter());
|
||||
return Reflect.ownKeys(target);
|
||||
},
|
||||
getOwnPropertyDescriptor(_, prop) {
|
||||
target ?? (target = getter());
|
||||
return Reflect.getOwnPropertyDescriptor(target, prop);
|
||||
},
|
||||
defineProperty(_, prop, descriptor) {
|
||||
target ?? (target = getter());
|
||||
return Reflect.defineProperty(target, prop, descriptor);
|
||||
},
|
||||
});
|
||||
}
|
||||
export function stringifyPrimitive(value) {
|
||||
if (typeof value === "bigint")
|
||||
return value.toString() + "n";
|
||||
if (typeof value === "string")
|
||||
return `"${value}"`;
|
||||
return `${value}`;
|
||||
}
|
||||
export function optionalKeys(shape) {
|
||||
return Object.keys(shape).filter((k) => {
|
||||
return shape[k]._zod.optin !== undefined && shape[k]._zod.optout === "optional";
|
||||
});
|
||||
}
|
||||
// Wrapped in a `@__PURE__` IIFE: esbuild never tree-shakes a top-level initializer that contains a member access on `Number`, so the bare object literal survived into every bundle.
|
||||
export const NUMBER_FORMAT_RANGES = /*@__PURE__*/ (() => ({
|
||||
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 = {
|
||||
int64: [/* @__PURE__*/ BigInt("-9223372036854775808"), /* @__PURE__*/ BigInt("9223372036854775807")],
|
||||
uint64: [/* @__PURE__*/ BigInt(0), /* @__PURE__*/ BigInt("18446744073709551615")],
|
||||
};
|
||||
export function pick(schema, mask) {
|
||||
const currDef = schema._zod.def;
|
||||
const checks = currDef.checks;
|
||||
const hasChecks = checks && checks.length > 0;
|
||||
if (hasChecks) {
|
||||
throw new Error(".pick() cannot be used on object schemas containing refinements");
|
||||
}
|
||||
const newShape = {};
|
||||
mirrorShape(newShape, schema, maskedKeys(schema, mask));
|
||||
return clone(schema, mergeDefs(currDef, { shape: newShape, checks: [] }));
|
||||
}
|
||||
// the mask keys that select something, checked against the source's shape without resolving it
|
||||
function maskedKeys(schema, mask) {
|
||||
const raw = sourceShape(schema);
|
||||
const keys = [];
|
||||
// `for...in` skips symbols, so a symbol in the mask would select nothing
|
||||
for (const key of Reflect.ownKeys(mask)) {
|
||||
if (!Object.getOwnPropertyDescriptor(raw, key)?.enumerable) {
|
||||
throw new Error(`Unrecognized key: "${String(key)}"`);
|
||||
}
|
||||
if (mask[key])
|
||||
keys.push(key);
|
||||
}
|
||||
return keys;
|
||||
}
|
||||
export function omit(schema, mask) {
|
||||
const currDef = schema._zod.def;
|
||||
const checks = currDef.checks;
|
||||
const hasChecks = checks && checks.length > 0;
|
||||
if (hasChecks) {
|
||||
throw new Error(".omit() cannot be used on object schemas containing refinements");
|
||||
}
|
||||
const omitted = new Set(maskedKeys(schema, mask));
|
||||
const newShape = {};
|
||||
mirrorShape(newShape, schema, Reflect.ownKeys(sourceShape(schema)).filter((key) => !omitted.has(key)));
|
||||
return clone(schema, mergeDefs(currDef, { shape: newShape, checks: [] }));
|
||||
}
|
||||
export function extend(schema, shape) {
|
||||
if (!isPlainObject(shape)) {
|
||||
throw new Error("Invalid input to extend: expected a plain object");
|
||||
}
|
||||
const checks = schema._zod.def.checks;
|
||||
const hasChecks = checks && checks.length > 0;
|
||||
if (hasChecks) {
|
||||
// Only throw if new shape overlaps with existing shape. Use getOwnPropertyDescriptor to check key existence without accessing values
|
||||
const existingShape = sourceShape(schema);
|
||||
for (const key of Reflect.ownKeys(shape)) {
|
||||
if (Object.getOwnPropertyDescriptor(existingShape, key) !== undefined) {
|
||||
throw new Error("Cannot overwrite keys on object schemas containing refinements. Use `.safeExtend()` instead.");
|
||||
}
|
||||
}
|
||||
}
|
||||
return clone(schema, mergeDefs(schema._zod.def, { shape: extended(schema, shape) }));
|
||||
}
|
||||
// the source's keys, then the caller's overlaid on top
|
||||
function extended(schema, shape) {
|
||||
const newShape = {};
|
||||
mirrorShape(newShape, schema, Reflect.ownKeys(sourceShape(schema)));
|
||||
mirrorProps(newShape, shape);
|
||||
return newShape;
|
||||
}
|
||||
export function safeExtend(schema, shape) {
|
||||
if (!isPlainObject(shape)) {
|
||||
throw new Error("Invalid input to safeExtend: expected a plain object");
|
||||
}
|
||||
return clone(schema, mergeDefs(schema._zod.def, { shape: extended(schema, shape) }));
|
||||
}
|
||||
export function merge(a, b) {
|
||||
if (!b?._zod?.def) {
|
||||
throw new Error("Invalid input to merge: expected an object schema. To merge a plain shape, use `.extend()`.");
|
||||
}
|
||||
if (a._zod.def.checks?.length) {
|
||||
throw new Error(".merge() cannot be used on object schemas containing refinements. Use .safeExtend() instead.");
|
||||
}
|
||||
const newShape = {};
|
||||
mirrorShape(newShape, a, Reflect.ownKeys(sourceShape(a)));
|
||||
mirrorShape(newShape, b, Reflect.ownKeys(sourceShape(b)));
|
||||
const def = mergeDefs(a._zod.def, {
|
||||
shape: newShape,
|
||||
get catchall() {
|
||||
return b._zod.def.catchall;
|
||||
},
|
||||
checks: b._zod.def.checks ?? [],
|
||||
});
|
||||
return clone(a, def);
|
||||
}
|
||||
export function partial(Class, schema, mask, name = "partial") {
|
||||
const currDef = schema._zod.def;
|
||||
const checks = currDef.checks;
|
||||
const hasChecks = checks && checks.length > 0;
|
||||
if (hasChecks) {
|
||||
throw new Error(`.${name}() cannot be used on object schemas containing refinements`);
|
||||
}
|
||||
const selected = mask ? new Set(maskedKeys(schema, mask)) : undefined;
|
||||
const newShape = {};
|
||||
mirrorShape(newShape, schema, Reflect.ownKeys(sourceShape(schema)), Class &&
|
||||
((value, key) => (selected && !selected.has(key) ? value : new Class({ type: "optional", innerType: value }))));
|
||||
return clone(schema, mergeDefs(schema._zod.def, { shape: newShape, checks: [] }));
|
||||
}
|
||||
export function required(Class, schema, mask) {
|
||||
const selected = mask ? new Set(maskedKeys(schema, mask)) : undefined;
|
||||
const newShape = {};
|
||||
mirrorShape(newShape, schema, Reflect.ownKeys(sourceShape(schema)), (value, key) =>
|
||||
// overwrite with non-optional
|
||||
selected && !selected.has(key) ? value : new Class({ type: "nonoptional", innerType: value }));
|
||||
return clone(schema, mergeDefs(schema._zod.def, { shape: newShape }));
|
||||
}
|
||||
// invalid_type | too_big | too_small | invalid_format | not_multiple_of | unrecognized_keys | invalid_union | invalid_key | invalid_element | invalid_value | custom
|
||||
export function aborted(x, startIndex = 0) {
|
||||
if (x.aborted === true)
|
||||
return true;
|
||||
for (let i = startIndex; i < x.issues.length; i++) {
|
||||
if (x.issues[i]?.continue !== true) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
// Checks for explicit abort (continue === false), as opposed to implicit abort (continue === undefined). Used to respect `abort: true` in .refine() even for checks that have a `when` function.
|
||||
export function explicitlyAborted(x, startIndex = 0) {
|
||||
if (x.aborted === true)
|
||||
return true;
|
||||
for (let i = startIndex; i < x.issues.length; i++) {
|
||||
if (x.issues[i]?.continue === false) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
export function prefixIssues(path, issues) {
|
||||
return issues.map((iss) => {
|
||||
var _a;
|
||||
(_a = iss).path ?? (_a.path = []);
|
||||
iss.path.unshift(path);
|
||||
return iss;
|
||||
});
|
||||
}
|
||||
export function unwrapMessage(message) {
|
||||
return typeof message === "string" ? message : message?.message;
|
||||
}
|
||||
/* A check holds no link back to the schema it is attached to — the same check instance is shared by every clone of that schema — so the owner is stamped onto the issues a check just raised, at the only point where both are in scope. Runs on the failure path only; `start` is the issue count from before the check ran. */
|
||||
/** The leading size checks of `defChecks` that set an upper bound, each paired with it. */
|
||||
export function sizeCaps(defChecks) {
|
||||
const caps = [];
|
||||
for (const ch of defChecks ?? []) {
|
||||
const d = ch._zod.def;
|
||||
// a later check may rewrite the value
|
||||
if (!/_(length|size)$|_equals$/.test(d.check))
|
||||
break;
|
||||
const max = d.maximum ?? d.length ?? d.size;
|
||||
if (max >= 0)
|
||||
caps.push([max, ch]);
|
||||
}
|
||||
return caps;
|
||||
}
|
||||
export function attachSchema(issues, start, inst) {
|
||||
var _a;
|
||||
for (let i = start; i < issues.length; i++) {
|
||||
(_a = issues[i]).schema ?? (_a.schema = inst);
|
||||
}
|
||||
}
|
||||
export function finalizeIssue(iss, ctx, config) {
|
||||
var _a;
|
||||
// A schema that raised an issue itself owns it outright, and outranks any stamp an enclosing check left in `attachSchema`. String formats and z.custom() are schema and check at once, so when they act as a check they defer to that stamp instead.
|
||||
const traits = iss.inst?._zod?.traits;
|
||||
if (traits?.has("$ZodType")) {
|
||||
if (traits.has("$ZodCheck"))
|
||||
(_a = iss).schema ?? (_a.schema = iss.inst);
|
||||
else
|
||||
iss.schema = iss.inst;
|
||||
}
|
||||
// Decreasing specificity, first map to return a message wins. `inst` is whatever raised the issue, so a check's own map outranks the owning schema's.
|
||||
const schemaError = iss.schema !== iss.inst ? iss.schema?._zod.def?.error : undefined;
|
||||
const message = iss.message
|
||||
? iss.message
|
||||
: (unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ??
|
||||
unwrapMessage(schemaError?.(iss)) ??
|
||||
unwrapMessage(ctx?.error?.(iss)) ??
|
||||
unwrapMessage(config.customError?.(iss)) ??
|
||||
unwrapMessage(config.localeError?.(iss)) ??
|
||||
"Invalid input");
|
||||
// an explicit own-key copy beats object rest with excluded keys, which v8 routes through a generic runtime call; Object.keys rather than for-in so an issue pushed with a prototype does not leak inherited keys, and an own __proto__ key is dropped rather than assigned through the setter
|
||||
const full = {};
|
||||
for (const k of Object.keys(iss)) {
|
||||
if (k === "inst" || k === "schema" || k === "continue" || k === "input" || k === "__proto__")
|
||||
continue;
|
||||
full[k] = iss[k];
|
||||
}
|
||||
full.path ?? (full.path = []);
|
||||
full.message = message;
|
||||
if (ctx?.reportInput) {
|
||||
full.input = iss.input;
|
||||
}
|
||||
return full;
|
||||
}
|
||||
export function getSizableOrigin(input) {
|
||||
if (input instanceof Set)
|
||||
return "set";
|
||||
if (input instanceof Map)
|
||||
return "map";
|
||||
// @ts-ignore
|
||||
if (input instanceof File)
|
||||
return "file";
|
||||
return "unknown";
|
||||
}
|
||||
const highSurrogate = /[\uD800-\uDBFF]/;
|
||||
// Code points in `str`: a surrogate pair counts once, a lone surrogate as itself. Hand-rolled because the string iterator allocates and runs ~250x slower on this path; the regex probe exits ~50x quicker for a string with no astral characters.
|
||||
export function codePointLength(str) {
|
||||
const units = str.length;
|
||||
if (!highSurrogate.test(str))
|
||||
return units;
|
||||
let count = units;
|
||||
for (let i = 0; i < units - 1; i++) {
|
||||
if ((str.charCodeAt(i) & 0xfc00) === 0xd800 && (str.charCodeAt(i + 1) & 0xfc00) === 0xdc00) {
|
||||
count--;
|
||||
i++;
|
||||
}
|
||||
}
|
||||
return count;
|
||||
}
|
||||
export function getLengthableOrigin(input) {
|
||||
if (Array.isArray(input))
|
||||
return "array";
|
||||
if (typeof input === "string")
|
||||
return "string";
|
||||
return "unknown";
|
||||
}
|
||||
export function parsedType(data) {
|
||||
const t = typeof data;
|
||||
switch (t) {
|
||||
case "number": {
|
||||
return Number.isNaN(data) ? "nan" : "number";
|
||||
}
|
||||
case "object": {
|
||||
if (data === null) {
|
||||
return "null";
|
||||
}
|
||||
if (Array.isArray(data)) {
|
||||
return "array";
|
||||
}
|
||||
const obj = data;
|
||||
if (obj && Object.getPrototypeOf(obj) !== Object.prototype && "constructor" in obj && obj.constructor) {
|
||||
return obj.constructor.name;
|
||||
}
|
||||
}
|
||||
}
|
||||
return t;
|
||||
}
|
||||
export function issue(...args) {
|
||||
const [iss, input, inst] = args;
|
||||
if (typeof iss === "string") {
|
||||
return {
|
||||
message: iss,
|
||||
code: "custom",
|
||||
input,
|
||||
inst,
|
||||
};
|
||||
}
|
||||
return { ...iss };
|
||||
}
|
||||
export function cleanEnum(obj) {
|
||||
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]);
|
||||
}
|
||||
// Codec utility functions
|
||||
export function base64ToUint8Array(base64) {
|
||||
const binaryString = atob(base64);
|
||||
const bytes = new Uint8Array(binaryString.length);
|
||||
for (let i = 0; i < binaryString.length; i++) {
|
||||
bytes[i] = binaryString.charCodeAt(i);
|
||||
}
|
||||
return bytes;
|
||||
}
|
||||
export function uint8ArrayToBase64(bytes) {
|
||||
let binaryString = "";
|
||||
for (let i = 0; i < bytes.length; i++) {
|
||||
binaryString += String.fromCharCode(bytes[i]);
|
||||
}
|
||||
return btoa(binaryString);
|
||||
}
|
||||
export function base64urlToUint8Array(base64url) {
|
||||
const base64 = base64url.replace(/-/g, "+").replace(/_/g, "/");
|
||||
const padding = "=".repeat((4 - (base64.length % 4)) % 4);
|
||||
return base64ToUint8Array(base64 + padding);
|
||||
}
|
||||
export function uint8ArrayToBase64url(bytes) {
|
||||
return uint8ArrayToBase64(bytes).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
|
||||
}
|
||||
export function hexToUint8Array(hex) {
|
||||
const cleanHex = hex.replace(/^0x/, "");
|
||||
if (cleanHex.length % 2 !== 0) {
|
||||
throw new Error("Invalid hex string length");
|
||||
}
|
||||
const bytes = new Uint8Array(cleanHex.length / 2);
|
||||
for (let i = 0; i < cleanHex.length; i += 2) {
|
||||
bytes[i / 2] = Number.parseInt(cleanHex.slice(i, i + 2), 16);
|
||||
}
|
||||
return bytes;
|
||||
}
|
||||
export function uint8ArrayToHex(bytes) {
|
||||
return Array.from(bytes)
|
||||
.map((b) => b.toString(16).padStart(2, "0"))
|
||||
.join("");
|
||||
}
|
||||
// instanceof
|
||||
export class Class {
|
||||
constructor(..._args) { }
|
||||
}
|
||||
////////// PROTOTYPE INSTALLERS //////////
|
||||
//
|
||||
// Members live on the prototype and materialize per instance on first read, which keeps own-property count under the step where V8 stops using inline slots. Changing anything here means re-measuring runtime, memory and bundle size together — see "The three axes" in AGENTS.md.
|
||||
/**
|
||||
* Installs a trait's members on its prototype. Each value builds that member for the instance on first read; the built value shadows the accessor as an own property, so a detached `const { parse } = schema` keeps working.
|
||||
*
|
||||
* Call this from a `proto` initializer, which runs once per prototype — never per instance.
|
||||
*/
|
||||
export function members(proto, table) {
|
||||
for (const key in table) {
|
||||
const desc = Object.getOwnPropertyDescriptor(table, key);
|
||||
// a getter installs as written, so it stays live: `description` reads through to the registry on every access. not enumerable: an object literal's is, and a prototype member never was
|
||||
if (desc.get)
|
||||
Object.defineProperty(proto, key, { ...desc, enumerable: false });
|
||||
// a method materializes bound on first read, which is what keeps a detached member working: `const opt = schema.optional; opt()`
|
||||
else
|
||||
defineBound(proto, key, desc.value);
|
||||
}
|
||||
}
|
||||
/** Shadows a prototype member with an own value, so a getter that builds from the instance runs once. */
|
||||
export function own(inst, key, value, enumerable = true) {
|
||||
Object.defineProperty(inst, key, { configurable: true, writable: true, enumerable, value });
|
||||
return value;
|
||||
}
|
||||
/** Like {@link own}, for a member that was never an own data property and has to stay out of `Object.keys`. */
|
||||
export function hide(inst, key, value) {
|
||||
return own(inst, key, value, false);
|
||||
}
|
||||
/** Adds members a table derives from the instance: each builds on first read and shadows as own data, and assignment shadows the same way, as when these were own properties. */
|
||||
export /*@__NO_SIDE_EFFECTS__*/ function derived(computes, table) {
|
||||
for (const key in computes) {
|
||||
const compute = computes[key];
|
||||
// an object literal's accessor is configurable and enumerable, and `members` copies the descriptor as written
|
||||
Object.defineProperty(table, key, {
|
||||
configurable: true,
|
||||
enumerable: true,
|
||||
get() {
|
||||
return own(this, key, compute(this));
|
||||
},
|
||||
set(value) {
|
||||
own(this, key, value);
|
||||
},
|
||||
});
|
||||
}
|
||||
return table;
|
||||
}
|
||||
function defineBound(proto, key, fn) {
|
||||
Object.defineProperty(proto, key, {
|
||||
configurable: true,
|
||||
get() {
|
||||
// vitest's spyOn calls a prototype getter bare to find the function it wraps, so a nullish receiver answers the raw method
|
||||
return this == null ? fn : own(this, key, fn.bind(this));
|
||||
},
|
||||
set(value) {
|
||||
own(this, key, value);
|
||||
},
|
||||
});
|
||||
}
|
||||
/** Returns the prototype to install on, or `undefined` if this group is already installed on it. */
|
||||
function claim(inst, sentinel) {
|
||||
const proto = Object.getPrototypeOf(inst);
|
||||
// Runs on every construction, so `in` rather than the costlier `hasOwnProperty.call`. Sentinels are keys the group itself defines.
|
||||
return sentinel in proto ? undefined : proto;
|
||||
}
|
||||
// The internals whose init chain is installing. A second call for the same one is a derived constructor overriding its base, so it must not construct another schema in between or the override is dropped.
|
||||
let installing;
|
||||
// Set while a getter is running, so a value that resolved through a recursion break is not memoized. One shared descriptor shadows the key for the duration, which costs no per-key allocation.
|
||||
let broke = false;
|
||||
const breaker = {
|
||||
configurable: true,
|
||||
get() {
|
||||
broke = true;
|
||||
return undefined;
|
||||
},
|
||||
};
|
||||
/**
|
||||
* Installs a lazily-derived internal on the `_zod` prototype of `inst`'s
|
||||
* constructor, computed from the internals object itself and cached there on
|
||||
* first read. One accessor per constructor rather than one per instance.
|
||||
*/
|
||||
export function defineLazyInternal(inst, key, compute) {
|
||||
const proto = Object.getPrototypeOf(inst._zod);
|
||||
if (key in proto && installing !== inst._zod) {
|
||||
// A repeat construction: everything is installed already. Cleared here so the reference is not held past the first construction of every type.
|
||||
installing = undefined;
|
||||
return;
|
||||
}
|
||||
installing = inst._zod;
|
||||
Object.defineProperty(proto, key, {
|
||||
configurable: true,
|
||||
get() {
|
||||
// Shadowed before computing so a re-entrant read from a recursive schema resolves to undefined instead of running the getter again.
|
||||
Object.defineProperty(this, key, breaker);
|
||||
const outer = broke;
|
||||
broke = false;
|
||||
try {
|
||||
const value = compute(this);
|
||||
// A result that resolved through a recursion break is recomputed once the graph is complete; everything else memoizes, undefined included.
|
||||
if (broke)
|
||||
delete this[key];
|
||||
else
|
||||
Object.defineProperty(this, key, { configurable: true, writable: true, value });
|
||||
broke = broke || outer;
|
||||
return value;
|
||||
}
|
||||
catch (err) {
|
||||
// A compute that threw memoizes nothing, so a later read runs it again and fails the same way. The shadow goes with it, since leaving it installed would answer undefined for every later read.
|
||||
delete this[key];
|
||||
broke = broke || outer;
|
||||
throw err;
|
||||
}
|
||||
},
|
||||
set(value) {
|
||||
Object.defineProperty(this, key, { configurable: true, writable: true, value });
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Installs `key` on `inst`'s prototype, computed by `make` on first read and cached there as an own
|
||||
* data property. One accessor per constructor rather than one per instance, because an own accessor
|
||||
* puts every instance after the first into v8 dictionary mode. The key doubles as the sentinel.
|
||||
*/
|
||||
export function installLazyProp(inst, key, make, enumerable) {
|
||||
const proto = claim(inst, key);
|
||||
if (!proto)
|
||||
return;
|
||||
Object.defineProperty(proto, key, {
|
||||
configurable: true,
|
||||
get() {
|
||||
// Shadowed before computing, so a re-entrant read from a self-referential shape resolves to undefined instead of running the getter again. A data property rather than an accessor: an own accessor is the dictionary-mode transition this exists to avoid.
|
||||
const desc = { configurable: true, writable: true, enumerable, value: undefined };
|
||||
Object.defineProperty(this, key, desc);
|
||||
// a compute that throws leaves the shadow behind, so later reads answer undefined instead of re-throwing; `defineLazy` did the same, and `defineLazyInternal`'s delete-on-catch would cost bytes in every bundle for a case only a throwing user getter reaches
|
||||
desc.value = make(this);
|
||||
Object.defineProperty(this, key, desc);
|
||||
return desc.value;
|
||||
},
|
||||
set(value) {
|
||||
Object.defineProperty(this, key, { configurable: true, writable: true, enumerable, value });
|
||||
},
|
||||
});
|
||||
}
|
||||
/** Marks the thunk `_catch` synthesises for a constant catch value. `Function.length` cannot tell that thunk from a user callback — rest and defaulted parameters both report arity 0 — and a user callback reads `ctx.error`, whose issues only finalize correctly against the caller's per-parse error map. Provenance can say what arity cannot. A plain string key rather than `Symbol.for`, whose call at module scope no bundler can prove pure — the same shape that anchored `urlCanParse` into every build. */
|
||||
export const CONSTANT_CATCH = "~constantCatch";
|
||||
/** Wraps a constant catch value in a thunk tagged with {@link CONSTANT_CATCH}. */
|
||||
export function constantCatch(value) {
|
||||
const fn = () => value;
|
||||
fn[CONSTANT_CATCH] = true;
|
||||
return fn;
|
||||
}
|
||||
+27
@@ -0,0 +1,27 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.version = void 0;
|
||||
exports.version = {
|
||||
major: 4,
|
||||
minor: 6,
|
||||
patch: 7,
|
||||
};
|
||||
|
||||
// seal-cjs-exports
|
||||
(function () {
|
||||
var keys = Object.getOwnPropertyNames(exports);
|
||||
for (var i = 0; i < keys.length; i++) {
|
||||
var desc = Object.getOwnPropertyDescriptor(exports, keys[i]);
|
||||
if (!desc || !desc.get || !desc.configurable) continue;
|
||||
var value;
|
||||
try {
|
||||
value = desc.get();
|
||||
} catch (e) {
|
||||
continue;
|
||||
}
|
||||
// a circular require may not have settled this one yet, so leave it live
|
||||
if (value === undefined) continue;
|
||||
Object.defineProperty(exports, keys[i], { value: value, writable: false, enumerable: desc.enumerable, configurable: false });
|
||||
}
|
||||
Object.freeze(exports);
|
||||
})();
|
||||
+5
@@ -0,0 +1,5 @@
|
||||
export declare const version: {
|
||||
readonly major: 4;
|
||||
readonly minor: 6;
|
||||
readonly patch: number;
|
||||
};
|
||||
+5
@@ -0,0 +1,5 @@
|
||||
export declare const version: {
|
||||
readonly major: 4;
|
||||
readonly minor: 6;
|
||||
readonly patch: number;
|
||||
};
|
||||
+5
@@ -0,0 +1,5 @@
|
||||
export const version = {
|
||||
major: 4,
|
||||
minor: 6,
|
||||
patch: 7,
|
||||
};
|
||||
+214
@@ -0,0 +1,214 @@
|
||||
"use strict";
|
||||
// Traversal pattern adapted from Jaen's v3 `mapOnSchema` (Apache-2.0): https://gist.github.com/jaens/7e15ae1984bb338c86eb5e452dee3010
|
||||
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.visit = visit;
|
||||
const schemas = __importStar(require("./schemas.cjs"));
|
||||
const util_js_1 = require("./util.cjs");
|
||||
const RESOLVING = Symbol("z.visit/resolving");
|
||||
function visit(schema, fnOrHandlers) {
|
||||
const fn = typeof fnOrHandlers === "function"
|
||||
? fnOrHandlers
|
||||
: (node, rewritten) => {
|
||||
// A union of handlers isn't callable with one argument; handler `K` only ever sees kind `K`.
|
||||
const h = fnOrHandlers[node._zod.def.type];
|
||||
return h ? h(node, rewritten) : node;
|
||||
};
|
||||
const cache = new Map();
|
||||
function run(s) {
|
||||
const cached = cache.get(s);
|
||||
if (cached === RESOLVING) {
|
||||
// Non-lazy cycle. Defer to parse time, when the cache holds the finished node.
|
||||
return new schemas.$ZodLazy({
|
||||
type: "lazy",
|
||||
getter: () => cache.get(s),
|
||||
});
|
||||
}
|
||||
if (cached !== undefined)
|
||||
return cached;
|
||||
cache.set(s, RESOLVING);
|
||||
const inner = mapInner(s);
|
||||
const mapped = fn(inner, inner !== s);
|
||||
cache.set(s, mapped);
|
||||
return mapped;
|
||||
}
|
||||
function mapInner(s) {
|
||||
const def = s._zod.def;
|
||||
const kind = def.type;
|
||||
switch (kind) {
|
||||
case "object": {
|
||||
const oldShape = def.shape;
|
||||
const keys = Object.keys(oldShape);
|
||||
let changed = false;
|
||||
const newShape = {};
|
||||
for (const k of keys) {
|
||||
const mapped = run(oldShape[k]);
|
||||
if (mapped !== oldShape[k])
|
||||
changed = true;
|
||||
newShape[k] = mapped;
|
||||
}
|
||||
let newCatchall = def.catchall;
|
||||
if (def.catchall) {
|
||||
newCatchall = run(def.catchall);
|
||||
if (newCatchall !== def.catchall)
|
||||
changed = true;
|
||||
}
|
||||
return changed ? (0, util_js_1.clone)(s, { ...def, shape: newShape, catchall: newCatchall }) : s;
|
||||
}
|
||||
case "array": {
|
||||
const mapped = run(def.element);
|
||||
return mapped === def.element ? s : (0, util_js_1.clone)(s, { ...def, element: mapped });
|
||||
}
|
||||
case "tuple": {
|
||||
const oldItems = def.items;
|
||||
let changed = false;
|
||||
const newItems = [];
|
||||
for (const item of oldItems) {
|
||||
const mapped = run(item);
|
||||
if (mapped !== item)
|
||||
changed = true;
|
||||
newItems.push(mapped);
|
||||
}
|
||||
let newRest = def.rest;
|
||||
if (def.rest) {
|
||||
newRest = run(def.rest);
|
||||
if (newRest !== def.rest)
|
||||
changed = true;
|
||||
}
|
||||
return changed ? (0, util_js_1.clone)(s, { ...def, items: newItems, rest: newRest }) : s;
|
||||
}
|
||||
case "record":
|
||||
case "map": {
|
||||
const newKey = run(def.keyType);
|
||||
const newVal = run(def.valueType);
|
||||
return newKey === def.keyType && newVal === def.valueType
|
||||
? s
|
||||
: (0, util_js_1.clone)(s, { ...def, keyType: newKey, valueType: newVal });
|
||||
}
|
||||
case "set": {
|
||||
const newVal = run(def.valueType);
|
||||
return newVal === def.valueType ? s : (0, util_js_1.clone)(s, { ...def, valueType: newVal });
|
||||
}
|
||||
case "union": {
|
||||
const oldOptions = def.options;
|
||||
let changed = false;
|
||||
const newOptions = [];
|
||||
for (const opt of oldOptions) {
|
||||
const mapped = run(opt);
|
||||
if (mapped !== opt)
|
||||
changed = true;
|
||||
newOptions.push(mapped);
|
||||
}
|
||||
return changed ? (0, util_js_1.clone)(s, { ...def, options: newOptions }) : s;
|
||||
}
|
||||
case "intersection": {
|
||||
const newLeft = run(def.left);
|
||||
const newRight = run(def.right);
|
||||
return newLeft === def.left && newRight === def.right
|
||||
? s
|
||||
: (0, util_js_1.clone)(s, { ...def, left: newLeft, right: newRight });
|
||||
}
|
||||
case "optional":
|
||||
case "nullable":
|
||||
case "default":
|
||||
case "prefault":
|
||||
case "catch":
|
||||
case "readonly":
|
||||
case "nonoptional":
|
||||
case "promise":
|
||||
case "success": {
|
||||
const newInner = run(def.innerType);
|
||||
return newInner === def.innerType ? s : (0, util_js_1.clone)(s, { ...def, innerType: newInner });
|
||||
}
|
||||
case "pipe": {
|
||||
const newIn = run(def.in);
|
||||
const newOut = run(def.out);
|
||||
return newIn === def.in && newOut === def.out ? s : (0, util_js_1.clone)(s, { ...def, in: newIn, out: newOut });
|
||||
}
|
||||
case "function": {
|
||||
const newInput = run(def.input);
|
||||
const newOutput = run(def.output);
|
||||
return newInput === def.input && newOutput === def.output
|
||||
? s
|
||||
: (0, util_js_1.clone)(s, { ...def, input: newInput, output: newOutput });
|
||||
}
|
||||
case "lazy": {
|
||||
// Invoking the getter here would trip the cycle check, so lazy nodes always re-clone.
|
||||
const original = def.getter;
|
||||
// Drop the memo, or it shadows the new getter forever.
|
||||
const { _cachedInner, ...rest } = def;
|
||||
return (0, util_js_1.clone)(s, { ...rest, getter: () => run(original()) });
|
||||
}
|
||||
// A leaf by choice: `parts` are regex fragments, not data positions.
|
||||
case "template_literal":
|
||||
// Leaves.
|
||||
case "string":
|
||||
case "number":
|
||||
case "int":
|
||||
case "boolean":
|
||||
case "bigint":
|
||||
case "symbol":
|
||||
case "undefined":
|
||||
case "null":
|
||||
case "void":
|
||||
case "never":
|
||||
case "any":
|
||||
case "unknown":
|
||||
case "date":
|
||||
case "nan":
|
||||
case "enum":
|
||||
case "literal":
|
||||
case "file":
|
||||
case "transform":
|
||||
case "custom":
|
||||
return s;
|
||||
default: {
|
||||
// A new built-in kind becomes a compile error here; unknown user kinds fall through.
|
||||
kind;
|
||||
return s;
|
||||
}
|
||||
}
|
||||
}
|
||||
return run(schema);
|
||||
}
|
||||
|
||||
// seal-cjs-exports
|
||||
(function () {
|
||||
var keys = Object.getOwnPropertyNames(exports);
|
||||
for (var i = 0; i < keys.length; i++) {
|
||||
var desc = Object.getOwnPropertyDescriptor(exports, keys[i]);
|
||||
if (!desc || !desc.get || !desc.configurable) continue;
|
||||
var value;
|
||||
try {
|
||||
value = desc.get();
|
||||
} catch (e) {
|
||||
continue;
|
||||
}
|
||||
// a circular require may not have settled this one yet, so leave it live
|
||||
if (value === undefined) continue;
|
||||
Object.defineProperty(exports, keys[i], { value: value, writable: false, enumerable: desc.enumerable, configurable: false });
|
||||
}
|
||||
Object.freeze(exports);
|
||||
})();
|
||||
+30
@@ -0,0 +1,30 @@
|
||||
import * as schemas from "./schemas.cjs";
|
||||
type AnyZod = schemas.$ZodType;
|
||||
type Kind = schemas.$ZodTypeDef["type"];
|
||||
/** The concrete schema class for a `def.type`, or `$ZodType` for kinds with no dedicated class. */
|
||||
type SchemaOfKind<K extends Kind> = [Extract<schemas.$ZodTypes, {
|
||||
_zod: {
|
||||
def: {
|
||||
type: K;
|
||||
};
|
||||
};
|
||||
}>] extends [never] ? AnyZod : Extract<schemas.$ZodTypes, {
|
||||
_zod: {
|
||||
def: {
|
||||
type: K;
|
||||
};
|
||||
};
|
||||
}>;
|
||||
export type VisitFn = (node: AnyZod, rewritten: boolean) => AnyZod;
|
||||
export type VisitHandlers = {
|
||||
[K in Kind]?: (node: SchemaOfKind<K>, rewritten: boolean) => AnyZod;
|
||||
};
|
||||
/**
|
||||
* @internal Bottom-up rewrite of a schema tree. Unhandled kinds and unchanged branches keep their
|
||||
* identity. Returns `$ZodType`: a visitor can swap in a schema of any type, so callers declare
|
||||
* their own return type. `rewritten` tells a handler whether the traversal replaced anything
|
||||
* below the node it is looking at.
|
||||
*/
|
||||
export declare function visit(schema: schemas.SomeType, fn: VisitFn): AnyZod;
|
||||
export declare function visit(schema: schemas.SomeType, handlers: VisitHandlers): AnyZod;
|
||||
export {};
|
||||
+30
@@ -0,0 +1,30 @@
|
||||
import * as schemas from "./schemas.js";
|
||||
type AnyZod = schemas.$ZodType;
|
||||
type Kind = schemas.$ZodTypeDef["type"];
|
||||
/** The concrete schema class for a `def.type`, or `$ZodType` for kinds with no dedicated class. */
|
||||
type SchemaOfKind<K extends Kind> = [Extract<schemas.$ZodTypes, {
|
||||
_zod: {
|
||||
def: {
|
||||
type: K;
|
||||
};
|
||||
};
|
||||
}>] extends [never] ? AnyZod : Extract<schemas.$ZodTypes, {
|
||||
_zod: {
|
||||
def: {
|
||||
type: K;
|
||||
};
|
||||
};
|
||||
}>;
|
||||
export type VisitFn = (node: AnyZod, rewritten: boolean) => AnyZod;
|
||||
export type VisitHandlers = {
|
||||
[K in Kind]?: (node: SchemaOfKind<K>, rewritten: boolean) => AnyZod;
|
||||
};
|
||||
/**
|
||||
* @internal Bottom-up rewrite of a schema tree. Unhandled kinds and unchanged branches keep their
|
||||
* identity. Returns `$ZodType`: a visitor can swap in a schema of any type, so callers declare
|
||||
* their own return type. `rewritten` tells a handler whether the traversal replaced anything
|
||||
* below the node it is looking at.
|
||||
*/
|
||||
export declare function visit(schema: schemas.SomeType, fn: VisitFn): AnyZod;
|
||||
export declare function visit(schema: schemas.SomeType, handlers: VisitHandlers): AnyZod;
|
||||
export {};
|
||||
+169
@@ -0,0 +1,169 @@
|
||||
// Traversal pattern adapted from Jaen's v3 `mapOnSchema` (Apache-2.0): https://gist.github.com/jaens/7e15ae1984bb338c86eb5e452dee3010
|
||||
import * as schemas from "./schemas.js";
|
||||
import { clone } from "./util.js";
|
||||
const RESOLVING = Symbol("z.visit/resolving");
|
||||
export function visit(schema, fnOrHandlers) {
|
||||
const fn = typeof fnOrHandlers === "function"
|
||||
? fnOrHandlers
|
||||
: (node, rewritten) => {
|
||||
// A union of handlers isn't callable with one argument; handler `K` only ever sees kind `K`.
|
||||
const h = fnOrHandlers[node._zod.def.type];
|
||||
return h ? h(node, rewritten) : node;
|
||||
};
|
||||
const cache = new Map();
|
||||
function run(s) {
|
||||
const cached = cache.get(s);
|
||||
if (cached === RESOLVING) {
|
||||
// Non-lazy cycle. Defer to parse time, when the cache holds the finished node.
|
||||
return new schemas.$ZodLazy({
|
||||
type: "lazy",
|
||||
getter: () => cache.get(s),
|
||||
});
|
||||
}
|
||||
if (cached !== undefined)
|
||||
return cached;
|
||||
cache.set(s, RESOLVING);
|
||||
const inner = mapInner(s);
|
||||
const mapped = fn(inner, inner !== s);
|
||||
cache.set(s, mapped);
|
||||
return mapped;
|
||||
}
|
||||
function mapInner(s) {
|
||||
const def = s._zod.def;
|
||||
const kind = def.type;
|
||||
switch (kind) {
|
||||
case "object": {
|
||||
const oldShape = def.shape;
|
||||
const keys = Object.keys(oldShape);
|
||||
let changed = false;
|
||||
const newShape = {};
|
||||
for (const k of keys) {
|
||||
const mapped = run(oldShape[k]);
|
||||
if (mapped !== oldShape[k])
|
||||
changed = true;
|
||||
newShape[k] = mapped;
|
||||
}
|
||||
let newCatchall = def.catchall;
|
||||
if (def.catchall) {
|
||||
newCatchall = run(def.catchall);
|
||||
if (newCatchall !== def.catchall)
|
||||
changed = true;
|
||||
}
|
||||
return changed ? clone(s, { ...def, shape: newShape, catchall: newCatchall }) : s;
|
||||
}
|
||||
case "array": {
|
||||
const mapped = run(def.element);
|
||||
return mapped === def.element ? s : clone(s, { ...def, element: mapped });
|
||||
}
|
||||
case "tuple": {
|
||||
const oldItems = def.items;
|
||||
let changed = false;
|
||||
const newItems = [];
|
||||
for (const item of oldItems) {
|
||||
const mapped = run(item);
|
||||
if (mapped !== item)
|
||||
changed = true;
|
||||
newItems.push(mapped);
|
||||
}
|
||||
let newRest = def.rest;
|
||||
if (def.rest) {
|
||||
newRest = run(def.rest);
|
||||
if (newRest !== def.rest)
|
||||
changed = true;
|
||||
}
|
||||
return changed ? clone(s, { ...def, items: newItems, rest: newRest }) : s;
|
||||
}
|
||||
case "record":
|
||||
case "map": {
|
||||
const newKey = run(def.keyType);
|
||||
const newVal = run(def.valueType);
|
||||
return newKey === def.keyType && newVal === def.valueType
|
||||
? s
|
||||
: clone(s, { ...def, keyType: newKey, valueType: newVal });
|
||||
}
|
||||
case "set": {
|
||||
const newVal = run(def.valueType);
|
||||
return newVal === def.valueType ? s : clone(s, { ...def, valueType: newVal });
|
||||
}
|
||||
case "union": {
|
||||
const oldOptions = def.options;
|
||||
let changed = false;
|
||||
const newOptions = [];
|
||||
for (const opt of oldOptions) {
|
||||
const mapped = run(opt);
|
||||
if (mapped !== opt)
|
||||
changed = true;
|
||||
newOptions.push(mapped);
|
||||
}
|
||||
return changed ? clone(s, { ...def, options: newOptions }) : s;
|
||||
}
|
||||
case "intersection": {
|
||||
const newLeft = run(def.left);
|
||||
const newRight = run(def.right);
|
||||
return newLeft === def.left && newRight === def.right
|
||||
? s
|
||||
: clone(s, { ...def, left: newLeft, right: newRight });
|
||||
}
|
||||
case "optional":
|
||||
case "nullable":
|
||||
case "default":
|
||||
case "prefault":
|
||||
case "catch":
|
||||
case "readonly":
|
||||
case "nonoptional":
|
||||
case "promise":
|
||||
case "success": {
|
||||
const newInner = run(def.innerType);
|
||||
return newInner === def.innerType ? s : clone(s, { ...def, innerType: newInner });
|
||||
}
|
||||
case "pipe": {
|
||||
const newIn = run(def.in);
|
||||
const newOut = run(def.out);
|
||||
return newIn === def.in && newOut === def.out ? s : clone(s, { ...def, in: newIn, out: newOut });
|
||||
}
|
||||
case "function": {
|
||||
const newInput = run(def.input);
|
||||
const newOutput = run(def.output);
|
||||
return newInput === def.input && newOutput === def.output
|
||||
? s
|
||||
: clone(s, { ...def, input: newInput, output: newOutput });
|
||||
}
|
||||
case "lazy": {
|
||||
// Invoking the getter here would trip the cycle check, so lazy nodes always re-clone.
|
||||
const original = def.getter;
|
||||
// Drop the memo, or it shadows the new getter forever.
|
||||
const { _cachedInner, ...rest } = def;
|
||||
return clone(s, { ...rest, getter: () => run(original()) });
|
||||
}
|
||||
// A leaf by choice: `parts` are regex fragments, not data positions.
|
||||
case "template_literal":
|
||||
// Leaves.
|
||||
case "string":
|
||||
case "number":
|
||||
case "int":
|
||||
case "boolean":
|
||||
case "bigint":
|
||||
case "symbol":
|
||||
case "undefined":
|
||||
case "null":
|
||||
case "void":
|
||||
case "never":
|
||||
case "any":
|
||||
case "unknown":
|
||||
case "date":
|
||||
case "nan":
|
||||
case "enum":
|
||||
case "literal":
|
||||
case "file":
|
||||
case "transform":
|
||||
case "custom":
|
||||
return s;
|
||||
default: {
|
||||
// A new built-in kind becomes a compile error here; unknown user kinds fall through.
|
||||
kind;
|
||||
return s;
|
||||
}
|
||||
}
|
||||
}
|
||||
return run(schema);
|
||||
}
|
||||
Reference in New Issue
Block a user