@dxtmisha/constructor 0.23.0

package/src/constructors/Mask/MaskSpecial.ts

@@ -0,0 +1,179 @@
+import { computed } from 'vue'
+import { forEach, isArray, isObject, isObjectNotArray } from '@dxtmisha/functional'
+
+import { MaskType } from './MaskType'
+import { MaskDate } from './MaskDate'
+import { MaskFormat } from './MaskFormat'
+
+import type { FieldPatternItemOrFunction } from '../../types/fieldTypes'
+import type {
+  MaskMatchItem,
+  MaskSpecialItem,
+  MaskSpecialList,
+  MaskSpecialProp
+} from './basicTypes'
+import type { MaskProps } from './props'
+
+/**
+ * Class for working with groups defined by special symbols.
+ *
+ * Класс для работы с группами, определёнными специальными символами.
+ */
+export class MaskSpecial {
+  /**
+   * Constructor
+   * @param props input data/ входные данные
+   * @param type mask type helper/ объект помощник типа маски
+   * @param date date mask helper/ объект помощник маски даты
+   * @param format numeric/currency mask helper/ объект помощник числовых масок
+   */
+  constructor(
+    protected readonly props: MaskProps,
+    protected readonly type: MaskType,
+    protected readonly date: MaskDate,
+    protected readonly format: MaskFormat
+  ) {
+  }
+
+  /**
+   * Returns list of special symbols.
+   *
+   * Возвращает список специальных символов.
+   */
+  readonly item = computed<string[]>(() => {
+    if (this.type.isCurrencyOrNumber()) {
+      return this.format.getSpecial()
+    }
+
+    if (this.type.isTime()) {
+      return this.date.getSpecialFull()
+    }
+
+    if (this.type.isDate()) {
+      return this.date.getSpecialDate()
+    }
+
+    const special = this.special.value
+
+    if (isArray(special)) {
+      return special
+    }
+
+    if (isObject(special)) {
+      return Object.keys(special)
+    }
+
+    return [special]
+  })
+
+  /**
+   * Returns map of only rubber-enabled groups.
+   *
+   * Возвращает карту только резиновых групп.
+   */
+  readonly rubberList = computed<MaskSpecialList>(() => {
+    const data: MaskSpecialList = {}
+
+    if (isObjectNotArray(this.special.value)) {
+      forEach(this.special.value, (item, index) => {
+        if (item?.rubber) {
+          data[index] = item
+        }
+      })
+    }
+
+    return data
+  })
+
+  /**
+   * Checks if symbol is special.
+   *
+   * Проверяет, является ли символ специальным.
+   * @param char symbol to check/ символ для проверки
+   */
+  isSpecial(char: string): boolean {
+    return this.item.value.indexOf(char) !== -1
+  }
+
+  /**
+   * Checks if group has default value.
+   *
+   * Проверяет, имеет ли группа значение по умолчанию.
+   * @param groupName group name/ название группы
+   */
+  isDefault(groupName: string): boolean {
+    return Boolean(this.getDefault(groupName))
+  }
+
+  /**
+   * Returns default value for group.
+   *
+   * Возвращает значение по умолчанию для группы.
+   * @param groupName group name/ название группы
+   */
+  getDefault(groupName: string): MaskMatchItem | undefined {
+    return this.getSpecialItem(groupName)?.defaultValue
+  }
+
+  /**
+   * Returns matcher (regexp/string) for group.
+   *
+   * Возвращает выражение для проверки группы.
+   * @param groupName group name/ название группы
+   */
+  getMatch(groupName: string): MaskMatchItem | undefined {
+    return this.getSpecialItem(groupName)?.match
+  }
+
+  /**
+   * Returns pattern definition for group.
+   *
+   * Возвращает pattern для группы.
+   * @param groupName group name/ название группы
+   */
+  getPattern(groupName: string): FieldPatternItemOrFunction | undefined {
+    return this.getSpecialItem(groupName)?.pattern
+  }
+
+  /**
+   * Returns view (display character) for group.
+   *
+   * Возвращает отображаемый символ для группы.
+   * @param groupName group name/ название группы
+   */
+  getView(groupName: string): string | undefined {
+    return this.getSpecialItem(groupName)?.view
+  }
+
+  /**
+   * Returns special property (original definition).
+   *
+   * Возвращает свойство special (оригинальное определение).
+   */
+  protected readonly special = computed<MaskSpecialProp>(() => {
+    if (this.type.isCurrencyOrNumber()) {
+      return this.format.special
+    }
+
+    return this.props.special ?? '*'
+  })
+
+  /**
+   * Returns special group item data by name.
+   *
+   * Возвращает данные группы special по имени.
+   * @param groupName group name/ название группы
+   */
+  protected getSpecialItem(groupName: string): MaskSpecialItem | undefined {
+    const special = this.special.value
+
+    if (
+      isObjectNotArray(special)
+      && groupName in special
+    ) {
+      return special[groupName]
+    }
+
+    return undefined
+  }
+}

