@nemigo/helpers 0.0.10 → 0.0.19

package/dist/async.d.ts

@@ -0,0 +1,42 @@
+import type { Timestamp } from "./types.js";
+/**
+ * Создаёт задержку на указанное количество миллисекунд
+ *
+ * @param ms - Количество миллисекунд для задержки
+ */
+export declare const delay: (ms: Timestamp) => Promise<void>;
+/**
+ * Создаёт debounce-функцию, которая откладывает выполнение до тех пор, пока не пройдёт указанное время без новых вызовов
+ *
+ * @param call - Функция для debounce
+ * @param delay - Задержка в миллисекундах
+ *
+ * @returns Функция с debounce
+ */
+export declare const debounce: <T extends (...args: any[]) => any>(call: T, delay: Timestamp) => ((...args: Parameters<T>) => void);
+/**
+ * Создаёт функцию-замыкание, которое гарантирует (старается), что переданная функция `call`
+ * будет вызвана не чаще одного раза в заданный интервал времени.
+ *
+ * mode = `"delay"`
+ *   - первый вызов откладывается на `ms`
+ *   - повторные вызовы до старта игнорируются, аргументы обновляются
+ *   - все ждут одного промисса
+ *
+ * mode = `"urgent"`:
+ *   - первый вызов исполняется сразу
+ *   - повторные вызовы возвращают тот же промиcс в течение `ms` (даже после завершения)
+ *   - после `ms` можно снова вызвать
+ */
+export declare const trottling: <F extends (...args: any[]) => any>(call: F, mode: "urgent" | "delay", ms: number) => ((...args: Parameters<F>) => Promise<Awaited<ReturnType<F>>>);
+/**
+ * Создаёт функцию-замыкание, которая гарантирует однократное выполнение асинхронной операции
+ *
+ * При первом вызове запускает переданный `call` и сохраняет его результат.
+ * Все последующие вызовы возвращают сохранённый результат без повторного выполнения операции.
+ * Если вызов происходит во время выполнения, возвращает тот же промисс, вместо создания нового
+ *
+ * @param call - Асинхронная функция, результат которой нужно кешировать
+ * @returns Функция, возвращающая закешированный результат после первого успешного выполнения
+ */
+export declare const createPromiseTrap: <T>(call: () => Promise<T>) => () => Promise<T>;

package/dist/async.js

@@ -0,0 +1,95 @@
+/**
+ * Создаёт задержку на указанное количество миллисекунд
+ *
+ * @param ms - Количество миллисекунд для задержки
+ */
+export const delay = (ms) => new Promise((ready) => setTimeout(ready, ms));
+//...
+/**
+ * Создаёт debounce-функцию, которая откладывает выполнение до тех пор, пока не пройдёт указанное время без новых вызовов
+ *
+ * @param call - Функция для debounce
+ * @param delay - Задержка в миллисекундах
+ *
+ * @returns Функция с debounce
+ */
+export const debounce = (call, delay) => {
+    let timeout;
+    return (...args) => {
+        if (timeout)
+            clearTimeout(timeout);
+        timeout = setTimeout(() => call(...args), delay);
+    };
+};
+/**
+ * Создаёт функцию-замыкание, которое гарантирует (старается), что переданная функция `call`
+ * будет вызвана не чаще одного раза в заданный интервал времени.
+ *
+ * mode = `"delay"`
+ *   - первый вызов откладывается на `ms`
+ *   - повторные вызовы до старта игнорируются, аргументы обновляются
+ *   - все ждут одного промисса
+ *
+ * mode = `"urgent"`:
+ *   - первый вызов исполняется сразу
+ *   - повторные вызовы возвращают тот же промиcс в течение `ms` (даже после завершения)
+ *   - после `ms` можно снова вызвать
+ */
+export const trottling = (call, mode, ms) => {
+    let _promise = null;
+    let _args = [];
+    return (...args) => {
+        _args = args;
+        if (_promise)
+            return _promise;
+        let resolver;
+        let rejecter;
+        _promise = new Promise((resolve, reject) => {
+            resolver = resolve;
+            rejecter = reject;
+        });
+        const reset = () => (_promise = null);
+        if (mode === "delay") {
+            setTimeout(() => {
+                call(..._args)
+                    .then(resolver)
+                    .catch(rejecter)
+                    .finally(reset);
+            }, ms);
+        }
+        else {
+            call(..._args)
+                .then(resolver)
+                .catch(rejecter)
+                .finally(delay(ms).then(reset));
+        }
+        return _promise;
+    };
+};
+//...
+/**
+ * Создаёт функцию-замыкание, которая гарантирует однократное выполнение асинхронной операции
+ *
+ * При первом вызове запускает переданный `call` и сохраняет его результат.
+ * Все последующие вызовы возвращают сохранённый результат без повторного выполнения операции.
+ * Если вызов происходит во время выполнения, возвращает тот же промисс, вместо создания нового
+ *
+ * @param call - Асинхронная функция, результат которой нужно кешировать
+ * @returns Функция, возвращающая закешированный результат после первого успешного выполнения
+ */
+export const createPromiseTrap = (call) => {
+    const mark = Symbol();
+    let value = mark;
+    let promise = null;
+    return () => {
+        if (value !== mark)
+            return value;
+        if (!promise) {
+            promise = call().then((result) => {
+                value = result;
+                return result;
+            });
+        }
+        return promise;
+    };
+};

package/dist/datetime.d.ts

