senaev-utils 1.0.0

package/src/utils/Function/subscribeUpdatesWithTimeout/index.ts

@@ -0,0 +1,44 @@
+import { Milliseconds } from '../../../types/Time/Milliseconds';
+import { noop } from '../noop';
+
+export function subscribeUpdatesWithTimeout<T> ({
+    callback,
+    subscribe,
+    timeout,
+    onResubscribe,
+}: {
+    callback: (value: T) => void;
+    subscribe: (cb: typeof callback) => VoidFunction;
+    timeout: Milliseconds;
+    onResubscribe: VoidFunction;
+}): void {
+    let refreshTimeoutId: ReturnType<typeof setTimeout>;
+    const clearResubscribeTimeout = () => {
+        clearTimeout(refreshTimeoutId);
+    };
+    const setResubscribeTimeout = () => {
+        refreshTimeoutId = setTimeout(resubscribe, timeout);
+    };
+
+    let unsubscribe = noop;
+    const resubscribe = (isFirst = false) => {
+        if (!isFirst) {
+            onResubscribe();
+        }
+
+        clearResubscribeTimeout();
+        unsubscribe();
+
+        unsubscribe = subscribe((value) => {
+            clearResubscribeTimeout();
+
+            callback(value);
+
+            setResubscribeTimeout();
+        });
+
+        setResubscribeTimeout();
+    };
+
+    resubscribe(true);
+}

package/src/utils/Function/throttleFunction/throttleFunction.ts

@@ -0,0 +1,18 @@
+import { Subject, throttleTime } from 'rxjs';
+
+import { Milliseconds } from '../../../types/Time/Milliseconds';
+
+export function throttleFunction(func: VoidFunction, delay: Milliseconds): VoidFunction {
+    const subject = new Subject();
+
+    subject
+        .pipe(throttleTime(delay, undefined, {
+            leading: true,
+            trailing: true,
+        }))
+        .subscribe(func);
+
+    return () => {
+        subject.next(undefined);
+    };
+}

package/src/utils/Function/throttleWithPromiseFunction/throttleWithPromiseFunction.ts

@@ -0,0 +1,19 @@
+export function throttleWithPromiseFunction(callback: VoidFunction, promiseFunction: () => Promise<void>) {
+    let isRunning = false;
+
+    const throttled = () => {
+        if (isRunning) {
+            return;
+        }
+
+        isRunning = true;
+
+        promiseFunction().finally(() => {
+            callback();
+
+            isRunning = false;
+        });
+    };
+
+    return throttled;
+}

package/src/utils/Function/tryCatch/tryCatch.ts

@@ -0,0 +1,13 @@
+import { AnyFunction } from '../../../types/any/AnyFunction';
+
+export function tryCatch<T extends AnyFunction>(fn: T, onError?: (e: Error) => void): ReturnType<T> | undefined {
+    try {
+        return fn();
+    } catch (e) {
+        if (typeof onError === 'function') {
+            onError(e as Error);
+        }
+    }
+
+    return undefined;
+}

package/src/utils/Latch/Latch.ts

