prlg-ui 1.8.132 → 1.8.134

package/dist/utils/index.ts

@@ -0,0 +1,3 @@
+import Portal from "./Portal.vue";
+
+export { Portal };

package/dist/utils/isClient.util.ts

@@ -0,0 +1,3 @@
+export default function isClient(): boolean {
+    return !!(typeof window !== 'undefined' && window.document && window.document.createElement);
+}

package/dist/utils/mask.util.test.ts

@@ -0,0 +1,170 @@
+import { describe, it, expect, beforeEach } from 'vitest'
+import { Mask } from './mask.util'
+
+// Mock HTMLInputElement
+class MockHTMLInputElement {
+    value: string = ''
+    
+    constructor() {}
+}
+
+describe('Mask', () => {
+    let mask: Mask
+    let mockInput: MockHTMLInputElement
+
+    beforeEach(() => {
+        mask = new Mask()
+        mockInput = new MockHTMLInputElement()
+    })
+
+    const createEvent = (value: string): Event => {
+        mockInput.value = value
+        return { target: mockInput } as unknown as Event
+    }
+
+    describe('getDateMask', () => {
+        it('должен ограничивать ввод только цифрами', () => {
+            const event = createEvent('abc123def')
+            mask.getDateMask(event)
+            expect(mockInput.value).toBe('12.3')
+        })
+
+        it('должен применять маску dd.mm.yyyy по умолчанию', () => {
+            const event = createEvent('12065678')
+            mask.getDateMask(event)
+            expect(mockInput.value).toBe('12.06.5678')
+        })
+
+        it('должен ограничивать длину ввода согласно формату', () => {
+            const event = createEvent('120656789012345')
+            mask.getDateMask(event)
+            expect(mockInput.value).toBe('12.06.5678')
+        })
+
+        it('должен корректировать неправильный день больше 31', () => {
+            const event = createEvent('3201')
+            mask.getDateMask(event)
+            expect(mockInput.value).toBe('31.01')
+        })
+
+        it('должен корректировать день 00 на 01', () => {
+            const event = createEvent('0001')
+            mask.getDateMask(event)
+            expect(mockInput.value).toBe('01.01')
+        })
+
+        it('должен корректировать неправильный месяц больше 12', () => {
+            const event = createEvent('0113')
+            mask.getDateMask(event)
+            expect(mockInput.value).toBe('01.12')
+        })
+
+        it('должен корректировать месяц 00 на 01', () => {
+            const event = createEvent('0100')
+            mask.getDateMask(event)
+            expect(mockInput.value).toBe('01.01')
+        })
+
+        it('должен корректировать 31.06 на 30.06 (июнь имеет 30 дней)', () => {
+            const event = createEvent('3106')
+            mask.getDateMask(event)
+            expect(mockInput.value).toBe('30.06')
+        })
+
+        it('должен корректировать 31.04 на 30.04 (апрель имеет 30 дней)', () => {
+            const event = createEvent('3104')
+            mask.getDateMask(event)
+            expect(mockInput.value).toBe('30.04')
+        })
+
+        it('должен разрешать 31.01 (январь имеет 31 день)', () => {
+            const event = createEvent('3101')
+            mask.getDateMask(event)
+            expect(mockInput.value).toBe('31.01')
+        })
+
+        it('должен разрешать 29.02 (максимум для февраля)', () => {
+            const event = createEvent('2902')
+            mask.getDateMask(event)
+            expect(mockInput.value).toBe('29.02')
+        })
+
+        it('должен корректировать 30.02 на 29.02', () => {
+            const event = createEvent('3002')
+            mask.getDateMask(event)
+            expect(mockInput.value).toBe('29.02')
+        })
+
+        it('должен не подставлять год если пользователь ввел только день и месяц', () => {
+            const event = createEvent('1206')
+            mask.getDateMask(event)
+            expect(mockInput.value).toBe('12.06')
+            expect(mockInput.value.length).toBe(5)
+        })
+
+        it('должен использовать автокоррекцию dayjs когда начинает вводить год', () => {
+            const event = createEvent('31062025')
+            mask.getDateMask(event)
+            // dayjs скорректирует 31.06.2025 на 01.07.2025
+            expect(mockInput.value).toBe('01.07.2025')
+        })
+
+        it('должен работать с частично введенным годом', () => {
+            const event = createEvent('3106202')
+            mask.getDateMask(event)
+            // При частичном годе (7 символов, больше yearStart=6) используется dayjs
+            // dayjs корректирует 31.06.2020 -> 01.07.2020, затем обрезается до 7 символов
+            expect(mockInput.value).toBe('01.07.202')
+        })
+
+        it('должен принимать параметры minDate и maxDate без ошибок', () => {
+            const event = createEvent('01012020')
+            expect(() => {
+                mask.getDateMask(event, 'dd.mm.yyyy', '01.01.2021')
+            }).not.toThrow()
+        })
+
+        it('должен принимать параметры maxDate без ошибок', () => {
+            const event = createEvent('01012025')
+            expect(() => {
+                mask.getDateMask(event, 'dd.mm.yyyy', undefined, '31.12.2024')
+            }).not.toThrow()
+        })
+
+        it('должен не изменять дату если она в пределах minDate и maxDate', () => {
+            const event = createEvent('15062023')
+            mask.getDateMask(event, 'dd.mm.yyyy', '01.01.2023', '31.12.2023')
+            expect(mockInput.value).toBe('15.06.2023')
+        })
+
+        it('должен работать с форматом mm.dd.yyyy', () => {
+            const event = createEvent('12312023')
+            mask.getDateMask(event, 'mm.dd.yyyy')
+            expect(mockInput.value).toBe('12.31.2023')
+        })
+
+        it('должен корректировать неправильную дату в формате mm.dd.yyyy', () => {
+            const event = createEvent('13312023')
+            mask.getDateMask(event, 'mm.dd.yyyy')
+            expect(mockInput.value).toBe('12.31.2023')
+        })
+
+        it('должен возвращать пустое значение если target не HTMLInputElement', () => {
+            const event = { target: null } as unknown as Event
+            mask.getDateMask(event)
+            // Не должно выбросить ошибку
+        })
+
+        it('должен обрабатывать пустой ввод', () => {
+            const event = createEvent('')
+            mask.getDateMask(event)
+            expect(mockInput.value).toBe('')
+        })
+
+        it('должен обрабатывать ввод одной цифры', () => {
+            const event = createEvent('1')
+            mask.getDateMask(event)
+            expect(mockInput.value).toBe('1')
+        })
+    })
+})

