zod-compare 0.1.1

package/README.md

@@ -0,0 +1,98 @@
+# Zod Compare
+
+[![Build](https://github.com/lawvs/zod-compare/actions/workflows/build.yml/badge.svg)](https://github.com/lawvs/zod-compare/actions/workflows/build.yml)
+
+Compare two [Zod](https://zod.dev/) schemas recursively.
+
+`zod-compare` provides functions to compare Zod schemas, allowing you to determine whether two schemas are the same or compatible.
+
+## Installation
+
+```bash
+npm install zod zod-compare --save
+```
+
+## Usage
+
+```ts
+import { z } from "zod";
+import { isSameType, isCompatibleType } from "zod-compare";
+
+isSameType(z.string(), z.string()); // true
+isSameType(z.string(), z.number()); // false
+isSameType(
+  z.object({ name: z.string(), other: z.number() }),
+  z.object({ name: z.string() }),
+);
+// false
+
+isCompatibleType(
+  z.object({ name: z.string(), other: z.number() }),
+  z.object({ name: z.string() }),
+);
+// true
+```
+
+## Advanced Usage
+
+`isSameType` also offers an `interceptor` option, enabling you to tailor the comparison process according to your needs.
+
+```ts
+isSameType(
+  z.object({ name: z.string(), other: z.number() }),
+  z.object({ name: z.string() }),
+  {
+    interceptor: (a, b) => {
+      if (a instanceof z.ZodObject && b instanceof z.ZodObject) {
+        // return boolean to override the comparison result
+        return a.shape.name === b.shape.name;
+      }
+      // return other values to use the default comparison
+    },
+  },
+);
+// true
+```
+
+## Caveats
+
+`zod-compare` is designed to compare Zod schemas created by the developer.
+We do not have plans to support comparing schemas that include custom validation functions or other advanced Zod features.
+
+This tool will disregard any custom validations like `min`, `max`, `length`, among others.
+
+Furthermore, it cannot be utilized for comparing `ZodLazy`, `ZodEffects`, `ZodDefault`, `ZodCatch`, `ZodPipeline`, `ZodTransformer`, `ZodError` types.
+
+But you can use the `interceptor` option to customize the comparison process.
+
+## API
+
+### `isSameType`
+
+Compares two Zod schemas and returns `true` if they are the same.
+
+```ts
+function isSameType(
+  a: ZodType,
+  b: ZodType,
+  options?: {
+    interceptor?: (a: ZodType, b: ZodType) => boolean | undefined;
+  },
+): boolean;
+```
+
+### `isCompatibleType` (Unstable API)
+
+```ts
+function isCompatibleType(
+  a: ZodType,
+  b: ZodType,
+  options?: {
+    interceptor?: (a: ZodType, b: ZodType) => boolean | undefined;
+  },
+): boolean;
+```
+
+## License
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const t=require("zod"),a={deep:!0,ignoreOptional:!1,ignoreNullable:!1,ignoreReadOnly:!1,ignoreBranded:!1,ignoreValidations:!0,ignoreIntersectionsOrder:!1,interceptor:()=>{}},l=e=>e instanceof t.z.ZodString||e instanceof t.z.ZodNumber||e instanceof t.z.ZodNaN||e instanceof t.z.ZodBigInt||e instanceof t.z.ZodBoolean||e instanceof t.z.ZodDate||e instanceof t.z.ZodSymbol||e instanceof t.z.ZodUndefined||e instanceof t.z.ZodNull||e instanceof t.z.ZodAny||e instanceof t.z.ZodUnknown||e instanceof t.z.ZodNever||e instanceof t.z.ZodVoid,f=(e,n,d)=>{const r={...a,...d},u=r.interceptor(e,n,r);if(u===!0||u===!1)return u;if(e===void 0||n===void 0)throw new Error("Failed to compare type! "+e+" "+n);if(e===n)return!0;if(e.constructor!==n.constructor)return!1;if(!("typeName"in e._def)||!("typeName"in n._def))throw new Error("Failed to compare type! "+e._def+" "+n._def);if(e._def.typeName!==n._def.typeName)return!1;if(r.ignoreBranded)return e instanceof t.z.ZodBranded&&(e=e.unwrap()),n instanceof t.z.ZodBranded&&(n=n.unwrap()),f(e,n,r);if(e instanceof t.z.ZodBranded||n instanceof t.z.ZodBranded)return!1;if("unwrap"in e&&typeof e.unwrap=="function")return"unwrap"in n&&typeof n.unwrap=="function"?f(e.unwrap(),n.unwrap(),r):!1;if(!r.ignoreOptional&&e.isOptional()!==n.isOptional()||!r.ignoreNullable&&e.isNullable()!==n.isNullable())return!1;if(l(e))return!0;if(e instanceof t.z.ZodObject&&n instanceof t.z.ZodObject){const o=e.shape,s=n.shape;if(Object.keys(o).length!==Object.keys(s).length)return!1;for(const i in o)if(!(i in s)||!f(o[i],s[i],r))return!1;return!0}if(e instanceof t.z.ZodArray&&n instanceof t.z.ZodArray)return f(e.element,n.element,r);if(e instanceof t.z.ZodTuple&&n instanceof t.z.ZodTuple){if(e.items.length!==n.items.length)return!1;for(let o=0;o<e.items.length;o++)if(!f(e.items[o],n.items[o],r))return!1;return e._def.rest||n._def.rest?!e._def.rest||!n._def.rest?!1:f(e._def.rest,n._def.rest,r):!0}if(e instanceof t.z.ZodLiteral&&n instanceof t.z.ZodLiteral)return e.value===n.value;if(e instanceof t.z.ZodIntersection&&n instanceof t.z.ZodIntersection)return f(e._def.left,n._def.left,r)&&f(e._def.right,n._def.right,r);if(e instanceof t.z.ZodUnion&&n instanceof t.z.ZodUnion){if(e.options.length!==n.options.length)return!1;for(let o=0;o<e.options.length;o++)if(!f(e.options[o],n.options[o],r))return!1;return!0}if(e instanceof t.z.ZodReadonly&&n instanceof t.z.ZodReadonly)return f(e._def.innerType,n._def.innerType,r);if(e instanceof t.z.ZodRecord&&n instanceof t.z.ZodRecord||e instanceof t.z.ZodMap&&n instanceof t.z.ZodMap)return f(e.keySchema,n.keySchema,r)&&f(e.valueSchema,n.valueSchema,r);if(e instanceof t.z.ZodSet&&n instanceof t.z.ZodSet)return f(e._def.valueType,n._def.valueType,r);if(e instanceof t.z.ZodFunction&&n instanceof t.z.ZodFunction)return f(e.parameters(),n.parameters(),r)&&f(e.returnType(),n.returnType(),r);if(e instanceof t.z.ZodEnum&&n instanceof t.z.ZodEnum){const o=e.options,s=n.options;if(o.length!==s.length)return!1;for(let i=0;i<o.length;i++)if(o[i]!==s[i])return!1;return!0}if(e instanceof t.z.ZodNativeEnum&&n instanceof t.z.ZodNativeEnum){const o=e.enum,s=n.enum;if(Object.keys(o).length!==Object.keys(s).length)return!1;for(const i in o)if(o[i]!==s[i])return!1;return!0}throw console.error('Failed to compare type! "'+e,n),new Error("Unknown type! "+e._def.typeName+" "+n._def.typeName)},c=(e,n,d)=>{const r={...a,...d},u=r.interceptor(e,n,r);if(u===!0||u===!1)return u;if(f(e,n,r))return!0;if(!("typeName"in e._def)||!("typeName"in n._def))throw new Error("Failed to compare type! "+e._def+" "+n._def);if(n instanceof t.z.ZodOptional||n instanceof t.z.ZodNullable)return c(e,n.unwrap(),r);if(e instanceof t.z.ZodUnion&&n instanceof t.z.ZodUnion){for(let o=0;o<e.options.length;o++)if(!n.options.some(i=>c(i,n.options[o],r)))return!1;return!0}if(e instanceof t.z.ZodUnion)return e.options.every(o=>c(o,n,r));if(n instanceof t.z.ZodUnion)return n.options.some(o=>c(e,o,r));if(e.constructor!==n.constructor)return!1;if(e instanceof t.z.ZodObject&&n instanceof t.z.ZodObject){const o=e.shape,s=n.shape;if(Object.keys(o).length<Object.keys(s).length)return!1;for(const i in s)if(!(i in o)||!c(o[i],s[i],r))return!1;return!0}if(e instanceof t.z.ZodArray&&n instanceof t.z.ZodArray)return c(e.element,n.element,r);if(e instanceof t.z.ZodTuple&&n instanceof t.z.ZodTuple){if(e.items.length<n.items.length)return!1;for(let o=0;o<n.items.length;o++)if(!c(e.items[o],n.items[o],r))return!1;return n._def.rest?e._def.rest?c(e._def.rest,n._def.rest,r):!1:!0}throw new Error("Failed to compare types!"+e._def.typeName+" "+n._def.typeName)};exports.isCompatibleType=c;exports.isSameType=f;
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","sources":["../src/utils.ts","../src/is-same-type.ts","../src/is-compatible-type.ts"],"sourcesContent":["import { z, type ZodType } from \"zod\";\n\nexport interface IsSameTypeOptions {\n  deep: true;\n  /**\n   * Ignore all specific validations like min, max, length, email etc.\n   *\n   * You still can use `interceptor` to validate the type manually.\n   */\n  ignoreValidations: true;\n  ignoreOptional: boolean;\n  ignoreNullable: boolean;\n  ignoreReadOnly: false;\n  ignoreBranded: boolean;\n  ignoreIntersectionsOrder: false;\n  /**\n   * A function that provides custom logic for comparing two ZodType instances.\n   *\n   * If the function returns `true` or `false`, the result will be used as the comparison result.\n   * Otherwise, the default comparison logic will be used.\n   *\n   */\n  interceptor: (\n    a: ZodType,\n    b: ZodType,\n    options: IsSameTypeOptions,\n  ) => boolean | void;\n}\n\nexport interface IsCompatibleTypeOptions extends IsSameTypeOptions {\n  ignoreOptional: false;\n  ignoreNullable: false;\n}\n\nexport const DEFAULT_COMPARE_TYPE_OPTIONS = {\n  deep: true,\n  ignoreOptional: false,\n  ignoreNullable: false,\n  ignoreReadOnly: false,\n  ignoreBranded: false,\n  ignoreValidations: true,\n  ignoreIntersectionsOrder: false,\n  interceptor: () => {},\n} as const satisfies IsSameTypeOptions;\n\n// See ZodFirstPartyTypeKind\nexport const isPrimitiveType = (a: ZodType): boolean => {\n  return (\n    a instanceof z.ZodString ||\n    a instanceof z.ZodNumber ||\n    a instanceof z.ZodNaN ||\n    a instanceof z.ZodBigInt ||\n    a instanceof z.ZodBoolean ||\n    a instanceof z.ZodDate ||\n    a instanceof z.ZodSymbol ||\n    a instanceof z.ZodUndefined ||\n    a instanceof z.ZodNull ||\n    a instanceof z.ZodAny ||\n    a instanceof z.ZodUnknown ||\n    a instanceof z.ZodNever ||\n    a instanceof z.ZodVoid\n  );\n};\n","import type { EnumLike, ZodType } from \"zod\";\nimport { z } from \"zod\";\nimport {\n  type IsSameTypeOptions,\n  DEFAULT_COMPARE_TYPE_OPTIONS,\n  isPrimitiveType,\n} from \"./utils.ts\";\n\n/**\n * isSameType is a function that checks if two ZodTypes are the same.\n *\n * Caveats:\n * - The function does not validate specific criteria such as min or max values, length, email, etc.\n * - It excludes comparisons involving methods like .describe(), .catch(), .default(), .refine(), and .transform().\n * - When comparing definitions with .or and .and, they are assessed sequentially based on their order.\n *\n * @param a - The first ZodType to compare.\n * @param b - The second ZodType to compare.\n * @returns A boolean indicating whether the two types are the same.\n *\n * @throws Will throw an error if it encounters an unknown type.\n *\n * @example\n * ```ts\n * isSameType(z.string(), z.string()); // true\n * isSameType(z.string(), z.number()); // false\n * ```\n */\nexport const isSameType = (\n  a: ZodType,\n  b: ZodType,\n  options?: Partial<IsSameTypeOptions>,\n): boolean => {\n  const opts = { ...DEFAULT_COMPARE_TYPE_OPTIONS, ...options };\n  const interceptorResult = opts.interceptor(a, b, opts);\n  if (interceptorResult === true || interceptorResult === false) {\n    return interceptorResult;\n  }\n\n  if (a === undefined || b === undefined) {\n    throw new Error(\"Failed to compare type! \" + a + \" \" + b);\n  }\n\n  if (a === b) {\n    return true;\n  }\n\n  // compare constructor\n  if (a.constructor !== b.constructor) {\n    // https://stackoverflow.com/questions/24959862/how-to-tell-if-two-javascript-instances-are-of-the-same-class-type\n    return false;\n  }\n  // See https://github.com/colinhacks/zod/blob/master/src/types.ts\n  if (!(\"typeName\" in a._def) || !(\"typeName\" in b._def)) {\n    throw new Error(\"Failed to compare type! \" + a._def + \" \" + b._def);\n  }\n  if (a._def.typeName !== b._def.typeName) {\n    return false;\n  }\n\n  // ZodBranded\n  if (opts.ignoreBranded) {\n    if (a instanceof z.ZodBranded) {\n      a = a.unwrap();\n    }\n    if (b instanceof z.ZodBranded) {\n      b = b.unwrap();\n    }\n    return isSameType(a, b, opts);\n  } else {\n    if (a instanceof z.ZodBranded || b instanceof z.ZodBranded) {\n      // We can not distinguish different branded type\n      // throw new Error(\"Can not distinguish different branded type!\");\n      return false;\n    }\n  }\n\n  // ZodPromise ZodOptional ZodNullable ZodBranded\n  if (\"unwrap\" in a && typeof a.unwrap === \"function\") {\n    if (!(\"unwrap\" in b && typeof b.unwrap === \"function\")) {\n      return false;\n    }\n    return isSameType(a.unwrap(), b.unwrap(), opts);\n  }\n\n  if (!opts.ignoreOptional && a.isOptional() !== b.isOptional()) return false;\n  if (!opts.ignoreNullable && a.isNullable() !== b.isNullable()) return false;\n\n  if (isPrimitiveType(a)) {\n    // Already assert a and b are the same constructor\n    return true;\n  }\n\n  // ZodObject\n  if (a instanceof z.ZodObject && b instanceof z.ZodObject) {\n    const aShape = a.shape;\n    const bShape = b.shape;\n    if (Object.keys(aShape).length !== Object.keys(bShape).length) return false;\n    for (const key in aShape) {\n      if (!(key in bShape)) return false;\n      if (!isSameType(aShape[key], bShape[key], opts)) return false;\n    }\n    return true;\n  }\n\n  // ZodArray\n  if (a instanceof z.ZodArray && b instanceof z.ZodArray) {\n    return isSameType(a.element, b.element, opts);\n  }\n\n  // ZodTuple\n  if (a instanceof z.ZodTuple && b instanceof z.ZodTuple) {\n    if (a.items.length !== b.items.length) return false;\n    for (let i = 0; i < a.items.length; i++) {\n      if (!isSameType(a.items[i], b.items[i], opts)) return false;\n    }\n    // Compare rest\n    if (a._def.rest || b._def.rest) {\n      // If one has rest, the other must have rest\n      if (!a._def.rest || !b._def.rest) return false;\n      return isSameType(a._def.rest, b._def.rest, opts);\n    }\n    return true;\n  }\n\n  // ZodLiteral\n  if (a instanceof z.ZodLiteral && b instanceof z.ZodLiteral) {\n    return a.value === b.value;\n  }\n\n  // ZodIntersection aka and\n  if (a instanceof z.ZodIntersection && b instanceof z.ZodIntersection) {\n    return (\n      isSameType(a._def.left, b._def.left, opts) &&\n      isSameType(a._def.right, b._def.right, opts)\n    );\n  }\n\n  // ZodUnion aka or\n  if (a instanceof z.ZodUnion && b instanceof z.ZodUnion) {\n    if (a.options.length !== b.options.length) return false;\n    for (let i = 0; i < a.options.length; i++) {\n      if (!isSameType(a.options[i], b.options[i], opts)) return false;\n    }\n    return true;\n  }\n\n  // ZodReadonly\n  if (a instanceof z.ZodReadonly && b instanceof z.ZodReadonly) {\n    return isSameType(a._def.innerType, b._def.innerType, opts);\n  }\n\n  // ZodRecord / ZodMap\n  if (\n    (a instanceof z.ZodRecord && b instanceof z.ZodRecord) ||\n    (a instanceof z.ZodMap && b instanceof z.ZodMap)\n  ) {\n    return (\n      isSameType(a.keySchema, b.keySchema, opts) &&\n      isSameType(a.valueSchema, b.valueSchema, opts)\n    );\n  }\n\n  // ZodSet\n  if (a instanceof z.ZodSet && b instanceof z.ZodSet) {\n    return isSameType(a._def.valueType, b._def.valueType, opts);\n  }\n\n  // ZodFunction\n  if (a instanceof z.ZodFunction && b instanceof z.ZodFunction) {\n    return (\n      isSameType(a.parameters(), b.parameters(), opts) &&\n      isSameType(a.returnType(), b.returnType(), opts)\n    );\n  }\n\n  // ZodEnum\n  if (a instanceof z.ZodEnum && b instanceof z.ZodEnum) {\n    const optionsA: [string, ...string[]] = a.options;\n    const optionsB: [string, ...string[]] = b.options;\n    if (optionsA.length !== optionsB.length) return false;\n    for (let i = 0; i < optionsA.length; i++) {\n      if (optionsA[i] !== optionsB[i]) return false;\n    }\n    return true;\n  }\n\n  // ZodNativeEnum\n  if (a instanceof z.ZodNativeEnum && b instanceof z.ZodNativeEnum) {\n    const enumA: EnumLike = a.enum;\n    const enumB: EnumLike = b.enum;\n    if (Object.keys(enumA).length !== Object.keys(enumB).length) return false;\n    for (const key in enumA) {\n      if (enumA[key] !== enumB[key]) return false;\n    }\n    return true;\n  }\n\n  // ZodLazy\n  // ZodEffects\n  // ZodDefault\n  // ZodCatch\n  // ZodPipeline\n  // ZodTransformer\n  // ZodError\n  console.error('Failed to compare type! \"' + a, b);\n  throw new Error(\"Unknown type! \" + a._def.typeName + \" \" + b._def.typeName);\n};\n","import { z, type ZodType } from \"zod\";\nimport { isSameType } from \"./is-same-type.ts\";\nimport {\n  DEFAULT_COMPARE_TYPE_OPTIONS,\n  type IsCompatibleTypeOptions,\n} from \"./utils.ts\";\n\n/**\n * Check if a the higherType matches the lowerType\n *\n * @deprecated This a unstable API and still in development\n *\n * @param higherType The looser type\n * @param lowerType The stricter type\n *\n * @example\n * ```ts\n * isCompatibleType(z.string(), z.string()); // true\n *\n * isCompatibleType(\n *   z.object({ name: z.string(), other: z.number() }),\n *   z.object({ name: z.string() })\n * );\n * // true\n * ```\n */\nexport const isCompatibleType = (\n  higherType: ZodType,\n  lowerType: ZodType,\n  options?: Partial<IsCompatibleTypeOptions>,\n): boolean => {\n  const opts: IsCompatibleTypeOptions = {\n    ...DEFAULT_COMPARE_TYPE_OPTIONS,\n    ...options,\n  };\n  const interceptorResult = opts.interceptor(higherType, lowerType, opts);\n  if (interceptorResult === true || interceptorResult === false) {\n    return interceptorResult;\n  }\n  if (isSameType(higherType, lowerType, opts)) {\n    return true;\n  }\n\n  if (!(\"typeName\" in higherType._def) || !(\"typeName\" in lowerType._def)) {\n    throw new Error(\n      \"Failed to compare type! \" + higherType._def + \" \" + lowerType._def,\n    );\n  }\n\n  if (\n    lowerType instanceof z.ZodOptional ||\n    lowerType instanceof z.ZodNullable\n  ) {\n    return isCompatibleType(higherType, lowerType.unwrap(), opts);\n  }\n\n  // ZodUnion aka or\n  if (higherType instanceof z.ZodUnion && lowerType instanceof z.ZodUnion) {\n    for (let i = 0; i < higherType.options.length; i++) {\n      const match = lowerType.options.some((option: ZodType) =>\n        isCompatibleType(option, lowerType.options[i], opts),\n      );\n      if (!match) return false;\n    }\n    return true;\n  }\n  if (higherType instanceof z.ZodUnion) {\n    return higherType.options.every((option: ZodType) =>\n      isCompatibleType(option, lowerType, opts),\n    );\n  }\n  if (lowerType instanceof z.ZodUnion) {\n    return lowerType.options.some((option: ZodType) =>\n      isCompatibleType(higherType, option, opts),\n    );\n  }\n\n  // compare constructor\n  if (higherType.constructor !== lowerType.constructor) {\n    return false;\n  }\n\n  // ZodObject\n  if (higherType instanceof z.ZodObject && lowerType instanceof z.ZodObject) {\n    const superTypeShape = higherType.shape;\n    const subTypeShape = lowerType.shape;\n    if (Object.keys(superTypeShape).length < Object.keys(subTypeShape).length)\n      return false;\n    for (const key in subTypeShape) {\n      if (!(key in superTypeShape)) return false;\n      if (!isCompatibleType(superTypeShape[key], subTypeShape[key], opts)) {\n        return false;\n      }\n    }\n    return true;\n  }\n\n  // ZodArray\n  if (higherType instanceof z.ZodArray && lowerType instanceof z.ZodArray) {\n    return isCompatibleType(higherType.element, lowerType.element, opts);\n  }\n\n  // ZodTuple\n  if (higherType instanceof z.ZodTuple && lowerType instanceof z.ZodTuple) {\n    if (higherType.items.length < lowerType.items.length) return false;\n    for (let i = 0; i < lowerType.items.length; i++) {\n      if (!isCompatibleType(higherType.items[i], lowerType.items[i], opts)) {\n        return false;\n      }\n    }\n    // Check rest\n    if (lowerType._def.rest) {\n      if (!higherType._def.rest) return false;\n      return isCompatibleType(higherType._def.rest, lowerType._def.rest, opts);\n    }\n    return true;\n  }\n\n  throw new Error(\n    \"Failed to compare types!\" +\n      higherType._def.typeName +\n      \" \" +\n      lowerType._def.typeName,\n  );\n};\n"],"names":["DEFAULT_COMPARE_TYPE_OPTIONS","isPrimitiveType","a","z","isSameType","b","options","opts","interceptorResult","aShape","bShape","key","i","optionsA","optionsB","enumA","enumB","isCompatibleType","higherType","lowerType","option","superTypeShape","subTypeShape"],"mappings":"uGAkCaA,EAA+B,CAC1C,KAAM,GACN,eAAgB,GAChB,eAAgB,GAChB,eAAgB,GAChB,cAAe,GACf,kBAAmB,GACnB,yBAA0B,GAC1B,YAAa,IAAM,CAAC,CACtB,EAGaC,EAAmBC,GAE5BA,aAAaC,EAAE,EAAA,WACfD,aAAaC,EAAAA,EAAE,WACfD,aAAaC,IAAE,QACfD,aAAaC,IAAE,WACfD,aAAaC,EAAAA,EAAE,YACfD,aAAaC,IAAE,SACfD,aAAaC,EAAA,EAAE,WACfD,aAAaC,EAAAA,EAAE,cACfD,aAAaC,IAAE,SACfD,aAAaC,EAAE,EAAA,QACfD,aAAaC,EAAAA,EAAE,YACfD,aAAaC,EAAE,EAAA,UACfD,aAAaC,EAAE,EAAA,QChCNC,EAAa,CACxBF,EACAG,EACAC,IACY,CACZ,MAAMC,EAAO,CAAE,GAAGP,EAA8B,GAAGM,CAAQ,EACrDE,EAAoBD,EAAK,YAAYL,EAAGG,EAAGE,CAAI,EACjD,GAAAC,IAAsB,IAAQA,IAAsB,GAC/C,OAAAA,EAGL,GAAAN,IAAM,QAAaG,IAAM,OAC3B,MAAM,IAAI,MAAM,2BAA6BH,EAAI,IAAMG,CAAC,EAG1D,GAAIH,IAAMG,EACD,MAAA,GAIL,GAAAH,EAAE,cAAgBG,EAAE,YAEf,MAAA,GAGT,GAAI,EAAE,aAAcH,EAAE,OAAS,EAAE,aAAcG,EAAE,MAC/C,MAAM,IAAI,MAAM,2BAA6BH,EAAE,KAAO,IAAMG,EAAE,IAAI,EAEpE,GAAIH,EAAE,KAAK,WAAaG,EAAE,KAAK,SACtB,MAAA,GAIT,GAAIE,EAAK,cACH,OAAAL,aAAaC,IAAE,aACjBD,EAAIA,EAAE,UAEJG,aAAaF,IAAE,aACjBE,EAAIA,EAAE,UAEDD,EAAWF,EAAGG,EAAGE,CAAI,EAE5B,GAAIL,aAAaC,EAAAA,EAAE,YAAcE,aAAaF,EAAAA,EAAE,WAGvC,MAAA,GAKX,GAAI,WAAYD,GAAK,OAAOA,EAAE,QAAW,WACvC,MAAM,WAAYG,GAAK,OAAOA,EAAE,QAAW,WAGpCD,EAAWF,EAAE,OAAA,EAAUG,EAAE,OAAA,EAAUE,CAAI,EAFrC,GAMX,GADI,CAACA,EAAK,gBAAkBL,EAAE,WAAW,IAAMG,EAAE,WAAW,GACxD,CAACE,EAAK,gBAAkBL,EAAE,WAAW,IAAMG,EAAE,WAAW,EAAU,MAAA,GAElE,GAAAJ,EAAgBC,CAAC,EAEZ,MAAA,GAIT,GAAIA,aAAaC,EAAAA,EAAE,WAAaE,aAAaF,EAAAA,EAAE,UAAW,CACxD,MAAMM,EAASP,EAAE,MACXQ,EAASL,EAAE,MACb,GAAA,OAAO,KAAKI,CAAM,EAAE,SAAW,OAAO,KAAKC,CAAM,EAAE,OAAe,MAAA,GACtE,UAAWC,KAAOF,EAEZ,GADA,EAAEE,KAAOD,IACT,CAACN,EAAWK,EAAOE,CAAG,EAAGD,EAAOC,CAAG,EAAGJ,CAAI,EAAU,MAAA,GAEnD,MAAA,EACT,CAGA,GAAIL,aAAaC,EAAAA,EAAE,UAAYE,aAAaF,EAAAA,EAAE,SAC5C,OAAOC,EAAWF,EAAE,QAASG,EAAE,QAASE,CAAI,EAI9C,GAAIL,aAAaC,EAAAA,EAAE,UAAYE,aAAaF,EAAAA,EAAE,SAAU,CACtD,GAAID,EAAE,MAAM,SAAWG,EAAE,MAAM,OAAe,MAAA,GAC9C,QAASO,EAAI,EAAGA,EAAIV,EAAE,MAAM,OAAQU,IAC9B,GAAA,CAACR,EAAWF,EAAE,MAAMU,CAAC,EAAGP,EAAE,MAAMO,CAAC,EAAGL,CAAI,EAAU,MAAA,GAGxD,OAAIL,EAAE,KAAK,MAAQG,EAAE,KAAK,KAEpB,CAACH,EAAE,KAAK,MAAQ,CAACG,EAAE,KAAK,KAAa,GAClCD,EAAWF,EAAE,KAAK,KAAMG,EAAE,KAAK,KAAME,CAAI,EAE3C,EACT,CAGA,GAAIL,aAAaC,EAAAA,EAAE,YAAcE,aAAaF,EAAAA,EAAE,WACvC,OAAAD,EAAE,QAAUG,EAAE,MAIvB,GAAIH,aAAaC,EAAAA,EAAE,iBAAmBE,aAAaF,EAAAA,EAAE,gBACnD,OACEC,EAAWF,EAAE,KAAK,KAAMG,EAAE,KAAK,KAAME,CAAI,GACzCH,EAAWF,EAAE,KAAK,MAAOG,EAAE,KAAK,MAAOE,CAAI,EAK/C,GAAIL,aAAaC,EAAAA,EAAE,UAAYE,aAAaF,EAAAA,EAAE,SAAU,CACtD,GAAID,EAAE,QAAQ,SAAWG,EAAE,QAAQ,OAAe,MAAA,GAClD,QAASO,EAAI,EAAGA,EAAIV,EAAE,QAAQ,OAAQU,IAChC,GAAA,CAACR,EAAWF,EAAE,QAAQU,CAAC,EAAGP,EAAE,QAAQO,CAAC,EAAGL,CAAI,EAAU,MAAA,GAErD,MAAA,EACT,CAGA,GAAIL,aAAaC,EAAAA,EAAE,aAAeE,aAAaF,EAAAA,EAAE,YAC/C,OAAOC,EAAWF,EAAE,KAAK,UAAWG,EAAE,KAAK,UAAWE,CAAI,EAKzD,GAAAL,aAAaC,EAAE,EAAA,WAAaE,aAAaF,EAAAA,EAAE,WAC3CD,aAAaC,EAAE,EAAA,QAAUE,aAAaF,EAAAA,EAAE,OAEzC,OACEC,EAAWF,EAAE,UAAWG,EAAE,UAAWE,CAAI,GACzCH,EAAWF,EAAE,YAAaG,EAAE,YAAaE,CAAI,EAKjD,GAAIL,aAAaC,EAAAA,EAAE,QAAUE,aAAaF,EAAAA,EAAE,OAC1C,OAAOC,EAAWF,EAAE,KAAK,UAAWG,EAAE,KAAK,UAAWE,CAAI,EAI5D,GAAIL,aAAaC,EAAAA,EAAE,aAAeE,aAAaF,EAAAA,EAAE,YAC/C,OACEC,EAAWF,EAAE,WAAc,EAAAG,EAAE,aAAcE,CAAI,GAC/CH,EAAWF,EAAE,WAAW,EAAGG,EAAE,WAAA,EAAcE,CAAI,EAKnD,GAAIL,aAAaC,EAAAA,EAAE,SAAWE,aAAaF,EAAAA,EAAE,QAAS,CACpD,MAAMU,EAAkCX,EAAE,QACpCY,EAAkCT,EAAE,QACtC,GAAAQ,EAAS,SAAWC,EAAS,OAAe,MAAA,GAChD,QAAS,EAAI,EAAG,EAAID,EAAS,OAAQ,IACnC,GAAIA,EAAS,CAAC,IAAMC,EAAS,CAAC,EAAU,MAAA,GAEnC,MAAA,EACT,CAGA,GAAIZ,aAAaC,EAAAA,EAAE,eAAiBE,aAAaF,EAAAA,EAAE,cAAe,CAChE,MAAMY,EAAkBb,EAAE,KACpBc,EAAkBX,EAAE,KACtB,GAAA,OAAO,KAAKU,CAAK,EAAE,SAAW,OAAO,KAAKC,CAAK,EAAE,OAAe,MAAA,GACpE,UAAWL,KAAOI,EAChB,GAAIA,EAAMJ,CAAG,IAAMK,EAAML,CAAG,EAAU,MAAA,GAEjC,MAAA,EACT,CASQ,cAAA,MAAM,4BAA8BT,EAAGG,CAAC,EAC1C,IAAI,MAAM,iBAAmBH,EAAE,KAAK,SAAW,IAAMG,EAAE,KAAK,QAAQ,CAC5E,ECrLaY,EAAmB,CAC9BC,EACAC,EACAb,IACY,CACZ,MAAMC,EAAgC,CACpC,GAAGP,EACH,GAAGM,CAAA,EAECE,EAAoBD,EAAK,YAAYW,EAAYC,EAAWZ,CAAI,EAClE,GAAAC,IAAsB,IAAQA,IAAsB,GAC/C,OAAAA,EAET,GAAIJ,EAAWc,EAAYC,EAAWZ,CAAI,EACjC,MAAA,GAGT,GAAI,EAAE,aAAcW,EAAW,OAAS,EAAE,aAAcC,EAAU,MAChE,MAAM,IAAI,MACR,2BAA6BD,EAAW,KAAO,IAAMC,EAAU,IAAA,EAInE,GACEA,aAAqBhB,EAAAA,EAAE,aACvBgB,aAAqBhB,EAAAA,EAAE,YAEvB,OAAOc,EAAiBC,EAAYC,EAAU,SAAUZ,CAAI,EAI9D,GAAIW,aAAsBf,EAAAA,EAAE,UAAYgB,aAAqBhB,EAAAA,EAAE,SAAU,CACvE,QAASS,EAAI,EAAGA,EAAIM,EAAW,QAAQ,OAAQN,IAI7C,GAAI,CAHUO,EAAU,QAAQ,KAAMC,GACpCH,EAAiBG,EAAQD,EAAU,QAAQP,CAAC,EAAGL,CAAI,CAAA,EAElC,MAAA,GAEd,MAAA,EACT,CACI,GAAAW,aAAsBf,IAAE,SAC1B,OAAOe,EAAW,QAAQ,MAAOE,GAC/BH,EAAiBG,EAAQD,EAAWZ,CAAI,CAAA,EAGxC,GAAAY,aAAqBhB,IAAE,SACzB,OAAOgB,EAAU,QAAQ,KAAMC,GAC7BH,EAAiBC,EAAYE,EAAQb,CAAI,CAAA,EAKzC,GAAAW,EAAW,cAAgBC,EAAU,YAChC,MAAA,GAIT,GAAID,aAAsBf,EAAAA,EAAE,WAAagB,aAAqBhB,EAAAA,EAAE,UAAW,CACzE,MAAMkB,EAAiBH,EAAW,MAC5BI,EAAeH,EAAU,MAC3B,GAAA,OAAO,KAAKE,CAAc,EAAE,OAAS,OAAO,KAAKC,CAAY,EAAE,OAC1D,MAAA,GACT,UAAWX,KAAOW,EAEZ,GADA,EAAEX,KAAOU,IACT,CAACJ,EAAiBI,EAAeV,CAAG,EAAGW,EAAaX,CAAG,EAAGJ,CAAI,EACzD,MAAA,GAGJ,MAAA,EACT,CAGA,GAAIW,aAAsBf,EAAAA,EAAE,UAAYgB,aAAqBhB,EAAAA,EAAE,SAC7D,OAAOc,EAAiBC,EAAW,QAASC,EAAU,QAASZ,CAAI,EAIrE,GAAIW,aAAsBf,EAAAA,EAAE,UAAYgB,aAAqBhB,EAAAA,EAAE,SAAU,CACvE,GAAIe,EAAW,MAAM,OAASC,EAAU,MAAM,OAAe,MAAA,GAC7D,QAASP,EAAI,EAAGA,EAAIO,EAAU,MAAM,OAAQP,IACtC,GAAA,CAACK,EAAiBC,EAAW,MAAMN,CAAC,EAAGO,EAAU,MAAMP,CAAC,EAAGL,CAAI,EAC1D,MAAA,GAIP,OAAAY,EAAU,KAAK,KACZD,EAAW,KAAK,KACdD,EAAiBC,EAAW,KAAK,KAAMC,EAAU,KAAK,KAAMZ,CAAI,EADrC,GAG7B,EACT,CAEA,MAAM,IAAI,MACR,2BACEW,EAAW,KAAK,SAChB,IACAC,EAAU,KAAK,QAAA,CAErB"}

package/dist/index.d.ts

@@ -0,0 +1,74 @@
+import { ZodType } from 'zod';
+
+/**
+ * Check if a the higherType matches the lowerType
+ *
+ * @deprecated This a unstable API and still in development
+ *
+ * @param higherType The looser type
+ * @param lowerType The stricter type
+ *
+ * @example
+ * ```ts
+ * isCompatibleType(z.string(), z.string()); // true
+ *
+ * isCompatibleType(
+ *   z.object({ name: z.string(), other: z.number() }),
+ *   z.object({ name: z.string() })
+ * );
+ * // true
+ * ```
+ */
+export declare const isCompatibleType: (higherType: ZodType, lowerType: ZodType, options?: Partial<IsCompatibleTypeOptions>) => boolean;
+
+declare interface IsCompatibleTypeOptions extends IsSameTypeOptions {
+    ignoreOptional: false;
+    ignoreNullable: false;
+}
+
+/**
+ * isSameType is a function that checks if two ZodTypes are the same.
+ *
+ * Caveats:
+ * - The function does not validate specific criteria such as min or max values, length, email, etc.
+ * - It excludes comparisons involving methods like .describe(), .catch(), .default(), .refine(), and .transform().
+ * - When comparing definitions with .or and .and, they are assessed sequentially based on their order.
+ *
+ * @param a - The first ZodType to compare.
+ * @param b - The second ZodType to compare.
+ * @returns A boolean indicating whether the two types are the same.
+ *
+ * @throws Will throw an error if it encounters an unknown type.
+ *
+ * @example
+ * ```ts
+ * isSameType(z.string(), z.string()); // true
+ * isSameType(z.string(), z.number()); // false
+ * ```
+ */
+export declare const isSameType: (a: ZodType, b: ZodType, options?: Partial<IsSameTypeOptions>) => boolean;
+
+export declare interface IsSameTypeOptions {
+    deep: true;
+    /**
+     * Ignore all specific validations like min, max, length, email etc.
+     *
+     * You still can use `interceptor` to validate the type manually.
+     */
+    ignoreValidations: true;
+    ignoreOptional: boolean;
+    ignoreNullable: boolean;
+    ignoreReadOnly: false;
+    ignoreBranded: boolean;
+    ignoreIntersectionsOrder: false;
+    /**
+     * A function that provides custom logic for comparing two ZodType instances.
+     *
+     * If the function returns `true` or `false`, the result will be used as the comparison result.
+     * Otherwise, the default comparison logic will be used.
+     *
+     */
+    interceptor: (a: ZodType, b: ZodType, options: IsSameTypeOptions) => boolean | void;
+}
+
+export { }

package/dist/index.js

@@ -0,0 +1,154 @@
+import { z as t } from "zod";
+const a = {
+  deep: !0,
+  ignoreOptional: !1,
+  ignoreNullable: !1,
+  ignoreReadOnly: !1,
+  ignoreBranded: !1,
+  ignoreValidations: !0,
+  ignoreIntersectionsOrder: !1,
+  interceptor: () => {
+  }
+}, l = (e) => e instanceof t.ZodString || e instanceof t.ZodNumber || e instanceof t.ZodNaN || e instanceof t.ZodBigInt || e instanceof t.ZodBoolean || e instanceof t.ZodDate || e instanceof t.ZodSymbol || e instanceof t.ZodUndefined || e instanceof t.ZodNull || e instanceof t.ZodAny || e instanceof t.ZodUnknown || e instanceof t.ZodNever || e instanceof t.ZodVoid, f = (e, n, d) => {
+  const r = { ...a, ...d }, u = r.interceptor(e, n, r);
+  if (u === !0 || u === !1)
+    return u;
+  if (e === void 0 || n === void 0)
+    throw new Error("Failed to compare type! " + e + " " + n);
+  if (e === n)
+    return !0;
+  if (e.constructor !== n.constructor)
+    return !1;
+  if (!("typeName" in e._def) || !("typeName" in n._def))
+    throw new Error("Failed to compare type! " + e._def + " " + n._def);
+  if (e._def.typeName !== n._def.typeName)
+    return !1;
+  if (r.ignoreBranded)
+    return e instanceof t.ZodBranded && (e = e.unwrap()), n instanceof t.ZodBranded && (n = n.unwrap()), f(e, n, r);
+  if (e instanceof t.ZodBranded || n instanceof t.ZodBranded)
+    return !1;
+  if ("unwrap" in e && typeof e.unwrap == "function")
+    return "unwrap" in n && typeof n.unwrap == "function" ? f(e.unwrap(), n.unwrap(), r) : !1;
+  if (!r.ignoreOptional && e.isOptional() !== n.isOptional() || !r.ignoreNullable && e.isNullable() !== n.isNullable())
+    return !1;
+  if (l(e))
+    return !0;
+  if (e instanceof t.ZodObject && n instanceof t.ZodObject) {
+    const o = e.shape, s = n.shape;
+    if (Object.keys(o).length !== Object.keys(s).length)
+      return !1;
+    for (const i in o)
+      if (!(i in s) || !f(o[i], s[i], r))
+        return !1;
+    return !0;
+  }
+  if (e instanceof t.ZodArray && n instanceof t.ZodArray)
+    return f(e.element, n.element, r);
+  if (e instanceof t.ZodTuple && n instanceof t.ZodTuple) {
+    if (e.items.length !== n.items.length)
+      return !1;
+    for (let o = 0; o < e.items.length; o++)
+      if (!f(e.items[o], n.items[o], r))
+        return !1;
+    return e._def.rest || n._def.rest ? !e._def.rest || !n._def.rest ? !1 : f(e._def.rest, n._def.rest, r) : !0;
+  }
+  if (e instanceof t.ZodLiteral && n instanceof t.ZodLiteral)
+    return e.value === n.value;
+  if (e instanceof t.ZodIntersection && n instanceof t.ZodIntersection)
+    return f(e._def.left, n._def.left, r) && f(e._def.right, n._def.right, r);
+  if (e instanceof t.ZodUnion && n instanceof t.ZodUnion) {
+    if (e.options.length !== n.options.length)
+      return !1;
+    for (let o = 0; o < e.options.length; o++)
+      if (!f(e.options[o], n.options[o], r))
+        return !1;
+    return !0;
+  }
+  if (e instanceof t.ZodReadonly && n instanceof t.ZodReadonly)
+    return f(e._def.innerType, n._def.innerType, r);
+  if (e instanceof t.ZodRecord && n instanceof t.ZodRecord || e instanceof t.ZodMap && n instanceof t.ZodMap)
+    return f(e.keySchema, n.keySchema, r) && f(e.valueSchema, n.valueSchema, r);
+  if (e instanceof t.ZodSet && n instanceof t.ZodSet)
+    return f(e._def.valueType, n._def.valueType, r);
+  if (e instanceof t.ZodFunction && n instanceof t.ZodFunction)
+    return f(e.parameters(), n.parameters(), r) && f(e.returnType(), n.returnType(), r);
+  if (e instanceof t.ZodEnum && n instanceof t.ZodEnum) {
+    const o = e.options, s = n.options;
+    if (o.length !== s.length)
+      return !1;
+    for (let i = 0; i < o.length; i++)
+      if (o[i] !== s[i])
+        return !1;
+    return !0;
+  }
+  if (e instanceof t.ZodNativeEnum && n instanceof t.ZodNativeEnum) {
+    const o = e.enum, s = n.enum;
+    if (Object.keys(o).length !== Object.keys(s).length)
+      return !1;
+    for (const i in o)
+      if (o[i] !== s[i])
+        return !1;
+    return !0;
+  }
+  throw console.error('Failed to compare type! "' + e, n), new Error("Unknown type! " + e._def.typeName + " " + n._def.typeName);
+}, c = (e, n, d) => {
+  const r = {
+    ...a,
+    ...d
+  }, u = r.interceptor(e, n, r);
+  if (u === !0 || u === !1)
+    return u;
+  if (f(e, n, r))
+    return !0;
+  if (!("typeName" in e._def) || !("typeName" in n._def))
+    throw new Error(
+      "Failed to compare type! " + e._def + " " + n._def
+    );
+  if (n instanceof t.ZodOptional || n instanceof t.ZodNullable)
+    return c(e, n.unwrap(), r);
+  if (e instanceof t.ZodUnion && n instanceof t.ZodUnion) {
+    for (let o = 0; o < e.options.length; o++)
+      if (!n.options.some(
+        (i) => c(i, n.options[o], r)
+      ))
+        return !1;
+    return !0;
+  }
+  if (e instanceof t.ZodUnion)
+    return e.options.every(
+      (o) => c(o, n, r)
+    );
+  if (n instanceof t.ZodUnion)
+    return n.options.some(
+      (o) => c(e, o, r)
+    );
+  if (e.constructor !== n.constructor)
+    return !1;
+  if (e instanceof t.ZodObject && n instanceof t.ZodObject) {
+    const o = e.shape, s = n.shape;
+    if (Object.keys(o).length < Object.keys(s).length)
+      return !1;
+    for (const i in s)
+      if (!(i in o) || !c(o[i], s[i], r))
+        return !1;
+    return !0;
+  }
+  if (e instanceof t.ZodArray && n instanceof t.ZodArray)
+    return c(e.element, n.element, r);
+  if (e instanceof t.ZodTuple && n instanceof t.ZodTuple) {
+    if (e.items.length < n.items.length)
+      return !1;
+    for (let o = 0; o < n.items.length; o++)
+      if (!c(e.items[o], n.items[o], r))
+        return !1;
+    return n._def.rest ? e._def.rest ? c(e._def.rest, n._def.rest, r) : !1 : !0;
+  }
+  throw new Error(
+    "Failed to compare types!" + e._def.typeName + " " + n._def.typeName
+  );
+};
+export {
+  c as isCompatibleType,
+  f as isSameType
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../src/utils.ts","../src/is-same-type.ts","../src/is-compatible-type.ts"],"sourcesContent":["import { z, type ZodType } from \"zod\";\n\nexport interface IsSameTypeOptions {\n  deep: true;\n  /**\n   * Ignore all specific validations like min, max, length, email etc.\n   *\n   * You still can use `interceptor` to validate the type manually.\n   */\n  ignoreValidations: true;\n  ignoreOptional: boolean;\n  ignoreNullable: boolean;\n  ignoreReadOnly: false;\n  ignoreBranded: boolean;\n  ignoreIntersectionsOrder: false;\n  /**\n   * A function that provides custom logic for comparing two ZodType instances.\n   *\n   * If the function returns `true` or `false`, the result will be used as the comparison result.\n   * Otherwise, the default comparison logic will be used.\n   *\n   */\n  interceptor: (\n    a: ZodType,\n    b: ZodType,\n    options: IsSameTypeOptions,\n  ) => boolean | void;\n}\n\nexport interface IsCompatibleTypeOptions extends IsSameTypeOptions {\n  ignoreOptional: false;\n  ignoreNullable: false;\n}\n\nexport const DEFAULT_COMPARE_TYPE_OPTIONS = {\n  deep: true,\n  ignoreOptional: false,\n  ignoreNullable: false,\n  ignoreReadOnly: false,\n  ignoreBranded: false,\n  ignoreValidations: true,\n  ignoreIntersectionsOrder: false,\n  interceptor: () => {},\n} as const satisfies IsSameTypeOptions;\n\n// See ZodFirstPartyTypeKind\nexport const isPrimitiveType = (a: ZodType): boolean => {\n  return (\n    a instanceof z.ZodString ||\n    a instanceof z.ZodNumber ||\n    a instanceof z.ZodNaN ||\n    a instanceof z.ZodBigInt ||\n    a instanceof z.ZodBoolean ||\n    a instanceof z.ZodDate ||\n    a instanceof z.ZodSymbol ||\n    a instanceof z.ZodUndefined ||\n    a instanceof z.ZodNull ||\n    a instanceof z.ZodAny ||\n    a instanceof z.ZodUnknown ||\n    a instanceof z.ZodNever ||\n    a instanceof z.ZodVoid\n  );\n};\n","import type { EnumLike, ZodType } from \"zod\";\nimport { z } from \"zod\";\nimport {\n  type IsSameTypeOptions,\n  DEFAULT_COMPARE_TYPE_OPTIONS,\n  isPrimitiveType,\n} from \"./utils.ts\";\n\n/**\n * isSameType is a function that checks if two ZodTypes are the same.\n *\n * Caveats:\n * - The function does not validate specific criteria such as min or max values, length, email, etc.\n * - It excludes comparisons involving methods like .describe(), .catch(), .default(), .refine(), and .transform().\n * - When comparing definitions with .or and .and, they are assessed sequentially based on their order.\n *\n * @param a - The first ZodType to compare.\n * @param b - The second ZodType to compare.\n * @returns A boolean indicating whether the two types are the same.\n *\n * @throws Will throw an error if it encounters an unknown type.\n *\n * @example\n * ```ts\n * isSameType(z.string(), z.string()); // true\n * isSameType(z.string(), z.number()); // false\n * ```\n */\nexport const isSameType = (\n  a: ZodType,\n  b: ZodType,\n  options?: Partial<IsSameTypeOptions>,\n): boolean => {\n  const opts = { ...DEFAULT_COMPARE_TYPE_OPTIONS, ...options };\n  const interceptorResult = opts.interceptor(a, b, opts);\n  if (interceptorResult === true || interceptorResult === false) {\n    return interceptorResult;\n  }\n\n  if (a === undefined || b === undefined) {\n    throw new Error(\"Failed to compare type! \" + a + \" \" + b);\n  }\n\n  if (a === b) {\n    return true;\n  }\n\n  // compare constructor\n  if (a.constructor !== b.constructor) {\n    // https://stackoverflow.com/questions/24959862/how-to-tell-if-two-javascript-instances-are-of-the-same-class-type\n    return false;\n  }\n  // See https://github.com/colinhacks/zod/blob/master/src/types.ts\n  if (!(\"typeName\" in a._def) || !(\"typeName\" in b._def)) {\n    throw new Error(\"Failed to compare type! \" + a._def + \" \" + b._def);\n  }\n  if (a._def.typeName !== b._def.typeName) {\n    return false;\n  }\n\n  // ZodBranded\n  if (opts.ignoreBranded) {\n    if (a instanceof z.ZodBranded) {\n      a = a.unwrap();\n    }\n    if (b instanceof z.ZodBranded) {\n      b = b.unwrap();\n    }\n    return isSameType(a, b, opts);\n  } else {\n    if (a instanceof z.ZodBranded || b instanceof z.ZodBranded) {\n      // We can not distinguish different branded type\n      // throw new Error(\"Can not distinguish different branded type!\");\n      return false;\n    }\n  }\n\n  // ZodPromise ZodOptional ZodNullable ZodBranded\n  if (\"unwrap\" in a && typeof a.unwrap === \"function\") {\n    if (!(\"unwrap\" in b && typeof b.unwrap === \"function\")) {\n      return false;\n    }\n    return isSameType(a.unwrap(), b.unwrap(), opts);\n  }\n\n  if (!opts.ignoreOptional && a.isOptional() !== b.isOptional()) return false;\n  if (!opts.ignoreNullable && a.isNullable() !== b.isNullable()) return false;\n\n  if (isPrimitiveType(a)) {\n    // Already assert a and b are the same constructor\n    return true;\n  }\n\n  // ZodObject\n  if (a instanceof z.ZodObject && b instanceof z.ZodObject) {\n    const aShape = a.shape;\n    const bShape = b.shape;\n    if (Object.keys(aShape).length !== Object.keys(bShape).length) return false;\n    for (const key in aShape) {\n      if (!(key in bShape)) return false;\n      if (!isSameType(aShape[key], bShape[key], opts)) return false;\n    }\n    return true;\n  }\n\n  // ZodArray\n  if (a instanceof z.ZodArray && b instanceof z.ZodArray) {\n    return isSameType(a.element, b.element, opts);\n  }\n\n  // ZodTuple\n  if (a instanceof z.ZodTuple && b instanceof z.ZodTuple) {\n    if (a.items.length !== b.items.length) return false;\n    for (let i = 0; i < a.items.length; i++) {\n      if (!isSameType(a.items[i], b.items[i], opts)) return false;\n    }\n    // Compare rest\n    if (a._def.rest || b._def.rest) {\n      // If one has rest, the other must have rest\n      if (!a._def.rest || !b._def.rest) return false;\n      return isSameType(a._def.rest, b._def.rest, opts);\n    }\n    return true;\n  }\n\n  // ZodLiteral\n  if (a instanceof z.ZodLiteral && b instanceof z.ZodLiteral) {\n    return a.value === b.value;\n  }\n\n  // ZodIntersection aka and\n  if (a instanceof z.ZodIntersection && b instanceof z.ZodIntersection) {\n    return (\n      isSameType(a._def.left, b._def.left, opts) &&\n      isSameType(a._def.right, b._def.right, opts)\n    );\n  }\n\n  // ZodUnion aka or\n  if (a instanceof z.ZodUnion && b instanceof z.ZodUnion) {\n    if (a.options.length !== b.options.length) return false;\n    for (let i = 0; i < a.options.length; i++) {\n      if (!isSameType(a.options[i], b.options[i], opts)) return false;\n    }\n    return true;\n  }\n\n  // ZodReadonly\n  if (a instanceof z.ZodReadonly && b instanceof z.ZodReadonly) {\n    return isSameType(a._def.innerType, b._def.innerType, opts);\n  }\n\n  // ZodRecord / ZodMap\n  if (\n    (a instanceof z.ZodRecord && b instanceof z.ZodRecord) ||\n    (a instanceof z.ZodMap && b instanceof z.ZodMap)\n  ) {\n    return (\n      isSameType(a.keySchema, b.keySchema, opts) &&\n      isSameType(a.valueSchema, b.valueSchema, opts)\n    );\n  }\n\n  // ZodSet\n  if (a instanceof z.ZodSet && b instanceof z.ZodSet) {\n    return isSameType(a._def.valueType, b._def.valueType, opts);\n  }\n\n  // ZodFunction\n  if (a instanceof z.ZodFunction && b instanceof z.ZodFunction) {\n    return (\n      isSameType(a.parameters(), b.parameters(), opts) &&\n      isSameType(a.returnType(), b.returnType(), opts)\n    );\n  }\n\n  // ZodEnum\n  if (a instanceof z.ZodEnum && b instanceof z.ZodEnum) {\n    const optionsA: [string, ...string[]] = a.options;\n    const optionsB: [string, ...string[]] = b.options;\n    if (optionsA.length !== optionsB.length) return false;\n    for (let i = 0; i < optionsA.length; i++) {\n      if (optionsA[i] !== optionsB[i]) return false;\n    }\n    return true;\n  }\n\n  // ZodNativeEnum\n  if (a instanceof z.ZodNativeEnum && b instanceof z.ZodNativeEnum) {\n    const enumA: EnumLike = a.enum;\n    const enumB: EnumLike = b.enum;\n    if (Object.keys(enumA).length !== Object.keys(enumB).length) return false;\n    for (const key in enumA) {\n      if (enumA[key] !== enumB[key]) return false;\n    }\n    return true;\n  }\n\n  // ZodLazy\n  // ZodEffects\n  // ZodDefault\n  // ZodCatch\n  // ZodPipeline\n  // ZodTransformer\n  // ZodError\n  console.error('Failed to compare type! \"' + a, b);\n  throw new Error(\"Unknown type! \" + a._def.typeName + \" \" + b._def.typeName);\n};\n","import { z, type ZodType } from \"zod\";\nimport { isSameType } from \"./is-same-type.ts\";\nimport {\n  DEFAULT_COMPARE_TYPE_OPTIONS,\n  type IsCompatibleTypeOptions,\n} from \"./utils.ts\";\n\n/**\n * Check if a the higherType matches the lowerType\n *\n * @deprecated This a unstable API and still in development\n *\n * @param higherType The looser type\n * @param lowerType The stricter type\n *\n * @example\n * ```ts\n * isCompatibleType(z.string(), z.string()); // true\n *\n * isCompatibleType(\n *   z.object({ name: z.string(), other: z.number() }),\n *   z.object({ name: z.string() })\n * );\n * // true\n * ```\n */\nexport const isCompatibleType = (\n  higherType: ZodType,\n  lowerType: ZodType,\n  options?: Partial<IsCompatibleTypeOptions>,\n): boolean => {\n  const opts: IsCompatibleTypeOptions = {\n    ...DEFAULT_COMPARE_TYPE_OPTIONS,\n    ...options,\n  };\n  const interceptorResult = opts.interceptor(higherType, lowerType, opts);\n  if (interceptorResult === true || interceptorResult === false) {\n    return interceptorResult;\n  }\n  if (isSameType(higherType, lowerType, opts)) {\n    return true;\n  }\n\n  if (!(\"typeName\" in higherType._def) || !(\"typeName\" in lowerType._def)) {\n    throw new Error(\n      \"Failed to compare type! \" + higherType._def + \" \" + lowerType._def,\n    );\n  }\n\n  if (\n    lowerType instanceof z.ZodOptional ||\n    lowerType instanceof z.ZodNullable\n  ) {\n    return isCompatibleType(higherType, lowerType.unwrap(), opts);\n  }\n\n  // ZodUnion aka or\n  if (higherType instanceof z.ZodUnion && lowerType instanceof z.ZodUnion) {\n    for (let i = 0; i < higherType.options.length; i++) {\n      const match = lowerType.options.some((option: ZodType) =>\n        isCompatibleType(option, lowerType.options[i], opts),\n      );\n      if (!match) return false;\n    }\n    return true;\n  }\n  if (higherType instanceof z.ZodUnion) {\n    return higherType.options.every((option: ZodType) =>\n      isCompatibleType(option, lowerType, opts),\n    );\n  }\n  if (lowerType instanceof z.ZodUnion) {\n    return lowerType.options.some((option: ZodType) =>\n      isCompatibleType(higherType, option, opts),\n    );\n  }\n\n  // compare constructor\n  if (higherType.constructor !== lowerType.constructor) {\n    return false;\n  }\n\n  // ZodObject\n  if (higherType instanceof z.ZodObject && lowerType instanceof z.ZodObject) {\n    const superTypeShape = higherType.shape;\n    const subTypeShape = lowerType.shape;\n    if (Object.keys(superTypeShape).length < Object.keys(subTypeShape).length)\n      return false;\n    for (const key in subTypeShape) {\n      if (!(key in superTypeShape)) return false;\n      if (!isCompatibleType(superTypeShape[key], subTypeShape[key], opts)) {\n        return false;\n      }\n    }\n    return true;\n  }\n\n  // ZodArray\n  if (higherType instanceof z.ZodArray && lowerType instanceof z.ZodArray) {\n    return isCompatibleType(higherType.element, lowerType.element, opts);\n  }\n\n  // ZodTuple\n  if (higherType instanceof z.ZodTuple && lowerType instanceof z.ZodTuple) {\n    if (higherType.items.length < lowerType.items.length) return false;\n    for (let i = 0; i < lowerType.items.length; i++) {\n      if (!isCompatibleType(higherType.items[i], lowerType.items[i], opts)) {\n        return false;\n      }\n    }\n    // Check rest\n    if (lowerType._def.rest) {\n      if (!higherType._def.rest) return false;\n      return isCompatibleType(higherType._def.rest, lowerType._def.rest, opts);\n    }\n    return true;\n  }\n\n  throw new Error(\n    \"Failed to compare types!\" +\n      higherType._def.typeName +\n      \" \" +\n      lowerType._def.typeName,\n  );\n};\n"],"names":["DEFAULT_COMPARE_TYPE_OPTIONS","isPrimitiveType","a","z","isSameType","b","options","opts","interceptorResult","aShape","bShape","key","i","optionsA","optionsB","enumA","enumB","isCompatibleType","higherType","lowerType","option","superTypeShape","subTypeShape"],"mappings":"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"}

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "zod-compare",
+  "version": "0.1.1",
+  "description": "Compare two Zod schemas recursively.",
+  "keywords": [
+    "zod",
+    "compare",
+    "comparator",
+    "schema",
+    "type",
+    "typescript",
+    "validation"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/lawvs/zod-compare.git"
+  },
+  "license": "MIT",
+  "author": "whitewater <me@waterwater.moe>",
+  "sideEffects": false,
+  "type": "module",
+  "main": "dist/index.js",
+  "files": [
+    "src",
+    "dist"
+  ],
+  "devDependencies": {
+    "@changesets/cli": "^2.27.1",
+    "@vitest/coverage-v8": "^1.3.1",
+    "prettier": "^3.2.5",
+    "typescript": "^5.3.3",
+    "vite": "^5.1.4",
+    "vite-plugin-dts": "^3.7.3",
+    "vitest": "^1.3.1",
+    "zod": "^3.22.4"
+  },
+  "peerDependencies": {
+    "zod": "^3.22.4"
+  },
+  "packageManager": "pnpm@8.15.3",
+  "engines": {
+    "node": ">=20"
+  },
+  "prettier": {},
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc && vite build",
+    "format": "prettier --check .",
+    "format:fix": "prettier --write .",
+    "typeCheck": "tsc --noEmit",
+    "test": "vitest",
+    "changeset": "changeset",
+    "release": "pnpm run build && changeset publish"
+  },
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    "types": "./dist/index.d.ts",
+    "import": "./dist/index.js",
+    "require": "./dist/index.cjs"
+  }
+}

