@anjianshi/utils 2.1.7 → 2.1.9

package/env-node/logging/handlers.d.ts

@@ -30,7 +30,7 @@ export declare class ConsoleHandler extends LogHandler {
     };
     private static readonly loggerColors;
     private static readonly loggerColorMap;
-    static getLoggerColor(logger: string): "green" | "yellow" | "blue" | "cyan" | "magenta" | "greenBright" | "yellowBright" | "blueBright" | "cyanBright" | "magentaBright";
+    static getLoggerColor(logger: string): "blue" | "blueBright" | "cyan" | "cyanBright" | "green" | "greenBright" | "magenta" | "magentaBright" | "yellow" | "yellowBright";
 }
 /**
  * 写入文件日志

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anjianshi/utils",
-  "version": "2.1.7",
+  "version": "2.1.9",
   "description": "Common JavaScript Utils",
   "homepage": "https://github.com/anjianshi/js-packages/utils",
   "bugs": {
@@ -26,10 +26,10 @@
     "typeorm": "^0.3.20",
     "vconsole": "^3.15.1",
     "typescript": "^5.4.4",
-    "@anjianshi/presets-eslint-typescript": "4.0.4",
-    "@anjianshi/presets-prettier": "3.0.0",
-    "@anjianshi/presets-eslint-node": "4.0.4",
-    "@anjianshi/presets-typescript": "3.1.4"
+    "@anjianshi/presets-eslint-typescript": "5.0.2",
+    "@anjianshi/presets-prettier": "3.0.1",
+    "@anjianshi/presets-eslint-node": "4.0.5",
+    "@anjianshi/presets-typescript": "3.1.5"
   },
   "peerDependencies": {
     "chalk": "^5.3.0",

package/validators/array.d.ts

@@ -1,20 +1,28 @@
-import { Validator } from './base.js';
+import { type CommonOptions, type Validator, type Validated } from './base.js';
 /** 验证元素数量任意、元素类型相同的数组 */
-export type ArrayOptions = {
+export interface ArrayOptions extends CommonOptions {
     /** 验证数组各元素 */
-    item: Validator;
+    item: Validator<unknown, CommonOptions>;
     /** 数组最小长度 */
     min?: number;
     /** 数组最大长度 */
     max?: number;
     /** 是否对数组元素进行去重 @defaults false */
     unique?: boolean;
-};
+}
+type ArrayValues<Options extends ArrayOptions> = Validated<Options extends {
+    item: Validator<infer T, CommonOptions>;
+} ? T : never, Options extends {
+    item: Validator<unknown, infer T>;
+} ? T : never>[];
+export declare function getArrayValidator<Options extends ArrayOptions>(options: Options): Validator<ArrayValues<Options>, Options>;
 /** 验证元素数量固定、类型可以不同的数组 */
