zod-to-json-schema - npm Package Compare versions

Comparing version 3.24.1 to 3.24.2

changelog.md

@@ -5,2 +5,3 @@ # Changelog
 | --------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| 3.24.2          | Restructured internals to remove circular dependencies which apparently might cause some build systems to whine a bit. Big thanks to [Víctor Hernández](https://github.com/NanezX) for the fix.                                                                                                                                                                        |
 | 3.24.1          | Adds OpenAI target                                                                                                                                                                                                                                                                                                                                                     |
@@ -7,0 +8,0 @@ | 3.24.0          | Implements new string checks (jwt, base64url, cidr ipv4/v6), matching the new Zod version                                                                                                                                                                                                                                                                              |

dist/cjs/index.js

@@ -21,2 +21,3 @@ "use strict";
 __exportStar(require("./parseDef.js"), exports);
+__exportStar(require("./parseTypes.js"), exports);
 __exportStar(require("./parsers/any.js"), exports);
@@ -52,4 +53,5 @@ __exportStar(require("./parsers/array.js"), exports);
 __exportStar(require("./parsers/unknown.js"), exports);
+__exportStar(require("./selectParser.js"), exports);
 __exportStar(require("./zodToJsonSchema.js"), exports);
 const zodToJsonSchema_js_1 = require("./zodToJsonSchema.js");
 exports.default = zodToJsonSchema_js_1.zodToJsonSchema;

dist/cjs/parseDef.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseDef = void 0;
-const zod_1 = require("zod");
-const any_js_1 = require("./parsers/any.js");
-const array_js_1 = require("./parsers/array.js");
-const bigint_js_1 = require("./parsers/bigint.js");
-const boolean_js_1 = require("./parsers/boolean.js");
-const branded_js_1 = require("./parsers/branded.js");
-const catch_js_1 = require("./parsers/catch.js");
-const date_js_1 = require("./parsers/date.js");
-const default_js_1 = require("./parsers/default.js");
-const effects_js_1 = require("./parsers/effects.js");
-const enum_js_1 = require("./parsers/enum.js");
-const intersection_js_1 = require("./parsers/intersection.js");
-const literal_js_1 = require("./parsers/literal.js");
-const map_js_1 = require("./parsers/map.js");
-const nativeEnum_js_1 = require("./parsers/nativeEnum.js");
-const never_js_1 = require("./parsers/never.js");
-const null_js_1 = require("./parsers/null.js");
-const nullable_js_1 = require("./parsers/nullable.js");
-const number_js_1 = require("./parsers/number.js");
-const object_js_1 = require("./parsers/object.js");
-const optional_js_1 = require("./parsers/optional.js");
-const pipeline_js_1 = require("./parsers/pipeline.js");
-const promise_js_1 = require("./parsers/promise.js");
-const record_js_1 = require("./parsers/record.js");
-const set_js_1 = require("./parsers/set.js");
-const string_js_1 = require("./parsers/string.js");
-const tuple_js_1 = require("./parsers/tuple.js");
-const undefined_js_1 = require("./parsers/undefined.js");
-const union_js_1 = require("./parsers/union.js");
-const unknown_js_1 = require("./parsers/unknown.js");
-const readonly_js_1 = require("./parsers/readonly.js");
 const Options_js_1 = require("./Options.js");
+const selectParser_js_1 = require("./selectParser.js");
 function parseDef(def, refs, forceResolution = false) {
@@ -52,3 +22,7 @@ const seenItem = refs.seen.get(def);
     refs.seen.set(def, newItem);
-    const jsonSchema = selectParser(def, def.typeName, refs);
+    const jsonSchemaOrGetter = (0, selectParser_js_1.selectParser)(def, def.typeName, refs);
+    // If the return was a function, then the inner definition needs to be extracted before a call to parseDef (recursive)
+    const jsonSchema = typeof jsonSchemaOrGetter === "function"
+        ? parseDef(jsonSchemaOrGetter(), refs)
+        : jsonSchemaOrGetter;
     if (jsonSchema) {
@@ -86,77 +60,2 @@ addMeta(def, refs, jsonSchema);
 };
-const selectParser = (def, typeName, refs) => {
-    switch (typeName) {
-        case zod_1.ZodFirstPartyTypeKind.ZodString:
-            return (0, string_js_1.parseStringDef)(def, refs);
-        case zod_1.ZodFirstPartyTypeKind.ZodNumber:
-            return (0, number_js_1.parseNumberDef)(def, refs);
-        case zod_1.ZodFirstPartyTypeKind.ZodObject:
-            return (0, object_js_1.parseObjectDef)(def, refs);
-        case zod_1.ZodFirstPartyTypeKind.ZodBigInt:
-            return (0, bigint_js_1.parseBigintDef)(def, refs);
-        case zod_1.ZodFirstPartyTypeKind.ZodBoolean:
-            return (0, boolean_js_1.parseBooleanDef)();
-        case zod_1.ZodFirstPartyTypeKind.ZodDate:
-            return (0, date_js_1.parseDateDef)(def, refs);
-        case zod_1.ZodFirstPartyTypeKind.ZodUndefined:
-            return (0, undefined_js_1.parseUndefinedDef)();
-        case zod_1.ZodFirstPartyTypeKind.ZodNull:
-            return (0, null_js_1.parseNullDef)(refs);
-        case zod_1.ZodFirstPartyTypeKind.ZodArray:
-            return (0, array_js_1.parseArrayDef)(def, refs);
-        case zod_1.ZodFirstPartyTypeKind.ZodUnion:
-        case zod_1.ZodFirstPartyTypeKind.ZodDiscriminatedUnion:
-            return (0, union_js_1.parseUnionDef)(def, refs);
-        case zod_1.ZodFirstPartyTypeKind.ZodIntersection:
-            return (0, intersection_js_1.parseIntersectionDef)(def, refs);
-        case zod_1.ZodFirstPartyTypeKind.ZodTuple:
-            return (0, tuple_js_1.parseTupleDef)(def, refs);
-        case zod_1.ZodFirstPartyTypeKind.ZodRecord:
-            return (0, record_js_1.parseRecordDef)(def, refs);
-        case zod_1.ZodFirstPartyTypeKind.ZodLiteral:
-            return (0, literal_js_1.parseLiteralDef)(def, refs);
-        case zod_1.ZodFirstPartyTypeKind.ZodEnum:
-            return (0, enum_js_1.parseEnumDef)(def);
-        case zod_1.ZodFirstPartyTypeKind.ZodNativeEnum:
-            return (0, nativeEnum_js_1.parseNativeEnumDef)(def);
-        case zod_1.ZodFirstPartyTypeKind.ZodNullable:
-            return (0, nullable_js_1.parseNullableDef)(def, refs);
-        case zod_1.ZodFirstPartyTypeKind.ZodOptional:
-            return (0, optional_js_1.parseOptionalDef)(def, refs);
-        case zod_1.ZodFirstPartyTypeKind.ZodMap:
-            return (0, map_js_1.parseMapDef)(def, refs);
-        case zod_1.ZodFirstPartyTypeKind.ZodSet:
-            return (0, set_js_1.parseSetDef)(def, refs);
-        case zod_1.ZodFirstPartyTypeKind.ZodLazy:
-            return parseDef(def.getter()._def, refs);
-        case zod_1.ZodFirstPartyTypeKind.ZodPromise:
-            return (0, promise_js_1.parsePromiseDef)(def, refs);
-        case zod_1.ZodFirstPartyTypeKind.ZodNaN:
-        case zod_1.ZodFirstPartyTypeKind.ZodNever:
-            return (0, never_js_1.parseNeverDef)();
-        case zod_1.ZodFirstPartyTypeKind.ZodEffects:
-            return (0, effects_js_1.parseEffectsDef)(def, refs);
-        case zod_1.ZodFirstPartyTypeKind.ZodAny:
-            return (0, any_js_1.parseAnyDef)();
-        case zod_1.ZodFirstPartyTypeKind.ZodUnknown:
-            return (0, unknown_js_1.parseUnknownDef)();
-        case zod_1.ZodFirstPartyTypeKind.ZodDefault:
-            return (0, default_js_1.parseDefaultDef)(def, refs);
-        case zod_1.ZodFirstPartyTypeKind.ZodBranded:
-            return (0, branded_js_1.parseBrandedDef)(def, refs);
-        case zod_1.ZodFirstPartyTypeKind.ZodReadonly:
-            return (0, readonly_js_1.parseReadonlyDef)(def, refs);
-        case zod_1.ZodFirstPartyTypeKind.ZodCatch:
-            return (0, catch_js_1.parseCatchDef)(def, refs);
-        case zod_1.ZodFirstPartyTypeKind.ZodPipeline:
-            return (0, pipeline_js_1.parsePipelineDef)(def, refs);
-        case zod_1.ZodFirstPartyTypeKind.ZodFunction:
-        case zod_1.ZodFirstPartyTypeKind.ZodVoid:
-        case zod_1.ZodFirstPartyTypeKind.ZodSymbol:
-            return undefined;
-        default:
-            /* c8 ignore next */
-            return ((_) => undefined)(typeName);
-    }
-};
 const addMeta = (def, refs, jsonSchema) => {
@@ -163,0 +62,0 @@ if (def.description) {

dist/esm/index.js

@@ -5,2 +5,3 @@ export * from "./Options.js";
 export * from "./parseDef.js";
+export * from "./parseTypes.js";
 export * from "./parsers/any.js";
@@ -36,4 +37,5 @@ export * from "./parsers/array.js";
 export * from "./parsers/unknown.js";
+export * from "./selectParser.js";
 export * from "./zodToJsonSchema.js";
 import { zodToJsonSchema } from "./zodToJsonSchema.js";
 export default zodToJsonSchema;

dist/esm/package.json

@@ -1,1 +0,1 @@
-{"type":"module"}
+{"type":"module","main":"index.js"}

dist/esm/parseDef.js

@@ -1,33 +0,3 @@
-import { ZodFirstPartyTypeKind } from "zod";
-import { parseAnyDef } from "./parsers/any.js";
-import { parseArrayDef } from "./parsers/array.js";
-import { parseBigintDef } from "./parsers/bigint.js";
-import { parseBooleanDef } from "./parsers/boolean.js";
-import { parseBrandedDef } from "./parsers/branded.js";
-import { parseCatchDef } from "./parsers/catch.js";
-import { parseDateDef } from "./parsers/date.js";
-import { parseDefaultDef } from "./parsers/default.js";
-import { parseEffectsDef } from "./parsers/effects.js";
-import { parseEnumDef } from "./parsers/enum.js";
-import { parseIntersectionDef, } from "./parsers/intersection.js";
-import { parseLiteralDef } from "./parsers/literal.js";
-import { parseMapDef } from "./parsers/map.js";
-import { parseNativeEnumDef, } from "./parsers/nativeEnum.js";
-import { parseNeverDef } from "./parsers/never.js";
-import { parseNullDef } from "./parsers/null.js";
-import { parseNullableDef, } from "./parsers/nullable.js";
-import { parseNumberDef } from "./parsers/number.js";
-import { parseObjectDef } from "./parsers/object.js";
-import { parseOptionalDef } from "./parsers/optional.js";
-import { parsePipelineDef } from "./parsers/pipeline.js";
-import { parsePromiseDef } from "./parsers/promise.js";
-import { parseRecordDef } from "./parsers/record.js";
-import { parseSetDef } from "./parsers/set.js";
-import { parseStringDef } from "./parsers/string.js";
-import { parseTupleDef } from "./parsers/tuple.js";
-import { parseUndefinedDef, } from "./parsers/undefined.js";
-import { parseUnionDef } from "./parsers/union.js";
-import { parseUnknownDef } from "./parsers/unknown.js";
-import { parseReadonlyDef } from "./parsers/readonly.js";
 import { ignoreOverride } from "./Options.js";
+import { selectParser } from "./selectParser.js";
 export function parseDef(def, refs, forceResolution = false) {
@@ -49,3 +19,7 @@ const seenItem = refs.seen.get(def);
     refs.seen.set(def, newItem);
-    const jsonSchema = selectParser(def, def.typeName, refs);
+    const jsonSchemaOrGetter = selectParser(def, def.typeName, refs);
+    // If the return was a function, then the inner definition needs to be extracted before a call to parseDef (recursive)
+    const jsonSchema = typeof jsonSchemaOrGetter === "function"
+        ? parseDef(jsonSchemaOrGetter(), refs)
+        : jsonSchemaOrGetter;
     if (jsonSchema) {
@@ -82,77 +56,2 @@ addMeta(def, refs, jsonSchema);
 };
-const selectParser = (def, typeName, refs) => {
-    switch (typeName) {
-        case ZodFirstPartyTypeKind.ZodString:
-            return parseStringDef(def, refs);
-        case ZodFirstPartyTypeKind.ZodNumber:
-            return parseNumberDef(def, refs);
-        case ZodFirstPartyTypeKind.ZodObject:
-            return parseObjectDef(def, refs);
-        case ZodFirstPartyTypeKind.ZodBigInt:
-            return parseBigintDef(def, refs);
-        case ZodFirstPartyTypeKind.ZodBoolean:
-            return parseBooleanDef();
-        case ZodFirstPartyTypeKind.ZodDate:
-            return parseDateDef(def, refs);
-        case ZodFirstPartyTypeKind.ZodUndefined:
-            return parseUndefinedDef();
-        case ZodFirstPartyTypeKind.ZodNull:
-            return parseNullDef(refs);
-        case ZodFirstPartyTypeKind.ZodArray:
-            return parseArrayDef(def, refs);
-        case ZodFirstPartyTypeKind.ZodUnion:
-        case ZodFirstPartyTypeKind.ZodDiscriminatedUnion:
-            return parseUnionDef(def, refs);
-        case ZodFirstPartyTypeKind.ZodIntersection:
-            return parseIntersectionDef(def, refs);
-        case ZodFirstPartyTypeKind.ZodTuple:
-            return parseTupleDef(def, refs);
-        case ZodFirstPartyTypeKind.ZodRecord:
-            return parseRecordDef(def, refs);
-        case ZodFirstPartyTypeKind.ZodLiteral:
-            return parseLiteralDef(def, refs);
-        case ZodFirstPartyTypeKind.ZodEnum:
-            return parseEnumDef(def);
-        case ZodFirstPartyTypeKind.ZodNativeEnum:
-            return parseNativeEnumDef(def);
-        case ZodFirstPartyTypeKind.ZodNullable:
-            return parseNullableDef(def, refs);
-        case ZodFirstPartyTypeKind.ZodOptional:
-            return parseOptionalDef(def, refs);
-        case ZodFirstPartyTypeKind.ZodMap:
-            return parseMapDef(def, refs);
-        case ZodFirstPartyTypeKind.ZodSet:
-            return parseSetDef(def, refs);
-        case ZodFirstPartyTypeKind.ZodLazy:
-            return parseDef(def.getter()._def, refs);
-        case ZodFirstPartyTypeKind.ZodPromise:
-            return parsePromiseDef(def, refs);
-        case ZodFirstPartyTypeKind.ZodNaN:
-        case ZodFirstPartyTypeKind.ZodNever:
-            return parseNeverDef();
-        case ZodFirstPartyTypeKind.ZodEffects:
-            return parseEffectsDef(def, refs);
-        case ZodFirstPartyTypeKind.ZodAny:
-            return parseAnyDef();
-        case ZodFirstPartyTypeKind.ZodUnknown:
-            return parseUnknownDef();
-        case ZodFirstPartyTypeKind.ZodDefault:
-            return parseDefaultDef(def, refs);
-        case ZodFirstPartyTypeKind.ZodBranded:
-            return parseBrandedDef(def, refs);
-        case ZodFirstPartyTypeKind.ZodReadonly:
-            return parseReadonlyDef(def, refs);
-        case ZodFirstPartyTypeKind.ZodCatch:
-            return parseCatchDef(def, refs);
-        case ZodFirstPartyTypeKind.ZodPipeline:
-            return parsePipelineDef(def, refs);
-        case ZodFirstPartyTypeKind.ZodFunction:
-        case ZodFirstPartyTypeKind.ZodVoid:
-        case ZodFirstPartyTypeKind.ZodSymbol:
-            return undefined;
-        default:
-            /* c8 ignore next */
-            return ((_) => undefined)(typeName);
-    }
-};
 const addMeta = (def, refs, jsonSchema) => {
@@ -159,0 +58,0 @@ if (def.description) {

dist/types/errorMessages.d.ts

@@ -1,2 +0,2 @@
-import { JsonSchema7TypeUnion } from "./parseDef.js";
+import { JsonSchema7TypeUnion } from "./parseTypes.js";
 import { Refs } from "./Refs.js";
@@ -3,0 +3,0 @@ export type ErrorMessages<T extends JsonSchema7TypeUnion, OmitProperties extends string = ""> = Partial<Omit<{

dist/types/index.d.ts

@@ -5,2 +5,3 @@ export * from "./Options.js";
 export * from "./parseDef.js";
+export * from "./parseTypes.js";
 export * from "./parsers/any.js";
@@ -36,4 +37,5 @@ export * from "./parsers/array.js";
 export * from "./parsers/unknown.js";
+export * from "./selectParser.js";
 export * from "./zodToJsonSchema.js";
 import { zodToJsonSchema } from "./zodToJsonSchema.js";
 export default zodToJsonSchema;

dist/types/Options.d.ts

 import { ZodSchema, ZodTypeDef } from "zod";
 import { Refs, Seen } from "./Refs";
-import { JsonSchema7Type } from "./parseDef";
+import { JsonSchema7Type } from "./parseTypes";
 export type Targets = "jsonSchema7" | "jsonSchema2019-09" | "openApi3" | "openAi";
@@ -5,0 +5,0 @@ export type DateStrategy = "format:date-time" | "format:date" | "string" | "integer";

dist/types/parseDef.d.ts

 import { ZodTypeDef } from "zod";
-import { JsonSchema7AnyType } from "./parsers/any.js";
-import { JsonSchema7ArrayType } from "./parsers/array.js";
-import { JsonSchema7BigintType } from "./parsers/bigint.js";
-import { JsonSchema7BooleanType } from "./parsers/boolean.js";
-import { JsonSchema7DateType } from "./parsers/date.js";
-import { JsonSchema7EnumType } from "./parsers/enum.js";
-import { JsonSchema7AllOfType } from "./parsers/intersection.js";
-import { JsonSchema7LiteralType } from "./parsers/literal.js";
-import { JsonSchema7MapType } from "./parsers/map.js";
-import { JsonSchema7NativeEnumType } from "./parsers/nativeEnum.js";
-import { JsonSchema7NeverType } from "./parsers/never.js";
-import { JsonSchema7NullType } from "./parsers/null.js";
-import { JsonSchema7NullableType } from "./parsers/nullable.js";
-import { JsonSchema7NumberType } from "./parsers/number.js";
-import { JsonSchema7ObjectType } from "./parsers/object.js";
-import { JsonSchema7RecordType } from "./parsers/record.js";
-import { JsonSchema7SetType } from "./parsers/set.js";
-import { JsonSchema7StringType } from "./parsers/string.js";
-import { JsonSchema7TupleType } from "./parsers/tuple.js";
-import { JsonSchema7UndefinedType } from "./parsers/undefined.js";
-import { JsonSchema7UnionType } from "./parsers/union.js";
-import { JsonSchema7UnknownType } from "./parsers/unknown.js";
 import { Refs } from "./Refs.js";
-type JsonSchema7RefType = {
-    $ref: string;
-};
-type JsonSchema7Meta = {
-    title?: string;
-    default?: any;
-    description?: string;
-    markdownDescription?: string;
-};
-export type JsonSchema7TypeUnion = JsonSchema7StringType | JsonSchema7ArrayType | JsonSchema7NumberType | JsonSchema7BigintType | JsonSchema7BooleanType | JsonSchema7DateType | JsonSchema7EnumType | JsonSchema7LiteralType | JsonSchema7NativeEnumType | JsonSchema7NullType | JsonSchema7NumberType | JsonSchema7ObjectType | JsonSchema7RecordType | JsonSchema7TupleType | JsonSchema7UnionType | JsonSchema7UndefinedType | JsonSchema7RefType | JsonSchema7NeverType | JsonSchema7MapType | JsonSchema7AnyType | JsonSchema7NullableType | JsonSchema7AllOfType | JsonSchema7UnknownType | JsonSchema7SetType;
-export type JsonSchema7Type = JsonSchema7TypeUnion & JsonSchema7Meta;
+import { JsonSchema7Type } from "./parseTypes.js";
 export declare function parseDef(def: ZodTypeDef, refs: Refs, forceResolution?: boolean): JsonSchema7Type | undefined;
-export {};

dist/types/parsers/array.d.ts

 import { ZodArrayDef } from "zod";
 import { ErrorMessages } from "../errorMessages.js";
-import { JsonSchema7Type } from "../parseDef.js";
+import { JsonSchema7Type } from "../parseTypes.js";
 import { Refs } from "../Refs.js";
@@ -5,0 +5,0 @@ export type JsonSchema7ArrayType = {

dist/types/parsers/branded.d.ts

 import { ZodBrandedDef } from "zod";
 import { Refs } from "../Refs.js";
-export declare function parseBrandedDef(_def: ZodBrandedDef<any>, refs: Refs): import("../parseDef.js").JsonSchema7Type | undefined;
+export declare function parseBrandedDef(_def: ZodBrandedDef<any>, refs: Refs): import("../parseTypes.js").JsonSchema7Type | undefined;

dist/types/parsers/catch.d.ts

 import { ZodCatchDef } from "zod";
 import { Refs } from "../Refs.js";
-export declare const parseCatchDef: (def: ZodCatchDef<any>, refs: Refs) => import("../parseDef.js").JsonSchema7Type | undefined;
+export declare const parseCatchDef: (def: ZodCatchDef<any>, refs: Refs) => import("../parseTypes.js").JsonSchema7Type | undefined;

dist/types/parsers/default.d.ts

 import { ZodDefaultDef } from "zod";
-import { JsonSchema7Type } from "../parseDef.js";
+import { JsonSchema7Type } from "../parseTypes.js";
 import { Refs } from "../Refs.js";
@@ -4,0 +4,0 @@ export declare function parseDefaultDef(_def: ZodDefaultDef, refs: Refs): JsonSchema7Type & {

dist/types/parsers/effects.d.ts

 import { ZodEffectsDef } from "zod";
-import { JsonSchema7Type } from "../parseDef.js";
+import { JsonSchema7Type } from "../parseTypes.js";
 import { Refs } from "../Refs.js";
 export declare function parseEffectsDef(_def: ZodEffectsDef, refs: Refs): JsonSchema7Type | undefined;

dist/types/parsers/intersection.d.ts

 import { ZodIntersectionDef } from "zod";
-import { JsonSchema7Type } from "../parseDef.js";
+import { JsonSchema7Type } from "../parseTypes.js";
 import { Refs } from "../Refs.js";
@@ -4,0 +4,0 @@ export type JsonSchema7AllOfType = {

dist/types/parsers/map.d.ts

 import { ZodMapDef } from "zod";
-import { JsonSchema7Type } from "../parseDef.js";
+import { JsonSchema7Type } from "../parseTypes.js";
 import { Refs } from "../Refs.js";
@@ -4,0 +4,0 @@ import { JsonSchema7RecordType } from "./record.js";

dist/types/parsers/nullable.d.ts

 import { ZodNullableDef } from "zod";
-import { JsonSchema7Type } from "../parseDef.js";
+import { JsonSchema7Type } from "../parseTypes.js";
 import { Refs } from "../Refs.js";
@@ -4,0 +4,0 @@ import { JsonSchema7NullType } from "./null.js";

dist/types/parsers/object.d.ts

 import { ZodObjectDef } from "zod";
-import { JsonSchema7Type } from "../parseDef.js";
+import { JsonSchema7Type } from "../parseTypes.js";
 import { Refs } from "../Refs.js";
@@ -4,0 +4,0 @@ export type JsonSchema7ObjectType = {

dist/types/parsers/optional.d.ts

 import { ZodOptionalDef } from "zod";
-import { JsonSchema7Type } from "../parseDef.js";
+import { JsonSchema7Type } from "../parseTypes.js";
 import { Refs } from "../Refs.js";
 export declare const parseOptionalDef: (def: ZodOptionalDef, refs: Refs) => JsonSchema7Type | undefined;

dist/types/parsers/pipeline.d.ts

 import { ZodPipelineDef } from "zod";
-import { JsonSchema7Type } from "../parseDef.js";
+import { JsonSchema7Type } from "../parseTypes.js";
 import { Refs } from "../Refs.js";
 import { JsonSchema7AllOfType } from "./intersection.js";
 export declare const parsePipelineDef: (def: ZodPipelineDef<any, any>, refs: Refs) => JsonSchema7AllOfType | JsonSchema7Type | undefined;

dist/types/parsers/promise.d.ts

 import { ZodPromiseDef } from "zod";
-import { JsonSchema7Type } from "../parseDef.js";
+import { JsonSchema7Type } from "../parseTypes.js";
 import { Refs } from "../Refs.js";
 export declare function parsePromiseDef(def: ZodPromiseDef, refs: Refs): JsonSchema7Type | undefined;

dist/types/parsers/readonly.d.ts

 import { ZodReadonlyDef } from "zod";
 import { Refs } from "../Refs.js";
-export declare const parseReadonlyDef: (def: ZodReadonlyDef<any>, refs: Refs) => import("../parseDef.js").JsonSchema7Type | undefined;
+export declare const parseReadonlyDef: (def: ZodReadonlyDef<any>, refs: Refs) => import("../parseTypes.js").JsonSchema7Type | undefined;

dist/types/parsers/record.d.ts

 import { ZodMapDef, ZodRecordDef, ZodTypeAny } from "zod";
-import { JsonSchema7Type } from "../parseDef.js";
+import { JsonSchema7Type } from "../parseTypes.js";
 import { Refs } from "../Refs.js";
@@ -4,0 +4,0 @@ import { JsonSchema7EnumType } from "./enum.js";

dist/types/parsers/set.d.ts

 import { ZodSetDef } from "zod";
 import { ErrorMessages } from "../errorMessages.js";
-import { JsonSchema7Type } from "../parseDef.js";
+import { JsonSchema7Type } from "../parseTypes.js";
 import { Refs } from "../Refs.js";
@@ -5,0 +5,0 @@ export type JsonSchema7SetType = {

dist/types/parsers/tuple.d.ts

 import { ZodTupleDef, ZodTupleItems, ZodTypeAny } from "zod";
-import { JsonSchema7Type } from "../parseDef.js";
+import { JsonSchema7Type } from "../parseTypes.js";
 import { Refs } from "../Refs.js";
@@ -4,0 +4,0 @@ export type JsonSchema7TupleType = {

dist/types/parsers/union.d.ts

 import { ZodDiscriminatedUnionDef, ZodUnionDef } from "zod";
-import { JsonSchema7Type } from "../parseDef.js";
+import { JsonSchema7Type } from "../parseTypes.js";
 import { Refs } from "../Refs.js";
@@ -4,0 +4,0 @@ export declare const primitiveMappings: {

dist/types/Refs.d.ts

 import { ZodTypeDef } from "zod";
 import { Options, Targets } from "./Options.js";
-import { JsonSchema7Type } from "./parseDef.js";
+import { JsonSchema7Type } from "./parseTypes.js";
 export type Refs = {
@@ -5,0 +5,0 @@ seen: Map<ZodTypeDef, Seen>;

dist/types/zodToJsonSchema.d.ts

 import { ZodSchema } from "zod";
 import { Options, Targets } from "./Options.js";
-import { JsonSchema7Type } from "./parseDef.js";
+import { JsonSchema7Type } from "./parseTypes.js";
 declare const zodToJsonSchema: <Target extends Targets = "jsonSchema7">(schema: ZodSchema<any>, options?: string | Partial<Options<Target>> | undefined) => (Target extends "jsonSchema7" ? JsonSchema7Type : object) & {
@@ -5,0 +5,0 @@ $schema?: string | undefined;

package.json

 {
   "name": "zod-to-json-schema",
-  "version": "3.24.1",
+  "version": "3.24.2",
   "description": "Converts Zod schemas to Json Schemas",
@@ -19,6 +19,7 @@ "types": "./dist/types/index.d.ts",
   "scripts": {
+    "build:test": "npm --prefix ./dist-test test",
     "build:types": "tsc -p tsconfig.types.json",
     "build:cjs": "tsc -p tsconfig.cjs.json && tsx postcjs.ts",
     "build:esm": "tsc -p tsconfig.esm.json && tsx postesm.ts",
-    "build": "npm i && npm run gen && npm test && rimraf ./dist && npm run build:types && npm run build:cjs && npm run build:esm",
+    "build": "npm i && npm run gen && npm test && rimraf ./dist && npm run build:types && npm run build:cjs && npm run build:esm && npm run build:test",
     "dry": "npm run build && npm pub --dry-run",
@@ -67,3 +68,4 @@ "test:watch": "tsx watch test/index.ts",
     "Mitchell Merry (https://github.com/mitchell-merry)",
-    "Enzo Monjardín (https://github.com/enzomonjardin)"
+    "Enzo Monjardín (https://github.com/enzomonjardin)",
+    "Víctor Hernández (https://github.com/NanezX)"
   ],
@@ -70,0 +72,0 @@ "repository": {

postesm.ts

 import { writeFileSync } from "fs";
 
-writeFileSync("./dist/esm/package.json", '{"type":"module"}', "utf-8");
+writeFileSync("./dist/esm/package.json", '{"type":"module","main":"index.js"}', "utf-8");

README.md

@@ -258,2 +258,3 @@ # Zod to Json Schema
 - Since v3, the Object parser uses `.isOptional()` to check if a property should be included in `required` or not. This has the potentially dangerous behavior of calling `.safeParse` with `undefined`. To work around this, make sure your `preprocess` and other effects callbacks are pure and not liable to throw errors. An issue has been logged in the Zod repo and can be [tracked here](https://github.com/colinhacks/zod/issues/1460).
+- JSON Schema version 2020-12 is not yet officially supported. However, you should be able to use this library to obtain a compatible schema for the 2020-12 format just by changing the returned schema's `$schema` field to: "https://json-schema.org/draft/2020-12/schema#"
 
@@ -260,0 +261,0 @@ ## Versioning

New alerts

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Mixed license

License

(Experimental) Package contains multiple licenses.

Found 1 instance in 1 package

URL strings

Supply chain risk

Package contains fragments of external URLs or IP addresses, which the package may be accessing at runtime.

Found 1 instance in 1 package

Fixed alerts

URL strings

Supply chain risk

Package contains fragments of external URLs or IP addresses, which the package may be accessing at runtime.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

2291831

1123.13%

Number of package files

296

144.63%

Lines of code

50832

1414.21%

Number of lines in readme file

269

0.37%

Worsened metrics

Number of low license alerts

1

Infinity%

Number of medium supply chain risk alerts

1

Infinity%

No dependency changes