package/src/__tests__/is-compatible-type.test.ts

@@ -0,0 +1,136 @@
+import { describe, expect, test } from "vitest";
+import { z } from "zod";
+import { isCompatibleType } from "../is-compatible-type.ts";
+
+describe("isCompatibleType", () => {
+  test("should ref same type", () => {
+    const uniqueType = z.string().brand("unique");
+    expect(isCompatibleType(uniqueType, uniqueType)).toBe(true);
+  });
+
+  test("compare basic type", () => {
+    expect(isCompatibleType(z.undefined(), z.undefined())).toBe(true);
+    expect(isCompatibleType(z.string(), z.string())).toBe(true);
+    expect(isCompatibleType(z.string(), z.number())).toBe(false);
+    expect(isCompatibleType(z.string().optional(), z.string())).toBe(false);
+    expect(isCompatibleType(z.string().optional(), z.string().optional())).toBe(
+      true,
+    );
+    expect(isCompatibleType(z.string().nullable(), z.string().optional())).toBe(
+      false,
+    );
+    expect(isCompatibleType(z.string(), z.string().nullable())).toBe(true);
+    expect(isCompatibleType(z.string(), z.string().optional())).toBe(true);
+  });
+
+  test("should compare simple object", () => {
+    expect(
+      isCompatibleType(
+        z.object({
+          name: z.string(),
+          other: z.number(),
+        }),
+        z.object({
+          name: z.string(),
+        }),
+      ),
+    ).toBe(true);
+    expect(
+      isCompatibleType(
+        z.object({
+          name: z.number(),
+        }),
+        z.object({
+          name: z.number().nullable(),
+        }),
+      ),
+    ).toBe(true);
+    expect(
+      isCompatibleType(
+        z
+          .object({
+            name: z.string().optional(),
+          })
+          .partial(),
+        z.object({
+          name: z.string(),
+        }),
+      ),
+    ).toBe(false);
+    expect(
+      isCompatibleType(
+        z.object({
+          name: z.string(),
+        }),
+        z
+          .object({
+            name: z.string(),
+          })
+          .partial(),
+      ),
+    ).toBe(true);
+    expect(
+      isCompatibleType(
+        z.object({
+          name: z.string().nullable(),
+        }),
+        z.object({
+          name: z.string().optional(),
+        }),
+      ),
+    ).toBe(false);
+    expect(
+      isCompatibleType(
+        z.object({}),
+        z.object({
+          name: z.string(),
+        }),
+      ),
+    ).toBe(false);
+  });
+
+  test("should compare rest tuple", () => {
+    expect(
+      isCompatibleType(
+        z.tuple([z.string(), z.string()]),
+        z.tuple([z.string()]),
+      ),
+    ).toBe(true);
+    expect(
+      isCompatibleType(
+        z.tuple([z.string(), z.string()]),
+        z.tuple([z.string(), z.number()]),
+      ),
+    ).toBe(false);
+    expect(
+      isCompatibleType(
+        z.tuple([z.string(), z.string()]).rest(z.number()),
+        z.tuple([z.string(), z.string()]),
+      ),
+    ).toBe(true);
+    expect(
+      isCompatibleType(
+        z.tuple([z.string()]),
+        z.tuple([z.string()]).rest(z.number()),
+      ),
+    ).toBe(false);
+
+    expect(
+      isCompatibleType(z.tuple([]).rest(z.number()), z.array(z.number())),
+    ).toBe(false);
+  });
+
+  test("should compare `or` type", () => {
+    expect(isCompatibleType(z.string(), z.string().or(z.number()))).toBe(true);
+    expect(
+      isCompatibleType(z.string(), z.number().or(z.string()).or(z.boolean())),
+    ).toBe(true);
+    expect(isCompatibleType(z.string().or(z.number()), z.string())).toBe(false);
+    expect(
+      isCompatibleType(
+        z.string().or(z.number()),
+        z.number().or(z.string()).or(z.boolean()),
+      ),
+    ).toBe(true);
+  });
+});