package/dist/utils/mask.util.ts

@@ -0,0 +1,217 @@
+import { dayjs } from '../dayjs.util'
+
+export class Mask {
+    public constructor() {
+    }
+
+    public getPhoneMask(_e: Event, _format: string = '(999) 999-99-99') {
+
+    }
+
+    public getDateMask(e: Event, format: string = 'dd.mm.yyyy', minDate?: string, maxDate?: string) {
+        const input = e.target as HTMLInputElement
+        if (!input) return
+
+        let value = input.value.replace(/\D/g, '')
+        
+        const formatLength = format.replace(/\W/g, '').length
+        
+        if (value.length > formatLength) {
+            value = value.slice(0, formatLength)
+        }
+
+        value = this.correctDateValues(value, format)
+
+        let maskedValue = ''
+        let valueIndex = 0
+
+        for (let i = 0; i < format.length && valueIndex < value.length; i++) {
+            const formatChar = format[i]
+            
+            if (formatChar === 'd' || formatChar === 'm' || formatChar === 'y') {
+                maskedValue += value[valueIndex]
+                valueIndex++
+            } else {
+                maskedValue += formatChar
+            }
+        }
+
+        if (maskedValue.length >= format.length) {
+            const parsedDate = this.parseDate(maskedValue, format)
+            if (parsedDate && parsedDate.isValid()) {
+                const correctedDate = this.applyDateLimits(maskedValue, format, minDate, maxDate)
+                if (correctedDate) {
+                    maskedValue = correctedDate
+                }
+            }
+        }
+
+        input.value = maskedValue
+    }
+
+    private parseDate(value: string, format: string) {
+        return dayjs(value, format.toLowerCase())
+    }
+
+    private correctDateValues(value: string, format: string): string {
+        if (value.length < 2) return value
+
+        const formatLower = format.toLowerCase()
+        const dayIndex = formatLower.indexOf('dd')
+        const monthIndex = formatLower.indexOf('mm')
+
+        let correctedValue = value
+
+        // Корректировка дня (01-31)
+        if (dayIndex !== -1 && value.length >= 2) {
+            const dayValue = parseInt(value.substring(0, 2))
+            if (dayValue > 31) {
+                correctedValue = '31' + value.substring(2)
+            } else if (dayValue === 0) {
+                correctedValue = '01' + value.substring(2)
+            }
+        }
+
+        // Корректировка месяца (01-12)
+        if (monthIndex !== -1 && correctedValue.length >= 4) {
+            const monthStart = monthIndex === 0 ? 0 : 2
+            const monthValue = parseInt(correctedValue.substring(monthStart, monthStart + 2))
+            if (monthValue > 12) {
+                correctedValue = correctedValue.substring(0, monthStart) + '12' + correctedValue.substring(monthStart + 2)
+            } else if (monthValue === 0) {
+                correctedValue = correctedValue.substring(0, monthStart) + '01' + correctedValue.substring(monthStart + 2)
+            }
+        }
+
+        // Корректировка даты через dayjs (минимум 4 символа для дд.мм)
+        if (correctedValue.length >= 4 && dayIndex !== -1 && monthIndex !== -1) {
+            correctedValue = this.correctDateThroughDayjs(correctedValue, format)
+        }
+
+        return correctedValue
+    }
+
+    private correctDateThroughDayjs(value: string, format: string): string {
+        const formatLower = format.toLowerCase()
+        // const dayIndex = formatLower.indexOf('dd')
+        // const monthIndex = formatLower.indexOf('mm')
+        const yearIndex = formatLower.indexOf('yyyy')
+
+        // const dayStart = dayIndex === 0 ? 0 : dayIndex === 3 ? 3 : 6
+        // const monthStart = monthIndex === 0 ? 0 : monthIndex === 3 ? 3 : 6
+        const yearStart = yearIndex === 0 ? 0 : yearIndex === 3 ? 3 : 6
+
+        // Проверяем, есть ли минимум день и месяц (4 символа для dd.mm)
+        if (value.length < 4) {
+            return value
+        }
+
+        // Проверяем, начал ли пользователь вводить год
+        const hasStartedYear = value.length > yearStart
+        if (!hasStartedYear) {
+            // Если год не начал вводить, только проверяем день/месяц без автокоррекции через dayjs
+            return this.correctDayAndMonthOnly(value, format)
+        }
+
+        let maskedForParsing = ''
+        let valueIndex = 0
+
+        for (let i = 0; i < format.length && valueIndex < value.length; i++) {
+            const formatChar = format[i]
+            
+            if (formatChar === 'd' || formatChar === 'm' || formatChar === 'y') {
+                maskedForParsing += value[valueIndex] || '0'
+                valueIndex++
+            } else {
+                maskedForParsing += formatChar
+            }
+        }
+
+        // Если год не полный, дополняем текущим годом для валидации
+        if (maskedForParsing.length < format.length) {
+            const currentYear = new Date().getFullYear().toString()
+            const missingLength = format.length - maskedForParsing.length
+            maskedForParsing += currentYear.slice(-missingLength)
+        }
+
+        try {
+            const parsedDate = dayjs(maskedForParsing, format.toUpperCase())
+            if (parsedDate.isValid()) {
+                const correctedDateString = parsedDate.format(format.toUpperCase())
+                const correctedDigits = correctedDateString.replace(/\D/g, '')
+                // Возвращаем только то количество цифр, которое пользователь ввел
+                return correctedDigits.substring(0, value.length)
+            }
+        } catch (e) {
+            // Если парсинг не удался, возвращаем исходное значение
+        }
+
+        return value
+    }
+
+    private correctDayAndMonthOnly(value: string, format: string): string {
+        const formatLower = format.toLowerCase()
+        const dayIndex = formatLower.indexOf('dd')
+        const monthIndex = formatLower.indexOf('mm')
+
+        const dayStart = dayIndex === 0 ? 0 : dayIndex === 3 ? 3 : 6
+        const monthStart = monthIndex === 0 ? 0 : monthIndex === 3 ? 3 : 6
+
+        // Минимум нужно 4 символа для dd.mm
+        if (value.length < 4) return value
+
+        const day = parseInt(value.substring(dayStart, dayStart + 2))
+        const month = parseInt(value.substring(monthStart, monthStart + 2))
+        
+        if (!day || !month) return value
+
+        // Определяем количество дней в месяце
+        const daysInMonth = this.getDaysInMonth(month)
+
+        if (day > daysInMonth) {
+            const correctedDay = daysInMonth.toString().padStart(2, '0')
+            return value.substring(0, dayStart) + correctedDay + value.substring(dayStart + 2)
+        }
+
+        return value
+    }
+
+    private getDaysInMonth(month: number): number {
+        const daysInMonths = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
+        if (month < 1 || month > 12) return 31
+        return daysInMonths[month - 1]
+    }
+
+    private applyDateLimits(dateString: string, format: string, minDate?: string, maxDate?: string): string | null {
+        if (!minDate && !maxDate) {
+            return null
+        }
+
+        const parsedDate = this.parseDate(dateString, format)
+        
+        if (!parsedDate || !parsedDate.isValid()) {
+            return null
+        }
+
+        let correctedDate = parsedDate
+        let hasChanges = false
+
+        if (minDate) {
+            const minDateObj = dayjs(minDate)
+            if (correctedDate.isBefore(minDateObj)) {
+                correctedDate = minDateObj
+                hasChanges = true
+            }
+        }
+
+        if (maxDate) {
+            const maxDateObj = dayjs(maxDate)
+            if (correctedDate.isAfter(maxDateObj)) {
+                correctedDate = maxDateObj
+                hasChanges = true
+            }
+        }
+
+        return hasChanges ? correctedDate.format(format.toUpperCase()) : null
+    }
+}

