zod 4.3.0-canary.20251222T195342 → 4.3.0-canary.20251222T205904

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zod",
-  "version": "4.3.0-canary.20251222T195342",
+  "version": "4.3.0-canary.20251222T205904",
   "type": "module",
   "license": "MIT",
   "author": "Colin McDonnell <zod@colinhacks.com>",

package/src/v4/classic/schemas.ts

@@ -1540,6 +1540,10 @@ export interface ZodMap<Key extends core.SomeType = core.$ZodType, Value extends
   "~standard": ZodStandardSchemaWithJSON<this>;
   keyType: Key;
   valueType: Value;
+  min(minSize: number, params?: string | core.$ZodCheckMinSizeParams): this;
+  nonempty(params?: string | core.$ZodCheckMinSizeParams): this;
+  max(maxSize: number, params?: string | core.$ZodCheckMaxSizeParams): this;
+  size(size: number, params?: string | core.$ZodCheckSizeEqualsParams): this;
 }
 export const ZodMap: core.$constructor<ZodMap> = /*@__PURE__*/ core.$constructor("ZodMap", (inst, def) => {
   core.$ZodMap.init(inst, def);
@@ -1547,6 +1551,10 @@ export const ZodMap: core.$constructor<ZodMap> = /*@__PURE__*/ core.$constructor
   inst._zod.processJSONSchema = (ctx, json, params) => processors.mapProcessor(inst, ctx, json, params);
   inst.keyType = def.keyType;
   inst.valueType = def.valueType;
+  inst.min = (...args) => inst.check(core._minSize(...args));
+  inst.nonempty = (params) => inst.check(core._minSize(1, params));
+  inst.max = (...args) => inst.check(core._maxSize(...args));
+  inst.size = (...args) => inst.check(core._size(...args));
 });
 
 export function map<Key extends core.SomeType, Value extends core.SomeType>(

package/src/v4/classic/tests/map.test.ts

@@ -4,6 +4,12 @@ import * as z from "zod/v4";
 const stringMap = z.map(z.string(), z.string());
 type stringMap = z.infer<typeof stringMap>;
 
+const minTwo = stringMap.min(2);
+const maxTwo = stringMap.max(2);
+const justTwo = stringMap.size(2);
+const nonEmpty = stringMap.nonempty();
+const nonEmptyMax = stringMap.nonempty().max(2);
+
 test("type inference", () => {
   expectTypeOf<stringMap>().toEqualTypeOf<Map<string, string>>();
 });
@@ -24,6 +30,75 @@ test("valid parse", () => {
   `);
 });
 
+test("valid parse: size-related methods", () => {
+  expect(() => {
+    minTwo.parse(
+      new Map([
+        ["a", "b"],
+        ["c", "d"],
+      ])
+    );
+    minTwo.parse(
+      new Map([
+        ["a", "b"],
+        ["c", "d"],
+        ["e", "f"],
+      ])
+    );
+    maxTwo.parse(
+      new Map([
+        ["a", "b"],
+        ["c", "d"],
+      ])
+    );
+    maxTwo.parse(new Map([["a", "b"]]));
+    justTwo.parse(
+      new Map([
+        ["a", "b"],
+        ["c", "d"],
+      ])
+    );
+    nonEmpty.parse(new Map([["a", "b"]]));
+    nonEmptyMax.parse(
+      new Map([
+        ["a", "b"],
+        ["c", "d"],
+      ])
+    );
+  }).not.toThrow();
+
+  const sizeZeroResult = stringMap.parse(new Map());
+  expect(sizeZeroResult.size).toBe(0);
+
+  const sizeTwoResult = minTwo.parse(
+    new Map([
+      ["a", "b"],
+      ["c", "d"],
+    ])
+  );
+  expect(sizeTwoResult.size).toBe(2);
+});
+
+test("failing when parsing empty map in nonempty ", () => {
+  const result = nonEmpty.safeParse(new Map());
+  expect(result.success).toEqual(false);
+  expect(result.error!.issues.length).toEqual(1);
+  expect(result.error!.issues[0].code).toEqual("too_small");
+});
+
+test("failing when map is bigger than max() ", () => {
+  const result = maxTwo.safeParse(
+    new Map([
+      ["a", "b"],
+      ["c", "d"],
+      ["e", "f"],
+    ])
+  );
+  expect(result.success).toEqual(false);
+  expect(result.error!.issues.length).toEqual(1);
+  expect(result.error!.issues[0].code).toEqual("too_big");
+});
+
 test("valid parse async", async () => {
   const asyncMap = z.map(
     z.string().refine(async () => false, "bad key"),
@@ -194,3 +269,62 @@ test("map with object keys", () => {
     ]]
   `);
 });
