@wwog/react 1.3.12 → 1.3.13

package/src/utils/ruleChecker.test.ts

@@ -1,407 +1,403 @@
-import { describe, expect, it } from 'vitest';
-import { ruleChecker } from './ruleChecker';
-import type { RuleDescription } from './ruleChecker';
+import {describe, expect, it} from 'vitest'
+import {ruleChecker} from './ruleChecker'
+import type {RuleDescription} from './ruleChecker'
 
 describe('ruleChecker', () => {
   // ==== 基础功能测试 ====
   describe('基础功能', () => {
     it('应该通过空规则验证', () => {
-      const result = ruleChecker({}, {});
-      expect(result.valid).toBe(true);
+      const result = ruleChecker({}, {})
+      expect(result.valid).toBe(true)
       if (result.valid) {
-        expect(result.data).toEqual({});
+        expect(result.data).toEqual({})
       }
-    });
+    })
 
     it('应该验证 required 规则 - 成功', () => {
-      const data = { name: 'John' };
+      const data = {name: 'John'}
       const rules: RuleDescription<typeof data> = {
-        name: { required: true },
-      };
-      const result = ruleChecker(data, rules);
-      expect(result.valid).toBe(true);
+        name: {required: true},
+      }
+      const result = ruleChecker(data, rules)
+      expect(result.valid).toBe(true)
       if (result.valid) {
-        expect(result.data.name).toBe('John');
+        expect(result.data.name).toBe('John')
       }
-    });
+    })
 
     it('应该验证 required 规则 - 失败', () => {
-      const data = { name: '' };
+      const data = {name: ''}
       const rules: RuleDescription<typeof data> = {
-        name: { required: true },
-      };
-      const result = ruleChecker(data, rules);
-      expect(result.valid).toBe(false);
+        name: {required: true},
+      }
+      const result = ruleChecker(data, rules)
+      expect(result.valid).toBe(false)
       if (!result.valid) {
-        expect(result.errors).toContain('name 为必填项');
-        expect(result.fieldErrors.name).toContain('name 为必填项');
+        expect(result.errors).toContain('name 为必填项')
+        expect(result.fieldErrors.name).toContain('name 为必填项')
       }
-    });
+    })
 
     it('应该使用自定义错误消息', () => {
-      const data = { email: '' };
+      const data = {email: ''}
       const rules: RuleDescription<typeof data> = {
-        email: { required: true, message: '邮箱不能为空' },
-      };
-      const result = ruleChecker(data, rules);
-      expect(result.valid).toBe(false);
+        email: {required: true, message: '邮箱不能为空'},
+      }
+      const result = ruleChecker(data, rules)
+      expect(result.valid).toBe(false)
       if (!result.valid) {
-        expect(result.errors).toContain('邮箱不能为空');
+        expect(result.errors).toContain('邮箱不能为空')
       }
-    });
+    })
 
     it('应该处理 null 和 undefined 值', () => {
-      type DataType = { name: string | null; age?: number };
-      const data: Partial<DataType> = { name: null, age: undefined };
+      type DataType = {name: string | null; age?: number}
+      const data: Partial<DataType> = {name: null, age: undefined}
       const rules: RuleDescription<DataType> = {
-        name: { required: true },
-        age: { required: false },
-      };
-      const result = ruleChecker(data, rules);
-      expect(result.valid).toBe(false);
+        name: {required: true},
+        age: {required: false},
+      }
+      const result = ruleChecker(data, rules)
+      expect(result.valid).toBe(false)
       if (!result.valid) {
-        expect(result.fieldErrors.name).toContain('name 为必填项');
-        expect(result.fieldErrors.age).toBeUndefined();
+        expect(result.fieldErrors.name).toContain('name 为必填项')
+        expect(result.fieldErrors.age).toBeUndefined()
       }
-    });
+    })
 
     it('应该验证自定义 validator - 返回 boolean', () => {
-      const data = { password: '123' };
+      const data = {password: '123'}
       const rules: RuleDescription<typeof data> = {
         password: {
           validator: (value) => value.length >= 6,
           message: '密码至少6位',
         },
-      };
-      const result = ruleChecker(data, rules);
-      expect(result.valid).toBe(false);
+      }
+      const result = ruleChecker(data, rules)
+      expect(result.valid).toBe(false)
       if (!result.valid) {
-        expect(result.errors).toContain('密码至少6位');
+        expect(result.errors).toContain('密码至少6位')
       }
-    });
+    })
 
     it('应该验证自定义 validator - 返回 string', () => {
-      const data = { username: 'admin' };
+      const data = {username: 'admin'}
       const rules: RuleDescription<typeof data> = {
         username: {
-          validator: (value) =>
-            value === 'admin' ? '用户名不能是admin' : true,
+          validator: (value) => (value === 'admin' ? '用户名不能是admin' : true),
         },
-      };
-      const result = ruleChecker(data, rules);
-      expect(result.valid).toBe(false);
+      }
+      const result = ruleChecker(data, rules)
+      expect(result.valid).toBe(false)
       if (!result.valid) {
-        expect(result.errors).toContain('用户名不能是admin');
+        expect(result.errors).toContain('用户名不能是admin')
       }
-    });
-  });
+    })
+  })
 
   // ==== 字符串规则测试 ====
   describe('字符串规则', () => {
     it('应该验证字符串长度 len', () => {
-      const data = { code: '123' };
+      const data = {code: '123'}
       const rules: RuleDescription<typeof data> = {
-        code: { len: 4 },
-      };
-      const result = ruleChecker(data, rules);
-      expect(result.valid).toBe(false);
+        code: {len: 4},
+      }
+      const result = ruleChecker(data, rules)
+      expect(result.valid).toBe(false)
       if (!result.valid) {
-        expect(result.errors).toContain('code 长度必须为 4');
+        expect(result.errors).toContain('code 长度必须为 4')
       }
-    });
+    })
 
     it('应该验证字符串最小长度 min', () => {
-      const data = { username: 'ab' };
+      const data = {username: 'ab'}
       const rules: RuleDescription<typeof data> = {
-        username: { min: 3 },
-      };
-      const result = ruleChecker(data, rules);
-      expect(result.valid).toBe(false);
+        username: {min: 3},
+      }
+      const result = ruleChecker(data, rules)
+      expect(result.valid).toBe(false)
       if (!result.valid) {
-        expect(result.errors).toContain('username 长度不能少于 3');
+        expect(result.errors).toContain('username 长度不能少于 3')
       }
-    });
+    })
 
     it('应该验证字符串最大长度 max', () => {
-      const data = { comment: 'a'.repeat(101) };
+      const data = {comment: 'a'.repeat(101)}
       const rules: RuleDescription<typeof data> = {
-        comment: { max: 100 },
-      };
-      const result = ruleChecker(data, rules);
-      expect(result.valid).toBe(false);
+        comment: {max: 100},
+      }
+      const result = ruleChecker(data, rules)
+      expect(result.valid).toBe(false)
       if (!result.valid) {
-        expect(result.errors).toContain('comment 长度不能超过 100');
+        expect(result.errors).toContain('comment 长度不能超过 100')
       }
-    });
+    })
 
     it('应该验证正则表达式', () => {
-      const data = { phone: '123456' };
+      const data = {phone: '123456'}
       const rules: RuleDescription<typeof data> = {
-        phone: { regex: /^\d{11}$/ },
-      };
-      const result = ruleChecker(data, rules);
-      expect(result.valid).toBe(false);
+        phone: {regex: /^\d{11}$/},
+      }
+      const result = ruleChecker(data, rules)
+      expect(result.valid).toBe(false)
       if (!result.valid) {
-        expect(result.errors).toContain('phone 格式不正确');
+        expect(result.errors).toContain('phone 格式不正确')
       }
-    });
+    })
 
     it('应该验证邮箱格式', () => {
-      const data = { email: 'invalid-email' };
+      const data = {email: 'invalid-email'}
       const rules: RuleDescription<typeof data> = {
-        email: { email: true },
-      };
-      const result = ruleChecker(data, rules);
-      expect(result.valid).toBe(false);
+        email: {email: true},
+      }
+      const result = ruleChecker(data, rules)
+      expect(result.valid).toBe(false)
       if (!result.valid) {
-        expect(result.errors).toContain('email 不是有效的邮箱');
+        expect(result.errors).toContain('email 不是有效的邮箱')
       }
-    });
+    })
 
     it('应该通过有效的邮箱验证', () => {
-      const data = { email: 'test@example.com' };
+      const data = {email: 'test@example.com'}
       const rules: RuleDescription<typeof data> = {
-        email: { email: true },
-      };
-      const result = ruleChecker(data, rules);
-      expect(result.valid).toBe(true);
-    });
+        email: {email: true},
+      }
+      const result = ruleChecker(data, rules)
+      expect(result.valid).toBe(true)
+    })
 
     it('应该验证URL格式', () => {
-      const data = { website: 'invalid-url' };
+      const data = {website: 'invalid-url'}
       const rules: RuleDescription<typeof data> = {
-        website: { url: true },
-      };
-      const result = ruleChecker(data, rules);
-      expect(result.valid).toBe(false);
+        website: {url: true},
+      }
+      const result = ruleChecker(data, rules)
+      expect(result.valid).toBe(false)
       if (!result.valid) {
-        expect(result.errors).toContain('website 不是有效的URL');
+        expect(result.errors).toContain('website 不是有效的URL')
       }
-    });
+    })
 
     it('应该通过有效的URL验证', () => {
-      const data = { website: 'https://example.com' };
+      const data = {website: 'https://example.com'}
       const rules: RuleDescription<typeof data> = {
-        website: { url: true },
-      };
-      const result = ruleChecker(data, rules);
-      expect(result.valid).toBe(true);
-    });
+        website: {url: true},
+      }
+      const result = ruleChecker(data, rules)
+      expect(result.valid).toBe(true)
+    })
 
     it('应该验证手机号格式', () => {
-      const data = { mobile: '123456789' };
+      const data = {mobile: '123456789'}
       const rules: RuleDescription<typeof data> = {
-        mobile: { phone: true },
-      };
-      const result = ruleChecker(data, rules);
-      expect(result.valid).toBe(false);
+        mobile: {phone: true},
+      }
+      const result = ruleChecker(data, rules)
+      expect(result.valid).toBe(false)
       if (!result.valid) {
-        expect(result.errors).toContain('mobile 不是有效的手机号');
+        expect(result.errors).toContain('mobile 不是有效的手机号')
       }
-    });
+    })
 
     it('应该通过有效的手机号验证', () => {
-      const data = { mobile: '13812345678' };
+      const data = {mobile: '13812345678'}
       const rules: RuleDescription<typeof data> = {
-        mobile: { phone: true },
-      };
-      const result = ruleChecker(data, rules);
-      expect(result.valid).toBe(true);
-    });
-  });
+        mobile: {phone: true},
+      }
+      const result = ruleChecker(data, rules)
+      expect(result.valid).toBe(true)
+    })
+  })
 
   // ==== 数字规则测试 ====
   describe('数字规则', () => {
     it('应该验证数字最小值', () => {
-      const data = { age: 5 };
+      const data = {age: 5}
       const rules: RuleDescription<typeof data> = {
-        age: { min: 18 },
-      };
-      const result = ruleChecker(data, rules);
-      expect(result.valid).toBe(false);
+        age: {min: 18},
+      }
+      const result = ruleChecker(data, rules)
+      expect(result.valid).toBe(false)
       if (!result.valid) {
-        expect(result.errors).toContain('age 不能小于 18');
+        expect(result.errors).toContain('age 不能小于 18')
       }
-    });
+    })
 
     it('应该验证数字最大值', () => {
-      const data = { score: 105 };
+      const data = {score: 105}
       const rules: RuleDescription<typeof data> = {
-        score: { max: 100 },
-      };
-      const result = ruleChecker(data, rules);
-      expect(result.valid).toBe(false);
+        score: {max: 100},
+      }
+      const result = ruleChecker(data, rules)
+      expect(result.valid).toBe(false)
       if (!result.valid) {
-        expect(result.errors).toContain('score 不能大于 100');
+        expect(result.errors).toContain('score 不能大于 100')
       }
-    });
+    })
 
     it('应该通过数字范围验证', () => {
-      const data = { percentage: 85 };
+      const data = {percentage: 85}
       const rules: RuleDescription<typeof data> = {
-        percentage: { min: 0, max: 100 },
-      };
-      const result = ruleChecker(data, rules);
-      expect(result.valid).toBe(true);
-    });
-  });
+        percentage: {min: 0, max: 100},
+      }
+      const result = ruleChecker(data, rules)
+      expect(result.valid).toBe(true)
+    })
+  })
 
   // ==== 数组规则测试 ====
   describe('数组规则', () => {
     it('应该验证数组长度 len', () => {
-      const data = { items: [1, 2, 3] };
+      const data = {items: [1, 2, 3]}
       const rules: RuleDescription<typeof data> = {
-        items: { len: 5 },
-      };
-      const result = ruleChecker(data, rules);
-      expect(result.valid).toBe(false);
+        items: {len: 5},
+      }
+      const result = ruleChecker(data, rules)
+      expect(result.valid).toBe(false)
       if (!result.valid) {
-        expect(result.errors).toContain('items 长度必须为 5');
+        expect(result.errors).toContain('items 长度必须为 5')
       }
-    });
+    })
 
     it('应该验证数组最小长度', () => {
-      const data = { tags: ['one'] };
+      const data = {tags: ['one']}
       const rules: RuleDescription<typeof data> = {
-        tags: { min: 2 },
-      };
-      const result = ruleChecker(data, rules);
-      expect(result.valid).toBe(false);
+        tags: {min: 2},
+      }
+      const result = ruleChecker(data, rules)
+      expect(result.valid).toBe(false)
       if (!result.valid) {
-        expect(result.errors).toContain('tags 长度不能小于 2');
+        expect(result.errors).toContain('tags 长度不能小于 2')
       }
-    });
+    })
 
     it('应该验证数组最大长度', () => {
-      const data = { categories: [1, 2, 3, 4, 5, 6] };
+      const data = {categories: [1, 2, 3, 4, 5, 6]}
       const rules: RuleDescription<typeof data> = {
-        categories: { max: 5 },
-      };
-      const result = ruleChecker(data, rules);
-      expect(result.valid).toBe(false);
+        categories: {max: 5},
+      }
+      const result = ruleChecker(data, rules)
+      expect(result.valid).toBe(false)
       if (!result.valid) {
-        expect(result.errors).toContain('categories 长度不能大于 5');
+        expect(result.errors).toContain('categories 长度不能大于 5')
       }
-    });
+    })
 
     it('应该验证数组元素唯一性', () => {
-      const data = { ids: [1, 2, 2, 3] };
+      const data = {ids: [1, 2, 2, 3]}
       const rules: RuleDescription<typeof data> = {
-        ids: { unique: true },
-      };
-      const result = ruleChecker(data, rules);
-      expect(result.valid).toBe(false);
+        ids: {unique: true},
+      }
+      const result = ruleChecker(data, rules)
+      expect(result.valid).toBe(false)
       if (!result.valid) {
-        expect(result.errors).toContain('ids 元素必须唯一');
+        expect(result.errors).toContain('ids 元素必须唯一')
       }
-    });
+    })
 
     it('应该通过数组元素唯一性验证', () => {
-      const data = { ids: [1, 2, 3, 4] };
+      const data = {ids: [1, 2, 3, 4]}
       const rules: RuleDescription<typeof data> = {
-        ids: { unique: true },
-      };
-      const result = ruleChecker(data, rules);
-      expect(result.valid).toBe(true);
-    });
+        ids: {unique: true},
+      }
+      const result = ruleChecker(data, rules)
+      expect(result.valid).toBe(true)
+    })
 
     it('应该验证数组元素规则', () => {
-      const data = { emails: ['valid@email.com', 'invalid-email'] };
+      const data = {emails: ['valid@email.com', 'invalid-email']}
       const rules: RuleDescription<typeof data> = {
         emails: {
-          elementRule: { email: true },
+          elementRule: {email: true},
         },
-      };
-      const result = ruleChecker(data, rules);
-      expect(result.valid).toBe(false);
+      }
+      const result = ruleChecker(data, rules)
+      expect(result.valid).toBe(false)
       if (!result.valid) {
         // 检查错误信息包含了数组元素索引的错误
-        expect(result.errors.some((error) => error.includes('emails[1]'))).toBe(
-          true
-        );
+        expect(result.errors.some((error) => error.includes('emails[1]'))).toBe(true)
       }
-    });
-  });
+    })
+  })
 
   // ==== 依赖验证测试 ====
   describe('依赖验证', () => {
     it('应该验证 dependsOn - 返回 boolean', () => {
-      const data = { type: 'premium', discount: 0.9 };
+      const data = {type: 'premium', discount: 0.9}
       const rules: RuleDescription<typeof data> = {
         discount: {
           dependsOn: (data) => data.type === 'basic', // 当类型不是basic时会失败
           message: '只有基础用户才能设置折扣',
         },
-      };
-      const result = ruleChecker(data, rules);
-      expect(result.valid).toBe(false);
+      }
+      const result = ruleChecker(data, rules)
+      expect(result.valid).toBe(false)
       if (!result.valid) {
-        expect(result.errors).toContain('只有基础用户才能设置折扣');
+        expect(result.errors).toContain('只有基础用户才能设置折扣')
       }
-    });
+    })
 
     it('应该验证 dependsOn - 返回 string', () => {
-      const data = { age: 16, hasLicense: true };
+      const data = {age: 16, hasLicense: true}
       const rules: RuleDescription<typeof data> = {
         hasLicense: {
-          dependsOn: (data) =>
-            (data.age || 0) < 18 ? '未成年人不能有驾驶证' : true,
+          dependsOn: (data) => ((data.age || 0) < 18 ? '未成年人不能有驾驶证' : true),
         },
-      };
-      const result = ruleChecker(data, rules);
-      expect(result.valid).toBe(false);
+      }
+      const result = ruleChecker(data, rules)
+      expect(result.valid).toBe(false)
       if (!result.valid) {
-        expect(result.errors).toContain('未成年人不能有驾驶证');
+        expect(result.errors).toContain('未成年人不能有驾驶证')
       }
-    });
+    })
 
     it('应该通过 dependsOn 验证', () => {
-      const data = { type: 'basic', discount: undefined };
+      const data = {type: 'basic', discount: undefined}
       const rules: RuleDescription<typeof data> = {
         discount: {
           dependsOn: (data) => data.type === 'premium',
         },
-      };
-      const result = ruleChecker(data, rules);
-      expect(result.valid).toBe(true);
-    });
-  });
+      }
+      const result = ruleChecker(data, rules)
+      expect(result.valid).toBe(true)
+    })
+  })
 
   // ==== 复杂场景测试 ====
   describe('复杂场景', () => {
     it('应该处理多个规则数组', () => {
-      const data = { password: '123' };
+      const data = {password: '123'}
       const rules: RuleDescription<typeof data> = {
         password: [
-          { required: true },
-          { min: 6, message: '密码至少6位' },
-          { regex: /[A-Z]/, message: '密码必须包含大写字母' },
+          {required: true},
+          {min: 6, message: '密码至少6位'},
+          {regex: /[A-Z]/, message: '密码必须包含大写字母'},
         ],
-      };
-      const result = ruleChecker(data, rules);
-      expect(result.valid).toBe(false);
+      }
+      const result = ruleChecker(data, rules)
+      expect(result.valid).toBe(false)
       if (!result.valid) {
-        expect(result.errors).toContain('密码至少6位');
-        expect(result.errors).toContain('密码必须包含大写字母');
+        expect(result.errors).toContain('密码至少6位')
+        expect(result.errors).toContain('密码必须包含大写字母')
       }
-    });
+    })
 
     it('应该收集多个字段的错误', () => {
-      const data = { name: '', email: 'invalid', age: 5 };
-      const rules: RuleDescription<typeof data> = {
-        name: { required: true },
-        email: { email: true },
-        age: { min: 18 },
-      };
-      const result = ruleChecker(data, rules);
-      expect(result.valid).toBe(false);
+      const data = {name: '', email: 'invalid', age: 5}
+      const rules: RuleDescription<typeof data> = {
+        name: {required: true},
+        email: {email: true},
+        age: {min: 18},
+      }
+      const result = ruleChecker(data, rules)
+      expect(result.valid).toBe(false)
       if (!result.valid) {
-        expect(result.errors).toHaveLength(3);
-        expect(result.fieldErrors.name).toContain('name 为必填项');
-        expect(result.fieldErrors.email).toContain('email 不是有效的邮箱');
-        expect(result.fieldErrors.age).toContain('age 不能小于 18');
+        expect(result.errors).toHaveLength(3)
+        expect(result.fieldErrors.name).toContain('name 为必填项')
+        expect(result.fieldErrors.email).toContain('email 不是有效的邮箱')
+        expect(result.fieldErrors.age).toContain('age 不能小于 18')
       }
-    });
+    })
 
     it('应该处理复杂的用户注册场景', () => {
       const data = {
@@ -412,86 +408,77 @@ describe('ruleChecker', () => {
         age: 25,
         hobbies: ['reading'],
         terms: false,
-      };
+      }
 
       const rules: RuleDescription<typeof data> = {
-        username: { required: true, min: 3, max: 20 },
-        email: { required: true, email: true },
-        password: [
-          { required: true },
-          { min: 6 },
-          { regex: /[A-Z]/, message: '密码必须包含大写字母' },
-        ],
+        username: {required: true, min: 3, max: 20},
+        email: {required: true, email: true},
+        password: [{required: true}, {min: 6}, {regex: /[A-Z]/, message: '密码必须包含大写字母'}],
         confirmPassword: {
           required: true,
-          validator: (value, data) =>
-            value === data.password || '两次密码不一致',
+          validator: (value, data) => value === data.password || '两次密码不一致',
         },
-        age: { required: true, min: 18, max: 120 },
-        hobbies: { min: 2, max: 5 },
+        age: {required: true, min: 18, max: 120},
+        hobbies: {min: 2, max: 5},
         terms: {
           required: true,
           validator: (value) => value === true || '必须同意用户协议',
         },
-      };
+      }
 
-      const result = ruleChecker(data, rules);
-      expect(result.valid).toBe(false);
+      const result = ruleChecker(data, rules)
+      expect(result.valid).toBe(false)
       if (!result.valid) {
-        expect(result.fieldErrors.username).toContain(
-          'username 长度不能少于 3'
-        );
-        expect(result.fieldErrors.password).toContain(
-          'password 长度不能少于 6'
-        );
-        expect(result.fieldErrors.confirmPassword).toContain('两次密码不一致');
-        expect(result.fieldErrors.hobbies).toContain('hobbies 长度不能小于 2');
-        expect(result.fieldErrors.terms).toContain('必须同意用户协议');
-      }
-    });
+        expect(result.fieldErrors.username).toContain('username 长度不能少于 3')
+        expect(result.fieldErrors.password).toContain('password 长度不能少于 6')
+        expect(result.fieldErrors.confirmPassword).toContain('两次密码不一致')
+        expect(result.fieldErrors.hobbies).toContain('hobbies 长度不能小于 2')
+        expect(result.fieldErrors.terms).toContain('必须同意用户协议')
+      }
+    })
 
     it('应该在所有验证通过时返回正确的数据', () => {
       const data = {
         name: 'John Doe',
         email: 'john@example.com',
         age: 30,
-      };
+      }
 
       const rules: RuleDescription<typeof data> = {
-        name: { required: true, min: 2 },
-        email: { required: true, email: true },
-        age: { required: true, min: 18, max: 120 },
-      };
+        name: {required: true, min: 2},
+        email: {required: true, email: true},
+        age: {required: true, min: 18, max: 120},
+      }
 
