zod 3.14.2 → 3.14.5

package/lib/types.d.ts

@@ -15,15 +15,7 @@ export declare type ZodTypeAny = ZodType<any, any, any>;
 export declare type TypeOf<T extends ZodType<any, any, any>> = T["_output"];
 export declare type input<T extends ZodType<any, any, any>> = T["_input"];
 export declare type output<T extends ZodType<any, any, any>> = T["_output"];
-declare type allKeys<T> = T extends any ? keyof T : never;
-export declare type TypeOfFlattenedError<T extends ZodType<any, any, any>, U = string> = {
-    formErrors: U[];
-    fieldErrors: {
-        [P in allKeys<TypeOf<T>>]?: U[];
-    };
-};
-export declare type TypeOfFormErrors<T extends ZodType<any, any, any>> = TypeOfFlattenedError<T>;
-export type { TypeOf as infer, TypeOfFlattenedError as inferFlattenedErrors, TypeOfFormErrors as inferFormErrors, };
+export type { TypeOf as infer };
 export declare type CustomErrorParams = Partial<util.Omit<ZodCustomIssue, "code">>;
 export interface ZodTypeDef {
     errorMap?: ZodErrorMap;
@@ -44,7 +36,7 @@ export declare type SafeParseError<Input> = {
     error: ZodError<Input>;
 };
 export declare type SafeParseReturnType<Input, Output> = SafeParseSuccess<Output> | SafeParseError<Input>;
-export declare abstract class ZodType<Output, Def extends ZodTypeDef = ZodTypeDef, Input = Output> {
+export declare abstract class ZodType<Output = any, Def extends ZodTypeDef = ZodTypeDef, Input = Output> {
     readonly _type: Output;
     readonly _output: Output;
     readonly _input: Input;
@@ -65,10 +57,6 @@ export declare abstract class ZodType<Output, Def extends ZodTypeDef = ZodTypeDe
     safeParseAsync(data: unknown, params?: Partial<ParseParams>): Promise<SafeParseReturnType<Input, Output>>;
     /** Alias of safeParseAsync */
     spa: (data: unknown, params?: Partial<ParseParams> | undefined) => Promise<SafeParseReturnType<Input, Output>>;
-    /** The .is method has been removed in Zod 3. For details see https://github.com/colinhacks/zod/tree/v3. */
-    is: never;
-    /** The .check method has been removed in Zod 3. For details see https://github.com/colinhacks/zod/tree/v3. */
-    check: never;
     refine<RefinedOutput extends Output>(check: (arg: Output) => arg is RefinedOutput, message?: string | CustomErrorParams | ((arg: Output) => CustomErrorParams)): ZodEffects<this, RefinedOutput, RefinedOutput>;
     refine(check: (arg: Output) => unknown | Promise<unknown>, message?: string | CustomErrorParams | ((arg: Output) => CustomErrorParams)): ZodEffects<this, Output, Input>;
     refinement<RefinedOutput extends Output>(check: (arg: Output) => arg is RefinedOutput, refinementData: IssueData | ((arg: Output, ctx: RefinementCtx) => IssueData)): ZodEffects<this, RefinedOutput, RefinedOutput>;
@@ -279,38 +267,30 @@ export declare class ZodArray<T extends ZodTypeAny, Cardinality extends ArrayCar
 }
 export declare type ZodNonEmptyArray<T extends ZodTypeAny> = ZodArray<T, "atleastone">;
 export declare namespace objectUtil {
-    export type MergeShapes<U extends ZodRawShape, V extends ZodRawShape> = {
+    type MergeShapes<U extends ZodRawShape, V extends ZodRawShape> = {
         [k in Exclude<keyof U, keyof V>]: U[k];
     } & V;
-    type optionalKeys<T extends object> = {
-        [k in keyof T]: undefined extends T[k] ? k : never;
-    }[keyof T];
     type requiredKeys<T extends object> = {
         [k in keyof T]: undefined extends T[k] ? never : k;
     }[keyof T];
-    export type addQuestionMarks<T extends object> = {
-        [k in optionalKeys<T>]?: T[k];
+    type addQuestionMarks<T extends object> = {
+        [k in keyof T]?: T[k];
     } & {
         [k in requiredKeys<T>]: T[k];
     };
-    export type identity<T> = T;
-    export type flatten<T extends object> = identity<{
+    type identity<T> = T;
+    type flatten<T extends object> = identity<{
         [k in keyof T]: T[k];
     }>;
-    export type noNeverKeys<T extends ZodRawShape> = {
+    type noNeverKeys<T extends ZodRawShape> = {
         [k in keyof T]: [T[k]] extends [never] ? never : k;
     }[keyof T];
-    export type noNever<T extends ZodRawShape> = identity<{
+    type noNever<T extends ZodRawShape> = identity<{
         [k in noNeverKeys<T>]: k extends keyof T ? T[k] : never;
     }>;
-    export const mergeShapes: <U extends ZodRawShape, T extends ZodRawShape>(first: U, second: T) => T & U;
-    export {};
+    const mergeShapes: <U extends ZodRawShape, T extends ZodRawShape>(first: U, second: T) => T & U;
 }
-export declare type extendShape<A, B> = {
-    [k in Exclude<keyof A, keyof B>]: A[k];
-} & {
-    [k in keyof B]: B[k];
-};
+export declare type extendShape<A, B> = Omit<A, keyof B> & B;
 declare type UnknownKeysParam = "passthrough" | "strict" | "strip";
 export interface ZodObjectDef<T extends ZodRawShape = ZodRawShape, UnknownKeys extends UnknownKeysParam = UnknownKeysParam, Catchall extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
     typeName: ZodFirstPartyTypeKind.ZodObject;
@@ -365,14 +345,10 @@ export declare class ZodObject<T extends ZodRawShape, UnknownKeys extends Unknow
     catchall<Index extends ZodTypeAny>(index: Index): ZodObject<T, UnknownKeys, Index>;
     pick<Mask extends {
         [k in keyof T]?: true;
-    }>(mask: Mask): ZodObject<objectUtil.noNever<{
-        [k in keyof Mask]: k extends keyof T ? T[k] : never;
-    }>, UnknownKeys, Catchall>;
+    }>(mask: Mask): ZodObject<Pick<T, Extract<keyof T, keyof Mask>>, UnknownKeys, Catchall>;
     omit<Mask extends {
         [k in keyof T]?: true;
-    }>(mask: Mask): ZodObject<objectUtil.noNever<{
-        [k in keyof T]: k extends keyof Mask ? never : T[k];
-    }>, UnknownKeys, Catchall>;
+    }>(mask: Mask): ZodObject<Omit<T, keyof Mask>, UnknownKeys, Catchall>;
     deepPartial(): partialUtil.DeepPartial<this>;
     partial(): ZodObject<{
         [k in keyof T]: ZodOptional<T[k]>;

package/lib/types.js

@@ -6,6 +6,17 @@ const errorUtil_1 = require("./helpers/errorUtil");
 const parseUtil_1 = require("./helpers/parseUtil");
 const util_1 = require("./helpers/util");
 const ZodError_1 = require("./ZodError");
+class ParseInputLazyPath {
+    constructor(parent, value, path, key) {
+        this.parent = parent;
+        this.data = value;
+        this._path = path;
+        this._key = key;
+    }
+    get path() {
+        return this._path.concat(this._key);
+    }
+}
 const handleResult = (ctx, result) => {
     if ((0, parseUtil_1.isValid)(result)) {
         return { success: true, data: result.value };
@@ -62,8 +73,8 @@ class ZodType {
         this.transform = this.transform.bind(this);
         this.default = this.default.bind(this);
         this.describe = this.describe.bind(this);
-        this.isOptional = this.isOptional.bind(this);
         this.isNullable = this.isNullable.bind(this);
+        this.isOptional = this.isOptional.bind(this);
     }
     get description() {
         return this._def.description;
@@ -117,7 +128,6 @@ class ZodType {
             common: {
                 issues: [],
                 async: (_a = params === null || params === void 0 ? void 0 : params.async) !== null && _a !== void 0 ? _a : false,
-                typeCache: typeof Map !== "undefined" ? new Map() : undefined,
                 contextualErrorMap: params === null || params === void 0 ? void 0 : params.errorMap,
             },
             path: (params === null || params === void 0 ? void 0 : params.path) || [],
@@ -141,7 +151,6 @@ class ZodType {
                 issues: [],
                 contextualErrorMap: params === null || params === void 0 ? void 0 : params.errorMap,
                 async: true,
-                typeCache: typeof Map !== "undefined" ? new Map() : undefined,
             },
             path: (params === null || params === void 0 ? void 0 : params.path) || [],
             schemaErrorMap: this._def.errorMap,
@@ -909,21 +918,13 @@ class ZodArray extends ZodType {
         }
         if (ctx.common.async) {
             return Promise.all(ctx.data.map((item, i) => {
-                return def.type._parseAsync({
-                    parent: ctx,
-                    path: [...ctx.path, i],
-                    data: item,
-                });
+                return def.type._parseAsync(new ParseInputLazyPath(ctx, item, ctx.path, i));
             })).then((result) => {
                 return parseUtil_1.ParseStatus.mergeArray(status, result);
             });
         }
         const result = ctx.data.map((item, i) => {
-            return def.type._parseSync({
-                parent: ctx,
-                path: [...ctx.path, i],
-                data: item,
-            });
+            return def.type._parseSync(new ParseInputLazyPath(ctx, item, ctx.path, i));
         });
         return parseUtil_1.ParseStatus.mergeArray(status, result);
     }
@@ -1044,19 +1045,19 @@ class ZodObject extends ZodType {
         }
         const { status, ctx } = this._processInputParams(input);
         const { shape, keys: shapeKeys } = this._getCached();
-        const dataKeys = util_1.util.objectKeys(ctx.data);
-        const extraKeys = dataKeys.filter((k) => !shapeKeys.includes(k));
+        const extraKeys = [];
+        for (const key in ctx.data) {
+            if (!shapeKeys.includes(key)) {
+                extraKeys.push(key);
+            }
+        }
         const pairs = [];
         for (const key of shapeKeys) {
             const keyValidator = shape[key];
             const value = ctx.data[key];
             pairs.push({
                 key: { status: "valid", value: key },
-                value: keyValidator._parse({
-                    parent: ctx,
-                    data: value,
-                    path: [...ctx.path, key],
-                }),
+                value: keyValidator._parse(new ParseInputLazyPath(ctx, value, ctx.path, key)),
                 alwaysSet: key in ctx.data,
             });
         }
@@ -1092,7 +1093,7 @@ class ZodObject extends ZodType {
                 const value = ctx.data[key];
                 pairs.push({
                     key: { status: "valid", value: key },
-                    value: catchall._parse({ parent: ctx, path: [...ctx.path, key], data: value } //, ctx.child(key), value, getParsedType(value)
+                    value: catchall._parse(new ParseInputLazyPath(ctx, value, ctx.path, key) //, ctx.child(key), value, getParsedType(value)
                     ),
                     alwaysSet: key in ctx.data,
                 });
@@ -1592,11 +1593,7 @@ class ZodTuple extends ZodType {
             const schema = this._def.items[itemIndex] || this._def.rest;
             if (!schema)
                 return null;
-            return schema._parse({
-                data: item,
-                path: [...ctx.path, itemIndex],
-                parent: ctx,
-            });
+            return schema._parse(new ParseInputLazyPath(ctx, item, ctx.path, itemIndex));
         })
             .filter((x) => !!x); // filter nulls
         if (ctx.common.async) {
@@ -1649,16 +1646,8 @@ class ZodRecord extends ZodType {
         const valueType = this._def.valueType;
         for (const key in ctx.data) {
             pairs.push({
-                key: keyType._parse({
-                    data: key,
-                    path: [...ctx.path, key],
-                    parent: ctx,
-                }),
-                value: valueType._parse({
-                    data: ctx.data[key],
-                    path: [...ctx.path, key],
-                    parent: ctx,
-                }),
+                key: keyType._parse(new ParseInputLazyPath(ctx, key, ctx.path, key)),
+                value: valueType._parse(new ParseInputLazyPath(ctx, ctx.data[key], ctx.path, key)),
             });
         }
         if (ctx.common.async) {
@@ -1704,16 +1693,8 @@ class ZodMap extends ZodType {
         const valueType = this._def.valueType;
         const pairs = [...ctx.data.entries()].map(([key, value], index) => {
             return {
-                key: keyType._parse({
-                    data: key,
-                    path: [...ctx.path, index, "key"],
-                    parent: ctx,
-                }),
-                value: valueType._parse({
-                    data: value,
-                    path: [...ctx.path, index, "value"],
-                    parent: ctx,
-                }),
+                key: keyType._parse(new ParseInputLazyPath(ctx, key, ctx.path, [index, "key"])),
+                value: valueType._parse(new ParseInputLazyPath(ctx, value, ctx.path, [index, "value"])),
             };
         });
         if (ctx.common.async) {
@@ -1807,7 +1788,7 @@ class ZodSet extends ZodType {
             }
             return { status: status.value, value: parsedSet };
         }
-        const elements = [...ctx.data.values()].map((item, i) => valueType._parse({ data: item, path: [...ctx.path, i], parent: ctx }));
+        const elements = [...ctx.data.values()].map((item, i) => valueType._parse(new ParseInputLazyPath(ctx, item, ctx.path, i)));
         if (ctx.common.async) {
             return Promise.all(elements).then((elements) => finalizeSet(elements));
         }
@@ -1988,9 +1969,8 @@ class ZodLiteral extends ZodType {
         if (input.data !== this._def.value) {
             const ctx = this._getOrReturnCtx(input);
             (0, parseUtil_1.addIssueToContext)(ctx, {
-                code: ZodError_1.ZodIssueCode.invalid_type,
-                expected: (0, parseUtil_1.getParsedType)(this._def.value),
-                received: ctx.parsedType,
+                code: ZodError_1.ZodIssueCode.invalid_literal,
+                expected: this._def.value,
             });
             return parseUtil_1.INVALID;
         }

package/package.json

@@ -1,21 +1,22 @@
 {
   "name": "zod",
-  "version": "3.14.2",
+  "version": "3.14.5",
   "description": "TypeScript-first schema declaration and validation library with static type inference",
   "main": "./lib/index.js",
-  "types": "./lib/index.d.ts",
+  "types": "./index.d.ts",
   "module": "./lib/index.mjs",
   "dependencies": {},
   "exports": {
     ".": {
       "require": "./lib/index.js",
       "import": "./lib/index.mjs",
-      "types": "./lib/index.d.ts"
+      "types": "./index.d.ts"
     },
     "./package.json": "./package.json"
   },
   "files": [
-    "/lib"
+    "/lib",
+    "/index.d.ts"
   ],
   "repository": {
     "type": "git",
@@ -43,7 +44,7 @@
   ],
   "scripts": {
     "prettier:check": "prettier --check src/**/*.ts deno/lib/**/*.ts --no-error-on-unmatched-pattern",
-    "prettier:fix": "prettier --write src/**/*.ts deno/lib/**/*.ts --no-error-on-unmatched-pattern",
+    "prettier:fix": "prettier --write src/**/*.ts deno/lib/**/*.ts --ignore-unknown --no-error-on-unmatched-pattern",
     "lint:check": "eslint --ext .ts ./src",
     "lint:fix": "eslint --fix --ext .ts ./src",
     "check": "yarn lint:check && yarn prettier:check",
@@ -57,51 +58,44 @@
     "rollup": "rollup --config rollup.config.js",
     "test": "jest --coverage",
     "test:deno": "cd deno && deno test",
-    "badge": "make-coverage-badge --output-path ./coverage.svg",
     "prepublishOnly": "npm run test && npm run build && npm run build:deno",
     "play": "nodemon -e ts -w . -x ts-node src/playground.ts --project tsconfig.json --trace-warnings",
     "depcruise": "depcruise -c .dependency-cruiser.js src",
-    "benchmark": "ts-node src/benchmarks/index.ts"
+    "benchmark": "ts-node src/benchmarks/index.ts",
+    "prepare": "husky install"
   },
   "devDependencies": {
     "@rollup/plugin-typescript": "^8.2.0",
     "@types/benchmark": "^2.1.0",
     "@types/jest": "^26.0.17",
-    "@types/node": "^14.14.10",
+    "@types/node": "14",
     "@typescript-eslint/eslint-plugin": "^5.15.0",
     "@typescript-eslint/parser": "^5.15.0",
     "benchmark": "^2.1.4",
     "dependency-cruiser": "^9.19.0",
-    "eslint": "^7.15.0",
-    "eslint-config-prettier": "^7.1.0",
-    "eslint-plugin-ban": "^1.5.2",
-    "eslint-plugin-import": "^2.22.1",
+    "eslint": "^8.11.0",
+    "eslint-config-prettier": "^8.5.0",
+    "eslint-plugin-ban": "^1.6.0",
+    "eslint-plugin-import": "^2.25.4",
     "eslint-plugin-simple-import-sort": "^7.0.0",
-    "eslint-plugin-unused-imports": "^1.1.0",
-    "husky": "^4.3.4",
-    "jest": "^26.6.3",
-    "lint-staged": "^10.5.3",
-    "make-coverage-badge": "^1.2.0",
-    "nodemon": "^2.0.2",
-    "prettier": "^2.2.1",
-    "rollup": "^2.42.1",
-    "rollup-plugin-uglify": "^6.0.4",
-    "table": "^6.8.0",
-    "ts-jest": "^26.4.4",
-    "ts-node": "^9.1.0",
+    "eslint-plugin-unused-imports": "^2.0.0",
+    "husky": "^7.0.4",
+    "jest": "^27.5.1",
+    "lint-staged": "^12.3.7",
+    "nodemon": "^2.0.15",
+    "prettier": "^2.6.0",
+    "pretty-quick": "^3.1.3",
+    "rollup": "^2.70.1",
+    "ts-jest": "^27.1.3",
+    "ts-morph": "^14.0.0",
+    "ts-node": "^10.7.0",
     "tslib": "^2.3.1",
     "typescript": "^4.6.2"
   },
-  "husky": {
-    "hooks": {
-      "pre-commit": "lint-staged",
-      "pre-push": "lint-staged"
-    }
-  },
   "lint-staged": {
-    "*.ts": [
-      "yarn lint:fix",
-      "yarn prettier:fix"
+    "src/*.ts": [
+      "eslint --cache --fix",
+      "prettier --ignore-unknown --write"
     ]
   }
 }