@chnak/zod-to-markdown 1.0.1

package/README.md

@@ -0,0 +1,177 @@
+# zod-to-markdown
+
+将 Zod schema 转换为 Markdown 文档的工具函数。
+
+## 安装
+
+```bash
+npm install @chnak/zod-to-markdown
+```
+
+## 使用方法
+
+### ESM / TypeScript
+
+```typescript
+import { zodSchemaToMarkdown } from '@chnak/zod-to-markdown';
+import { z } from 'zod';
+
+const schema = z.object({
+  name: z.string(),
+  age: z.number(),
+});
+
+const markdown = zodSchemaToMarkdown(schema);
+console.log(markdown);
+```
+
+### CommonJS / Node.js
+
+```javascript
+const { zodSchemaToMarkdown } = require('@chnak/zod-to-markdown');
+const { z } = require('zod');
+
+const schema = z.object({
+  name: z.string(),
+  age: z.number(),
+});
+
+const markdown = zodSchemaToMarkdown(schema);
+console.log(markdown);
+```
+
+### 输出结果
+
+```markdown
+- name
+  - String
+- age
+  - Number
+```
+
+## 支持的 Zod 类型
+
+### 基础类型
+- `ZodObject` - 对象 schema，包含嵌套属性
+- `ZodArray` - 数组 schema，包含元素类型
+- `ZodString` - 字符串，可选 minLength/maxLength
+- `ZodNumber` - 数字，可选 minValue/maxValue
+- `ZodBoolean` - 布尔类型
+- `ZodEnum` - 枚举值
+- `ZodBigInt` - BigInt 类型
+- `ZodDate` - Date 类型
+
+### 工具类型
+- `ZodOptional` - 可选属性
+- `ZodNullable` - 可为空属性
+- `ZodDefault` - 默认值
+- `ZodEffects` - transform/coerce 效果
+
+### 高级类型
+- `ZodUnion` - 联合类型
+- `ZodDiscriminatedUnion` - 带鉴别键的联合类型
+- `ZodIntersection` - 交叉类型
+- `ZodRecord` - Record（字典）类型
+- `ZodTuple` - 元组类型
+
+### 特殊类型
+- `ZodLiteral` - 字面量值（如 `"hello"`, `1`, `true`）
+- `ZodNaN` - NaN 类型
+- `ZodNever` - Never 类型
+- `ZodUnknown` - Unknown 类型
+- `ZodVoid` - Void 类型
+
+## 示例
+
+### 复杂 Schema
+
+```typescript
+import { z } from 'zod';
+
+const userSchema = z.object({
+  id: z.string().uuid(),
+  name: z.string(),
+  email: z.string().email(),
+  age: z.number().optional(),
+  role: z.enum(['admin', 'user', 'guest']),
+  metadata: z.record(z.string(), z.unknown()).optional(),
+});
+
+console.log(zodSchemaToMarkdown(userSchema));
+```
+
+输出：
+```markdown
+- id
+  - String
+- name
+  - String
+- email
+  - String
+- age
+  - Optional
+    - Number
+- role
+  - Enum: admin, user, guest
+- metadata
+  - Optional
+    - Record
+      Key:
+        - String
+      Value:
+        - Unknown
+```
+
+### 鉴别联合类型 (Discriminated Union)
+
+```typescript
+const messageSchema = z.discriminatedUnion('role', [
+  z.object({ role: z.literal('user'), content: z.string() }),
+  z.object({ role: z.literal('assistant'), content: z.string() }),
+]);
+
+console.log(zodSchemaToMarkdown(messageSchema));
+```
+
+输出：
+```markdown
+- DiscriminatedUnion (key: role)
+  - role
+    - Literal: "user"
+  - content
+    - String
+  |
+  - role
+    - Literal: "assistant"
+  - content
+    - String
+```
+
+### Transform 效果
+
+```typescript
+const transformedSchema = z.string().transform(val => val.length);
+
+console.log(zodSchemaToMarkdown(transformedSchema));
+```
+
+输出：
+```markdown
+- Effects (transform)
+  - String
+```
+
+## API
+
+### `zodSchemaToMarkdown(schema, indentLevel?)`
+
+| 参数 | 类型 | 说明 |
+|------|------|------|
+| `schema` | `z.ZodTypeAny` | 要转换的 Zod schema |
+| `indentLevel` | `number` | 初始缩进级别（默认: `0`） |
+
+返回转换后的 Markdown 字符串。
+
+## License
+
+MIT License