@@ -0,0 +1,63 @@
+import { callFunctions } from '../Function/callFunctions/callFunctions';
+import { isFunction } from '../Function/isFunction';
+import { noop } from '../Function/noop';
+import { once } from '../Function/once/once';
+
+export type LatchCallback<T> = (parameter: T) => void;
+
+/**
+ * Класс, инстанс которого хранит неизменяемое значение и может находиться в двух состояниях
+ * - значение не задано
+ * - значение задано
+ *
+ * Если значение не задано, подписаться на его установку можно с помощью метода subscribe,
+ * а установить значение вызвав метод dispatch
+ *
+ * В случае, если значение задано, при вызове метода subscribe callback отрабатывает сразу,
+ * а дальнейшие вызовы dispatch игнорируются
+ */
+export class Latch<T = undefined> {
+    public dispatch = once((value: T): void => {
+        this.value = value;
+        this._isDispatched = true;
+
+        callFunctions(this.callbacks, value);
+        this.callbacks.clear();
+    });
+
+    private readonly callbacks: Set<LatchCallback<T>> = new Set();
+    private _isDispatched = false;
+    private value?: T;
+
+    public constructor(callback?: LatchCallback<T>) {
+        if (isFunction(callback)) {
+            this.callbacks.add(callback);
+        }
+    }
+
+    public subscribe(callback: LatchCallback<T>): VoidFunction {
+        if (this._isDispatched) {
+            callback(this.value!);
+
+            return noop;
+        }
+
+        this.callbacks.add(callback);
+
+        return () => {
+            this.callbacks.delete(callback);
+        };
+    }
+
+    public unsubscribe(callback: LatchCallback<T>): void {
+        this.callbacks.delete(callback);
+    }
+
+    public isDispatched(): boolean {
+        return this._isDispatched;
+    }
+
+    public getValue(): T | undefined {
+        return this.value;
+    }
+}

package/src/utils/Map/ObservableMap/ObservableMap.ts

@@ -0,0 +1,55 @@
+import { callFunctions } from '../../Function/callFunctions/callFunctions';
+
+type ObservableMapEvent<K, V> =
+| {
+    type: 'set';
+    key: K;
+    value: V;
+}
+| {
+    type: 'delete';
+    key: K;
+};
+
+type ObservableMapCallback<K, V> = (event: ObservableMapEvent<K, V>) => void;
+
+export class ObservableMap<K, V> extends Map<K, V> {
+    private readonly _callbacks: Set<ObservableMapCallback<K, V>> = new Set();
+
+    public subscribe(callback: ObservableMapCallback<K, V>): VoidFunction {
+        this._callbacks.add(callback);
+
+        return () => {
+            this._callbacks.delete(callback);
+        };
+    }
+
+    public set (key: K, value: V): this {
+        const previousValue = this.get(key);
+
+        super.set(key, value);
+
+        if (value !== previousValue) {
+            callFunctions(this._callbacks ?? [], {
+                type: 'set',
+                key,
+                value,
+            });
+        }
+
+        return this;
+    }
+
+    public delete (key: K): boolean {
+        const result = super.delete(key);
+
+        if (result) {
+            callFunctions(this._callbacks ?? [], {
+                type: 'delete',
+                key,
+            });
+        }
+
+        return result;
+    }
+}

package/src/utils/Map/findMapsDifferences/findMapsDifferences.ts

@@ -0,0 +1,35 @@
+export function findMapsDifferences<K, V, V2>(originalMap: Map<K, V>, targetMap: Map<K, V2>): {
+    added: K[];
+    updated: K[];
+    deleted: K[];
+} {
+    const result = {
+        added: [] as K[],
+        updated: [] as K[],
+        deleted: [] as K[],
+    };
+
+    // Value added to the original map
+    targetMap.forEach((_, id) => {
+        if (!originalMap.has(id)) {
+            result.added.push(id);
+        }
+    });
+
+    originalMap.forEach((_, id) => {
+        if (targetMap.has(id)) {
+            const originalValue = originalMap.get(id);
+            const targetValue = targetMap.get(id);
+
+            // Value has been changed
+            if (originalValue !== targetValue) {
+                result.updated.push(id);
+            }
+        } else {
+            // Value is not represented in settings anymore
+            result.deleted.push(id);
+        }
+    });
+
+    return result;
+}

package/src/utils/Map/mapGetOrSet/mapGetOrSet.ts

@@ -0,0 +1,7 @@
+export const mapGetOrSet = <K, V>(map: Map<K, V>, key: K, value: V): V => {
+    if (!map.has(key)) {
+        map.set(key, value);
+    }
+
+    return map.get(key)!;
+};

package/src/utils/Map/mapMapToArray/mapMapToArray.ts

@@ -0,0 +1,6 @@
+export function mapMapToArray<K, V, R>(map: Map<K, V>, callback: (value: V, key: K) => R): R[] {
+    return Array.from(map.entries(), ([
+        key,
+        value,
+    ]) => callback(value, key));
+}

