@gabrielbryk/json-schema-to-zod 2.8.0 → 2.9.0

package/dist/esm/generators/generateBundle.js

@@ -1,61 +1,31 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateSchemaBundle = void 0;
-const jsonSchemaToZod_js_1 = require("../jsonSchemaToZod.js");
-const generateSchemaBundle = (schema, options = {}) => {
+import { analyzeSchema } from "../core/analyzeSchema.js";
+import { emitZod } from "../core/emitZod.js";
+export const generateSchemaBundle = (schema, options = {}) => {
     const module = options.module ?? "esm";
-    const rootName = options.splitDefs?.rootName ?? options.name ?? "RootSchema";
-    const rootTypeName = typeof options.type === "string"
-        ? options.type
-        : options.splitDefs?.rootTypeName ?? (typeof options.type === "boolean" && options.type ? rootName : undefined);
     if (!schema || typeof schema !== "object") {
         throw new Error("generateSchemaBundle requires an object schema");
     }
-    const defs = schema.$defs || schema.definitions || {};
+    const defs = schema.$defs || {};
+    const definitions = schema.definitions || {};
     const defNames = Object.keys(defs);
-    const defInfoMap = buildDefInfoMap(defNames, defs, options);
-    const cycles = detectCycles(defInfoMap);
-    for (const defName of cycles) {
-        const info = defInfoMap.get(defName);
-        if (info)
-            info.hasCycle = true;
-    }
+    const { rootName, rootTypeName, defInfoMap } = buildBundleContext(defNames, defs, options);
     const files = [];
-    // Generate individual $def files
-    for (const defName of defNames) {
-        const info = defInfoMap.get(defName);
-        const usedRefs = new Set();
-        const defSchemaWithDefs = {
-            ...defs[defName],
-            $defs: defs,
-        };
-        const zodSchema = (0, jsonSchemaToZod_js_1.jsonSchemaToZod)(defSchemaWithDefs, {
+    const targets = planBundleTargets(schema, defs, definitions, defNames, options, rootName, rootTypeName);
+    for (const target of targets) {
+        const usedRefs = target.usedRefs;
+        const analysis = analyzeSchema(target.schemaWithDefs, {
             ...options,
             module,
-            name: info.schemaName,
-            type: info.typeName,
-            parserOverride: createRefHandler(defName, defInfoMap, usedRefs, defs, options),
+            name: target.schemaName,
+            type: target.typeName,
+            parserOverride: createRefHandler(target.defName, defInfoMap, usedRefs, {
+                ...(target.schemaWithDefs.$defs || {}),
+                ...(target.schemaWithDefs.definitions || {}),
+            }, options),
         });
+        const zodSchema = emitZod(analysis);
         const finalSchema = buildSchemaFile(zodSchema, usedRefs, defInfoMap, module);
-        const fileName = options.splitDefs?.fileName?.(defName, { isRoot: false }) ?? `${defName}.schema.ts`;
-        files.push({ fileName, contents: finalSchema });
-    }
-    // Generate root schema if requested
-    if (options.splitDefs?.includeRoot ?? true) {
-        const usedRefs = new Set();
-        const workflowSchemaWithDefs = {
-            ...schema,
-        };
-        const workflowZodSchema = (0, jsonSchemaToZod_js_1.jsonSchemaToZod)(workflowSchemaWithDefs, {
-            ...options,
-            module,
-            name: rootName,
-            type: rootTypeName,
-            parserOverride: createRefHandler(null, defInfoMap, usedRefs, defs, options),
-        });
-        const finalWorkflow = buildSchemaFile(workflowZodSchema, usedRefs, defInfoMap, module);
-        const rootFile = options.splitDefs?.fileName?.("root", { isRoot: true }) ?? "workflow.schema.ts";
-        files.push({ fileName: rootFile, contents: finalWorkflow });
+        files.push({ fileName: target.fileName, contents: finalSchema });
     }
     // Nested types extraction (optional)
     const nestedTypesEnabled = options.nestedTypes?.enable;
@@ -69,7 +39,6 @@ const generateSchemaBundle = (schema, options = {}) => {
     }
     return { files, defNames };
 };
-exports.generateSchemaBundle = generateSchemaBundle;
 // ---------------------------------------------------------------------------
 // Internals
 // ---------------------------------------------------------------------------
@@ -95,6 +64,20 @@ const buildDefInfoMap = (defNames, defs, options) => {
     }
     return map;
 };
+const buildBundleContext = (defNames, defs, options) => {
+    const defInfoMap = buildDefInfoMap(defNames, defs, options);
+    const cycles = detectCycles(defInfoMap);
+    for (const defName of cycles) {
+        const info = defInfoMap.get(defName);
+        if (info)
+            info.hasCycle = true;
+    }
+    const rootName = options.splitDefs?.rootName ?? options.name ?? "RootSchema";
+    const rootTypeName = typeof options.type === "string"
+        ? options.type
+        : options.splitDefs?.rootTypeName ?? (typeof options.type === "boolean" && options.type ? rootName : undefined);
+    return { defInfoMap, rootName, rootTypeName };
+};
 const createRefHandler = (currentDefName, defInfoMap, usedRefs, allDefs, options) => {
     return (schema, refs) => {
         if (typeof schema["$ref"] === "string") {
@@ -102,6 +85,10 @@ const createRefHandler = (currentDefName, defInfoMap, usedRefs, allDefs, options
             const match = refPath.match(/^#\/(?:\$defs|definitions)\/(.+)$/);
             if (match) {
                 const refName = match[1];
+                // Only intercept top-level def refs (no nested path like a/$defs/x)
+                if (refName.includes("/")) {
+                    return undefined;
+                }
                 const refInfo = defInfoMap.get(refName);
                 if (refInfo) {
                     // Track imports when referencing other defs
@@ -118,22 +105,22 @@ const createRefHandler = (currentDefName, defInfoMap, usedRefs, allDefs, options
                     });
                     if (resolved)
                         return resolved;
+                    if (isCycle && options.refResolution?.lazyCrossRefs) {
+                        return `z.lazy(() => ${refInfo.schemaName})`;
+                    }
                     return refInfo.schemaName;
                 }
+                // If the ref points to a local/inline $def (not part of top-level defs),
+                // let the default parser resolve it normally.
+                if (allDefs && Object.prototype.hasOwnProperty.call(allDefs, refName)) {
+                    return undefined;
+                }
             }
             const unknown = options.refResolution?.onUnknownRef?.({ ref: refPath, currentDef: currentDefName });
             if (unknown)
                 return unknown;
             return options.useUnknown ? "z.unknown()" : "z.any()";
         }
-        // Inline $defs within a schema
-        if (schema["$defs"] && typeof schema["$defs"] === "object") {
-            return (0, jsonSchemaToZod_js_1.jsonSchemaToZod)(schema, {
-                ...options,
-                module: options.module ?? "esm",
-                parserOverride: createRefHandler(currentDefName, defInfoMap, usedRefs, allDefs, options),
-            });
-        }
         return undefined;
     };
 };
@@ -151,6 +138,52 @@ const buildSchemaFile = (zodCode, usedRefs, defInfoMap, module) => {
         return zodCode;
     return zodCode.replace('import { z } from "zod"', `import { z } from "zod"\n${imports.join("\n")}`);
 };
+const planBundleTargets = (rootSchema, defs, definitions, defNames, options, rootName, rootTypeName) => {
+    const targets = [];
+    for (const defName of defNames) {
+        const defSchema = defs[defName];
+        const defSchemaWithDefs = {
+            ...defSchema,
+            $defs: { ...defs, ...defSchema?.$defs },
+            definitions: {
+                ...defSchema.definitions,
+                ...definitions,
+            },
+        };
+        const pascalName = toPascalCase(defName);
+        const schemaName = options.splitDefs?.schemaName?.(defName, { isRoot: false }) ?? `${pascalName}Schema`;
+        const typeName = options.splitDefs?.typeName?.(defName, { isRoot: false }) ?? pascalName;
+        const fileName = options.splitDefs?.fileName?.(defName, { isRoot: false }) ?? `${defName}.schema.ts`;
+        targets.push({
+            defName,
+            schemaWithDefs: defSchemaWithDefs,
+            schemaName,
+            typeName,
+            fileName,
+            usedRefs: new Set(),
+            isRoot: false,
+        });
+    }
+    if (options.splitDefs?.includeRoot ?? true) {
+        const rootFile = options.splitDefs?.fileName?.("root", { isRoot: true }) ?? "workflow.schema.ts";
+        targets.push({
+            defName: null,
+            schemaWithDefs: {
+                ...rootSchema,
+                definitions: {
+                    ...rootSchema.definitions,
+                    ...definitions,
+                },
+            },
+            schemaName: rootName,
+            typeName: rootTypeName,
+            fileName: rootFile,
+            usedRefs: new Set(),
+            isRoot: true,
+        });
+    }
+    return targets;
+};
 const findRefDependencies = (schema, validDefNames) => {
     const deps = new Set();
     function traverse(obj) {
@@ -239,7 +272,7 @@ const findNestedTypesInSchema = (schema, parentTypeName, defNames, currentPath =
     if (schema === null || typeof schema !== "object")
         return nestedTypes;
     const record = schema;
-    if (record.title && typeof record.title === "string" && record.type === "object") {
+    if (record.title && typeof record.title === "string") {
         const title = record.title;
         if (title !== parentTypeName && !defNames.map((d) => toPascalCase(d)).includes(title)) {
             nestedTypes.push({
@@ -250,6 +283,12 @@ const findNestedTypesInSchema = (schema, parentTypeName, defNames, currentPath =
             });
         }
     }
+    // inline $defs
+    if (record.$defs && typeof record.$defs === "object") {
+        for (const [_defName, defSchema] of Object.entries(record.$defs)) {
+            nestedTypes.push(...findNestedTypesInSchema(defSchema, parentTypeName, defNames, currentPath));
+        }
+    }
     if (record.properties && typeof record.properties === "object") {
         for (const [propName, propSchema] of Object.entries(record.properties)) {
             nestedTypes.push(...findNestedTypesInSchema(propSchema, parentTypeName, defNames, [...currentPath, propName]));
@@ -261,10 +300,10 @@ const findNestedTypesInSchema = (schema, parentTypeName, defNames, currentPath =
         }
     }
     if (record.items) {
-        nestedTypes.push(...findNestedTypesInSchema(record.items, parentTypeName, defNames, currentPath));
+        nestedTypes.push(...findNestedTypesInSchema(record.items, parentTypeName, defNames, [...currentPath, "items"]));
     }
     if (record.additionalProperties && typeof record.additionalProperties === "object") {
-        nestedTypes.push(...findNestedTypesInSchema(record.additionalProperties, parentTypeName, defNames, currentPath));
+        nestedTypes.push(...findNestedTypesInSchema(record.additionalProperties, parentTypeName, defNames, [...currentPath, "additionalProperties"]));
     }
     return nestedTypes;
 };
@@ -285,12 +324,13 @@ const generateNestedTypesFile = (nestedTypes) => {
         }
         byParent.get(info.parentType).push(info);
     }
-    const imports = new Set();
+    const imports = new Map(); // file -> type name
     for (const info of nestedTypes) {
-        imports.add(info.file);
+        if (!imports.has(info.file)) {
+            imports.set(info.file, info.parentType);
+        }
     }
-    for (const file of [...imports].sort()) {
-        const typeName = file === "workflow" ? "Workflow" : toPascalCase(file);
+    for (const [file, typeName] of [...imports.entries()].sort()) {
         lines.push(`import type { ${typeName} } from './${file}.schema.js';`);
     }
     lines.push("");

package/dist/esm/index.js

@@ -1,46 +1,34 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./Types.js"), exports);
-__exportStar(require("./generators/generateBundle.js"), exports);
-__exportStar(require("./jsonSchemaToZod.js"), exports);
-__exportStar(require("./parsers/parseAllOf.js"), exports);
-__exportStar(require("./parsers/parseAnyOf.js"), exports);
-__exportStar(require("./parsers/parseArray.js"), exports);
-__exportStar(require("./parsers/parseBoolean.js"), exports);
-__exportStar(require("./parsers/parseConst.js"), exports);
-__exportStar(require("./parsers/parseDefault.js"), exports);
-__exportStar(require("./parsers/parseEnum.js"), exports);
-__exportStar(require("./parsers/parseIfThenElse.js"), exports);
-__exportStar(require("./parsers/parseMultipleType.js"), exports);
-__exportStar(require("./parsers/parseNot.js"), exports);
-__exportStar(require("./parsers/parseNull.js"), exports);
-__exportStar(require("./parsers/parseNullable.js"), exports);
-__exportStar(require("./parsers/parseNumber.js"), exports);
-__exportStar(require("./parsers/parseObject.js"), exports);
-__exportStar(require("./parsers/parseOneOf.js"), exports);
-__exportStar(require("./parsers/parseSchema.js"), exports);
-__exportStar(require("./parsers/parseSimpleDiscriminatedOneOf.js"), exports);
-__exportStar(require("./parsers/parseString.js"), exports);
-__exportStar(require("./utils/anyOrUnknown.js"), exports);
-__exportStar(require("./utils/cycles.js"), exports);
-__exportStar(require("./utils/half.js"), exports);
-__exportStar(require("./utils/jsdocs.js"), exports);
-__exportStar(require("./utils/omit.js"), exports);
-__exportStar(require("./utils/withMessage.js"), exports);
-__exportStar(require("./zodToJsonSchema.js"), exports);
-const jsonSchemaToZod_js_1 = require("./jsonSchemaToZod.js");
-exports.default = jsonSchemaToZod_js_1.jsonSchemaToZod;
+export * from "./Types.js";
+export * from "./core/analyzeSchema.js";
+export * from "./core/emitZod.js";
+export * from "./generators/generateBundle.js";
+export * from "./jsonSchemaToZod.js";
+export * from "./parsers/parseAllOf.js";
+export * from "./parsers/parseAnyOf.js";
+export * from "./parsers/parseArray.js";
+export * from "./parsers/parseBoolean.js";
+export * from "./parsers/parseConst.js";
+export * from "./parsers/parseDefault.js";
+export * from "./parsers/parseEnum.js";
+export * from "./parsers/parseIfThenElse.js";
+export * from "./parsers/parseMultipleType.js";
+export * from "./parsers/parseNot.js";
+export * from "./parsers/parseNull.js";
+export * from "./parsers/parseNullable.js";
+export * from "./parsers/parseNumber.js";
+export * from "./parsers/parseObject.js";
+export * from "./parsers/parseOneOf.js";
+export * from "./parsers/parseSchema.js";
+export * from "./parsers/parseSimpleDiscriminatedOneOf.js";
+export * from "./parsers/parseString.js";
+export * from "./utils/anyOrUnknown.js";
+export * from "./utils/buildRefRegistry.js";
+export * from "./utils/cycles.js";
+export * from "./utils/half.js";
+export * from "./utils/jsdocs.js";
+export * from "./utils/omit.js";
+export * from "./utils/resolveUri.js";
+export * from "./utils/withMessage.js";
+export * from "./zodToJsonSchema.js";
+import { jsonSchemaToZod } from "./jsonSchemaToZod.js";
+export default jsonSchemaToZod;

package/dist/esm/jsonSchemaToZod.js

@@ -1,172 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.jsonSchemaToZod = void 0;
-const parseSchema_js_1 = require("./parsers/parseSchema.js");
-const jsdocs_js_1 = require("./utils/jsdocs.js");
-const cycles_js_1 = require("./utils/cycles.js");
-const jsonSchemaToZod = (schema, { module, name, type, noImport, ...rest } = {}) => {
-    if (type && (!name || module !== "esm")) {
-        throw new Error("Option `type` requires `name` to be set and `module` to be `esm`");
-    }
-    const refNameByPointer = new Map();
-    const usedNames = new Set();
-    const exportRefs = rest.exportRefs ?? true;
-    const withMeta = rest.withMeta ?? true;
-    if (name)
-        usedNames.add(name);
-    // Pass 1: collect declarations/dependencies to detect cycles before emitting
-    const pass1 = {
-        module,
-        name,
-        path: [],
-        seen: new Map(),
-        declarations: new Map(),
-        dependencies: new Map(),
-        inProgress: new Set(),
-        refNameByPointer,
-        usedNames,
-        root: schema,
-        currentSchemaName: name,
-        ...rest,
-        withMeta,
-    };
-    (0, parseSchema_js_1.parseSchema)(schema, pass1);
-    const names = Array.from(pass1.declarations.keys());
-    const cycleRefNames = (0, cycles_js_1.detectCycles)(names, pass1.dependencies);
-    const { componentByName } = (0, cycles_js_1.computeScc)(names, pass1.dependencies);
-    // Pass 2: generate with cycle awareness
-    const declarations = new Map();
-    const dependencies = new Map();
-    const parsedSchema = (0, parseSchema_js_1.parseSchema)(schema, {
-        module,
-        name,
-        path: [],
-        seen: new Map(),
-        declarations,
-        dependencies,
-        inProgress: new Set(),
-        refNameByPointer,
-        usedNames,
-        root: schema,
-        currentSchemaName: name,
-        cycleRefNames,
-        cycleComponentByName: componentByName,
-        ...rest,
-        withMeta,
-    });
-    const declarationBlock = declarations.size
-        ? orderDeclarations(Array.from(declarations.entries()), dependencies)
-            .map(([refName, value]) => {
-            const shouldExport = exportRefs && module === "esm";
-            const decl = `${shouldExport ? "export " : ""}const ${refName} = ${value}`;
-            return decl;
-        })
-            .join("\n")
-        : "";
-    const jsdocs = rest.withJsdocs && typeof schema !== "boolean" && schema.description
-        ? (0, jsdocs_js_1.expandJsdocs)(schema.description)
-        : "";
-    const lines = [];
-    if (module === "cjs" && !noImport) {
-        lines.push(`const { z } = require("zod")`);
-    }
-    if (module === "esm" && !noImport) {
-        lines.push(`import { z } from "zod"`);
-    }
-    if (declarationBlock) {
-        lines.push(declarationBlock);
-    }
-    if (module === "cjs") {
-        const payload = name ? `{ ${JSON.stringify(name)}: ${parsedSchema} }` : parsedSchema;
-        lines.push(`${jsdocs}module.exports = ${payload}`);
-    }
-    else if (module === "esm") {
-        lines.push(`${jsdocs}export ${name ? `const ${name} =` : `default`} ${parsedSchema}`);
-    }
-    else if (name) {
-        lines.push(`${jsdocs}const ${name} = ${parsedSchema}`);
-    }
-    else {
-        lines.push(`${jsdocs}${parsedSchema}`);
-    }
-    let typeLine;
-    if (type && name) {
-        let typeName = typeof type === "string"
-            ? type
-            : `${name[0].toUpperCase()}${name.substring(1)}`;
-        typeLine = `export type ${typeName} = z.infer<typeof ${name}>`;
-    }
-    const joined = lines.filter(Boolean).join("\n\n");
-    const combined = typeLine ? `${joined}\n${typeLine}` : joined;
-    const shouldEndWithNewline = module === "esm" || module === "cjs";
-    return `${combined}${shouldEndWithNewline ? "\n" : ""}`;
+import { analyzeSchema } from "./core/analyzeSchema.js";
+import { emitZod } from "./core/emitZod.js";
+export const jsonSchemaToZod = (schema, options = {}) => {
+    const analysis = analyzeSchema(schema, options);
+    return emitZod(analysis);
 };
-exports.jsonSchemaToZod = jsonSchemaToZod;
-function orderDeclarations(entries, dependencies) {
-    const valueByName = new Map(entries);
-    const depGraph = new Map();
-    // Seed with explicit dependencies recorded during parsing
-    for (const [from, set] of dependencies.entries()) {
-        const onlyKnown = new Set();
-        for (const dep of set) {
-            if (valueByName.has(dep) && dep !== from) {
-                onlyKnown.add(dep);
-            }
-        }
-        if (onlyKnown.size)
-            depGraph.set(from, onlyKnown);
-    }
-    // Also infer deps by scanning declaration bodies for referenced names
-    const names = Array.from(valueByName.keys());
-    for (const [name, value] of entries) {
-        const deps = depGraph.get(name) ?? new Set();
-        for (const candidate of names) {
-            if (candidate === name)
-                continue;
-            const matcher = new RegExp(`\\b${candidate}\\b`);
-            if (matcher.test(value)) {
-                deps.add(candidate);
-            }
-        }
-        if (deps.size)
-            depGraph.set(name, deps);
-    }
-    const ordered = [];
-    const perm = new Set();
-    const temp = new Set();
-    const visit = (name) => {
-        if (perm.has(name))
-            return;
-        if (temp.has(name)) {
-            // Cycle detected; break it but still include the node.
-            temp.delete(name);
-            perm.add(name);
-            ordered.push(name);
-            return;
-        }
-        temp.add(name);
-        const deps = depGraph.get(name);
-        if (deps) {
-            for (const dep of deps) {
-                if (valueByName.has(dep)) {
-                    visit(dep);
-                }
-            }
-        }
-        temp.delete(name);
-        perm.add(name);
-        ordered.push(name);
-    };
-    for (const name of valueByName.keys()) {
-        visit(name);
-    }
-    const unique = [];
-    const seen = new Set();
-    for (const name of ordered) {
-        if (!seen.has(name)) {
-            seen.add(name);
-            unique.push(name);
-        }
-    }
-    return unique.map((name) => [name, valueByName.get(name)]);
-}

package/dist/esm/parsers/parseAllOf.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseAllOf = parseAllOf;
-const parseSchema_js_1 = require("./parseSchema.js");
-const half_js_1 = require("../utils/half.js");
+import { parseSchema } from "./parseSchema.js";
+import { half } from "../utils/half.js";
 const originalIndex = Symbol("Original index");
 const ensureOriginalIndex = (arr) => {
     let newArr = [];
@@ -20,19 +17,19 @@ const ensureOriginalIndex = (arr) => {
     }
     return newArr;
 };
-function parseAllOf(schema, refs) {
+export function parseAllOf(schema, refs) {
     if (schema.allOf.length === 0) {
         return "z.never()";
     }
     else if (schema.allOf.length === 1) {
         const item = schema.allOf[0];
-        return (0, parseSchema_js_1.parseSchema)(item, {
+        return parseSchema(item, {
             ...refs,
             path: [...refs.path, "allOf", item[originalIndex]],
         });
     }
     else {
-        const [left, right] = (0, half_js_1.half)(ensureOriginalIndex(schema.allOf));
+        const [left, right] = half(ensureOriginalIndex(schema.allOf));
         return `z.intersection(${parseAllOf({ allOf: left }, refs)}, ${parseAllOf({
             allOf: right,
         }, refs)})`;

package/dist/esm/parsers/parseAnyOf.js

@@ -1,18 +1,14 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseAnyOf = void 0;
-const parseSchema_js_1 = require("./parseSchema.js");
-const anyOrUnknown_js_1 = require("../utils/anyOrUnknown.js");
-const parseAnyOf = (schema, refs) => {
+import { parseSchema } from "./parseSchema.js";
+import { anyOrUnknown } from "../utils/anyOrUnknown.js";
+export const parseAnyOf = (schema, refs) => {
     return schema.anyOf.length
         ? schema.anyOf.length === 1
-            ? (0, parseSchema_js_1.parseSchema)(schema.anyOf[0], {
+            ? parseSchema(schema.anyOf[0], {
                 ...refs,
                 path: [...refs.path, "anyOf", 0],
             })
             : `z.union([${schema.anyOf
-                .map((schema, i) => (0, parseSchema_js_1.parseSchema)(schema, { ...refs, path: [...refs.path, "anyOf", i] }))
+                .map((schema, i) => parseSchema(schema, { ...refs, path: [...refs.path, "anyOf", i] }))
                 .join(", ")}])`
-        : (0, anyOrUnknown_js_1.anyOrUnknown)(refs);
+        : anyOrUnknown(refs);
 };
-exports.parseAnyOf = parseAnyOf;

package/dist/esm/parsers/parseArray.js

@@ -1,14 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseArray = void 0;
-const withMessage_js_1 = require("../utils/withMessage.js");
-const parseSchema_js_1 = require("./parseSchema.js");
-const anyOrUnknown_js_1 = require("../utils/anyOrUnknown.js");
-const parseArray = (schema, refs) => {
+import { withMessage } from "../utils/withMessage.js";
+import { parseSchema } from "./parseSchema.js";
+import { anyOrUnknown } from "../utils/anyOrUnknown.js";
+export const parseArray = (schema, refs) => {
     if (Array.isArray(schema.items)) {
-        let tuple = `z.tuple([${schema.items.map((v, i) => (0, parseSchema_js_1.parseSchema)(v, { ...refs, path: [...refs.path, "items", i] }))}])`;
+        let tuple = `z.tuple([${schema.items.map((v, i) => parseSchema(v, { ...refs, path: [...refs.path, "items", i] }))}])`;
         if (schema.contains) {
-            const containsSchema = (0, parseSchema_js_1.parseSchema)(schema.contains, {
+            const containsSchema = parseSchema(schema.contains, {
                 ...refs,
                 path: [...refs.path, "contains"],
             });
@@ -27,18 +24,18 @@ const parseArray = (schema, refs) => {
         return tuple;
     }
     let r = !schema.items
-        ? `z.array(${(0, anyOrUnknown_js_1.anyOrUnknown)(refs)})`
-        : `z.array(${(0, parseSchema_js_1.parseSchema)(schema.items, {
+        ? `z.array(${anyOrUnknown(refs)})`
+        : `z.array(${parseSchema(schema.items, {
             ...refs,
             path: [...refs.path, "items"],
         })})`;
-    r += (0, withMessage_js_1.withMessage)(schema, "minItems", ({ json }) => ({
+    r += withMessage(schema, "minItems", ({ json }) => ({
         opener: `.min(${json}`,
         closer: ")",
         messagePrefix: ", { error: ",
         messageCloser: " })",
     }));
-    r += (0, withMessage_js_1.withMessage)(schema, "maxItems", ({ json }) => ({
+    r += withMessage(schema, "maxItems", ({ json }) => ({
         opener: `.max(${json}`,
         closer: ")",
         messagePrefix: ", { error: ",
@@ -69,7 +66,7 @@ const parseArray = (schema, refs) => {
 })`;
     }
     if (schema.contains) {
-        const containsSchema = (0, parseSchema_js_1.parseSchema)(schema.contains, {
+        const containsSchema = parseSchema(schema.contains, {
             ...refs,
             path: [...refs.path, "contains"],
         });
@@ -87,4 +84,3 @@ const parseArray = (schema, refs) => {
     }
     return r;
 };
-exports.parseArray = parseArray;

package/dist/esm/parsers/parseBoolean.js

@@ -1,7 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseBoolean = void 0;
-const parseBoolean = (_schema) => {
+export const parseBoolean = (_schema) => {
     return "z.boolean()";
 };
-exports.parseBoolean = parseBoolean;

package/dist/esm/parsers/parseConst.js

@@ -1,7 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseConst = void 0;
-const parseConst = (schema) => {
+export const parseConst = (schema) => {
     return `z.literal(${JSON.stringify(schema.const)})`;
 };
-exports.parseConst = parseConst;