package/dist/utils/onClickOutside.util.ts

@@ -0,0 +1,78 @@
+import type { ComponentPublicInstance, MaybeRef, MaybeRefOrGetter } from 'vue';
+import { unref, toValue } from 'vue';
+
+export type VueInstance = ComponentPublicInstance;
+export type MaybeElement = HTMLElement | SVGElement | VueInstance | undefined | null;
+export type MaybeElementRef<T extends MaybeElement = MaybeElement> = MaybeRef<T>;
+export type MaybeElementTarget = MaybeElementRef<MaybeElement> | string;
+
+export interface OnClickOutsideOptions {
+  ignore?: MaybeRefOrGetter<(MaybeElementRef<MaybeElement> | string)[]>;
+}
+
+const activeListeners = new WeakMap<HTMLElement, () => void>();
+
+function unrefElement(elRef: MaybeElementRef<MaybeElement>): HTMLElement | null {
+  const plain = unref(elRef);
+  return (plain as VueInstance)?.$el ?? (plain as HTMLElement | null);
+}
+
+function resolveTarget(target: MaybeElementTarget): HTMLElement | null {
+  if (typeof target === 'string') {
+    return document.querySelector(target) as HTMLElement | null;
+  }
+  return unrefElement(target);
+}
+
+export function onClickOutside(
+    target: MaybeElementTarget,
+    handler: (event: MouseEvent | TouchEvent) => void,
+    options: OnClickOutsideOptions = {}
+): () => void {
+  const targetElement = resolveTarget(target);
+  if (!targetElement) return () => {};
+
+  // Remove existing listener if present
+  const existingCleanup = activeListeners.get(targetElement);
+  if (existingCleanup) {
+    existingCleanup();
+    activeListeners.delete(targetElement);
+  }
+
+  const listener = (event: MouseEvent | TouchEvent) => {
+    const targetNode = event.target instanceof Node ? event.target : null;
+    if (!targetNode) return;
+
+    const rawIgnores = toValue(options.ignore) ?? [];
+    const ignoreElements = rawIgnores
+        .map(el => {
+          if (typeof el === 'string') {
+            return document.querySelector(el) as HTMLElement | null;
+          }
+          return unrefElement(el);
+        })
+        .filter((el): el is HTMLElement => el !== null && el !== undefined);
+
+    if (
+        targetElement.contains(targetNode) ||
+        ignoreElements.some(ignoreEl => ignoreEl.contains(targetNode))
+    ) {
+      return;
+    }
+
+    handler(event);
+  };
+
+  document.addEventListener('mousedown', listener, { capture: true });
+  document.addEventListener('touchstart', listener, { capture: true });
+
+  // Store cleanup function and return it
+  const cleanup = () => {
+    document.removeEventListener('mousedown', listener, { capture: true });
+    document.removeEventListener('touchstart', listener, { capture: true });
+    activeListeners.delete(targetElement);
+  };
+  activeListeners.set(targetElement, cleanup);
+
+  return cleanup;
+}

