@globalbrain/sefirot 0.72.0 → 2.0.0-draft.4

package/lib/validation/Validation.ts

@@ -1,151 +0,0 @@
-import { ref, computed, toRefs, Ref } from '@vue/composition-api'
-import { Rule } from './rules'
-
-export interface Validation {
-  _isValidation: boolean
-  $data: Ref<any>
-  $initData: any
-  $isDirty: Ref<boolean>
-  $isValid: Ref<boolean>
-  $errors: Ref<readonly Error[]>
-  $touch: () => void
-  $reset: () => void
-  $init: () => void
-  $validate: () => boolean
-  [name: string]: MaybeValidation
-}
-
-export type Data = Record<string, any>
-export type Rules = Record<string, Rule[] | Record<string, any>>
-export type InitData = any
-export type Error = [string, string]
-export type MaybeValidation = any | boolean | Ref<boolean> | Ref<readonly Error[]> | Function | Validation
-
-export function createValidation(data: Data, rules: Rules, rootData?: Data): Validation {
-  const validation = createInitialValidation()
-  setNestedValidations(validation, data, rootData ?? data, rules)
-  setValidation(validation)
-  return validation
-}
-
-function createInitialValidation(): Validation {
-  return {
-    _isValidation: true,
-    $data: ref(null),
-    $initData: null,
-    $isDirty: ref(false),
-    $isValid: ref(false),
-    $errors: ref([]),
-    $touch: () => {},
-    $reset: () => {},
-    $init: () => {},
-    $validate: () => false
-  }
-}
-
-function createNestedValidation(name: string, data: Data, rootData: Data, validators: Rule[]): Validation {
-  const initData = data[name]
-  const dataRef = toRefs(data)[name]
-
-  const isDirty = ref(false)
-
-  const errors = computed(() => {
-    return validators.reduce<Error[]>((errors, validator) => {
-      const d = data[name]
-
-      if (validator.optional && (d === undefined || d === null || d === '')) {
-        return errors
-      }
-
-      if (!validator.validate(d, rootData)) {
-        errors.push([validator.name, validator.message])
-      }
-
-      return errors
-    }, [])
-  })
-
-  const isValid = computed(() => errors.value.length === 0)
-
-  const touch = () => { isDirty.value = true }
-  const reset = () => { isDirty.value = false }
-
-  const init = () => {
-    reset()
-    dataRef.value = initData
-  }
-
-  const validate = () => {
-    touch()
-    return isValid.value
-  }
-
-  return {
-    _isValidation: true,
-    $data: dataRef,
-    $initData: initData,
-    $isDirty: isDirty,
-    $errors: errors,
-    $isValid: isValid,
-    $touch: touch,
-    $reset: reset,
-    $init: init,
-    $validate: validate
-  }
-}
-
-function setValidation(validation: Validation): void {
-  const isDirty = computed(() => {
-    return Object.keys(validation).every((field) => {
-      const v = validation[field]
-      return isValidation(v) ? v.$isDirty.value : true
-    }, [])
-  })
-
-  const errors = computed(() => {
-    return Object.keys(validation).reduce<Error[]>((errors, field) => {
-      const v = validation[field]
-      return isValidation(v) ? errors.concat(v.$errors.value) : errors
-    }, [])
-  })
-
-  const isValid = computed(() => errors.value.length === 0)
-
-  const touch = () => { callAll(validation, 'touch') }
-  const reset = () => { callAll(validation, 'reset') }
-  const init = () => { callAll(validation, 'init') }
-
-  const validate = () => {
-    touch()
-    return isValid.value
-  }
-
-  validation.$isDirty = isDirty
-  validation.$errors = errors
-  validation.$isValid = isValid
-  validation.$touch = touch
-  validation.$reset = reset
-  validation.$init = init
-  validation.$validate = validate
-}
-
-function setNestedValidations(validation: Validation, data: Data, rootData: Data, rules: Rules): void {
-  for (const name in rules) {
-    const validators = rules[name]
-
-    validation[name] = Array.isArray(validators)
-      ? createNestedValidation(name, data, rootData, validators)
-      : createValidation(data[name], validators, rootData)
-  }
-}
-
-function callAll(validation: Validation, method: 'touch' | 'reset' | 'init'): void {
-  for (const field in validation) {
-    const v = validation[field]
-    isValidation(v) && v[`$${method}`]()
-  }
-}
-
-function isValidation(value: MaybeValidation): value is Validation {
-  return value !== null && typeof value === 'object' && !Array.isArray(value) && value._isValidation
-}

