@chnak/zod-to-markdown 1.0.4 → 1.0.6

package/lib/index.js

@@ -1,14 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.zodSchemaToMarkdown = exports.zodSchemaToTable = void 0;
-const zod_1 = require("zod");
+/**
+ * 使用 typeName 检查 Zod 类型，解决跨模块实例化导致的 instanceof 失败问题
+ */
+function isZodType(schema, typeName) {
+    var _a;
+    return ((_a = schema._def) === null || _a === void 0 ? void 0 : _a.typeName) === typeName;
+}
 /**
  * 将 Zod schema 转换为表格形式的 Markdown
  * @param schema - 要转换的 Zod schema
  * @returns 表格形式的 Markdown 字符串
  */
 function zodSchemaToTable(schema) {
-    if (!(schema instanceof zod_1.z.ZodObject)) {
+    if (!isZodType(schema, 'ZodObject')) {
         return zodSchemaToMarkdown(schema);
     }
     // 收集所有嵌套字段
@@ -30,13 +36,13 @@ exports.zodSchemaToTable = zodSchemaToTable;
  */
 function collectFields(schema, prefix, fields, wrapperType) {
     // 处理 Optional - 包装类型
-    if (schema instanceof zod_1.z.ZodOptional) {
+    if (isZodType(schema, 'ZodOptional')) {
         const inner = schema.unwrap();
         // 对于简单类型直接包装
-        if (inner instanceof zod_1.z.ZodObject || inner instanceof zod_1.z.ZodArray) {
+        if (isZodType(inner, 'ZodObject') || isZodType(inner, 'ZodArray')) {
             collectFields(inner, prefix, fields, 'Optional');
         }
-        else if (inner instanceof zod_1.z.ZodUnion || inner instanceof zod_1.z.ZodDiscriminatedUnion || inner instanceof zod_1.z.ZodIntersection) {
+        else if (isZodType(inner, 'ZodUnion') || isZodType(inner, 'ZodDiscriminatedUnion') || isZodType(inner, 'ZodIntersection')) {
             // 嵌套的复杂类型也需要展开
             collectFields(inner, prefix, fields, 'Optional');
         }
@@ -50,12 +56,12 @@ function collectFields(schema, prefix, fields, wrapperType) {
         return;
     }
     // 处理 Nullable - 包装类型
-    if (schema instanceof zod_1.z.ZodNullable) {
+    if (isZodType(schema, 'ZodNullable')) {
         const inner = schema.unwrap();
-        if (inner instanceof zod_1.z.ZodObject || inner instanceof zod_1.z.ZodArray) {
+        if (isZodType(inner, 'ZodObject') || isZodType(inner, 'ZodArray')) {
             collectFields(inner, prefix, fields, 'Nullable');
         }
-        else if (inner instanceof zod_1.z.ZodUnion || inner instanceof zod_1.z.ZodDiscriminatedUnion || inner instanceof zod_1.z.ZodIntersection) {
+        else if (isZodType(inner, 'ZodUnion') || isZodType(inner, 'ZodDiscriminatedUnion') || isZodType(inner, 'ZodIntersection')) {
             // 嵌套的复杂类型也需要展开
             collectFields(inner, prefix, fields, 'Nullable');
         }
@@ -69,15 +75,15 @@ function collectFields(schema, prefix, fields, wrapperType) {
         return;
     }
     // 处理 Default
-    if (schema instanceof zod_1.z.ZodDefault) {
+    if (isZodType(schema, 'ZodDefault')) {
         collectFields(schema.removeDefault(), prefix, fields);
         return;
     }
     // 处理 Array - 收集元素类型
-    if (schema instanceof zod_1.z.ZodArray) {
+    if (isZodType(schema, 'ZodArray')) {
         const element = schema.element;
         // 如果是对象数组，展开其字段
-        if (element instanceof zod_1.z.ZodObject) {
+        if (isZodType(element, 'ZodObject')) {
             const innerFields = [];
             collectFields(element, '', innerFields);
             innerFields.forEach(field => {
@@ -89,16 +95,20 @@ function collectFields(schema, prefix, fields, wrapperType) {
                 });
             });
         }
-        else if (element instanceof zod_1.z.ZodUnion || element instanceof zod_1.z.ZodDiscriminatedUnion) {
+        else if (isZodType(element, 'ZodUnion') || isZodType(element, 'ZodDiscriminatedUnion')) {
             // 数组元素是 Union 类型时，展开每个选项
-            element.options.forEach((opt, index) => {
+            const unionSchema = element;
+            unionSchema.options.forEach((opt, index) => {
                 // 对于 ZodOptional/ZodNullable，保留包装类型信息
-                if (opt instanceof zod_1.z.ZodOptional || opt instanceof zod_1.z.ZodNullable) {
+                if (isZodType(opt, 'ZodOptional') || isZodType(opt, 'ZodNullable')) {
                     const typeStr = getTypeString(opt);
-                    const inner = opt instanceof zod_1.z.ZodOptional ? opt.unwrap() : opt.unwrap();
-                    if (inner instanceof zod_1.z.ZodObject || inner instanceof zod_1.z.ZodIntersection) {
+                    const innerWrapperType = isZodType(opt, 'ZodOptional') ? 'Optional' : 'Nullable';
+                    const inner = isZodType(opt, 'ZodOptional')
+                        ? opt.unwrap()
+                        : opt.unwrap();
+                    if (isZodType(inner, 'ZodObject') || isZodType(inner, 'ZodIntersection')) {
                         const innerFields = [];
-                        collectFields(inner, '', innerFields);
+                        collectFields(inner, '', innerFields, innerWrapperType);
                         innerFields.forEach(field => {
                             fields.push({
                                 path: `${prefix}[].${field.path} (option ${index + 1})`,
@@ -115,7 +125,7 @@ function collectFields(schema, prefix, fields, wrapperType) {
                         });
                     }
                 }
-                else if (opt instanceof zod_1.z.ZodObject || opt instanceof zod_1.z.ZodIntersection) {
+                else if (isZodType(opt, 'ZodObject') || isZodType(opt, 'ZodIntersection')) {
                     // 对象类型或交叉类型，递归展开
                     const innerFields = [];
                     collectFields(opt, '', innerFields);
@@ -137,10 +147,10 @@ function collectFields(schema, prefix, fields, wrapperType) {
                 }
             });
         }
-        else if (element instanceof zod_1.z.ZodOptional) {
+        else if (isZodType(element, 'ZodOptional')) {
             // 数组元素是 Optional 类型时，展开内部类型
             const inner = element.unwrap();
-            if (inner instanceof zod_1.z.ZodObject) {
+            if (isZodType(inner, 'ZodObject')) {
                 const innerFields = [];
                 collectFields(inner, '', innerFields);
                 innerFields.forEach(field => {
@@ -171,7 +181,7 @@ function collectFields(schema, prefix, fields, wrapperType) {
         return;
     }
     // 处理 ZodObject - 递归展开
-    if (schema instanceof zod_1.z.ZodObject) {
+    if (isZodType(schema, 'ZodObject')) {
         const shape = schema.shape;
         Object.keys(shape).forEach(key => {
             const subSchema = shape[key];
@@ -181,15 +191,18 @@ function collectFields(schema, prefix, fields, wrapperType) {
         return;
     }
     // 处理 ZodUnion - 展开每个选项
-    if (schema instanceof zod_1.z.ZodUnion) {
-        schema.options.forEach((opt, index) => {
+    if (isZodType(schema, 'ZodUnion')) {
+        const unionSchema = schema;
+        unionSchema.options.forEach((opt, index) => {
             // 对于 ZodOptional/ZodNullable，保留包装类型信息
-            if (opt instanceof zod_1.z.ZodOptional || opt instanceof zod_1.z.ZodNullable) {
+            if (isZodType(opt, 'ZodOptional') || isZodType(opt, 'ZodNullable')) {
                 const typeStr = getTypeString(opt);
-                const innerWrapperType = opt instanceof zod_1.z.ZodOptional ? 'Optional' : 'Nullable';
-                const inner = opt instanceof zod_1.z.ZodOptional ? opt.unwrap() : opt.unwrap();
+                const innerWrapperType = isZodType(opt, 'ZodOptional') ? 'Optional' : 'Nullable';
+                const inner = isZodType(opt, 'ZodOptional')
+                    ? opt.unwrap()
+                    : opt.unwrap();
                 // 只有内部是对象或交叉类型才展开，否则直接使用类型字符串
-                if (inner instanceof zod_1.z.ZodObject || inner instanceof zod_1.z.ZodIntersection) {
+                if (isZodType(inner, 'ZodObject') || isZodType(inner, 'ZodIntersection')) {
                     const innerFields = [];
                     collectFields(inner, '', innerFields, innerWrapperType);
                     innerFields.forEach(field => {
@@ -208,7 +221,7 @@ function collectFields(schema, prefix, fields, wrapperType) {
                     });
                 }
             }
-            else if (opt instanceof zod_1.z.ZodObject || opt instanceof zod_1.z.ZodIntersection) {
+            else if (isZodType(opt, 'ZodObject') || isZodType(opt, 'ZodIntersection')) {
                 // 对象类型或交叉类型，递归展开
                 const innerFields = [];
                 collectFields(opt, '', innerFields);
@@ -232,14 +245,17 @@ function collectFields(schema, prefix, fields, wrapperType) {
         return;
     }
     // 处理 ZodDiscriminatedUnion - 类似 Union 但有关联键
-    if (schema instanceof zod_1.z.ZodDiscriminatedUnion) {
-        schema.options.forEach((opt, index) => {
+    if (isZodType(schema, 'ZodDiscriminatedUnion')) {
+        const discUnionSchema = schema;
+        discUnionSchema.options.forEach((opt, index) => {
             // 对于 ZodOptional/ZodNullable，保留包装类型信息
-            if (opt instanceof zod_1.z.ZodOptional || opt instanceof zod_1.z.ZodNullable) {
+            if (isZodType(opt, 'ZodOptional') || isZodType(opt, 'ZodNullable')) {
                 const typeStr = getTypeString(opt);
-                const innerWrapperType = opt instanceof zod_1.z.ZodOptional ? 'Optional' : 'Nullable';
-                const inner = opt instanceof zod_1.z.ZodOptional ? opt.unwrap() : opt.unwrap();
-                if (inner instanceof zod_1.z.ZodObject || inner instanceof zod_1.z.ZodIntersection) {
+                const innerWrapperType = isZodType(opt, 'ZodOptional') ? 'Optional' : 'Nullable';
+                const inner = isZodType(opt, 'ZodOptional')
+                    ? opt.unwrap()
+                    : opt.unwrap();
+                if (isZodType(inner, 'ZodObject') || isZodType(inner, 'ZodIntersection')) {
                     const innerFields = [];
                     collectFields(inner, '', innerFields, innerWrapperType);
                     innerFields.forEach(field => {
@@ -258,7 +274,7 @@ function collectFields(schema, prefix, fields, wrapperType) {
                     });
                 }
             }
-            else if (opt instanceof zod_1.z.ZodObject || opt instanceof zod_1.z.ZodIntersection) {
+            else if (isZodType(opt, 'ZodObject') || isZodType(opt, 'ZodIntersection')) {
                 const innerFields = [];
                 collectFields(opt, '', innerFields);
                 innerFields.forEach(field => {
@@ -280,11 +296,12 @@ function collectFields(schema, prefix, fields, wrapperType) {
         return;
     }
     // 处理 ZodIntersection - 展开左右两部分
-    if (schema instanceof zod_1.z.ZodIntersection) {
+    if (isZodType(schema, 'ZodIntersection')) {
+        const intSchema = schema;
         const leftFields = [];
         const rightFields = [];
-        collectFields(schema._def.left, '', leftFields);
-        collectFields(schema._def.right, '', rightFields);
+        collectFields(intSchema._def.left, '', leftFields);
+        collectFields(intSchema._def.right, '', rightFields);
         leftFields.forEach(field => {
             fields.push({
                 path: `${prefix}: ${field.path} (Left)`,
@@ -302,17 +319,19 @@ function collectFields(schema, prefix, fields, wrapperType) {
         return;
     }
     // 处理 Record
-    if (schema instanceof zod_1.z.ZodRecord) {
+    if (isZodType(schema, 'ZodRecord')) {
+        const recordSchema = schema;
         fields.push({
             path: prefix,
-            type: `Record<${getTypeString(schema.keySchema)}, ${getTypeString(schema.valueSchema)}>`,
+            type: `Record<${getTypeString(recordSchema.keySchema)}, ${getTypeString(recordSchema.valueSchema)}>`,
             description: schema.description || '-',
         });
         return;
     }
     // 处理 Tuple
-    if (schema instanceof zod_1.z.ZodTuple) {
-        const items = schema.items.map((item) => getTypeString(item)).join(', ');
+    if (isZodType(schema, 'ZodTuple')) {
+        const tupleSchema = schema;
+        const items = tupleSchema.items.map((item) => getTypeString(item)).join(', ');
         fields.push({
             path: prefix,
             type: `Tuple(${items})`,
@@ -320,6 +339,29 @@ function collectFields(schema, prefix, fields, wrapperType) {
         });
         return;
     }
+    // 处理 ZodEffects (transform)
+    if (isZodType(schema, 'ZodEffects')) {
+        const effectsSchema = schema;
+        const innerFields = [];
+        collectFields(effectsSchema.innerType(), prefix, innerFields);
+        if (innerFields.length > 0) {
+            innerFields.forEach(field => {
+                fields.push({
+                    path: field.path,
+                    type: `Effects(${effectsSchema._def.effect.type})<${field.type}>`,
+                    description: field.description,
+                });
+            });
+        }
+        else {
+            fields.push({
+                path: prefix,
+                type: `Effects(${effectsSchema._def.effect.type})<${getTypeString(effectsSchema.innerType())}>`,
+                description: schema.description || '-',
+            });
+        }
+        return;
+    }
     // 其他类型直接添加
     let typeStr = getTypeString(schema);
     if (wrapperType === 'Optional' && !typeStr.startsWith('Optional<') && !typeStr.startsWith('Nullable<')) {
@@ -338,88 +380,119 @@ function collectFields(schema, prefix, fields, wrapperType) {
  * 获取类型的字符串描述
  */
 function getTypeString(schema) {
-    if (schema instanceof zod_1.z.ZodOptional) {
+    if (isZodType(schema, 'ZodOptional')) {
         return `Optional<${getTypeString(schema.unwrap())}>`;
     }
-    if (schema instanceof zod_1.z.ZodNullable) {
+    if (isZodType(schema, 'ZodNullable')) {
         return `Nullable<${getTypeString(schema.unwrap())}>`;
     }
-    if (schema instanceof zod_1.z.ZodDefault) {
+    if (isZodType(schema, 'ZodDefault')) {
         return `Default<${getTypeString(schema.removeDefault())}>`;
     }
-    if (schema instanceof zod_1.z.ZodArray) {
+    if (isZodType(schema, 'ZodArray')) {
         return `Array<${getTypeString(schema.element)}>`;
     }
-    if (schema instanceof zod_1.z.ZodString) {
+    if (isZodType(schema, 'ZodObject')) {
+        // ZodObject 应该被 collectFields 展开，这里仅作为兜底
+        const keys = Object.keys(schema.shape);
+        return `Object{${keys.join(', ')}}`;
+    }
+    if (isZodType(schema, 'ZodString')) {
+        const strSchema = schema;
         let result = 'String';
-        if (schema.minLength !== null || schema.maxLength !== null) {
+        if (strSchema.minLength !== null || strSchema.maxLength !== null) {
             const constraints = [];
-            if (schema.minLength !== null)
-                constraints.push(`min: ${schema.minLength}`);
-            if (schema.maxLength !== null)
-                constraints.push(`max: ${schema.maxLength}`);
+            if (strSchema.minLength !== null)
+                constraints.push(`min: ${strSchema.minLength}`);
+            if (strSchema.maxLength !== null)
+                constraints.push(`max: ${strSchema.maxLength}`);
             result += ` (${constraints.join(', ')})`;
         }
         return result;
     }
-    if (schema instanceof zod_1.z.ZodNumber) {
+    if (isZodType(schema, 'ZodNumber')) {
+        const numSchema = schema;
         let result = 'Number';
-        if (schema.minValue !== null || schema.maxValue !== null) {
+        if (numSchema.minValue !== null || numSchema.maxValue !== null) {
             const constraints = [];
-            if (schema.minValue !== null)
-                constraints.push(`min: ${schema.minValue}`);
-            if (schema.maxValue !== null)
-                constraints.push(`max: ${schema.maxValue}`);
+            if (numSchema.minValue !== null)
+                constraints.push(`min: ${numSchema.minValue}`);
+            if (numSchema.maxValue !== null)
+                constraints.push(`max: ${numSchema.maxValue}`);
             result += ` (${constraints.join(', ')})`;
         }
         return result;
     }
-    if (schema instanceof zod_1.z.ZodEnum) {
-        return `Enum(${schema.options.join(' | ')})`;
+    if (isZodType(schema, 'ZodEnum')) {
+        return `Enum(${(schema.options).join(' | ')})`;
     }
-    if (schema instanceof zod_1.z.ZodLiteral) {
+    if (isZodType(schema, 'ZodLiteral')) {
         return `Literal(${JSON.stringify(schema.value)})`;
     }
-    if (schema instanceof zod_1.z.ZodBoolean)
+    if (isZodType(schema, 'ZodBoolean'))
         return 'Boolean';
-    if (schema instanceof zod_1.z.ZodBigInt)
+    if (isZodType(schema, 'ZodBigInt'))
         return 'BigInt';
-    if (schema instanceof zod_1.z.ZodDate)
+    if (isZodType(schema, 'ZodDate'))
         return 'Date';
-    if (schema instanceof zod_1.z.ZodNaN)
+    if (isZodType(schema, 'ZodNaN'))
         return 'NaN';
-    if (schema instanceof zod_1.z.ZodNever)
+    if (isZodType(schema, 'ZodNever'))
         return 'Never';
-    if (schema instanceof zod_1.z.ZodUnknown)
+    if (isZodType(schema, 'ZodUnknown'))
         return 'Unknown';
-    if (schema instanceof zod_1.z.ZodVoid)
+    if (isZodType(schema, 'ZodVoid'))
         return 'Void';
-    if (schema instanceof zod_1.z.ZodRecord) {
-        return `Record<${getTypeString(schema.keySchema)}, ${getTypeString(schema.valueSchema)}>`;
+    if (isZodType(schema, 'ZodRecord')) {
+        const recSchema = schema;
+        return `Record<${getTypeString(recSchema.keySchema)}, ${getTypeString(recSchema.valueSchema)}>`;
     }
-    if (schema instanceof zod_1.z.ZodTuple) {
-        const items = schema.items.map((item) => getTypeString(item)).join(', ');
+    if (isZodType(schema, 'ZodTuple')) {
+        const tupSchema = schema;
+        const items = tupSchema.items.map((item) => getTypeString(item)).join(', ');
         return `Tuple(${items})`;
     }
-    if (schema instanceof zod_1.z.ZodUnion) {
-        const options = schema.options.map((opt) => getTypeString(opt)).join(' | ');
+    if (isZodType(schema, 'ZodUnion')) {
+        const unionSchema = schema;
+        const options = unionSchema.options.map((opt) => getTypeString(opt)).join(' | ');
         return `Union(${options})`;
     }
-    if (schema instanceof zod_1.z.ZodDiscriminatedUnion) {
+    if (isZodType(schema, 'ZodDiscriminatedUnion')) {
         return `DiscriminatedUnion(${schema.discriminator})`;
     }
-    if (schema instanceof zod_1.z.ZodIntersection) {
+    if (isZodType(schema, 'ZodIntersection')) {
         return 'Intersection';
     }
-    if (schema instanceof zod_1.z.ZodEffects) {
+    if (isZodType(schema, 'ZodEffects')) {
         return `Effects(${schema._def.effect.type})`;
     }
-    return schema.constructor.name;
+    if (isZodType(schema, 'ZodMap')) {
+        const mapSchema = schema;
+        return `Map<${getTypeString(mapSchema.keySchema)}, ${getTypeString(mapSchema.valueSchema)}>`;
+    }
+    if (isZodType(schema, 'ZodSet')) {
+        return `Set<${getTypeString(schema._def.valueType)}>`;
+    }
+    if (isZodType(schema, 'ZodAny'))
+        return 'Any';
+    if (isZodType(schema, 'ZodLazy')) {
+        return `Lazy(${schema._def.getter().constructor.name || 'unknown'})`;
+    }
+    if (isZodType(schema, 'ZodFunction')) {
+        const fnSchema = schema;
+        const args = fnSchema._def.args ? getTypeString(fnSchema._def.args) : 'args';
+        const returns = fnSchema._def.returns ? getTypeString(fnSchema._def.returns) : 'returns';
+        return `Function(${args} => ${returns})`;
+    }
+    if (isZodType(schema, 'ZodPromise')) {
+        return `Promise<${getTypeString(schema._def.type)}>`;
+    }
+    return schema._def.typeName || schema.constructor.name;
 }
 function zodSchemaToMarkdown(schema, indentLevel = 0) {
     let markdown = "";
     const indent = "  ".repeat(indentLevel);
-    if (schema instanceof zod_1.z.ZodObject) {
+    if (isZodType(schema, 'ZodObject')) {
         const shape = schema.shape;
         Object.keys(shape).forEach((key) => {
             const subSchema = shape[key];
@@ -428,11 +501,11 @@ function zodSchemaToMarkdown(schema, indentLevel = 0) {
             markdown += zodSchemaToMarkdown(subSchema, indentLevel + 1);
         });
     }
-    else if (schema instanceof zod_1.z.ZodArray) {
+    else if (isZodType(schema, 'ZodArray')) {
         markdown += `${indent}- Array\n`;
         markdown += zodSchemaToMarkdown(schema.element, indentLevel + 1);
     }
-    else if (schema instanceof zod_1.z.ZodString) {
+    else if (isZodType(schema, 'ZodString')) {
         markdown += `${indent}- String`;
         if (schema.minLength !== null) {
             markdown += ` (minLength: ${schema.minLength})`;
@@ -442,7 +515,7 @@ function zodSchemaToMarkdown(schema, indentLevel = 0) {
         }
         markdown += "\n";
     }
-    else if (schema instanceof zod_1.z.ZodNumber) {
+    else if (isZodType(schema, 'ZodNumber')) {
         markdown += `${indent}- Number`;
         if (schema.minValue !== null) {
             markdown += ` (minValue: ${schema.minValue})`;
@@ -452,93 +525,99 @@ function zodSchemaToMarkdown(schema, indentLevel = 0) {
         }
         markdown += "\n";
     }
-    else if (schema instanceof zod_1.z.ZodEnum) {
+    else if (isZodType(schema, 'ZodEnum')) {
         const values = schema.options.join(", ");
         markdown += `${indent}- Enum: ${values}\n`;
     }
-    else if (schema instanceof zod_1.z.ZodUnion) {
+    else if (isZodType(schema, 'ZodUnion')) {
+        const unionSchema = schema;
         markdown += `${indent}- Union\n`;
-        schema.options.forEach((option, index) => {
+        unionSchema.options.forEach((option, index) => {
             markdown += zodSchemaToMarkdown(option, indentLevel + 1);
-            if (index < schema.options.length - 1) {
+            if (index < unionSchema.options.length - 1) {
                 markdown += `${indent}  |\n`;
             }
         });
     }
-    else if (schema instanceof zod_1.z.ZodBoolean) {
+    else if (isZodType(schema, 'ZodBoolean')) {
         markdown += `${indent}- Boolean\n`;
     }
-    else if (schema instanceof zod_1.z.ZodDefault) {
-        markdown += `${indent}- Default: ${JSON.stringify(schema._def.defaultValue())}\n`;
-        markdown += zodSchemaToMarkdown(schema.removeDefault(), indentLevel);
+    else if (isZodType(schema, 'ZodDefault')) {
+        const defSchema = schema;
+        markdown += `${indent}- Default: ${JSON.stringify(defSchema._def.defaultValue())}\n`;
+        markdown += zodSchemaToMarkdown(defSchema.removeDefault(), indentLevel);
     }
-    else if (schema instanceof zod_1.z.ZodOptional) {
+    else if (isZodType(schema, 'ZodOptional')) {
         markdown += `${indent}- Optional\n`;
         markdown += zodSchemaToMarkdown(schema.unwrap(), indentLevel + 1);
     }
-    else if (schema instanceof zod_1.z.ZodNullable) {
+    else if (isZodType(schema, 'ZodNullable')) {
         markdown += `${indent}- Nullable\n`;
         markdown += zodSchemaToMarkdown(schema.unwrap(), indentLevel + 1);
     }
-    else if (schema instanceof zod_1.z.ZodEffects) {
+    else if (isZodType(schema, 'ZodEffects')) {
         const effectType = schema._def.effect.type;
         markdown += `${indent}- Effects (${effectType})\n`;
         markdown += zodSchemaToMarkdown(schema.innerType(), indentLevel + 1);
     }
-    else if (schema instanceof zod_1.z.ZodDiscriminatedUnion) {
-        const discriminator = schema.discriminator;
+    else if (isZodType(schema, 'ZodDiscriminatedUnion')) {
+        const discUnionSchema = schema;
+        const discriminator = discUnionSchema.discriminator;
         markdown += `${indent}- DiscriminatedUnion (key: ${discriminator})\n`;
-        schema.options.forEach((option, index) => {
+        discUnionSchema.options.forEach((option, index) => {
             markdown += zodSchemaToMarkdown(option, indentLevel + 1);
-            if (index < schema.options.length - 1) {
+            if (index < discUnionSchema.options.length - 1) {
                 markdown += `${indent}  |\n`;
             }
         });
     }
-    else if (schema instanceof zod_1.z.ZodIntersection) {
+    else if (isZodType(schema, 'ZodIntersection')) {
+        const intSchema = schema;
         markdown += `${indent}- Intersection\n`;
         markdown += `${indent}  Left:\n`;
-        markdown += zodSchemaToMarkdown(schema._def.left, indentLevel + 2);
+        markdown += zodSchemaToMarkdown(intSchema._def.left, indentLevel + 2);
         markdown += `${indent}  Right:\n`;
-        markdown += zodSchemaToMarkdown(schema._def.right, indentLevel + 2);
+        markdown += zodSchemaToMarkdown(intSchema._def.right, indentLevel + 2);
     }
-    else if (schema instanceof zod_1.z.ZodRecord) {
+    else if (isZodType(schema, 'ZodRecord')) {
+        const recSchema = schema;
         markdown += `${indent}- Record\n`;
         markdown += `${indent}  Key:\n`;
-        markdown += zodSchemaToMarkdown(schema.keySchema, indentLevel + 2);
+        markdown += zodSchemaToMarkdown(recSchema.keySchema, indentLevel + 2);
         markdown += `${indent}  Value:\n`;
-        markdown += zodSchemaToMarkdown(schema.valueSchema, indentLevel + 2);
+        markdown += zodSchemaToMarkdown(recSchema.valueSchema, indentLevel + 2);
     }
-    else if (schema instanceof zod_1.z.ZodTuple) {
+    else if (isZodType(schema, 'ZodTuple')) {
+        const tupSchema = schema;
         markdown += `${indent}- Tuple\n`;
-        schema.items.forEach((item, index) => {
+        tupSchema.items.forEach((item, index) => {
             markdown += `${indent}  [${index}]:\n`;
             markdown += zodSchemaToMarkdown(item, indentLevel + 2);
         });
     }
-    else if (schema instanceof zod_1.z.ZodLiteral) {
+    else if (isZodType(schema, 'ZodLiteral')) {
         markdown += `${indent}- Literal: ${JSON.stringify(schema.value)}\n`;
     }
-    else if (schema instanceof zod_1.z.ZodBigInt) {
+    else if (isZodType(schema, 'ZodBigInt')) {
         markdown += `${indent}- BigInt\n`;
     }
-    else if (schema instanceof zod_1.z.ZodDate) {
+    else if (isZodType(schema, 'ZodDate')) {
         markdown += `${indent}- Date\n`;
     }
-    else if (schema instanceof zod_1.z.ZodNaN) {
+    else if (isZodType(schema, 'ZodNaN')) {
         markdown += `${indent}- NaN\n`;
     }
-    else if (schema instanceof zod_1.z.ZodNever) {
+    else if (isZodType(schema, 'ZodNever')) {
         markdown += `${indent}- Never\n`;
     }
-    else if (schema instanceof zod_1.z.ZodUnknown) {
+    else if (isZodType(schema, 'ZodUnknown')) {
         markdown += `${indent}- Unknown\n`;
     }
-    else if (schema instanceof zod_1.z.ZodVoid) {
+    else if (isZodType(schema, 'ZodVoid')) {
         markdown += `${indent}- Void\n`;
     }
     else {
-        markdown += `${indent}- Type: ${schema.constructor.name}\n`;
+        markdown += `${indent}- Type: ${schema._def.typeName || schema.constructor.name}\n`;
     }
     return markdown;
 }

package/lib/index.test.js

@@ -309,6 +309,66 @@ describe('zodSchemaToTable', () => {
 |------|------|------|
 | items[].a (option 1) | String | - |
 | items[].b (option 2) | Number | - |
+`;
+        expect((0, index_1.zodSchemaToTable)(schema)).toBe(expected);
+    });
+    it('should convert object schema with ZodMap to table', () => {
+        const schema = zod_1.z.object({
+            map: zod_1.z.map(zod_1.z.string(), zod_1.z.number()),
+        });
+        const expected = `| 字段 | 类型 | 描述 |
+|------|------|------|
+| map | Map<String, Number> | - |
+`;
+        expect((0, index_1.zodSchemaToTable)(schema)).toBe(expected);
+    });
+    it('should convert object schema with ZodSet to table', () => {
+        const schema = zod_1.z.object({
+            set: zod_1.z.set(zod_1.z.string()),
+        });
+        const expected = `| 字段 | 类型 | 描述 |
+|------|------|------|
+| set | Set<String> | - |
+`;
+        expect((0, index_1.zodSchemaToTable)(schema)).toBe(expected);
+    });
+    it('should convert object schema with ZodAny to table', () => {
+        const schema = zod_1.z.object({
+            any: zod_1.z.any(),
+        });
+        const expected = `| 字段 | 类型 | 描述 |
+|------|------|------|
+| any | Any | - |
+`;
+        expect((0, index_1.zodSchemaToTable)(schema)).toBe(expected);
+    });
+    it('should convert object schema with ZodLazy to table', () => {
+        const schema = zod_1.z.object({
+            lazy: zod_1.z.lazy(() => zod_1.z.string()),
+        });
+        const expected = `| 字段 | 类型 | 描述 |
+|------|------|------|
+| lazy | Lazy(ZodString) | - |
+`;
+        expect((0, index_1.zodSchemaToTable)(schema)).toBe(expected);
+    });
+    it('should convert object schema with ZodFunction to table', () => {
+        const schema = zod_1.z.object({
+            fn: zod_1.z.function().args(zod_1.z.string()).returns(zod_1.z.number()),
+        });
+        const expected = `| 字段 | 类型 | 描述 |
+|------|------|------|
+| fn | Function(Tuple(String) => Number) | - |
+`;
+        expect((0, index_1.zodSchemaToTable)(schema)).toBe(expected);
+    });
+    it('should convert object schema with ZodPromise to table', () => {
+        const schema = zod_1.z.object({
+            promise: zod_1.z.promise(zod_1.z.string()),
+        });
+        const expected = `| 字段 | 类型 | 描述 |
+|------|------|------|
+| promise | Promise<String> | - |
 `;
         expect((0, index_1.zodSchemaToTable)(schema)).toBe(expected);
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chnak/zod-to-markdown",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "A utility function to convert Zod schemas to Markdown documentation",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",