@anjianshi/utils 2.7.0 → 2.8.0

package/validators/base.d.ts

@@ -0,0 +1,82 @@
+import { type MaySuccess } from '../lang/index.js';
+/**
+ * 支持传入进行验证的值类型
+ */
+export type AllowedInputValue = PrimitiveType | null | undefined;
+/**
+ * JavaScript 基础值类型
+ */
+export type PrimitiveType = string | boolean | number | PrimitiveType[] | [...PrimitiveType[]] | {
+    [key: string]: PrimitiveType;
+};
+/**
+ * validator 通用参数
+ */
+export interface CommonOptions<Value = any> {
+    /** 是否允许 null 值 @default false */
+    null?: boolean;
+    /** 字段是否必须有值（不能是 undefined） @default true */
+    required?: boolean;
+    /**
+     * 默认值，字段无值（或值为 undefined）时生效，值为 null 不会生效。
+     * 指定后 required 选项将失去作用。
+     */
+    defaults?: Value;
+    custom?: (input: Value) => MaySuccess<Value>;
+    [key: string]: 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;
+    custom: Options extends {
+        custom: 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<any>>(inputOptions: InputOptions) => Validator<unknown, InputOptions>;
+export {};

package/validators/base.js

@@ -0,0 +1,42 @@
+import { success, failed } from '../lang/index.js';
+// -----------------------------------
+/**
+ * 返回支持指定格式的 options、并按照传入的逻辑进行验证的 validator 的生成器。
+ * 对 CommonOptions 相关内容的验证以自动包含在里面，只需要传入额外的验证逻辑即可。
+ */
+export function getValidatorGenerator(validate) {
+    return function validatorGenerator(inputOptions) {
+        function validator(field, input) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+            const { null: allowNull = false, required = true, defaults, custom } = inputOptions;
+            if (typeof field !== 'string') {
+                input = field;
+                field = 'value';
+            }
+            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);
+            const validated = validate(field, value, inputOptions);
+            return validated.success && custom ? custom(validated.data) : validated;
+        }
+        return validator;
+    };
+}
+// -----------------------------------
+/**
+ * 返回只进行基本检查，不带定制的验证逻辑的 validator。
+ * 同时也是定制 validator 最小化实现的例子。
+ */
+export const getAnyValidator = getValidatorGenerator(function validate(field, input) {
+    return success(input);
+});

package/validators/boolean.d.ts

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,22 @@
+import { success, failed } from '../lang/index.js';
+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/datetime.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 验证日期时间类型的值，依赖 dayjs
+ */
+import { Dayjs } from 'dayjs';
+import { type CommonOptions } from './base.js';
+export interface DatetimeOptions extends CommonOptions<number> {
+    raw?: boolean;
+}
+export type DatetimeValue<Options extends DatetimeOptions> = Options extends {
+    raw: true;
+} ? Date : Dayjs;
+export declare function getDatetimeValidator<const Options extends DatetimeOptions>(options?: Options): import("./base.js").Validator<DatetimeValue<Options>, Options>;

package/validators/datetime.js

@@ -0,0 +1,30 @@
+/**
+ * 验证日期时间类型的值，依赖 dayjs
+ */
+import dayjs, { Dayjs } from 'dayjs';
+import { success, failed } from '../lang/index.js';
+import { getValidatorGenerator } from './base.js';
+export function getDatetimeValidator(options = {}) {
+    return getValidatorGenerator(function validate(field, value) {
+        let dayjsValue;
+        if (typeof value === 'number') {
+            dayjsValue = dayjs.unix(value);
+            if (!dayjsValue.isValid())
+                return failed(`${field} must be a valid unix timestamp`);
+        }
+        else if (typeof value === 'string') {
+            dayjsValue = dayjs(value);
+            if (!dayjsValue.isValid())
+                return failed(`${field} must be a valid datetime string`);
+        }
+        else if (value instanceof Date || value instanceof Dayjs) {
+            dayjsValue = dayjs(value);
+            if (!dayjsValue.isValid())
+                return failed(`${field} must be a valid Date or Dayjs object`);
+        }
+        else {
+            return failed(`${field} must be a datetime string or unix timestamp`);
+        }
+        return success((options.raw ? dayjsValue.toDate() : dayjsValue));
+    })(options);
+}