package/examples/complex-types.md

@@ -0,0 +1,152 @@
+# Zod to Markdown - Complex Types Examples
+
+This document demonstrates the `zodSchemaToMarkdown` function's support for complex Zod types used in OpenAI API schemas.
+
+## ZodEffects (Transform)
+
+```typescript
+const schema = z.string().transform(val => val.length);
+```
+
+Output:
+```markdown
+- Effects (transform)
+  - String
+```
+
+## ZodDiscriminatedUnion
+
+```typescript
+const schema = z.discriminatedUnion('type', [
+  z.object({ type: z.literal('a'), a: z.string() }),
+  z.object({ type: z.literal('b'), b: z.number() })
+]);
+```
+
+Output:
+```markdown
+- DiscriminatedUnion (key: type)
+  - type
+    - Literal: "a"
+  - a
+    - String
+  |
+  - type
+    - Literal: "b"
+  - b
+    - Number
+```
+
+## ZodIntersection
+
+```typescript
+const schema = z.object({ a: z.string() }).and(z.object({ b: z.number() }));
+```
+
+Output:
+```markdown
+- Intersection
+  Left:
+    - a
+      - String
+  Right:
+    - b
+      - Number
+```
+
+## ZodRecord
+
+```typescript
+const schema = z.record(z.string(), z.number());
+```
+
+Output:
+```markdown
+- Record
+  Key:
+    - String
+  Value:
+    - Number
+```
+
+## ZodTuple
+
+```typescript
+const schema = z.tuple([z.string(), z.number()]);
+```
+
+Output:
+```markdown
+- Tuple
+  [0]:
+    - String
+  [1]:
+    - Number
+```
+
+## ZodLiteral
+
+```typescript
+const schema = z.literal('hello');
+```
+
+Output:
+```markdown
+- Literal: "hello"
+```
+
+## Primitive Types
+
+### ZodBigInt
+```typescript
+z.bigint()
+```
+Output:
+```markdown
+- BigInt
+```
+
+### ZodDate
+```typescript
+z.date()
+```
+Output:
+```markdown
+- Date
+```
+
+### ZodNaN
+```typescript
+z.nan()
+```
+Output:
+```markdown
+- NaN
+```
+
+### ZodNever
+```typescript
+z.never()
+```
+Output:
+```markdown
+- Never
+```
+
+### ZodUnknown
+```typescript
+z.unknown()
+```
+Output:
+```markdown
+- Unknown
+```
+
+### ZodVoid
+```typescript
+z.void()
+```
+Output:
+```markdown
+- Void
+```

package/examples/openai-chat-completion.md

