test: add isZodType tests for v4

Author: joshunrau

src/__tests__/zod4.test.ts

@@ -72,27 +72,62 @@ describe('isZodTypeLike', () => {
 });
 
 describe('isZodType', () => {
-  // since we use require here, the prototype chain in the cjs module will be different than the esm build
-  const { z: z3_2 } = require('zod/v3') as typeof import('zod/v3');
+  describe('v3', () => {
+    // since we use require here, the prototype chain in the cjs module will be different than the esm build
+    const { z: z3_2 } = require('zod/v3') as typeof import('zod/v3');
 
-  it('should return true for an instance of ZodNumber', () => {
-    expect(isZodType(z3.number(), { version: 3 })).toBe(true);
+    it('should return true for an instance of ZodNumber', () => {
+      expect(isZodType(z3.number(), { version: 3 })).toBe(true);
+    });
+    it('should return true for an instance of ZodObject', () => {
+      expect(isZodType(z3.object({}), { version: 3 })).toBe(true);
+    });
+    it('should return false for null', () => {
+      expect(isZodType(null, { version: 3 })).toBe(false);
+    });
+    it('should return false for any empty object', () => {
+      expect(isZodType({}, { version: 3 })).toBe(false);
+    });
+    it('should return false for an object with a null prototype', () => {
+      expect(isZodType(Object.create(null), { version: 3 })).toBe(false);
+    });
+    it('should return false for a Zod v4 object', () => {
+      expect(isZodType(z4.object({}), { version: 3 })).toBe(false);
+    });
+    it('should return true for a ZodObject created in a different context', () => {
+      const input = z3_2.object({});
+      expect(input).not.toBeInstanceOf(z3.ZodType);
+      expect(isZodType(input, { version: 3 })).toBe(true);
+    });
   });
-  it('should return true for an instance of ZodObject', () => {
-    expect(isZodType(z3.object({}), { version: 3 })).toBe(true);
-  });
-  it('should return false for null', () => {
-    expect(isZodType(null, { version: 3 })).toBe(false);
-  });
-  it('should return false for any empty object', () => {
-    expect(isZodType({}, { version: 3 })).toBe(false);
-  });
-  it('should return false for an object with a null prototype', () => {
-    expect(isZodType(Object.create(null), { version: 3 })).toBe(false);
-  });
-  it('should return true for a ZodObject created in a different context', () => {
-    const input = z3_2.object({});
-    expect(input).not.toBeInstanceOf(z3.ZodType);
-    expect(isZodType(input, { version: 3 })).toBe(true);
+  describe('v4', () => {
+    it('should return true for an instance of ZodNumber', () => {
+      expect(isZodType(z4.number(), { version: 4 })).toBe(true);
+    });
+    it('should return true for an instance of ZodObject', () => {
+      expect(isZodType(z4.object({}), { version: 4 })).toBe(true);
+    });
+    it('should return false for null', () => {
+      expect(isZodType(null, { version: 4 })).toBe(false);
+    });
+    it('should return false for any empty object', () => {
+      expect(isZodType({}, { version: 4 })).toBe(false);
+    });
+    it('should return false for a Zod v3 object', () => {
+      expect(isZodType(z3.object({}), { version: 4 })).toBe(false);
+    });
+    it('should return true for a ZodObject created in a different context', () => {
+      const base = z4.object({});
+      const input = {
+        _zod: {
+          version: structuredClone(base._zod.version)
+        },
+        '~standard': {
+          vendor: base['~standard'].vendor
+        }
+      };
+      expect(input).not.toBeInstanceOf(z4.ZodType);
+      expect(isZodType(input, { version: 4 })).toBe(true);
+    });
   });
 });

src/zod4.ts

@@ -1,4 +1,5 @@
 import type { z as z3 } from 'zod/v3';
+import type { z as z4 } from 'zod/v4';
 
 import { isObject, isObjectLike, isPlainObject } from './object.js';
 
@@ -30,6 +31,7 @@ type ZodSafeParseErrorLike = {
 type ZodSafeParseResultLike<T> = ZodSafeParseErrorLike | ZodSafeParseSuccessLike<T>;
 
 type ZodTypeLike<TOutput, TInput = unknown> = {
+  [key: string]: any;
   readonly _input: TInput;
   readonly _output: TOutput;
   safeParseAsync: (data: unknown) => Promise<ZodSafeParseResultLike<TOutput>>;
@@ -55,8 +57,22 @@ function isZodV3Type(arg: unknown): arg is z3.ZodTypeAny {
   return Boolean(prototype && Reflect.get(prototype, 'name') === 'ZodType');
 }
 
-function isZodType(arg: unknown, _options: { version: 3 }): arg is z3.ZodTypeAny {
-  return isZodV3Type(arg);
+function isZodV4Type(arg: unknown): arg is z4.ZodType {
+  if (!isZodTypeLike(arg)) {
+    return false;
+  }
+  const zod: unknown = arg._zod;
+  if (!isPlainObject(zod)) {
+    return false;
+  }
+  const version: unknown = zod.version;
+  return isPlainObject(version) && version.major === 4;
+}
+
+function isZodType(arg: unknown, options: { version: 3 }): arg is z3.ZodTypeAny;
+function isZodType(arg: unknown, options: { version: 4 }): arg is z4.ZodType;
+function isZodType(arg: unknown, options: { version: 3 | 4 }): boolean {
+  return options.version === 3 ? isZodV3Type(arg) : isZodV4Type(arg);
 }
 
 export { isZodType, isZodTypeLike };