package/validators/factory.d.ts

@@ -0,0 +1,70 @@
+/**
+ * 实现创建 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 DatetimeOptions, type DatetimeValue } from './datetime.js';
+import { type NumberOptions, type NumberValueWithChoices } from './number.js';
+import { type RecordOptions, type StructOptions } from './object.js';
+import { type OneOfOptions } from './one-of.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 DatetimeDefinition extends DatetimeOptions {
+    type: 'datetime';
+}
+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 interface OneOfDefinition extends Omit<OneOfOptions, 'validators'> {
+    type: 'oneOf';
+    validators: Definition[];
+}
+export type Definition = AnyDefinition | BooleanDefinition | NumberDefinition | StringDefinition | DatetimeDefinition | ArrayDefinition | TupleDefinition | StructDefinition | RecordDefinition | OneOfDefinition;
+export 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 DatetimeDefinition ? DatetimeValue<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']>> : Def extends OneOfDefinition ? {
+    [Key in keyof Def['validators']]: Def['validators'][Key] extends Definition ? Validated<ValueOfDefinition<Def['validators'][Key]>, Def['validators'][Key]> : Def['validators'][Key];
+}[number] : never;
+export 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;
+export type ValidatorForDefinition<Def extends Definition> = Validator<ValueOfDefinition<Def>, OptionsFromDefinition<Def>>;
+export type ResultForDefinition<Def extends Definition> = ReturnType<ValidatorForDefinition<Def>>;
+export declare function getValidator<const InputDefinition extends Definition>(definition: InputDefinition): ValidatorForDefinition<InputDefinition>;

package/validators/factory.js

@@ -0,0 +1,121 @@
+/**
+ * 实现创建 validator 的快捷方式
+ */
+import { getArrayValidator, getTupleValidator, } from './array.js';
+import { getAnyValidator } from './base.js';
+import { getBooleanValidator } from './boolean.js';
+import { getDatetimeValidator } from './datetime.js';
+import { getNumberValidator } from './number.js';
+import { getRecordValidator, getStructValidator, } from './object.js';
+import { getOneOfValidator } from './one-of.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 'datetime':
+            return getDatetimeValidator(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),
+            });
+        case 'oneOf':
+            return getOneOfValidator({
+                ...definition,
+                validators: definition.validators.map(def => getValidator(def)),
+            });
+    }
+}
+// ---------------- 测试用例 -----------------
+// 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)
+// const v10 = getValidator({
+//   type: 'oneOf',
+//   validators: [
+//     { type: 'string', choices: ['a', 'b', 'c'] },
+//     { type: 'number', null: true },
+//   ],
+//   defaults: true,
+// })(1)
+// const v11 = getValidator({
+//   type: 'string',
+//   custom(value) {
+//     return { success: true, data: value }
+//   },
+//   defaults: 'some text',
+// })(1)
+// const v12 = getValidator({
+//   type: 'datetime',
+//   null: true,
+//   required: false,
+// })(1)
+// const v13 = getValidator({
+//   type: 'datetime',
+//   raw: true,
+// })(1)

package/validators/index.d.ts

@@ -0,0 +1,9 @@
+export * from './base.js';
+export * from './boolean.js';
+export * from './number.js';
+export * from './string.js';
+export * from './datetime.js';
+export * from './array.js';
+export * from './object.js';
+export * from './one-of.js';
+export * from './factory.js';

package/validators/index.js

@@ -0,0 +1,9 @@
+export * from './base.js';
+export * from './boolean.js';
+export * from './number.js';
+export * from './string.js';
+export * from './datetime.js';
+export * from './array.js';
+export * from './object.js';
+export * from './one-of.js';
+export * from './factory.js';

package/validators/number.d.ts