package/lib/validation/rules/day.ts

@@ -1,11 +0,0 @@
-import { day as baseDay } from '../validators'
-import { Rule } from './'
-
-export default function day(year?: string, month?: string, message?: string): Rule {
-  return {
-    name: 'day',
-    message: message ?? 'The Date is invalid.',
-    optional: true,
-    validate: (value, data) => baseDay(value, data[year!], data[month!])
-  }
-}

package/lib/validation/rules/email.ts

@@ -1,11 +0,0 @@
-import { email as baseEmail } from '../validators'
-import { Rule } from './'
-
-export default function email(message?: string): Rule {
-  return {
-    name: 'email',
-    message: message ?? 'The Email address is invalid.',
-    optional: true,
-    validate: baseEmail
-  }
-}

package/lib/validation/rules/every.ts

@@ -1,38 +0,0 @@
-import { Rule } from './'
-
-interface Options {
-  [name: string]: Rule[]
-}
-
-export default function every(options: Options): Rule {
-  return {
-    name: 'each',
-    message: 'Error found in items.',
-    optional: true,
-    validate(value: Record<string, any>[], data): boolean {
-      return value.every(item => check(options, item, data))
-    }
-  }
-}
-
-function check(
-  options: Options,
-  item: Record<string, any>,
-  data: any
-): boolean {
-  for (const key in item) {
-    const rules = options[key]
-
-    if (!rules) {
-      continue
-    }
-
-    const result = rules.every(rule => rule.validate(item[key], data))
-
-    if (!result) {
-      return false
-    }
-  }
-
-  return true
-}

package/lib/validation/rules/include.ts

@@ -1,11 +0,0 @@
-import { include as baseInclude } from '../validators'
-import { Rule } from './'
-
-export default function required(other: string, message?: string): Rule {
-  return {
-    name: 'include',
-    message: message ?? `The value must include ${other}.`,
-    optional: true,
-    validate: (value, data) => baseInclude(value, data[other])
-  }
-}

package/lib/validation/rules/includeSome.ts

@@ -1,11 +0,0 @@
-import { includeSome as baseIncludeSome } from '../validators'
-import { Rule } from './'
-
-export default function required(other: string, message?: string): Rule {
-  return {
-    name: 'includeSome',
-    message: message ?? `The value must include some of ${other}.`,
-    optional: true,
-    validate: (value, data) => baseIncludeSome(value, data[other])
-  }
-}

package/lib/validation/rules/integer.ts

@@ -1,11 +0,0 @@
-import { integer as baseInteger } from '../validators'
-import { Rule } from './'
-
-export default function integer(message?: string): Rule {
-  return {
-    name: 'maxValue',
-    message: message ?? 'The value must not contain decimals.',
-    optional: true,
-    validate: baseInteger
-  }
-}

package/lib/validation/rules/maxValue.ts

@@ -1,11 +0,0 @@
-import { maxValue as baseMaxValue } from '../validators'
-import { Rule } from './'
-
-export default function maxValue(max: number, message?: string): Rule {
-  return {
-    name: 'maxValue',
-    message: message ?? `The value must be ${max} or less.`,
-    optional: true,
-    validate: value => baseMaxValue(value, max)
-  }
-}

package/lib/validation/rules/minValue.ts