package/src/constructors/Mask/MaskType.ts

@@ -0,0 +1,103 @@
+import { computed } from 'vue'
+import type { GeoDate } from '@dxtmisha/functional'
+
+import type { MaskTypeItem } from './basicTypes'
+import type { MaskProps } from './props'
+
+/**
+ * Class for defining the mask type.
+ *
+ * Класс для определения типа маски.
+ */
+export class MaskType {
+  /**
+   * Constructor
+   * @param props input data/ входные данные
+   */
+  constructor(
+    protected readonly props: MaskProps
+  ) {
+  }
+
+  /** Current mask type (default: text)/ Текущий тип маски (по умолчанию: text) */
+  readonly item = computed<MaskTypeItem>(() => this.props.type ?? 'text')
+
+  /**
+   * Is the mask simple number type.
+   *
+   * Является ли маска простым числовым типом (number).
+   */
+  isNumber(): boolean {
+    return this.item.value === 'number'
+  }
+
+  /**
+   * Is the mask formatted number type (number-format).
+   *
+   * Является ли маска типом форматированного числа (number-format).
+   */
+  isNumberFormat(): boolean {
+    return this.item.value === 'number-format'
+  }
+
+  /**
+   * Is the mask currency type.
+   *
+   * Является ли маска валютным типом (currency).
+   */
+  isCurrency(): boolean {
+    return this.item.value === 'currency'
+  }
+
+  /**
+   * Is the mask one of numeric related types (number | number-format | currency).
+   *
+   * Является ли маска одним из числовых типов (number | number-format | currency).
+   */
+  isCurrencyOrNumber(): boolean {
+    return this.isNumber() || this.isNumberFormat() || this.isCurrency()
+  }
+
+  /**
+   * Is the mask one of the time input types.
+   *
+   * Является ли маска одним из типов для ввода времени.
+   */
+  isTime(): boolean {
+    return [
+      'full',
+      'datetime',
+      'time',
+      'hour-minute',
+      'hour',
+      'minute',
+      'second'
+    ].indexOf(this.item.value) !== -1
+  }
+
+  /**
+   * Is the mask one of the date (or time) input types.
+   *
+   * Является ли маска одним из типов для ввода даты (или времени).
+   */
+  isDate(): boolean {
+    return this.isTime()
+      || [
+        'date',
+        'year',
+        'year-month',
+        'month',
+        'day',
+        'day-month'
+      ].indexOf(this.item.value) !== -1
+  }
+
+  /**
+   * Returns GeoDate-compatible mask type (fallback: date).
+   *
+   * Возвращает тип маски совместимый с GeoDate (если нет — date).
+   */
+  getByDate(): GeoDate {
+    return this.isDate() ? (this.item.value as GeoDate) : 'date'
+  }
+}

package/src/constructors/Mask/MaskValidation.ts