@@ -0,0 +1,191 @@
+# OpenAI Chat Completion Schema
+
+完整的 OpenAI API Schema 转换为 Markdown 文档的示例。
+
+## TypeScript 定义
+
+```typescript
+const messageSchema = z.discriminatedUnion('role', [
+  z.object({
+    role: z.literal('system'),
+    content: z.string(),
+    name: z.string().optional(),
+  }),
+  z.object({
+    role: z.literal('user'),
+    content: z.union([z.string(), z.array(z.object({
+      type: z.literal('text'),
+      text: z.string(),
+    }))]),
+    name: z.string().optional(),
+  }),
+  z.object({
+    role: z.literal('assistant'),
+    content: z.string().nullable(),
+    tool_calls: z.array(z.object({
+      id: z.string(),
+      type: z.literal('function'),
+      function: z.object({
+        name: z.string(),
+        arguments: z.string(),
+      }),
+    })).optional(),
+    name: z.string().optional(),
+  }),
+  z.object({
+    role: z.literal('tool'),
+    content: z.union([z.string(), z.object({
+      type: z.literal('image_url'),
+      image_url: z.object({
+        url: z.string(),
+        detail: z.enum(['low', 'high', 'auto']).optional(),
+      }),
+    })]),
+    tool_call_id: z.string(),
+    name: z.string().optional(),
+  }),
+]);
+
+const chatCompletionRequestSchema = z.object({
+  model: z.string(),
+  messages: z.array(messageSchema),
+  temperature: z.number().min(0).max(2).optional(),
+  top_p: z.number().min(0).max(1).optional(),
+  n: z.number().int().min(1).optional(),
+  stream: z.boolean().optional(),
+  stop: z.union([z.string(), z.array(z.string())]).optional(),
+  max_tokens: z.number().int().optional(),
+  presence_penalty: z.number().min(-2).max(2).optional(),
+  frequency_penalty: z.number().min(-2).max(2).optional(),
+  logit_bias: z.record(z.string(), z.number()).optional(),
+  user: z.string().optional(),
+});
+```
+
+## 生成的 Markdown 文档
+
+```markdown
+- model
+  - String
+- messages
+  - Array
+    - DiscriminatedUnion (key: role)
+      - role
+        - Literal: "system"
+      - content
+        - String
+      - name
+        - Optional
+          - String
+      |
+      - role
+        - Literal: "user"
+      - content
+        - Union
+          - String
+          |
+          - Array
+            - type
+              - Literal: "text"
+            - text
+              - String
+      - name
+        - Optional
+          - String
+      |
+      - role
+        - Literal: "assistant"
+      - content
+        - Nullable
+          - String
+      - tool_calls
+        - Optional
+          - Array
+            - id
+              - String
+            - type
+              - Literal: "function"
+            - function
+              - name
+                - String
+              - arguments
+                - String
+      - name
+        - Optional
+          - String
+      |
+      - role
+        - Literal: "tool"
+      - content
+        - Union
+          - String
+          |
+          - type
+            - Literal: "image_url"
+          - image_url
+            - url
+              - String
+            - detail
+              - Optional
+                - Enum: low, high, auto
+      - tool_call_id
+        - String
+      - name
+        - Optional
+          - String
+- temperature
+  - Optional
+    - Number (minValue: 0) (maxValue: 2)
+- top_p
+  - Optional
+    - Number (minValue: 0) (maxValue: 1)
+- n
+  - Optional
+    - Number (minValue: 1)
+- stream
+  - Optional
+    - Boolean
+- stop
+  - Optional
+    - Union
+      - String
+      |
+      - Array
+        - String
+- max_tokens
+  - Optional
+    - Number
+- presence_penalty
+  - Optional
+    - Number (minValue: -2) (maxValue: 2)
+- frequency_penalty
+  - Optional
+    - Number (minValue: -2) (maxValue: 2)
+- logit_bias
+  - Optional
+    - Record
+      Key:
+        - String
+      Value:
+        - Number
+- user
+  - Optional
+    - String
+```
+
+## 使用的类型覆盖
+
+| 类型 | 出现位置 |
+|------|----------|
+| `ZodDiscriminatedUnion` | `messages` 数组元素，role 鉴别键 |
+| `ZodObject` | 顶层 schema 和各 message 类型 |
+| `ZodArray` | `messages`, `tool_calls`, `stop` |
+| `ZodOptional` | `name`, `tool_calls`, `detail` 等 |
+| `ZodNullable` | `content` (assistant) |
+| `ZodUnion` | `content`, `stop` |
+| `ZodLiteral` | `role` 值，`type` 值 |
+| `ZodEnum` | `detail` 枚举 |
+| `ZodRecord` | `logit_bias` |
+| `ZodString` | 各种字符串字段 |
+| `ZodNumber` | 各种数字字段，带 min/max 约束 |
+| `ZodBoolean` | `stream` |

package/examples/openai-chat-schema.ts