package/src/__tests__/is-same-type.test.ts

@@ -0,0 +1,174 @@
+import { describe, expect, test } from "vitest";
+import { z } from "zod";
+import { isSameType } from "../is-same-type.ts";
+
+describe("isSameType", () => {
+  test("should ref same type", () => {
+    const uniqueType = z.string().brand("unique");
+    expect(isSameType(uniqueType, uniqueType)).toBe(true);
+  });
+
+  test("compare basic type", () => {
+    expect(isSameType(z.undefined(), z.undefined())).toBe(true);
+    expect(isSameType(z.string(), z.string())).toBe(true);
+    expect(isSameType(z.string(), z.number())).toBe(false);
+    expect(isSameType(z.string().optional(), z.string())).toBe(false);
+    expect(isSameType(z.string().optional(), z.string().optional())).toBe(true);
+    expect(isSameType(z.string().nullable(), z.string().optional())).toBe(
+      false,
+    );
+  });
+
+  test("should return false when compare branded type", () => {
+    expect(isSameType(z.string().brand("test"), z.string())).toBe(false);
+    expect(isSameType(z.string().brand("test"), z.string().brand("test"))).toBe(
+      false,
+    );
+    // expect(() =>
+    //   isSameType(z.string().brand("test"), z.string().brand("test"))
+    // ).toThrowError();
+  });
+
+  test("should compare simple object", () => {
+    expect(
+      isSameType(
+        z.object({
+          name: z.string(),
+        }),
+        z.object({
+          name: z.string(),
+        }),
+      ),
+    ).toBe(true);
+    expect(
+      isSameType(
+        z.object({
+          name: z.string(),
+        }),
+        z.object({
+          name: z.number(),
+        }),
+      ),
+    ).toBe(false);
+    expect(
+      isSameType(
+        z
+          .object({
+            name: z.string(),
+          })
+          .partial(),
+        z.object({
+          name: z.string(),
+        }),
+      ),
+    ).toBe(false);
+    expect(
+      isSameType(
+        z
+          .object({
+            name: z.string(),
+          })
+          .partial(),
+        z
+          .object({
+            name: z.string(),
+          })
+          .partial(),
+      ),
+    ).toBe(true);
+    expect(
+      isSameType(
+        z.object({
+          name: z.string().nullable(),
+        }),
+        z.object({
+          name: z.string().optional(),
+        }),
+      ),
+    ).toBe(false);
+    expect(
+      isSameType(
+        z.object({}),
+        z.object({
+          name: z.string(),
+        }),
+      ),
+    ).toBe(false);
+  });
+
+  test("should compare rest tuple", () => {
+    expect(
+      isSameType(
+        z.tuple([z.string(), z.string()]),
+        z.tuple([z.string(), z.string()]),
+      ),
+    ).toBe(true);
+    expect(
+      isSameType(
+        z.tuple([z.string(), z.string()]),
+        z.tuple([z.string(), z.number()]),
+      ),
+    ).toBe(false);
+    expect(
+      isSameType(
+        z.tuple([z.string(), z.string()]).rest(z.number()),
+        z.tuple([z.string(), z.string()]),
+      ),
+    ).toBe(false);
+    expect(
+      isSameType(
+        z.tuple([z.string(), z.string()]).rest(z.number()),
+        z.tuple([z.string(), z.string()]).rest(z.number()),
+      ),
+    ).toBe(true);
+
+    expect(isSameType(z.tuple([]).rest(z.number()), z.array(z.number()))).toBe(
+      false,
+    );
+  });
+
+  test("should compare `and` type", () => {
+    expect(
+      isSameType(z.string().and(z.number()), z.string().and(z.number())),
+    ).toBe(true);
+    expect(
+      isSameType(z.number().and(z.string()), z.number().and(z.string())),
+    ).toBe(true);
+
+    // order matters
+    expect(
+      isSameType(z.number().and(z.string()), z.string().and(z.number())),
+    ).toBe(false);
+  });
+
+  test("should compare `or` type", () => {
+    expect(
+      isSameType(z.string().or(z.number()), z.string().or(z.number())),
+    ).toBe(true);
+    expect(
+      isSameType(z.number().or(z.string()), z.number().or(z.string())),
+    ).toBe(true);
+
+    // order matters
+    expect(
+      isSameType(z.number().or(z.string()), z.string().or(z.number())),
+    ).toBe(false);
+  });
+
+  test("should compare literal type", () => {
+    expect(isSameType(z.literal("test"), z.literal("test"))).toBe(true);
+    expect(isSameType(z.literal("test"), z.literal("test2"))).toBe(false);
+  });
+
+  test("should compare readonly type", () => {
+    expect(
+      isSameType(
+        z.object({ foo: z.string().readonly() }),
+        z.object({
+          foo: z.string().readonly(),
+        }),
+      ),
+    ).toBe(true);
+    expect(isSameType(z.string().readonly(), z.string())).toBe(false);
+  });
+});