@@ -0,0 +1,102 @@
+import { computed } from 'vue'
+
+import { FieldInputCheckInclude } from '../../classes/field/FieldInputCheckInclude'
+import { MaskPattern } from './MaskPattern'
+import { MaskValue } from './MaskValue'
+
+import type { FieldValidationItem } from '../../types/fieldTypes'
+
+/**
+ * Class for working with the validity of entered data.
+ *
+ * Класс для работы с валидностью введённых данных.
+ */
+export class MaskValidation {
+  /**
+   * Constructor
+   * @param pattern object for working with input data validation/ объект для работы с проверкой введённых данных
+   * @param value object for working with entered data/ объект для работы с введёнными данными
+   */
+  constructor(
+    protected readonly pattern: MaskPattern,
+    protected readonly value: MaskValue
+  ) {
+  }
+
+  /** Validation error info or undefined/ Информация об ошибке или undefined */
+  readonly item = computed(() => {
+    for (const input of Object.values(this.pattern.item.value)) {
+      const item = this.value.getInfoItem(input.group)
+
+      if (item && item.full) {
+        const check = input.check(item.value)
+
+        if (check && !check.status) {
+          return {
+            ...check,
+            value: this.value.item.value
+          }
+        }
+      }
+    }
+
+    return this.getValidationCheck()
+  })
+
+  /**
+   * Checks if the current group has an error.
+   *
+   * Проверяет, есть ли ошибка у текущей группы.
+   * @param groupName group name/ название группы
+   */
+  isError(groupName: string): boolean {
+    const groupError = this.item.value?.group
+
+    return Boolean(
+      groupError && (
+        groupError === groupName
+        || groupError === FieldInputCheckInclude.getGroupDefault()
+      )
+    )
+  }
+
+  /**
+   * Checks the correctness of filling in the values.
+   *
+   * Проверяет корректность заполнения значений.
+   */
+  checkValidity(): boolean {
+    return this.item.value === undefined
+  }
+
+  /**
+   * Getting global check data.
+   *
+   * Получение данных глобальной проверки.
+   */
+  protected getValidationCheck(): FieldValidationItem {
+    if (this.value.isFull.value) {
+      const item = this.value.getForCheck()
+
+      if (this.pattern.isCheck()) {
+        const check = this.pattern.getInput(item.group)?.check(item.value)
+
+        if (check && !check.status) {
+          return check
+        }
+      }
+
+      return {
+        status: true,
+        value: item.value,
+        isFull: true
+      }
+    }
+
+    return {
+      status: true,
+      value: this.value.item.value,
+      isFull: false
+    }
+  }
+}

package/src/constructors/Mask/MaskValue.ts

