senaev-utils 1.0.0

package/src/utils/Number/collectIntegerSequences/collectIntegerSequences.ts

@@ -0,0 +1,36 @@
+import { Integer } from '../../../types/Number/Integer';
+import { PositiveInteger } from '../../../types/Number/PositiveInteger';
+import { UnsignedInteger } from '../../../types/Number/UnsignedInteger';
+
+type IntegerSequence = {
+    start: UnsignedInteger;
+    length: PositiveInteger;
+};
+
+export function collectIntegerSequences(integers: Integer[]): IntegerSequence[] {
+    if (!integers.length) {
+        return [];
+    }
+
+    const sequences: IntegerSequence[] = [
+        {
+            start: integers[0],
+            length: 1,
+        },
+    ];
+
+    for (let i = 1; i < integers.length; i += 1) {
+        const lastSequence = sequences.at(-1)!;
+
+        if (lastSequence.start + lastSequence.length === integers[i]) {
+            lastSequence.length += 1;
+        } else {
+            sequences.push({
+                start: integers[i],
+                length: 1,
+            });
+        }
+    }
+
+    return sequences;
+}

package/src/utils/Number/numberToFixedPrecision/numberToFixedPrecision.ts

@@ -0,0 +1,13 @@
+export function numberToFixedPrecision(number: number, precision = 4): string {
+    // Handle zero as a special case since Math.log10(0) returns -Infinity
+    if (number === 0) {
+        return '0';
+    }
+
+    const absNumber = Math.abs(number);
+    const log10 = Math.log10(absNumber);
+    const log10Int = Math.floor(log10);
+    const toFixed = Math.max(0, precision - log10Int);
+
+    return number.toFixed(toFixed);
+}

package/src/utils/Object/cloneObject/cloneObject.ts

@@ -0,0 +1,3 @@
+export function cloneObject<T>(object: T): T {
+    return structuredClone(object);
+}

package/src/utils/Object/deepEqual/deepEqual.ts

@@ -0,0 +1,45 @@
+import { isObject } from '../../../types/Object/Object';
+import { getObjectKeys } from '../getObjectKeys/getObjectKeys';
+
+/**
+ * Код взят отсюда https://gist.github.com/egardner/efd34f270cc33db67c0246e837689cb9
+ *
+ * Функция подходит только для сравнения объектов и массивов любой вложенности с примитивами внутри
+ *
+ * Не подходит для сравнения сложных объектов типа Date, Function, RegExp и т.п.
+ * Воспринимает их как простые объекты и сравнивает собственные перечисляемые свойства
+ *
+ * Выдает false при сравнении двух NaN
+ */
+export function deepEqual<T>(actual: unknown, expected: T): actual is T {
+    if (actual === expected) {
+        return true;
+    }
+
+    if (!isObject(actual) || !isObject(expected)) {
+        return false;
+    }
+
+    if (Array.isArray(actual) !== Array.isArray(expected)) {
+        return false;
+    }
+
+    const actualKeys = getObjectKeys(actual);
+    const expectedKeys = getObjectKeys(expected);
+
+    if (actualKeys.length !== expectedKeys.length) {
+        return false;
+    }
+
+    for (const key of expectedKeys) {
+        if (!((key as string) in actual)) {
+            return false;
+        }
+
+        if (!deepEqual((actual as T)[key as keyof T], expected[key])) {
+            return false;
+        }
+    }
+
+    return true;
+}

package/src/utils/Object/deleteUndefinedProperties/index.ts

@@ -0,0 +1,13 @@
+import { hasOwnProperty } from '../hasOwnProperty/hasOwnProperty';
+
+export function deleteUndefinedProperties<T extends Record<string, unknown>>(obj: T): Partial<T> {
+    const result: Partial<T> = {};
+
+    for (const key in obj) {
+        if (hasOwnProperty(obj, key) && obj[key] !== undefined) {
+            result[key] = obj[key];
+        }
+    }
+
+    return result;
+}

package/src/utils/Object/entriesToObject/entriesToObject.ts

@@ -0,0 +1,12 @@
+export function entriesToObject<Key extends string, Value>(entries: [Key, Value][]): Record<Key, Value> {
+    const object = {} as Record<Key, Value>;
+
+    entries.forEach(([
+        key,
+        value,
+    ]) => {
+        object[key] = value;
+    });
+
+    return object;
+}