@@ -1,11 +0,0 @@
-import { minValue as baseMinValue } from '../validators'
-import { Rule } from './'
-
-export default function minValue(min: number, message?: string): Rule {
-  return {
-    name: 'minValue',
-    message: message ?? `The value must be ${min} or more.`,
-    optional: true,
-    validate: value => baseMinValue(value, min)
-  }
-}

package/lib/validation/rules/month.ts

@@ -1,11 +0,0 @@
-import { month as baseMonth } from '../validators'
-import { Rule } from './'
-
-export default function month(message?: string): Rule {
-  return {
-    name: 'month',
-    message: message ?? 'The month is invalid.',
-    optional: true,
-    validate: baseMonth
-  }
-}

package/lib/validation/rules/not.ts

@@ -1,10 +0,0 @@
-import { Rule } from './'
-
-export default function not(rule: Rule, message?: string): Rule {
-  return {
-    name: `not-${rule.name}`,
-    message: message ?? '',
-    optional: true,
-    validate: (value, data) => !rule.validate(value, data)
-  }
-}

package/lib/validation/rules/regex.ts

@@ -1,11 +0,0 @@
-import { regex as baseRegex } from '../validators'
-import { Rule } from './'
-
-export default function required(regExp: RegExp, message?: string): Rule {
-  return {
-    name: 'regex',
-    message: message ?? 'The value is invalid.',
-    optional: true,
-    validate: value => baseRegex(value, regExp)
-  }
-}

package/lib/validation/rules/requiredHMS.ts

@@ -1,11 +0,0 @@
-import baseRequiredHMS, { HMSType } from '../validators/requiredHMS'
-import { Rule } from './'
-
-export default function requiredHMS(required?: HMSType[], message?: string): Rule {
-  return {
-    name: 'requiredHMS',
-    message: message ?? 'The field is required.',
-    optional: true,
-    validate: v => baseRequiredHMS(v, required)
-  }
-}

package/lib/validation/rules/requiredMonthDate.ts

@@ -1,11 +0,0 @@
-import { requiredMonthDate as baseRequiredMonthDate } from '../validators'
-import { Rule } from './'
-
-export default function requiredMonthDate(message?: string): Rule {
-  return {
-    name: 'requiredMonthDate',
-    message: message ?? 'The field is required.',
-    optional: true,
-    validate: baseRequiredMonthDate
-  }
-}

package/lib/validation/rules/requiredYearMonth.ts

@@ -1,11 +0,0 @@
-import { requiredYearMonth as baseRequiredYearMonth } from '../validators'
-import { Rule } from './'
-
-export default function requiredYearMonth(message?: string): Rule {
-  return {
-    name: 'requiredYearMonth',
-    message: message ?? 'The field is required.',
-    optional: true,
-    validate: baseRequiredYearMonth
-  }
-}

package/lib/validation/rules/requiredYearMonthDate.ts

@@ -1,11 +0,0 @@
-import { requiredYearMonthDate as baseRequiredYearMonthDate } from '../validators'
-import { Rule } from './'
-
-export default function requiredYearMonthDate(message?: string): Rule {
-  return {
-    name: 'requiredYearMonthDate',
-    message: message ?? 'The field is required.',
-    optional: true,
-    validate: baseRequiredYearMonthDate
-  }
-}

package/lib/validation/rules/rule.ts

@@ -1,5 +0,0 @@
-import { Rule } from './'
-
-export default function rule(options: Rule): Rule {
-  return options
-}

package/lib/validation/rules/sameAs.ts

@@ -1,11 +0,0 @@
-import { sameAs as baseSameAs } from '../validators'
-import { Rule } from './'
-
-export default function required(other: string, message?: string): Rule {
-  return {
-    name: 'sameAs',
-    message: message ?? `The value must match ${other}.`,
-    optional: true,
-    validate: (value, data) => baseSameAs(value, data[other])
-  }
-}

package/lib/validation/rules/url.ts