@@ -0,0 +1,225 @@
+import { computed, watch } from 'vue'
+
+import { FieldInputCheckInclude } from '../../classes/field/FieldInputCheckInclude'
+import { MaskType } from './MaskType'
+import { MaskDate } from './MaskDate'
+import { MaskFormat } from './MaskFormat'
+import { MaskItem } from './MaskItem'
+import { MaskSpecial } from './MaskSpecial'
+import { MaskValueBasic } from './MaskValueBasic'
+
+import type { FieldMaskItem, FieldMasks } from '../../types/fieldTypes'
+import { MASK_CHAR_DELETE } from './basicTypes'
+import type { MaskProps } from './props'
+
+/**
+ * Class for transforming the entered data into the final result.
+ *
+ * Класс для преобразования введенных данных в конечный результат.
+ */
+export class MaskValue {
+  protected infoCache?: FieldMasks
+
+  /**
+   * Constructor
+   * @param props input data/ входные данные
+   * @param type object for working with the mask type/ объект для работы с типом маски
+   * @param date object for working with date types/ объект для работы с типом даты
+   * @param format object for managing numeric mask types/ объект для управления числовыми типами масок
+   * @param mask object for managing masks/ объект управления маской
+   * @param special object for working with special characters/ объект для работы со специальными символами
+   * @param valueBasic object for working with base values/ объект для работы с базовыми значениями
+   */
+  constructor(
+    protected readonly props: MaskProps,
+    protected readonly type: MaskType,
+    protected readonly date: MaskDate,
+    protected readonly format: MaskFormat,
+    protected readonly mask: MaskItem,
+    protected readonly special: MaskSpecial,
+    protected readonly valueBasic: MaskValueBasic
+  ) {
+    watch(this.info, (_, old) => {
+      if (this.type.isDate()) {
+        this.infoCache = old
+      }
+    })
+  }
+
+  /**
+   * Receiving a list with information about standard values/
+   * Получение списка с информацией о стандартных значениях
+   */
+  readonly info = computed<FieldMasks>(() => {
+    const standard = this.valueBasic.item.value
+    const data: FieldMasks = {}
+
+    this.mask.item.value.forEach((char, index) => {
+      if (this.special.isSpecial(char)) {
+        const value = this.add(data, char)
+
+        if (
+          this.isStandard(index)
+          && standard[index] !== MASK_CHAR_DELETE
+        ) {
+          value.chars.push(String(standard[index]))
+        }
+
+        value.maxLength++
+        value.end = value.maxLength === value.chars.length
+        value.full = this.special.isDefault(char) || value.end
+        value.value = value.full ? value.chars.join('') : ''
+      }
+    })
+
+    return data
+  })
+
+  /** Final value (shortcut)/ Финальное значение (ярлык) */
+  readonly item = computed(() => this.getValue(this.info.value))
+
+  /** Checks if the mask is fully filled/ Проверяет, полностью ли заполнена маска */
+  readonly isFull = computed<boolean>(() => {
+    for (const item of Object.values(this.info.value)) {
+      if (!item.full) {
+        return false
+      }
+    }
+
+    return true
+  })
+
+  /** Checks if the mask is fully filled by length/ Проверяет, полностью ли заполнена маска по длине */
+  readonly isEnd = computed<boolean>(() => {
+    for (const item of Object.values(this.info.value)) {
+      if (!item.end) {
+        return false
+      }
+    }
+
+    return true
+  })
+
+  /**
+   * Returns old values.
+   *
+   * Возвращает старые значения.
+   */
+  getValueCache(): string {
+    if (this.infoCache) {
+      return this.getValue(this.infoCache)
+    }
+
+    return this.item.value
+  }
+
+  /**
+   * Getting full information for global verification.
+   *
+   * Получение полной информации для глобальной проверки.
+   */
+  getForCheck(): FieldMaskItem {
+    const value = this.item.value
+
+    return {
+      group: FieldInputCheckInclude.getGroupDefault(),
+      value,
+      maxLength: value.length,
+      full: this.isFull.value,
+      end: this.isEnd.value,
+      chars: value.split('')
+    }
+  }
+
+  /**
+   * Getting information for a specific group.
+   *
+   * Получение информации для конкретной группы.
+   * @param groupName group name/ название группы
+   */
+  getInfoItem(groupName: string): FieldMaskItem | undefined {
+    return this.info.value?.[groupName]
+  }
+
+  /** Returns the final form of the value/ Возвращает финальный вид значения */
+  protected readonly valueFinal = computed(() => {
+    const basic = this.valueBasic.item.value.split('')
+    const mask = this.mask.item.value
+    let data: string = ''
+
+    for (const index in mask) {
+      if (index in basic) {
+        data += basic[index]
+      } else if (mask[index]) {
+        const defaultValue = this.special.getDefault(mask[index])
+
+        if (defaultValue) {
+          data += defaultValue
+        }
+      }
+    }
+
+    return data
+  })
+
+  /**
+   * Checks if there is a value by the key number in the basic values.
+   *
+   * Проверяет, есть ли значение по номеру ключа в базовых значениях.
+   * @param index key number/ номер ключа
+   */
+  protected isStandard(index: number): boolean {
+    return Boolean(this.valueBasic.getChar(index))
+  }
+
+  /**
+   * Returns values based on the specified data information structure.
+   *
+   * Возвращает значения по указанной структуре информации о данных.
+   * @param info data information/ информация о данных
+   */
+  protected getValue(info: FieldMasks) {
+    if (this.type.isCurrencyOrNumber()) {
+      return this.format.getValueStandard(info)
+    }
+
+    if (this.type.isDate()) {
+      if (this.isFull.value) {
+        return this.date.getValueStandard(info)
+      }
+
+      return ''
+    }
+
+    if (
+      this.props.fullOnly
+      && !this.isFull.value
+    ) {
+      return ''
+    }
+
+    return this.valueFinal.value
+  }
+
+  /**
+   * Adding a new character to the list divided by groups if it is not there and returning the property of the given group.
+   *
+   * Добавление нового символа в список, разделенный по группам, если его там нет, и возвращение свойства данной группы.
+   * @param data data for verification/ данные для проверки
+   * @param groupName group name/ название группы
+   */
+  protected add(data: FieldMasks, groupName: string): FieldMaskItem {
+    if (!(groupName in data)) {
+      data[groupName] = {
+        group: groupName,
+        value: '',
+        maxLength: 0,
+        full: false,
+        end: false,
+        chars: []
+      }
+    }
+
+    return data[groupName] as FieldMaskItem
+  }
+}