package/src/utils/Object/filterObject/filterObject.ts

@@ -0,0 +1,18 @@
+import { getObjectKeys } from '../getObjectKeys/getObjectKeys';
+
+export function filterObject<O extends Record<string, unknown>>(
+    object: O,
+    filterFunction: (value: O[keyof O], key: keyof O) => boolean
+): O {
+    const resultObject = {} as O;
+
+    getObjectKeys(object).forEach((key) => {
+        const shouldRemainProperty = filterFunction(object[key], key);
+
+        if (shouldRemainProperty) {
+            resultObject[key] = object[key];
+        }
+    });
+
+    return resultObject;
+}

package/src/utils/Object/forOwn/forOwn.ts

@@ -0,0 +1,12 @@
+import { hasOwnProperty } from '../hasOwnProperty/hasOwnProperty';
+
+export function forOwn<Obj extends {}>(
+    obj: Obj,
+    fn: (value: Obj[keyof Obj], key: keyof Obj, sourceObj: Obj) => void
+): void {
+    for (const key in obj) {
+        if (hasOwnProperty(obj, key)) {
+            fn(obj[key], key, obj);
+        }
+    }
+}

package/src/utils/Object/getObjectEntries/getObjectEntries.ts

@@ -0,0 +1,3 @@
+export function getObjectEntries<Key extends string, Value>(object: Record<Key, Value>): [Key, Value][] {
+    return Object.entries(object) as [Key, Value][];
+}

package/src/utils/Object/getObjectKeys/getObjectKeys.ts

@@ -0,0 +1,3 @@
+export function getObjectKeys<T extends Record<string, unknown>>(object: T): (keyof T)[] {
+    return Object.keys(object);
+}

package/src/utils/Object/getObjectValues/index.ts

@@ -0,0 +1,3 @@
+export function getObjectValues<T extends Record<string, unknown>>(object: T): T[keyof T][] {
+    return Object.values(object) as T[keyof T][];
+}

package/src/utils/Object/hasOwnProperty/hasOwnProperty.ts

@@ -0,0 +1,3 @@
+export function hasOwnProperty<O>(obj: O, key: string | number | symbol): key is keyof O {
+    return Object.prototype.hasOwnProperty.call(obj, key);
+}

package/src/utils/Object/invertObject/InvertedObject.ts

@@ -0,0 +1,3 @@
+export type InvertedObject<T extends Record<string, string>> = {
+    [key in T[keyof T]]: keyof T;
+};

package/src/utils/Object/invertObject/invertObject.ts

@@ -0,0 +1,15 @@
+import { InvertedObject } from './InvertedObject';
+
+export function invertObject<T extends Record<string, string>>(object: T): InvertedObject<T> {
+    const nextObject = {} as InvertedObject<T>;
+
+    for (const key in object) {
+        if (Object.prototype.hasOwnProperty.call(object, key)) {
+            const value = object[key];
+
+            (nextObject as Record<T[keyof T], keyof T>)[value] = key;
+        }
+    }
+
+    return nextObject;
+}

package/src/utils/Object/isEmptyObject/index.ts

@@ -0,0 +1,5 @@
+import { getObjectKeys } from '../getObjectKeys/getObjectKeys';
+
+export function isEmptyObject<T extends Record<string, unknown>>(object: T): boolean {
+    return !getObjectKeys(object).length;
+}

package/src/utils/Object/isObject/index.ts

@@ -0,0 +1,8 @@
+/**
+ * Returns 'true' if {@param value} is {@type object}
+ */
+export function isObject<T extends Record<string, unknown> = Record<string, unknown>>(value: unknown): value is T {
+    const type = typeof value;
+
+    return Boolean(value) && (type === 'object' || type === 'function');
+}

package/src/utils/Object/mapObjectKeys/mapObjectKeys.ts

