@nemigo/helpers 0.13.3 → 1.5.0

package/dist/html/cookie.js

@@ -0,0 +1,37 @@
+import { MS_IN_DAY } from "../datetime/delta.js";
+/**
+ * @param name - Имя куки
+ * @param value - Значение куки
+ * @param [options] - Опции куки
+ * @param [options.MaxAge=21days] - {@link SetDocumentCookieOptions.MaxAge}
+ * @param [options.SameSite="Lax"] - {@link SetDocumentCookieOptions.SameSite}
+ * @param [options.Secure=true] - {@link SetDocumentCookieOptions.Secure}
+ * @param [options.Path="/"] - {@link SetDocumentCookieOptions.Path}
+ * @param [options.Domain] - {@link SetDocumentCookieOptions.Domain}
+ */
+export const setDocumentCookie = (name, value, options = {}) => {
+    const { MaxAge = (21 * MS_IN_DAY) / 1000, SameSite = "Lax", Secure = true, Path = "/", Domain } = options;
+    let acc = `${name}=${value}`;
+    if (Domain)
+        acc += `;Domain=${Domain}`;
+    acc += `;Path=${Path};SameSite=${SameSite}`;
+    if (Secure)
+        acc += ";Secure";
+    if (MaxAge)
+        acc += `;Max-Age=${MaxAge}`;
+    document.cookie = acc;
+};
+export const getDocumentCookie = (name) => {
+    const search = name + "=";
+    const cookies = document.cookie.split(";");
+    for (const raw of cookies) {
+        const cookie = raw.trim();
+        if (cookie.startsWith(search)) {
+            return cookie.slice(search.length);
+        }
+    }
+};
+/**
+ * Удаляет куку по имени, устанавливая Max-Age=0 через {@link setDocumentCookie}
+ */
+export const deleteDocumentCookie = (name, Path) => setDocumentCookie(name, "", { Path, MaxAge: 0 });

package/dist/html/events.d.ts