@@ -0,0 +1,44 @@
+import type { Timestamp } from "./types.js";
+/**
+ * Русифицированные названия месяцев в родительском падеже
+ */
+export declare const months: string[];
+/**
+ * Русифицированные сокращённые названия месяцев в родительском падеже
+ */
+export declare const abbs: string[];
+/**
+ * Шаблонизатор вывода даты и времени из {@link Timestamp}
+ *
+ * TS - секунды
+ *
+ * TM - минуты
+ *
+ * DD - дни
+ *
+ * DM - месяц числом
+ *
+ * DFM - месяц полным названием
+ *
+ * DAM - месяц сокращённым названием
+ *
+ * DY - год
+ *
+ * @example
+ * const formatted = dateTimeFormatter(new Date(), 'DD.DM.DY TH:TM:TS');
+ * console.log(formatted); // "09.10.2023 14:30:59"
+ */
+export declare const formatDateTime: (datetime?: Date | Timestamp | string, format?: string) => string;
+/**
+ * Конвертирует строковые представления даты и времени в {@link Timestamp}
+ *
+ * @param date - Строка даты в формате "DD.MM.YYYY"
+ * @param [time="00:00"] - Строка времени в формате "HH:MM"
+ *
+ * @returns TimeStamp соответствующий указанной дате и времени или 0 при неверном формате
+ *
+ * @example
+ * const timestamp = toTimeStamp("11.02.2012", "13:45");
+ * console.log(timestamp); // Выведет {@link Timestamp} для "11.02.2012 13:45"
+ */
+export declare const toTimeStamp: (date: string, time?: string) => Timestamp | 0;

package/dist/datetime.js

@@ -0,0 +1,109 @@
+import { pad } from "./index.js";
+/**
+ * Русифицированные названия месяцев в родительском падеже
+ */
+export const months = [
+    "января",
+    "февраля",
+    "марта",
+    "апреля",
+    "мая",
+    "июня",
+    "июля",
+    "августа",
+    "сентября",
+    "октября",
+    "ноября",
+    "декабря",
+];
+/**
+ * Русифицированные сокращённые названия месяцев в родительском падеже
+ */
+export const abbs = [
+    "янв",
+    "фев",
+    "марта",
+    "апр",
+    "мая",
+    "июня",
+    "июля",
+    "авг",
+    "сен",
+    "окт",
+    "ноя",
+    "дек",
+];
+/**
+ * Шаблонизатор вывода даты и времени из {@link Timestamp}
+ *
+ * TS - секунды
+ *
+ * TM - минуты
+ *
+ * DD - дни
+ *
+ * DM - месяц числом
+ *
+ * DFM - месяц полным названием
+ *
+ * DAM - месяц сокращённым названием
+ *
+ * DY - год
+ *
+ * @example
+ * const formatted = dateTimeFormatter(new Date(), 'DD.DM.DY TH:TM:TS');
+ * console.log(formatted); // "09.10.2023 14:30:59"
+ */
+export const formatDateTime = (datetime = Date.now(), format = "DD.DM.DY TH:TM") => {
+    const date = new Date(datetime);
+    const replacements = {
+        TS: pad(date.getSeconds()),
+        TM: pad(date.getMinutes()),
+        TH: pad(date.getHours()),
+        //...
+        DD: pad(date.getDate()),
+        DM: pad(date.getMonth() + 1),
+        DFM: months[date.getMonth()],
+        DAM: abbs[date.getMonth()],
+        DY: date.getFullYear().toString(),
+    };
+    const result = [];
+    let i = 0;
+    while (i < format.length) {
+        let found = false;
+        for (const key in replacements) {
+            if (format.startsWith(key, i)) {
+                result.push(replacements[key]);
+                i += key.length;
+                found = true;
+                break;
+            }
+        }
+        if (!found) {
+            result.push(format[i]);
+            i++;
+        }
+    }
+    return result.join("");
+};
+/**
+ * Конвертирует строковые представления даты и времени в {@link Timestamp}
+ *
+ * @param date - Строка даты в формате "DD.MM.YYYY"
+ * @param [time="00:00"] - Строка времени в формате "HH:MM"
+ *
+ * @returns TimeStamp соответствующий указанной дате и времени или 0 при неверном формате
+ *
+ * @example
+ * const timestamp = toTimeStamp("11.02.2012", "13:45");
+ * console.log(timestamp); // Выведет {@link Timestamp} для "11.02.2012 13:45"
+ */
+export const toTimeStamp = (date, time = "00:00") => {
+    const [day, month, year] = date.split(".").map(Number);
+    const [hours, minutes] = time.split(":").map(Number);
+    // Проверка на корректность ввода (если хотя бы одно значение не число)
+    // prettier-ignore
+    if ([day, month, year, hours, minutes].some(isNaN))
+        return 0;
+    return new Date(year, month - 1, day, hours, minutes).valueOf();
+};

package/dist/files.d.ts

@@ -0,0 +1 @@
+export declare const fileToBase64: (file: File) => Promise<string>;

package/dist/files.js

@@ -0,0 +1,6 @@
+export const fileToBase64 = (file) => new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => resolve(reader.result);
+    reader.onerror = reject;
+    reader.readAsDataURL(file);
+});

package/dist/format.d.ts