@@ -1,11 +0,0 @@
-import { url as baseUrl } from '../validators'
-import { Rule } from './'
-
-export default function url(message?: string): Rule {
-  return {
-    name: 'url',
-    message: message ?? 'The URL is invalid.',
-    optional: true,
-    validate: baseUrl
-  }
-}

package/lib/validation/rules/validateIf.ts

@@ -1,27 +0,0 @@
-import { required } from '../validators'
-import { Rule, Locator, locate } from './'
-
-export default function validateIf(locator: Locator, rules: Rule[]): Rule {
-  return {
-    name: 'validateIf',
-    message: 'Default message.',
-    optional: false,
-    validate(value, data) {
-      if (!locate(data, locator)) {
-        return true
-      }
-
-      return rules.every((rule) => {
-        if (rule.optional && !required(value)) {
-          return true
-        }
-
-        const result = rule.validate(value, data)
-
-        this.message = rule.message
-
-        return result
-      })
-    }
-  }
-}

package/lib/validation/rules/year.ts

@@ -1,11 +0,0 @@
-import { year as baseYear } from '../validators'
-import { Rule } from './'
-
-export default function year(message?: string): Rule {
-  return {
-    name: 'year',
-    message: message ?? 'The year is invalid.',
-    optional: true,
-    validate: baseYear
-  }
-}

package/lib/validation/rules/yearMonth.ts

@@ -1,11 +0,0 @@
-import { yearMonth as baseYearMonth } from '../validators'
-import { Rule } from './'
-
-export default function yearMonth(message?: string): Rule {
-  return {
-    name: 'yearMonth',
-    message: message ?? 'The date is invalid.',
-    optional: true,
-    validate: baseYearMonth
-  }
-}

package/lib/validation/rules/yearMonthDate.ts

@@ -1,11 +0,0 @@
-import { yearMonthDate as baseYearMonthDate } from '../validators'
-import { Rule } from './'
-
-export default function year(message?: string): Rule {
-  return {
-    name: 'yearMonthDate',
-    message: message ?? 'The date is invalid.',
-    optional: true,
-    validate: baseYearMonthDate
-  }
-}

package/lib/validation/validators/day.ts

@@ -1,29 +0,0 @@
-import dayjs from 'dayjs'
-
-export default function day(value: number, year?: number, month?: number): boolean {
-  if (year && !month) {
-    return validateDateOnly(value)
-  }
-
-  if (!year && month) {
-    return validateWithMonth(month, value)
-  }
-
-  if (year && month) {
-    return validateWithYearMonth(year, month, value)
-  }
-
-  return validateDateOnly(value)
-}
-
-function validateDateOnly(date: number): boolean {
-  return date > 0 && date < 32
-}
-
-function validateWithMonth(month: number, date: number): boolean {
-  return dayjs().year(2020).month(month - 1).date(date).date() === date
-}
-
-function validateWithYearMonth(year: number, month: number, date: number): boolean {
-  return dayjs().year(year).month(month - 1).date(date).date() === date
-}

package/lib/validation/validators/email.ts

@@ -1,5 +0,0 @@
-const regex = /(^$|^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$)/
-
-export default function email(value: any): boolean {
-  return regex.test(value)
-}

package/lib/validation/validators/include.ts

@@ -1,5 +0,0 @@
-import { isEqual } from '../../support/Util'
-
-export default function include(value: any[], other: any): boolean {
-  return value.some(v => isEqual(v, other))
-}

package/lib/validation/validators/includeSome.ts

@@ -1,5 +0,0 @@
-import { isEqual } from '../../support/Util'
-
-export default function includeSome(value: any[], other: any[]): boolean {
-  return value.some(v => other.some(o => isEqual(v, o)))
-}

package/lib/validation/validators/index.ts

