refactor: add isZodType

Author: joshunrau

src/__tests__/zod4.test.ts

@@ -3,7 +3,7 @@ import { describe, expect, expectTypeOf, it, test } from 'vitest';
 import { z as z3 } from 'zod/v3';
 import { z as z4 } from 'zod/v4';
 
-import { isZodTypeLike, isZodV3Type } from '../zod4.js';
+import { isZodType, isZodTypeLike } from '../zod4.js';
 
 import type {
   ZodErrorLike,
@@ -71,28 +71,28 @@ describe('isZodTypeLike', () => {
   });
 });
 
-describe('isZodV3Type', () => {
+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');
 
   it('should return true for an instance of ZodNumber', () => {
-    expect(isZodV3Type(z3.number())).toBe(true);
+    expect(isZodType(z3.number(), { version: 3 })).toBe(true);
   });
   it('should return true for an instance of ZodObject', () => {
-    expect(isZodV3Type(z3.object({}))).toBe(true);
+    expect(isZodType(z3.object({}), { version: 3 })).toBe(true);
   });
   it('should return false for null', () => {
-    expect(isZodV3Type(null)).toBe(false);
+    expect(isZodType(null, { version: 3 })).toBe(false);
   });
   it('should return false for any empty object', () => {
-    expect(isZodV3Type({})).toBe(false);
+    expect(isZodType({}, { version: 3 })).toBe(false);
   });
   it('should return false for an object with a null prototype', () => {
-    expect(isZodV3Type(Object.create(null))).toBe(false);
+    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(isZodV3Type(input)).toBe(true);
+    expect(isZodType(input, { version: 3 })).toBe(true);
   });
 });

src/zod4.ts

@@ -2,34 +2,34 @@ import type { z as z3 } from 'zod/v3';
 
 import { isObject, isObjectLike, isPlainObject } from './object.js';
 
-export type ZodIssueLike = {
+type ZodIssueLike = {
   [key: string]: any;
   readonly code: string;
   readonly message: string;
   readonly path: PropertyKey[];
 };
 
-export type ZodErrorLike = {
+type ZodErrorLike = {
   cause?: unknown;
   issues: ZodIssueLike[];
   name: string;
 };
 
-export type ZodSafeParseSuccessLike<TOutput> = {
+type ZodSafeParseSuccessLike<TOutput> = {
   data: TOutput;
   error?: never;
   success: true;
 };
 
-export type ZodSafeParseErrorLike = {
+type ZodSafeParseErrorLike = {
   data?: never;
   error: ZodErrorLike;
   success: false;
 };
 
-export type ZodSafeParseResultLike<T> = ZodSafeParseErrorLike | ZodSafeParseSuccessLike<T>;
+type ZodSafeParseResultLike<T> = ZodSafeParseErrorLike | ZodSafeParseSuccessLike<T>;
 
-export type ZodTypeLike<TOutput, TInput = unknown> = {
+type ZodTypeLike<TOutput, TInput = unknown> = {
   readonly _input: TInput;
   readonly _output: TOutput;
   safeParseAsync: (data: unknown) => Promise<ZodSafeParseResultLike<TOutput>>;
@@ -39,18 +39,32 @@ export type ZodTypeLike<TOutput, TInput = unknown> = {
   };
 };
 
-export function isZodTypeLike(arg: unknown): arg is ZodTypeLike<unknown> {
+function isZodTypeLike(arg: unknown): arg is ZodTypeLike<unknown> {
   if (!isObjectLike(arg)) {
     return false;
   }
   const standardSchema: unknown = Reflect.get(arg, '~standard');
   return isPlainObject(standardSchema) && standardSchema.vendor === 'zod';
 }
 
-export function isZodV3Type(arg: unknown): arg is z3.ZodTypeAny {
+function isZodV3Type(arg: unknown): arg is z3.ZodTypeAny {
   let prototype: null | object = null;
   if (isObject(arg) && isObject(arg.constructor)) {
     prototype = Reflect.getPrototypeOf(arg.constructor);
   }
   return Boolean(prototype && Reflect.get(prototype, 'name') === 'ZodType');
 }
+
+function isZodType(arg: unknown, _options: { version: 3 }): arg is z3.ZodTypeAny {
+  return isZodV3Type(arg);
+}
+
+export { isZodType, isZodTypeLike };
+export type {
+  ZodErrorLike,
+  ZodIssueLike,
+  ZodSafeParseErrorLike,
+  ZodSafeParseResultLike,
+  ZodSafeParseSuccessLike,
+  ZodTypeLike
+};