-      const result = ruleChecker(data, rules);
-      expect(result.valid).toBe(true);
+      const result = ruleChecker(data, rules)
+      expect(result.valid).toBe(true)
       if (result.valid) {
-        expect(result.data).toEqual(data);
+        expect(result.data).toEqual(data)
       }
-    });
-  });
+    })
+  })
 
   // ==== 类型安全测试 ====
   describe('类型安全验证', () => {
     it('数字字段应该只支持数字相关规则', () => {
-      const data = { age: 25 };
+      const data = {age: 25}
 
       // 这些应该是有效的数字规则
       const validRules: RuleDescription<typeof data> = {
-        age: { min: 0, max: 120, required: true },
-      };
+        age: {min: 0, max: 120, required: true},
+      }
 
-      const result = ruleChecker(data, validRules);
-      expect(result.valid).toBe(true);
+      const result = ruleChecker(data, validRules)
+      expect(result.valid).toBe(true)
 
       // 注意：TypeScript 会阻止以下无效的数字规则
       // age: { email: true }, // ❌ 编译错误
       // age: { regex: /test/ }, // ❌ 编译错误
       // age: { len: 10 }, // ❌ 编译错误
-    });
+    })
 
     it('字符串字段应该支持长度和格式规则', () => {
-      const data = { email: 'test@example.com', name: 'John' };
+      const data = {email: 'test@example.com', name: 'John'}
 
       const rules: RuleDescription<typeof data> = {
         email: {
@@ -506,35 +493,35 @@ describe('ruleChecker', () => {
           max: 50,
           regex: /^[a-zA-Z]+$/,
         },
-      };
+      }
 
-      const result = ruleChecker(data, rules);
-      expect(result.valid).toBe(true);
-    });
+      const result = ruleChecker(data, rules)
+      expect(result.valid).toBe(true)
+    })
 
     it('数组字段应该支持长度和唯一性规则', () => {
-      const data = { tags: ['react', 'typescript'], ids: [1, 2, 3] };
+      const data = {tags: ['react', 'typescript'], ids: [1, 2, 3]}
 
       const rules: RuleDescription<typeof data> = {
         tags: {
           min: 1,
           max: 5,
           unique: true,
-          elementRule: { min: 2, max: 20 }, // 元素是字符串
+          elementRule: {min: 2, max: 20}, // 元素是字符串
         },
         ids: {
           len: 3,
           unique: true,
-          elementRule: { min: 1, max: 1000 }, // 元素是数字
+          elementRule: {min: 1, max: 1000}, // 元素是数字
         },
-      };
+      }
 
-      const result = ruleChecker(data, rules);
-      expect(result.valid).toBe(true);
-    });
+      const result = ruleChecker(data, rules)
+      expect(result.valid).toBe(true)
+    })
 
     it('布尔字段应该只支持基础规则', () => {
-      const data = { isActive: false, hasPermission: false };
+      const data = {isActive: false, hasPermission: false}
 
       const rules: RuleDescription<typeof data> = {
         isActive: {
@@ -544,14 +531,14 @@ describe('ruleChecker', () => {
         hasPermission: {
           required: true,
         },
-      };
+      }
 
-      const result = ruleChecker(data, rules);
-      expect(result.valid).toBe(false);
+      const result = ruleChecker(data, rules)
+      expect(result.valid).toBe(false)
       if (!result.valid) {
-        expect(result.errors).toContain('必须激活账户');
+        expect(result.errors).toContain('必须激活账户')
       }
-    });
+    })
 
     it('应该正确处理混合类型的复杂对象', () => {
       const data = {
@@ -561,89 +548,89 @@ describe('ruleChecker', () => {
         tags: ['electronics', 'mobile'],
         isActive: true,
         description: 'A great product',
-      };
+      }
 
       const rules: RuleDescription<typeof data> = {
-        id: { required: true, min: 1 }, // 数字规则
-        name: { required: true, min: 3, max: 50 }, // 字符串长度规则
-        price: { required: true, min: 0, max: 10000 }, // 数字范围规则
-        tags: { min: 1, max: 10, unique: true }, // 数组规则
-        isActive: { required: true }, // 布尔基础规则
-        description: { min: 10, max: 500, regex: /^[a-zA-Z\s]+$/ }, // 字符串格式规则
-      };
+        id: {required: true, min: 1}, // 数字规则
+        name: {required: true, min: 3, max: 50}, // 字符串长度规则
+        price: {required: true, min: 0, max: 10000}, // 数字范围规则
+        tags: {min: 1, max: 10, unique: true}, // 数组规则
+        isActive: {required: true}, // 布尔基础规则
+        description: {min: 10, max: 500, regex: /^[a-zA-Z\s]+$/}, // 字符串格式规则
+      }
 
-      const result = ruleChecker(data, rules);
-      expect(result.valid).toBe(true);
-    });
-  });
+      const result = ruleChecker(data, rules)
+      expect(result.valid).toBe(true)
+    })
+  })
 
   // ==== 边缘情况测试 ====
   describe('边缘情况', () => {
     it('应该正确处理空字符串的各种验证', () => {
-      const data = { text: '' };
+      const data = {text: ''}
       const rules: RuleDescription<typeof data> = {
-        text: { min: 1 }, // 空字符串长度为0，应该失败
-      };
-      const result = ruleChecker(data, rules);
-      expect(result.valid).toBe(false);
-    });
+        text: {min: 1}, // 空字符串长度为0，应该失败
+      }
+      const result = ruleChecker(data, rules)
+      expect(result.valid).toBe(false)
+    })
 
     it('应该正确处理空数组的各种验证', () => {
-      const data = { items: [] as string[] };
+      const data = {items: [] as string[]}
       const rules: RuleDescription<typeof data> = {
-        items: { min: 1 }, // 空数组长度为0，应该失败
-      };
-      const result = ruleChecker(data, rules);
-      expect(result.valid).toBe(false);
-    });
+        items: {min: 1}, // 空数组长度为0，应该失败
+      }
+      const result = ruleChecker(data, rules)
+      expect(result.valid).toBe(false)
+    })
 
     it('应该正确处理数字 0 的验证', () => {
-      const data = { count: 0 };
+      const data = {count: 0}
       const rules: RuleDescription<typeof data> = {
-        count: { required: true, min: 0 }, // 0 是有效值，应该通过
-      };
-      const result = ruleChecker(data, rules);
-      expect(result.valid).toBe(true);
-    });
+        count: {required: true, min: 0}, // 0 是有效值，应该通过
+      }
+      const result = ruleChecker(data, rules)
+      expect(result.valid).toBe(true)
+    })
 
     it('应该正确处理 false 值的验证', () => {
-      const data = { isEnabled: false };
+      const data = {isEnabled: false}
       const rules: RuleDescription<typeof data> = {
-        isEnabled: { required: true }, // false 是有效值，应该通过
-      };
-      const result = ruleChecker(data, rules);
-      expect(result.valid).toBe(true);
-    });
+        isEnabled: {required: true}, // false 是有效值，应该通过
+      }
+      const result = ruleChecker(data, rules)
+      expect(result.valid).toBe(true)
+    })
 
     it('应该正确处理只有空格的字符串', () => {
-      const data = { text: '   ' };
+      const data = {text: '   '}
       const rules: RuleDescription<typeof data> = {
-        text: { required: true }, // 只有空格被视为空值，应该失败
-      };
-      const result = ruleChecker(data, rules);
-      expect(result.valid).toBe(false);
-    });
+        text: {required: true}, // 只有空格被视为空值，应该失败
+      }
+      const result = ruleChecker(data, rules)
+      expect(result.valid).toBe(false)
+    })
 
     it('应该处理非常长的字符串', () => {
-      const longText = 'a'.repeat(1000);
-      const data = { content: longText };
+      const longText = 'a'.repeat(1000)
+      const data = {content: longText}
       const rules: RuleDescription<typeof data> = {
-        content: { max: 500 }, // 超过最大长度，应该失败
-      };
-      const result = ruleChecker(data, rules);
-      expect(result.valid).toBe(false);
+        content: {max: 500}, // 超过最大长度，应该失败
+      }
+      const result = ruleChecker(data, rules)
+      expect(result.valid).toBe(false)
       if (!result.valid) {
-        expect(result.errors).toContain('content 长度不能超过 500');
+        expect(result.errors).toContain('content 长度不能超过 500')
       }
-    });
+    })
 
     it('应该处理复杂的嵌套数组元素验证', () => {
       const data = {
         users: [
-          { name: 'Alice', email: 'alice@test.com' },
-          { name: 'B', email: 'invalid-email' }, // 名字太短，邮箱无效
+          {name: 'Alice', email: 'alice@test.com'},
+          {name: 'B', email: 'invalid-email'}, // 名字太短，邮箱无效
         ],
-      };
+      }
 
       // 注意：这个例子展示了当前系统的限制
       // 对于复杂嵌套对象，需要扩展 elementRule 支持
@@ -653,10 +640,10 @@ describe('ruleChecker', () => {
           max: 10,
           // elementRule 目前不支持对象验证
         },
-      };
+      }
 
-      const result = ruleChecker(data, rules);
-      expect(result.valid).toBe(true); // 基本数组规则通过
-    });
-  });
-});
+      const result = ruleChecker(data, rules)
+      expect(result.valid).toBe(true) // 基本数组规则通过
+    })
+  })
+})