@@ -0,0 +1,31 @@
+import type { CanBeNullable } from "./types.js";
+interface FormatNumberConfig {
+    /**
+     * @default 2
+     */
+    fraction?: number;
+    /**
+     * @default "---"
+     */
+    fallback?: string;
+    /**
+     * @example "₽"
+     */
+    postfix?: string;
+    /**
+     * - "always" - "0" для всех исключительных ситуаций
+     * - "value" - "0" только при значении равном нулю, иначе `fallback`
+     * - "never" - `fallback` всегда
+     *
+     * @default value
+     */
+    zero?: "always" | "value" | "never";
+}
+export declare const FormatNumberRegExp: RegExp;
+/**
+ * Форматирование числа по тысячам
+ *
+ * @example "1 234" или "1 234,56"
+ */
+export declare const formatNumber: (amount: CanBeNullable<number | string>, { fraction, fallback, zero, postfix }?: FormatNumberConfig) => string;
+export {};

package/dist/format.js

@@ -0,0 +1,20 @@
+import { caseNumber } from "./cases.js";
+import { toRound } from "./phymath.js";
+export const FormatNumberRegExp = /\B(?=(\d{3})+(?!\d))/g;
+/**
+ * Форматирование числа по тысячам
+ *
+ * @example "1 234" или "1 234,56"
+ */
+export const formatNumber = (amount, { fraction = 2, fallback = "---", zero = "value", postfix } = {}) => caseNumber(amount, (v) => {
+    if (v === undefined)
+        return zero === "always" ? (postfix ? "0 " + postfix : "0") : fallback;
+    if (v === 0)
+        return zero === "never" ? fallback : postfix ? "0 " + postfix : "0";
+    if (fraction === 0)
+        return Math.round(v).toString().replace(FormatNumberRegExp, " ");
+    const { 0: integer, 1: fractional = "" } = toRound(v, fraction).toString().split(".");
+    const result = integer.replace(FormatNumberRegExp, " ");
+    const formatted = fractional ? `${result},${fractional}` : result;
+    return postfix ? formatted + " " + postfix : formatted;
+});

package/dist/html.d.ts

@@ -0,0 +1,58 @@
+import type { CanBeNullable, CanBePromise, KEYS } from "./types";
+/**
+ * Проверка по глобальному `window`
+ */
+export declare const isSSR: boolean;
+/**
+ * Предотвращает дефолтное поведение события и останавливает всплытие
+ */
+export declare const preventStop: (e: Event) => void;
+/**
+ * Создаёт обработчик события с {@link preventStop}, который выполняется всегда.
+ * Коллбэк выполняется только, если load вернёт `false` (при его наличии)
+ */
+export declare const preventStopHook: <T extends Event = Event>(call?: CanBeNullable<(e: T) => CanBePromise>, load?: () => boolean | undefined) => ((e: T) => void);
+/**
+ * Возвращает обработчик клавиатурных событий, который:
+ *
+ * 1. Если `usePreventStop === true`, вызывает {@link preventStop}
+ * 2. Если load вернёт `false` (при его наличии), то выполнение остановится
+ * 3. Вызывает переданный **prepare-коллбэк** (при его наличии), если он вернёт `false`, то выполнение остановится
+ * 4. Вызывает основной коллбэк только при нажатии `Enter`.
+ */
+export declare const enterKeyHook: <T extends KeyboardEvent = KeyboardEvent>(call?: CanBeNullable<(e: T) => CanBePromise>, config?: {
+    usePreventStop?: "enter" | boolean | ((e: T, isEnter: boolean) => boolean);
+    prepare?: (e: T) => CanBePromise<boolean>;
+    load?: () => boolean | undefined;
+}) => (e: T) => void;
+/**
+ * Создаёт обработчик событий для указанного элемента или окна
+ *
+ * @template T - Тип события из `WindowEventMap`
+ * @template E - Тип объекта события (по умолчанию `WindowEventMap[T]`)
+ *
+ * @param {T} event - Ключ события
+ * @param {(e: E) => CanBePromise} call - Функция-обработчик события
+ * @param {AddEventListenerOptions} [options] - Дополнительные параметры
+ * @param {HTMLElement | Window} [target=window] - Целевой элемент для привязки события
+ *
+ * @returns Функция для удаления обработчика события
+ */
+export declare const createEventListener: <const M = WindowEventMap, const T extends KEYS<M> = KEYS<M>, const E = M[T]>(event: T, call: (e: E) => CanBePromise, options?: AddEventListenerOptions, target?: HTMLElement | Window | Document) => (() => void);
+/**
+ * Убирает все выделения текста на странице
+ */
+export declare const unselect: () => void;
+/**
+ * Создаёт once-обработчик события "mousedown" с {@link unselect}
+ *
+ * @returns Функция для удаления обработчика события
+ */
+export declare const unselectByMousedown: () => (() => void);
+/**
+ * Преобразование `{@link FormData}` в объект
+ *
+ * @param form - данные формы
+ * @param multi - поддержка массивов значений
+ */
+export declare const formon: <D = any>(form: FormData, multi?: boolean) => D;

package/dist/html.js

