zod - npm Package Compare versions

Comparing version 1.11.5 to 1.11.6

lib/src/helpers/Mocker.d.ts

 export declare class Mocker {
     pick: (...args: any[]) => any;
-    readonly string: string;
-    readonly number: number;
-    readonly bigint: bigint;
-    readonly boolean: boolean;
-    readonly date: Date;
-    readonly null: null;
-    readonly undefined: undefined;
-    readonly stringOptional: any;
-    readonly stringNullable: any;
-    readonly numberOptional: any;
-    readonly numberNullable: any;
-    readonly booleanOptional: any;
-    readonly booleanNullable: any;
+    get string(): string;
+    get number(): number;
+    get bigint(): bigint;
+    get boolean(): boolean;
+    get date(): Date;
+    get null(): null;
+    get undefined(): undefined;
+    get stringOptional(): any;
+    get stringNullable(): any;
+    get numberOptional(): any;
+    get numberNullable(): any;
+    get booleanOptional(): any;
+    get booleanNullable(): any;
 }

lib/src/helpers/objectUtil.d.ts

 import { ZodRawShape } from '../types/base';
 import { ZodObject } from '../types/object';
 export declare namespace objectUtil {
-    interface ZodObjectParams {
+    export interface ZodObjectParams {
         strict: boolean;
     }
-    type MergeObjectParams<First extends ZodObjectParams, Second extends ZodObjectParams> = {
+    export type MergeObjectParams<First extends ZodObjectParams, Second extends ZodObjectParams> = {
         strict: First['strict'] extends false ? false : Second['strict'] extends false ? false : true;
     };
-    type MergeShapes<U extends ZodRawShape, V extends ZodRawShape> = {
+    export type MergeShapes<U extends ZodRawShape, V extends ZodRawShape> = {
         [k in Exclude<keyof U, keyof V>]: U[k];
     } & V;
-    type Flatten<T extends object> = {
+    export type Flatten<T extends object> = {
         [k in keyof T]: T[k];
@@ -32,11 +32,12 @@ };
     }>;
-    type NoNeverKeys<T extends ZodRawShape> = {
+    export type NoNeverKeys<T extends ZodRawShape> = {
         [k in keyof T]: [T[k]] extends [never] ? never : k;
     }[keyof T];
-    type NoNever<T extends ZodRawShape> = Identity<{
+    export type NoNever<T extends ZodRawShape> = Identity<{
         [k in NoNeverKeys<T>]: k extends keyof T ? T[k] : never;
     }>;
-    type ObjectType<T extends ZodRawShape> = FlattenObject<ObjectIntersection<T>>;
-    const mergeShapes: <U extends ZodRawShape, T extends ZodRawShape>(first: U, second: T) => T & U;
-    const mergeObjects: <First extends ZodObject<any, any, any>>(first: First) => <Second extends ZodObject<any, any, any>>(second: Second) => ZodObject<First["_shape"] & Second["_shape"], MergeObjectParams<First["_params"], Second["_params"]>, First["_type"] & Second["_type"]>;
+    export type ObjectType<T extends ZodRawShape> = FlattenObject<ObjectIntersection<T>>;
+    export const mergeShapes: <U extends ZodRawShape, T extends ZodRawShape>(first: U, second: T) => T & U;
+    export const mergeObjects: <First extends ZodObject<any, any, any>>(first: First) => <Second extends ZodObject<any, any, any>>(second: Second) => ZodObject<First["_shape"] & Second["_shape"], MergeObjectParams<First["_params"], Second["_params"]>, First["_type"] & Second["_type"]>;
+    export {};
 }

lib/src/helpers/objectUtil.js

@@ -13,2 +13,9 @@ "use strict";
 };
+var __spreadArrays = (this && this.__spreadArrays) || function () {
+    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+    for (var r = Array(s), k = 0, i = 0; i < il; i++)
+        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+            r[k] = a[j];
+    return r;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
@@ -29,3 +36,3 @@ var base_1 = require("../types/base");
         }
-        return __assign({}, first, second, sharedShape);
+        return __assign(__assign(__assign({}, first), second), sharedShape);
     };
@@ -36,3 +43,3 @@ objectUtil.mergeObjects = function (first) { return function (second) {
             t: base_1.ZodTypes.object,
-            checks: (first._def.checks || []).concat((second._def.checks || [])),
+            checks: __spreadArrays((first._def.checks || []), (second._def.checks || [])),
             params: {
@@ -39,0 +46,0 @@ strict: first.params.strict && second.params.strict,

lib/src/index.d.ts

@@ -39,12 +39,12 @@ import { ZodString, ZodStringDef } from './types/string';
 declare const voidType: () => ZodVoid;
-declare const arrayType: <T extends ZodType<any, any>>(schema: T) => ZodArray<T>;
+declare const arrayType: <T extends ZodTypeAny>(schema: T) => ZodArray<T>;
 declare const objectType: <T extends import("./types/base").ZodRawShape>(shape: T) => ZodObject<T, {
     strict: true;
-}, { [k in keyof ({ [k in { [k in keyof { [k in keyof T]: T[k]["_type"]; }]: undefined extends { [k in keyof T]: T[k]["_type"]; }[k] ? k : never; }[keyof T]]?: { [k in keyof T]: T[k]["_type"]; }[k] | undefined; } & { [k in Exclude<keyof T, { [k in keyof { [k in keyof T]: T[k]["_type"]; }]: undefined extends { [k in keyof T]: T[k]["_type"]; }[k] ? k : never; }[keyof T]>]: { [k in keyof T]: T[k]["_type"]; }[k]; })]: ({ [k in { [k in keyof { [k in keyof T]: T[k]["_type"]; }]: undefined extends { [k in keyof T]: T[k]["_type"]; }[k] ? k : never; }[keyof T]]?: { [k in keyof T]: T[k]["_type"]; }[k] | undefined; } & { [k in Exclude<keyof T, { [k in keyof { [k in keyof T]: T[k]["_type"]; }]: undefined extends { [k in keyof T]: T[k]["_type"]; }[k] ? k : never; }[keyof T]>]: { [k in keyof T]: T[k]["_type"]; }[k]; })[k]; }>;
-declare const unionType: <T extends [ZodType<any, any>, ZodType<any, any>, ...ZodType<any, any>[]]>(types: T) => ZodUnion<T>;
-declare const intersectionType: <T extends ZodType<any, any>, U extends ZodType<any, any>>(left: T, right: U) => ZodIntersection<T, U>;
-declare const tupleType: <T extends [ZodType<any, any>, ...ZodType<any, any>[]] | []>(schemas: T) => ZodTuple<T>;
-declare const recordType: <Value extends ZodType<any, any> = ZodType<any, any>>(valueType: Value) => ZodRecord<Value>;
-declare const functionType: <T extends ZodTuple<any> = ZodTuple<[]>, U extends ZodType<any, any> = ZodUnknown>(args?: T | undefined, returns?: U | undefined) => ZodFunction<T, U>;
-declare const lazyType: <T extends ZodType<any, any>>(getter: () => T) => ZodLazy<T>;
+}, { [k_4 in keyof ({ [k_2 in { [k_1 in keyof { [k in keyof T]: T[k]["_type"]; }]: undefined extends { [k in keyof T]: T[k]["_type"]; }[k_1] ? k_1 : never; }[keyof T]]?: { [k in keyof T]: T[k]["_type"]; }[k_2] | undefined; } & { [k_3 in Exclude<keyof T, { [k_1 in keyof { [k in keyof T]: T[k]["_type"]; }]: undefined extends { [k in keyof T]: T[k]["_type"]; }[k_1] ? k_1 : never; }[keyof T]>]: { [k in keyof T]: T[k]["_type"]; }[k_3]; })]: ({ [k_2 in { [k_1 in keyof { [k in keyof T]: T[k]["_type"]; }]: undefined extends { [k in keyof T]: T[k]["_type"]; }[k_1] ? k_1 : never; }[keyof T]]?: { [k in keyof T]: T[k]["_type"]; }[k_2] | undefined; } & { [k_3 in Exclude<keyof T, { [k_1 in keyof { [k in keyof T]: T[k]["_type"]; }]: undefined extends { [k in keyof T]: T[k]["_type"]; }[k_1] ? k_1 : never; }[keyof T]>]: { [k in keyof T]: T[k]["_type"]; }[k_3]; })[k_4]; }>;
+declare const unionType: <T extends [ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>(types: T) => ZodUnion<T>;
+declare const intersectionType: <T extends ZodTypeAny, U extends ZodTypeAny>(left: T, right: U) => ZodIntersection<T, U>;
+declare const tupleType: <T extends [ZodTypeAny, ...ZodTypeAny[]] | []>(schemas: T) => ZodTuple<T>;
+declare const recordType: <Value extends ZodTypeAny = ZodTypeAny>(valueType: Value) => ZodRecord<Value>;
+declare const functionType: <T extends ZodTuple<any> = ZodTuple<[]>, U extends ZodTypeAny = ZodUnknown>(args?: T | undefined, returns?: U | undefined) => ZodFunction<T, U>;
+declare const lazyType: <T extends ZodTypeAny>(getter: () => T) => ZodLazy<T>;
 declare const literalType: <T extends import("./helpers/primitive").Primitive>(value: T) => ZodLiteral<T>;
@@ -56,3 +56,3 @@ declare const enumType: <U extends string, T extends [U, ...U[]]>(values: T) => ZodEnum<T>;
 }>(values: T) => ZodNativeEnum<T>;
-declare const promiseType: <T extends ZodType<any, any>>(schema: T) => ZodPromise<T>;
+declare const promiseType: <T extends ZodTypeAny>(schema: T) => ZodPromise<T>;
 declare const ostring: () => ZodUnion<[ZodString, ZodUndefined]>;
@@ -82,3 +82,3 @@ declare const onumber: () => ZodUnion<[ZodNumber, ZodUndefined]>;
         strict: true;
-    }, { [k in keyof ({ [k in { [k in keyof { [k in keyof T]: T[k]["_type"]; }]: undefined extends { [k in keyof T]: T[k]["_type"]; }[k] ? k : never; }[keyof T]]?: { [k in keyof T]: T[k]["_type"]; }[k] | undefined; } & { [k in Exclude<keyof T, { [k in keyof { [k in keyof T]: T[k]["_type"]; }]: undefined extends { [k in keyof T]: T[k]["_type"]; }[k] ? k : never; }[keyof T]>]: { [k in keyof T]: T[k]["_type"]; }[k]; })]: ({ [k in { [k in keyof { [k in keyof T]: T[k]["_type"]; }]: undefined extends { [k in keyof T]: T[k]["_type"]; }[k] ? k : never; }[keyof T]]?: { [k in keyof T]: T[k]["_type"]; }[k] | undefined; } & { [k in Exclude<keyof T, { [k in keyof { [k in keyof T]: T[k]["_type"]; }]: undefined extends { [k in keyof T]: T[k]["_type"]; }[k] ? k : never; }[keyof T]>]: { [k in keyof T]: T[k]["_type"]; }[k]; })[k]; }>;
+    }, { [k_4 in keyof ({ [k_2 in { [k_1 in keyof { [k in keyof T]: T[k]["_type"]; }]: undefined extends { [k in keyof T]: T[k]["_type"]; }[k_1] ? k_1 : never; }[keyof T]]?: { [k in keyof T]: T[k]["_type"]; }[k_2] | undefined; } & { [k_3 in Exclude<keyof T, { [k_1 in keyof { [k in keyof T]: T[k]["_type"]; }]: undefined extends { [k in keyof T]: T[k]["_type"]; }[k_1] ? k_1 : never; }[keyof T]>]: { [k in keyof T]: T[k]["_type"]; }[k_3]; })]: ({ [k_2 in { [k_1 in keyof { [k in keyof T]: T[k]["_type"]; }]: undefined extends { [k in keyof T]: T[k]["_type"]; }[k_1] ? k_1 : never; }[keyof T]]?: { [k in keyof T]: T[k]["_type"]; }[k_2] | undefined; } & { [k_3 in Exclude<keyof T, { [k_1 in keyof { [k in keyof T]: T[k]["_type"]; }]: undefined extends { [k in keyof T]: T[k]["_type"]; }[k_1] ? k_1 : never; }[keyof T]>]: { [k in keyof T]: T[k]["_type"]; }[k_3]; })[k_4]; }>;
 };
@@ -85,0 +85,0 @@ export { ZodString, ZodNumber, ZodBigInt, ZodBoolean, ZodDate, ZodUndefined, ZodNull, ZodAny, ZodUnknown, ZodVoid, ZodArray, ZodObject, ZodUnion, ZodIntersection, ZodTuple, ZodRecord, ZodFunction, ZodLazy, ZodLiteral, ZodEnum, ZodNativeEnum, ZodPromise, ZodType, ZodType as Schema, ZodType as ZodSchema, ZodTypeAny, ZodDef, ZodErrorMap, ZodParsedType, ZodCodeGenerator, };

lib/src/parser.js

@@ -14,6 +14,7 @@ "use strict";
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
         function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
         function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
@@ -54,6 +55,15 @@ });
     if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0)