@@ -0,0 +1,133 @@
+import type { ConditionGuardType } from "../index.js";
+import type { CanBeNullable, CanBePromise, KEYS } from "../types.js";
+/**
+ * Предотвращает стандартное поведение события и останавливает его всплытие
+ */
+export declare const preventStop: (e: Event) => void;
+/**
+ * @param handler - Обработчик события
+ * @param [guards={}] - Условия выполнений
+ * @param [guards.preventStopGuard=true] - Вызов {@link preventStop} для события
+ * @param [guards.eventHandlerGuard=true] - Вызов обработчика
+ */
+export declare const usePreventStop: <T extends Event = Event>(handler?: CanBeNullable<(e: T) => CanBePromise>, guards?: {
+    preventStopGuard?: ConditionGuardType<{
+        event: T;
+        handler: typeof handler;
+    }>;
+    eventHandlerGuard?: ConditionGuardType<{
+        event: T;
+        handler: typeof handler;
+    }>;
+}) => ((event: T) => void);
+/**
+ * @param handler - Обработчик события
+ * @param [props={}] - Дополнительные возможности
+ * @param [props.preventStopGuard="enter"] - Политика вызова {@link preventStop} для события
+ * @param [props.eventHandlerGuard=true] - Вызов обработчика
+ * @param [props.secondary] - Обработчик для других клавиш
+ */
+export declare const createEnterHandler: <T extends KeyboardEvent = KeyboardEvent>(handler?: CanBeNullable<(e: T) => CanBePromise>, props?: {
+    preventStopGuard?: "enter" | ConditionGuardType<{
+        event: T;
+        isEnter: boolean;
+    }>;
+    eventHandlerGuard?: ConditionGuardType<T>;
+    secondary?: (e: T) => void;
+}) => ((event: T) => void);
+/**
+ * Тип события {@link Event} с уточнённым `currentTarget`
+ */
+export type TargetEvent<E extends Event, N extends HTMLElement = HTMLDivElement> = E & {
+    currentTarget: EventTarget & N;
+};
+/**
+ * Тип клавиатурного события {@link KeyboardEvent} с уточнённым `currentTarget`
+ */
+export type TargetKeyboardEvent<N extends HTMLElement = HTMLDivElement> = TargetEvent<KeyboardEvent, N>;
+/**
+ * Объединение {@link MouseEvent} и {@link TargetKeyboardEvent}
+ */
+export type MouseBoardEvent<N extends HTMLElement = HTMLDivElement> = MouseEvent | TargetKeyboardEvent<N>;
+export declare const isKeyboardEvent: (e: any) => e is KeyboardEvent;
+export type CtxMenuEvent<N extends HTMLElement = HTMLDivElement> = {
+    isKeyboardEvent: true;
+    event: TargetKeyboardEvent<N>;
+    position: {
+        left: number;
+        top: number;
+    };
+} | {
+    isKeyboardEvent: false;
+    event: MouseEvent;
+    position: {
+        left: number;
+        top: number;
+    };
+};
+/**
+ * Создаёт обработчик события контекстного меню
+ *
+ * - Если событие вызвано клавиатурой, то координаты берутся из {@link getBoundingClientRect} текущего элемента
+ * - Если мышью - то из {@link MouseEvent.clientX} и {@link MouseEvent.clientY}
+ *
+ * @param handler - Обработчик события
+ * @param [guards={}] - Условия выполнений
+ * @param [guards.preventStopGuard="handler"] - Политика вызова {@link preventStop} для события
+ * @param [guards.eventHandlerGuard=true] - Вызов обработчика
+ */
+export declare const createCtxMenuHandler: <N extends HTMLElement = HTMLDivElement>(handler?: CanBeNullable<(event: CtxMenuEvent<N>) => CanBePromise>, guards?: {
+    preventStopGuard?: "handler" | ConditionGuardType<[CtxMenuEvent<N>, typeof handler]>;
+    eventHandlerGuard?: ConditionGuardType<CtxMenuEvent<N>>;
+}) => ((event: MouseBoardEvent<N>) => void);
+/**
+ * Чинит то, что при `ondblclick` первоначально вызывается `onclick`.
+ * Использовать **только** при реальной обработке `ondblclick`, так как создаётся input-лаг
+ *
+ * @param singleClickHandler - Обработчик для `onclick`
+ * @param doubleClickHandler - Обработчик для `ondblclick`
+ * @param [delay=65ms] - Задержка для определения, что это `ondblclick`
+ */
+export declare const createClickHandlers: (singleClickHandler: (e: MouseEvent) => CanBePromise, doubleClickHandler: (e: MouseEvent) => CanBePromise, delay?: number) => {
+    onclick: (e: MouseEvent) => void;
+    ondblclick: (e: MouseEvent) => void;
+};
+export interface CreateEventListenerOptions extends AddEventListenerOptions {
+    target?: HTMLElement | Window | Document;
+}
+/**
+ * @template EventMap - Карта событий (например, {@link WindowEventMap})
+ *
+ * @param event - Ключ события
+ * @param listener - Обработчик события
+ * @param [options] - Опции создания
+ * @param [options.target=window] - У чего слушаем события
+ *
+ * @returns Функция для удаления обработчика
+ */
+export declare const createEventListener: <EventMap = WindowEventMap, const K extends KEYS<EventMap> = KEYS<EventMap>, E = EventMap[K]>(event: K, listener: (e: E) => CanBePromise, options?: CreateEventListenerOptions) => (() => void);
+declare global {
+    interface WindowEventMap {
+        /**
+         * Кастомное событие для прокрутки
+         */
+        scrollTo: CustomEvent;
+    }
+}
+export interface CreateScrollToListenerContext extends CreateEventListenerOptions {
+    /**
+     * @default { top: 0, behavior: "smooth" }
+     */
+    options?: ScrollToOptions;
+    element?: HTMLElement;
+}
+/**
+ * Создаёт обработчик события `scrollTo`
+ *
+ * @returns Функция для удаления обработчика
+ */
+export declare const createScrollToListener: (ctx: CreateScrollToListenerContext) => (() => void);
+/**
+ * @param [element=window] - Что диспатчит событие `scrollTo`
+ */
+export declare const dispatchScrollTo: (element?: HTMLElement | Window | Document) => boolean;

package/dist/html/events.js