@@ -0,0 +1,113 @@
+/**
+ * Проверка по глобальному `window`
+ */
+export const isSSR = typeof window === "undefined";
+/**
+ * Предотвращает дефолтное поведение события и останавливает всплытие
+ */
+export const preventStop = (e) => (e.preventDefault(), e.stopPropagation());
+/**
+ * Создаёт обработчик события с {@link preventStop}, который выполняется всегда.
+ * Коллбэк выполняется только, если load вернёт `false` (при его наличии)
+ */
+export const preventStopHook = (call, load) => (e) => {
+    preventStop(e);
+    if (!load || !load())
+        call?.(e);
+};
+//...
+/**
+ * Возвращает обработчик клавиатурных событий, который:
+ *
+ * 1. Если `usePreventStop === true`, вызывает {@link preventStop}
+ * 2. Если load вернёт `false` (при его наличии), то выполнение остановится
+ * 3. Вызывает переданный **prepare-коллбэк** (при его наличии), если он вернёт `false`, то выполнение остановится
+ * 4. Вызывает основной коллбэк только при нажатии `Enter`.
+ */
+export const enterKeyHook = (call, config = { usePreventStop: "enter" }) => (e) => {
+    const isEnter = e.key === "Enter";
+    if (config?.usePreventStop === "enter") {
+        if (isEnter)
+            preventStop(e);
+    }
+    else {
+        if (config?.usePreventStop !== undefined) {
+            if (typeof config?.usePreventStop === "boolean") {
+                if (config?.usePreventStop)
+                    preventStop(e);
+            }
+            else {
+                if (config?.usePreventStop(e, isEnter))
+                    preventStop(e);
+            }
+        }
+    }
+    if (config?.load?.())
+        return;
+    if (config?.prepare) {
+        Promise.resolve(config?.prepare?.(e)).then((next) => {
+            if (next && isEnter)
+                call?.(e);
+        });
+    }
+    else {
+        if (isEnter)
+            call?.(e);
+    }
+};
+//...
+/**
+ * Создаёт обработчик событий для указанного элемента или окна
+ *
+ * @template T - Тип события из `WindowEventMap`
+ * @template E - Тип объекта события (по умолчанию `WindowEventMap[T]`)
+ *
+ * @param {T} event - Ключ события
+ * @param {(e: E) => CanBePromise} call - Функция-обработчик события
+ * @param {AddEventListenerOptions} [options] - Дополнительные параметры
+ * @param {HTMLElement | Window} [target=window] - Целевой элемент для привязки события
+ *
+ * @returns Функция для удаления обработчика события
+ */
+export const createEventListener = (event, call, options = {}, target = window) => {
+    target.addEventListener(event, call, options);
+    return () => target.removeEventListener(event, call);
+};
+//...
+/**
+ * Убирает все выделения текста на странице
+ */
+export const unselect = () => document.getSelection()?.removeAllRanges();
+/**
+ * Создаёт once-обработчик события "mousedown" с {@link unselect}
+ *
+ * @returns Функция для удаления обработчика события
+ */
+export const unselectByMousedown = () => createEventListener("mousedown", unselect, { once: true });
+//...
+/**
+ * Преобразование `{@link FormData}` в объект
+ *
+ * @param form - данные формы
+ * @param multi - поддержка массивов значений
+ */
+export const formon = (form, multi = false) => {
+    if (multi) {
+        const result = {};
+        for (const { 0: key, 1: value } of form.entries()) {
+            if (result[key] !== undefined) {
+                if (!Array.isArray(result[key])) {
+                    result[key] = [result[key]];
+                }
+                result[key].push(value);
+            }
+            else {
+                result[key] = value;
+            }
+        }
+        return result;
+    }
+    else {
+        return Object.fromEntries(form.entries());
+    }
+};

package/dist/humanly.d.ts

@@ -0,0 +1,5 @@
+export type RU_CASES = "nominative" | "genitive" | "dative" | "accusative" | "ablative";
+/**
+ * Форма слова 'рубль' в правильном падеже и числе в зависимости от количества
+ */
+export declare const Rubles: (value: number, form?: RU_CASES) => string;

package/dist/humanly.js

@@ -0,0 +1,46 @@
+//...
+/**
+ * Основные формы слова 'рубль'
+ */
+const RublesMainSwitch = (form) => {
+    switch (form) {
+        case "dative":
+            return "рублям";
+        case "ablative":
+            return "рублями";
+        default:
+            return "рублей";
+    }
+};
+/**
+ * Форма слова 'рубль' в правильном падеже и числе в зависимости от количества
+ */
+export const Rubles = (value, form = "nominative") => {
+    const lastTwoDigits = Math.abs(value % 100);
+    if (lastTwoDigits > 4 && lastTwoDigits < 21)
+        return RublesMainSwitch(form);
+    const lastDigit = Math.abs(value % 10);
+    if (lastDigit >= 2 && lastDigit <= 4) {
+        switch (form) {
+            case "nominative":
+            case "accusative":
+                return "рубля";
+            default:
+                return RublesMainSwitch(form);
+        }
+    }
+    if (lastDigit === 1) {
+        switch (form) {
+            case "nominative":
+            case "accusative":
+                return "рубль";
+            case "genitive":
+                return "рубля";
+            case "dative":
+                return "рублю";
+            case "ablative":
+                return "рублём";
+        }
+    }
+    return RublesMainSwitch(form);
+};

package/dist/index.d.ts

@@ -0,0 +1,33 @@
+import type { CanBeArray } from "./types.js";
+/**
+ * Добавляет ведущие нули к числу для достижения указанной длины
+ *
+ * @example pad(123, 5) => "00123"
+ */
+export declare const pad: (v: number, l?: number) => string;
+/**
+ * JSON-клонирование объектов посредством `JSON.parse(JSON.stringify(v))`
+ * Если значение не `object` вернётся как есть
+ */
+export declare const parsify: <T>(v: T) => T;
+/**
+ * Приведение значения к массиву
+ */
+export declare const arrayble: <T>(v: CanBeArray<T>) => T[];
+/**
+ * Тип разделения для функции {@link partition}
+ */
+export interface Partition<T> {
+    /**
+     * Элементы, удовлетворяющие условию
+     */
+    result: T[];
+    /**
+     * Исключённые элементы
+     */
+    excluded: T[];
+}
+/**
+ * Разделяет массив на два по условию
+ */
+export declare const partition: <T>(arr: T[], filter: (item: T) => boolean, initial?: Partition<T>) => Partition<T>;