package/src/utils/Map/mapMapValues/mapMapValues.ts

@@ -0,0 +1,9 @@
+export function mapMapValues<K, V, R>(map: Map<K, V>, callback: (value: V, key: K) => R): Map<K, R> {
+    const result = new Map<K, R>();
+
+    map.forEach((value, key) => {
+        result.set(key, callback(value, key));
+    });
+
+    return result;
+}

package/src/utils/Math/createSimpleMovingAverageSeries/createSimpleMovingAverageSeries.ts

@@ -0,0 +1,22 @@
+import { PositiveInteger } from '../../../types/Number/PositiveInteger';
+import { mean } from '../mean/mean';
+
+export function createSimpleMovingAverageSeries({
+    series,
+    windowSize,
+}: {
+    series: number[];
+    windowSize: PositiveInteger;
+}): (number | undefined)[] {
+    const movingAverageData: (number | undefined)[] = [];
+
+    for (let i = 0; i < series.length; i++) {
+        if (i < windowSize - 1) {
+            movingAverageData.push(undefined);
+        } else {
+            movingAverageData.push(mean(series.slice(i - windowSize + 1, i + 1)));
+        }
+    }
+
+    return movingAverageData;
+}

package/src/utils/Math/mean/mean.ts

@@ -0,0 +1,14 @@
+import { IterableWithIndexAccess } from '../../../types/IterableWithIndexAccess';
+import { sum } from '../sum/sum';
+
+/**
+ * Stolen from here
+ * https://github.com/simple-statistics/simple-statistics/blob/ac07cbec74534a4b4c71a541292e9ae8c26f0930/src/mean.js#L17C1-L23C2
+ */
+export function mean(x: IterableWithIndexAccess<number>): number {
+    if (x.length === 0) {
+        throw new Error('mean requires at least one data point');
+    }
+
+    return sum(x) / x.length;
+}

package/src/utils/Math/simpleMovingAverageUsingAccFabric/simpleMovingAverageUsingAccFabric.ts

@@ -0,0 +1,29 @@
+import { PositiveInteger } from '../../../types/Number/PositiveInteger';
+import { CircularBuffer } from '../../CircularBuffer/CircularBuffer';
+
+/**
+ * Calculates using accumulator to avoid re-calculating the mean
+ * Can have small floating point errors
+ */
+export function simpleMovingAverageUsingAccFabric(windowSize: PositiveInteger): (value: number) => number | undefined {
+    const queue = new CircularBuffer<number>(windowSize);
+    let accumulator = 0;
+
+    return (newValue: number) => {
+        let diff = newValue;
+
+        if (queue.length === windowSize) {
+            diff -= queue.shift()!;
+        }
+
+        queue.push(newValue);
+
+        accumulator += diff / windowSize;
+
+        if (queue.length < windowSize) {
+            return undefined;
+        }
+
+        return accumulator;
+    };
+}

package/src/utils/Math/sum/sum.ts

@@ -0,0 +1,45 @@
+import { IterableWithIndexAccess } from '../../../types/IterableWithIndexAccess';
+
+/**
+ * Stolen from here
+ * https://github.com/simple-statistics/simple-statistics/blob/ac07cbec74534a4b4c71a541292e9ae8c26f0930/src/sum.js#L19C1-L56C2
+ */
+export function sum(x: IterableWithIndexAccess<number>): number {
+    // If the array is empty, we needn't bother computing its sum
+    if (x.length === 0) {
+        return 0;
+    }
+
+    // Initializing the sum as the first number in the array
+    let sumResult = x.at(0);
+
+    // Keeping track of the floating-point error correction
+    let correction: number = 0;
+
+    let transition: number;
+
+    if (typeof sumResult !== 'number') {
+        return Number.NaN;
+    }
+
+    for (let i = 1; i < x.length; i++) {
+        if (typeof x.at(i) !== 'number') {
+            return Number.NaN;
+        }
+
+        transition = sumResult + x.at(i)!;
+
+        // Here we need to update the correction in a different fashion
+        // if the new absolute value is greater than the absolute sum
+        if (Math.abs(sumResult) >= Math.abs(x.at(i)!)) {
+            correction += sumResult - transition + x.at(i)!;
+        } else {
+            correction += x.at(i)! - transition + sumResult;
+        }
+
+        sumResult = transition;
+    }
+
+    // Returning the corrected sum
+    return sumResult + correction;
+}