@@ -0,0 +1,25 @@
+import { getObjectKeys } from '../getObjectKeys/getObjectKeys';
+
+/**
+ * Функция принимает на вход первым агрументом объект и прогоняет все собственные свойства
+ * (ключ и значение в качестве аргументов) через функцию, которая приходит вторым аргументом.
+ * Эта функция для каждого свойства должна вернуть новый ключ для
+ * конкретного значения объекта.
+ *
+ * Функция возвращает новый объект, со старыми значениями и новыми ключами.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function mapObjectKeys<T extends Record<string, any>, S extends string>(
+    object: T,
+    mapFunction: (key: keyof T, value: T[keyof T]) => S
+): Record<S, T[keyof T]> {
+    const resultObject = {} as Record<S, T[keyof T]>;
+
+    getObjectKeys(object).forEach((key) => {
+        const newKey = mapFunction(key, object[key]);
+
+        resultObject[newKey] = object[key];
+    });
+
+    return resultObject;
+}

package/src/utils/Object/mapObjectValues/mapObjectValues.ts

@@ -0,0 +1,16 @@
+import { getObjectKeys } from '../getObjectKeys/getObjectKeys';
+
+export function mapObjectValues<
+    T extends Record<string, unknown>,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- only for util snd better typing
+    TMapFunc extends (value: T[keyof T], key: keyof T) => any,
+    R extends { [P in keyof T]: ReturnType<TMapFunc> },
+>(object: T, mapFunction: TMapFunc): R {
+    const resultObject = {} as Record<string, unknown>;
+
+    getObjectKeys(object).forEach((key) => {
+        resultObject[key as string] = mapFunction(object[key], key);
+    });
+
+    return resultObject as R;
+}

package/src/utils/Object/mirrorObject/ObjectKeysMirror.ts

@@ -0,0 +1 @@
+export type ObjectKeysMirror<T extends Record<string, unknown>> = { [key in keyof T]: key };

package/src/utils/Object/mirrorObject/mirrorObject.ts

@@ -0,0 +1,7 @@
+import { mapObjectValues } from '../mapObjectValues/mapObjectValues';
+
+import { ObjectKeysMirror } from './ObjectKeysMirror';
+
+export function mirrorObject<T extends Record<string, unknown>>(object: T): ObjectKeysMirror<T> {
+    return mapObjectValues(object, (_value, key) => key) as ObjectKeysMirror<T>;
+}

package/src/utils/Pagination/DEFAULT_PAGE.ts

@@ -0,0 +1 @@
+export const DEFAULT_PAGE = 1;

package/src/utils/Pagination/calculatePaginationParameters.ts

@@ -0,0 +1,29 @@
+import { PositiveInteger } from '../../types/Number/PositiveInteger';
+import { UnsignedInteger } from '../../types/Number/UnsignedInteger';
+
+import { DEFAULT_PAGE } from './DEFAULT_PAGE';
+
+export const calculatePaginationParameters = ({
+    page,
+    pageSize,
+    totalCount,
+}: {
+    page: UnsignedInteger;
+    pageSize: PositiveInteger;
+    totalCount: UnsignedInteger;
+}): {
+    canGoToPreviousPage: boolean;
+    canGoToNextPage: boolean;
+    totalPages: UnsignedInteger;
+} => {
+    const canGoToPreviousPage = page > DEFAULT_PAGE;
+
+    const totalPages = Math.ceil(totalCount / pageSize);
+    const isLastPage = page >= totalPages;
+
+    return {
+        canGoToPreviousPage,
+        canGoToNextPage: !isLastPage,
+        totalPages,
+    };
+};

package/src/utils/Promise/promiseAll/promiseAll.ts

@@ -0,0 +1,6 @@
+/**
+ * Type-safe version of Promise.all(...)
+ */
+export function promiseAll<T extends unknown[]>(promises: T): Promise<{ [K in keyof T]: Awaited<T[K]> }> {
+    return Promise.all(promises);
+}

package/src/utils/Promise/restrictParallelCalls/restrictParallelCalls.ts

@@ -0,0 +1,18 @@
+import { AnyAsyncFunction } from '../../../types/any/AnyAsyncFunction';
+
+export function restrictParallelCalls<T extends AnyAsyncFunction>(callback: T, errorMessage?: string): T {
+    let isRunning = false;
+
+    return ((...args: Parameters<T>) => {
+        if (isRunning) {
+            throw new Error(`restrictParallelCalls${errorMessage ? ` errorMessage=[${errorMessage}]` : ''} previous call is not finished, do not call function in parallel`);
+        }
+
+        isRunning = true;
+        const promise = callback(...args);
+
+        return promise.finally(() => {
+            isRunning = false;
+        });
+    }) as T;
+}