@@ -0,0 +1,64 @@
+import { z } from 'zod';
+import { zodSchemaToMarkdown } from '../src/index';
+
+// OpenAI Chat Message Schema Example
+const messageSchema = z.discriminatedUnion('role', [
+  z.object({
+    role: z.literal('system'),
+    content: z.string(),
+    name: z.string().optional(),
+  }),
+  z.object({
+    role: z.literal('user'),
+    content: z.union([z.string(), z.array(z.object({
+      type: z.literal('text'),
+      text: z.string(),
+    }))]),
+    name: z.string().optional(),
+  }),
+  z.object({
+    role: z.literal('assistant'),
+    content: z.string().nullable(),
+    tool_calls: z.array(z.object({
+      id: z.string(),
+      type: z.literal('function'),
+      function: z.object({
+        name: z.string(),
+        arguments: z.string(),
+      }),
+    })).optional(),
+    name: z.string().optional(),
+  }),
+  z.object({
+    role: z.literal('tool'),
+    content: z.union([z.string(), z.object({
+      type: z.literal('image_url'),
+      image_url: z.object({
+        url: z.string(),
+        detail: z.enum(['low', 'high', 'auto']).optional(),
+      }),
+    })]),
+    tool_call_id: z.string(),
+    name: z.string().optional(),
+  }),
+]);
+
+const chatCompletionRequestSchema = z.object({
+  model: z.string(),
+  messages: z.array(messageSchema),
+  temperature: z.number().min(0).max(2).optional(),
+  top_p: z.number().min(0).max(1).optional(),
+  n: z.number().int().min(1).optional(),
+  stream: z.boolean().optional(),
+  stop: z.union([z.string(), z.array(z.string())]).optional(),
+  max_tokens: z.number().int().optional(),
+  presence_penalty: z.number().min(-2).max(2).optional(),
+  frequency_penalty: z.number().min(-2).max(2).optional(),
+  logit_bias: z.record(z.string(), z.number()).optional(),
+  user: z.string().optional(),
+});
+
+const schema = chatCompletionRequestSchema;
+const markdown = zodSchemaToMarkdown(schema);
+
+console.log(markdown);

package/jest.config.js

@@ -0,0 +1,5 @@
+module.exports = {
+    preset: 'ts-jest',
+    testEnvironment: 'node',
+    testPathIgnorePatterns: ['/node_modules/', '/lib/'],
+  };

package/lib/index.d.ts

@@ -0,0 +1,2 @@
+import { z } from "zod";
+export declare function zodSchemaToMarkdown(schema: z.ZodTypeAny, indentLevel?: number): string;

