zod 3.25.56 → 3.25.57

package/README.md

@@ -138,7 +138,7 @@ When validation fails, the `.parse()` method will throw a `ZodError` instance wi
 try {
   Player.parse({ username: 42, xp: "100" });
 } catch (err) {
-  if (error instanceof z.ZodError) {
+  if (err instanceof z.ZodError) {
     err.issues;
     /* [
       {

package/dist/cjs/v4/classic/schemas.js

@@ -1085,7 +1085,8 @@ function _instanceof(cls, params = {
 const stringbool = (...args) => core._stringbool({
     Pipe: exports.ZodPipe,
     Boolean: exports.ZodBoolean,
-    Unknown: exports.ZodUnknown,
+    String: exports.ZodString,
+    Transform: exports.ZodTransform,
 }, ...args);
 exports.stringbool = stringbool;
 function json(params) {

package/dist/cjs/v4/core/api.js

@@ -957,61 +957,57 @@ function _refine(Class, fn, _params) {
 }
 function _stringbool(Classes, _params) {
     const { case: _case, error, truthy, falsy } = util.normalizeParams(_params);
-    const trueValues = new Set(truthy ?? ["true", "1", "yes", "on", "y", "enabled"]);
-    const falseValues = new Set(falsy ?? ["false", "0", "no", "off", "n", "disabled"]);
+    let truthyArray = truthy ?? ["true", "1", "yes", "on", "y", "enabled"];
+    let falsyArray = falsy ?? ["false", "0", "no", "off", "n", "disabled"];
+    if (_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 _Unknown = Classes.Unknown ?? schemas.$ZodUnknown;
-    const inst = new _Unknown({
-        type: "unknown",
-        checks: [
-            {
-                _zod: {
-                    check: (ctx) => {
-                        if (typeof ctx.value === "string") {
-                            let data = ctx.value;
-                            if (_case !== "sensitive")
-                                data = data.toLowerCase();
-                            if (trueValues.has(data)) {
-                                ctx.value = true;
-                            }
-                            else if (falseValues.has(data)) {
-                                ctx.value = false;
-                            }
-                            else {
-                                ctx.issues.push({
-                                    code: "invalid_value",
-                                    expected: "stringbool",
-                                    values: [...trueValues, ...falseValues],
-                                    input: ctx.value,
-                                    inst,
-                                });
-                            }
-                        }
-                        else {
-                            ctx.issues.push({
-                                code: "invalid_type",
-                                expected: "string",
-                                input: ctx.value,
-                            });
-                        }
-                    },
-                    def: {
-                        check: "custom",
-                    },
-                    onattach: [],
-                },
-            },
-        ],
+    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 (_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,
+                });
+                return {};
+            }
+        },
+        error,
+    });
+    const innerPipe = new _Pipe({
+        type: "pipe",
+        in: new _String({ type: "string", error }),
+        out: tx,
         error,
     });
-    return new _Pipe({
+    const outerPipe = new _Pipe({
         type: "pipe",
-        in: inst,
+        in: innerPipe,
         out: new _Boolean({
             type: "boolean",
             error,
         }),
         error,
     });
+    return outerPipe;
 }

package/dist/cjs/v4/mini/schemas.js

@@ -814,7 +814,8 @@ function _instanceof(cls, params = {
 const stringbool = (...args) => core._stringbool({
     Pipe: exports.ZodMiniPipe,
     Boolean: exports.ZodMiniBoolean,
-    Unknown: exports.ZodMiniUnknown,
+    String: exports.ZodMiniString,
+    Transform: exports.ZodMiniTransform,
 }, ...args);
 exports.stringbool = stringbool;
 function json() {

package/dist/esm/v4/classic/schemas.js

@@ -984,7 +984,8 @@ export { _instanceof as instanceof };
 export const stringbool = (...args) => core._stringbool({
     Pipe: ZodPipe,
     Boolean: ZodBoolean,
-    Unknown: ZodUnknown,
+    String: ZodString,
+    Transform: ZodTransform,
 }, ...args);
 export function json(params) {
     const jsonSchema = lazy(() => {

package/dist/esm/v4/core/api.js

@@ -826,61 +826,57 @@ export function _refine(Class, fn, _params) {
 }
 export function _stringbool(Classes, _params) {
     const { case: _case, error, truthy, falsy } = util.normalizeParams(_params);
-    const trueValues = new Set(truthy ?? ["true", "1", "yes", "on", "y", "enabled"]);
-    const falseValues = new Set(falsy ?? ["false", "0", "no", "off", "n", "disabled"]);
+    let truthyArray = truthy ?? ["true", "1", "yes", "on", "y", "enabled"];
+    let falsyArray = falsy ?? ["false", "0", "no", "off", "n", "disabled"];
+    if (_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 _Unknown = Classes.Unknown ?? schemas.$ZodUnknown;
-    const inst = new _Unknown({
-        type: "unknown",
-        checks: [
-            {
-                _zod: {
-                    check: (ctx) => {
-                        if (typeof ctx.value === "string") {
-                            let data = ctx.value;
-                            if (_case !== "sensitive")
-                                data = data.toLowerCase();
-                            if (trueValues.has(data)) {
-                                ctx.value = true;
-                            }
-                            else if (falseValues.has(data)) {
-                                ctx.value = false;
-                            }
-                            else {
-                                ctx.issues.push({
-                                    code: "invalid_value",
-                                    expected: "stringbool",
-                                    values: [...trueValues, ...falseValues],
-                                    input: ctx.value,
-                                    inst,
-                                });
-                            }
-                        }
-                        else {
-                            ctx.issues.push({
-                                code: "invalid_type",
-                                expected: "string",
-                                input: ctx.value,
-                            });
-                        }
-                    },
-                    def: {
-                        check: "custom",
-                    },
-                    onattach: [],
-                },
-            },
-        ],
+    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 (_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,
+                });
+                return {};
+            }
+        },
+        error,
+    });
+    const innerPipe = new _Pipe({
+        type: "pipe",
+        in: new _String({ type: "string", error }),
+        out: tx,
         error,
     });
-    return new _Pipe({
+    const outerPipe = new _Pipe({
         type: "pipe",
-        in: inst,
+        in: innerPipe,
         out: new _Boolean({
             type: "boolean",
             error,
         }),
         error,
     });
+    return outerPipe;
 }

package/dist/esm/v4/mini/schemas.js

@@ -710,7 +710,8 @@ export { _instanceof as instanceof };
 export const stringbool = (...args) => core._stringbool({
     Pipe: ZodMiniPipe,
     Boolean: ZodMiniBoolean,
-    Unknown: ZodMiniUnknown,
+    String: ZodMiniString,
+    Transform: ZodMiniTransform,
 }, ...args);
 export function json() {
     const jsonSchema = _lazy(() => {

package/dist/types/v4/classic/schemas.d.ts

@@ -511,7 +511,7 @@ export interface ZodLiteral<T extends util.Primitive = util.Primitive> extends _
     value: T;
 }
 export declare const ZodLiteral: core.$constructor<ZodLiteral>;
-export declare function literal<const T extends Array<util.Literal>>(value: T, params?: string | core.$ZodLiteralParams): ZodLiteral<T[number]>;
+export declare function literal<const T extends ReadonlyArray<util.Literal>>(value: T, params?: string | core.$ZodLiteralParams): ZodLiteral<T[number]>;
 export declare function literal<const T extends util.Literal>(value: T, params?: string | core.$ZodLiteralParams): ZodLiteral<T>;
 export interface ZodFile extends _ZodType<core.$ZodFileInternals>, core.$ZodFile {
     min(size: number, params?: string | core.$ZodCheckMinSizeParams): this;
@@ -603,7 +603,7 @@ export declare function superRefine<T>(fn: (arg: T, payload: RefinementCtx<T>) =
 type ZodInstanceOfParams = core.Params<ZodCustom, core.$ZodIssueCustom, "type" | "check" | "checks" | "fn" | "abort" | "error" | "params" | "path">;
 declare function _instanceof<T extends typeof util.Class>(cls: T, params?: ZodInstanceOfParams): ZodCustom<InstanceType<T>, InstanceType<T>>;
 export { _instanceof as instanceof };
-export declare const stringbool: (_params?: string | core.$ZodStringBoolParams) => ZodPipe<ZodUnknown, ZodBoolean>;
+export declare const stringbool: (_params?: string | core.$ZodStringBoolParams) => ZodPipe<ZodPipe<ZodString, ZodTransform<boolean, string>>, ZodBoolean>;
 type _ZodJSONSchema = ZodUnion<[
     ZodString,
     ZodNumber,

package/dist/types/v4/core/api.d.ts

@@ -260,14 +260,15 @@ export interface $ZodStringBoolParams extends TypeParams {
     truthy?: string[];
     falsy?: string[];
     /**
-     * Options `"sensitive"`, `"insensitive"`
+     * Options: `"sensitive"`, `"insensitive"`
      *
-     * Defaults to `"insensitive"`
+     * @default `"insensitive"`
      */
     case?: "sensitive" | "insensitive" | undefined;
 }
 export declare function _stringbool(Classes: {
     Pipe?: typeof schemas.$ZodPipe;
     Boolean?: typeof schemas.$ZodBoolean;
-    Unknown?: typeof schemas.$ZodUnknown;
-}, _params?: string | $ZodStringBoolParams): schemas.$ZodPipe<schemas.$ZodUnknown, schemas.$ZodBoolean<boolean>>;
+    Transform?: typeof schemas.$ZodTransform;
+    String?: typeof schemas.$ZodString;
+}, _params?: string | $ZodStringBoolParams): schemas.$ZodPipe<schemas.$ZodPipe<schemas.$ZodString, schemas.$ZodTransform<boolean, string>>, schemas.$ZodBoolean<boolean>>;

