1065 lines
27 KiB
JavaScript
1065 lines
27 KiB
JavaScript
"use strict";
|
|
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
|
|
if (k2 === undefined) k2 = k;
|
|
var desc = Object.getOwnPropertyDescriptor(m, k);
|
|
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
|
|
desc = { enumerable: true, get: function() { return m[k]; } };
|
|
}
|
|
Object.defineProperty(o, k2, desc);
|
|
}) : (function(o, m, k, k2) {
|
|
if (k2 === undefined) k2 = k;
|
|
o[k2] = m[k];
|
|
}));
|
|
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
|
|
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
|
}) : function(o, v) {
|
|
o["default"] = v;
|
|
});
|
|
var __importStar = (this && this.__importStar) || function (mod) {
|
|
if (mod && mod.__esModule) return mod;
|
|
var result = {};
|
|
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
|
|
__setModuleDefault(result, mod);
|
|
return result;
|
|
};
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.TimePrecision = void 0;
|
|
exports._string = _string;
|
|
exports._coercedString = _coercedString;
|
|
exports._email = _email;
|
|
exports._guid = _guid;
|
|
exports._uuid = _uuid;
|
|
exports._uuidv4 = _uuidv4;
|
|
exports._uuidv6 = _uuidv6;
|
|
exports._uuidv7 = _uuidv7;
|
|
exports._url = _url;
|
|
exports._emoji = _emoji;
|
|
exports._nanoid = _nanoid;
|
|
exports._cuid = _cuid;
|
|
exports._cuid2 = _cuid2;
|
|
exports._ulid = _ulid;
|
|
exports._xid = _xid;
|
|
exports._ksuid = _ksuid;
|
|
exports._ipv4 = _ipv4;
|
|
exports._ipv6 = _ipv6;
|
|
exports._cidrv4 = _cidrv4;
|
|
exports._cidrv6 = _cidrv6;
|
|
exports._base64 = _base64;
|
|
exports._base64url = _base64url;
|
|
exports._e164 = _e164;
|
|
exports._jwt = _jwt;
|
|
exports._isoDateTime = _isoDateTime;
|
|
exports._isoDate = _isoDate;
|
|
exports._isoTime = _isoTime;
|
|
exports._isoDuration = _isoDuration;
|
|
exports._number = _number;
|
|
exports._coercedNumber = _coercedNumber;
|
|
exports._int = _int;
|
|
exports._float32 = _float32;
|
|
exports._float64 = _float64;
|
|
exports._int32 = _int32;
|
|
exports._uint32 = _uint32;
|
|
exports._boolean = _boolean;
|
|
exports._coercedBoolean = _coercedBoolean;
|
|
exports._bigint = _bigint;
|
|
exports._coercedBigint = _coercedBigint;
|
|
exports._int64 = _int64;
|
|
exports._uint64 = _uint64;
|
|
exports._symbol = _symbol;
|
|
exports._undefined = _undefined;
|
|
exports._null = _null;
|
|
exports._any = _any;
|
|
exports._unknown = _unknown;
|
|
exports._never = _never;
|
|
exports._void = _void;
|
|
exports._date = _date;
|
|
exports._coercedDate = _coercedDate;
|
|
exports._nan = _nan;
|
|
exports._lt = _lt;
|
|
exports._lte = _lte;
|
|
exports._max = _lte;
|
|
exports._lte = _lte;
|
|
exports._max = _lte;
|
|
exports._gt = _gt;
|
|
exports._gte = _gte;
|
|
exports._min = _gte;
|
|
exports._gte = _gte;
|
|
exports._min = _gte;
|
|
exports._positive = _positive;
|
|
exports._negative = _negative;
|
|
exports._nonpositive = _nonpositive;
|
|
exports._nonnegative = _nonnegative;
|
|
exports._multipleOf = _multipleOf;
|
|
exports._maxSize = _maxSize;
|
|
exports._minSize = _minSize;
|
|
exports._size = _size;
|
|
exports._maxLength = _maxLength;
|
|
exports._minLength = _minLength;
|
|
exports._length = _length;
|
|
exports._regex = _regex;
|
|
exports._lowercase = _lowercase;
|
|
exports._uppercase = _uppercase;
|
|
exports._includes = _includes;
|
|
exports._startsWith = _startsWith;
|
|
exports._endsWith = _endsWith;
|
|
exports._property = _property;
|
|
exports._mime = _mime;
|
|
exports._overwrite = _overwrite;
|
|
exports._normalize = _normalize;
|
|
exports._trim = _trim;
|
|
exports._toLowerCase = _toLowerCase;
|
|
exports._toUpperCase = _toUpperCase;
|
|
exports._array = _array;
|
|
exports._union = _union;
|
|
exports._discriminatedUnion = _discriminatedUnion;
|
|
exports._intersection = _intersection;
|
|
exports._tuple = _tuple;
|
|
exports._record = _record;
|
|
exports._map = _map;
|
|
exports._set = _set;
|
|
exports._enum = _enum;
|
|
exports._nativeEnum = _nativeEnum;
|
|
exports._literal = _literal;
|
|
exports._file = _file;
|
|
exports._transform = _transform;
|
|
exports._optional = _optional;
|
|
exports._nullable = _nullable;
|
|
exports._default = _default;
|
|
exports._nonoptional = _nonoptional;
|
|
exports._success = _success;
|
|
exports._catch = _catch;
|
|
exports._pipe = _pipe;
|
|
exports._readonly = _readonly;
|
|
exports._templateLiteral = _templateLiteral;
|
|
exports._lazy = _lazy;
|
|
exports._promise = _promise;
|
|
exports._custom = _custom;
|
|
exports._refine = _refine;
|
|
exports._superRefine = _superRefine;
|
|
exports._check = _check;
|
|
exports._stringbool = _stringbool;
|
|
exports._stringFormat = _stringFormat;
|
|
const checks = __importStar(require("./checks.cjs"));
|
|
const schemas = __importStar(require("./schemas.cjs"));
|
|
const util = __importStar(require("./util.cjs"));
|
|
function _string(Class, params) {
|
|
return new Class({
|
|
type: "string",
|
|
...util.normalizeParams(params),
|
|
});
|
|
}
|
|
function _coercedString(Class, params) {
|
|
return new Class({
|
|
type: "string",
|
|
coerce: true,
|
|
...util.normalizeParams(params),
|
|
});
|
|
}
|
|
function _email(Class, params) {
|
|
return new Class({
|
|
type: "string",
|
|
format: "email",
|
|
check: "string_format",
|
|
abort: false,
|
|
...util.normalizeParams(params),
|
|
});
|
|
}
|
|
function _guid(Class, params) {
|
|
return new Class({
|
|
type: "string",
|
|
format: "guid",
|
|
check: "string_format",
|
|
abort: false,
|
|
...util.normalizeParams(params),
|
|
});
|
|
}
|
|
function _uuid(Class, params) {
|
|
return new Class({
|
|
type: "string",
|
|
format: "uuid",
|
|
check: "string_format",
|
|
abort: false,
|
|
...util.normalizeParams(params),
|
|
});
|
|
}
|
|
function _uuidv4(Class, params) {
|
|
return new Class({
|
|
type: "string",
|
|
format: "uuid",
|
|
check: "string_format",
|
|
abort: false,
|
|
version: "v4",
|
|
...util.normalizeParams(params),
|
|
});
|
|
}
|
|
function _uuidv6(Class, params) {
|
|
return new Class({
|
|
type: "string",
|
|
format: "uuid",
|
|
check: "string_format",
|
|
abort: false,
|
|
version: "v6",
|
|
...util.normalizeParams(params),
|
|
});
|
|
}
|
|
function _uuidv7(Class, params) {
|
|
return new Class({
|
|
type: "string",
|
|
format: "uuid",
|
|
check: "string_format",
|
|
abort: false,
|
|
version: "v7",
|
|
...util.normalizeParams(params),
|
|
});
|
|
}
|
|
function _url(Class, params) {
|
|
return new Class({
|
|
type: "string",
|
|
format: "url",
|
|
check: "string_format",
|
|
abort: false,
|
|
...util.normalizeParams(params),
|
|
});
|
|
}
|
|
function _emoji(Class, params) {
|
|
return new Class({
|
|
type: "string",
|
|
format: "emoji",
|
|
check: "string_format",
|
|
abort: false,
|
|
...util.normalizeParams(params),
|
|
});
|
|
}
|
|
function _nanoid(Class, params) {
|
|
return new Class({
|
|
type: "string",
|
|
format: "nanoid",
|
|
check: "string_format",
|
|
abort: false,
|
|
...util.normalizeParams(params),
|
|
});
|
|
}
|
|
function _cuid(Class, params) {
|
|
return new Class({
|
|
type: "string",
|
|
format: "cuid",
|
|
check: "string_format",
|
|
abort: false,
|
|
...util.normalizeParams(params),
|
|
});
|
|
}
|
|
function _cuid2(Class, params) {
|
|
return new Class({
|
|
type: "string",
|
|
format: "cuid2",
|
|
check: "string_format",
|
|
abort: false,
|
|
...util.normalizeParams(params),
|
|
});
|
|
}
|
|
function _ulid(Class, params) {
|
|
return new Class({
|
|
type: "string",
|
|
format: "ulid",
|
|
check: "string_format",
|
|
abort: false,
|
|
...util.normalizeParams(params),
|
|
});
|
|
}
|
|
function _xid(Class, params) {
|
|
return new Class({
|
|
type: "string",
|
|
format: "xid",
|
|
check: "string_format",
|
|
abort: false,
|
|
...util.normalizeParams(params),
|
|
});
|
|
}
|
|
function _ksuid(Class, params) {
|
|
return new Class({
|
|
type: "string",
|
|
format: "ksuid",
|
|
check: "string_format",
|
|
abort: false,
|
|
...util.normalizeParams(params),
|
|
});
|
|
}
|
|
function _ipv4(Class, params) {
|
|
return new Class({
|
|
type: "string",
|
|
format: "ipv4",
|
|
check: "string_format",
|
|
abort: false,
|
|
...util.normalizeParams(params),
|
|
});
|
|
}
|
|
function _ipv6(Class, params) {
|
|
return new Class({
|
|
type: "string",
|
|
format: "ipv6",
|
|
check: "string_format",
|
|
abort: false,
|
|
...util.normalizeParams(params),
|
|
});
|
|
}
|
|
function _cidrv4(Class, params) {
|
|
return new Class({
|
|
type: "string",
|
|
format: "cidrv4",
|
|
check: "string_format",
|
|
abort: false,
|
|
...util.normalizeParams(params),
|
|
});
|
|
}
|
|
function _cidrv6(Class, params) {
|
|
return new Class({
|
|
type: "string",
|
|
format: "cidrv6",
|
|
check: "string_format",
|
|
abort: false,
|
|
...util.normalizeParams(params),
|
|
});
|
|
}
|
|
function _base64(Class, params) {
|
|
return new Class({
|
|
type: "string",
|
|
format: "base64",
|
|
check: "string_format",
|
|
abort: false,
|
|
...util.normalizeParams(params),
|
|
});
|
|
}
|
|
function _base64url(Class, params) {
|
|
return new Class({
|
|
type: "string",
|
|
format: "base64url",
|
|
check: "string_format",
|
|
abort: false,
|
|
...util.normalizeParams(params),
|
|
});
|
|
}
|
|
function _e164(Class, params) {
|
|
return new Class({
|
|
type: "string",
|
|
format: "e164",
|
|
check: "string_format",
|
|
abort: false,
|
|
...util.normalizeParams(params),
|
|
});
|
|
}
|
|
function _jwt(Class, params) {
|
|
return new Class({
|
|
type: "string",
|
|
format: "jwt",
|
|
check: "string_format",
|
|
abort: false,
|
|
...util.normalizeParams(params),
|
|
});
|
|
}
|
|
exports.TimePrecision = {
|
|
Any: null,
|
|
Minute: -1,
|
|
Second: 0,
|
|
Millisecond: 3,
|
|
Microsecond: 6,
|
|
};
|
|
function _isoDateTime(Class, params) {
|
|
return new Class({
|
|
type: "string",
|
|
format: "datetime",
|
|
check: "string_format",
|
|
offset: false,
|
|
local: false,
|
|
precision: null,
|
|
...util.normalizeParams(params),
|
|
});
|
|
}
|
|
function _isoDate(Class, params) {
|
|
return new Class({
|
|
type: "string",
|
|
format: "date",
|
|
check: "string_format",
|
|
...util.normalizeParams(params),
|
|
});
|
|
}
|
|
function _isoTime(Class, params) {
|
|
return new Class({
|
|
type: "string",
|
|
format: "time",
|
|
check: "string_format",
|
|
precision: null,
|
|
...util.normalizeParams(params),
|
|
});
|
|
}
|
|
function _isoDuration(Class, params) {
|
|
return new Class({
|
|
type: "string",
|
|
format: "duration",
|
|
check: "string_format",
|
|
...util.normalizeParams(params),
|
|
});
|
|
}
|
|
function _number(Class, params) {
|
|
return new Class({
|
|
type: "number",
|
|
checks: [],
|
|
...util.normalizeParams(params),
|
|
});
|
|
}
|
|
function _coercedNumber(Class, params) {
|
|
return new Class({
|
|
type: "number",
|
|
coerce: true,
|
|
checks: [],
|
|
...util.normalizeParams(params),
|
|
});
|
|
}
|
|
function _int(Class, params) {
|
|
return new Class({
|
|
type: "number",
|
|
check: "number_format",
|
|
abort: false,
|
|
format: "safeint",
|
|
...util.normalizeParams(params),
|
|
});
|
|
}
|
|
function _float32(Class, params) {
|
|
return new Class({
|
|
type: "number",
|
|
check: "number_format",
|
|
abort: false,
|
|
format: "float32",
|
|
...util.normalizeParams(params),
|
|
});
|
|
}
|
|
function _float64(Class, params) {
|
|
return new Class({
|
|
type: "number",
|
|
check: "number_format",
|
|
abort: false,
|
|
format: "float64",
|
|
...util.normalizeParams(params),
|
|
});
|
|
}
|
|
function _int32(Class, params) {
|
|
return new Class({
|
|
type: "number",
|
|
check: "number_format",
|
|
abort: false,
|
|
format: "int32",
|
|
...util.normalizeParams(params),
|
|
});
|
|
}
|
|
function _uint32(Class, params) {
|
|
return new Class({
|
|
type: "number",
|
|
check: "number_format",
|
|
abort: false,
|
|
format: "uint32",
|
|
...util.normalizeParams(params),
|
|
});
|
|
}
|
|
function _boolean(Class, params) {
|
|
return new Class({
|
|
type: "boolean",
|
|
...util.normalizeParams(params),
|
|
});
|
|
}
|
|
function _coercedBoolean(Class, params) {
|
|
return new Class({
|
|
type: "boolean",
|
|
coerce: true,
|
|
...util.normalizeParams(params),
|
|
});
|
|
}
|
|
function _bigint(Class, params) {
|
|
return new Class({
|
|
type: "bigint",
|
|
...util.normalizeParams(params),
|
|
});
|
|
}
|
|
function _coercedBigint(Class, params) {
|
|
return new Class({
|
|
type: "bigint",
|
|
coerce: true,
|
|
...util.normalizeParams(params),
|
|
});
|
|
}
|
|
function _int64(Class, params) {
|
|
return new Class({
|
|
type: "bigint",
|
|
check: "bigint_format",
|
|
abort: false,
|
|
format: "int64",
|
|
...util.normalizeParams(params),
|
|
});
|
|
}
|
|
function _uint64(Class, params) {
|
|
return new Class({
|
|
type: "bigint",
|
|
check: "bigint_format",
|
|
abort: false,
|
|
format: "uint64",
|
|
...util.normalizeParams(params),
|
|
});
|
|
}
|
|
function _symbol(Class, params) {
|
|
return new Class({
|
|
type: "symbol",
|
|
...util.normalizeParams(params),
|
|
});
|
|
}
|
|
function _undefined(Class, params) {
|
|
return new Class({
|
|
type: "undefined",
|
|
...util.normalizeParams(params),
|
|
});
|
|
}
|
|
function _null(Class, params) {
|
|
return new Class({
|
|
type: "null",
|
|
...util.normalizeParams(params),
|
|
});
|
|
}
|
|
function _any(Class) {
|
|
return new Class({
|
|
type: "any",
|
|
});
|
|
}
|
|
function _unknown(Class) {
|
|
return new Class({
|
|
type: "unknown",
|
|
});
|
|
}
|
|
function _never(Class, params) {
|
|
return new Class({
|
|
type: "never",
|
|
...util.normalizeParams(params),
|
|
});
|
|
}
|
|
function _void(Class, params) {
|
|
return new Class({
|
|
type: "void",
|
|
...util.normalizeParams(params),
|
|
});
|
|
}
|
|
function _date(Class, params) {
|
|
return new Class({
|
|
type: "date",
|
|
...util.normalizeParams(params),
|
|
});
|
|
}
|
|
function _coercedDate(Class, params) {
|
|
return new Class({
|
|
type: "date",
|
|
coerce: true,
|
|
...util.normalizeParams(params),
|
|
});
|
|
}
|
|
function _nan(Class, params) {
|
|
return new Class({
|
|
type: "nan",
|
|
...util.normalizeParams(params),
|
|
});
|
|
}
|
|
function _lt(value, params) {
|
|
return new checks.$ZodCheckLessThan({
|
|
check: "less_than",
|
|
...util.normalizeParams(params),
|
|
value,
|
|
inclusive: false,
|
|
});
|
|
}
|
|
function _lte(value, params) {
|
|
return new checks.$ZodCheckLessThan({
|
|
check: "less_than",
|
|
...util.normalizeParams(params),
|
|
value,
|
|
inclusive: true,
|
|
});
|
|
}
|
|
function _gt(value, params) {
|
|
return new checks.$ZodCheckGreaterThan({
|
|
check: "greater_than",
|
|
...util.normalizeParams(params),
|
|
value,
|
|
inclusive: false,
|
|
});
|
|
}
|
|
function _gte(value, params) {
|
|
return new checks.$ZodCheckGreaterThan({
|
|
check: "greater_than",
|
|
...util.normalizeParams(params),
|
|
value,
|
|
inclusive: true,
|
|
});
|
|
}
|
|
function _positive(params) {
|
|
return _gt(0, params);
|
|
}
|
|
// negative
|
|
function _negative(params) {
|
|
return _lt(0, params);
|
|
}
|
|
// nonpositive
|
|
function _nonpositive(params) {
|
|
return _lte(0, params);
|
|
}
|
|
// nonnegative
|
|
function _nonnegative(params) {
|
|
return _gte(0, params);
|
|
}
|
|
function _multipleOf(value, params) {
|
|
return new checks.$ZodCheckMultipleOf({
|
|
check: "multiple_of",
|
|
...util.normalizeParams(params),
|
|
value,
|
|
});
|
|
}
|
|
function _maxSize(maximum, params) {
|
|
return new checks.$ZodCheckMaxSize({
|
|
check: "max_size",
|
|
...util.normalizeParams(params),
|
|
maximum,
|
|
});
|
|
}
|
|
function _minSize(minimum, params) {
|
|
return new checks.$ZodCheckMinSize({
|
|
check: "min_size",
|
|
...util.normalizeParams(params),
|
|
minimum,
|
|
});
|
|
}
|
|
function _size(size, params) {
|
|
return new checks.$ZodCheckSizeEquals({
|
|
check: "size_equals",
|
|
...util.normalizeParams(params),
|
|
size,
|
|
});
|
|
}
|
|
function _maxLength(maximum, params) {
|
|
const ch = new checks.$ZodCheckMaxLength({
|
|
check: "max_length",
|
|
...util.normalizeParams(params),
|
|
maximum,
|
|
});
|
|
return ch;
|
|
}
|
|
function _minLength(minimum, params) {
|
|
return new checks.$ZodCheckMinLength({
|
|
check: "min_length",
|
|
...util.normalizeParams(params),
|
|
minimum,
|
|
});
|
|
}
|
|
function _length(length, params) {
|
|
return new checks.$ZodCheckLengthEquals({
|
|
check: "length_equals",
|
|
...util.normalizeParams(params),
|
|
length,
|
|
});
|
|
}
|
|
function _regex(pattern, params) {
|
|
return new checks.$ZodCheckRegex({
|
|
check: "string_format",
|
|
format: "regex",
|
|
...util.normalizeParams(params),
|
|
pattern,
|
|
});
|
|
}
|
|
function _lowercase(params) {
|
|
return new checks.$ZodCheckLowerCase({
|
|
check: "string_format",
|
|
format: "lowercase",
|
|
...util.normalizeParams(params),
|
|
});
|
|
}
|
|
function _uppercase(params) {
|
|
return new checks.$ZodCheckUpperCase({
|
|
check: "string_format",
|
|
format: "uppercase",
|
|
...util.normalizeParams(params),
|
|
});
|
|
}
|
|
function _includes(includes, params) {
|
|
return new checks.$ZodCheckIncludes({
|
|
check: "string_format",
|
|
format: "includes",
|
|
...util.normalizeParams(params),
|
|
includes,
|
|
});
|
|
}
|
|
function _startsWith(prefix, params) {
|
|
return new checks.$ZodCheckStartsWith({
|
|
check: "string_format",
|
|
format: "starts_with",
|
|
...util.normalizeParams(params),
|
|
prefix,
|
|
});
|
|
}
|
|
function _endsWith(suffix, params) {
|
|
return new checks.$ZodCheckEndsWith({
|
|
check: "string_format",
|
|
format: "ends_with",
|
|
...util.normalizeParams(params),
|
|
suffix,
|
|
});
|
|
}
|
|
function _property(property, schema, params) {
|
|
return new checks.$ZodCheckProperty({
|
|
check: "property",
|
|
property,
|
|
schema,
|
|
...util.normalizeParams(params),
|
|
});
|
|
}
|
|
function _mime(types, params) {
|
|
return new checks.$ZodCheckMimeType({
|
|
check: "mime_type",
|
|
mime: types,
|
|
...util.normalizeParams(params),
|
|
});
|
|
}
|
|
function _overwrite(tx) {
|
|
return new checks.$ZodCheckOverwrite({
|
|
check: "overwrite",
|
|
tx,
|
|
});
|
|
}
|
|
// normalize
|
|
function _normalize(form) {
|
|
return _overwrite((input) => input.normalize(form));
|
|
}
|
|
// trim
|
|
function _trim() {
|
|
return _overwrite((input) => input.trim());
|
|
}
|
|
// toLowerCase
|
|
function _toLowerCase() {
|
|
return _overwrite((input) => input.toLowerCase());
|
|
}
|
|
// toUpperCase
|
|
function _toUpperCase() {
|
|
return _overwrite((input) => input.toUpperCase());
|
|
}
|
|
function _array(Class, element, params) {
|
|
return new Class({
|
|
type: "array",
|
|
element,
|
|
// get element() {
|
|
// return element;
|
|
// },
|
|
...util.normalizeParams(params),
|
|
});
|
|
}
|
|
function _union(Class, options, params) {
|
|
return new Class({
|
|
type: "union",
|
|
options,
|
|
...util.normalizeParams(params),
|
|
});
|
|
}
|
|
function _discriminatedUnion(Class, discriminator, options, params) {
|
|
return new Class({
|
|
type: "union",
|
|
options,
|
|
discriminator,
|
|
...util.normalizeParams(params),
|
|
});
|
|
}
|
|
function _intersection(Class, left, right) {
|
|
return new Class({
|
|
type: "intersection",
|
|
left,
|
|
right,
|
|
});
|
|
}
|
|
// export function _tuple(
|
|
// Class: util.SchemaClass<schemas.$ZodTuple>,
|
|
// items: [],
|
|
// params?: string | $ZodTupleParams
|
|
// ): schemas.$ZodTuple<[], null>;
|
|
function _tuple(Class, items, _paramsOrRest, _params) {
|
|
const hasRest = _paramsOrRest instanceof schemas.$ZodType;
|
|
const params = hasRest ? _params : _paramsOrRest;
|
|
const rest = hasRest ? _paramsOrRest : null;
|
|
return new Class({
|
|
type: "tuple",
|
|
items,
|
|
rest,
|
|
...util.normalizeParams(params),
|
|
});
|
|
}
|
|
function _record(Class, keyType, valueType, params) {
|
|
return new Class({
|
|
type: "record",
|
|
keyType,
|
|
valueType,
|
|
...util.normalizeParams(params),
|
|
});
|
|
}
|
|
function _map(Class, keyType, valueType, params) {
|
|
return new Class({
|
|
type: "map",
|
|
keyType,
|
|
valueType,
|
|
...util.normalizeParams(params),
|
|
});
|
|
}
|
|
function _set(Class, valueType, params) {
|
|
return new Class({
|
|
type: "set",
|
|
valueType,
|
|
...util.normalizeParams(params),
|
|
});
|
|
}
|
|
function _enum(Class, values, params) {
|
|
const entries = Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values;
|
|
// if (Array.isArray(values)) {
|
|
// for (const value of values) {
|
|
// entries[value] = value;
|
|
// }
|
|
// } else {
|
|
// Object.assign(entries, values);
|
|
// }
|
|
// const entries: util.EnumLike = {};
|
|
// for (const val of values) {
|
|
// entries[val] = val;
|
|
// }
|
|
return new Class({
|
|
type: "enum",
|
|
entries,
|
|
...util.normalizeParams(params),
|
|
});
|
|
}
|
|
/** @deprecated This API has been merged into `z.enum()`. Use `z.enum()` instead.
|
|
*
|
|
* ```ts
|
|
* enum Colors { red, green, blue }
|
|
* z.enum(Colors);
|
|
* ```
|
|
*/
|
|
function _nativeEnum(Class, entries, params) {
|
|
return new Class({
|
|
type: "enum",
|
|
entries,
|
|
...util.normalizeParams(params),
|
|
});
|
|
}
|
|
function _literal(Class, value, params) {
|
|
return new Class({
|
|
type: "literal",
|
|
values: Array.isArray(value) ? value : [value],
|
|
...util.normalizeParams(params),
|
|
});
|
|
}
|
|
function _file(Class, params) {
|
|
return new Class({
|
|
type: "file",
|
|
...util.normalizeParams(params),
|
|
});
|
|
}
|
|
function _transform(Class, fn) {
|
|
return new Class({
|
|
type: "transform",
|
|
transform: fn,
|
|
});
|
|
}
|
|
function _optional(Class, innerType) {
|
|
return new Class({
|
|
type: "optional",
|
|
innerType,
|
|
});
|
|
}
|
|
function _nullable(Class, innerType) {
|
|
return new Class({
|
|
type: "nullable",
|
|
innerType,
|
|
});
|
|
}
|
|
function _default(Class, innerType, defaultValue) {
|
|
return new Class({
|
|
type: "default",
|
|
innerType,
|
|
get defaultValue() {
|
|
return typeof defaultValue === "function" ? defaultValue() : defaultValue;
|
|
},
|
|
});
|
|
}
|
|
function _nonoptional(Class, innerType, params) {
|
|
return new Class({
|
|
type: "nonoptional",
|
|
innerType,
|
|
...util.normalizeParams(params),
|
|
});
|
|
}
|
|
function _success(Class, innerType) {
|
|
return new Class({
|
|
type: "success",
|
|
innerType,
|
|
});
|
|
}
|
|
function _catch(Class, innerType, catchValue) {
|
|
return new Class({
|
|
type: "catch",
|
|
innerType,
|
|
catchValue: (typeof catchValue === "function" ? catchValue : () => catchValue),
|
|
});
|
|
}
|
|
function _pipe(Class, in_, out) {
|
|
return new Class({
|
|
type: "pipe",
|
|
in: in_,
|
|
out,
|
|
});
|
|
}
|
|
function _readonly(Class, innerType) {
|
|
return new Class({
|
|
type: "readonly",
|
|
innerType,
|
|
});
|
|
}
|
|
function _templateLiteral(Class, parts, params) {
|
|
return new Class({
|
|
type: "template_literal",
|
|
parts,
|
|
...util.normalizeParams(params),
|
|
});
|
|
}
|
|
function _lazy(Class, getter) {
|
|
return new Class({
|
|
type: "lazy",
|
|
getter,
|
|
});
|
|
}
|
|
function _promise(Class, innerType) {
|
|
return new Class({
|
|
type: "promise",
|
|
innerType,
|
|
});
|
|
}
|
|
function _custom(Class, fn, _params) {
|
|
const norm = util.normalizeParams(_params);
|
|
norm.abort ?? (norm.abort = true); // default to abort:false
|
|
const schema = new Class({
|
|
type: "custom",
|
|
check: "custom",
|
|
fn: fn,
|
|
...norm,
|
|
});
|
|
return schema;
|
|
}
|
|
// same as _custom but defaults to abort:false
|
|
function _refine(Class, fn, _params) {
|
|
const schema = new Class({
|
|
type: "custom",
|
|
check: "custom",
|
|
fn: fn,
|
|
...util.normalizeParams(_params),
|
|
});
|
|
return schema;
|
|
}
|
|
function _superRefine(fn) {
|
|
const ch = _check((payload) => {
|
|
payload.addIssue = (issue) => {
|
|
if (typeof issue === "string") {
|
|
payload.issues.push(util.issue(issue, payload.value, ch._zod.def));
|
|
}
|
|
else {
|
|
// for Zod 3 backwards compatibility
|
|
const _issue = issue;
|
|
if (_issue.fatal)
|
|
_issue.continue = false;
|
|
_issue.code ?? (_issue.code = "custom");
|
|
_issue.input ?? (_issue.input = payload.value);
|
|
_issue.inst ?? (_issue.inst = ch);
|
|
_issue.continue ?? (_issue.continue = !ch._zod.def.abort);
|
|
payload.issues.push(util.issue(_issue));
|
|
}
|
|
};
|
|
return fn(payload.value, payload);
|
|
});
|
|
return ch;
|
|
}
|
|
function _check(fn, params) {
|
|
const ch = new checks.$ZodCheck({
|
|
check: "custom",
|
|
...util.normalizeParams(params),
|
|
});
|
|
ch._zod.check = fn;
|
|
return ch;
|
|
}
|
|
function _stringbool(Classes, _params) {
|
|
const params = util.normalizeParams(_params);
|
|
let truthyArray = params.truthy ?? ["true", "1", "yes", "on", "y", "enabled"];
|
|
let falsyArray = params.falsy ?? ["false", "0", "no", "off", "n", "disabled"];
|
|
if (params.case !== "sensitive") {
|
|
truthyArray = truthyArray.map((v) => (typeof v === "string" ? v.toLowerCase() : v));
|
|
falsyArray = falsyArray.map((v) => (typeof v === "string" ? v.toLowerCase() : v));
|
|
}
|
|
const truthySet = new Set(truthyArray);
|
|
const falsySet = new Set(falsyArray);
|
|
const _Pipe = Classes.Pipe ?? schemas.$ZodPipe;
|
|
const _Boolean = Classes.Boolean ?? schemas.$ZodBoolean;
|
|
const _String = Classes.String ?? schemas.$ZodString;
|
|
const _Transform = Classes.Transform ?? schemas.$ZodTransform;
|
|
const tx = new _Transform({
|
|
type: "transform",
|
|
transform: (input, payload) => {
|
|
let data = input;
|
|
if (params.case !== "sensitive")
|
|
data = data.toLowerCase();
|
|
if (truthySet.has(data)) {
|
|
return true;
|
|
}
|
|
else if (falsySet.has(data)) {
|
|
return false;
|
|
}
|
|
else {
|
|
payload.issues.push({
|
|
code: "invalid_value",
|
|
expected: "stringbool",
|
|
values: [...truthySet, ...falsySet],
|
|
input: payload.value,
|
|
inst: tx,
|
|
continue: false,
|
|
});
|
|
return {};
|
|
}
|
|
},
|
|
error: params.error,
|
|
});
|
|
// params.error;
|
|
const innerPipe = new _Pipe({
|
|
type: "pipe",
|
|
in: new _String({ type: "string", error: params.error }),
|
|
out: tx,
|
|
error: params.error,
|
|
});
|
|
const outerPipe = new _Pipe({
|
|
type: "pipe",
|
|
in: innerPipe,
|
|
out: new _Boolean({
|
|
type: "boolean",
|
|
error: params.error,
|
|
}),
|
|
error: params.error,
|
|
});
|
|
return outerPipe;
|
|
}
|
|
function _stringFormat(Class, format, fnOrRegex, _params = {}) {
|
|
const params = util.normalizeParams(_params);
|
|
const def = {
|
|
...util.normalizeParams(_params),
|
|
check: "string_format",
|
|
type: "string",
|
|
format,
|
|
fn: typeof fnOrRegex === "function" ? fnOrRegex : (val) => fnOrRegex.test(val),
|
|
...params,
|
|
};
|
|
if (fnOrRegex instanceof RegExp) {
|
|
def.pattern = fnOrRegex;
|
|
}
|
|
const inst = new Class(def);
|
|
return inst;
|
|
}
|