-export type TupleOptions = {
+export interface TupleOptions extends CommonOptions {
     /** 验证数组各元素（validator 与元素一一对应） */
-    tuple: Validator[];
-};
-export declare class ArrayValidator extends Validator<ArrayOptions | TupleOptions> {
-    validate(field: string, value: unknown): import("../lang/may-success.js").Failed<void> | import("../lang/may-success.js").Success<unknown>;
+    tuple: Validator<unknown, CommonOptions>[];
 }
+type TupleValues<Options extends TupleOptions> = {
+    [Key in keyof Options['tuple']]: Options['tuple'][Key] extends Validator<infer Value, infer Options> ? Validated<Value, Options> : never;
+};
+export declare function getTupleValidator<const Options extends TupleOptions>(options: Options): Validator<TupleValues<Options>, Options>;
+export {};

package/validators/array.js

@@ -1,44 +1,43 @@
 import { success, failed } from '../lang/index.js';
-import { Validator } from './base.js';
-export class ArrayValidator extends Validator {
-    validate(field, value) {
-        const superResult = super.validate(field, value);
-        if (!superResult.success)
-            return superResult;
-        value = superResult.data;
-        if (value === null || value === undefined)
-            return superResult;
-        const opt = this.options;
+import { getValidatorGenerator, } from './base.js';
+export function getArrayValidator(options) {
+    return getValidatorGenerator(function validate(field, value, options) {
         if (!Array.isArray(value))
             return failed(`${field} should be an array`);
         let formatted = [];
-        if ('item' in opt) {
-            if (typeof opt.min === 'number' && value.length < opt.min)
-                return failed(`array ${field}'s length should >= ${opt.min}`);
-            if (typeof opt.max === 'number' && value.length > opt.max)
-                return failed(`array ${field}'s length should <= ${opt.max}`);
-            for (let i = 0; i < value.length; i++) {
-                const itemResult = opt.item.validate(`${field}[${i}]`, value[i]);
-                if (itemResult.success)
-                    formatted.push(itemResult.data);
-                else
-                    return itemResult;
-            }
-            if (opt.unique === true)
-                formatted = [...new Set(formatted)];
+        if (typeof options.min === 'number' && value.length < options.min)
+            return failed(`array ${field}'s length should >= ${options.min}`);
+        if (typeof options.max === 'number' && value.length > options.max)
+            return failed(`array ${field}'s length should <= ${options.max}`);
+        const itemValidator = options.item;
+        for (let i = 0; i < value.length; i++) {
+            const itemResult = itemValidator(`${field}[${i}]`, value[i]);
+            if (itemResult.success)
+                formatted.push(itemResult.data);
+            else
+                return itemResult;
         }
-        else {
-            if (value.length > opt.tuple.length)
-                return failed(`${field} should be a tuple with ${opt.tuple.length} items`);
-            // 这种情况不能遍历 value，因为它的长度可能小于 opt.tuple
-            for (let i = 0; i < opt.tuple.length; i++) {
-                const itemResult = opt.tuple[i].validate(`${field}[${i}]`, value[i]);
-                if (itemResult.success)
-                    formatted.push(itemResult.data);
-                else
-                    return itemResult;
-            }
+        if (options.unique === true)
+            formatted = [...new Set(formatted)];
+        return success(formatted);
+    })(options);
+}
+export function getTupleValidator(options) {
+    return getValidatorGenerator(function validate(field, value, options) {
+        if (!Array.isArray(value))
+            return failed(`${field} should be an array`);
+        if (value.length > options.tuple.length)
+            return failed(`${field} should be a tuple with ${options.tuple.length} items`);
+        const formatted = [];
+        // 这种情况不能遍历 value，因为它的长度可能小于 opt.tuple
+        for (let i = 0; i < options.tuple.length; i++) {
+            const itemValidator = options.tuple[i];
+            const itemResult = itemValidator(`${field}[${i}]`, value[i]);
+            if (itemResult.success)
+                formatted.push(itemResult.data);
+            else
+                return itemResult;
         }
         return success(formatted);
-    }
+    })(options);
 }

package/validators/base.d.ts

@@ -1,26 +1,77 @@
 import { type MaySuccess } from '../lang/index.js';
-export interface BaseOptions {
-    /**
-     * 是否允许 null 值
-     * @default false
-     */
-    null: boolean;
-    /**
-     * 字段是否必须有值（不能是 undefined）
-     * @default true
-     */
-    required: boolean;
+/**
+ * 支持传入进行验证的值类型
+ */
+export type AllowedInputValue = PrimitiveType | null | undefined;
+/**
+ * JavaScript 基础值类型
+ */
+export type PrimitiveType = string | boolean | number | PrimitiveType[] | [...PrimitiveType[]] | {
+    [key: string]: PrimitiveType;
+};
+/**
+ * validator 通用参数
+ */
+export interface CommonOptions<Defaults = unknown> {
+    /** 是否允许 null 值 @default false */
+    null?: boolean;
+    /** 字段是否必须有值（不能是 undefined） @default true */
+    required?: boolean;
     /**
      * 默认值，字段无值（或值为 undefined）时生效，值为 null 不会生效。
      * 指定后 required 选项将失去作用。
      */
-    defaults: unknown;
+    defaults?: Defaults;
 }
-export declare class Validator<ExtraOptions = unknown> {
-    readonly options: BaseOptions & ExtraOptions;
-    constructor(options: Partial<BaseOptions> & ExtraOptions);
-    /**
-     * 各子类继承此方法补充验证逻辑
-     */
-    validate(field: string, value: unknown): MaySuccess<unknown>;
+/**
+ * 补全了的 Options
+ */
+type FullfiledOptions<Options extends Partial<CommonOptions>> = Omit<Options, keyof CommonOptions> & {
+    null: Options['null'] extends true ? true : false;
+    required: Options['required'] extends false ? false : true;
+    defaults: Options extends {
+        defaults: infer T;
+    } ? T : undefined;
+};
+/**
+ * 验证完成后能得到的值类型
+ */
+export type Validated<Value, InputOptions extends CommonOptions> = FullfiledOptions<InputOptions> extends {
+    defaults: undefined;
+} ? FullfiledOptions<InputOptions> extends {
+    required: false;
+    null: false;
+} ? Value | undefined : FullfiledOptions<InputOptions> extends {
+    required: false;
+    null: true;
+} ? Value | undefined | null : FullfiledOptions<InputOptions> extends {
+    required: true;
+    null: false;
+} ? Value : FullfiledOptions<InputOptions> extends {
+    required: true;
+    null: true;
+} ? Value | null : Value : FullfiledOptions<InputOptions> extends {
+    defaults: infer T;
+    null: false;
+} ? Value | T : FullfiledOptions<InputOptions> extends {
+    defaults: infer T;
+    null: true;
+} ? Value | T | null : never;
+/**
+ * 最终生成的 validator 函数类型
+ */
+export interface Validator<Value, InputOptions extends CommonOptions> {
+    (input: AllowedInputValue): MaySuccess<Validated<Value, InputOptions>>;
+    (field: string, input: AllowedInputValue): MaySuccess<Validated<Value, InputOptions>>;
 }
+/**
+ * 返回支持指定格式的 options、并按照传入的逻辑进行验证的 validator 的生成器。
+ * 对 CommonOptions 相关内容的验证以自动包含在里面，只需要传入额外的验证逻辑即可。
+ */
+export declare function getValidatorGenerator<Value, Options extends CommonOptions>(validate: (field: string, input: PrimitiveType | Validated<Value, Options>, options: Options) => MaySuccess<Value>): <const InputOptions extends Options>(inputOptions: InputOptions) => Validator<Value, InputOptions>;
+/**
+ * 返回只进行基本检查，不带定制的验证逻辑的 validator。
+ * 同时也是定制 validator 最小化实现的例子。
+ */
+export declare const getAnyValidator: <const InputOptions extends CommonOptions<unknown>>(inputOptions: InputOptions) => Validator<unknown, InputOptions>;
+export {};

package/validators/base.js

@@ -1,28 +1,40 @@
 import { success, failed } from '../lang/index.js';
-export class Validator {
-    options;
-    constructor(options) {
-        this.options = {
-            null: false,
-            required: true,
-            defaults: undefined,
-            ...options,
-        };
-    }
-    /**
-     * 各子类继承此方法补充验证逻辑
-     */
-    validate(field, value) {
-        if (typeof value === 'undefined') {
-            if (typeof this.options.defaults !== 'undefined') {
-                value = this.options.defaults;
+// -----------------------------------
+/**
+ * 返回支持指定格式的 options、并按照传入的逻辑进行验证的 validator 的生成器。
+ * 对 CommonOptions 相关内容的验证以自动包含在里面，只需要传入额外的验证逻辑即可。
+ */
+export function getValidatorGenerator(validate) {
+    return function validatorGenerator(inputOptions) {
+        function validator(field, input) {
+            const { null: allowNull = false, required = true, defaults } = inputOptions;
+            if (typeof field !== 'string') {
+                input = field;
+                field = 'value';
             }
-            else if (this.options.required) {
-                return failed(`${field} is required`);
+            let value = input;
+            if (typeof value === 'undefined') {
+                if (typeof defaults !== 'undefined') {
+                    value = defaults;
+                }
+                else if (required) {
+                    return failed(`${field} is required`);
+                }
             }
+            if (value === null && !allowNull)
+                return failed(`${field} cannot be null`);
+            if (value === null || value === undefined)
+                return success(value);
+            return validate(field, value, inputOptions);
         }
-        if (value === null && !this.options.null)
-            return failed(`${field} cannot be null`);
-        return success(value);
-    }
+        return validator;
+    };
 }
+// -----------------------------------
+/**
+ * 返回只进行基本检查，不带定制的验证逻辑的 validator。
+ * 同时也是定制 validator 最小化实现的例子。
+ */
+export const getAnyValidator = getValidatorGenerator(function validate(field, input) {
+    return success(input);
+});

package/validators/boolean.d.ts

@@ -1,4 +1,3 @@
-import { Validator } from './base.js';
-export declare class BooleanValidator extends Validator {
-    validate(field: string, value: unknown): import("../lang/may-success.js").Failed<void> | import("../lang/may-success.js").Success<unknown>;
-}
+import { type CommonOptions } from './base.js';
+export type BooleanOptions = CommonOptions<boolean>;
+export declare const getBooleanValidator: <const InputOptions extends BooleanOptions>(inputOptions: InputOptions) => import("./base.js").Validator<boolean, InputOptions>;

package/validators/boolean.js

@@ -1,28 +1,22 @@
 import { success, failed } from '../lang/index.js';
-import { Validator } from './base.js';
-export class BooleanValidator extends Validator {
-    validate(field, value) {
-        const superResult = super.validate(field, value);
-        if (!superResult.success)
-            return superResult;
-        value = superResult.data;
-        if (value === null || value === undefined)
-            return superResult;
-        if (typeof value === 'string') {
-            const str = value.trim().toLowerCase();
-            if (['1', 'true', 'on', 'yes'].includes(str))
-                value = true;
-            else if (['0', 'false', 'off', 'no'].includes(str))
-                value = false;
-        }
-        else if (typeof value === 'number') {
-            if (value === 1)
-                value = true;
-            else if (value === 0)
-                value = false;
-        }
-        if (typeof value !== 'boolean')
-            return failed(`${field} must be true or false`);
-        return success(value);
+import { getValidatorGenerator } from './base.js';
+export const getBooleanValidator = getValidatorGenerator(function validate(field, input) {
+    let value = null;
+    if (typeof input === 'boolean') {
+        value = input;
     }
-}
+    else if (typeof input === 'string') {
+        const str = input.trim().toLowerCase();
+        if (['1', 'true', 'on', 'yes'].includes(str))
+            value = true;
+        else if (['0', 'false', 'off', 'no'].includes(str))
+            value = false;
+    }
+    else if (typeof input === 'number') {
+        if (input === 1)
+            value = true;
+        else if (input === 0)
+            value = false;
+    }
+    return value === null ? failed(`${field} must be true or false`) : success(value);
+});

package/validators/factory.d.ts

@@ -0,0 +1,59 @@
+/**
+ * 实现创建 validator 的快捷方式
+ */
+import { type ArrayOptions, type TupleOptions } from './array.js';
+import { type Validator, type CommonOptions, type Validated } from './base.js';
+import { type BooleanOptions } from './boolean.js';
+import { type NumberOptions, type NumberValueWithChoices } from './number.js';
+import { type RecordOptions, type StructOptions } from './object.js';
+import { type StringOptions, type StringValueWithChoices } from './string.js';
+export interface AnyDefinition extends CommonOptions {
+    type: 'any';
+}
+export interface BooleanDefinition extends BooleanOptions {
+    type: 'boolean';
+}
+export interface NumberDefinition extends NumberOptions {
+    type: 'number';
+}
+export interface StringDefinition extends StringOptions {
+    type: 'string';
+}
+export interface ArrayDefinition extends Omit<ArrayOptions, 'item'> {
+    type: 'array';
+    item: Definition;
+}
+export interface TupleDefinition extends Omit<TupleOptions, 'tuple'> {
+    type: 'tuple';
+    tuple: Definition[];
+}
+export interface StructDefinition extends Omit<StructOptions, 'struct'> {
+    type: 'struct';
+    struct: Record<string, Definition>;
+}
+export interface RecordDefinition extends Omit<RecordOptions, 'record'> {
+    type: 'record';
+    record: Definition;
+}
+export type Definition = AnyDefinition | BooleanDefinition | NumberDefinition | StringDefinition | ArrayDefinition | TupleDefinition | StructDefinition | RecordDefinition;
+type ValueOfDefinition<Def extends Definition> = Def extends AnyDefinition ? unknown : Def extends BooleanDefinition ? boolean : Def extends NumberDefinition ? NumberValueWithChoices<Def> : Def extends StringDefinition ? StringValueWithChoices<Def> : Def extends ArrayDefinition ? Validated<ValueOfDefinition<Def['item']>, Def['item']>[] : Def extends TupleDefinition ? {
+    [Key in keyof Def['tuple']]: Def['tuple'][Key] extends Definition ? Validated<ValueOfDefinition<Def['tuple'][Key]>, Def['tuple'][Key]> : Def['tuple'][Key];
+} : Def extends StructDefinition ? {
+    [Key in keyof Def['struct']]: Validated<ValueOfDefinition<Def['struct'][Key]>, Def['struct'][Key]>;
+} : Def extends RecordDefinition ? Record<string, Validated<ValueOfDefinition<Def['record']>, Def['record']>> : never;
+type OptionsFromDefinition<Def extends Definition> = Def extends ArrayDefinition ? Omit<Def, 'item'> & {
+    item: ValidatorForDefinition<Def['item']>;
+} : Def extends TupleDefinition ? Omit<Def, 'tuple'> & {
+    tuple: {
+        [Key in keyof Def['tuple']]: Def['tuple'][Key] extends Definition ? ValidatorForDefinition<Def['tuple'][Key]> : never;
+    };
+} : Def extends StructDefinition ? Omit<Def, 'struct'> & {
+    struct: {
+        [Key in keyof Def['struct']]: ValidatorForDefinition<Def['struct'][Key]>;
+    };
+} : Def extends RecordDefinition ? Omit<Def, 'record'> & {
+    record: ValidatorForDefinition<Def['record']>;
+} : Def;
+type ValidatorForDefinition<Def extends Definition> = Validator<ValueOfDefinition<Def>, OptionsFromDefinition<Def>>;
+export declare function getValidator<const InputDefinition extends Definition>(definition: InputDefinition): ValidatorForDefinition<InputDefinition>;
+export {};

package/validators/factory.js

@@ -0,0 +1,88 @@
+/**
+ * 实现创建 validator 的快捷方式
+ */
+import { getArrayValidator, getTupleValidator, } from './array.js';
+import { getAnyValidator } from './base.js';
+import { getBooleanValidator } from './boolean.js';
+import { getNumberValidator } from './number.js';
+import { getRecordValidator, getStructValidator, } from './object.js';
+import { getStringValidator } from './string.js';
+export function getValidator(definition) {
+    switch (definition.type) {
+        case 'any':
+            return getAnyValidator(definition);
+        case 'boolean':
+            return getBooleanValidator(definition);
+        case 'number':
+            return getNumberValidator(definition);
+        case 'string':
+            return getStringValidator(definition);
+        case 'array':
+            // @ts-ignore 允许递归类型推断
+            return getArrayValidator({
+                // @ts-ignore 允许递归类型推断
+                ...definition,
+                item: getValidator(definition['item']),
+            });
+        case 'tuple':
+            return getTupleValidator({
+                ...definition,
+                tuple: definition['tuple'].map(def => getValidator(def)),
+            });
+        case 'struct': {
+            const struct = {};
+            for (const [key, def] of Object.entries(definition['struct']))
+                struct[key] = getValidator(def);
+            return getStructValidator({ ...definition, struct });
+        }
+        case 'record':
+            return getRecordValidator({
+                ...definition,
+                record: getValidator(definition['record']),
+            });
+    }
+}
+// ---------------- 测试用例 -----------------
+// const v1 = getValidator({ type: 'string' })(1)
+// const v2 = getValidator({ type: 'string', null: true })(1)
+// const v3 = getValidator({ type: 'string', null: true, required: false })(1)
+// const v4 = getValidator({ type: 'string', null: true, required: false, choices: ['a', 'b', 'c'] })(
+//   1,
+// )
+// const v5 = getValidator({
+//   type: 'string',
+//   null: true,
+//   required: false,
+//   choices: ['a', 'b', 'c'],
+//   defaults: 'd',
+// })(1)
+// const v6 = getValidator({
+//   type: 'array',
+//   null: true,
+//   required: false,
+//   item: { type: 'string', null: true, choices: ['a', 'b', 'c'] },
+// })(1)
+// const v7 = getValidator({
+//   type: 'tuple',
+//   tuple: [
+//     { type: 'string', choices: ['a', 'b', 'c'] },
+//     { type: 'string', null: true },
+//   ],
+// })(1)
+// if (v7.success) {
+//   const [a, b] = v7.data
+// }
+// const v8 = getValidator({
+//   type: 'struct',
+//   struct: {
+//     x: { type: 'string', choices: ['a', 'b', 'c'] },
+//     y: { type: 'string', null: true },
+//   },
+// })(1)
+// if (v8.success) {
+//   const { x, y } = v8.data
+// }
+// const v9 = getValidator({
+//   type: 'record',
+//   record: { type: 'string', null: true, choices: ['a', 'b', 'c'] },
+// })(1)

package/validators/index.d.ts

@@ -4,4 +4,4 @@ export * from './boolean.js';
 export * from './number.js';
 export * from './object.js';
 export * from './string.js';
-export * as validators from './factories.js';
+export * from './factory.js';

package/validators/index.js

@@ -4,4 +4,4 @@ export * from './boolean.js';
 export * from './number.js';
 export * from './object.js';
 export * from './string.js';
-export * as validators from './factories.js';
+export * from './factory.js';

package/validators/number.d.ts

@@ -1,15 +1,17 @@
-import { type BaseOptions, Validator } from './base.js';
-export interface NumberOptions {
+import { type CommonOptions } from './base.js';
+export interface NumberOptions extends CommonOptions<number> {
     /** 数值最小值 */
     min?: number;
     /** 数值最大值 */
     max?: number;
     /** 是否允许小数 @default false */
-    float: boolean;
-    /** 指定可选值 */
-    enum?: number[];
-}
-export declare class NumberValidator extends Validator<NumberOptions> {
-    constructor(options?: Partial<BaseOptions & NumberOptions>);
-    validate(field: string, value: unknown): import("../lang/may-success.js").Failed<void> | import("../lang/may-success.js").Success<unknown>;
+    float?: boolean;
+    /**
+     * 指定可选值
+     * 若指定，前几个选项将不再生效 */
+    choices?: number[];
 }
+export type NumberValueWithChoices<Options extends NumberOptions> = Options extends {
+    choices: (infer T)[];
+} ? T : number;
+export declare function getNumberValidator<const Options extends NumberOptions>(options?: Options): import("./base.js").Validator<NumberValueWithChoices<Options>, Options>;

package/validators/number.js

@@ -1,32 +1,23 @@
-import { success, failed } from '../lang/index.js';
-import { Validator } from './base.js';
-export class NumberValidator extends Validator {
-    constructor(options = {}) {
-        super({
-            float: false,
-            ...options,
-        });
-    }
-    validate(field, value) {
-        const superResult = super.validate(field, value);
-        if (!superResult.success)
-            return superResult;
-        value = superResult.data;
-        if (value === null || value === undefined)
-            return superResult;
-        const opt = this.options;
+import { truthy, success, failed } from '../lang/index.js';
+import { getValidatorGenerator } from './base.js';
+export function getNumberValidator(options = {}) {
+    return getValidatorGenerator(function validate(field, value) {
         if (typeof value === 'string')
             value = parseFloat(value);
         if (typeof value !== 'number' || !isFinite(value))
             return failed(`${field} must be a valid number`);
-        if (opt.enum !== undefined && !opt.enum.includes(value))
-            return failed(`${field} can only be one of ${opt.enum.join(', ')}.`);
-        if (!opt.float && value % 1 !== 0)
-            return failed(`${field} must be a integer`);
-        if (typeof opt.min === 'number' && value < opt.min)
-            return failed(`${field} must >= ${opt.min}`);
-        if (typeof opt.max === 'number' && value > opt.max)
-            return failed(`${field} must <= ${opt.max}`);
+        if ('choices' in options && options.choices) {
+            if (!options.choices.includes(value))
+                return failed(`${field} can only be one of ${options.choices.join(', ')}.`);
+        }
+        else {
+            if (!truthy(options.float) && value % 1 !== 0)
+                return failed(`${field} must be a integer`);
+            if (typeof options.min === 'number' && value < options.min)
+                return failed(`${field} must >= ${options.min}`);
+            if (typeof options.max === 'number' && value > options.max)
+                return failed(`${field} must <= ${options.max}`);
+        }
         return success(value);
-    }
+    })(options);
 }

package/validators/object.d.ts

@@ -1,20 +1,28 @@
-import { Validator } from './base.js';
+import { type CommonOptions, type Validator, type Validated } from './base.js';
 /** 验证有明确键值对结构的对象 */
-export type StructOptions = {
+export interface StructOptions extends CommonOptions {
     /** 定义对象结构，及各个值的验证规则 */
-    struct: Record<string, Validator>;
+    struct: Record<string, Validator<unknown, CommonOptions>>;
+}
+type StructValues<Options extends StructOptions> = {
+    [Key in keyof Options['struct']]: Options['struct'][Key] extends Validator<infer Value, infer Options> ? Validated<Value, Options> : never;
 };
+export declare function getStructValidator<const Options extends StructOptions>(options: Options): Validator<StructValues<Options>, Options>;
 /**
  * 验证有任意多个 key，但值的类型固定的对象
  */
-export type RecordOptions = {
+export interface RecordOptions extends CommonOptions {
     /** 验证单个值  */
-    record: Validator;
+    record: Validator<unknown, CommonOptions>;
     /** 对象至少要有几项 */
     min?: number;
     /** 对象最多有几项 */
     max?: number;
-};
-export declare class ObjectValidator extends Validator<StructOptions | RecordOptions> {
-    validate(field: string, value: unknown): import("../lang/may-success.js").Failed<void> | import("../lang/may-success.js").Success<unknown>;
 }
+type RecordValues<Options extends RecordOptions> = Record<string, Validated<Options extends {
+    record: Validator<infer T, CommonOptions>;
+} ? T : never, Options extends {
+    record: Validator<unknown, infer T>;
+} ? T : never>>;
+export declare function getRecordValidator<Options extends RecordOptions>(options: Options): Validator<RecordValues<Options>, Options>;
+export {};

package/validators/object.js

@@ -1,52 +1,49 @@
 import isPlainObject from 'lodash/isPlainObject.js';
 import { success, failed } from '../lang/index.js';
-import { Validator } from './base.js';
-export class ObjectValidator extends Validator {
-    validate(field, value) {
-        const superResult = super.validate(field, value);
-        if (!superResult.success)
-            return superResult;
-        value = superResult.data;
-        if (value === null || value === undefined)
-            return superResult;
-        const opt = this.options;
+import { getValidatorGenerator, } from './base.js';
+export function getStructValidator(options) {
+    return getValidatorGenerator(function validate(field, value, options) {
         if (!isPlainObject(value))
             return failed(`${field} should be a plain object`);
         const formatted = {};
-        if ('struct' in opt) {
-            for (const [key, itemValidator] of Object.entries(opt.struct)) {
-                const itemResult = itemValidator.validate(`${field}["${key}"]`, value[key]);
-                if (itemResult.success) {
-                    if (itemResult.data !== undefined)
-                        formatted[key] = itemResult.data;
-                }
-                else {
-                    return itemResult;
-                }
+        for (const [key, itemValidator] of Object.entries(options.struct)) {
+            const itemResult = itemValidator(`${field}["${key}"]`, value[key]);
+            if (itemResult.success) {
+                if (itemResult.data !== undefined)
+                    formatted[key] = itemResult.data;
+            }
+            else {
+                return itemResult;
             }
         }
-        else {
-            for (const [key, itemValue] of Object.entries(value)) {
-                // record 场景下，值为 undefined 的项目视为不存在，不保留在验证结果里，
-                // 不然一些因为不想赋值而填充了 undefined 值的项目可能意外触发验证失败，或意外得到了默认值。
-                // （因此 validator 的 required 选项和 defaults 选项也没有意义了）
-                if (itemValue === undefined)
-                    continue;
-                const itemResult = opt.record.validate(`${field}["${key}"]`, itemValue);
-                if (itemResult.success) {
-                    if (itemResult.data !== undefined)
-                        formatted[key] = itemResult.data;
-                }
-                else {
-                    return itemResult;
-                }
+        return success(formatted);
+    })(options);
+}
+export function getRecordValidator(options) {
+    return getValidatorGenerator(function validate(field, value, options) {
+        if (!isPlainObject(value))
+            return failed(`${field} should be a plain object`);
+        const formatted = {};
+        for (const [key, itemValue] of Object.entries(value)) {
+            // record 场景下，值为 undefined 的项目视为不存在，不保留在验证结果里，
+            // 不然一些因为不想赋值而填充了 undefined 值的项目可能意外触发验证失败，或意外得到了默认值。
+            // （因此 validator 的 required 选项和 defaults 选项也没有意义了）
+            if (itemValue === undefined)
+                continue;
+            const itemResult = options.record(`${field}["${key}"]`, itemValue);
+            if (itemResult.success) {
+                if (itemResult.data !== undefined)
+                    formatted[key] = itemResult.data;
+            }
+            else {
+                return itemResult;
             }
-            const length = Object.keys(formatted).length;
-            if (typeof opt.min === 'number' && length < opt.min)
-                return failed(`size of ${field} should >= ${opt.min}`);
-            if (typeof opt.max === 'number' && length > opt.max)
-                return failed(`size of ${field} should <= ${opt.max}`);
         }
+        const length = Object.keys(formatted).length;
+        if (typeof options.min === 'number' && length < options.min)
+            return failed(`size of ${field} should >= ${options.min}`);
+        if (typeof options.max === 'number' && length > options.max)
+            return failed(`size of ${field} should <= ${options.max}`);
         return success(formatted);
-    }
+    })(options);
 }

package/validators/string.d.ts

@@ -1,17 +1,22 @@
-import { type BaseOptions, Validator } from './base.js';
-export interface StringOptions {
+import { type CommonOptions } from './base.js';
+export interface StringOptions extends CommonOptions<string> {
     /** 字符串最小长度。defaults='' 时默认为 0，否则默认为 1 */
-    min: number;
+    min?: number;
     /** 字符串最大长度。 */
     max?: number;
-    /** 字符串需匹配此正则 */
-    pattern?: RegExp;
-    /** 指定一个数组或 TypeScript enum，字段值必须在此 enum 之中 */
-    enum?: string[] | Record<string, string>;
-    /** 验证之前，是否先清除两侧空白字符（默认开启） */
-    trim: boolean;
-}
-export declare class StringValidator extends Validator<StringOptions> {
-    constructor(options?: Partial<BaseOptions & StringOptions>);
-    validate(field: string, value: unknown): import("../lang/may-success.js").Failed<void> | import("../lang/may-success.js").Success<unknown>;
+    /** 字符串需匹配此正则，也可传入关键词使用预置的正则。正则通常应以 ^ 和 $ 开头结尾。 */
+    pattern?: RegExp | 'uuid' | 'mobile';
+    /**
+     * 指定一个数组或 TypeScript enum，字段值必须在此 enum 之中。
+     * 若指定，前几个选项将不再生效。
+     */
+    choices?: string[] | Record<string, string>;
+    /** 验证之前，是否先清除两侧空白字符 @default true */
+    trim?: boolean;
 }
+export type StringValueWithChoices<Options extends StringOptions> = Options extends {
+    choices: (infer T)[];
+} ? T : Options extends {
+    choices: Record<string, infer T>;
+} ? T : string;
+export declare function getStringValidator<const Options extends StringOptions>(options?: Options): import("./base.js").Validator<StringValueWithChoices<Options>, Options>;

package/validators/string.js

@@ -1,35 +1,35 @@
 import { success, failed } from '../lang/index.js';
-import { Validator } from './base.js';
-export class StringValidator extends Validator {
-    constructor(options = {}) {
-        super({
-            min: options.defaults === '' ? 0 : 1,
-            trim: true,
-            ...options,
-        });
-    }
-    validate(field, value) {
-        const opt = this.options;
-        const superResult = super.validate(field, value);
-        if (!superResult.success)
-            return superResult;
-        value = superResult.data;
-        if (value === null || value === undefined)
-            return superResult;
+import { getValidatorGenerator } from './base.js';
+export function getStringValidator(options = {}) {
+    return getValidatorGenerator(function validate(field, value) {
         if (typeof value !== 'string')
             return failed(`${field} must be a string`);
-        const formatted = opt.trim ? value.trim() : value;
-        if (typeof opt.min === 'number' && formatted.length < opt.min)
-            return failed(`${field}'s length must >= ${opt.min}`);
-        if (typeof opt.max === 'number' && formatted.length > opt.max)
-            return failed(`${field}'s length must <= ${opt.max}`);
-        if (opt.pattern && !opt.pattern.exec(formatted))
-            return failed(`${field} does not match the pattern.`);
-        if (opt.enum !== undefined) {
-            const validValues = Array.isArray(opt.enum) ? opt.enum : Object.values(opt.enum);
+        const trim = options.trim ?? true;
+        const formatted = trim ? value.trim() : value;
+        if ('choices' in options && options.choices) {
+            const validValues = Array.isArray(options.choices)
+                ? options.choices
+                : Object.values(options.choices);
             if (!validValues.includes(formatted))
                 return failed(`${field} can only be one of ${validValues.join(', ')}.`);
         }
+        else {
+            const { min = options.defaults === '' ? 0 : 1, max, pattern } = options;
+            if (typeof min === 'number' && formatted.length < min)
+                return failed(`${field}'s length must >= ${min}`);
+            if (typeof max === 'number' && formatted.length > max)
+                return failed(`${field}'s length must <= ${max}`);
+            if (pattern !== undefined) {
+                if (pattern instanceof RegExp && !pattern.exec(formatted))
+                    return failed(`${field} does not match the pattern`);
+                if (pattern === 'mobile' && !/^1\d{10}$/.test(formatted))
+                    return failed(`${field} is not a valid mobile number`);
+                if (pattern === 'uuid') {
+                    if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(formatted))
+                        return failed(`${field} is not a valid uuid`);
+                }
+            }
+        }
         return success(formatted);
-    }
+    })(options);
 }

package/validators/factories.d.ts

@@ -1,18 +0,0 @@
-/**
- * 创建 validator 的快捷方式
- */
-import { ArrayValidator, type ArrayOptions } from './array.js';
-import { Validator, type BaseOptions } from './base.js';
-import { BooleanValidator } from './boolean.js';
-import { NumberValidator } from './number.js';
-import { ObjectValidator, type RecordOptions } from './object.js';
-import { StringValidator } from './string.js';
-/** 仅进行基本检查（如检查空值），不检查具体格式 */
-export declare function any(options?: Partial<BaseOptions>): Validator<unknown>;
-export declare function string(...args: ConstructorParameters<typeof StringValidator>): StringValidator;
-export declare function number(...args: ConstructorParameters<typeof NumberValidator>): NumberValidator;
-export declare function boolean(options?: Partial<BaseOptions>): BooleanValidator;
-export declare function array(options: Validator | (ArrayOptions & Partial<BaseOptions>)): ArrayValidator;
-export declare function tuple(validators: Validator[], baseOptions?: Partial<BaseOptions>): ArrayValidator;
-export declare function struct(validators: Record<string, Validator>, options?: Partial<BaseOptions>): ObjectValidator;
-export declare function record(options: Validator | (RecordOptions & Partial<BaseOptions>)): ObjectValidator;

package/validators/factories.js

@@ -1,41 +0,0 @@
-/**
- * 创建 validator 的快捷方式
- */
-import { ArrayValidator } from './array.js';
-import { Validator } from './base.js';
-import { BooleanValidator } from './boolean.js';
-import { NumberValidator } from './number.js';
-import { ObjectValidator } from './object.js';
-import { StringValidator } from './string.js';
-/** 仅进行基本检查（如检查空值），不检查具体格式 */
-export function any(options) {
-    return new Validator(options ?? {});
-}
-export function string(...args) {
-    return new StringValidator(...args);
-}
-export function number(...args) {
-    return new NumberValidator(...args);
-}
-export function boolean(options = {}) {
-    return new BooleanValidator(options);
-}
-export function array(options) {
-    if (options instanceof Validator)
-        options = { item: options };
-    return new ArrayValidator(options);
-}
-export function tuple(validators, baseOptions) {
-    return new ArrayValidator({
-        ...(baseOptions ?? {}),
-        tuple: validators,
-    });
-}
-export function struct(validators, options = {}) {
-    return new ObjectValidator({ ...options, struct: validators });
-}
-export function record(options) {
-    if (options instanceof Validator)
-        options = { record: options };
-    return new ObjectValidator(options);
-}