@zhin.js/schema 1.0.42 → 1.0.44

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhin.js/schema",
-  "version": "1.0.42",
+  "version": "1.0.44",
   "description": "Configuration validation and schema system for Zhin.js",
   "type": "module",
   "main": "./lib/index.js",
@@ -11,10 +11,13 @@
       "import": "./lib/index.js"
     }
   },
+  "files": [
+    "lib"
+  ],
   "devDependencies": {
-    "typescript": "^5.3.0",
+    "typescript": "^5.9.3",
     "@types/node": "^24.3.0",
-    "zhin.js": "1.0.58"
+    "zhin.js": "1.0.60"
   },
   "repository": {
     "type": "git",
@@ -26,7 +29,7 @@
     "registry": "https://registry.npmjs.org"
   },
   "peerDependencies": {
-    "zhin.js": "1.0.58"
+    "zhin.js": "1.0.60"
   },
   "keywords": [
     "zhin",

package/CHANGELOG.md

@@ -1,274 +0,0 @@
-# @zhin.js/schema
-
-## 1.0.42
-
-### Patch Changes
-
-- zhin.js@1.0.58
-
-## 1.0.41
-
-### Patch Changes
-
-- zhin.js@1.0.57
-
-## 1.0.40
-
-### Patch Changes
-
-- zhin.js@1.0.56
-
-## 1.0.39
-
-### Patch Changes
-
-- zhin.js@1.0.55
-
-## 1.0.38
-
-### Patch Changes
-
-- 16c8f92: fix: 统一发一次版
-- Updated dependencies [16c8f92]
-  - zhin.js@1.0.54
-
-## 1.0.37
-
-### Patch Changes
-
-- zhin.js@1.0.53
-
-## 1.0.36
-
-### Patch Changes
-
-- Updated dependencies [bb6bfa8]
-- Updated dependencies [bb6bfa8]
-  - zhin.js@1.0.52
-
-## 1.0.35
-
-### Patch Changes
-
-- zhin.js@1.0.51
-
-## 1.0.34
-
-### Patch Changes
-
-- zhin.js@1.0.50
-
-## 1.0.33
-
-### Patch Changes
-
-- zhin.js@1.0.49
-
-## 1.0.32
-
-### Patch Changes
-
-- zhin.js@1.0.48
-
-## 1.0.31
-
-### Patch Changes
-
-- Updated dependencies [de3e352]
-  - zhin.js@1.0.47
-
-## 1.0.30
-
-### Patch Changes
-
-- Updated dependencies [7394603]
-  - zhin.js@1.0.46
-
-## 1.0.29
-
-### Patch Changes
-
-- zhin.js@1.0.45
-
-## 1.0.28
-
-### Patch Changes
-
-- zhin.js@1.0.44
-
-## 1.0.27
-
-### Patch Changes
-
-- Updated dependencies [72ec4ba]
-  - zhin.js@1.0.43
-
-## 1.0.26
-
-### Patch Changes
-
-- zhin.js@1.0.42
-
-## 1.0.25
-
-### Patch Changes
-
-- zhin.js@1.0.41
-
-## 1.0.24
-
-### Patch Changes
-
-- Updated dependencies [7ef9057]
-  - zhin.js@1.0.40
-
-## 1.0.23
-
-### Patch Changes
-
-- zhin.js@1.0.39
-
-## 1.0.22
-
-### Patch Changes
-
-- Updated dependencies [ab5c54a]
-  - zhin.js@1.0.38
-
-## 1.0.21
-
-### Patch Changes
-
-- zhin.js@1.0.37
-
-## 1.0.20
-
-### Patch Changes
-
-- zhin.js@1.0.36
-
-## 1.0.19
-
-### Patch Changes
-
-- zhin.js@1.0.35
-
-## 1.0.18
-
-### Patch Changes
-
-- zhin.js@1.0.34
-
-## 1.0.17
-
-### Patch Changes
-
-- zhin.js@1.0.33
-
-## 1.0.16
-
-### Patch Changes
-
-- zhin.js@1.0.32
-
-## 1.0.15
-
-### Patch Changes
-
-- zhin.js@1.0.31
-
-## 1.0.14
-
-### Patch Changes
-
-- Updated dependencies [460a6c6]
-  - zhin.js@1.0.30
-
-## 1.0.13
-
-### Patch Changes
-
-- zhin.js@1.0.29
-
-## 1.0.12
-
-### Patch Changes
-
-- zhin.js@1.0.28
-
-## 1.0.11
-
-### Patch Changes
-
-- Updated dependencies [b27e633]
-  - zhin.js@1.0.27
-
-## 1.0.10
-
-### Patch Changes
-
-- 106d357: fix: ai
-- Updated dependencies [106d357]
-  - zhin.js@1.0.26
-
-## 1.0.9
-
-### Patch Changes
-
-- 26d2942: fix: ai
-- 6b02c41: fix: ai
-- Updated dependencies [26d2942]
-- Updated dependencies [6b02c41]
-  - zhin.js@1.0.25
-
-## 1.0.8
-
-### Patch Changes
-
-- zhin.js@1.0.24
-
-## 1.0.7
-
-### Patch Changes
-
-- Updated dependencies [52ae08a]
-  - zhin.js@1.0.23
-
-## 1.0.6
-
-### Patch Changes
-
-- Updated dependencies [26aba27]
-  - zhin.js@1.0.22
-
-## 1.0.5
-
-### Patch Changes
-
-- zhin.js@1.0.21
-
-## 1.0.4
-
-### Patch Changes
-
-- a3b7673: fix: 调整依赖项
-- Updated dependencies [5141137]
-  - zhin.js@1.0.20
-
-## 1.0.3
-
-### Patch Changes
-
-- f9faa1d: fix: test release
-
-## 1.0.2
-
-### Patch Changes
-
-- d16a69c: fix: test trust publish
-
-## 1.0.1
-
-### Patch Changes
-
-- 547028f: fix: 优化包结构,优化客户端支持

package/src/index.ts

@@ -1,2 +0,0 @@
-export * from './schema.js';
-export * from './utils.js';

package/src/schema.ts

@@ -1,374 +0,0 @@
-import { isEmpty } from './utils.js';
-
-export class Schema<S = any, T = S> {
-    public [Symbol.toStringTag] = 'Schema';
-    constructor(
-        public meta: Schema.Meta<S, T>,
-        public options: Schema.Options = {},
-    ) {
-        const _this = this;
-        const schema = function (value?: S, key: string = 'value') {
-            const formatter = Schema.resolve(_this.meta.type);
-            if (!formatter) throw new Error(`type ${_this.meta.type} not found`);
-            return formatter.call(_this, key, value);
-        } as Schema<S, T>;
-        return new Proxy(schema, {
-            get(target, p: string | symbol, receiver: any): any {
-                return Reflect.get(_this, p, receiver);
-            },
-            set(target, p: string | symbol, value: any, receiver: any): boolean {
-                return Reflect.set(_this, p, value, receiver);
-            },
-        });
-    }
-    static fromJSON<S, T>(json: Schema.JSON<S, T>) {
-        const { object, inner, list, ...meta } = json;
-        const options: Schema.Options = {};
-        if (object)
-            options.object = Object.fromEntries(Object.entries(object).map(([key, value]) => [key, Schema.fromJSON(value)]));
-        if (inner) options.inner = Schema.fromJSON(inner);
-        if (list) options.list = list.map(item => Schema.fromJSON(item));
-        return new Schema<S, T>(meta, options);
-    }
-    toJSON(): Record<string, any> {
-        return Object.fromEntries(
-            Object.entries({
-                ...this.meta,
-                default: typeof this.meta.default === 'function' ? this.meta.default() : this.meta.default,
-                inner: this.options.inner?.toJSON(),
-                object: this.options.object
-                    ? Object.fromEntries(Object.entries(this.options.object || {}).map(([key, value]) => [
-                        key, 
-                        { 
-                            ...value.toJSON(), 
-                            key 
-                        }
-                    ]))
-                    : undefined,
-                list: this.options.list?.map(item => item.toJSON()),
-            }).filter(([key, value]) => typeof value !== 'undefined'),
-        );
-    }
-    [Symbol.unscopables]() {
-        return {
-            options: true,
-            meta: true,
-        };
-    }
-    /** 设置是否必填 */
-    required(): this {
-        this.meta.required = true;
-        return this;
-    }
-    /** 是否隐藏 */
-    hidden(): this {
-        this.meta.hidden = true;
-        return this;
-    }
-    /** 设置描述 */
-    description(description: string): this {
-        this.meta.description = description;
-        return this;
-    }
-    /** 设置默认值 */
-    default(defaultValue: T): this {
-        this.meta.default = defaultValue;
-        return this;
-    }
-    /** 设置选项列表 */
-    option(list: (T | Schema.Option<T>)[]): this {
-        this.meta.options = Schema.formatOptionList(list);
-        return this;
-    }
-    /** 设置是否允许多选 */
-    multiple(): this {
-        if (this.meta.type !== 'list') throw new Error('multiple only support list type');
-        this.meta.multiple = true;
-        return this;
-    }
-    /** 设置最小值 */
-    min(value: number): this {
-        this.meta.min = value;
-        return this;
-    }
-    /** 设置最大值 */
-    max(value: number): this {
-        this.meta.max = value;
-        return this;
-    }
-    /** 设置步进值 */
-    step(value: number): this {
-        this.meta.step = value;
-        return this;
-    }
-    /** 设置组件类型 */
-    component(type: string): this {
-        this.meta.component = type;
-        return this;
-    }
-    /** 声明一个数字类型 */
-    static number(key?: string): Schema<number> {
-        return new Schema<number>({ type: 'number', key });
-    }
-    /** 声明一个字符串类型 */
-    static string(key?: string): Schema<string> {
-        return new Schema<string>({ type: 'string', key });
-    }
-    /** 声明一个布尔类型 */
-    static boolean(key?: string): Schema<boolean> {
-        return new Schema<boolean>({ type: 'boolean', key });
-    }
-    /** 声明一个正则类型 */
-    static regexp(key?: string) {
-        return new Schema<RegExp | string, RegExp>({ type: 'regexp', key });
-    }
-    /** 声明一个日期类型 */
-    static date(key?: string) {
-        return new Schema<Date | number, Date>({ type: 'date', key });
-    }
-    /** 声明一个字典类型 */
-    static dict<X extends Schema>(input: X, key?: string) {
-        return new Schema<Record<string, Schema.Types<X>>>({ type: 'dict', key }, { inner: input });
-    }
-    static object<X extends Record<string, Schema>>(input: X, key: string = '') {
-        return new Schema<Schema.RecordTypes<X>>({ type: 'object', key }, { object: input });
-    }
-    /** 声明一个列表类型 */
-    static list<X extends Schema>(inner: X, key?: string) {
-        return new Schema<Schema.Types<X>[]>({ type: 'list', key }, { inner });
-    }
-    /** 声明一个元组类型 */
-    static tuple<X extends readonly any[]>(list: X, key?: string) {
-        return new Schema<Schema.Tuple<X>>({ type: 'tuple', key }, { list });
-    }
-    /** 声明一个联合类型 */
-    static union<X extends readonly any[]>(list: X, key?: string) {
-        return new Schema<Schema.Union<X>>({ type: 'union', key }, { list });
-    }
-    /** 声明一个交叉类型 */
-    static intersect<X extends readonly any[]>(list: X, key?: string) {
-        return new Schema<Schema.Intersect<X>>({ type: 'intersect', key }, { list });
-    }
-    /** 声明一个常量 */
-    static const<X extends string | number | boolean>(value: X, key?: string) {
-        return new Schema<X>({ type: 'const', default: value as any, key });
-    }
-    /** 声明任意类型 */
-    static any(key?: any) {
-        return new Schema<any>({ type: 'any', key });
-    }
-    static resolve<T extends string>(type: T): Schema.Formatter {
-        return Schema.formatters.get(type)!;
-    }
-    static extend<T extends string>(type: T, formatter: Schema.Formatter) {
-        Schema.formatters.set(type, formatter);
-    }
-}
-export interface Schema<S = any> {
-    (value?: S, key?: string): S;
-}
-export namespace Schema {
-    export const formatters: Map<string, Formatter> = new Map<string, Formatter>();
-    export type Formatter<S = any, T = S> = (this: Schema, key: string, value: S) => T;
-    export type JSON<S = any, T = S> = Meta<S, T> & {
-        object?: Record<string, JSON>;
-        inner?: JSON;
-        list?: JSON[];
-    };
-    export interface Meta<S = any, T = S> {
-        hidden?: boolean;
-        type: string;
-        default?: T;
-        required?: boolean;
-        options?: Option<T>[];
-        multiple?: boolean;
-        key?: string;
-        description?: string;
-        component?: string;
-        min?: number;
-        max?: number;
-        step?: number;
-    }
-    export interface Options {
-        object?: Record<string, Schema>;
-        inner?: Schema;
-        list?: readonly Schema[];
-    }
-    export type Types<T> = T extends Schema<infer S> ? S : never;
-    export type RecordTypes<T> = T extends Record<string, Schema>
-        ? {
-            [K in keyof T]?: Types<T[K]>;
-        }
-        : unknown;
-    export type Union<T extends readonly any[]> = T extends readonly [infer L, ...infer R]
-        ? Types<L> | Union<R>
-        : never;
-    export type Intersect<T extends readonly any[]> = T extends readonly [infer L, ...infer R]
-        ? Types<L> & Intersect<R>
-        : unknown;
-    export type Tuple<T extends readonly any[]> = T extends readonly [infer L, ...infer R]
-        ? [Types<L>, ...Tuple<R>]
-        : [];
-    export function checkDefault<T>(schema: Schema, key: string, value: T, fallback: T = value) {
-        if (isEmpty(value)) {
-            value = schema.meta.default || fallback;
-        }
-        const validateType = (schema: Schema, key: string, value: any) => {
-            switch (schema.meta.type) {
-                case 'string':
-                    if (!['string', 'undefined'].includes(typeof value)) throw new TypeError(`${key} is not a string`);
-                    break;
-                case 'number':
-                    if (!['number', 'undefined'].includes(typeof value)) throw new TypeError(`${key} is not a number`);
-                    break;
-                case 'boolean':
-                    if (!['boolean', 'undefined'].includes(typeof value)) throw new TypeError(`${key} is not a boolean`);
-                    break;
-                case 'regexp':
-                    if (!['string', 'undefined'].includes(typeof value) && !(value instanceof RegExp))
-                        throw new TypeError(`${key} is not a RegExp|string`);
-                    break;
-                case 'date':
-                    if (!['number', 'undefined'].includes(typeof value) && !(value instanceof Date))
-                        throw new TypeError(`${key} is not a Date|number`);
-                    if (value instanceof Date && isNaN(value.getTime())) throw new TypeError(`${key} is not a valid Date`);
-                    break;
-                case 'dict':
-                    if (!['object', 'undefined', 'null'].includes(typeof value)) throw new TypeError(`${key} is not a object`);
-                    break;
-                case 'object':
-                    if (!['object', 'undefined', 'null'].includes(typeof value)) throw new TypeError(`${key} is not a object`);
-                    break;
-                case 'list':
-                    if (typeof value !== 'undefined' && !Array.isArray(value)) throw new TypeError(`${key} is not a list`);
-                    break;
-                case 'tuple':
-                    if (typeof value !== 'undefined' && !Array.isArray(value)) throw new TypeError(`${key} is not a tuple`);
-                    break;
-                case 'union':
-                    // union类型不在这里验证，在extend函数中验证
-                    break;
-                case 'intersect':
-                    // intersect类型不在这里验证，在extend函数中验证
-                    break;
-                case 'const':
-                    if (typeof value !== 'undefined' && value !== schema.meta.default) throw new TypeError(`${key} is not const`);
-                    break;
-                case 'any':
-                    // any类型不验证
-                    break;
-                default:
-                    throw new TypeError(`${key} is not a valid type`);
-            }
-        };
-        if (schema.meta.required && typeof value === 'undefined') throw new Error(`${key} is required`);
-        validateType(schema, key, value);
-        return value;
-    }
-    export type Option<T = any> = {
-        label: string;
-        value: T;
-    };
-    export function formatOptionList<T extends (any | Schema.Option)[]>(list: T): Schema.Option[] {
-        return list.map(item => {
-            if (typeof item === 'string') {
-                return {
-                    label: `${item}`,
-                    value: item,
-                } as Schema.Option;
-            }
-            return item as unknown as Schema.Option;
-        });
-    }
-}
-Schema.extend('number', function (this: Schema, key: string, value: any) {
-    value = Schema.checkDefault(this, key, value);
-    return value;
-});
-Schema.extend('string', function (this: Schema, key: string, value: any) {
-    value = Schema.checkDefault(this, key, value);
-    return value;
-});
-Schema.extend('boolean', function (this: Schema, key: string, value: any) {
-    return Schema.checkDefault(this, key, value);
-});
-Schema.extend('dict', function (this: Schema, key: string, value: any) {
-    value = Schema.checkDefault(this, key, value, {});
-    return Object.fromEntries(
-        Object.entries(value).map(([k, schema]) => {
-            return [k, this.options.inner!(schema, `${key}.${k}`)];
-        }),
-    );
-});
-
-Schema.extend('object', function (this: Schema, key: string, value: any) {
-    const getDefault = (schema: Schema) => {
-        const result = Object.create(null);
-        for (const key in schema.options.object) {
-            const propSchema = schema.options.object[key];
-            result[key] = propSchema.default !== undefined ? propSchema.default : undefined;
-        }
-        return result;
-    };
-    value = Schema.checkDefault(this, key, value, getDefault(this));
-    const result = Object.create(null);
-    for (const [k, val] of Object.entries(value)) {
-        const propSchema = this.options.object![k];
-        if (propSchema) {
-            // propSchema是一个可调用的Schema实例
-            result[k] = (propSchema as any)(val, `${key}.${k}`);
-        } else {
-            result[k] = val;
-        }
-    }
-    return result;
-});
-Schema.extend('list', function (this: Schema, key: string, value: any) {
-    value = Schema.checkDefault(this, key, value, []);
-    return value.map((item: any, index: number) => this.options.inner!(item, `${key}[${index}]`));
-});
-Schema.extend('regexp', function (this: Schema, key: string, value: any) {
-    value = Schema.checkDefault(this, key, value);
-    if (typeof value === 'string') {
-        return new RegExp(value);
-    }
-    return value;
-});
-Schema.extend('date', function (this: Schema, key: string, value: any) {
-    value = Schema.checkDefault(this, key, value);
-    return new Date(value);
-});
-Schema.extend('const', function (this: Schema, key: string, value: any) {
-    value = Schema.checkDefault(this, key, value);
-    if (value !== this.meta.default) {
-        throw new Error(`${key} const value not match`);
-    }
-    return value;
-});
-Schema.extend('tuple', function (this: Schema, key: string, value: any) {
-    value = Schema.checkDefault(this, key, value, []);
-    return value.map((item: any, index: number) => this.options.list![index](item, `${key}[${index}]`));
-});
-Schema.extend('union', function (this: Schema, key: string, value: any) {
-    value = Schema.checkDefault(this, key, value);
-    for (const schema of this.options.list!) {
-        try {
-            return (schema as any)(value, key);
-        } catch { /* schema mismatch, try next variant */ }
-    }
-    throw new Error(`${key} union type not match`);
-});
-Schema.extend('intersect', function (this: Schema, key: string, value: any) {
-    value = Schema.checkDefault(this, key, value);
-    for (const schema of this.options.list!) {
-        try {
-            value = (schema as any)(value, key);
-        } catch (e) {
-            throw new Error(`${key} intersect type not match`);
-        }
-    }
-    return value;
-});
-Schema.extend('any', function (this: Schema, key: string, value: any) {
-    return Schema.checkDefault(this, key, value);
-});

package/src/utils.ts

@@ -1,32 +0,0 @@
-/**
- * 检查值是否为空
- */
-export function isEmpty(value: any): boolean {
-  return value === null || value === undefined || value === '';
-}
-
-/**
- * 深度合并对象
- */
-export function deepMerge<T>(target: T, source: Partial<T>): T {
-  if (!target || !source) return target;
-  
-  const result = { ...target };
-  
-  for (const key in source) {
-    const sourceValue = source[key];
-    const targetValue = result[key];
-    
-    if (sourceValue !== undefined) {
-      if (typeof sourceValue === 'object' && sourceValue !== null && 
-          typeof targetValue === 'object' && targetValue !== null &&
-          !Array.isArray(sourceValue) && !Array.isArray(targetValue)) {
-        (result as any)[key] = deepMerge(targetValue, sourceValue);
-      } else {
-        (result as any)[key] = sourceValue;
-      }
-    }
-  }
-  
-  return result;
-}

package/tests/schema.test.ts

@@ -1,243 +0,0 @@
-import { describe, it, expect, beforeAll } from 'vitest'
-import { Schema } from '../src/index'
-
-describe('Schema', () => {
-  describe('Basic types', () => {
-    it('should create string schema', () => {
-      const schema = Schema.string()
-      expect(schema).toBeDefined()
-      expect(schema.meta.type).toBe('string')
-    })
-
-    it('should create number schema', () => {
-      const schema = Schema.number()
-      expect(schema).toBeDefined()
-      expect(schema.meta.type).toBe('number')
-    })
-
-    it('should create boolean schema', () => {
-      const schema = Schema.boolean()
-      expect(schema).toBeDefined()
-      expect(schema.meta.type).toBe('boolean')
-    })
-
-    it('should create date schema', () => {
-      const schema = Schema.date()
-      expect(schema).toBeDefined()
-      expect(schema.meta.type).toBe('date')
-    })
-
-    it('should create regexp schema', () => {
-      const schema = Schema.regexp()
-      expect(schema).toBeDefined()
-      expect(schema.meta.type).toBe('regexp')
-    })
-  })
-
-  describe('Complex types', () => {
-    it('should create object schema', () => {
-      const schema = Schema.object({
-        name: Schema.string(),
-        age: Schema.number()
-      })
-      expect(schema).toBeDefined()
-      expect(schema.meta.type).toBe('object')
-    })
-
-    it('should create list schema', () => {
-      const schema = Schema.list(Schema.string())
-      expect(schema).toBeDefined()
-      expect(schema.meta.type).toBe('list')
-    })
-
-    it('should create dict schema', () => {
-      const schema = Schema.dict(Schema.number())
-      expect(schema).toBeDefined()
-      expect(schema.meta.type).toBe('dict')
-    })
-
-    it('should create union schema', () => {
-      const schema = Schema.union(['option1', 'option2', 'option3'])
-      expect(schema).toBeDefined()
-    })
-  })
-
-  describe('Schema methods', () => {
-    it('should set description', () => {
-      const schema = Schema.string().description('Test description')
-      expect(schema.meta.description).toBe('Test description')
-    })
-
-    it('should set default value', () => {
-      const schema = Schema.string().default('default value')
-      expect(schema.meta.default).toBe('default value')
-    })
-
-    it('should set required', () => {
-      const schema = Schema.string().required()
-      expect(schema.meta.required).toBe(true)
-    })
-
-    it('should have meta property', () => {
-      const schema = Schema.string()
-      expect(schema.meta).toBeDefined()
-      expect(schema.meta.type).toBe('string')
-    })
-
-    it('should chain multiple methods', () => {
-      const schema = Schema.string()
-        .description('Name')
-        .default('John')
-        .required()
-      
-      expect(schema.meta.description).toBe('Name')
-      expect(schema.meta.default).toBe('John')
-      expect(schema.meta.required).toBe(true)
-    })
-  })
-
-  describe('Const schema', () => {
-    it('should create const schema with string', () => {
-      const schema = Schema.const('constant')
-      expect(schema.meta.type).toBe('const')
-      expect(schema.meta.default).toBe('constant')
-    })
-
-    it('should create const schema with number', () => {
-      const schema = Schema.const(42)
-      expect(schema.meta.type).toBe('const')
-      expect(schema.meta.default).toBe(42)
-    })
-
-    it('should create const schema with object', () => {
-      const obj = { key: 'value' }
-      const schema = Schema.const(obj)
-      expect(schema.meta.type).toBe('const')
-      expect(schema.meta.default).toBe(obj)
-    })
-  })
-
-  describe('Schema properties', () => {
-    it('should have meta for string schema', () => {
-      const schema = Schema.string()
-      expect(schema.meta).toBeDefined()
-      expect(schema.meta.type).toBe('string')
-    })
-
-    it('should have meta for number schema', () => {
-      const schema = Schema.number()
-      expect(schema.meta).toBeDefined()
-      expect(schema.meta.type).toBe('number')
-    })
-
-    it('should have meta for boolean schema', () => {
-      const schema = Schema.boolean()
-      expect(schema.meta).toBeDefined()
-      expect(schema.meta.type).toBe('boolean')
-    })
-
-    it('should have options for object schema', () => {
-      const schema = Schema.object({
-        name: Schema.string(),
-        age: Schema.number()
-      })
-      expect(schema.options).toBeDefined()
-      expect(schema.options.object).toBeDefined()
-    })
-
-    it('should have options for list schema', () => {
-      const schema = Schema.list(Schema.string())
-      expect(schema.options).toBeDefined()
-      expect(schema.options.inner).toBeDefined()
-    })
-  })
-
-  describe('Schema intersect', () => {
-    it('should create intersect schema', () => {
-      const schema1 = Schema.object({ name: Schema.string() })
-      const schema2 = Schema.object({ age: Schema.number() })
-      const intersect = Schema.intersect([schema1, schema2])
-      
-      expect(intersect).toBeDefined()
-      expect(intersect.meta.type).toBe('intersect')
-    })
-  })
-})
-
-// ============================================================================
-// Schema 工具函数补全
-// ============================================================================
-describe('Schema utils', () => {
-  let isEmpty: (v: any) => boolean;
-  let deepMerge: <T>(target: T, source: Partial<T>) => T;
-
-  beforeAll(async () => {
-    const utils = await import('../src/utils.js');
-    isEmpty = utils.isEmpty;
-    deepMerge = utils.deepMerge;
-  });
-
-  describe('isEmpty', () => {
-    it('null 应为空', () => {
-      expect(isEmpty(null)).toBe(true)
-    })
-
-    it('undefined 应为空', () => {
-      expect(isEmpty(undefined)).toBe(true)
-    })
-
-    it('空字符串应为空', () => {
-      expect(isEmpty('')).toBe(true)
-    })
-
-    it('0 不应为空', () => {
-      expect(isEmpty(0)).toBe(false)
-    })
-
-    it('false 不应为空', () => {
-      expect(isEmpty(false)).toBe(false)
-    })
-
-    it('非空字符串不应为空', () => {
-      expect(isEmpty('hello')).toBe(false)
-    })
-
-    it('空数组不应为空', () => {
-      expect(isEmpty([])).toBe(false)
-    })
-  })
-
-  describe('deepMerge', () => {
-    it('应合并简单对象', () => {
-      const target = { a: 1, b: 2 }
-      const source = { b: 3, c: 4 }
-      const result = deepMerge(target, source)
-      expect(result).toEqual({ a: 1, b: 3, c: 4 })
-    })
-
-    it('应深度合并嵌套对象', () => {
-      const target = { a: { x: 1, y: 2 }, b: 3 }
-      const source = { a: { y: 5, z: 6 } }
-      const result = deepMerge(target, source)
-      expect(result).toEqual({ a: { x: 1, y: 5, z: 6 }, b: 3 })
-    })
-
-    it('数组应直接覆盖而非合并', () => {
-      const target = { a: [1, 2] }
-      const source = { a: [3, 4, 5] }
-      const result = deepMerge(target, source)
-      expect(result).toEqual({ a: [3, 4, 5] })
-    })
-
-    it('undefined 值不应覆盖', () => {
-      const target = { a: 1, b: 2 }
-      const source = { a: undefined, b: 3 }
-      const result = deepMerge(target, source)
-      expect(result).toEqual({ a: 1, b: 3 })
-    })
-
-    it('null target 应返回 target', () => {
-      expect(deepMerge(null, { a: 1 })).toBeNull()
-    })
-  })
-})

package/tsconfig.json

@@ -1,24 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "ESNext",
-    "moduleResolution": "bundler",
-    "allowImportingTsExtensions": false,
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "resolveJsonModule": true,
-    "isolatedModules": true,
-    "verbatimModuleSyntax": false,
-    "allowSyntheticDefaultImports": true,
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true,
-    "outDir": "./lib",
-    "rootDir": "./src"
-  },
-  "include": [
-    "src/**/*"
-  ]
-}