package/dist/index.js

@@ -0,0 +1,23 @@
+/**
+ * Добавляет ведущие нули к числу для достижения указанной длины
+ *
+ * @example pad(123, 5) => "00123"
+ */
+export const pad = (v, l = 2) => String(v).padStart(l, "0");
+/**
+ * JSON-клонирование объектов посредством `JSON.parse(JSON.stringify(v))`
+ * Если значение не `object` вернётся как есть
+ */
+export const parsify = (v) => {
+    if (typeof v !== "object")
+        return v;
+    return JSON.parse(JSON.stringify(v));
+};
+/**
+ * Приведение значения к массиву
+ */
+export const arrayble = (v) => (Array.isArray(v) ? v : [v]);
+/**
+ * Разделяет массив на два по условию
+ */
+export const partition = (arr, filter, initial = { result: [], excluded: [] }) => arr.reduce((acc, item) => (acc[filter(item) ? "result" : "excluded"].push(item), acc), initial);

package/dist/queue.d.ts

@@ -0,0 +1,35 @@
+import type { Timestamp } from "./types.js";
+/**
+ * Абстрактный класс очереди
+ *
+ * @template T - Тип элементов в очереди
+ */
+export declare abstract class Queue<T> {
+    _queue: T[];
+    _delay: number;
+    private timeout;
+    /**
+     * @param [delay=25] - Задержка (в миллисекундах) между обработкой элементов очереди
+     */
+    constructor(delay?: Timestamp);
+    /**
+     * Добавляет элемент в очередь и запускает обработку
+     *
+     * @param item - Элемент для добавления в очередь
+     */
+    protected push(item: T): void;
+    /**
+     * Запускает обработку очереди с задержкой
+     */
+    private run;
+    /**
+     * Метод для обработки элемента очереди
+     *
+     * @param item - Элемент для обработки
+     */
+    protected abstract handle(item: T): void;
+    /**
+     * Сброс очереди
+     */
+    reset(): void;
+}

package/dist/queue.js

@@ -0,0 +1,48 @@
+/**
+ * Абстрактный класс очереди
+ *
+ * @template T - Тип элементов в очереди
+ */
+export class Queue {
+    _queue = [];
+    _delay;
+    timeout = 0;
+    // noinspection TypeScriptAbstractClassConstructorCanBeMadeProtected
+    /**
+     * @param [delay=25] - Задержка (в миллисекундах) между обработкой элементов очереди
+     */
+    constructor(delay = 25) {
+        this._delay = delay;
+    }
+    /**
+     * Добавляет элемент в очередь и запускает обработку
+     *
+     * @param item - Элемент для добавления в очередь
+     */
+    push(item) {
+        this._queue.push(item);
+        this.run();
+    }
+    /**
+     * Запускает обработку очереди с задержкой
+     */
+    run() {
+        this.reset();
+        this.timeout = setTimeout(() => {
+            if (this._queue.length === 0)
+                return this.reset();
+            const item = this._queue.shift();
+            this.handle(item);
+            this._queue.length > 0 ? this.run() : this.reset();
+        }, this._delay);
+    }
+    /**
+     * Сброс очереди
+     */
+    reset() {
+        if (this.timeout)
+            clearTimeout(this.timeout);
+        this.timeout = 0;
+        this._queue.length = 0;
+    }
+}

package/dist/string.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Регулярное выражение для захвата всех нецифровых символов из строки
+ */
+export declare const oDigitRegExp: RegExp;
+/**
+ * Чистка строки от всего, кроме цифр
+ */
+export declare const oDigitClean: (v?: string) => string;
+/**
+ * Регулярное выражение для захвата пробелов
+ */
+export declare const spaceRegExp: RegExp;
+/**
+ * Заменяет все двойные, тройные и т. д. пробелы на один
+ */
+export declare const spaceClean: (v?: string) => string;
+/**
+ * Очистка от плейсхолдеров
+ */
+export declare const clearPH: (str?: string, placeholder?: string | RegExp) => string;
+/**
+ * Приводит первый символ слова к верхнему регистру
+ */
+export declare const toCapital: (word?: string) => string;
+/**
+ * Приводит первый символ каждого слова к верхнему регистру
+ */
+export declare const toCapitalMap: (str?: string) => string;
+/**
+ * Повторяет строку указанное количество раз с разделителем
+ *
+ * @param {string} str - Исходная строка
+ * @param {number} length - Количество повторений
+ * @param {string} [separator=""] - Разделитель между повторениями (по умолчанию пустая строка)
+ */
+export declare const repeat: (str: string, length: number, separator?: string) => string;
+/**
+ * Приводит всё к нижнему регистру и корректирует пробелы
+ */
+export declare const toFlat: (str?: string) => string;
+/**
+ * Готовая {@link Map} для перевода кириллицы нижнего регистра в латиницу
+ */
+export declare const cyrillicToLatinMap: Map<string, string>;
+/**
+ * Функция для создания *slug* (фрагмента URL) сущности
+ */
+export declare const toSlug: (text: string, separator?: string) => string;

