@dxtmisha/constructor 0.23.0

package/src/constructors/Mask/MaskFocus.ts

@@ -0,0 +1,49 @@
+import { MaskBuffer } from './MaskBuffer'
+
+/**
+ * Class for storing element focus state.
+ *
+ * Класс для хранения состояния фокуса элемента.
+ */
+export class MaskFocus {
+  /** Focus state flag/ Флаг состояния фокуса */
+  protected value: boolean = false
+
+  /**
+   * Constructor
+   * @param buffer buffer helper object/ объект помощник буфера
+   */
+  constructor(
+    protected readonly buffer: MaskBuffer
+  ) {
+  }
+
+  /**
+   * Returns current focus state.
+   *
+   * Возвращает текущее состояние фокуса.
+   */
+  is(): boolean {
+    return this.value
+  }
+
+  /**
+   * Sets focus state to active and resets buffer.
+   *
+   * Устанавливает состояние фокуса активным и сбрасывает буфер.
+   */
+  in(): void {
+    this.value = true
+    this.buffer.reset()
+  }
+
+  /**
+   * Removes focus state and resets buffer.
+   *
+   * Снимает состояние фокуса и сбрасывает буфер.
+   */
+  out(): void {
+    this.value = false
+    this.buffer.reset()
+  }
+}

package/src/constructors/Mask/MaskFormat.ts

