zod-compare 0.1.1 → 0.1.3

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 whitewater
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,6 +1,7 @@
 # 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)
+[![npm](https://img.shields.io/npm/v/zod-compare)](https://www.npmjs.com/package/zod-compare)
 
 Compare two [Zod](https://zod.dev/) schemas recursively.
 

package/dist/index.cjs

@@ -1,2 +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;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const t=require("zod"),z={deep:!0,ignoreOptional:!1,ignoreNullable:!1,ignoreReadOnly:!1,ignoreBranded:!1,ignoreValidations:!0,interceptor:()=>{}},Z=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,a=e=>e.options.flatMap(n=>n instanceof t.z.ZodUnion?a(n):n),s=(e,n,u)=>{const r={...z,...u},d=r.interceptor(e,n,r);if(d===!0||d===!1)return d;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()),s(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"?s(e.unwrap(),n.unwrap(),r):!1;if(!r.ignoreOptional&&e.isOptional()!==n.isOptional()||!r.ignoreNullable&&e.isNullable()!==n.isNullable())return!1;if(Z(e))return!0;if(e instanceof t.z.ZodObject&&n instanceof t.z.ZodObject){const o=e.shape,i=n.shape;if(Object.keys(o).length!==Object.keys(i).length)return!1;for(const f in o)if(!(f in i)||!s(o[f],i[f],r))return!1;return!0}if(e instanceof t.z.ZodArray&&n instanceof t.z.ZodArray)return s(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(!s(e.items[o],n.items[o],r))return!1;return e._def.rest||n._def.rest?!e._def.rest||!n._def.rest?!1:s(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 s(e._def.left,n._def.left,r)&&s(e._def.right,n._def.right,r)||s(e._def.left,n._def.right,r)&&s(e._def.right,n._def.left,r);if(e instanceof t.z.ZodUnion&&n instanceof t.z.ZodUnion){const o=a(e),i=a(n);if(o.length!==i.length)return!1;for(let f of o){let l=i.findIndex(m=>s(f,m,r));if(l===-1)return!1;i.splice(l,1)}return i.length===0}if(e instanceof t.z.ZodReadonly&&n instanceof t.z.ZodReadonly)return s(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 s(e.keySchema,n.keySchema,r)&&s(e.valueSchema,n.valueSchema,r);if(e instanceof t.z.ZodSet&&n instanceof t.z.ZodSet)return s(e._def.valueType,n._def.valueType,r);if(e instanceof t.z.ZodFunction&&n instanceof t.z.ZodFunction)return s(e.parameters(),n.parameters(),r)&&s(e.returnType(),n.returnType(),r);if(e instanceof t.z.ZodEnum&&n instanceof t.z.ZodEnum){const o=e.options,i=n.options;if(o.length!==i.length)return!1;for(let f=0;f<o.length;f++)if(o[f]!==i[f])return!1;return!0}if(e instanceof t.z.ZodNativeEnum&&n instanceof t.z.ZodNativeEnum){const o=e.enum,i=n.enum;if(Object.keys(o).length!==Object.keys(i).length)return!1;for(const f in o)if(o[f]!==i[f])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,u)=>{const r={...z,...u},d=r.interceptor(e,n,r);if(d===!0||d===!1)return d;if(s(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(f=>c(f,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,i=n.shape;if(Object.keys(o).length<Object.keys(i).length)return!1;for(const f in i)if(!(f in o)||!c(o[f],i[f],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=s;
 //# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -1 +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":"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"}
+{"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  /**\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  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\ntype Mutable<T> = { -readonly [k in keyof T]: T[k] };\n\nexport const flatUnwrapUnion = <\n  T extends z.ZodUnionOptions = readonly [z.ZodTypeAny, ...z.ZodTypeAny[]],\n>(\n  t: z.ZodUnion<T>,\n): Mutable<T> => {\n  return t.options.flatMap((x) => {\n    if (x instanceof z.ZodUnion) {\n      return flatUnwrapUnion(x);\n    }\n    return x;\n  }) as unknown as T;\n};\n","import type { EnumLike, ZodType } from \"zod\";\nimport { z } from \"zod\";\nimport {\n  type IsSameTypeOptions,\n  DEFAULT_COMPARE_TYPE_OPTIONS,\n  isPrimitiveType,\n  flatUnwrapUnion,\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      (isSameType(a._def.left, b._def.right, opts) &&\n        isSameType(a._def.right, b._def.left, opts))\n    );\n  }\n\n  // ZodUnion aka or\n  if (a instanceof z.ZodUnion && b instanceof z.ZodUnion) {\n    const aOptions = flatUnwrapUnion(a as z.ZodUnion<z.ZodUnionOptions>);\n    const bOptions = flatUnwrapUnion(b as z.ZodUnion<z.ZodUnionOptions>);\n    if (aOptions.length !== bOptions.length) return false;\n\n    for (let optionA of aOptions) {\n      let matchIndex = bOptions.findIndex((optionB) =>\n        isSameType(optionA, optionB, opts),\n      );\n      if (matchIndex === -1) return false;\n      bOptions.splice(matchIndex, 1);\n    }\n\n    return bOptions.length === 0;\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","flatUnwrapUnion","t","x","isSameType","b","options","opts","interceptorResult","aShape","bShape","key","i","aOptions","bOptions","optionA","matchIndex","optionB","optionsA","optionsB","enumA","enumB","isCompatibleType","higherType","lowerType","option","superTypeShape","subTypeShape"],"mappings":"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"}

package/dist/index.d.ts

@@ -60,7 +60,6 @@ export declare interface IsSameTypeOptions {
     ignoreNullable: boolean;
     ignoreReadOnly: false;
     ignoreBranded: boolean;
-    ignoreIntersectionsOrder: false;
     /**
      * A function that provides custom logic for comparing two ZodType instances.
      *

package/dist/index.js

@@ -1,18 +1,17 @@
 import { z as t } from "zod";
-const a = {
+const Z = {
   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;
+}, p = (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, a = (e) => e.options.flatMap((n) => n instanceof t.ZodUnion ? a(n) : n), s = (e, n, u) => {
+  const r = { ...Z, ...u }, d = r.interceptor(e, n, r);
+  if (d === !0 || d === !1)
+    return d;
   if (e === void 0 || n === void 0)
     throw new Error("Failed to compare type! " + e + " " + n);
   if (e === n)
@@ -24,81 +23,87 @@ const a = {
   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);
+    return e instanceof t.ZodBranded && (e = e.unwrap()), n instanceof t.ZodBranded && (n = n.unwrap()), s(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;
+    return "unwrap" in n && typeof n.unwrap == "function" ? s(e.unwrap(), n.unwrap(), r) : !1;
   if (!r.ignoreOptional && e.isOptional() !== n.isOptional() || !r.ignoreNullable && e.isNullable() !== n.isNullable())
     return !1;
-  if (l(e))
+  if (p(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)
+    const o = e.shape, f = n.shape;
+    if (Object.keys(o).length !== Object.keys(f).length)
       return !1;
     for (const i in o)
-      if (!(i in s) || !f(o[i], s[i], r))
+      if (!(i in f) || !s(o[i], f[i], r))
         return !1;
     return !0;
   }
   if (e instanceof t.ZodArray && n instanceof t.ZodArray)
-    return f(e.element, n.element, r);
+    return s(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))
+      if (!s(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;
+    return e._def.rest || n._def.rest ? !e._def.rest || !n._def.rest ? !1 : s(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);
+    return s(e._def.left, n._def.left, r) && s(e._def.right, n._def.right, r) || s(e._def.left, n._def.right, r) && s(e._def.right, n._def.left, r);
   if (e instanceof t.ZodUnion && n instanceof t.ZodUnion) {
-    if (e.options.length !== n.options.length)
+    const o = a(e), f = a(n);
+    if (o.length !== f.length)
       return !1;
-    for (let o = 0; o < e.options.length; o++)
-      if (!f(e.options[o], n.options[o], r))
+    for (let i of o) {
+      let l = f.findIndex(
+        (m) => s(i, m, r)
+      );
+      if (l === -1)
         return !1;
-    return !0;
+      f.splice(l, 1);
+    }
+    return f.length === 0;
   }
   if (e instanceof t.ZodReadonly && n instanceof t.ZodReadonly)
-    return f(e._def.innerType, n._def.innerType, r);
+    return s(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);
+    return s(e.keySchema, n.keySchema, r) && s(e.valueSchema, n.valueSchema, r);
   if (e instanceof t.ZodSet && n instanceof t.ZodSet)
-    return f(e._def.valueType, n._def.valueType, r);
+    return s(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);
+    return s(e.parameters(), n.parameters(), r) && s(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)
+    const o = e.options, f = n.options;
+    if (o.length !== f.length)
       return !1;
     for (let i = 0; i < o.length; i++)
-      if (o[i] !== s[i])
+      if (o[i] !== f[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)
+    const o = e.enum, f = n.enum;
+    if (Object.keys(o).length !== Object.keys(f).length)
       return !1;
     for (const i in o)
-      if (o[i] !== s[i])
+      if (o[i] !== f[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) => {
+}, c = (e, n, u) => {
   const r = {
-    ...a,
-    ...d
-  }, u = r.interceptor(e, n, r);
-  if (u === !0 || u === !1)
-    return u;
-  if (f(e, n, r))
+    ...Z,
+    ...u
+  }, d = r.interceptor(e, n, r);
+  if (d === !0 || d === !1)
+    return d;
+  if (s(e, n, r))
     return !0;
   if (!("typeName" in e._def) || !("typeName" in n._def))
     throw new Error(
@@ -125,11 +130,11 @@ const a = {
   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)
+    const o = e.shape, f = n.shape;
+    if (Object.keys(o).length < Object.keys(f).length)
       return !1;
-    for (const i in s)
-      if (!(i in o) || !c(o[i], s[i], r))
+    for (const i in f)
+      if (!(i in o) || !c(o[i], f[i], r))
         return !1;
     return !0;
   }
@@ -149,6 +154,6 @@ const a = {
 };
 export {
   c as isCompatibleType,
-  f as isSameType
+  s as isSameType
 };
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +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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"}
+{"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  /**\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  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\ntype Mutable<T> = { -readonly [k in keyof T]: T[k] };\n\nexport const flatUnwrapUnion = <\n  T extends z.ZodUnionOptions = readonly [z.ZodTypeAny, ...z.ZodTypeAny[]],\n>(\n  t: z.ZodUnion<T>,\n): Mutable<T> => {\n  return t.options.flatMap((x) => {\n    if (x instanceof z.ZodUnion) {\n      return flatUnwrapUnion(x);\n    }\n    return x;\n  }) as unknown as T;\n};\n","import type { EnumLike, ZodType } from \"zod\";\nimport { z } from \"zod\";\nimport {\n  type IsSameTypeOptions,\n  DEFAULT_COMPARE_TYPE_OPTIONS,\n  isPrimitiveType,\n  flatUnwrapUnion,\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      (isSameType(a._def.left, b._def.right, opts) &&\n        isSameType(a._def.right, b._def.left, opts))\n    );\n  }\n\n  // ZodUnion aka or\n  if (a instanceof z.ZodUnion && b instanceof z.ZodUnion) {\n    const aOptions = flatUnwrapUnion(a as z.ZodUnion<z.ZodUnionOptions>);\n    const bOptions = flatUnwrapUnion(b as z.ZodUnion<z.ZodUnionOptions>);\n    if (aOptions.length !== bOptions.length) return false;\n\n    for (let optionA of aOptions) {\n      let matchIndex = bOptions.findIndex((optionB) =>\n        isSameType(optionA, optionB, opts),\n      );\n      if (matchIndex === -1) return false;\n      bOptions.splice(matchIndex, 1);\n    }\n\n    return bOptions.length === 0;\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","flatUnwrapUnion","t","x","isSameType","b","options","opts","interceptorResult","aShape","bShape","key","i","aOptions","bOptions","optionA","matchIndex","optionB","optionsA","optionsB","enumA","enumB","isCompatibleType","higherType","lowerType","option","superTypeShape","subTypeShape"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zod-compare",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Compare two Zod schemas recursively.",
   "keywords": [
     "zod",

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

@@ -135,10 +135,9 @@ describe("isSameType", () => {
       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);
+    ).toBe(true);
   });
 
   test("should compare `or` type", () => {
@@ -149,10 +148,19 @@ describe("isSameType", () => {
       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);
+    ).toBe(true);
+
+    // should flat union type
+    expect(
+      isSameType(
+        // (number | string) | boolean
+        z.number().or(z.string()).or(z.boolean()),
+        // (string | boolean) | number
+        z.string().or(z.boolean()).or(z.number()),
+      ),
+    ).toBe(true);
   });
 
   test("should compare literal type", () => {

package/src/is-same-type.ts

@@ -4,6 +4,7 @@ import {
   type IsSameTypeOptions,
   DEFAULT_COMPARE_TYPE_OPTIONS,
   isPrimitiveType,
+  flatUnwrapUnion,
 } from "./utils.ts";
 
 /**
@@ -131,18 +132,28 @@ export const isSameType = (
   // 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)
+      (isSameType(a._def.left, b._def.left, opts) &&
+        isSameType(a._def.right, b._def.right, opts)) ||
+      (isSameType(a._def.left, b._def.right, opts) &&
+        isSameType(a._def.right, b._def.left, 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;
+    const aOptions = flatUnwrapUnion(a as z.ZodUnion<z.ZodUnionOptions>);
+    const bOptions = flatUnwrapUnion(b as z.ZodUnion<z.ZodUnionOptions>);
+    if (aOptions.length !== bOptions.length) return false;
+
+    for (let optionA of aOptions) {
+      let matchIndex = bOptions.findIndex((optionB) =>
+        isSameType(optionA, optionB, opts),
+      );
+      if (matchIndex === -1) return false;
+      bOptions.splice(matchIndex, 1);
     }
-    return true;
+
+    return bOptions.length === 0;
   }
 
   // ZodReadonly

package/src/utils.ts

@@ -12,7 +12,6 @@ export interface IsSameTypeOptions {
   ignoreNullable: boolean;
   ignoreReadOnly: false;
   ignoreBranded: boolean;
-  ignoreIntersectionsOrder: false;
   /**
    * A function that provides custom logic for comparing two ZodType instances.
    *
@@ -39,7 +38,6 @@ export const DEFAULT_COMPARE_TYPE_OPTIONS = {
   ignoreReadOnly: false,
   ignoreBranded: false,
   ignoreValidations: true,
-  ignoreIntersectionsOrder: false,
   interceptor: () => {},
 } as const satisfies IsSameTypeOptions;
 
@@ -61,3 +59,18 @@ export const isPrimitiveType = (a: ZodType): boolean => {
     a instanceof z.ZodVoid
   );
 };
+
+type Mutable<T> = { -readonly [k in keyof T]: T[k] };
+
+export const flatUnwrapUnion = <
+  T extends z.ZodUnionOptions = readonly [z.ZodTypeAny, ...z.ZodTypeAny[]],
+>(
+  t: z.ZodUnion<T>,
+): Mutable<T> => {
+  return t.options.flatMap((x) => {
+    if (x instanceof z.ZodUnion) {
+      return flatUnwrapUnion(x);
+    }
+    return x;
+  }) as unknown as T;
+};