@@ -1,51 +0,0 @@
-import checked from './checked'
-import day from './day'
-import email from './email'
-import fileExtension from './fileExtension'
-import hms from './hms'
-import include from './include'
-import includeSome from './includeSome'
-import integer from './integer'
-import maxLength from './maxLength'
-import maxValue from './maxValue'
-import minValue from './minValue'
-import month from './month'
-import monthDate from './monthDate'
-import regex from './regex'
-import required from './required'
-import requiredHMS from './requiredHMS'
-import requiredMonthDate from './requiredMonthDate'
-import requiredYearMonth from './requiredYearMonth'
-import requiredYearMonthDate from './requiredYearMonthDate'
-import sameAs from './sameAs'
-import url from './url'
-import year from './year'
-import yearMonthDate from './yearMonthDate'
-import yearMonth from './yearMonth'
-
-export {
-  checked,
-  day,
-  email,
-  fileExtension,
-  hms,
-  include,
-  includeSome,
-  integer,
-  maxLength,
-  maxValue,
-  minValue,
-  month,
-  monthDate,
-  regex,
-  required,
-  requiredHMS,
-  requiredMonthDate,
-  requiredYearMonth,
-  requiredYearMonthDate,
-  sameAs,
-  url,
-  year,
-  yearMonthDate,
-  yearMonth
-}

package/lib/validation/validators/integer.ts

@@ -1,6 +0,0 @@
-export default function integer(value: number): boolean {
-  // ^[0-9]*$  - for empty string and positive integer.
-  // ^-[0-9]+$ - only for negative integer (minus sign without at least
-  //             1 digit is not a number)
-  return /(^[0-9]*$)|(^-[0-9]+$)/.test(String(value))
-}

package/lib/validation/validators/maxLength.ts

@@ -1,3 +0,0 @@
-export default function maxLength(value: string | string[], max: number): boolean {
-  return value.length <= max
-}

package/lib/validation/validators/maxValue.ts

@@ -1,3 +0,0 @@
-export default function maxValue(value: number, max: number): boolean {
-  return value <= max
-}

package/lib/validation/validators/minValue.ts

@@ -1,3 +0,0 @@
-export default function minValue(value: number, min: number): boolean {
-  return min <= value
-}

package/lib/validation/validators/month.ts

@@ -1,3 +0,0 @@
-export default function month(value: number): boolean {
-  return value > 0 && value < 13
-}

package/lib/validation/validators/monthDate.ts

@@ -1,20 +0,0 @@
-import day from 'dayjs'
-
-export interface MonthDate {
-  month?: number
-  date?: number
-}
-
-export default function monthDate(value: MonthDate): boolean {
-  if (value.month === undefined || value.date === undefined) {
-    return true
-  }
-
-  const d = day(new Date(2020, value.month - 1, value.date))
-
-  if (d.month() + 1 !== value.month) {
-    return false
-  }
-
-  return d.isValid()
-}

package/lib/validation/validators/regex.ts

@@ -1,3 +0,0 @@
-export default function regex(value: any, regExp: RegExp): boolean {
-  return regExp.test(value)
-}

package/lib/validation/validators/required.ts

@@ -1,27 +0,0 @@
-export default function required(value: any): boolean {
-  if (Array.isArray(value)) {
-    return !!value.length
-  }
-
-  if (value === undefined || value === null) {
-    return false
-  }
-
-  if (value === false) {
-    return true
-  }
-
-  if (value instanceof Date) {
-    return true
-  }
-
-  if (typeof value === 'object') {
-    for (const _ in value) {
-      return true
-    }
-
-    return false
-  }
-
-  return !!String(value).length
-}

package/lib/validation/validators/requiredHMS.ts

@@ -1,17 +0,0 @@
-export interface HMS {
-  hour?: string
-  minute?: string
-  second?: string
-}
-
-export type HMSType = 'h' | 'm' | 's'
-
-const HMSMap = {
-  h: 'hour',
-  m: 'minute',
-  s: 'second'
-} as const
-
-export default function requiredHMS(hms: HMS, required: HMSType[] = ['h', 'm', 's']): boolean {
-  return required.every(r => hms[HMSMap[r]] !== undefined)
-}