package/dist/string.js

@@ -0,0 +1,117 @@
+/**
+ * Регулярное выражение для захвата всех нецифровых символов из строки
+ */
+export const oDigitRegExp = /\D/g;
+/**
+ * Чистка строки от всего, кроме цифр
+ */
+export const oDigitClean = (v = "") => v.replace(oDigitRegExp, "");
+//...
+/**
+ * Регулярное выражение для захвата пробелов
+ */
+export const spaceRegExp = /\s+/g;
+/**
+ * Заменяет все двойные, тройные и т. д. пробелы на один
+ */
+export const spaceClean = (v = "") => v.replace(spaceRegExp, " ").trim();
+/**
+ * Очистка от плейсхолдеров
+ */
+export const clearPH = (str = "", placeholder = "_") => str.replaceAll(placeholder, "");
+//...
+/**
+ * Приводит первый символ слова к верхнему регистру
+ */
+export const toCapital = (word = "") => word.charAt(0).toUpperCase() + word.slice(1);
+/**
+ * Приводит первый символ каждого слова к верхнему регистру
+ */
+export const toCapitalMap = (str = "") => str.split(" ").map(toCapital).join(" ");
+//...
+/**
+ * Повторяет строку указанное количество раз с разделителем
+ *
+ * @param {string} str - Исходная строка
+ * @param {number} length - Количество повторений
+ * @param {string} [separator=""] - Разделитель между повторениями (по умолчанию пустая строка)
+ */
+export const repeat = (str, length, separator = "") => Array.from({ length }).fill(str).join(separator);
+//...
+/**
+ * Приводит всё к нижнему регистру и корректирует пробелы
+ */
+export const toFlat = (str = "") => spaceClean(str.toLowerCase());
+/**
+ * Готовая {@link Map} для перевода кириллицы нижнего регистра в латиницу
+ */
+export const cyrillicToLatinMap = new Map([
+    ["а", "a"],
+    ["б", "b"],
+    ["в", "v"],
+    ["г", "g"],
+    ["д", "d"],
+    ["е", "e"],
+    ["ё", "yo"],
+    ["ж", "zh"],
+    ["з", "z"],
+    ["и", "i"],
+    ["й", "y"],
+    ["к", "k"],
+    ["л", "l"],
+    ["м", "m"],
+    ["н", "n"],
+    ["о", "o"],
+    ["п", "p"],
+    ["р", "r"],
+    ["с", "s"],
+    ["т", "t"],
+    ["у", "u"],
+    ["ф", "f"],
+    ["х", "h"],
+    ["ц", "ts"],
+    ["ч", "ch"],
+    ["ш", "sh"],
+    ["щ", "sch"],
+    ["ъ", ""],
+    ["ы", "y"],
+    ["ь", ""],
+    ["э", "e"],
+    ["ю", "yu"],
+    ["я", "ya"],
+]);
+/**
+ * Функция для создания *slug* (фрагмента URL) сущности
+ */
+export const toSlug = (text, separator = "-") => {
+    let acc = "";
+    let wasSpace = false;
+    for (const _char of text.split("")) {
+        const char = _char.toLowerCase();
+        const code = char.charCodeAt(0);
+        // Кириллица (а-я, ё)
+        if ((code >= 1072 && code <= 1103) || code === 1105) {
+            acc += cyrillicToLatinMap.get(char) || char;
+            wasSpace = false;
+        }
+        // Латиница (a-z)
+        else if (code >= 97 && code <= 122) {
+            acc += char;
+            wasSpace = false;
+        }
+        // Цифры (0-9)
+        else if (code >= 48 && code <= 57) {
+            acc += char;
+            wasSpace = false;
+        }
+        // Пробел или другие символы, которые нужно заменить на separator
+        else {
+            if (!wasSpace && acc.length > 0) {
+                acc += separator;
+                wasSpace = true;
+            }
+        }
+    }
+    // Убираем завершающий separator, если он есть
+    return acc.endsWith(separator) ? acc.slice(0, -1) : acc;
+};

package/dist/types.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Дата и время в формате UNIX
+ */
+export type Timestamp = number;
+/**
+ * Идентификатор чего-либо для рантайма (например, для кэша)
+ */
+export type RID = string | number | symbol;
+/**
+ * Обобщённый тип таймеров
+ */
+export type TimeoutType = ReturnType<typeof setTimeout>;
+/**
+ * Обобщённый тип интервалов
+ */
+export type IntervalType = ReturnType<typeof setInterval>;
+/**
+ * Массив в массиве
+ */
+export type Matrix<T = unknown> = T[][];
+/**
+ * Значение может быть `null` или `undefined`
+ */
+export type CanBeNullable<T = unknown> = T | null | undefined;
+/**
+ * Значение может быть массивом или одиночным элементом
+ */
+export type CanBeArray<T = unknown> = T | T[];
+/**
+ * Значение может быть промиссом
+ */
+export type CanBePromise<T = unknown> = T | Promise<T>;
+/**
+ * Исключение `undefined`
+ */
+export type Exist<T> = Exclude<T, undefined>;
+/**
+ * Только строковые ключи объектов
+ */
+export type KEYS<O> = keyof O extends infer Key ? (Key extends string ? Key : never) : never;
+/**
+ * Рекурсивный {@link Partial}
+ */
+export type DeepPartial<O> = {
+    [K in keyof O]?: O[K] extends object | undefined ? DeepPartial<O[K]> : O[K];
+};
+/**
+ * Рекурсивный {@link Required}
+ */
+export type DeepRequired<O> = {
+    [K in keyof O]-?: O[K] extends object | undefined ? DeepRequired<NonNullable<O[K]>> : O[K];
+};
+/**
+ * Получение тип элемента массива
+ */
+export type ArrayElement<T> = T extends (infer U)[] ? U : never;
+/**
+ * - ASC - по возрастанию
+ * - DESC - по убыванию
+ */
+export type SortDirection = "ASC" | "DESC";

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/url.d.ts