@@ -0,0 +1,139 @@
+import { useConditionGuard } from "../index.js";
+/**
+ * Предотвращает стандартное поведение события и останавливает его всплытие
+ */
+export const preventStop = (e) => (e.preventDefault(), e.stopPropagation());
+/**
+ * @param handler - Обработчик события
+ * @param [guards={}] - Условия выполнений
+ * @param [guards.preventStopGuard=true] - Вызов {@link preventStop} для события
+ * @param [guards.eventHandlerGuard=true] - Вызов обработчика
+ */
+export const usePreventStop = (handler, guards = {}) => (event) => {
+    const { preventStopGuard = true, eventHandlerGuard = true } = guards;
+    if (useConditionGuard(preventStopGuard, { event, handler }))
+        preventStop(event);
+    if (handler && useConditionGuard(eventHandlerGuard, { event, handler }))
+        void handler(event);
+};
+//...
+/**
+ * @param handler - Обработчик события
+ * @param [props={}] - Дополнительные возможности
+ * @param [props.preventStopGuard="enter"] - Политика вызова {@link preventStop} для события
+ * @param [props.eventHandlerGuard=true] - Вызов обработчика
+ * @param [props.secondary] - Обработчик для других клавиш
+ */
+export const createEnterHandler = (handler, props = {}) => (event) => {
+    const { preventStopGuard = "enter", eventHandlerGuard = true, secondary } = props;
+    const isEnter = event.key === "Enter";
+    if (preventStopGuard === "enter") {
+        if (isEnter)
+            preventStop(event);
+    }
+    else {
+        if (useConditionGuard(preventStopGuard, { event, isEnter }))
+            preventStop(event);
+    }
+    if (isEnter) {
+        if (handler && useConditionGuard(eventHandlerGuard, event))
+            void handler(event);
+    }
+    else {
+        secondary?.(event);
+    }
+};
+export const isKeyboardEvent = (e) => !!e.code;
+/**
+ * Создаёт обработчик события контекстного меню
+ *
+ * - Если событие вызвано клавиатурой, то координаты берутся из {@link getBoundingClientRect} текущего элемента
+ * - Если мышью - то из {@link MouseEvent.clientX} и {@link MouseEvent.clientY}
+ *
+ * @param handler - Обработчик события
+ * @param [guards={}] - Условия выполнений
+ * @param [guards.preventStopGuard="handler"] - Политика вызова {@link preventStop} для события
+ * @param [guards.eventHandlerGuard=true] - Вызов обработчика
+ */
+export const createCtxMenuHandler = (handler, guards = {}) => (event) => {
+    const { preventStopGuard = "handler", eventHandlerGuard = true } = guards;
+    if (preventStopGuard === "handler") {
+        if (handler)
+            preventStop(event);
+        else
+            return;
+    }
+    let ctx;
+    if (isKeyboardEvent(event)) {
+        const { x, y } = event.currentTarget.getBoundingClientRect();
+        ctx = { isKeyboardEvent: true, event, position: { left: x, top: y } };
+    }
+    else {
+        ctx = { isKeyboardEvent: false, event, position: { left: event.clientX, top: event.clientY } };
+    }
+    if (useConditionGuard(preventStopGuard, [ctx, handler]))
+        preventStop(event);
+    if (handler && useConditionGuard(eventHandlerGuard, ctx))
+        void handler(ctx);
+};
+//...
+/**
+ * Чинит то, что при `ondblclick` первоначально вызывается `onclick`.
+ * Использовать **только** при реальной обработке `ondblclick`, так как создаётся input-лаг
+ *
+ * @param singleClickHandler - Обработчик для `onclick`
+ * @param doubleClickHandler - Обработчик для `ondblclick`
+ * @param [delay=65ms] - Задержка для определения, что это `ondblclick`
+ */
+export const createClickHandlers = (singleClickHandler, doubleClickHandler, delay = 65) => {
+    let clickTimer = 0;
+    let isDoubleClick = false;
+    const onclick = (e) => {
+        if (clickTimer)
+            return;
+        clickTimer = setTimeout(() => {
+            if (!isDoubleClick)
+                void singleClickHandler(e);
+            clickTimer = 0;
+            isDoubleClick = false;
+        }, delay);
+    };
+    const ondblclick = (e) => {
+        isDoubleClick = true;
+        if (clickTimer) {
+            clearTimeout(clickTimer);
+            clickTimer = 0;
+        }
+        void doubleClickHandler(e);
+    };
+    return { onclick, ondblclick };
+};
+/**
+ * @template EventMap - Карта событий (например, {@link WindowEventMap})
+ *
+ * @param event - Ключ события
+ * @param listener - Обработчик события
+ * @param [options] - Опции создания
+ * @param [options.target=window] - У чего слушаем события
+ *
+ * @returns Функция для удаления обработчика
+ */
+export const createEventListener = (event, listener, options = {}) => {
+    const target = options.target ?? window;
+    target.addEventListener(event, listener, options);
+    return () => target.removeEventListener(event, listener);
+};
+/**
+ * Создаёт обработчик события `scrollTo`
+ *
+ * @returns Функция для удаления обработчика
+ */
+export const createScrollToListener = (ctx) => createEventListener("scrollTo", 
+// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+() => ctx.element?.scrollTo?.(ctx.options ?? { top: 0, behavior: "smooth" }), ctx);
+/**
+ * @param [element=window] - Что диспатчит событие `scrollTo`
+ */
+export const dispatchScrollTo = (element = window) => 
+// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+element?.dispatchEvent?.(new CustomEvent("scrollTo"));

package/dist/html/index.d.ts

@@ -0,0 +1,31 @@
+/**
+ * `true`, если глобальный объект `window` отсутствует
+ */
+export declare const isSSR: boolean;
+/**
+ * Убирает фокус на активном элементе страницы
+ */
+export declare const unfocus: () => void;
+/**
+ * Снимает текущее выделение текста на странице
+ */
+export declare const unselect: () => void;
+/**
+ * Добавляет одноразовый обработчик `mousedown`, который снимает выделение текста
+ *
+ * @returns Функция для удаления обработчика
+ */
+export declare const unselectByMousedown: () => (() => void);
+/**
+ * Автоматически изменяет высоту `textarea` в зависимости от содержимого
+ *
+ * @remarks работает с {@link HTMLTextAreaElement.style.height} и {@link HTMLTextAreaElement.scrollTop}
+ */
+export declare const autoAreaHeight: (area?: HTMLTextAreaElement) => void;
+/**
+ * Преобразует {@link FormData} в объект
+ *
+ * @param form - Данные формы
+ * @param [multi=false] - Есть массивы значений для одинаковых ключей
+ */
+export declare const formon: <D = any>(form: FormData, multi?: boolean) => D;

package/dist/html/index.js

@@ -0,0 +1,61 @@
+import { createEventListener } from "./events.js";
+/**
+ * `true`, если глобальный объект `window` отсутствует
+ */
+export const isSSR = typeof window === "undefined";
+//...
+/**
+ * Убирает фокус на активном элементе страницы
+ */
+export const unfocus = () => 
+// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+document.activeElement?.blur?.();
+/**
+ * Снимает текущее выделение текста на странице
+ */
+export const unselect = () => document.getSelection()?.removeAllRanges();
+/**
+ * Добавляет одноразовый обработчик `mousedown`, который снимает выделение текста
+ *
+ * @returns Функция для удаления обработчика
+ */
+export const unselectByMousedown = () => createEventListener("mousedown", unselect, { once: true });
+//...
+/**
+ * Автоматически изменяет высоту `textarea` в зависимости от содержимого
+ *
+ * @remarks работает с {@link HTMLTextAreaElement.style.height} и {@link HTMLTextAreaElement.scrollTop}
+ */
+export const autoAreaHeight = (area) => {
+    if (!area)
+        return;
+    area.style.height = "auto";
+    area.style.height = `${area.scrollHeight}px`;
+    area.scrollTop = area.scrollHeight;
+};
+/**
+ * Преобразует {@link FormData} в объект
+ *
+ * @param form - Данные формы
+ * @param [multi=false] - Есть массивы значений для одинаковых ключей
+ */
+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/index.d.ts

@@ -1,60 +1,58 @@
-import type { CanBeArray, CanBePromise, CanBeReadonly } from "./types.js";
 /**
- * Добавляет ведущие нули к числу для достижения указанной длины
+ * Преобразует число в строку, добавляя ведущие нули для достижения указанной длины
  *
- * @example pad(123, 5) => "00123"
+ * @example
+ * ```typescript
+ * pad(123, 5); // "00123"
+ * ```
  */
 export declare const pad: (v: number, l?: number) => string;
 /**
  * JSON-клонирование объектов посредством `JSON.parse(JSON.stringify(v))`
- * Если значение не `object` вернётся как есть
+ *
+ * Если значение не `object` - возвращается как есть
  */
 export declare const parsify: <T>(v: T) => T;
 /**
- * Приведение значения к массиву
- */
-export declare const arrayble: <T>(v: CanBeArray<T>) => T[];
-export declare const isObject: (obj: unknown) => obj is object;
-export declare const isSameType: <A = unknown>(a: A, b: unknown) => b is A;
-/**
- * Тип разделения для функции {@link partition}
+ * Агрегация функций в одну
  */
-export interface Partition<T> {
-    /**
-     * Элементы, удовлетворяющие условию
-     */
-    result: T[];
-    /**
-     * Исключённые элементы
-     */
-    excluded: T[];
-}
+export declare const aggregate: (...args: (() => void)[]) => () => void;
 /**
- * Разделяет массив на два по условию
+ * Проверяет, является ли значение объектом (не `null`, и `typeof === "object"`)
  */
-export declare const partition: <T>(arr: CanBeReadonly<T>, filter: (item: T) => boolean, initial?: Partition<T>) => Partition<T>;
+export declare const isObject: (obj: unknown) => obj is object;
 /**
- * Удаляет `null` и `undefined` и оставляет только уникальные строки
+ * Проверяет, имеют ли два значения одинаковый тип (на основе {@link Object.prototype.toString})
  */
-export declare const setify: (arr: CanBeReadonly<string | undefined | null>) => string[];
+export declare const isSameType: <A = unknown>(a: A, b: unknown) => b is A;
+export type ConditionGuardValue = object | number | string | boolean | null;
+export type ConditionGuardType<CTX> = ConditionGuardValue | ((ctx: CTX) => ConditionGuardValue);
 /**
- * Удаляет дубликаты объектов из массива на основе указанного ключа
+ * Использование значения (или функции, возвращающей значение) и приведение его к булевому
  *
- * @template T - Тип элементов массива
- * @template K - Ключ объекта, по которому определяется уникальность
- * @param {T[]} arr - Исходный массив объектов
- * @param {K} [key="id"] - Ключ, по которому будут удаляться дубликаты
- * @returns {T[]} Новый массив без дубликатов
+ * @param condition - Условие для проверки
+ * @param ctx - Контекст, передаваемый в функцию-условие
  */
-export declare const unify: <T, K extends keyof T>(arr: CanBeReadonly<T>, key?: K) => T[];
-export declare const useConditionGuard: (condition: unknown, ...args: any[]) => boolean;
+export declare const useConditionGuard: <CTX>(condition: ConditionGuardType<CTX>, ctx: CTX) => boolean;
 /**
- * Сортирует ключи объекта в алфавитном порядке и возвращает новый объект с отсортированными ключами
+ * Создаёт новый объект и добавляет в него ключи и значения исходного в алфавитном порядке
+ *
+ * @remarks **НЕ** предназначен для работы с декларативными методами (могут потерять `this`)
  */
-export declare const sortObjectByKeys: <T>(obj: T) => T;
-export type BoundaryFallback<E> = E | ((err: unknown) => CanBePromise<E>);
+export declare const sortObjectByKeys: <T extends object>(obj: T) => T;
 /**
- * Приведение коллбэка к промису с отловом ошибок и fallback-ом
- */
-export declare const boundary: <R = undefined, E = R>(call: () => CanBePromise<R>, fallback?: BoundaryFallback<E>) => Promise<R | E>;
-export declare const cleanup: (...args: (() => void)[]) => () => void;
+ * Создаёт функцию для склонения слова по числу (для русского языка)
+ *
+ * @param one - Форма слова для одного элемента (например, "яблоко")
+ * @param few - Форма слова для двух-четырёх элементов (например, "яблока")
+ * @param many - Форма слова для пяти-девяти элементов или нуля (например, "яблок")
+ *
+ * @example
+ * ```typescript
+ * const pluralizeApple = createValuePluralizer("яблоко", "яблока", "яблок");
+ * pluralizeApple(1); // "яблоко"
+ * pluralizeApple(3); // "яблока"
+ * pluralizeApple(5); // "яблок"
+ * ```
+ */
+export declare const createValuePluralizer: (one: string, few: string, many: string) => (value: number) => string;

package/dist/index.js

@@ -1,64 +1,50 @@
 /**
- * Добавляет ведущие нули к числу для достижения указанной длины
+ * Преобразует число в строку, добавляя ведущие нули для достижения указанной длины
  *
- * @example pad(123, 5) => "00123"
+ * @example
+ * ```typescript
+ * pad(123, 5); // "00123"
+ * ```
  */
 export const pad = (v, l = 2) => String(v).padStart(l, "0");
 /**
  * JSON-клонирование объектов посредством `JSON.parse(JSON.stringify(v))`
- * Если значение не `object` вернётся как есть
+ *
+ * Если значение не `object` - возвращается как есть
  */
 export const parsify = (v) => {
-    if (typeof v !== "object")
+    if (typeof v !== "object" || v === null)
         return v;
     return JSON.parse(JSON.stringify(v));
 };
 /**
- * Приведение значения к массиву
+ * Агрегация функций в одну
  */
-export const arrayble = (v) => (Array.isArray(v) ? v : [v]);
+export const aggregate = (...args) => () => {
+    for (const call of args)
+        call();
+};
 //...
-export const isObject = (obj) => obj !== null && typeof obj === "object";
-export const isSameType = (a, b) => Object.prototype.toString.call(a) === Object.prototype.toString.call(b);
 /**
- * Разделяет массив на два по условию
+ * Проверяет, является ли значение объектом (не `null`, и `typeof === "object"`)
  */
-export const partition = (arr, filter, initial = { result: [], excluded: [] }) => 
-// @ts-expect-error <оно себя неадекватно ведёт>
-arr.reduce((acc, item) => (acc[filter(item) ? "result" : "excluded"].push(item), acc), initial);
-//...
+export const isObject = (obj) => obj !== null && typeof obj === "object";
 /**
- * Удаляет `null` и `undefined` и оставляет только уникальные строки
+ * Проверяет, имеют ли два значения одинаковый тип (на основе {@link Object.prototype.toString})
  */
-export const setify = (arr) => 
-// @ts-expect-error <оно себя неадекватно ведёт>
-[...new Set(arr.filter((item) => typeof item === "string"))];
+export const isSameType = (a, b) => Object.prototype.toString.call(a) === Object.prototype.toString.call(b);
 /**
- * Удаляет дубликаты объектов из массива на основе указанного ключа
+ * Использование значения (или функции, возвращающей значение) и приведение его к булевому
  *
- * @template T - Тип элементов массива
- * @template K - Ключ объекта, по которому определяется уникальность
- * @param {T[]} arr - Исходный массив объектов
- * @param {K} [key="id"] - Ключ, по которому будут удаляться дубликаты
- * @returns {T[]} Новый массив без дубликатов
+ * @param condition - Условие для проверки
+ * @param ctx - Контекст, передаваемый в функцию-условие
  */
-export const unify = (arr, key = "id") => 
-// @ts-expect-error <оно себя неадекватно ведёт>
-[...new Map(arr.map((item) => [item[key], item])).values()];
-//...
-export const useConditionGuard = (condition, ...args) => {
-    switch (typeof condition) {
-        case "undefined":
-            return true;
-        case "function":
-            return !!condition(...args);
-        default:
-            return !!condition;
-    }
-};
+export const useConditionGuard = (condition, ctx) => typeof condition === "function" ? !!condition(ctx) : !!condition;
 //...
 /**
- * Сортирует ключи объекта в алфавитном порядке и возвращает новый объект с отсортированными ключами
+ * Создаёт новый объект и добавляет в него ключи и значения исходного в алфавитном порядке
+ *
+ * @remarks **НЕ** предназначен для работы с декларативными методами (могут потерять `this`)
  */
 export const sortObjectByKeys = (obj) => {
     const keys = Object.keys(obj).sort();
@@ -68,23 +54,24 @@ export const sortObjectByKeys = (obj) => {
     return result;
 };
 /**
- * Приведение коллбэка к промису с отловом ошибок и fallback-ом
+ * Создаёт функцию для склонения слова по числу (для русского языка)
+ *
+ * @param one - Форма слова для одного элемента (например, "яблоко")
+ * @param few - Форма слова для двух-четырёх элементов (например, "яблока")
+ * @param many - Форма слова для пяти-девяти элементов или нуля (например, "яблок")
+ *
+ * @example
+ * ```typescript
+ * const pluralizeApple = createValuePluralizer("яблоко", "яблока", "яблок");
+ * pluralizeApple(1); // "яблоко"
+ * pluralizeApple(3); // "яблока"
+ * pluralizeApple(5); // "яблок"
+ * ```
  */
-export const boundary = async (call, fallback) => {
-    try {
-        return await call();
-    }
-    catch (e) {
-        console.error("boundary", e);
-        if (typeof fallback === "function") {
-            // @ts-expect-error <тут не типизировать>
-            return fallback(e);
-        }
-        return fallback;
-    }
-};
-//...
-export const cleanup = (...args) => () => {
-    for (const call of args)
-        call();
+export const createValuePluralizer = (one, few, many) => (value) => {
+    const n = Math.abs(value) % 100;
+    if (n >= 11 && n <= 19)
+        return many;
+    const d = n % 10;
+    return d === 1 ? one : d >= 2 && d <= 4 ? few : many;
 };