package/src/utils/Ranges/checkRangesAdjacent/checkRangesAdjacent.ts

@@ -0,0 +1,23 @@
+import { RangeTuple } from '../../../types/RangeTuple';
+
+export function checkRangesAdjacent(
+    range1: RangeTuple<number>,
+    range2: RangeTuple<number>
+): boolean {
+    const [
+        min1,
+        max1,
+    ] = [
+        Math.min(range1[0], range1[1]),
+        Math.max(range1[0], range1[1]),
+    ];
+    const [
+        min2,
+        max2,
+    ] = [
+        Math.min(range2[0], range2[1]),
+        Math.max(range2[0], range2[1]),
+    ];
+
+    return max1 === min2 || max2 === min1;
+}

package/src/utils/Ranges/checkRangesIntersection/checkRangesIntersection.ts

@@ -0,0 +1,8 @@
+import { RangeTuple } from '../../../types/RangeTuple';
+
+export function checkRangesIntersection(
+    range1: RangeTuple<number>,
+    range2: RangeTuple<number>
+): boolean {
+    return range1[0] < range2[1] && range1[1] > range2[0];
+}

package/src/utils/Ranges/excludeRanges/excludeRanges.ts

@@ -0,0 +1,42 @@
+type Range = [number, number];
+
+export function excludeRanges(initialRange: Range, sortedRangesToExclude: Range[]): Range[] {
+    const [
+        start,
+        end,
+    ] = initialRange;
+
+    const result: Range[] = [];
+    let currentNumber = start;
+
+    for (const [
+        meetingStart,
+        meetingEnd,
+    ] of sortedRangesToExclude) {
+        if (meetingStart >= end) {
+            break;
+        }
+
+        if (meetingEnd <= start) {
+            continue;
+        }
+
+        if (meetingStart > currentNumber) {
+            result.push([
+                currentNumber,
+                meetingStart,
+            ]);
+        }
+
+        currentNumber = Math.max(currentNumber, meetingEnd);
+    }
+
+    if (currentNumber < end) {
+        result.push([
+            currentNumber,
+            end,
+        ]);
+    }
+
+    return result;
+}

package/src/utils/Ranges/getDistanceToRange/getDistanceToRange.ts

@@ -0,0 +1,14 @@
+import { FiniteNumber } from '../../../types/Number/FiniteNumber';
+import { RangeTuple } from '../../../types/RangeTuple';
+
+export function getDistanceToRange(range: RangeTuple<FiniteNumber>, value: FiniteNumber): FiniteNumber {
+    if (value >= range[0] && value <= range[1]) {
+        return 0;
+    }
+
+    if (value < range[0]) {
+        return range[0] - value;
+    }
+
+    return range[1] - value;
+}

package/src/utils/Ranges/isRangeWithinRanges.ts

@@ -0,0 +1,14 @@
+type Range = [number, number];
+
+export function isRangeWithinRanges(range: Range, ranges: Range[]) {
+    for (const [
+        start,
+        end,
+    ] of ranges) {
+        if (start <= range[0] && range[1] <= end) {
+            return true;
+        }
+    }
+
+    return false;
+}

package/src/utils/Ranges/mapDateRangeToISODateStringRange/mapDateRangeToISODateStringRange.ts

@@ -0,0 +1,7 @@
+import { RangeTuple } from '../../../types/RangeTuple';
+import { ISODateString } from '../../../types/Time/ISODateString/ISODateString';
+import { mapRange } from '../mapRange/mapRange';
+
+export function mapDateRangeToISODateStringRange(range: RangeTuple<Date>): RangeTuple<ISODateString> {
+    return mapRange(range, (date) => date.toISOString());
+}

package/src/utils/Ranges/mapISODateStringRangeToUnixTimeMsRange/mapISODateStringRangeToUnixTimeMsRange.ts

