pa-ruler-factory 0.0.14

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 puijs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,297 @@
+# ruler-factory
+
+[English](./README.md) · [简体中文](./README.zh-CN.md)
+
+A flexible, chainable validation rule factory for TypeScript/JavaScript.
+
+## Features
+
+- Chainable API for building complex validation rules
+- Supports string, number, array, boolean, object, symbol, bigint, null, undefined
+- Customizable error messages
+- Easy to extend and integrate
+- TypeScript support
+
+## Installation
+
+```bash
+pnpm add ruler-factory
+# or
+npm install ruler-factory
+# or
+yarn add ruler-factory
+```
+
+## Integration with UI frameworks
+
+### Pui UI
+
+```vue
+<script setup lang="ts">
+import { ref } from 'vue'
+import { rulerFactory } from 'ruler-factory'
+
+const r = rulerFactory((validator) => {
+  return (value) => {
+    const e = validator(value)
+    return e ? e.message : true
+  }
+})
+
+const model = ref({
+  name: '',
+  email: '',
+})
+</script>
+
+<template>
+  <var-form>
+    <var-input
+      v-model="model.name"
+      placeholder="Name"
+      :rules="r().required('Required').min(2, 'Wrong length').done()"
+    />
+    <var-input v-model="model.age" placeholder="Email" :rules="r().email('Must be email format').done()" />
+  </var-form>
+</template>
+```
+
+### Vant
+
+```vue
+<script setup lang="ts">
+import { ref } from 'vue'
+import { rulerFactory } from 'ruler-factory'
+import type { FieldRule } from 'vant'
+
+const r = rulerFactory<FieldRule>((validator, params) => ({
+  validator(value) {
+    const e = validator(value)
+
+    return e ? e.message : true
+  },
+  trigger: ['onChange', 'onBlur', 'onSubmit'],
+  ...params,
+}))
+
+const model = ref({
+  name: '',
+  email: '',
+})
+</script>
+
+<template>
+  <van-form>
+    <van-cell-group inset>
+      <van-field v-model="model.name" label="Name" placeholder="Name" :rules="r().required('Required').done()" />
+      <van-field
+        v-model="model.email"
+        label="Email"
+        placeholder="Email"
+        :rules="r().email('Must be email format').done()"
+      />
+    </van-cell-group>
+  </van-form>
+</template>
+```
+
+### Naive UI
+
+```vue
+<script setup lang="ts">
+import { ref } from 'vue'
+import type { FormItemRule } from 'naive-ui'
+import { rulerFactory } from 'ruler-factory'
+
+const r = rulerFactory<FormItemRule>((validator, params = {}) => ({
+  trigger: ['blur', 'change', 'input'],
+  validator: (_, value) => validator(value),
+  ...params,
+}))
+
+const model = ref({
+  name: '',
+  age: 20,
+})
+</script>
+
+<template>
+  <n-form :model>
+    <n-form-item path="name" label="Name" :rule="r().required('Required').min(2, 'Wrong length').done()">
+      <n-input v-model:value="model.name" />
+    </n-form-item>
+    <n-form-item path="age" label="Age" :rule="r().number().required('Required').negative('Must be negative').done()">
+      <n-input-number v-model:value="model.age" />
+    </n-form-item>
+  </n-form>
+</template>
+```
+
+### Element Plus
+
+```vue
+<script setup lang="ts">
+import { ref } from 'vue'
+import type { FormItemRule } from 'element-plus'
+import { rulerFactory } from 'ruler-factory'
+
+const r = rulerFactory<FormItemRule>((validator, params) => ({
+  validator(_, value, callback) {
+    const e = validator(value)
+
+    e ? callback(e) : callback()
+  },
+  trigger: ['blur', 'change', 'input'],
+  ...params,
+}))
+
+const model = ref({
+  name: '',
+  email: '',
+})
+</script>
+
+<template>
+  <el-form :model>
+    <el-form-item prop="name" label="Name" :rules="r().required('Required').done()">
+      <el-input v-model="model.name" />
+    </el-form-item>
+    <el-form-item prop="email" label="Email" :rules="r().email('Must be email format').done()">
+      <el-input v-model="model.email" />
+    </el-form-item>
+  </el-form>
+</template>
+```
+
+### Extend API
+
+Take `Naive UI` as an example
+
+```ts
+import { FormItemRule } from 'naive-ui'
+import { RulerContext, rulerFactory, RulerFactoryMessage } from 'ruler-factory'
+
+interface RulerExtendedContext {
+  ip(message: RulerFactoryMessage, params?: FormItemRule): RulerContext<FormItemRule, FormItemRule, this>
+}
+
+const r = rulerFactory<FormItemRule, FormItemRule, RulerExtendedContext>(
+  (validator, params = {}) => ({
+    trigger: ['blur', 'change', 'input'],
+    validator: (_, value) => validator(value),
+    ...params,
+  }),
+  (ctx) => {
+    function ip(message: RulerFactoryMessage, params?: FormItemRule) {
+      ctx.addRule((value) => {
+        // Implement isString and isIP by yourself
+        if (!isString(value) || !isIP(value)) {
+          return new Error(ctx.getMessage(message))
+        }
+      }, params)
+
+      return ctx
+    }
+
+    return { ip }
+  },
+)
+
+r().ip('ip format error').done()
+```
+
+## API
+
+### Types Validation
+
+- `.string(message?, params?)`
+- `.number(message?, params?)`
+- `.array(message?, params?)`
+- `.boolean(message?, params?)`
+- `.object(message?, params?)`
+- `.symbol(message?, params?)`
+- `.bigint(message?, params?)`
+- `.null(message?, params?)`
+- `.undefined(message?, params?)`
+- `.true(message?, params?)`
+- `.false(message?, params?)`
+
+### Non Empty Validation
+
+- `.required(message)`
+
+### String Validation
+
+- `.min(value, message, params?)`
+- `.max(value, message, params?)`
+- `.length(value, message, params?)`
+- `.regex(regexp, message, params?)`
+- `.startsWith(value, message, params?)`
+- `.endsWith(value, message, params?)`
+- `.includes(value, message, params?)`
+- `.uppercase(message, params?)`
+- `.lowercase(message, params?)`
+- `.email(message, params?)`
+
+### Number Validation
+
+- `.number().min(value, message, params?)`
+- `.number().max(value, message, params?)`
+- `.number().gt(value, message, params?)`
+- `.number().gte(value, message, params?)` alias .min
+- `.number().lt(value, message, params?)`
+- `.number().lte(value, message, params?)` alias .max
+- `.number().positive(value, message, params?)`
+- `.number().negative(value, message, params?)`
+
+### Bigint Validation
+
+- `.bigint().min(value, message, params?)`
+- `.bigint().max(value, message, params?)`
+- `.bigint().gt(value, message, params?)`
+- `.bigint().gte(value, message, params?)` alias .min
+- `.bigint().lt(value, message, params?)`
+- `.bigint().lte(value, message, params?)` alias .max
+- `.bigint().positive(value, message, params?)`
+- `.bigint().negative(value, message, params?)`
+
+### Array Validation
+
+- `.array().min(value, message, params?)`
+- `.array().max(value, message, params?)`
+- `.array().length(value, message, params?)`
+- `.array().includes(value, message, params?)`
+
+### Predicate Validation
+
+- `.is(fn, message, params?)`
+- `.not(fn, message, params?)`
+
+### Complete rule building
+
+- `.done()`
+
+### Custom Rule
+
+- `.addRule(validator)`
+
+### Value Transformer
+
+- `.trim()`
+- `.toLowerCase()`
+- `.toUpperCase()`
+- `.transform(fn)`
+
+## License
+
+MIT
+
+## Links
+
+- [GitHub Repository](https://github.com/puijs/ruler-factory)
+- [Issues](https://github.com/puijs/ruler-factory/issues)
+
+## Inspired By
+
+[`zod`](https://zod.dev/)
+[`yup`](https://github.com/jquense/yup)

package/README.zh-CN.md

@@ -0,0 +1,288 @@
+# ruler-factory
+
+[English](./README.md) · [简体中文](./README.zh-CN.md)
+
+一个灵活、可链式调用的 TypeScript/JavaScript 校验规则工厂。
+
+## 特性
+
+- 链式 API，可构建复杂校验规则
+- 支持 string、number、array、boolean、object、symbol、bigint、null、undefined
+- 可自定义错误信息
+- 易于扩展与集成
+- 支持 TypeScript
+
+## 安装
+
+```bash
+pnpm add ruler-factory
+# 或
+npm install ruler-factory
+# 或
+yarn add ruler-factory
+```
+
+## 与 UI 框架集成
+
+### Pui UI
+
+```vue
+<script setup lang="ts">
+import { ref } from 'vue'
+import { rulerFactory } from 'ruler-factory'
+
+const r = rulerFactory((validator) => {
+  return (value) => {
+    const e = validator(value)
+    return e ? e.message : true
+  }
+})
+
+const model = ref({
+  name: '',
+  email: '',
+})
+</script>
+
+<template>
+  <var-form>
+    <var-input v-model="model.name" placeholder="姓名" :rules="r().required('必填').min(2, '长度不正确').done()" />
+    <var-input v-model="model.age" placeholder="邮箱" :rules="r().email('必须是邮箱格式').done()" />
+  </var-form>
+</template>
+```
+
+### Vant
+
+```vue
+<script setup lang="ts">
+import { ref } from 'vue'
+import { rulerFactory } from 'ruler-factory'
+import type { FieldRule } from 'vant'
+
+const r = rulerFactory<FieldRule>((validator, params) => ({
+  validator(value) {
+    const e = validator(value)
+
+    return e ? e.message : true
+  },
+  trigger: ['onChange', 'onBlur', 'onSubmit'],
+  ...params,
+}))
+
+const model = ref({
+  name: '',
+  email: '',
+})
+</script>
+
+<template>
+  <van-form>
+    <van-cell-group inset>
+      <van-field v-model="model.name" label="姓名" placeholder="姓名" :rules="r().required('必填').done()" />
+      <van-field v-model="model.email" label="邮箱" placeholder="邮箱" :rules="r().email('必须是邮箱格式').done()" />
+    </van-cell-group>
+  </van-form>
+</template>
+```
+
+### Naive UI
+
+```vue
+<script setup lang="ts">
+import { ref } from 'vue'
+import type { FormItemRule } from 'naive-ui'
+import { rulerFactory } from 'ruler-factory'
+
+const r = rulerFactory<FormItemRule>((validator, params = {}) => ({
+  trigger: ['blur', 'change', 'input'],
+  validator: (_, value) => validator(value),
+  ...params,
+}))
+
+const model = ref({
+  name: '',
+  age: 20,
+})
+</script>
+
+<template>
+  <n-form :model>
+    <n-form-item path="name" label="姓名" :rule="r().required('必填').min(2, '长度不正确').done()">
+      <n-input v-model:value="model.name" />
+    </n-form-item>
+    <n-form-item path="age" label="年龄" :rule="r().number().required('必填').negative('必须为负数').done()">
+      <n-input-number v-model:value="model.age" />
+    </n-form-item>
+  </n-form>
+</template>
+```
+
+### Element Plus
+
+```vue
+<script setup lang="ts">
+import { ref } from 'vue'
+import type { FormItemRule } from 'element-plus'
+import { rulerFactory } from 'ruler-factory'
+
+const r = rulerFactory<FormItemRule>((validator, params) => ({
+  validator(_, value, callback) {
+    const e = validator(value)
+
+    e ? callback(e) : callback()
+  },
+  trigger: ['blur', 'change', 'input'],
+  ...params,
+}))
+
+const model = ref({
+  name: '',
+  email: '',
+})
+</script>
+
+<template>
+  <el-form :model>
+    <el-form-item prop="name" label="姓名" :rules="r().required('必填').done()">
+      <el-input v-model="model.name" />
+    </el-form-item>
+    <el-form-item prop="email" label="邮箱" :rules="r().email('必须是邮箱格式').done()">
+      <el-input v-model="model.email" />
+    </el-form-item>
+  </el-form>
+</template>
+```
+
+### 扩展 API
+
+以 Naive UI 为例
+
+```ts
+import { FormItemRule } from 'naive-ui'
+import { RulerContext, rulerFactory, RulerFactoryMessage } from 'ruler-factory'
+
+interface RulerExtendedContext {
+  ip(message: RulerFactoryMessage, params?: FormItemRule): RulerContext<FormItemRule, FormItemRule, this>
+}
+
+const r = rulerFactory<FormItemRule, FormItemRule, RulerExtendedContext>(
+  (validator, params = {}) => ({
+    trigger: ['blur', 'change', 'input'],
+    validator: (_, value) => validator(value),
+    ...params,
+  }),
+  (ctx) => {
+    function ip(message: RulerFactoryMessage, params?: FormItemRule) {
+      ctx.addRule((value) => {
+        // 自行实现 isString 和 isIP
+        if (!isString(value) || !isIP(value)) {
+          return new Error(ctx.getMessage(message))
+        }
+      }, params)
+
+      return ctx
+    }
+
+    return { ip }
+  },
+)
+
+r().ip('IP 格式错误').done()
+```
+
+## API
+
+### 类型校验
+
+- `.string(message?, params?)`
+- `.number(message?, params?)`
+- `.array(message?, params?)`
+- `.boolean(message?, params?)`
+- `.object(message?, params?)`
+- `.symbol(message?, params?)`
+- `.bigint(message?, params?)`
+- `.null(message?, params?)`
+- `.undefined(message?, params?)`
+- `.true(message?, params?)`
+- `.false(message?, params?)`
+
+### 非空校验
+
+- `.required(message)`
+
+### 字符串校验
+
+- `.min(value, message, params?)`
+- `.max(value, message, params?)`
+- `.length(value, message, params?)`
+- `.regex(regexp, message, params?)`
+- `.startsWith(value, message, params?)`
+- `.endsWith(value, message, params?)`
+- `.includes(value, message, params?)`
+- `.uppercase(message, params?)`
+- `.lowercase(message, params?)`
+- `.email(message, params?)`
+
+### 数字校验
+
+- `.number().min(value, message, params?)`
+- `.number().max(value, message, params?)`
+- `.number().gt(value, message, params?)`
+- `.number().gte(value, message, params?)` 别名 .min
+- `.number().lt(value, message, params?)`
+- `.number().lte(value, message, params?)` 别名 .max
+- `.number().positive(value, message, params?)`
+- `.number().negative(value, message, params?)`
+
+### Bigint 校验
+
+- `.bigint().min(value, message, params?)`
+- `.bigint().max(value, message, params?)`
+- `.bigint().gt(value, message, params?)`
+- `.bigint().gte(value, message, params?)` 别名 .min
+- `.bigint().lt(value, message, params?)`
+- `.bigint().lte(value, message, params?)` 别名 .max
+- `.bigint().positive(value, message, params?)`
+- `.bigint().negative(value, message, params?)`
+
+### 数组校验
+
+- `.array().min(value, message, params?)`
+- `.array().max(value, message, params?)`
+- `.array().length(value, message, params?)`
+- `.array().includes(value, message, params?)`
+
+### 谓词校验
+
+- `.is(fn, message, params?)`
+- `.not(fn, message, params?)`
+
+### 完成规则构建
+
+- `.done()`
+
+### 自定义规则
+
+- `.addRule(validator)`
+
+### 值转换
+
+- `.trim()`
+- `.toLowerCase()`
+- `.toUpperCase()`
+- `.transform(fn)`
+
+## 许可证
+
+MIT
+
+## 链接
+
+- [GitHub 仓库](https://github.com/puijs/ruler-factory)
+- [Issues](https://github.com/puijs/ruler-factory/issues)
+
+## 灵感来源
+
+[`zod`](https://zod.dev/)
+[`yup`](https://github.com/jquense/yup)

package/dist/index.d.mts

@@ -0,0 +1,55 @@
+//#region src/index.d.ts
+type RulerFactoryMessage = string | (() => string);
+type RulerFactoryValidator = (value: any) => undefined | Error;
+type RulerFactoryGenerator<R, P> = (validator: RulerFactoryValidator, params?: P) => R;
+type RulerContext<R, P, E> = Omit<{
+  rules: R[];
+  addRule: (validator: RulerFactoryValidator, params?: P) => RulerContext<R, P, E>;
+  generator: RulerFactoryGenerator<R, P>;
+  getMessage: (message: RulerFactoryMessage) => string;
+  type: string;
+  string: (message?: RulerFactoryMessage, params?: P) => RulerContext<R, P, E>;
+  number: (message?: RulerFactoryMessage, params?: P) => RulerContext<R, P, E>;
+  array: (message?: RulerFactoryMessage, params?: P) => RulerContext<R, P, E>;
+  boolean: (message?: RulerFactoryMessage, params?: P) => RulerContext<R, P, E>;
+  object: (message?: RulerFactoryMessage, params?: P) => RulerContext<R, P, E>;
+  symbol: (message?: RulerFactoryMessage, params?: P) => RulerContext<R, P, E>;
+  bigint: (message?: RulerFactoryMessage, params?: P) => RulerContext<R, P, E>;
+  null: (message?: RulerFactoryMessage, params?: P) => RulerContext<R, P, E>;
+  undefined: (message?: RulerFactoryMessage, params?: P) => RulerContext<R, P, E>;
+  true: (message?: RulerFactoryMessage, params?: P) => RulerContext<R, P, E>;
+  false: (message?: RulerFactoryMessage, params?: P) => RulerContext<R, P, E>;
+  length: (v: number, message: RulerFactoryMessage, params?: P) => RulerContext<R, P, E>;
+  min: (v: number | bigint, message: RulerFactoryMessage, params?: P) => RulerContext<R, P, E>;
+  max: (v: number | bigint, message: RulerFactoryMessage, params?: P) => RulerContext<R, P, E>;
+  regex: (v: RegExp, message: RulerFactoryMessage, params?: P) => RulerContext<R, P, E>;
+  required: (message: RulerFactoryMessage, params?: P) => RulerContext<R, P, E>;
+  startsWith: (v: string, message: RulerFactoryMessage, params?: P) => RulerContext<R, P, E>;
+  endsWith: (v: string, message: RulerFactoryMessage, params?: P) => RulerContext<R, P, E>;
+  includes: (v: string, message: RulerFactoryMessage, params?: P) => RulerContext<R, P, E>;
+  uppercase: (message: RulerFactoryMessage, params?: P) => RulerContext<R, P, E>;
+  lowercase: (message: RulerFactoryMessage, params?: P) => RulerContext<R, P, E>;
+  email: (message: RulerFactoryMessage, params?: P) => RulerContext<R, P, E>;
+  gt: (v: number | bigint, message: RulerFactoryMessage, params?: P) => RulerContext<R, P, E>;
+  gte: (v: number | bigint, message: RulerFactoryMessage, params?: P) => RulerContext<R, P, E>;
+  lt: (v: number | bigint, message: RulerFactoryMessage, params?: P) => RulerContext<R, P, E>;
+  lte: (v: number | bigint, message: RulerFactoryMessage, params?: P) => RulerContext<R, P, E>;
+  positive: (message: RulerFactoryMessage, params?: P) => RulerContext<R, P, E>;
+  negative: (message: RulerFactoryMessage, params?: P) => RulerContext<R, P, E>;
+  uniq: (message: RulerFactoryMessage, params?: P) => RulerContext<R, P, E>;
+  uniqBy: (v: (a: any, b: any) => any, message: RulerFactoryMessage, params?: P) => RulerContext<R, P, E>;
+  is: (v: (value: any) => boolean, message: RulerFactoryMessage, params?: P) => RulerContext<R, P, E>;
+  not: (v: (value: any) => boolean, message: RulerFactoryMessage, params?: P) => RulerContext<R, P, E>;
+  done: () => R[];
+  transformer: (value: any) => any;
+  transform: (v: (value: any) => any) => void;
+  trim: () => RulerContext<R, P, E>;
+  shouldTrim: boolean;
+  toLowerCase: () => RulerContext<R, P, E>;
+  shouldToLowerCase: boolean;
+  toUpperCase: () => RulerContext<R, P, E>;
+  shouldToUpperCase: boolean;
+}, keyof E> & E;
+declare function rulerFactory<R, P = R, E extends Record<string, any> = {}>(generator: RulerFactoryGenerator<R, P>, extend?: (ctx: RulerContext<R, P, E>) => E): () => RulerContext<R, P, E>;
+//#endregion
+export { RulerContext, RulerFactoryGenerator, RulerFactoryMessage, RulerFactoryValidator, rulerFactory };

package/dist/index.mjs

@@ -0,0 +1,340 @@
+import { hasDuplicates, hasDuplicatesBy, isArray, isBoolean, isEmpty, isFunction, isNumber, isPlainObject, isString, isSymbol } from "rattail";
+//#region src/index.ts
+const EMAIL_REGEX = /^(?!\.)(?!.*\.\.)([a-z0-9_'+\-\\.]*)[a-z0-9_+-]@([a-z0-9][a-z0-9\\-]*\.)+[a-z]{2,}$/i;
+function rulerFactory(generator, extend) {
+	return function ruler() {
+		const rules = [];
+		const ctx = {
+			rules,
+			addRule,
+			generator,
+			getMessage,
+			type: "string",
+			string,
+			number,
+			array,
+			boolean,
+			object,
+			symbol,
+			bigint,
+			null: _null,
+			undefined: _undefined,
+			true: _true,
+			false: _false,
+			length,
+			min,
+			max,
+			regex,
+			required,
+			startsWith,
+			endsWith,
+			includes,
+			uppercase,
+			lowercase,
+			email,
+			gt,
+			gte,
+			lt,
+			lte,
+			positive,
+			negative,
+			uniq,
+			uniqBy,
+			is,
+			not,
+			done,
+			transformer,
+			transform,
+			trim,
+			shouldTrim: false,
+			toLowerCase,
+			shouldToLowerCase: false,
+			toUpperCase,
+			shouldToUpperCase: false
+		};
+		Object.assign(ctx, extend?.(ctx) ?? {});
+		function string(message, params) {
+			ctx.type = "string";
+			addRule((value) => {
+				if (message == null) return;
+				if (!isString(value)) return new Error(getMessage(message));
+			}, params);
+			return ctx;
+		}
+		function number(message, params) {
+			ctx.type = "number";
+			addRule((value) => {
+				if (message == null) return;
+				if (!isNumber(value)) return new Error(getMessage(message));
+			}, params);
+			return ctx;
+		}
+		function object(message, params) {
+			ctx.type = "object";
+			addRule((value) => {
+				if (message == null) return;
+				if (!isPlainObject(value)) return new Error(getMessage(message));
+			}, params);
+			return ctx;
+		}
+		function array(message, params) {
+			ctx.type = "array";
+			addRule((value) => {
+				if (message == null) return;
+				if (!isArray(value)) return new Error(getMessage(message));
+			}, params);
+			return ctx;
+		}
+		function boolean(message, params) {
+			ctx.type = "boolean";
+			addRule((value) => {
+				if (message == null) return;
+				if (!isBoolean(value)) return new Error(getMessage(message));
+			}, params);
+			return ctx;
+		}
+		function _true(message, params) {
+			ctx.type = "boolean";
+			addRule((value) => {
+				if (message == null) return;
+				if (value !== true) return new Error(getMessage(message));
+			}, params);
+			return ctx;
+		}
+		function _false(message, params) {
+			ctx.type = "boolean";
+			addRule((value) => {
+				if (message == null) return;
+				if (value !== false) return new Error(getMessage(message));
+			}, params);
+			return ctx;
+		}
+		function symbol(message, params) {
+			ctx.type = "symbol";
+			addRule((value) => {
+				if (message == null) return;
+				if (!isSymbol(value)) return new Error(getMessage(message));
+			}, params);
+			return ctx;
+		}
+		function _null(message, params) {
+			ctx.type = "null";
+			addRule((value) => {
+				if (message == null) return;
+				if (value !== null) return new Error(getMessage(message));
+			}, params);
+			return ctx;
+		}
+		function _undefined(message, params) {
+			ctx.type = "undefined";
+			addRule((value) => {
+				if (message == null) return;
+				if (value !== void 0) return new Error(getMessage(message));
+			}, params);
+			return ctx;
+		}
+		function bigint(message, params) {
+			ctx.type = "bigint";
+			addRule((value) => {
+				if (message == null) return;
+				if (typeof value !== "bigint") return new Error(getMessage(message));
+			}, params);
+			return ctx;
+		}
+		function required(message, params) {
+			addRule((value) => {
+				if (isEmpty(value)) return new Error(getMessage(message));
+			}, params);
+			return ctx;
+		}
+		function email(message, params) {
+			addRule((value) => {
+				if (ctx.type === "string" && (!isString(value) || !EMAIL_REGEX.test(value))) return new Error(getMessage(message));
+			}, params);
+			return ctx;
+		}
+		function min(v, message, params) {
+			addRule((value) => {
+				if (ctx.type === "string" && (!isString(value) || value.length < v)) return new Error(getMessage(message));
+				if (ctx.type === "number" || ctx.type === "bigint") {
+					if (!isNumber(value) && typeof value !== "bigint") return new Error(getMessage(message));
+					if (value < v) return new Error(getMessage(message));
+				}
+				if (ctx.type === "array" && (!isArray(value) || value.length < v)) return new Error(getMessage(message));
+			}, params);
+			return ctx;
+		}
+		function max(v, message, params) {
+			addRule((value) => {
+				if (ctx.type === "string" && (!isString(value) || value.length > v)) return new Error(getMessage(message));
+				if (ctx.type === "number" || ctx.type === "bigint") {
+					if (!isNumber(value) && typeof value !== "bigint") return new Error(getMessage(message));
+					if (value > v) return new Error(getMessage(message));
+				}
+				if (ctx.type === "array" && (!isArray(value) || value.length > v)) return new Error(getMessage(message));
+			}, params);
+			return ctx;
+		}
+		function length(v, message, params) {
+			addRule((value) => {
+				if (ctx.type === "string" && (!isString(value) || value.length !== v)) return new Error(getMessage(message));
+				if (ctx.type === "array" && (!isArray(value) || value.length !== v)) return new Error(getMessage(message));
+			}, params);
+			return ctx;
+		}
+		function regex(v, message, params) {
+			addRule((value) => {
+				if (ctx.type === "string" && (!isString(value) || !v.test(value))) return new Error(getMessage(message));
+			}, params);
+			return ctx;
+		}
+		function startsWith(v, message, params) {
+			addRule((value) => {
+				if (ctx.type === "string" && (!isString(value) || !value.startsWith(v))) return new Error(getMessage(message));
+			}, params);
+			return ctx;
+		}
+		function endsWith(v, message, params) {
+			addRule((value) => {
+				if (ctx.type === "string" && (!isString(value) || !value.endsWith(v))) return new Error(getMessage(message));
+			}, params);
+			return ctx;
+		}
+		function includes(v, message, params) {
+			addRule((value) => {
+				if (ctx.type === "string" && (!isString(value) || !value.includes(v))) return new Error(getMessage(message));
+				if (ctx.type === "array" && (!isArray(value) || !value.includes(v))) return new Error(getMessage(message));
+			}, params);
+			return ctx;
+		}
+		function uppercase(message, params) {
+			addRule((value) => {
+				if (ctx.type === "string" && (!isString(value) || value !== value.toUpperCase())) return new Error(getMessage(message));
+			}, params);
+			return ctx;
+		}
+		function lowercase(message, params) {
+			addRule((value) => {
+				if (ctx.type === "string" && (!isString(value) || value !== value.toLowerCase())) return new Error(getMessage(message));
+			}, params);
+			return ctx;
+		}
+		function gt(v, message, params) {
+			addRule((value) => {
+				if (ctx.type === "number" || ctx.type === "bigint") {
+					if (!isNumber(value) && typeof value !== "bigint") return new Error(getMessage(message));
+					if (value <= v) return new Error(getMessage(message));
+				}
+			}, params);
+			return ctx;
+		}
+		function gte(v, message, params) {
+			addRule((value) => {
+				if (ctx.type === "number" || ctx.type === "bigint") {
+					if (!isNumber(value) && typeof value !== "bigint") return new Error(getMessage(message));
+					if (value < v) return new Error(getMessage(message));
+				}
+			}, params);
+			return ctx;
+		}
+		function lt(v, message, params) {
+			addRule((value) => {
+				if (ctx.type === "number" || ctx.type === "bigint") {
+					if (!isNumber(value) && typeof value !== "bigint") return new Error(getMessage(message));
+					if (value >= v) return new Error(getMessage(message));
+				}
+			}, params);
+			return ctx;
+		}
+		function lte(v, message, params) {
+			addRule((value) => {
+				if (ctx.type === "number" || ctx.type === "bigint") {
+					if (!isNumber(value) && typeof value !== "bigint") return new Error(getMessage(message));
+					if (value > v) return new Error(getMessage(message));
+				}
+			}, params);
+			return ctx;
+		}
+		function positive(message, params) {
+			addRule((value) => {
+				if (ctx.type === "number" || ctx.type === "bigint") {
+					if (!isNumber(value) && typeof value !== "bigint") return new Error(getMessage(message));
+					if (value <= 0) return new Error(getMessage(message));
+				}
+			}, params);
+			return ctx;
+		}
+		function negative(message, params) {
+			addRule((value) => {
+				if (ctx.type === "number" || ctx.type === "bigint") {
+					if (!isNumber(value) && typeof value !== "bigint") return new Error(getMessage(message));
+					if (value >= 0) return new Error(getMessage(message));
+				}
+			}, params);
+			return ctx;
+		}
+		function uniq(message, params) {
+			addRule((value) => {
+				if (ctx.type === "array" && hasDuplicates(value)) return new Error(getMessage(message));
+			}, params);
+			return ctx;
+		}
+		function uniqBy(v, message, params) {
+			addRule((value) => {
+				if (ctx.type === "array" && hasDuplicatesBy(value, v)) return new Error(getMessage(message));
+			}, params);
+			return ctx;
+		}
+		function is(v, message, params) {
+			addRule((value) => {
+				if (!v(value)) return new Error(getMessage(message));
+			}, params);
+			return ctx;
+		}
+		function not(v, message, params) {
+			addRule((value) => {
+				if (v(value)) return new Error(getMessage(message));
+			}, params);
+			return ctx;
+		}
+		function trim() {
+			ctx.shouldTrim = true;
+			return ctx;
+		}
+		function toLowerCase() {
+			ctx.shouldToLowerCase = true;
+			return ctx;
+		}
+		function toUpperCase() {
+			ctx.shouldToUpperCase = true;
+			return ctx;
+		}
+		function transformer(value) {
+			if (ctx.type === "string" && isString(value)) {
+				ctx.shouldTrim && (value = value.trim());
+				ctx.shouldToLowerCase && (value = value.toLowerCase());
+				ctx.shouldToUpperCase && (value = value.toUpperCase());
+			}
+			return value;
+		}
+		function transform(v) {
+			ctx.transformer = v;
+		}
+		function addRule(validator, params) {
+			rules.push(generator((value) => {
+				value = ctx.transformer(value);
+				return validator(value);
+			}, params));
+			return ctx;
+		}
+		function done() {
+			return rules;
+		}
+		function getMessage(message) {
+			return isFunction(message) ? message() : message;
+		}
+		return ctx;
+	};
+}
+//#endregion
+export { rulerFactory };

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "pa-ruler-factory",
+  "version": "0.0.14",
+  "description": "A flexible, chainable validation rule factory for typeScript/javaScript.",
+  "keywords": [
+    "chainable",
+    "data",
+    "factory",
+    "form",
+    "javascript",
+    "rules",
+    "validation",
+    "validator"
+  ],
+  "bugs": {
+    "url": "https://github.com/puijs/ruler-factory/issues"
+  },
+  "license": "MIT",
+  "author": "haoziqaq <357229046@qq.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/puijs/ruler-factory.git"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "main": "dist/index.mjs",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.mts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
+    }
+  },
+  "scripts": {
+    "build": "vp pack",
+    "clean": "rimraf node_modules dist",
+    "dev": "vp test watch",
+    "format": "vp fmt",
+    "lint": "vp lint --fix",
+    "prepare": "vp config --hooks-dir .vite-hooks",
+    "release": "pnpm build && vr release",
+    "test": "vp test run --coverage"
+  },
+  "dependencies": {
+    "rattail": "^1.8.3"
+  },
+  "devDependencies": {
+    "@types/node": "^22.8.1",
+    "@nanawan/release": "^2.2.8",
+    "@vitest/coverage-istanbul": "^4.1.0",
+    "jsdom": "^25.0.1",
+    "rimraf": "^6.0.1",
+    "typescript": "5.3.3",
+    "vite-plus": "0.1.16",
+    "vitest": "$vitest"
+  },
+  "engines": {
+    "pnpm": ">=10.0.0"
+  },
+  "packageManager": "pnpm@10.0.0",
+  "pnpm": {
+    "overrides": {
+      "vite": "npm:@voidzero-dev/vite-plus-core@0.1.16",
+      "vitest": "npm:@voidzero-dev/vite-plus-test@0.1.16"
+    }
+  }
+}