zod 3.14.4 → 3.15.1

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;
@@ -79,7 +71,7 @@ export declare abstract class ZodType<Output = any, Def extends ZodTypeDef = Zod
     promise(): ZodPromise<this>;
     or<T extends ZodTypeAny>(option: T): ZodUnion<[this, T]>;
     and<T extends ZodTypeAny>(incoming: T): ZodIntersection<this, T>;
-    transform<NewOut>(transform: (arg: Output) => NewOut | Promise<NewOut>): ZodEffects<this, NewOut>;
+    transform<NewOut>(transform: (arg: Output, ctx: RefinementCtx) => NewOut | Promise<NewOut>): ZodEffects<this, NewOut>;
     default(def: util.noUndefined<Input>): ZodDefault<this>;
     default(def: () => util.noUndefined<Input>): ZodDefault<this>;
     describe(description: string): this;
@@ -275,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;
@@ -361,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]>;
@@ -589,7 +569,7 @@ export declare type RefinementEffect<T> = {
 };
 export declare type TransformEffect<T> = {
     type: "transform";
-    transform: (arg: T) => any;
+    transform: (arg: T, ctx: RefinementCtx) => any;
 };
 export declare type PreprocessEffect<T> = {
     type: "preprocess";

package/lib/types.js

@@ -223,8 +223,6 @@ class ZodType {
         });
     }
     optional() {
-        ("");
-        ("asdf");
         return ZodOptional.create(this);
     }
     nullable() {
@@ -2117,22 +2115,22 @@ class ZodEffects extends ZodType {
                 });
             }
         }
+        const checkCtx = {
+            addIssue: (arg) => {
+                (0, parseUtil_1.addIssueToContext)(ctx, arg);
+                if (arg.fatal) {
+                    status.abort();
+                }
+                else {
+                    status.dirty();
+                }
+            },
+            get path() {
+                return ctx.path;
+            },
+        };
+        checkCtx.addIssue = checkCtx.addIssue.bind(checkCtx);
         if (effect.type === "refinement") {
-            const checkCtx = {
-                addIssue: (arg) => {
-                    (0, parseUtil_1.addIssueToContext)(ctx, arg);
-                    if (arg.fatal) {
-                        status.abort();
-                    }
-                    else {
-                        status.dirty();
-                    }
-                },
-                get path() {
-                    return ctx.path;
-                },
-            };
-            checkCtx.addIssue = checkCtx.addIssue.bind(checkCtx);
             const executeRefinement = (acc
             // effect: RefinementEffect<any>
             ) => {
@@ -2186,11 +2184,11 @@ class ZodEffects extends ZodType {
                 // }
                 if (!(0, parseUtil_1.isValid)(base))
                     return base;
-                const result = effect.transform(base.value);
+                const result = effect.transform(base.value, checkCtx);
                 if (result instanceof Promise) {
                     throw new Error(`Asynchronous transform encountered during synchronous parse operation. Use .parseAsync instead.`);
                 }
-                return (0, parseUtil_1.OK)(result);
+                return { status: status.value, value: result };
             }
             else {
                 return this._def.schema
@@ -2202,7 +2200,7 @@ class ZodEffects extends ZodType {
                     // if (base.status === "dirty") {
                     //   return { status: "dirty", value: base.value };
                     // }
-                    return Promise.resolve(effect.transform(base.value)).then(parseUtil_1.OK);
+                    return Promise.resolve(effect.transform(base.value, checkCtx)).then(parseUtil_1.OK);
                 });
             }
         }

package/package.json

@@ -1,21 +1,22 @@
 {
   "name": "zod",
-  "version": "3.14.4",
+  "version": "3.15.1",
   "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",
@@ -86,6 +87,7 @@
     "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"