@@ -0,0 +1,216 @@
+import { computed } from 'vue'
+import { GeoIntl, strFill } from '@dxtmisha/functional'
+
+import { MaskType } from './MaskType'
+import { MaskRubberItem } from './MaskRubberItem'
+
+import type { FieldMasks } from '../../types/fieldTypes'
+import type { MaskSpecialList, MaskSpecialProp } from './basicTypes'
+import type { MaskProps } from './props'
+
+/**
+ * Class for working with formatted number / currency masks.
+ *
+ * Класс для работы с форматированными масками числа / валюты.
+ */
+export class MaskFormat {
+  /**
+   * Constructor
+   * @param props input data/ входные данные
+   * @param type mask type helper/ объект помощник типа маски
+   * @param rubberItem rubber groups helper/ объект помощник резиновых групп
+   */
+  constructor(
+    protected readonly props: MaskProps,
+    protected readonly type: MaskType,
+    protected readonly rubberItem: MaskRubberItem
+  ) {
+  }
+
+  /** Special symbols configuration (groups) for numeric input / Конфигурация специальных символов (группы) для числового ввода */
+  readonly special: MaskSpecialProp = {
+    n: {},
+    f: {
+      defaultValue: '0'
+    }
+  }
+
+  /** Rubber mask instructions (dynamic length per group) / Инструкции резиновой маски (динамическая длина по группам) */
+  readonly rubber = computed<MaskSpecialList>(() => {
+    return {
+      n: {
+        rubber: true,
+        transitionChar: this.getDecimal(),
+        maxLength: 10
+      },
+      f: {
+        rubber: this.isFractionRubber(),
+        maxLength: 4
+      }
+    }
+  })
+
+  /** Base view symbol per group / Базовый отображаемый символ для группы */
+  readonly view = computed<string>(() => {
+    if (this.type.isNumber()) {
+      return String.fromCharCode(8288)
+    }
+
+    return '0'
+  })
+
+  /** Fraction digits count / Количество знаков после запятой */
+  readonly fraction = computed<number>(() => {
+    if (this.type.isCurrency()) {
+      return 2
+    }
+
+    const fraction = this.props.fraction
+
+    if (typeof fraction === 'number') {
+      return fraction
+    }
+
+    if (
+      typeof fraction === 'string'
+      && fraction.match(/[0-9]+/)
+    ) {
+      return Number(fraction)
+    }
+
+    if (this.rubberItem.is('f')) {
+      return this.rubberItem.getByIndex('f') + 1
+    }
+
+    if (fraction === true) {
+      return 1
+    }
+
+    return 0
+  })
+
+  /** Returns mask characters for current numeric type / Возвращает символы маски для текущего числового типа */
+  readonly mask = computed<string[]>(() => {
+    if (this.type.isCurrency()) {
+      return this.toSpecial(this.getCurrency())
+    }
+
+    if (this.type.isNumberFormat()) {
+      return this.toSpecial(this.getNumberFormat())
+    }
+
+    return this.toSpecial(this.getNumber())
+  })
+
+  /**
+   * Is fraction part rubber (dynamic)?
+   *
+   * Является ли дробная часть резиновой (динамичной)?
+   */
+  isFractionRubber(): boolean {
+    return this.props.fraction === true
+  }
+
+  /**
+   * Returns standardized raw numeric value (integer or integer.fraction).
+   *
+   * Возвращает стандартизированное «сырое» числовое значение (целое или целое.дробь).
+   * @param value masks data object/ объект масок
+   */
+  getValueStandard(value: FieldMasks): string {
+    if (this.type.isNumber()) {
+      return value?.n?.value || ''
+    }
+
+    const number = `${value?.n?.value || '0'}.${value?.f?.value || '0'}`
+
+    if (number === '0.0') {
+      return '0'
+    }
+
+    return number
+  }
+
+  /** Returns base number mask string.
+   *
+   * Возвращает строку маски числа.
+   */
+  getNumber(): string {
+    return this.getNumberForString()
+  }
+
+  /**
+   * Returns formatted number mask string.
+   *
+   * Возвращает форматированную строку числа.
+   */
+  getNumberFormat(): string {
+    return this.getIntl().number(this.getNumberForString(), { maximumFractionDigits: 9 })
+  }
+
+  /**
+   * Returns currency mask string with appended currency symbol.
+   *
+   * Возвращает строку маски валюты с добавленным символом валюты.
+   */
+  getCurrency(): string {
+    return this.getIntl().currency(
+      this.getNumberForString(),
+      undefined,
+      this.props.currencyHide
+    )
+  }
+
+  /**
+   * Returns list of delimiter characters for switching to fraction part.
+   *
+   * Возвращает список символов-разделителей для перехода к дробной части.
+   */
+  getDecimal(): string[] {
+    return [this.getIntl().decimal(), '.']
+  }
+
+  /**
+   * Returns list of special group keys.
+   *
+   * Возвращает список ключей групп специальных символов.
+   */
+  getSpecial(): string[] {
+    return Object.keys(this.special)
+  }
+
+  /**
+   * Returns GeoIntl helper instance.
+   *
+   * Возвращает экземпляр помощника GeoIntl.
+   */
+  protected getIntl(): GeoIntl {
+    return new GeoIntl(this.props.language)
+  }
+
+  /**
+   * Builds base numeric pattern string (with optional fraction & currency).
+   *
+   * Формирует базовую строку числового паттерна (с необязательной дробью и валютой).
+   */
+  protected getNumberForString(): string {
+    const fraction = this.fraction.value
+
+    const number = strFill('9', this.rubberItem.getByIndex('n') + 1)
+    const numberFraction = fraction ? `.${strFill('3', fraction)}` : ''
+    const currency = this.type.isCurrency() && this.props.currency ? ` ${this.props.currency}` : ''
+
+    return `${number}${numberFraction}${currency}`
+  }
+
+  /**
+   * Converts digit markers (9/3) to group symbols (n/f).
+   *
+   * Преобразует цифровые маркеры (9/3) в групповые символы (n/f).
+   */
+  protected toSpecial(mask: string): string[] {
+    return mask.replace(/9/ig, 'n')
+      .replace(/3/ig, 'f')
+      .split('')
+  }
+}

package/src/constructors/Mask/MaskItem.ts