package/dist/utils/parseDate.util.ts

@@ -0,0 +1,41 @@
+function parseDurationToSeconds(duration: string): number {
+    const regex = /^(\d+)(s|m|h|d|day|month|year)$/;
+    const match = duration.match(regex);
+
+    if (!match) {
+        throw new Error('Invalid duration format. Use formats like 30d, 1m, 1h, 1day, 1month, 1year');
+    }
+
+    const value = parseInt(match[1], 10);
+    const unit = match[2];
+
+    switch (unit) {
+        case 's':
+            return value; // seconds
+        case 'm':
+            return value * 60; // minutes
+        case 'h':
+            return value * 3600; // hours
+        case 'd':
+        case 'day':
+            return value * 86400; // days
+        case 'month':
+            return value * 2592000; // months (30 days)
+        case 'year':
+            return value * 31536000; // years (365 days)
+        default:
+            throw new Error('Unsupported time unit');
+    }
+}
+
+export default parseDurationToSeconds;
+
+/** Примеры использования */
+/** example
+ console.log(parseDurationToSeconds('30d')); // 2592000
+ console.log(parseDurationToSeconds('1m')); // 60
+ console.log(parseDurationToSeconds('1h')); // 3600
+ console.log(parseDurationToSeconds('1day')); // 86400
+ console.log(parseDurationToSeconds('1month')); // 2592000
+ console.log(parseDurationToSeconds('1year')); // 31536000
+ */