package/src/utils/MinHeap/MinHeap.ts

@@ -0,0 +1,88 @@
+export type MinHeapTuple<T> = [number, T];
+
+export class MinHeap<T> {
+    private _heap: MinHeapTuple<T>[];
+
+    public constructor() {
+        this._heap = [];
+    }
+    public push(value: MinHeapTuple<T>): void {
+        this._heap.push(value);
+        this._bubbleUp();
+    }
+    public getFirst(): MinHeapTuple<T> | undefined {
+        return this._heap[0];
+    }
+
+    public getSize(): number {
+        return this._heap.length;
+    }
+
+    public pop(): MinHeapTuple<T> | undefined {
+        if (this._heap.length <= 1) {
+            return this._heap.pop();
+        }
+
+        const top = this._heap[0];
+
+        this._heap[0] = this._heap.pop()!;
+        this._bubbleDown();
+
+        return top;
+    }
+
+    private _bubbleUp(): void {
+        let idx = this._heap.length - 1;
+
+        while (idx > 0) {
+            const parentIdx = Math.floor((idx - 1) / 2);
+            const current = this._heap[idx];
+            const parent = this._heap[parentIdx];
+
+            if (parent[0] <= current[0]) {
+                break;
+            }
+
+            this._heap[idx] = parent;
+            this._heap[parentIdx] = current;
+
+            idx = parentIdx;
+        }
+    }
+
+    private _bubbleDown(): void {
+        let idx = 0;
+
+        while (true) {
+            const leftIdx = 2 * idx + 1;
+            const rightIdx = 2 * idx + 2;
+
+            if (leftIdx >= this._heap.length) {
+                break;
+            }
+
+            let smallestIdx = leftIdx;
+            const hasRight = rightIdx < this._heap.length;
+
+            if (hasRight) {
+                const rightIsPrior = this._heap[rightIdx][0] < this._heap[leftIdx][0];
+
+                if (rightIsPrior) {
+                    smallestIdx = rightIdx;
+                }
+            }
+
+            const value = this._heap[idx];
+            const smallestValue = this._heap[smallestIdx];
+
+            if (value[0] <= smallestValue[0]) {
+                break;
+            }
+
+            this._heap[idx] = smallestValue;
+            this._heap[smallestIdx] = value;
+
+            idx = smallestIdx;
+        }
+    }
+}

package/src/utils/MinHeapUniqueNumber/MinHeapUniqueNumber.ts