package/src/constructors/Mask/MaskValueBasic.ts

@@ -0,0 +1,87 @@
+import { computed } from 'vue'
+
+import { MaskRubberTransition } from './MaskRubberTransition'
+import { MaskItem } from './MaskItem'
+import { MaskSpecial } from './MaskSpecial'
+import { MaskCharacter } from './MaskCharacter'
+
+/**
+ * Class for getting basic input values.
+ *
+ * Класс для получения базовых вводимых значений.
+ */
+export class MaskValueBasic {
+  /**
+   * Constructor
+   * @param rubberTransition object for managing the transition character/ объект для управления символом перехода
+   * @param mask object for managing masks/ объект управления маской
+   * @param special object for working with special characters/ объект для работы со специальными символами
+   * @param character object for managing entered character/ объект для управления введённым символом
+   */
+  constructor(
+    protected readonly rubberTransition: MaskRubberTransition,
+    protected readonly mask: MaskItem,
+    protected readonly special: MaskSpecial,
+    protected readonly character: MaskCharacter
+  ) {
+  }
+
+  /**
+   * Receiving basic standard values.
+   *
+   * Получение базовых стандартных значений.
+   */
+  readonly item = computed(() => {
+    const character = this.character.item.value
+    const value: string[] = []
+    let key = 0 as number
+
+    for (const char of this.mask.item.value) {
+      if (!this.special.isSpecial(char)) {
+        value.push(char)
+      } else if (key in character) {
+        value.push(String(character[key++]))
+
+        if (
+          key > character.length
+          && this.rubberTransition.is()
+          && !this.rubberTransition.isChar(char)
+        ) {
+          break
+        }
+      } else {
+        break
+      }
+    }
+
+    return value.join('')
+  })
+
+  /**
+   * Checks if the values are filled in.
+   *
+   * Проверяет, заполнены ли значения.
+   */
+  is(): boolean {
+    return this.getLength() > 0
+  }
+
+  /**
+   * Getting the character from the basic standard values by its key number.
+   *
+   * Получение символа из базовых стандартных значений по его номеру ключа.
+   * @param index key number/ номер ключа
+   */
+  getChar(index: number): string | undefined {
+    return this.item.value?.[index]
+  }
+
+  /**
+   * Getting the length of basic standard values.
+   *
+   * Получение длины базовых стандартных значений.
+   */
+  getLength(): number {
+    return this.item.value.length
+  }
+}