package/dist/utils/parseFileSize.util.ts

@@ -0,0 +1,38 @@
+/**
+ * Преобразует строку с размером файла (например, "5mb", "10kb", "1.5gb") в число байт.
+ * 
+ * @param {string} size - Строка, содержащая числовое значение и единицу измерения (b, kb, mb, gb, tb).
+ *                       Пример: "5mb", "10kb", "1.5gb".
+ * @returns {number} - Размер в байтах.
+ * 
+ * Поддерживаемые единицы: b, kb, mb, gb, tb (регистр не имеет значения).
+ * Если единица не указана, по умолчанию считается "b" (байты).
+ */
+
+export const parseFileSize = (size: string): number => {
+    const units = ['b', 'kb', 'mb', 'gb', 'tb'];
+    const unit = size.match(/[a-zA-Z]+/)?.[0] || 'b';
+    const value = parseFloat(size.replace(unit, ''));
+    const index = units.indexOf(unit.toLowerCase());
+    return value * Math.pow(1024, index);
+}
+
+/**
+ * Преобразует размер файла в байтах в человекочитаемый текст (например, "1.5 МБ").
+ * 
+ * @param {number} bytes - Размер файла в байтах.
+ * @returns {string} - Размер файла в виде строки с подходящей единицей (Б, КБ, МБ, ГБ, ТБ).
+ */
+export function formatFileSize(bytes: number): string {
+    if (isNaN(bytes) || bytes < 0) return '0 Б';
+    const units = ['Б', 'КБ', 'МБ', 'ГБ', 'ТБ'];
+    let index = 0;
+    let value = bytes;
+    while (value >= 1024 && index < units.length - 1) {
+        value = value / 1024;
+        index++;
+    }
+    // Округляем до одного знака после запятой, если нужно
+    const rounded = value % 1 === 0 ? value : value.toFixed(0);
+    return `${rounded} ${units[index]}`;
+}

package/dist/utils/price.util.ts

@@ -0,0 +1,28 @@
+/**
+ * Преобразует число в форматированную строку с валютой (по умолчанию: ₽)
+ */
+export function formatPrice(value: number, currency = "₽"): string {
+  // Используем en-US локаль для точки как разделителя дробной части
+  // и заставляем всегда показывать ровно 2 знака после точки
+  const formatted = value.toLocaleString("en-US", {
+    minimumFractionDigits: 2,
+    maximumFractionDigits: 2
+  }).replace(/,/g, " ");
+  
+  return `${formatted} ${currency}`;
+}
+
+/**
+ * Возвращает сумму всех значений (например, для корзины)
+ */
+export function sumPrices(items: number[]): number {
+  return items.reduce((total, price) => total + price, 0);
+}
+
+/**
+ * Делает безопасное преобразование строки в число (цены из инпута)
+ */
+export function parsePrice(input: string): number {
+  const normalized = input.replace(/[^\d.,]/g, "").replace(",", ".");
+  return parseFloat(normalized) || 0;
+}

package/dist/utils/typeFile.util.ts

@@ -0,0 +1,32 @@
+/**
+ * Определяет тип файла по его MIME-типу.
+ * Возвращает 'image' для изображений, 'pdf' для PDF-файлов,
+ * 'word' для документов Word, 'excel' для файлов Excel,
+ * иначе 'other'.
+ *
+ * @param {string} mimeType - MIME-тип файла
+ * @returns {'image' | 'pdf' | 'word' | 'excel' | 'other'}
+ */
+export function getFileTypeByMime(
+    mimeType: string
+): 'image' | 'pdf' | 'word' | 'excel' | 'other' {
+    if (mimeType.startsWith('image/')) {
+        return 'image';
+    }
+    if (mimeType === 'application/pdf') {
+        return 'pdf';
+    }
+    if (
+        mimeType === 'application/msword' ||
+        mimeType === 'application/vnd.openxmlformats-officedocument.wordprocessingml.document'
+    ) {
+        return 'word';
+    }
+    if (
+        mimeType === 'application/vnd.ms-excel' ||
+        mimeType === 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
+    ) {
+        return 'excel';
+    }
+    return 'other';
+}