-            t[p[i]] = s[p[i]];
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
     return t;
 };
+var __spreadArrays = (this && this.__spreadArrays) || function () {
+    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+    for (var r = Array(s), k = 0, i = 0; i < il; i++)
+        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+            r[k] = a[j];
+    return r;
+};
 var __importStar = (this && this.__importStar) || function (mod) {
@@ -66,3 +76,2 @@ if (mod && mod.__esModule) return mod;
 };
-var _this = this;
 Object.defineProperty(exports, "__esModule", { value: true });
@@ -141,8 +150,8 @@ var z = __importStar(require("./types/base"));
     var makeError = function (errorData) {
-        var errorArg = __assign({}, errorData, { path: params.path.concat((errorData.path || [])) });
+        var errorArg = __assign(__assign({}, errorData), { path: __spreadArrays(params.path, (errorData.path || [])) });
         var ctxArg = { data: obj };
         var defaultError = defaultErrorMap_1.defaultErrorMap === params.errorMap
             ? { message: "Invalid value." }
-            : defaultErrorMap_1.defaultErrorMap(errorArg, __assign({}, ctxArg, { defaultError: "Invalid value." }));
-        return __assign({}, errorData, { path: params.path.concat((errorData.path || [])), message: errorData.message || params.errorMap(errorArg, __assign({}, ctxArg, { defaultError: defaultError.message })).message });
+            : defaultErrorMap_1.defaultErrorMap(errorArg, __assign(__assign({}, ctxArg), { defaultError: "Invalid value." }));
+        return __assign(__assign({}, errorData), { path: __spreadArrays(params.path, (errorData.path || [])), message: errorData.message || params.errorMap(errorArg, __assign(__assign({}, ctxArg), { defaultError: defaultError.message })).message });
     };