package/lib/index.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zodSchemaToMarkdown = void 0;
+const zod_1 = require("zod");
+function zodSchemaToMarkdown(schema, indentLevel = 0) {
+    let markdown = "";
+    const indent = "  ".repeat(indentLevel);
+    if (schema instanceof zod_1.z.ZodObject) {
+        const shape = schema.shape;
+        Object.keys(shape).forEach((key) => {
+            const subSchema = shape[key];
+            const description = subSchema.description ? `: ${subSchema.description}` : "";
+            markdown += `${indent}- ${key}${description}\n`;
+            markdown += zodSchemaToMarkdown(subSchema, indentLevel + 1);
+        });
+    }
+    else if (schema instanceof zod_1.z.ZodArray) {
+        markdown += `${indent}- Array\n`;
+        markdown += zodSchemaToMarkdown(schema.element, indentLevel + 1);
+    }
+    else if (schema instanceof zod_1.z.ZodString) {
+        markdown += `${indent}- String`;
+        if (schema.minLength !== null) {
+            markdown += ` (minLength: ${schema.minLength})`;
+        }
+        if (schema.maxLength !== null) {
+            markdown += ` (maxLength: ${schema.maxLength})`;
+        }
+        markdown += "\n";
+    }
+    else if (schema instanceof zod_1.z.ZodNumber) {
+        markdown += `${indent}- Number`;
+        if (schema.minValue !== null) {
+            markdown += ` (minValue: ${schema.minValue})`;
+        }
+        if (schema.maxValue !== null) {
+            markdown += ` (maxValue: ${schema.maxValue})`;
+        }
+        markdown += "\n";
+    }
+    else if (schema instanceof zod_1.z.ZodEnum) {
+        const values = schema.options.join(", ");
+        markdown += `${indent}- Enum: ${values}\n`;
+    }
+    else if (schema instanceof zod_1.z.ZodUnion) {
+        markdown += `${indent}- Union\n`;
+        schema.options.forEach((option, index) => {
+            markdown += zodSchemaToMarkdown(option, indentLevel + 1);
+            if (index < schema.options.length - 1) {
+                markdown += `${indent}  |\n`;
+            }
+        });
+    }
+    else if (schema instanceof zod_1.z.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 (schema instanceof zod_1.z.ZodOptional) {
+        markdown += `${indent}- Optional\n`;
+        markdown += zodSchemaToMarkdown(schema.unwrap(), indentLevel + 1);
+    }
+    else if (schema instanceof zod_1.z.ZodNullable) {
+        markdown += `${indent}- Nullable\n`;
+        markdown += zodSchemaToMarkdown(schema.unwrap(), indentLevel + 1);
+    }
+    else if (schema instanceof zod_1.z.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;
+        markdown += `${indent}- DiscriminatedUnion (key: ${discriminator})\n`;
+        schema.options.forEach((option, index) => {
+            markdown += zodSchemaToMarkdown(option, indentLevel + 1);
+            if (index < schema.options.length - 1) {
+                markdown += `${indent}  |\n`;
+            }
+        });
+    }
+    else if (schema instanceof zod_1.z.ZodIntersection) {
+        markdown += `${indent}- Intersection\n`;
+        markdown += `${indent}  Left:\n`;
+        markdown += zodSchemaToMarkdown(schema._def.left, indentLevel + 2);
+        markdown += `${indent}  Right:\n`;
+        markdown += zodSchemaToMarkdown(schema._def.right, indentLevel + 2);
+    }
+    else if (schema instanceof zod_1.z.ZodRecord) {
+        markdown += `${indent}- Record\n`;
+        markdown += `${indent}  Key:\n`;
+        markdown += zodSchemaToMarkdown(schema.keySchema, indentLevel + 2);
+        markdown += `${indent}  Value:\n`;
+        markdown += zodSchemaToMarkdown(schema.valueSchema, indentLevel + 2);
+    }
+    else if (schema instanceof zod_1.z.ZodTuple) {
+        markdown += `${indent}- Tuple\n`;
+        schema.items.forEach((item, index) => {
+            markdown += `${indent}  [${index}]:\n`;
+            markdown += zodSchemaToMarkdown(item, indentLevel + 2);
+        });
+    }
+    else if (schema instanceof zod_1.z.ZodLiteral) {
+        markdown += `${indent}- Literal: ${JSON.stringify(schema.value)}\n`;
+    }
+    else if (schema instanceof zod_1.z.ZodBigInt) {
+        markdown += `${indent}- BigInt\n`;
+    }
+    else if (schema instanceof zod_1.z.ZodDate) {
+        markdown += `${indent}- Date\n`;
+    }
+    else if (schema instanceof zod_1.z.ZodNaN) {
+        markdown += `${indent}- NaN\n`;
+    }
+    else if (schema instanceof zod_1.z.ZodNever) {
+        markdown += `${indent}- Never\n`;
+    }
+    else if (schema instanceof zod_1.z.ZodUnknown) {
+        markdown += `${indent}- Unknown\n`;
+    }
+    else if (schema instanceof zod_1.z.ZodVoid) {
+        markdown += `${indent}- Void\n`;
+    }
+    else {
+        markdown += `${indent}- Type: ${schema.constructor.name}\n`;
+    }
+    return markdown;
+}
+exports.zodSchemaToMarkdown = zodSchemaToMarkdown;

package/lib/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/index.test.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const zod_1 = require("zod");
+const index_1 = require("./index");
+describe('zodSchemaToMarkdown', () => {
+    it('should convert a simple object schema to markdown', () => {
+        const schema = zod_1.z.object({
+            name: zod_1.z.string(),
+            age: zod_1.z.number(),
+        });
+        const expected = `- name
+  - String
+- age
+  - Number
+`;
+        expect((0, index_1.zodSchemaToMarkdown)(schema)).toBe(expected);
+    });
+    it('should convert an array schema to markdown', () => {
+        const schema = zod_1.z.array(zod_1.z.string());
+        const expected = `- Array
+  - String
+`;
+        expect((0, index_1.zodSchemaToMarkdown)(schema)).toBe(expected);
+    });
+    it('should convert a union schema to markdown', () => {
+        const schema = zod_1.z.union([zod_1.z.string(), zod_1.z.number()]);
+        const expected = `- Union
+  - String
+  |
+  - Number
+`;
+        expect((0, index_1.zodSchemaToMarkdown)(schema)).toBe(expected);
+    });
+    it('should convert ZodEffects (transform) to markdown', () => {
+        const schema = zod_1.z.string().transform(val => val.length);
+        const expected = `- Effects (transform)
+  - String
+`;
+        expect((0, index_1.zodSchemaToMarkdown)(schema)).toBe(expected);
+    });
+    it('should convert ZodDiscriminatedUnion to markdown', () => {
+        const schema = zod_1.z.discriminatedUnion('type', [
+            zod_1.z.object({ type: zod_1.z.literal('a'), a: zod_1.z.string() }),
+            zod_1.z.object({ type: zod_1.z.literal('b'), b: zod_1.z.number() })
+        ]);
+        const expected = `- DiscriminatedUnion (key: type)
+  - type
+    - Literal: "a"
+  - a
+    - String
+  |
+  - type
+    - Literal: "b"
+  - b
+    - Number
+`;
+        expect((0, index_1.zodSchemaToMarkdown)(schema)).toBe(expected);
+    });
+    it('should convert ZodIntersection to markdown', () => {
+        const schema = zod_1.z.object({ a: zod_1.z.string() }).and(zod_1.z.object({ b: zod_1.z.number() }));
+        const expected = `- Intersection
+  Left:
+    - a
+      - String
+  Right:
+    - b
+      - Number
+`;
+        expect((0, index_1.zodSchemaToMarkdown)(schema)).toBe(expected);
+    });
+    it('should convert ZodRecord to markdown', () => {
+        const schema = zod_1.z.record(zod_1.z.string(), zod_1.z.number());
+        const expected = `- Record
+  Key:
+    - String
+  Value:
+    - Number
+`;
+        expect((0, index_1.zodSchemaToMarkdown)(schema)).toBe(expected);
+    });
+    it('should convert ZodTuple to markdown', () => {
+        const schema = zod_1.z.tuple([zod_1.z.string(), zod_1.z.number()]);
+        const expected = `- Tuple
+  [0]:
+    - String
+  [1]:
+    - Number
+`;
+        expect((0, index_1.zodSchemaToMarkdown)(schema)).toBe(expected);
+    });
+    it('should convert ZodLiteral to markdown', () => {
+        const schema = zod_1.z.literal('hello');
+        const expected = `- Literal: "hello"
+`;
+        expect((0, index_1.zodSchemaToMarkdown)(schema)).toBe(expected);
+    });
+    it('should convert ZodBigInt to markdown', () => {
+        const schema = zod_1.z.bigint();
+        const expected = `- BigInt
+`;
+        expect((0, index_1.zodSchemaToMarkdown)(schema)).toBe(expected);
+    });
+    it('should convert ZodDate to markdown', () => {
+        const schema = zod_1.z.date();
+        const expected = `- Date
+`;
+        expect((0, index_1.zodSchemaToMarkdown)(schema)).toBe(expected);
+    });
+    it('should convert ZodNaN to markdown', () => {
+        const schema = zod_1.z.nan();
+        const expected = `- NaN
+`;
+        expect((0, index_1.zodSchemaToMarkdown)(schema)).toBe(expected);
+    });
+    it('should convert ZodNever to markdown', () => {
+        const schema = zod_1.z.never();
+        const expected = `- Never
+`;
+        expect((0, index_1.zodSchemaToMarkdown)(schema)).toBe(expected);
+    });
+    it('should convert ZodUnknown to markdown', () => {
+        const schema = zod_1.z.unknown();
+        const expected = `- Unknown
+`;
+        expect((0, index_1.zodSchemaToMarkdown)(schema)).toBe(expected);
+    });
+    it('should convert ZodVoid to markdown', () => {
+        const schema = zod_1.z.void();
+        const expected = `- Void
+`;
+        expect((0, index_1.zodSchemaToMarkdown)(schema)).toBe(expected);
+    });
+});

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@chnak/zod-to-markdown",
+  "version": "1.0.1",
+  "description": "A utility function to convert Zod schemas to Markdown documentation",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "jest",
+    "prepublish": "npm run build"
+  },
+  "keywords": [
+    "zod",
+    "markdown",
+    "documentation",
+    "schema",
+    "typescript"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/chnak/zod-to-markdown.git"
+  },
+  "bugs": {
+    "url": "https://github.com/chnak/zod-to-markdown/issues"
+  },
+  "homepage": "https://github.com/chnak/zod-to-markdown#readme",
+  "dependencies": {
+    "zod": "^3.24.0"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.12",
+    "@types/node": "^14.0.0",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.2",
+    "typescript": "^4.0.0"
+  }
+}