@anjianshi/utils 3.0.0 → 3.0.2

package/src/validators/factory.ts

@@ -1,244 +0,0 @@
-/**
- * 实现创建 validator 的快捷方式
- */
-import {
-  type ArrayOptions,
-  getArrayValidator,
-  type TupleOptions,
-  getTupleValidator,
-} from './array.js'
-import { type Validator, type CommonOptions, type Validated, getAnyValidator } from './base.js'
-import { type BooleanOptions, getBooleanValidator } from './boolean.js'
-import { type DatetimeOptions, type DatetimeValue, getDatetimeValidator } from './datetime.js'
-import { type NumberOptions, type NumberValueWithChoices, getNumberValidator } from './number.js'
-import {
-  type RecordOptions,
-  getRecordValidator,
-  type StructOptions,
-  getStructValidator,
-} from './object.js'
-import { type OneOfOptions, getOneOfValidator } from './one-of.js'
-import { type StringOptions, type StringValueWithChoices, getStringValidator } 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 function getValidator<const InputDefinition extends Definition>(
-  definition: InputDefinition
-): ValidatorForDefinition<InputDefinition> {
-  type GotValidator = ValidatorForDefinition<InputDefinition>
-  switch (definition.type) {
-    case 'any':
-      return getAnyValidator(definition) as GotValidator
-    case 'boolean':
-      return getBooleanValidator(definition) as GotValidator
-    case 'number':
-      return getNumberValidator(definition) as GotValidator
-    case 'string':
-      return getStringValidator(definition) as GotValidator
-    case 'datetime':
-      return getDatetimeValidator(definition) as GotValidator
-    case 'array':
-      // @ts-ignore 允许递归类型推断
-      return getArrayValidator({
-        // @ts-ignore 允许递归类型推断
-        ...definition,
-        item: getValidator(definition.item),
-      }) as GotValidator
-    case 'tuple':
-      return getTupleValidator({
-        ...definition,
-        tuple: definition.tuple.map(def => getValidator(def)),
-      }) as GotValidator
-    case 'struct': {
-      const struct: Record<string, Validator<unknown, CommonOptions>> = {}
-      for (const [key, def] of Object.entries(definition.struct)) struct[key] = getValidator(def)
-      return getStructValidator({ ...definition, struct }) as GotValidator
-    }
-    case 'record':
-      return getRecordValidator({
-        ...definition,
-        record: getValidator(definition.record),
-      }) as GotValidator
-    case 'oneOf':
-      return getOneOfValidator({
-        ...definition,
-        validators: definition.validators.map(def => getValidator(def)),
-      }) as GotValidator
-  }
-}
-
-// ---------------- 测试用例 -----------------
-
-// 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/src/validators/index.ts

@@ -1,9 +0,0 @@
-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/src/validators/number.ts

@@ -1,54 +0,0 @@
-import { truthy, success, failed } from '../lang/index.js'
-import { getValidatorGenerator, 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 function getNumberValidator<const Options extends NumberOptions>(
-  options: Options = {} as Options,
-) {
-  return getValidatorGenerator<NumberValueWithChoices<Options>, Options>(
-    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 as NumberValueWithChoices<Options>)
-    },
-  )(options)
-}

package/src/validators/object.ts

@@ -1,101 +0,0 @@
-import isPlainObject from 'lodash/isPlainObject.js'
-import { success, failed } from '../lang/index.js'
-import {
-  getValidatorGenerator,
-  type CommonOptions,
-  type Validator,
-  type Validated,
-  type AllowedInputValue,
-} 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 function getStructValidator<const Options extends StructOptions>(options: Options) {
-  return getValidatorGenerator<StructValues<Options>, Options>(
-    function validate(field, value, options) {
-      if (!isPlainObject(value)) return failed(`${field} should be a plain object`)
-
-      const formatted: Record<string, unknown> = {}
-      for (const [key, itemValidator] of Object.entries(options.struct)) {
-        const itemResult = itemValidator(
-          `${field}["${key}"]`,
-          (value as Record<string, AllowedInputValue>)[key],
-        )
-        if (itemResult.success) {
-          if (itemResult.data !== undefined) formatted[key] = itemResult.data
-        } else {
-          return itemResult
-        }
-      }
-      return success(formatted as 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 function getRecordValidator<Options extends RecordOptions>(options: Options) {
-  return getValidatorGenerator<RecordValues<Options>, Options>(
-    function validate(field, value, options) {
-      if (!isPlainObject(value)) return failed(`${field} should be a plain object`)
-
-      const formatted: Record<string, unknown> = {}
-      for (const [key, itemValue] of Object.entries(value as Record<string, AllowedInputValue>)) {
-        // 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 as RecordValues<Options>)
-    },
-  )(options)
-}

package/src/validators/one-of.ts

@@ -1,33 +0,0 @@
-import { failed, type Result } from '../lang/index.js'
-import {
-  getValidatorGenerator,
-  type CommonOptions,
-  type Validator,
-  type AllowedInputValue,
-} 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 function getOneOfValidator<const Options extends OneOfOptions>(
-  options: Options = {} as Options,
-) {
-  return getValidatorGenerator<OneOfValue<Options>, Options>(function validate(field, value) {
-    const errors: string[] = []
-    for (const validator of options.validators) {
-      const result = validator(field, value as AllowedInputValue)
-      if (result.success) return result as Result<OneOfValue<Options>>
-      else errors.push(result.message)
-    }
-    return failed(`${field} do not match any valid format：\n- ` + errors.join('\n- '))
-  })(options)
-}

package/src/validators/string.ts

@@ -1,72 +0,0 @@
-import { success, failed } from '../lang/index.js'
-import { getValidatorGenerator, 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 function getStringValidator<const Options extends StringOptions>(
-  options: Options = {} as Options,
-) {
-  return getValidatorGenerator<StringValueWithChoices<Options>, Options>(
-    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: string[] = 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 as StringValueWithChoices<Options>)
-    },
-  )(options)
-}