@@ -0,0 +1,8 @@
+import { RangeTuple } from '../../../types/RangeTuple';
+import { ISODateString } from '../../../types/Time/ISODateString/ISODateString';
+import { UnixTimeMs } from '../../../types/Time/UnixTimeMs';
+import { mapRange } from '../mapRange/mapRange';
+
+export function mapISODateStringRangeToUnixTimeMsRange(range: RangeTuple<ISODateString>): RangeTuple<UnixTimeMs> {
+    return mapRange(range, (isoDateString) => new Date(isoDateString).getTime());
+}

package/src/utils/Ranges/mapRange/mapRange.ts

@@ -0,0 +1,13 @@
+import { RangeTuple } from '../../../types/RangeTuple';
+
+export function mapRange<A, F extends (
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    a: A, index: 0 | 1) => any, B extends ReturnType<F>>(
+    range: RangeTuple<A>,
+    func: F
+): RangeTuple<B> {
+    return [
+        func(range[0], 0),
+        func(range[1], 1),
+    ];
+}

package/src/utils/Ranges/mapUnixTimeMsRangeToISODateStringRange/mapUnixTimeMsRangeToISODateStringRange.ts

@@ -0,0 +1,8 @@
+import { RangeTuple } from '../../../types/RangeTuple';
+import { ISODateString } from '../../../types/Time/ISODateString/ISODateString';
+import { UnixTimeMs } from '../../../types/Time/UnixTimeMs';
+import { mapRange } from '../mapRange/mapRange';
+
+export function mapUnixTimeMsRangeToISODateStringRange(range: RangeTuple<UnixTimeMs>): RangeTuple<ISODateString> {
+    return mapRange(range, (timestamp) => new Date(timestamp).toISOString());
+}

package/src/utils/Ranges/mergeRanges/mergeRanges.ts

@@ -0,0 +1,34 @@
+type Range = [number, number];
+
+export function mergeRanges(ranges: Range[]): Range[] {
+    if (!ranges.length) {
+        return [];
+    }
+
+    const stack: Range[] = [];
+
+    const sorted = [...ranges].sort((a, b) => a[0] - b[0]);
+
+    const firstRange = sorted[0];
+
+    stack.push([
+        firstRange[0],
+        firstRange[1],
+    ]);
+
+    for (let i = 1; i < sorted.length; i++) {
+        const range = sorted[i];
+        const lastRange = stack.at(-1)!;
+
+        if (lastRange[1] < range[0]) {
+            stack.push([
+                range[0],
+                range[1],
+            ]);
+        } else if (lastRange[1] < range[1]) {
+            lastRange[1] = range[1];
+        }
+    }
+
+    return stack;
+}

package/src/utils/Signal/Signal.ts

@@ -0,0 +1,47 @@
+import { SignalCallback } from './SignalCallback';
+
+/**
+ * EventEmitter with consistent value, alternative to BehaviorSubject from RxJS
+ *
+ * This class has been designed on a base of SolidJS reactive signal pattern https://www.solidjs.com/docs/latest/api#createsignal
+ * and signal-js EventEmitter library https://www.npmjs.com/package/signal-js
+ *
+ * Allows to create and combine business logic into reactive Signals and use them in React.context via useSignal hook
+ */
+export class Signal<T> {
+    private readonly callbacks: Set<SignalCallback<T>> = new Set<SignalCallback<T>>();
+
+    public constructor(
+        private _value: T,
+        private readonly checkToEqualFunction: (currentValue: T, nextValue: T) => boolean = (currentValue, nextValue) =>
+            currentValue === nextValue
+    ) { }
+
+    public value(): T {
+        return this._value;
+    }
+
+    public subscribe(callback: SignalCallback<T>): VoidFunction {
+        this.callbacks.add(callback);
+
+        return () => {
+            this.unsubscribe(callback);
+        };
+    }
+
+    public next(nextValue: T): void {
+        if (this.checkToEqualFunction(this._value, nextValue)) {
+            return;
+        }
+
+        this._value = nextValue;
+
+        for (const callback of this.callbacks.values()) {
+            callback(nextValue);
+        }
+    }
+
+    public unsubscribe(callback: SignalCallback<T>): void {
+        this.callbacks.delete(callback);
+    }
+}

package/src/utils/Signal/SignalCallback.ts

@@ -0,0 +1 @@
+export type SignalCallback<T> = (this: unknown, param: T) => void;

package/src/utils/Signal/combineSignalsIntoNewOne/combineSignalsIntoNewOne.ts