@@ -0,0 +1,218 @@
+import { computed } from 'vue'
+import { getMaxLengthAllArray, isArray } from '@dxtmisha/functional'
+
+import { MaskType } from './MaskType'
+import { MaskRubberItem } from './MaskRubberItem'
+import { MaskDate } from './MaskDate'
+import { MaskCharacterLength } from './MaskCharacterLength'
+import { MaskSpecial } from './MaskSpecial'
+import { MaskFormat } from './MaskFormat'
+
+import type { MaskList, MaskSpecialInfo } from './basicTypes'
+import type { MaskProps } from './props'
+
+/**
+ * Class for working with a mask.
+ *
+ * Класс для работы с маской.
+ */
+export class MaskItem {
+  /**
+   * Constructor
+   * @param props input data/ входные данные
+   * @param type object for working with the mask type/ объект для работы с типом маски
+   * @param rubberItem object for working with rubber elements/ объект для работы с резиновыми элементами
+   * @param characterLength object for managing input length/ объект управления длиной ввода
+   * @param date object for working with date types/ объект для работы с типом даты
+   * @param format object for managing numeric mask types/ объект для управления числовыми типами масок
+   * @param special object for working with special characters/ объект для работы со специальными символами
+   */
+  constructor(
+    protected readonly props: MaskProps,
+    protected readonly type: MaskType,
+    protected readonly rubberItem: MaskRubberItem,
+    protected readonly characterLength: MaskCharacterLength,
+    protected readonly date: MaskDate,
+    protected readonly format: MaskFormat,
+    protected readonly special: MaskSpecial
+  ) {
+  }
+
+  /**
+   * Returns the current mask.
+   *
+   * Возвращает текущую маску.
+   */
+  readonly item = computed<string[]>(() => {
+    if (this.type.isCurrencyOrNumber()) {
+      return this.format.mask.value
+    }
+
+    if (this.type.isDate()) {
+      return this.date.mask.value
+    }
+
+    return this.basic.value
+  })
+
+  /**
+   * Returns an array with information about the location of all special characters.
+   *
+   * Возвращает массив с информацией о расположении всех специальных символов.
+   */
+  readonly info = computed(() => {
+    const data: MaskSpecialInfo[] = []
+    let index = 0
+
+    this.item.value.forEach((char, key) => {
+      if (this.special.isSpecial(char)) {
+        data.push({
+          index,
+          key,
+          char
+        })
+
+        index++
+      }
+    })
+
+    return data
+  })
+
+  /**
+   * Returns the length of the mask or the maximum length of masks if there are several.
+   *
+   * Возвращает длину маски или максимальную длину масок, если их несколько.
+   */
+  readonly maxLength = computed<number>(() => {
+    const mask = this.getMask()
+
+    if (isArray(mask)) {
+      return getMaxLengthAllArray(mask)
+    } else {
+      return this.item.value.length
+    }
+  })
+
+  /**
+   * Returns the mask symbol by its index.
+   *
+   * Возвращает символ маски по его индексу.
+   * @param index index of the symbol's location/ индекс расположения символа
+   */
+  get(index: number): string {
+    return this.item.value?.[index] ?? ''
+  }
+
+  /**
+   * Returns the location number for replacement by its input symbol.
+   *
+   * Возвращает номер нахождения для замены по его символу ввода.
+   * @param char input symbol/ символ ввода
+   * @param selection minimum index for search/ минимальный индекс для поиска
+   */
+  getByChar(
+    char: string,
+    selection: number = -1
+  ): number {
+    let data = selection
+
+    this.item.value.forEach((item, index) => {
+      if (item === char && index >= selection) {
+        data = index
+      }
+    })
+
+    return data
+  }
+
+  /**
+   * Returns the length of the active mask.
+   *
+   * Возвращает длину активной маски.
+   */
+  getLength(): number {
+    return this.item.value.length
+  }
+
+  /**
+   * Returns the length of only special characters.
+   *
+   * Возвращает длину только из специальных символов.
+   */
+  getLengthBySpecial(): number {
+    return this.info.value.length
+  }
+
+  /**
+   * Returns how many special characters were highlighted.
+   *
+   * Возвращает, сколько специальных символов было выделено.
+   * @param start start of selection/ начало выделения
+   * @param end end of selection/ конец выделения
+   */
+  getQuantity(
+    start: number,
+    end: number
+  ): number {
+    if (start === end) {
+      return 1
+    }
+
+    let quantity = 0
+
+    for (let i = start; i < end; i++) {
+      if (this.special.isSpecial(this.get(i))) {
+        quantity++
+      }
+    }
+
+    return quantity
+  }
+
+  /**
+   * Returns the active mask.
+   *
+   * Возвращает активную маску.
+   */
+  protected readonly maskActive = computed<string>(() => {
+    const mask = this.getMask()
+
+    if (isArray(mask)) {
+      return mask.find(mask => this.getSpecialLength(mask) >= this.characterLength.get()) || mask?.[mask.length - 1] || ''
+    }
+
+    return mask
+  })
+
+  /**
+   * Returns the number of special characters in the current mask.
+   *
+   * Возвращает количество специальных символов в текущей маске.
+   */
+  protected readonly basic = computed<string[]>(() => {
+    return this.rubberItem.expandMask(this.maskActive.value).split('')
+  })
+
+  /**
+   * Returns a list of masks.
+   *
+   * Возвращает список масок.
+   */
+  protected getMask(): MaskList {
+    return this.props.mask ?? ''
+  }
+
+  /**
+   * Returns the number of special characters in the current mask.
+   *
+   * Возвращает количество специальных символов в текущей маске.
+   * @param mask selected mask/ выбранная маска
+   */
+  protected getSpecialLength(mask: string): number {
+    return mask
+      .split('')
+      .filter(char => this.special.isSpecial(char))
+      .length
+  }
+}

