validate用法 ​

export function validate(
  type: ValidateTypeInput = 'required',
  rules: ValidateInput | boolean = {},
  pureValid = false,
): ValidateRuleResult | boolean {
  const normalized = normalizeValidateParams(type, rules, pureValid)
  const rulesObject = normalized.rulesObject
  const rawRules = normalized.rawRules
  const validType = normalized.type
  const isPureValid = normalized.pureValid
  const trigger = rulesObject.trigger ?? (['blur', 'change'] as ValidateTriggerType[])
  // 使用枚举值组成的联合类型来确保类型安全
  const typeMaps = Object.values(ValidateType) as string[]
  const parseRequired = rulesObject.required ?? true
  const defaultRequiredMessage = validType === ValidateType.CHANGE ? '请选择' : '请输入'
  const getPureValue = () => (Object.prototype.hasOwnProperty.call(rulesObject, 'value') ? rulesObject.value : rawRules)

  // 如果不包含typeMaps中的类型, 直接将第一个参数作为message
  if (!typeMaps.includes(validType)) {
    return {
      required: parseRequired,
      message: validType,
      trigger,
    }
  }
  if (validType === ValidateType.REQUIRED || validType === ValidateType.CHANGE) {
    return {
      required: parseRequired,
      message: rulesObject.message ?? defaultRequiredMessage,
      trigger,
    }
  }

  // validator: this.validateName,
  if (validType === ValidateType.PASSWORD) {
    const validateName = (rule: any, value: any, callback: (error?: Error) => void) => {
      let validFlag = /^[a-zA-Z0-9_-]+$/.test(value)
      if (!validFlag) {
        callback(new Error(rulesObject.message || '密码只能由英文、数字、下划线、中划线组成'))
      } else {
        callback()
      }
    }
    return {
      validator: validateName,
      trigger,
    }
  }
  if (validType === ValidateType.POSITIVE || validType === ValidateType.NUMBER) {
    // 正整数
    return _validValue(getPureValue(), '请输入正整数', isPureValid, /^[1-9]+\d*$/)
  }
  if (validType === ValidateType.ZERO_POSITIVE) {
    // 正整数且包含0
    return _validValue(getPureValue(), '请输入非负整数', isPureValid, /^(0|[1-9]+\d*)$/)
  }
  // 整数, 包含负数和0
  if (validType === ValidateType.INTEGER) {
    return _validValue(getPureValue(), '请输入整数', isPureValid, /^(0|[-]?[1-9]\d*)$/)
  }
  // 非负数, 整数和最多2位小数
  if (validType === ValidateType.DECIMAL) {
    return _validValue(
      getPureValue(),
      '请输入非负数字, 包含小数且最多2位',
      isPureValid,
      /(0|[1-9]\d*)(\.\d{1, 2})?|0\.\d{1,2}/,
    )
  }
  if (validType === ValidateType.MOBILE) {
    return _validValue(getPureValue(), '请输入正确的手机号', isPureValid, /^[1][0-9]{10}$/)
  }
  if (validType === ValidateType.EMAIL) {
    return _validValue(getPureValue(), '请输入正确的email', isPureValid, /^[^\s@]+@[^\s@]+\.[^\s@]+$/)
  }
  if (validType === ValidateType.IP) {
    return _validValue(
      getPureValue(),
      '请输入正确的ip地址',
      isPureValid,
      /^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/,
    )
  }
  if (validType === ValidateType.PORT) {
    return _validValue(
      getPureValue(),
      '请输入1-65535的端口号',
      isPureValid,
      /^([1-9]|[1-9][0-9]{1,3}|[1-5][0-9]{4}|6[0-5][0-5][0-3][0-5])$/,
    )
  }
  if (validType === ValidateType.BETWEEN) {
    let minValue = rulesObject.min ?? ''
    let maxValue = rulesObject.max ?? ''
    const validateBetween = (rule: any, value: any, callback: (error?: Error) => void) => {
      let validFlag = /^-?[0-9]+$/.test(value)
      if (!validFlag) {
        callback(new Error('请输入数字'))
      }
      if (!isEmpty(minValue) && value < minValue) {
        callback(new Error(`数字不能小于${minValue}`))
      }
      if (!isEmpty(maxValue) && value > maxValue && maxValue !== undefined) {
        callback(new Error(`数字不能大于${maxValue}`))
      }
      callback()
    }
    return {
      validator: validateBetween,
      trigger,
      required: parseRequired,
    }
  }
  if (validType === ValidateType.LENGTH) {
    return {
      min: rulesObject.min,
      max: rulesObject.max,
      message: rulesObject.message ?? `请输入${rulesObject.min}到${rulesObject.max}个字符`,
      trigger,
      required: parseRequired,
    }
  }

  if (validType === ValidateType.SAME) {
    const validateSame = (rule: any, value: any, callback: (error?: Error) => void) => {
      let isSame = value === rulesObject.value
      if (!isSame) {
        const errMessage = rulesObject.message || '密码和确认密码要一致'
        callback(new Error(errMessage))
      }
      if (parseRequired && !value) {
        callback(new Error(rulesObject.message || '请输入'))
      }
      callback()
    }
    let res = {
      validator: validateSame,
      trigger,
      required: parseRequired,
    }
    return res
  }
  if (validType === ValidateType.CUSTOM) {
    return _validValue(getPureValue(), rulesObject.message, isPureValid, rulesObject.reg!)
  }

  function _validValue(value: any, msg: string | undefined, pureValid: boolean, reg: RegExp) {
    if (pureValid) {
      return reg.test(value)
    }
    const validatePhone = (rule: any, value: any, callback: (error?: Error) => void) => {
      let validFlag = reg.test(value)
      if (!validFlag) {
        callback(new Error(rulesObject.message ?? msg))
      } else {
        callback()
      }
    }
    return {
      validator: validatePhone,
      required: rulesObject.required ?? true,
      trigger,
    }
  }
  return {}
}

/**
 * 为 `validate` 预置空触发时机，只在提交或手动调用表单校验时触发。
 *
 * @param type 校验类型。
 * @param rules 校验规则。
 * @param pureValid 是否直接返回布尔值。
 * @returns 与 `validate` 一致。
 *
 * @example
 * const rule = validateOnSubmit('required', { message: '请输入名称' })
 */
export function validateOnSubmit(
  type: ValidateTypeInput = 'required',
  rules: ValidateInput | boolean = {},
  pureValid = false,
): ValidateRuleResult | boolean {
  const normalized = normalizeValidateParams(type, rules, pureValid)
  if (normalized.pureValid) {
    return validate(normalized.type, normalized.rawRules, true)
  }
  return validate(
    normalized.type,
    {
      ...normalized.rulesObject,
      trigger: normalized.rulesObject.trigger ?? [],
    },
    normalized.pureValid,
  )
}