@@ -0,0 +1,61 @@
+import type { CanBeNullable } from "./types.js";
+/**
+ * Возможные значения параметра для {@link pushParams} и {@link clearParams}
+ */
+export type ParamValue = CanBeNullable<string | number | boolean>;
+/**
+ * KV-параметры для URL для {@link pushParams} и {@link clearParams}
+ */
+export type ParamKV<V extends ParamValue = ParamValue> = {
+    key: string;
+    value?: V;
+};
+/**
+ * Параметры для URL для {@link pushParams} и {@link clearParams}
+ */
+export type Params<V extends ParamValue = ParamValue> = CanBeNullable<string | ParamKV<V>>[];
+/**
+ * Добавляет параметры в URL
+ *
+ * Для каждого параметра из массива:
+ * - Если параметр равен `null` или `undefined`, он пропускается
+ * - Если параметр имеет тип `string`, то в строке запроса добавляется параметр с ключом равным значению строки и значением `"true"`
+ * - Если параметр является объектом с ключом и значением, то, если значение не `undefined` и не является объектом, оно приводится к строке и устанавливается в качестве значения
+ *
+ * **Небезопасное поведение:**
+ * - При передаче параметра типа `string` он добавляется как `?param1&param2` (без значения, то есть без `true`)
+ * - При передаче параметра, значение которого равно `true` или пустой строке, параметр добавляется без значения
+ *
+ * @param url - URL, в который будут добавлены параметры
+ * @param params - Массив параметров
+ * @param [unsafe=false] - Небезопасное поведение
+ */
+export declare const pushParams: (url: URL, params: Params, unsafe?: boolean) => URL;
+export type StrictPushParams = Required<ParamKV<string | boolean | number>>[];
+/**
+ * Объединяет массивы параметров для {@link pushParams} в один массив, исключая дубликаты
+ *
+ * @param args - Массивы параметров для объединения
+ * @returns Массив параметров без дубликатов
+ */
+export declare const mergePushParams: (...args: Params[]) => StrictPushParams;
+/**
+ * Удаляет из URL параметры
+ *
+ * Для каждого элемента массива:
+ * - Если параметр отсутствует или равен `null` или `undefined`, он пропускается
+ * - Если параметр имеет тип `string`, из URL удаляется параметр с таким именем
+ * - Если параметр является объектом с ключом (`key`), из URL удаляется параметр с этим ключом
+ *
+ * @param url - URL, из которого будут удалены параметры
+ * @param params - Массив параметров для удаления
+ */
+export declare const clearParams: (url: URL, params: Params) => URL;
+export type StrictClearParams = string[];
+/**
+ * Объединяет массивы параметров для {@link clearParams} в один массив, исключая дубликаты
+ *
+ * @param args - Массивы параметров для объединения
+ * @returns Массив параметров без дубликатов
+ */
+export declare const mergeClearParams: (...args: Params[]) => StrictClearParams;

package/dist/url.js