package/src/constructors/Mask/MaskMatch.ts

@@ -0,0 +1,73 @@
+import { MaskSpecial } from './MaskSpecial'
+import { isString } from '@dxtmisha/functional'
+
+import type { MaskMatchItem } from './basicTypes'
+import type { MaskProps } from './props'
+
+const MATCH_DEFAULT = /[0-9]/
+
+/**
+ * Class for checking an incoming character.
+ *
+ * Класс для проверки входящего символа.
+ */
+export class MaskMatch {
+  /**
+   * Constructor
+   * @param props input data/ входные данные
+   * @param special special symbols helper/ объект помощник специальных символов
+   */
+  constructor(
+    protected readonly props: MaskProps,
+    protected readonly special: MaskSpecial
+  ) {
+  }
+
+  /**
+   * Checks whether the character matches allowed pattern(s).
+   *
+   * Проверяет, соответствует ли символ разрешённому шаблону.
+   * @param char character to check/ символ для проверки
+   * @param groupName optional group name/ необязательное имя группы
+   */
+  is(
+    char: string,
+    groupName?: string
+  ): boolean {
+    const match = this.get(groupName)
+
+    if (match instanceof RegExp) {
+      return Boolean(char.match(match))
+    }
+
+    if (isString(match)) {
+      return Boolean(char.match(new RegExp(match)))
+    }
+
+    return Boolean(char.match(MATCH_DEFAULT))
+  }
+
+  /**
+   * Returns match definition (regexp or string) for group or global.
+   *
+   * Возвращает правило проверки (regexp или строка) для группы или глобально.
+   * @param groupName group name/ имя группы
+   */
+  get(groupName?: string): MaskMatchItem {
+    return (groupName && this.special.getMatch(groupName)) ?? this.props.match ?? MATCH_DEFAULT
+  }
+
+  /**
+   * Filters text returning only allowed characters (any group).
+   *
+   * Фильтрует текст, возвращая только допустимые символы (любая группа).
+   * @param text source text/ исходный текст
+   */
+  filter(text: string): string[] {
+    const special = this.special.item.value
+
+    return text
+      .split('')
+      .filter(char => special.find(groupName => this.is(char, groupName)))
+  }
+}