@@ -0,0 +1,105 @@
+export class MinHeapUniqueNumber {
+    private readonly _heap: number[];
+    private readonly _set: Set<number> = new Set();
+
+    public constructor() {
+        this._heap = [];
+    }
+
+    public push(value: number): void {
+        if (this._set.has(value)) {
+            return;
+        }
+
+        this._set.add(value);
+
+        this._heap.push(value);
+        this._bubbleUp();
+    }
+
+    public getFirst(): number | undefined {
+        return this._heap[0];
+    }
+
+    public getSize(): number {
+        return this._heap.length;
+    }
+
+    public pop(): number | undefined {
+        if (this._heap.length === 0) {
+            return undefined;
+        }
+
+        if (this._heap.length <= 1) {
+            const value = this._heap.pop()!;
+
+            this._set.delete(value);
+
+            return value;
+        }
+
+        const top = this._heap[0];
+
+        this._heap[0] = this._heap.pop()!;
+        this._bubbleDown();
+
+        this._set.delete(top);
+
+        return top;
+    }
+
+    private _bubbleUp(): void {
+        let idx = this._heap.length - 1;
+
+        while (idx > 0) {
+            const parentIdx = Math.floor((idx - 1) / 2);
+            const current = this._heap[idx];
+            const parent = this._heap[parentIdx];
+
+            if (parent < current) {
+                break;
+            }
+
+            this._heap[idx] = parent;
+            this._heap[parentIdx] = current;
+
+            idx = parentIdx;
+        }
+    }
+
+    private _bubbleDown(): void {
+        let idx = 0;
+
+        while (true) {
+            const leftIdx = 2 * idx + 1;
+            const rightIdx = 2 * idx + 2;
+
+            if (leftIdx >= this._heap.length) {
+                break;
+            }
+
+            let smallestIdx = leftIdx;
+            const hasRight = rightIdx < this._heap.length;
+
+            if (hasRight) {
+                const rightIsPrior = this._heap[rightIdx] < this._heap[leftIdx];
+
+                if (rightIsPrior) {
+                    smallestIdx = rightIdx;
+                }
+            }
+
+            const value = this._heap[idx];
+            const smallestValue = this._heap[smallestIdx];
+
+            if (value < smallestValue) {
+                break;
+            }
+
+            this._heap[idx] = smallestValue;
+            this._heap[smallestIdx] = value;
+
+            idx = smallestIdx;
+        }
+    }
+}

package/src/utils/MinMaxHeap/MinMaxHeap.ts

@@ -0,0 +1,91 @@
+export type MinMaxHeapTuple<T> = [number, T];
+export type MinMaxHeapCompareFunction = (a: number, b: number) => number;
+
+export class MinMaxHeap<T> {
+    private _heap: MinMaxHeapTuple<T>[];
+    private _compare: MinMaxHeapCompareFunction;
+
+    public constructor(compare: MinMaxHeapCompareFunction) {
+        this._heap = [];
+        this._compare = compare;
+    }
+    public push(value: MinMaxHeapTuple<T>): void {
+        this._heap.push(value);
+        this._bubbleUp();
+    }
+    public getFirst(): MinMaxHeapTuple<T> | undefined {
+        return this._heap[0];
+    }
+
+    public getSize(): number {
+        return this._heap.length;
+    }
+
+    public pop(): MinMaxHeapTuple<T> | undefined {
+        if (this._heap.length <= 1) {
+            return this._heap.pop();
+        }
+
+        const top = this._heap[0];
+
+        this._heap[0] = this._heap.pop()!;
+        this._bubbleDown();
+
+        return top;
+    }
+
+    private _bubbleUp(): void {
+        let idx = this._heap.length - 1;
+
+        while (idx > 0) {
+            const parentIdx = Math.floor((idx - 1) / 2);
+            const current = this._heap[idx];
+            const parent = this._heap[parentIdx];
+
+            if (this._compare(parent[0], current[0]) < 0) {
+                break;
+            }
+
+            this._heap[idx] = parent;
+            this._heap[parentIdx] = current;
+
+            idx = parentIdx;
+        }
+    }
+
+    private _bubbleDown(): void {
+        let idx = 0;
+
+        while (true) {
+            const leftIdx = 2 * idx + 1;
+            const rightIdx = 2 * idx + 2;
+
+            if (leftIdx >= this._heap.length) {
+                break;
+            }
+
+            let smallestIdx = leftIdx;
+            const hasRight = rightIdx < this._heap.length;
+
+            if (hasRight) {
+                const rightIsPrior = this._compare(this._heap[rightIdx][0], this._heap[leftIdx][0]) < 0;
+
+                if (rightIsPrior) {
+                    smallestIdx = rightIdx;
+                }
+            }
+
+            const value = this._heap[idx];
+            const smallestValue = this._heap[smallestIdx];
+
+            if (this._compare(value[0], smallestValue[0]) < 0) {
+                break;
+            }
+
+            this._heap[idx] = smallestValue;
+            this._heap[smallestIdx] = value;
+
+            idx = smallestIdx;
+        }
+    }
+}