@@ -261,3 +270,3 @@ var def = schemaDef;
                 try {
-                    var parsedItem = def.type.parse(item, __assign({}, params, { path: params.path.concat([i]) }));
+                    var parsedItem = def.type.parse(item, __assign(__assign({}, params), { path: __spreadArrays(params.path, [i]) }));
                     return parsedItem;
@@ -292,3 +301,3 @@ }
                 try {
-                    def.shape()[key].parse(obj[key], __assign({}, params, { path: params.path.concat([key]) }));
+                    def.shape()[key].parse(obj[key], __assign(__assign({}, params), { path: __spreadArrays(params.path, [key]) }));
                 }
@@ -361,3 +370,3 @@ catch (err) {
                 try {
-                    parsedTuple.push(itemParser.parse(item, __assign({}, params, { path: params.path.concat([index]) })));
+                    parsedTuple.push(itemParser.parse(item, __assign(__assign({}, params), { path: __spreadArrays(params.path, [index]) })));
                 }
@@ -452,3 +461,3 @@ catch (err) {
                 try {
-                    def.valueType.parse(obj[key], __assign({}, params, { path: params.path.concat([key]) }));
+                    def.valueType.parse(obj[key], __assign(__assign({}, params), { path: __spreadArrays(params.path, [key]) }));
                 }
@@ -488,3 +497,3 @@ catch (err) {
             }
-            return new Promise(function (res, rej) { return __awaiter(_this, void 0, void 0, function () {
+            return new Promise(function (res, rej) { return __awaiter(void 0, void 0, void 0, function () {
                 var objValue, parsed;
@@ -491,0 +500,0 @@ return __generator(this, function (_a) {

lib/src/types/array.d.ts

@@ -13,3 +13,3 @@ import * as z from './base';
     };
-    readonly element: T;
+    get element(): T;
     min: (minLength: number, message?: string | {
@@ -23,3 +23,3 @@ message?: string | undefined;
     nonempty: () => ZodNonEmptyArray<T>;
-    static create: <T_1 extends z.ZodType<any, any>>(schema: T_1) => ZodArray<T_1>;
+    static create: <T_1 extends z.ZodTypeAny>(schema: T_1) => ZodArray<T_1>;
 }
@@ -26,0 +26,0 @@ export declare class ZodNonEmptyArray<T extends z.ZodTypeAny> extends z.ZodType<[T['_type'], ...T['_type'][]], ZodArrayDef<T>> {

lib/src/types/array.js

@@ -60,3 +60,3 @@ "use strict";
         _this.nonempty = function () {
-            return new ZodNonEmptyArray(__assign({}, _this._def, { nonempty: true }));
+            return new ZodNonEmptyArray(__assign(__assign({}, _this._def), { nonempty: true }));
         };
@@ -63,0 +63,0 @@ return _this;

lib/src/types/base.js

@@ -13,2 +13,9 @@ "use strict";
 };
+var __spreadArrays = (this && this.__spreadArrays) || function () {
+    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+    for (var r = Array(s), k = 0, i = 0; i < il; i++)
+        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+            r[k] = a[j];
+    return r;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
@@ -85,3 +92,3 @@ var parser_1 = require("../parser");
         this._refinement = function (refinement) {
-            return new _this.constructor(__assign({}, _this._def, { checks: (_this._def.checks || []).concat([refinement]) }));
+            return new _this.constructor(__assign(__assign({}, _this._def), { checks: __spreadArrays((_this._def.checks || []), [refinement]) }));
         };
@@ -88,0 +95,0 @@ //  abstract // opt optional: () => any;

lib/src/types/enum.d.ts

@@ -14,8 +14,8 @@ import * as z from './base';
     toJSON: () => ZodEnumDef<T>;
-    readonly options: T;
-    readonly enum: Values<T>;
-    readonly Values: Values<T>;
-    readonly Enum: Values<T>;
+    get options(): T;
+    get enum(): Values<T>;
+    get Values(): Values<T>;
+    get Enum(): Values<T>;
     static create: <U extends string, T_1 extends [U, ...U[]]>(values: T_1) => ZodEnum<T_1>;
 }
 export {};

lib/src/types/function.d.ts

@@ -13,7 +13,7 @@ import * as z from './base';
     readonly _type: TypeOfFunction<Args, Returns>;
-    args: <Items extends [z.ZodType<any, any>, ...z.ZodType<any, any>[]] | []>(...items: Items) => ZodFunction<ZodTuple<Items>, Returns>;
+    args: <Items extends [z.ZodTypeAny, ...z.ZodTypeAny[]] | []>(...items: Items) => ZodFunction<ZodTuple<Items>, Returns>;
     returns: <NewReturnType extends z.ZodType<any, any>>(returnType: NewReturnType) => ZodFunction<Args, NewReturnType>;
     implement: <F extends TypeOfFunction<Args, Returns>>(func: F) => F;
     validate: <F extends TypeOfFunction<Args, Returns>>(func: F) => F;
-    static create: <T extends ZodTuple<any> = ZodTuple<[]>, U extends z.ZodType<any, any> = ZodUnknown>(args?: T | undefined, returns?: U | undefined) => ZodFunction<T, U>;
+    static create: <T extends ZodTuple<any> = ZodTuple<[]>, U extends z.ZodTypeAny = ZodUnknown>(args?: T | undefined, returns?: U | undefined) => ZodFunction<T, U>;
     toJSON: () => {
@@ -20,0 +20,0 @@ t: z.ZodTypes.function;

lib/src/types/function.js

@@ -46,6 +46,6 @@ "use strict";
             }
-            return new ZodFunction(__assign({}, _this._def, { args: tuple_1.ZodTuple.create(items) }));
+            return new ZodFunction(__assign(__assign({}, _this._def), { args: tuple_1.ZodTuple.create(items) }));
         };
         _this.returns = function (returnType) {
-            return new ZodFunction(__assign({}, _this._def, { returns: returnType }));
+            return new ZodFunction(__assign(__assign({}, _this._def), { returns: returnType }));
         };
@@ -52,0 +52,0 @@ _this.implement = function (func) {

lib/src/types/intersection.d.ts

@@ -13,3 +13,3 @@ import * as z from './base';
     };
-    static create: <T_1 extends z.ZodType<any, any>, U_1 extends z.ZodType<any, any>>(left: T_1, right: U_1) => ZodIntersection<T_1, U_1>;
+    static create: <T_1 extends z.ZodTypeAny, U_1 extends z.ZodTypeAny>(left: T_1, right: U_1) => ZodIntersection<T_1, U_1>;
 }

lib/src/types/lazy.d.ts

@@ -7,5 +7,5 @@ import * as z from './base';
 export declare class ZodLazy<T extends z.ZodTypeAny> extends z.ZodType<z.TypeOf<T>, ZodLazyDef<T>> {
-    readonly schema: T;
+    get schema(): T;
     toJSON: () => never;
-    static create: <T_1 extends z.ZodType<any, any>>(getter: () => T_1) => ZodLazy<T_1>;
+    static create: <T_1 extends z.ZodTypeAny>(getter: () => T_1) => ZodLazy<T_1>;
 }

lib/src/types/object.d.ts

@@ -23,4 +23,4 @@ import * as z from './base';
     readonly _params: Params;
-    readonly shape: T;
-    readonly params: Params;
+    get shape(): T;
+    get params(): Params;
     toJSON: () => {
@@ -37,4 +37,4 @@ t: z.ZodTypes.object;
     }>>>;
-    augment: <Augmentation extends z.ZodRawShape>(augmentation: Augmentation) => ZodObject<{ [k in Exclude<keyof T, keyof Augmentation>]: T[k]; } & { [k in keyof Augmentation]: Augmentation[k]; }, Params, ZodObjectType<{ [k in Exclude<keyof T, keyof Augmentation>]: T[k]; } & { [k in keyof Augmentation]: Augmentation[k]; }, Params>>;
-    extend: <Augmentation extends z.ZodRawShape>(augmentation: Augmentation) => ZodObject<{ [k in Exclude<keyof T, keyof Augmentation>]: T[k]; } & { [k in keyof Augmentation]: Augmentation[k]; }, Params, ZodObjectType<{ [k in Exclude<keyof T, keyof Augmentation>]: T[k]; } & { [k in keyof Augmentation]: Augmentation[k]; }, Params>>;
+    augment: <Augmentation extends z.ZodRawShape>(augmentation: Augmentation) => ZodObject<{ [k in Exclude<keyof T, keyof Augmentation>]: T[k]; } & { [k_1 in keyof Augmentation]: Augmentation[k_1]; }, Params, ZodObjectType<{ [k in Exclude<keyof T, keyof Augmentation>]: T[k]; } & { [k_1 in keyof Augmentation]: Augmentation[k_1]; }, Params>>;
+    extend: <Augmentation extends z.ZodRawShape>(augmentation: Augmentation) => ZodObject<{ [k in Exclude<keyof T, keyof Augmentation>]: T[k]; } & { [k_1 in keyof Augmentation]: Augmentation[k_1]; }, Params, ZodObjectType<{ [k in Exclude<keyof T, keyof Augmentation>]: T[k]; } & { [k_1 in keyof Augmentation]: Augmentation[k_1]; }, Params>>;
     /**
@@ -46,15 +46,15 @@ * Prior to zod@1.0.12 there was a bug in the
     merge: <MergeShape extends z.ZodRawShape, MergeParams extends ZodObjectParams>(other: ZodObject<MergeShape, MergeParams>) => ZodObject<T & MergeShape, objectUtil.MergeObjectParams<Params, MergeParams>>;
-    pick: <Mask extends { [k in keyof T]?: true | undefined; }>(mask: Mask) => ZodObject<{ [k in { [k in keyof { [k in keyof Mask]: k extends keyof T ? T[k] : never; }]: [{ [k in keyof Mask]: k extends keyof T ? T[k] : never; }[k]] extends [never] ? never : k; }[keyof Mask]]: k extends keyof Mask ? { [k in keyof Mask]: k extends keyof T ? T[k] : never; }[k] : never; }, Params, ZodObjectType<{ [k in { [k in keyof { [k in keyof Mask]: k extends keyof T ? T[k] : never; }]: [{ [k in keyof Mask]: k extends keyof T ? T[k] : never; }[k]] extends [never] ? never : k; }[keyof Mask]]: k extends keyof Mask ? { [k in keyof Mask]: k extends keyof T ? T[k] : never; }[k] : never; }, Params>>;
-    omit: <Mask extends { [k in keyof T]?: true | undefined; }>(mask: Mask) => ZodObject<{ [k in { [k in keyof { [k in keyof T]: k extends keyof Mask ? never : T[k]; }]: [{ [k in keyof T]: k extends keyof Mask ? never : T[k]; }[k]] extends [never] ? never : k; }[keyof T]]: k extends keyof T ? { [k in keyof T]: k extends keyof Mask ? never : T[k]; }[k] : never; }, Params, ZodObjectType<{ [k in { [k in keyof { [k in keyof T]: k extends keyof Mask ? never : T[k]; }]: [{ [k in keyof T]: k extends keyof Mask ? never : T[k]; }[k]] extends [never] ? never : k; }[keyof T]]: k extends keyof T ? { [k in keyof T]: k extends keyof Mask ? never : T[k]; }[k] : never; }, Params>>;
+    pick: <Mask extends { [k in keyof T]?: true | undefined; }>(mask: Mask) => ZodObject<{ [k_3 in { [k_2 in keyof { [k_1 in keyof Mask]: k_1 extends keyof T ? T[k_1] : never; }]: [{ [k_1 in keyof Mask]: k_1 extends keyof T ? T[k_1] : never; }[k_2]] extends [never] ? never : k_2; }[keyof Mask]]: k_3 extends keyof Mask ? { [k_1 in keyof Mask]: k_1 extends keyof T ? T[k_1] : never; }[k_3] : never; }, Params, ZodObjectType<{ [k_3 in { [k_2 in keyof { [k_1 in keyof Mask]: k_1 extends keyof T ? T[k_1] : never; }]: [{ [k_1 in keyof Mask]: k_1 extends keyof T ? T[k_1] : never; }[k_2]] extends [never] ? never : k_2; }[keyof Mask]]: k_3 extends keyof Mask ? { [k_1 in keyof Mask]: k_1 extends keyof T ? T[k_1] : never; }[k_3] : never; }, Params>>;
+    omit: <Mask extends { [k in keyof T]?: true | undefined; }>(mask: Mask) => ZodObject<{ [k_3 in { [k_2 in keyof { [k_1 in keyof T]: k_1 extends keyof Mask ? never : T[k_1]; }]: [{ [k_1 in keyof T]: k_1 extends keyof Mask ? never : T[k_1]; }[k_2]] extends [never] ? never : k_2; }[keyof T]]: k_3 extends keyof T ? { [k_1 in keyof T]: k_1 extends keyof Mask ? never : T[k_1]; }[k_3] : never; }, Params, ZodObjectType<{ [k_3 in { [k_2 in keyof { [k_1 in keyof T]: k_1 extends keyof Mask ? never : T[k_1]; }]: [{ [k_1 in keyof T]: k_1 extends keyof Mask ? never : T[k_1]; }[k_2]] extends [never] ? never : k_2; }[keyof T]]: k_3 extends keyof T ? { [k_1 in keyof T]: k_1 extends keyof Mask ? never : T[k_1]; }[k_3] : never; }, Params>>;
     partial: () => ZodObject<{ [k in keyof T]: ZodUnion<[T[k], ZodUndefined]>; }, Params, ZodObjectType<{ [k in keyof T]: ZodUnion<[T[k], ZodUndefined]>; }, Params>>;
-    primitives: () => ZodObject<{ [k in { [k in keyof { [k in keyof T]: [T[k]["_type"]] extends [Scalars] ? T[k] : never; }]: [{ [k in keyof T]: [T[k]["_type"]] extends [Scalars] ? T[k] : never; }[k]] extends [never] ? never : k; }[keyof T]]: k extends keyof T ? { [k in keyof T]: [T[k]["_type"]] extends [Scalars] ? T[k] : never; }[k] : never; }, Params, ZodObjectType<{ [k in { [k in keyof { [k in keyof T]: [T[k]["_type"]] extends [Scalars] ? T[k] : never; }]: [{ [k in keyof T]: [T[k]["_type"]] extends [Scalars] ? T[k] : never; }[k]] extends [never] ? never : k; }[keyof T]]: k extends keyof T ? { [k in keyof T]: [T[k]["_type"]] extends [Scalars] ? T[k] : never; }[k] : never; }, Params>>;
-    nonprimitives: () => ZodObject<{ [k in { [k in keyof { [k in keyof T]: [T[k]["_type"]] extends [Scalars] ? never : T[k]; }]: [{ [k in keyof T]: [T[k]["_type"]] extends [Scalars] ? never : T[k]; }[k]] extends [never] ? never : k; }[keyof T]]: k extends keyof T ? { [k in keyof T]: [T[k]["_type"]] extends [Scalars] ? never : T[k]; }[k] : never; }, Params, ZodObjectType<{ [k in { [k in keyof { [k in keyof T]: [T[k]["_type"]] extends [Scalars] ? never : T[k]; }]: [{ [k in keyof T]: [T[k]["_type"]] extends [Scalars] ? never : T[k]; }[k]] extends [never] ? never : k; }[keyof T]]: k extends keyof T ? { [k in keyof T]: [T[k]["_type"]] extends [Scalars] ? never : T[k]; }[k] : never; }, Params>>;
+    primitives: () => ZodObject<{ [k_2 in { [k_1 in keyof { [k in keyof T]: [T[k]["_type"]] extends [Scalars] ? T[k] : never; }]: [{ [k in keyof T]: [T[k]["_type"]] extends [Scalars] ? T[k] : never; }[k_1]] extends [never] ? never : k_1; }[keyof T]]: k_2 extends keyof T ? { [k in keyof T]: [T[k]["_type"]] extends [Scalars] ? T[k] : never; }[k_2] : never; }, Params, ZodObjectType<{ [k_2 in { [k_1 in keyof { [k in keyof T]: [T[k]["_type"]] extends [Scalars] ? T[k] : never; }]: [{ [k in keyof T]: [T[k]["_type"]] extends [Scalars] ? T[k] : never; }[k_1]] extends [never] ? never : k_1; }[keyof T]]: k_2 extends keyof T ? { [k in keyof T]: [T[k]["_type"]] extends [Scalars] ? T[k] : never; }[k_2] : never; }, Params>>;
+    nonprimitives: () => ZodObject<{ [k_2 in { [k_1 in keyof { [k in keyof T]: [T[k]["_type"]] extends [Scalars] ? never : T[k]; }]: [{ [k in keyof T]: [T[k]["_type"]] extends [Scalars] ? never : T[k]; }[k_1]] extends [never] ? never : k_1; }[keyof T]]: k_2 extends keyof T ? { [k in keyof T]: [T[k]["_type"]] extends [Scalars] ? never : T[k]; }[k_2] : never; }, Params, ZodObjectType<{ [k_2 in { [k_1 in keyof { [k in keyof T]: [T[k]["_type"]] extends [Scalars] ? never : T[k]; }]: [{ [k in keyof T]: [T[k]["_type"]] extends [Scalars] ? never : T[k]; }[k_1]] extends [never] ? never : k_1; }[keyof T]]: k_2 extends keyof T ? { [k in keyof T]: [T[k]["_type"]] extends [Scalars] ? never : T[k]; }[k_2] : never; }, Params>>;
     deepPartial: () => partialUtil.RootDeepPartial<this>;
     static create: <T_1 extends z.ZodRawShape>(shape: T_1) => ZodObject<T_1, {
         strict: true;
-    }, { [k in keyof ({ [k in { [k in keyof { [k in keyof T_1]: T_1[k]["_type"]; }]: undefined extends { [k in keyof T_1]: T_1[k]["_type"]; }[k] ? k : never; }[keyof T_1]]?: { [k in keyof T_1]: T_1[k]["_type"]; }[k] | undefined; } & { [k in Exclude<keyof T_1, { [k in keyof { [k in keyof T_1]: T_1[k]["_type"]; }]: undefined extends { [k in keyof T_1]: T_1[k]["_type"]; }[k] ? k : never; }[keyof T_1]>]: { [k in keyof T_1]: T_1[k]["_type"]; }[k]; })]: ({ [k in { [k in keyof { [k in keyof T_1]: T_1[k]["_type"]; }]: undefined extends { [k in keyof T_1]: T_1[k]["_type"]; }[k] ? k : never; }[keyof T_1]]?: { [k in keyof T_1]: T_1[k]["_type"]; }[k] | undefined; } & { [k in Exclude<keyof T_1, { [k in keyof { [k in keyof T_1]: T_1[k]["_type"]; }]: undefined extends { [k in keyof T_1]: T_1[k]["_type"]; }[k] ? k : never; }[keyof T_1]>]: { [k in keyof T_1]: T_1[k]["_type"]; }[k]; })[k]; }>;
+    }, { [k_4 in keyof ({ [k_2 in { [k_1 in keyof { [k in keyof T_1]: T_1[k]["_type"]; }]: undefined extends { [k in keyof T_1]: T_1[k]["_type"]; }[k_1] ? k_1 : never; }[keyof T_1]]?: { [k in keyof T_1]: T_1[k]["_type"]; }[k_2] | undefined; } & { [k_3 in Exclude<keyof T_1, { [k_1 in keyof { [k in keyof T_1]: T_1[k]["_type"]; }]: undefined extends { [k in keyof T_1]: T_1[k]["_type"]; }[k_1] ? k_1 : never; }[keyof T_1]>]: { [k in keyof T_1]: T_1[k]["_type"]; }[k_3]; })]: ({ [k_2 in { [k_1 in keyof { [k in keyof T_1]: T_1[k]["_type"]; }]: undefined extends { [k in keyof T_1]: T_1[k]["_type"]; }[k_1] ? k_1 : never; }[keyof T_1]]?: { [k in keyof T_1]: T_1[k]["_type"]; }[k_2] | undefined; } & { [k_3 in Exclude<keyof T_1, { [k_1 in keyof { [k in keyof T_1]: T_1[k]["_type"]; }]: undefined extends { [k in keyof T_1]: T_1[k]["_type"]; }[k_1] ? k_1 : never; }[keyof T_1]>]: { [k in keyof T_1]: T_1[k]["_type"]; }[k_3]; })[k_4]; }>;
     static lazycreate: <T_1 extends z.ZodRawShape>(shape: () => T_1) => ZodObject<T_1, {
         strict: true;
-    }, { [k in keyof ({ [k in { [k in keyof { [k in keyof T_1]: T_1[k]["_type"]; }]: undefined extends { [k in keyof T_1]: T_1[k]["_type"]; }[k] ? k : never; }[keyof T_1]]?: { [k in keyof T_1]: T_1[k]["_type"]; }[k] | undefined; } & { [k in Exclude<keyof T_1, { [k in keyof { [k in keyof T_1]: T_1[k]["_type"]; }]: undefined extends { [k in keyof T_1]: T_1[k]["_type"]; }[k] ? k : never; }[keyof T_1]>]: { [k in keyof T_1]: T_1[k]["_type"]; }[k]; })]: ({ [k in { [k in keyof { [k in keyof T_1]: T_1[k]["_type"]; }]: undefined extends { [k in keyof T_1]: T_1[k]["_type"]; }[k] ? k : never; }[keyof T_1]]?: { [k in keyof T_1]: T_1[k]["_type"]; }[k] | undefined; } & { [k in Exclude<keyof T_1, { [k in keyof { [k in keyof T_1]: T_1[k]["_type"]; }]: undefined extends { [k in keyof T_1]: T_1[k]["_type"]; }[k] ? k : never; }[keyof T_1]>]: { [k in keyof T_1]: T_1[k]["_type"]; }[k]; })[k]; }>;
+    }, { [k_4 in keyof ({ [k_2 in { [k_1 in keyof { [k in keyof T_1]: T_1[k]["_type"]; }]: undefined extends { [k in keyof T_1]: T_1[k]["_type"]; }[k_1] ? k_1 : never; }[keyof T_1]]?: { [k in keyof T_1]: T_1[k]["_type"]; }[k_2] | undefined; } & { [k_3 in Exclude<keyof T_1, { [k_1 in keyof { [k in keyof T_1]: T_1[k]["_type"]; }]: undefined extends { [k in keyof T_1]: T_1[k]["_type"]; }[k_1] ? k_1 : never; }[keyof T_1]>]: { [k in keyof T_1]: T_1[k]["_type"]; }[k_3]; })]: ({ [k_2 in { [k_1 in keyof { [k in keyof T_1]: T_1[k]["_type"]; }]: undefined extends { [k in keyof T_1]: T_1[k]["_type"]; }[k_1] ? k_1 : never; }[keyof T_1]]?: { [k in keyof T_1]: T_1[k]["_type"]; }[k_2] | undefined; } & { [k_3 in Exclude<keyof T_1, { [k_1 in keyof { [k in keyof T_1]: T_1[k]["_type"]; }]: undefined extends { [k in keyof T_1]: T_1[k]["_type"]; }[k_1] ? k_1 : never; }[keyof T_1]>]: { [k in keyof T_1]: T_1[k]["_type"]; }[k_3]; })[k_4]; }>;
 }
 export {};

lib/src/types/object.js

@@ -38,3 +38,3 @@ "use strict";
 var AugmentFactory = function (def) { return function (augmentation) {
-    return new ZodObject(__assign({}, def, { shape: function () { return (__assign({}, def.shape(), augmentation)); } }));
+    return new ZodObject(__assign(__assign({}, def), { shape: function () { return (__assign(__assign({}, def.shape()), augmentation)); } }));
 }; };
@@ -59,3 +59,3 @@ var objectDefToJson = function (def) { return ({
                 t: z.ZodTypes.object,
-                params: __assign({}, _this._params, { strict: false }),
+                params: __assign(__assign({}, _this._params), { strict: false }),
             });
@@ -78,3 +78,3 @@ };
             });
-            return new ZodObject(__assign({}, _this._def, { shape: function () { return shape; } }));
+            return new ZodObject(__assign(__assign({}, _this._def), { shape: function () { return shape; } }));
         };
@@ -88,3 +88,3 @@ _this.omit = function (mask) {
             });
-            return new ZodObject(__assign({}, _this._def, { shape: function () { return shape; } }));
+            return new ZodObject(__assign(__assign({}, _this._def), { shape: function () { return shape; } }));
         };
@@ -96,3 +96,3 @@ _this.partial = function () {
             }
-            return new ZodObject(__assign({}, _this._def, { shape: function () { return newShape; } }));
+            return new ZodObject(__assign(__assign({}, _this._def), { shape: function () { return newShape; } }));
         };
@@ -106,3 +106,3 @@ _this.primitives = function () {
             }
-            return new ZodObject(__assign({}, _this._def, { shape: function () { return newShape; } }));
+            return new ZodObject(__assign(__assign({}, _this._def), { shape: function () { return newShape; } }));
         };
@@ -116,3 +116,3 @@ _this.nonprimitives = function () {
             }
-            return new ZodObject(__assign({}, _this._def, { shape: function () { return newShape; } }));
+            return new ZodObject(__assign(__assign({}, _this._def), { shape: function () { return newShape; } }));
         };
@@ -130,3 +130,3 @@ _this.deepPartial = function () {
             }
-            return new ZodObject(__assign({}, _this._def, { shape: function () { return newShape; } }));
+            return new ZodObject(__assign(__assign({}, _this._def), { shape: function () { return newShape; } }));
         };
@@ -133,0 +133,0 @@ return _this;

lib/src/types/promise.d.ts

@@ -11,3 +11,3 @@ import * as z from './base';
     };
-    static create: <T_1 extends z.ZodType<any, any>>(schema: T_1) => ZodPromise<T_1>;
+    static create: <T_1 extends z.ZodTypeAny>(schema: T_1) => ZodPromise<T_1>;
 }

lib/src/types/record.d.ts

@@ -13,3 +13,3 @@ import * as z from './base';
     };
-    static create: <Value_1 extends z.ZodType<any, any> = z.ZodType<any, any>>(valueType: Value_1) => ZodRecord<Value_1>;
+    static create: <Value_1 extends z.ZodTypeAny = z.ZodTypeAny>(valueType: Value_1) => ZodRecord<Value_1>;
 }

lib/src/types/tuple.d.ts

@@ -14,3 +14,3 @@ import * as z from './base';
     };
-    static create: <T_1 extends [z.ZodType<any, any>, ...z.ZodType<any, any>[]] | []>(schemas: T_1) => ZodTuple<T_1>;
+    static create: <T_1 extends [z.ZodTypeAny, ...z.ZodTypeAny[]] | []>(schemas: T_1) => ZodTuple<T_1>;
 }

lib/src/types/union.d.ts

@@ -11,3 +11,3 @@ import * as z from './base';
     };
-    static create: <T_1 extends [z.ZodType<any, any>, z.ZodType<any, any>, ...z.ZodType<any, any>[]]>(types: T_1) => ZodUnion<T_1>;
+    static create: <T_1 extends [z.ZodTypeAny, z.ZodTypeAny, ...z.ZodTypeAny[]]>(types: T_1) => ZodUnion<T_1>;
 }

lib/src/ZodError.d.ts

@@ -89,4 +89,4 @@ import { ZodParsedType } from './parser';
     static create: (errors: ZodSuberror[]) => ZodError;
-    readonly message: string;
-    readonly isEmpty: boolean;
+    get message(): string;
+    get isEmpty(): boolean;
     addError: (sub: ZodSuberror) => void;
@@ -100,3 +100,3 @@ addErrors: (subs?: ZodSuberror[]) => void;
     };
-    readonly formErrors: {
+    get formErrors(): {
         formErrors: string[];
@@ -103,0 +103,0 @@ fieldErrors: {

lib/src/ZodError.js

@@ -15,2 +15,9 @@ "use strict";
 })();
+var __spreadArrays = (this && this.__spreadArrays) || function () {
+    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+    for (var r = Array(s), k = 0, i = 0; i < il; i++)
+        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+            r[k] = a[j];
+    return r;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
@@ -44,7 +51,7 @@ var util_1 = require("./helpers/util");
         _this.addError = function (sub) {
-            _this.errors = _this.errors.concat([sub]);
+            _this.errors = __spreadArrays(_this.errors, [sub]);
         };
         _this.addErrors = function (subs) {
             if (subs === void 0) { subs = []; }
-            _this.errors = _this.errors.concat(subs);
+            _this.errors = __spreadArrays(_this.errors, subs);
         };
@@ -80,6 +87,9 @@ _this.flatten = function () {
             // return JSON.stringify(this.errors, null, 2);
-            var errorMessage = [this.errors.length + " validation issue(s)", ''];
+            var errorMessage = [
+                this.errors.length + " validation issue(s)",
+                '',
+            ];
             for (var _i = 0, _a = this.errors; _i < _a.length; _i++) {
                 var err = _a[_i];
-                errorMessage.push("  Issue #" + this.errors.indexOf(err) + ": " + err.code + " at " + err.path.join('./index'));
+                errorMessage.push("  Issue #" + this.errors.indexOf(err) + ": " + err.code + " at " + err.path.join('.'));
                 errorMessage.push("  " + err.message);
@@ -86,0 +96,0 @@ errorMessage.push('');

package.json

 {
   "name": "zod",
-  "version": "1.11.5",
+  "version": "1.11.6",
   "description": "TypeScript-first schema declaration and validation library with static type inference",
@@ -57,4 +57,4 @@ "main": "./lib/src/index.js",
     "tslint-config-prettier": "^1.18.0",
-    "typescript": "3.3"
+    "typescript": "3.7"
   }
 }

README.md

@@ -43,2 +43,3 @@ <p align="center">
 - Zero dependencies
+- Plain JavaScript: works in browsers and Node.js
 - Tiny: 8kb minified + zipped
@@ -267,3 +268,3 @@ - Immutability: methods (i.e. `.optional()` return a new instance
 
-````ts
+```ts
 const stringSchema = z.string();
@@ -287,3 +288,3 @@
 
-For this instances, you can define custom a validation check on _any_ Zod schema with `.refine`:
+For example, you can define a custom validation check on _any_ Zod schema with `.refine`:
 
@@ -294,3 +295,3 @@ ```ts
 });
-````
+```
 
@@ -338,3 +339,3 @@ As you can see, `.refine` takes two arguments.
     "path": [ "confirm" ],
-    "message": "Invalid input."
+    "message": "Passwords don't match"
   }]
@@ -364,3 +365,3 @@ }
     "path": [ "passwordForm", "confirm" ],
-    "message": "Invalid input."
+    "message": "Passwords don't match"
   }]
@@ -960,3 +961,7 @@ }
 ```ts
-const FishEnum = z.union([z.literal('Salmon'), z.literal('Tuna'), z.literal('Trout')]);
+const FishEnum = z.union([
+  z.literal('Salmon'),
+  z.literal('Tuna'),
+  z.literal('Trout'),
+]);
 
@@ -1067,2 +1072,4 @@ FishEnum.parse('Salmon'); // => "Salmon"
 
+> ⚠️ Intersections are deprecated. If you are trying to merge objects, use the `.merge` method instead.
+
 Intersections are useful for creating "logical AND" types.
@@ -1081,3 +1088,3 @@
 
-This is particularly useful for defining "schema mixins" that you can apply to multiple schemas.
+<!-- This is particularly useful for defining "schema mixins" that you can apply to multiple schemas.
 
@@ -1097,3 +1104,3 @@ ```ts
 // { id:string; name:string };
-```
+``` -->
 
@@ -1174,3 +1181,3 @@ ## Tuples
 
-There isn't a built-in method for validating any JSON, because representing that requires recursive type aliases (a feature that TypeScript started supporting with version 3.7). In order to support a wider range of TypeScript versions (see the top of the README for details) we aren't providing a JSON type out of the box at this time. If you want to validate JSON and you're using TypeScript 3.7+, you can use this snippet to achieve that:
+If you want to validate any JSON value, you can use the snippet below. This requires TypeScript 3.7 or higher!
 
@@ -1181,6 +1188,8 @@ ```ts
 const literalSchema = z.union([z.string(), z.number(), z.boolean(), z.null()]);
-const jsonSchema: z.ZodSchema<Json> = z.lazy(() => z.union([Literal, z.array(Json), z.record(Json)]));
+const jsonSchema: z.ZodSchema<Json> = z.lazy(() =>
+  z.union([literalSchema, z.array(jsonSchema), z.record(jsonSchema)]),
+);
 
 jsonSchema.parse({
-  // ...
+  // data
 });
@@ -1187,0 +1196,0 @@ ```

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

278690

increased by0.69%

Lines of code

3641

increased by0.97%

Number of lines in readme file

1567

increased by0.58%

No dependency changes