package/src/constructors/Mask/MaskPattern.ts

@@ -0,0 +1,123 @@
+import { computed } from 'vue'
+import { forEach, isObjectNotArray, isString } from '@dxtmisha/functional'
+
+import {
+  FieldInputCheckInclude,
+  type FieldInputCheckListInclude
+} from '../../classes/field/FieldInputCheckInclude'
+
+import { MaskType } from './MaskType'
+import { MaskSpecial } from './MaskSpecial'
+import { MaskDate } from './MaskDate'
+
+import type { FieldPatternItemOrFunction, FieldPatternList } from '../../types/fieldTypes'
+import type { MaskProps } from './props'
+
+/**
+ * Class for producing validation pattern data per mask group.
+ *
+ * Класс для получения данных паттернов валидации по группам маски.
+ */
+export class MaskPattern {
+  /**
+   * Constructor
+   * @param props input data/ входные данные
+   * @param type mask type helper/ объект помощник типа маски
+   * @param date date mask helper/ объект помощник маски даты
+   * @param special special symbols helper/ объект помощник специальных символов
+   */
+  constructor(
+    protected readonly props: MaskProps,
+    protected readonly type: MaskType,
+    protected readonly date: MaskDate,
+    protected readonly special: MaskSpecial
+  ) {
+  }
+
+  /** Validation input objects by group / Объекты проверки по названию группы */
+  readonly item = computed<FieldInputCheckListInclude>(() => {
+    const inputList = {} as FieldInputCheckListInclude
+
+    forEach(this.list.value, (pattern, group) => {
+      inputList[group] = new FieldInputCheckInclude(pattern, group)
+    })
+
+    if (this.props.check) {
+      inputList.check = new FieldInputCheckInclude(this.props.check)
+    }
+
+    return inputList
+  })
+
+  /** Patterns list by group / Список паттернов по группам */
+  readonly list = computed<FieldPatternList>(() => {
+    const patterns = this.getByType()
+
+    for (const index in patterns) {
+      const item = this.getPattern(index)
+
+      if (patterns[index]) {
+        if (isString(item)) {
+          Object.assign(patterns[index], { pattern: item })
+        } else if (
+          isObjectNotArray(item)
+          && isObjectNotArray(patterns[index])
+        ) {
+          Object.assign(patterns[index], item)
+        }
+      }
+    }
+
+    return patterns
+  })
+
+  /**
+   * Checks if there is a global check pattern.
+   *
+   * Проверяет, есть ли глобальный паттерн проверки.
+   */
+  isCheck(): boolean {
+    return Boolean(this.props.check)
+  }
+
+  /**
+   * Returns validation input object by group.
+   *
+   * Возвращает объект проверки по названию группы.
+   * @param groupName group name (default: check)/ имя группы (по умолчанию: check)
+   */
+  getInput(
+    groupName: string = FieldInputCheckInclude.getGroupDefault()
+  ): FieldInputCheckInclude | undefined {
+    return this.item.value?.[groupName]
+  }
+
+  /**
+   * Builds base patterns object depending on mask type.
+   *
+   * Формирует базовый объект паттернов в зависимости от типа маски.
+   */
+  protected getByType(): FieldPatternList {
+    if (this.type.isDate()) {
+      return this.date.getPattern()
+    }
+
+    const patterns: FieldPatternList = {}
+
+    this.special.item.value.forEach((name) => {
+      patterns[name] = {}
+    })
+
+    return patterns
+  }
+
+  /**
+   * Returns pattern definition for group or global pattern.
+   *
+   * Возвращает определение паттерна для группы или глобальный паттерн.
+   * @param groupName group name/ имя группы
+   */
+  protected getPattern(groupName?: string): FieldPatternItemOrFunction | undefined {
+    return (groupName && this.special.getPattern(groupName)) ?? this.props.pattern
+  }
+}