@@ -0,0 +1,137 @@
+//...
+/**
+ * Добавляет параметры в URL
+ *
+ * Для каждого параметра из массива:
+ * - Если параметр равен `null` или `undefined`, он пропускается
+ * - Если параметр имеет тип `string`, то в строке запроса добавляется параметр с ключом равным значению строки и значением `"true"`
+ * - Если параметр является объектом с ключом и значением, то, если значение не `undefined` и не является объектом, оно приводится к строке и устанавливается в качестве значения
+ *
+ * **Небезопасное поведение:**
+ * - При передаче параметра типа `string` он добавляется как `?param1&param2` (без значения, то есть без `true`)
+ * - При передаче параметра, значение которого равно `true` или пустой строке, параметр добавляется без значения
+ *
+ * @param url - URL, в который будут добавлены параметры
+ * @param params - Массив параметров
+ * @param [unsafe=false] - Небезопасное поведение
+ */
+export const pushParams = (url, params, unsafe = false) => {
+    for (const param of params) {
+        if (!param)
+            continue;
+        if (typeof param === "string") {
+            // Если unsafe === true, добавляем параметр без значения, иначе - как "true"
+            url.searchParams.set(param, unsafe ? "" : "true");
+            continue;
+        }
+        if (!param?.key)
+            continue;
+        if (typeof param.value !== "object") {
+            if (unsafe && (param?.value === undefined || param.value === true || param.value === "")) {
+                url.searchParams.set(param.key, "");
+            }
+            else {
+                url.searchParams.set(param.key, String(param.value));
+            }
+        }
+    }
+    if (unsafe) {
+        const splitted = url.href.split("?");
+        if (splitted[1]) {
+            splitted[1] = splitted[1].replaceAll("=&", "&");
+            if (splitted[1].endsWith("="))
+                splitted[1] = splitted[1].slice(0, splitted[1].length - 1);
+        }
+        url.href = splitted.join("?");
+    }
+    return url;
+};
+/**
+ * Объединяет массивы параметров для {@link pushParams} в один массив, исключая дубликаты
+ *
+ * @param args - Массивы параметров для объединения
+ * @returns Массив параметров без дубликатов
+ */
+export const mergePushParams = (...args) => {
+    const acc = [];
+    for (const params of args) {
+        for (const param of params) {
+            if (!param)
+                continue;
+            if (typeof param === "string") {
+                const existed = acc.find((v) => v.key === param);
+                if (existed)
+                    existed.value = true;
+                else
+                    acc.push({ key: param, value: true });
+                continue;
+            }
+            if (!param?.key)
+                continue;
+            if (typeof param?.value !== "object") {
+                const existed = acc.find((v) => v.key === param.key);
+                if (param.value === undefined || param.value === true || param.value === "") {
+                    if (existed)
+                        existed.value = true;
+                    else
+                        acc.push({ key: param.key, value: true });
+                }
+                else {
+                    if (existed)
+                        existed.value = String(param.value);
+                    else
+                        acc.push({ key: param.key, value: param.value });
+                }
+            }
+        }
+    }
+    return acc;
+};
+//...
+/**
+ * Удаляет из URL параметры
+ *
+ * Для каждого элемента массива:
+ * - Если параметр отсутствует или равен `null` или `undefined`, он пропускается
+ * - Если параметр имеет тип `string`, из URL удаляется параметр с таким именем
+ * - Если параметр является объектом с ключом (`key`), из URL удаляется параметр с этим ключом
+ *
+ * @param url - URL, из которого будут удалены параметры
+ * @param params - Массив параметров для удаления
+ */
+export const clearParams = (url, params) => {
+    for (const param of params) {
+        if (!param)
+            continue;
+        if (typeof param === "string") {
+            url.searchParams.delete(param);
+            continue;
+        }
+        if (param?.key)
+            url.searchParams.delete(param.key);
+    }
+    return url;
+};
+/**
+ * Объединяет массивы параметров для {@link clearParams} в один массив, исключая дубликаты
+ *
+ * @param args - Массивы параметров для объединения
+ * @returns Массив параметров без дубликатов
+ */
+export const mergeClearParams = (...args) => {
+    const acc = [];
+    for (const params of args) {
+        for (const param of params) {
+            if (!param)
+                continue;
+            if (typeof param === "string") {
+                if (!acc.includes(param))
+                    acc.push(param);
+                continue;
+            }
+            if (param.key && !acc.includes(param.key))
+                acc.push(param.key);
+        }
+    }
+    return acc;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@nemigo/helpers",
-	"version": "0.0.10",
+	"version": "0.0.19",
 	"private": false,
 	"author": {
 		"name": "Vlad Logvin",
@@ -15,6 +15,14 @@
 		"format": "prettier --write ./"
 	},
 	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"default": "./dist/index.js"
+		},
+		"./async": {
+			"types": "./dist/async.d.ts",
+			"default": "./dist/async.js"
+		},
 		"./cases": {
 			"types": "./dist/cases.d.ts",
 			"default": "./dist/cases.js"
@@ -23,10 +31,30 @@
 			"types": "./dist/clean.d.ts",
 			"default": "./dist/clean.js"
 		},
+		"./datetime": {
+			"types": "./dist/datetime.d.ts",
+			"default": "./dist/datetime.js"
+		},
 		"./explorer": {
 			"types": "./dist/explorer.d.ts",
 			"default": "./dist/explorer.js"
 		},
+		"./files": {
+			"types": "./dist/files.d.ts",
+			"default": "./dist/files.js"
+		},
+		"./format": {
+			"types": "./dist/format.d.ts",
+			"default": "./dist/format.js"
+		},
+		"./html": {
+			"types": "./dist/html.d.ts",
+			"default": "./dist/html.js"
+		},
+		"./humanly": {
+			"types": "./dist/humanly.d.ts",
+			"default": "./dist/humanly.js"
+		},
 		"./lens": {
 			"types": "./dist/lens.d.ts",
 			"default": "./dist/lens.js"
@@ -35,23 +63,48 @@
 			"types": "./dist/msgpack.d.ts",
 			"default": "./dist/msgpack.js"
 		},
-		"./random": {
-			"types": "./dist/random.d.ts",
-			"default": "./dist/random.js"
-		},
 		"./phymath": {
 			"types": "./dist/phymath.d.ts",
 			"default": "./dist/phymath.js"
 		},
+		"./queue": {
+			"types": "./dist/queue.d.ts",
+			"default": "./dist/queue.js"
+		},
+		"./random": {
+			"types": "./dist/random.d.ts",
+			"default": "./dist/random.js"
+		},
 		"./script": {
 			"types": "./dist/script.d.ts",
 			"default": "./dist/script.js"
+		},
+		"./string": {
+			"types": "./dist/string.d.ts",
+			"default": "./dist/string.js"
+		},
+		"./types": {
+			"types": "./dist/types.d.ts",
+			"default": "./dist/types.js"
+		},
+		"./url": {
+			"types": "./dist/url.d.ts",
+			"default": "./dist/url.js"
+		}
+	},
+	"peerDependencies": {
+		"zod": "^4.0.0"
+	},
+	"peerDependenciesMeta": {
+		"zod": {
+			"optional": true
 		}
 	},
 	"dependencies": {
 		"@std/msgpack": "jsr:^1.0.0"
 	},
 	"devDependencies": {
-		"@nemigo/configs": "workspace:*"
+		"@nemigo/configs": "workspace:*",
+		"zod": "4.1.5"
 	}
 }