+
+test("min/max", async () => {
+  const schema = stringMap.min(4).max(5);
+
+  const r1 = schema.safeParse(
+    new Map([
+      ["a", "a"],
+      ["b", "b"],
+      ["c", "c"],
+      ["d", "d"],
+    ])
+  );
+  expect(r1.success).toEqual(true);
+
+  const r2 = schema.safeParse(
+    new Map([
+      ["a", "a"],
+      ["b", "b"],
+      ["c", "c"],
+    ])
+  );
+  expect(r2.success).toEqual(false);
+  expect(r2.error!.issues).toMatchInlineSnapshot(`
+    [
+      {
+        "code": "too_small",
+        "inclusive": true,
+        "message": "Too small: expected map to have >=4 entries",
+        "minimum": 4,
+        "origin": "map",
+        "path": [],
+      },
+    ]
+  `);
+
+  const r3 = schema.safeParse(
+    new Map([
+      ["a", "a"],
+      ["b", "b"],
+      ["c", "c"],
+      ["d", "d"],
+      ["e", "e"],
+      ["f", "f"],
+    ])
+  );
+  expect(r3.success).toEqual(false);
+  expect(r3.error!.issues).toMatchInlineSnapshot(`
+    [
+      {
+        "code": "too_big",
+        "inclusive": true,
+        "maximum": 5,
+        "message": "Too big: expected map to have <=5 entries",
+        "origin": "map",
+        "path": [],
+      },
+    ]
+  `);
+});

package/src/v4/locales/en.ts

@@ -31,6 +31,7 @@ const error: () => errors.$ZodErrorMap = () => {
     file: { unit: "bytes", verb: "to have" },
     array: { unit: "items", verb: "to have" },
     set: { unit: "items", verb: "to have" },
+    map: { unit: "entries", verb: "to have" },
   };
 
   function getSizing(origin: string): { unit: string; verb: string } | null {

package/v4/classic/schemas.cjs

@@ -826,6 +826,10 @@ exports.ZodMap = core.$constructor("ZodMap", (inst, def) => {
     inst._zod.processJSONSchema = (ctx, json, params) => processors.mapProcessor(inst, ctx, json, params);
     inst.keyType = def.keyType;
     inst.valueType = def.valueType;
+    inst.min = (...args) => inst.check(core._minSize(...args));
+    inst.nonempty = (params) => inst.check(core._minSize(1, params));
+    inst.max = (...args) => inst.check(core._maxSize(...args));
+    inst.size = (...args) => inst.check(core._size(...args));
 });
 function map(keyType, valueType, params) {
     return new exports.ZodMap({

package/v4/classic/schemas.d.cts

@@ -514,6 +514,10 @@ export interface ZodMap<Key extends core.SomeType = core.$ZodType, Value extends
     "~standard": ZodStandardSchemaWithJSON<this>;
     keyType: Key;
     valueType: Value;
+    min(minSize: number, params?: string | core.$ZodCheckMinSizeParams): this;
+    nonempty(params?: string | core.$ZodCheckMinSizeParams): this;
+    max(maxSize: number, params?: string | core.$ZodCheckMaxSizeParams): this;
+    size(size: number, params?: string | core.$ZodCheckSizeEqualsParams): this;
 }
 export declare const ZodMap: core.$constructor<ZodMap>;
 export declare function map<Key extends core.SomeType, Value extends core.SomeType>(keyType: Key, valueType: Value, params?: string | core.$ZodMapParams): ZodMap<Key, Value>;

package/v4/classic/schemas.d.ts

@@ -514,6 +514,10 @@ export interface ZodMap<Key extends core.SomeType = core.$ZodType, Value extends
     "~standard": ZodStandardSchemaWithJSON<this>;
     keyType: Key;
     valueType: Value;
+    min(minSize: number, params?: string | core.$ZodCheckMinSizeParams): this;
+    nonempty(params?: string | core.$ZodCheckMinSizeParams): this;
+    max(maxSize: number, params?: string | core.$ZodCheckMaxSizeParams): this;
+    size(size: number, params?: string | core.$ZodCheckSizeEqualsParams): this;
 }
 export declare const ZodMap: core.$constructor<ZodMap>;
 export declare function map<Key extends core.SomeType, Value extends core.SomeType>(keyType: Key, valueType: Value, params?: string | core.$ZodMapParams): ZodMap<Key, Value>;

package/v4/classic/schemas.js

@@ -709,6 +709,10 @@ export const ZodMap = /*@__PURE__*/ core.$constructor("ZodMap", (inst, def) => {
     inst._zod.processJSONSchema = (ctx, json, params) => processors.mapProcessor(inst, ctx, json, params);
     inst.keyType = def.keyType;
     inst.valueType = def.valueType;
+    inst.min = (...args) => inst.check(core._minSize(...args));
+    inst.nonempty = (params) => inst.check(core._minSize(1, params));
+    inst.max = (...args) => inst.check(core._maxSize(...args));
+    inst.size = (...args) => inst.check(core._size(...args));
 });
 export function map(keyType, valueType, params) {
     return new ZodMap({

package/v4/locales/en.cjs

@@ -53,6 +53,7 @@ const error = () => {
         file: { unit: "bytes", verb: "to have" },
         array: { unit: "items", verb: "to have" },
         set: { unit: "items", verb: "to have" },
+        map: { unit: "entries", verb: "to have" },
     };
     function getSizing(origin) {
         return Sizable[origin] ?? null;

package/v4/locales/en.js

@@ -25,6 +25,7 @@ const error = () => {
         file: { unit: "bytes", verb: "to have" },
         array: { unit: "items", verb: "to have" },
         set: { unit: "items", verb: "to have" },
+        map: { unit: "entries", verb: "to have" },
     };
     function getSizing(origin) {
         return Sizable[origin] ?? null;