@@ -0,0 +1,75 @@
+import { Signal } from '../Signal';
+
+export type CombineSignalsIntoNewOneResult<T> = {
+    signal: Signal<T>;
+    teardown: VoidFunction;
+};
+
+export function combineSignalsIntoNewOne<T, A, B, C, D, E, F, G>(
+    signals: [Signal<A>, Signal<B>, Signal<C>, Signal<D>, Signal<E>, Signal<F>, Signal<G>],
+    combinator: (a: A, b: B, c: C, d: D, e: E, f: F, g: G) => T,
+    checkToEqualFunction?: (currentValue: T, nextValue: T) => boolean,
+): CombineSignalsIntoNewOneResult<T>;
+
+export function combineSignalsIntoNewOne<T, A, B, C, D, E, F>(
+    signals: [Signal<A>, Signal<B>, Signal<C>, Signal<D>, Signal<E>, Signal<F>],
+    combinator: (a: A, b: B, c: C, d: D, e: E, f: F) => T,
+    checkToEqualFunction?: (currentValue: T, nextValue: T) => boolean,
+): CombineSignalsIntoNewOneResult<T>;
+
+export function combineSignalsIntoNewOne<T, A, B, C, D, E>(
+    signals: [Signal<A>, Signal<B>, Signal<C>, Signal<D>, Signal<E>],
+    combinator: (a: A, b: B, c: C, d: D, e: E) => T,
+    checkToEqualFunction?: (currentValue: T, nextValue: T) => boolean,
+): CombineSignalsIntoNewOneResult<T>;
+
+export function combineSignalsIntoNewOne<T, A, B, C, D>(
+    signals: [Signal<A>, Signal<B>, Signal<C>, Signal<D>],
+    combinator: (a: A, b: B, c: C, d: D) => T,
+    checkToEqualFunction?: (currentValue: T, nextValue: T) => boolean,
+): CombineSignalsIntoNewOneResult<T>;
+
+export function combineSignalsIntoNewOne<T, A, B, C>(
+    signals: [Signal<A>, Signal<B>, Signal<C>],
+    combinator: (a: A, b: B, c: C) => T,
+    checkToEqualFunction?: (currentValue: T, nextValue: T) => boolean,
+): CombineSignalsIntoNewOneResult<T>;
+
+export function combineSignalsIntoNewOne<T, A, B>(
+    signals: [Signal<A>, Signal<B>],
+    combinator: (a: A, b: B) => T,
+    checkToEqualFunction?: (currentValue: T, nextValue: T) => boolean,
+): CombineSignalsIntoNewOneResult<T>;
+
+export function combineSignalsIntoNewOne<T, A>(
+    signals: [Signal<A>],
+    combinator: (a: A) => T,
+    checkToEqualFunction?: (currentValue: T, nextValue: T) => boolean,
+): CombineSignalsIntoNewOneResult<T>;
+
+export function combineSignalsIntoNewOne<T>(
+    signals: Signal<unknown>[],
+    combinator: (...args: unknown[]) => T,
+    checkToEqualFunction?: (currentValue: T, nextValue: T) => boolean
+): CombineSignalsIntoNewOneResult<T> {
+    const getAllValues = () => signals.map((signal) => signal.value());
+
+    const initialValue = combinator(...getAllValues());
+    const combinedSignal = new Signal(initialValue, checkToEqualFunction);
+
+    const unsubscribeFunctions: VoidFunction[] = signals.map((signal) =>
+        signal.subscribe(() => {
+            const nextValue = combinator(...getAllValues());
+
+            combinedSignal.next(nextValue);
+        }));
+
+    return {
+        signal: combinedSignal,
+        teardown() {
+            unsubscribeFunctions.forEach((unsubscribeFunction) => {
+                unsubscribeFunction();
+            });
+        },
+    };
+}

package/src/utils/Signal/subscribeSignalAndCallWithCurrentValue/subscribeSignalAndCallWithCurrentValue.ts

@@ -0,0 +1,7 @@
+import { Signal } from '../Signal';
+
+export function subscribeSignalAndCallWithCurrentValue<T>(signal: Signal<T>, callback: (value: T) => void): VoidFunction {
+    callback(signal.value());
+
+    return signal.subscribe(callback);
+}