package/src/index.ts

@@ -0,0 +1,3 @@
+export { isSameType } from "./is-same-type.ts";
+export { isCompatibleType } from "./is-compatible-type.ts";
+export type { IsSameTypeOptions } from "./utils.ts";

package/src/is-compatible-type.ts

@@ -0,0 +1,125 @@
+import { z, type ZodType } from "zod";
+import { isSameType } from "./is-same-type.ts";
+import {
+  DEFAULT_COMPARE_TYPE_OPTIONS,
+  type IsCompatibleTypeOptions,
+} from "./utils.ts";
+
+/**
+ * Check if a the higherType matches the lowerType
+ *
+ * @deprecated This a unstable API and still in development
+ *
+ * @param higherType The looser type
+ * @param lowerType The stricter type
+ *
+ * @example
+ * ```ts
+ * isCompatibleType(z.string(), z.string()); // true
+ *
+ * isCompatibleType(
+ *   z.object({ name: z.string(), other: z.number() }),
+ *   z.object({ name: z.string() })
+ * );
+ * // true
+ * ```
+ */
+export const isCompatibleType = (
+  higherType: ZodType,
+  lowerType: ZodType,
+  options?: Partial<IsCompatibleTypeOptions>,
+): boolean => {
+  const opts: IsCompatibleTypeOptions = {
+    ...DEFAULT_COMPARE_TYPE_OPTIONS,
+    ...options,
+  };
+  const interceptorResult = opts.interceptor(higherType, lowerType, opts);
+  if (interceptorResult === true || interceptorResult === false) {
+    return interceptorResult;
+  }
+  if (isSameType(higherType, lowerType, opts)) {
+    return true;
+  }
+
+  if (!("typeName" in higherType._def) || !("typeName" in lowerType._def)) {
+    throw new Error(
+      "Failed to compare type! " + higherType._def + " " + lowerType._def,
+    );
+  }
+
+  if (
+    lowerType instanceof z.ZodOptional ||
+    lowerType instanceof z.ZodNullable
+  ) {
+    return isCompatibleType(higherType, lowerType.unwrap(), opts);
+  }
+
+  // ZodUnion aka or
+  if (higherType instanceof z.ZodUnion && lowerType instanceof z.ZodUnion) {
+    for (let i = 0; i < higherType.options.length; i++) {
+      const match = lowerType.options.some((option: ZodType) =>
+        isCompatibleType(option, lowerType.options[i], opts),
+      );
+      if (!match) return false;
+    }
+    return true;
+  }
+  if (higherType instanceof z.ZodUnion) {
+    return higherType.options.every((option: ZodType) =>
+      isCompatibleType(option, lowerType, opts),
+    );
+  }
+  if (lowerType instanceof z.ZodUnion) {
+    return lowerType.options.some((option: ZodType) =>
+      isCompatibleType(higherType, option, opts),
+    );
+  }
+
+  // compare constructor
+  if (higherType.constructor !== lowerType.constructor) {
+    return false;
+  }
+
+  // ZodObject
+  if (higherType instanceof z.ZodObject && lowerType instanceof z.ZodObject) {
+    const superTypeShape = higherType.shape;
+    const subTypeShape = lowerType.shape;
+    if (Object.keys(superTypeShape).length < Object.keys(subTypeShape).length)
+      return false;
+    for (const key in subTypeShape) {
+      if (!(key in superTypeShape)) return false;
+      if (!isCompatibleType(superTypeShape[key], subTypeShape[key], opts)) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  // ZodArray
+  if (higherType instanceof z.ZodArray && lowerType instanceof z.ZodArray) {
+    return isCompatibleType(higherType.element, lowerType.element, opts);
+  }
+
+  // ZodTuple
+  if (higherType instanceof z.ZodTuple && lowerType instanceof z.ZodTuple) {
+    if (higherType.items.length < lowerType.items.length) return false;
+    for (let i = 0; i < lowerType.items.length; i++) {
+      if (!isCompatibleType(higherType.items[i], lowerType.items[i], opts)) {
+        return false;
+      }
+    }
+    // Check rest
+    if (lowerType._def.rest) {
+      if (!higherType._def.rest) return false;
+      return isCompatibleType(higherType._def.rest, lowerType._def.rest, opts);
+    }
+    return true;
+  }
+
+  throw new Error(
+    "Failed to compare types!" +
+      higherType._def.typeName +
+      " " +
+      lowerType._def.typeName,
+  );
+};

package/src/is-same-type.ts

@@ -0,0 +1,208 @@
+import type { EnumLike, ZodType } from "zod";
+import { z } from "zod";
+import {
+  type IsSameTypeOptions,
+  DEFAULT_COMPARE_TYPE_OPTIONS,
+  isPrimitiveType,
+} from "./utils.ts";
+
+/**
+ * isSameType is a function that checks if two ZodTypes are the same.
+ *
+ * Caveats:
+ * - The function does not validate specific criteria such as min or max values, length, email, etc.
+ * - It excludes comparisons involving methods like .describe(), .catch(), .default(), .refine(), and .transform().
+ * - When comparing definitions with .or and .and, they are assessed sequentially based on their order.
+ *
+ * @param a - The first ZodType to compare.
+ * @param b - The second ZodType to compare.
+ * @returns A boolean indicating whether the two types are the same.
+ *
+ * @throws Will throw an error if it encounters an unknown type.
+ *
+ * @example
+ * ```ts
+ * isSameType(z.string(), z.string()); // true
+ * isSameType(z.string(), z.number()); // false
+ * ```
+ */
+export const isSameType = (
+  a: ZodType,
+  b: ZodType,
+  options?: Partial<IsSameTypeOptions>,
+): boolean => {
+  const opts = { ...DEFAULT_COMPARE_TYPE_OPTIONS, ...options };
+  const interceptorResult = opts.interceptor(a, b, opts);
+  if (interceptorResult === true || interceptorResult === false) {
+    return interceptorResult;
+  }
+
+  if (a === undefined || b === undefined) {
+    throw new Error("Failed to compare type! " + a + " " + b);
+  }
+
+  if (a === b) {
+    return true;
+  }
+
+  // compare constructor
+  if (a.constructor !== b.constructor) {
+    // https://stackoverflow.com/questions/24959862/how-to-tell-if-two-javascript-instances-are-of-the-same-class-type
+    return false;
+  }
+  // See https://github.com/colinhacks/zod/blob/master/src/types.ts
+  if (!("typeName" in a._def) || !("typeName" in b._def)) {
+    throw new Error("Failed to compare type! " + a._def + " " + b._def);
+  }
+  if (a._def.typeName !== b._def.typeName) {
+    return false;
+  }
+
+  // ZodBranded
+  if (opts.ignoreBranded) {
+    if (a instanceof z.ZodBranded) {
+      a = a.unwrap();
+    }
+    if (b instanceof z.ZodBranded) {
+      b = b.unwrap();
+    }
+    return isSameType(a, b, opts);
+  } else {
+    if (a instanceof z.ZodBranded || b instanceof z.ZodBranded) {
+      // We can not distinguish different branded type
+      // throw new Error("Can not distinguish different branded type!");
+      return false;
+    }
+  }
+
+  // ZodPromise ZodOptional ZodNullable ZodBranded
+  if ("unwrap" in a && typeof a.unwrap === "function") {
+    if (!("unwrap" in b && typeof b.unwrap === "function")) {
+      return false;
+    }
+    return isSameType(a.unwrap(), b.unwrap(), opts);
+  }
+
+  if (!opts.ignoreOptional && a.isOptional() !== b.isOptional()) return false;
+  if (!opts.ignoreNullable && a.isNullable() !== b.isNullable()) return false;
+
+  if (isPrimitiveType(a)) {
+    // Already assert a and b are the same constructor
+    return true;
+  }
+
+  // ZodObject
+  if (a instanceof z.ZodObject && b instanceof z.ZodObject) {
+    const aShape = a.shape;
+    const bShape = b.shape;
+    if (Object.keys(aShape).length !== Object.keys(bShape).length) return false;
+    for (const key in aShape) {
+      if (!(key in bShape)) return false;
+      if (!isSameType(aShape[key], bShape[key], opts)) return false;
+    }
+    return true;
+  }
+
+  // ZodArray
+  if (a instanceof z.ZodArray && b instanceof z.ZodArray) {
+    return isSameType(a.element, b.element, opts);
+  }
+
+  // ZodTuple
+  if (a instanceof z.ZodTuple && b instanceof z.ZodTuple) {
+    if (a.items.length !== b.items.length) return false;
+    for (let i = 0; i < a.items.length; i++) {
+      if (!isSameType(a.items[i], b.items[i], opts)) return false;
+    }
+    // Compare rest
+    if (a._def.rest || b._def.rest) {
+      // If one has rest, the other must have rest
+      if (!a._def.rest || !b._def.rest) return false;
+      return isSameType(a._def.rest, b._def.rest, opts);
+    }
+    return true;
+  }
+
+  // ZodLiteral
+  if (a instanceof z.ZodLiteral && b instanceof z.ZodLiteral) {
+    return a.value === b.value;
+  }
+
+  // ZodIntersection aka and
+  if (a instanceof z.ZodIntersection && b instanceof z.ZodIntersection) {
+    return (
+      isSameType(a._def.left, b._def.left, opts) &&
+      isSameType(a._def.right, b._def.right, opts)
+    );
+  }
+
+  // ZodUnion aka or
+  if (a instanceof z.ZodUnion && b instanceof z.ZodUnion) {
+    if (a.options.length !== b.options.length) return false;
+    for (let i = 0; i < a.options.length; i++) {
+      if (!isSameType(a.options[i], b.options[i], opts)) return false;
+    }
+    return true;
+  }
+
+  // ZodReadonly
+  if (a instanceof z.ZodReadonly && b instanceof z.ZodReadonly) {
+    return isSameType(a._def.innerType, b._def.innerType, opts);
+  }
+
+  // ZodRecord / ZodMap
+  if (
+    (a instanceof z.ZodRecord && b instanceof z.ZodRecord) ||
+    (a instanceof z.ZodMap && b instanceof z.ZodMap)
+  ) {
+    return (
+      isSameType(a.keySchema, b.keySchema, opts) &&
+      isSameType(a.valueSchema, b.valueSchema, opts)
+    );
+  }
+
+  // ZodSet
+  if (a instanceof z.ZodSet && b instanceof z.ZodSet) {
+    return isSameType(a._def.valueType, b._def.valueType, opts);
+  }
+
+  // ZodFunction
+  if (a instanceof z.ZodFunction && b instanceof z.ZodFunction) {
+    return (
+      isSameType(a.parameters(), b.parameters(), opts) &&
+      isSameType(a.returnType(), b.returnType(), opts)
+    );
+  }
+
+  // ZodEnum
+  if (a instanceof z.ZodEnum && b instanceof z.ZodEnum) {
+    const optionsA: [string, ...string[]] = a.options;
+    const optionsB: [string, ...string[]] = b.options;
+    if (optionsA.length !== optionsB.length) return false;
+    for (let i = 0; i < optionsA.length; i++) {
+      if (optionsA[i] !== optionsB[i]) return false;
+    }
+    return true;
+  }
+
+  // ZodNativeEnum
+  if (a instanceof z.ZodNativeEnum && b instanceof z.ZodNativeEnum) {
+    const enumA: EnumLike = a.enum;
+    const enumB: EnumLike = b.enum;
+    if (Object.keys(enumA).length !== Object.keys(enumB).length) return false;
+    for (const key in enumA) {
+      if (enumA[key] !== enumB[key]) return false;
+    }
+    return true;
+  }
+
+  // ZodLazy
+  // ZodEffects
+  // ZodDefault
+  // ZodCatch
+  // ZodPipeline
+  // ZodTransformer
+  // ZodError
+  console.error('Failed to compare type! "' + a, b);
+  throw new Error("Unknown type! " + a._def.typeName + " " + b._def.typeName);
+};

package/src/utils.ts

@@ -0,0 +1,63 @@
+import { z, type ZodType } from "zod";
+
+export interface IsSameTypeOptions {
+  deep: true;
+  /**
+   * Ignore all specific validations like min, max, length, email etc.
+   *
+   * You still can use `interceptor` to validate the type manually.
+   */
+  ignoreValidations: true;
+  ignoreOptional: boolean;
+  ignoreNullable: boolean;
+  ignoreReadOnly: false;
+  ignoreBranded: boolean;
+  ignoreIntersectionsOrder: false;
+  /**
+   * A function that provides custom logic for comparing two ZodType instances.
+   *
+   * If the function returns `true` or `false`, the result will be used as the comparison result.
+   * Otherwise, the default comparison logic will be used.
+   *
+   */
+  interceptor: (
+    a: ZodType,
+    b: ZodType,
+    options: IsSameTypeOptions,
+  ) => boolean | void;
+}
+
+export interface IsCompatibleTypeOptions extends IsSameTypeOptions {
+  ignoreOptional: false;
+  ignoreNullable: false;
+}
+
+export const DEFAULT_COMPARE_TYPE_OPTIONS = {
+  deep: true,
+  ignoreOptional: false,
+  ignoreNullable: false,
+  ignoreReadOnly: false,
+  ignoreBranded: false,
+  ignoreValidations: true,
+  ignoreIntersectionsOrder: false,
+  interceptor: () => {},
+} as const satisfies IsSameTypeOptions;
+
+// See ZodFirstPartyTypeKind
+export const isPrimitiveType = (a: ZodType): boolean => {
+  return (
+    a instanceof z.ZodString ||
+    a instanceof z.ZodNumber ||
+    a instanceof z.ZodNaN ||
+    a instanceof z.ZodBigInt ||
+    a instanceof z.ZodBoolean ||
+    a instanceof z.ZodDate ||
+    a instanceof z.ZodSymbol ||
+    a instanceof z.ZodUndefined ||
+    a instanceof z.ZodNull ||
+    a instanceof z.ZodAny ||
+    a instanceof z.ZodUnknown ||
+    a instanceof z.ZodNever ||
+    a instanceof z.ZodVoid
+  );
+};