@@ -0,0 +1,19 @@
+import { type CommonOptions } from './base.js';
+export interface NumberOptions extends CommonOptions<number> {
+    /** 数值最小值 */
+    min?: number;
+    /** 数值最大值 */
+    max?: number;
+    /** 是否允许小数 @default false */
+    float?: boolean;
+    /**
+     * 指定可选值
+     * 若指定，前几个选项将不再生效 */
+    choices?: number[] | Record<number, string>;
+}
+export type NumberValueWithChoices<Options extends NumberOptions> = Options extends {
+    choices: (infer T)[];
+} ? T : Options extends {
+    choices: Record<number, string>;
+} ? Options['choices'][keyof Options['choices']] : number;
+export declare function getNumberValidator<const Options extends NumberOptions>(options?: Options): import("./base.js").Validator<NumberValueWithChoices<Options>, Options>;

package/validators/number.js

@@ -0,0 +1,26 @@
+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 ('choices' in options && options.choices) {
+            const choices = Array.isArray(options.choices)
+                ? options.choices
+                : Object.values(options.choices).map(v => parseInt(v, 10));
+            if (!choices.includes(value))
+                return failed(`${field} can only be one of ${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

@@ -0,0 +1,28 @@
+import { type CommonOptions, type Validator, type Validated } from './base.js';
+/** 验证有明确键值对结构的对象 */
+export interface StructOptions extends CommonOptions {
+    /** 定义对象结构，及各个值的验证规则 */
+    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 interface RecordOptions extends CommonOptions {
+    /** 验证单个值  */
+    record: Validator<unknown, CommonOptions>;
+    /** 对象至少要有几项 */
+    min?: number;
+    /** 对象最多有几项 */
+    max?: number;
+}
+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

@@ -0,0 +1,49 @@
+import isPlainObject from 'lodash/isPlainObject.js';
+import { success, failed } from '../lang/index.js';
+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 = {};
+        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;
+            }
+        }
+        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 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/one-of.d.ts

@@ -0,0 +1,10 @@
+import { type CommonOptions, type Validator } from './base.js';
+/** 要求返回值通过其中一个验证器的检查 */
+export interface OneOfOptions extends CommonOptions {
+    /** 验证数组各元素 */
+    validators: Validator<unknown, CommonOptions>[];
+}
+export type OneOfValue<Options extends OneOfOptions> = Options extends {
+    validators: Validator<infer T, CommonOptions>[];
+} ? T : never;
+export declare function getOneOfValidator<const Options extends OneOfOptions>(options?: Options): Validator<OneOfValue<Options>, Options>;

package/validators/one-of.js

@@ -0,0 +1,15 @@
+import { failed } from '../lang/index.js';
+import { getValidatorGenerator, } from './base.js';
+export function getOneOfValidator(options = {}) {
+    return getValidatorGenerator(function validate(field, value) {
+        const errors = [];
+        for (const validator of options.validators) {
+            const result = validator(field, value);
+            if (result.success)
+                return result;
+            else
+                errors.push(result.message);
+        }
+        return failed(`${field} do not match any valid format：\n- ` + errors.join('\n- '));
+    })(options);
+}

package/validators/string.d.ts

@@ -0,0 +1,22 @@
+import { type CommonOptions } from './base.js';
+export interface StringOptions extends CommonOptions<string> {
+    /** 字符串最小长度。defaults='' 时默认为 0，否则默认为 1 */
+    min?: number;
+    /** 字符串最大长度。 */
+    max?: number;
+    /** 字符串需匹配此正则，也可传入关键词使用预置的正则。正则通常应以 ^ 和 $ 开头结尾。 */
+    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

@@ -0,0 +1,35 @@
+import { success, failed } from '../lang/index.js';
+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 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/README.md

@@ -1,10 +0,0 @@
-# Common JavaScript Utils
-
-## 依赖
-
-- `init-dayjs` 依赖 `dayjs`
-- `/logging` 依赖 `dayjs`，且会自动引用 `init-dayjs`
-- `/env-node/logging` 依赖 `chalk`
-- `/env-react/emotion` 依赖 `@emotion/*` 系列类库和 `react`
-- `/env-service/prisma` 依赖 `@prisma/client`
-- `/env-service/env-reader` 依赖 `dotenv`