package/dist/types/v4/core/checks.d.ts

@@ -27,7 +27,7 @@ export interface $ZodCheckLessThanDef extends $ZodCheckDef {
 }
 export interface $ZodCheckLessThanInternals<T extends util.Numeric = util.Numeric> extends $ZodCheckInternals<T> {
     def: $ZodCheckLessThanDef;
-    issc: errors.$ZodIssueTooSmall<T>;
+    issc: errors.$ZodIssueTooBig<T>;
 }
 export interface $ZodCheckLessThan<T extends util.Numeric = util.Numeric> extends $ZodCheck<T> {
     _zod: $ZodCheckLessThanInternals<T>;

package/dist/types/v4/mini/schemas.d.ts

@@ -254,7 +254,7 @@ export declare function nativeEnum<T extends util.EnumLike>(entries: T, params?:
 export interface ZodMiniLiteral<T extends util.Primitive = util.Primitive> extends _ZodMiniType<core.$ZodLiteralInternals<T>> {
 }
 export declare const ZodMiniLiteral: core.$constructor<ZodMiniLiteral>;
-export declare function literal<const T extends Array<util.Literal>>(value: T, params?: string | core.$ZodLiteralParams): ZodMiniLiteral<T[number]>;
+export declare function literal<const T extends ReadonlyArray<util.Literal>>(value: T, params?: string | core.$ZodLiteralParams): ZodMiniLiteral<T[number]>;
 export declare function literal<const T extends util.Literal>(value: T, params?: string | core.$ZodLiteralParams): ZodMiniLiteral<T>;
 export interface ZodMiniFile extends _ZodMiniType<core.$ZodFileInternals> {
 }
@@ -330,7 +330,7 @@ declare abstract class Class {
 }
 declare function _instanceof<T extends typeof Class>(cls: T, params?: core.$ZodCustomParams): ZodMiniCustom<InstanceType<T>, InstanceType<T>>;
 export { _instanceof as instanceof };
-export declare const stringbool: (_params?: string | core.$ZodStringBoolParams) => ZodMiniPipe<ZodMiniUnknown, ZodMiniBoolean<boolean>>;
+export declare const stringbool: (_params?: string | core.$ZodStringBoolParams) => ZodMiniPipe<ZodMiniPipe<ZodMiniString, ZodMiniTransform<boolean, string>>, ZodMiniBoolean>;
 type _ZodMiniJSONSchema = ZodMiniUnion<[
     ZodMiniString,
     ZodMiniNumber,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zod",
-  "version": "3.25.56",
+  "version": "3.25.57",
   "type": "module",
   "author": "Colin McDonnell <zod@colinhacks.com>",
   "description": "TypeScript-first schema declaration and validation library with static type inference",