@anjianshi/utils 2.7.0 → 2.8.0

package/src/validators/array.ts

@@ -1,97 +0,0 @@
-import { success, failed } from '../lang/index.js'
-import {
-  getValidatorGenerator,
-  type CommonOptions,
-  type Validator,
-  type Validated,
-  type PrimitiveType,
-} from './base.js'
-
-/** 验证元素数量任意、元素类型相同的数组 */
-export interface ArrayOptions extends CommonOptions {
-  /** 验证数组各元素 */
-  item: Validator<unknown, CommonOptions>
-
-  /** 数组最小长度 */
-  min?: number
-
-  /** 数组最大长度 */
-  max?: number
-
-  /** 是否对数组元素进行去重 @defaults false */
-  unique?: boolean
-
-  /** 如果传入的不是数组，是否要将其视为数组内元素，包裹成数组 */
-  toArray?: 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 function getArrayValidator<Options extends ArrayOptions>(options: Options) {
-  return getValidatorGenerator<ArrayValues<Options>, Options>(
-    function validate(field, value, options) {
-      if (!Array.isArray(value)) {
-        if (options.toArray) value = [value as PrimitiveType]
-        else return failed(`${field} should be an array`)
-      }
-
-      let 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
-      }
-
-      if (options.unique === true) formatted = [...new Set(formatted)]
-
-      return success(formatted as ArrayValues<Options>)
-    },
-  )(options)
-}
-
-// ---------------------------------------------------
-
-/** 验证元素数量固定、类型可以不同的数组 */
-export interface TupleOptions extends CommonOptions {
-  /** 验证数组各元素（validator 与元素一一对应） */
-  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 function getTupleValidator<const Options extends TupleOptions>(options: Options) {
-  return getValidatorGenerator<TupleValues<Options>, Options>(
-    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 as TupleValues<Options>)
-    },
-  )(options)
-}

package/src/validators/base.ts

@@ -1,145 +0,0 @@
-import { success, failed, 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 通用参数
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-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>
-
-  // 用来保证传入定制过的 Options 时 TypeScript 不会报不匹配的错
-  // 例如不加这句时， `{ other: boolean } extends CommonOptions` 是会被 TypeScript 判定为不匹配的：
-  // error TS2559: Type '{ other: boolean }' has no properties in common with type 'CommonOptions<unknown>'
-  // 此解决办法来自：https://mariusschulz.com/blog/weak-type-detection-in-typescript
-  [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 function getValidatorGenerator<Value, Options extends CommonOptions>(
-  validate: (
-    field: string,
-    input: PrimitiveType | Validated<Value, Options>,
-    options: Options,
-  ) => MaySuccess<Value>,
-) {
-  return function validatorGenerator<const InputOptions extends Options>(
-    inputOptions: InputOptions,
-  ): Validator<Value, InputOptions> {
-    type Return = MaySuccess<Validated<Value, InputOptions>>
-    function validator(input: AllowedInputValue): Return
-    function validator(field: string, input: AllowedInputValue): Return
-    function validator(field: string | AllowedInputValue, input?: AllowedInputValue) {
-      // 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: AllowedInputValue | Validated<Value, Options> = input
-      if (typeof value === 'undefined') {
-        if (typeof defaults !== 'undefined') {
-          value = defaults as Validated<Value, Options>
-        } 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<unknown, CommonOptions>(
-  function validate(field, input) {
-    return success(input)
-  },
-)

package/src/validators/boolean.ts

@@ -1,21 +0,0 @@
-import { success, failed } from '../lang/index.js'
-import { getValidatorGenerator, type CommonOptions } from './base.js'
-
-export type BooleanOptions = CommonOptions<boolean>
-
-export const getBooleanValidator = getValidatorGenerator<boolean, BooleanOptions>(
-  function validate(field, input) {
-    let value: boolean | null = 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/src/validators/datetime.ts

@@ -1,39 +0,0 @@
-/**
- * 验证日期时间类型的值，依赖 dayjs
- */
-import dayjs, { Dayjs } from 'dayjs'
-import { success, failed } from '../lang/index.js'
-import { getValidatorGenerator, type CommonOptions } from './base.js'
-
-export interface DatetimeOptions extends CommonOptions<number> {
-  raw?: boolean // 为 true 则返回原生 Date 对象；否则返回 Dayjs 对象（默认）
-}
-
-export type DatetimeValue<Options extends DatetimeOptions> = Options extends {
-  raw: true
-}
-  ? Date
-  : Dayjs
-
-export function getDatetimeValidator<const Options extends DatetimeOptions>(
-  options: Options = {} as Options
-) {
-  return getValidatorGenerator<DatetimeValue<Options>, Options>(function validate(field, value) {
-    let dayjsValue: Dayjs
-
-    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) as DatetimeValue<Options>)
-  })(options)
-}

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)
-}