senaev-utils 1.0.0

package/src/utils/random/fnv1a/fnv1a.ts

@@ -0,0 +1,87 @@
+/**
+ * FNV-1a hash generation init value.
+ * More info: https://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function#FNV_hash_parameters
+ *
+ * Stolen from https://github.com/sindresorhus/fnv1a/blob/main/index.js
+ */
+// FNV_PRIMES and FNV_OFFSETS from
+// http://www.isthe.com/chongo/tech/comp/fnv/index.html#FNV-param
+
+const FNV_PRIMES: Record<number, bigint> = {
+    32: 16_777_619n,
+    64: 1_099_511_628_211n,
+    128: 309_485_009_821_345_068_724_781_371n,
+    256: 374_144_419_156_711_147_060_143_317_175_368_453_031_918_731_002_211n,
+    512: 35_835_915_874_844_867_368_919_076_489_095_108_449_946_327_955_754_392_558_399_825_615_420_669_938_882_575_126_094_039_892_345_713_852_759n,
+    1024: 5_016_456_510_113_118_655_434_598_811_035_278_955_030_765_345_404_790_744_303_017_523_831_112_055_108_147_451_509_157_692_220_295_382_716_162_651_878_526_895_249_385_292_291_816_524_375_083_746_691_371_804_094_271_873_160_484_737_966_720_260_389_217_684_476_157_468_082_573n,
+};
+
+const FNV_OFFSETS: Record<number, bigint> = {
+    32: 2_166_136_261n,
+    64: 14_695_981_039_346_656_037n,
+    128: 144_066_263_297_769_815_596_495_629_667_062_367_629n,
+    256: 100_029_257_958_052_580_907_070_968_620_625_704_837_092_796_014_241_193_945_225_284_501_741_471_925_557n,
+    512: 9_659_303_129_496_669_498_009_435_400_716_310_466_090_418_745_672_637_896_108_374_329_434_462_657_994_582_932_197_716_438_449_813_051_892_206_539_805_784_495_328_239_340_083_876_191_928_701_583_869_517_785n,
+    1024: 14_197_795_064_947_621_068_722_070_641_403_218_320_880_622_795_441_933_960_878_474_914_617_582_723_252_296_732_303_717_722_150_864_096_521_202_355_549_365_628_174_669_108_571_814_760_471_015_076_148_029_755_969_804_077_320_157_692_458_563_003_215_304_957_150_157_403_644_460_363_550_505_412_711_285_966_361_610_267_868_082_893_823_963_790_439_336_411_086_884_584_107_735_010_676_915n,
+};
+
+const cachedEncoder = new globalThis.TextEncoder();
+
+function fnv1aUint8Array(uint8Array: Uint8Array, size: number) {
+    const fnvPrime = FNV_PRIMES[size];
+    let hash = FNV_OFFSETS[size];
+
+    for (let index = 0; index < uint8Array.length; index++) {
+        hash ^= BigInt(uint8Array[index]);
+        hash = BigInt.asUintN(size, hash * fnvPrime);
+    }
+
+    return hash;
+}
+
+function fnv1aEncodeInto(string: string, size: number, utf8Buffer: Uint8Array) {
+    if (utf8Buffer.length === 0) {
+        throw new Error('The `utf8Buffer` option must have a length greater than zero');
+    }
+
+    const fnvPrime = FNV_PRIMES[size];
+    let hash = FNV_OFFSETS[size];
+    let remaining = string;
+
+    while (remaining.length > 0) {
+        const result = cachedEncoder.encodeInto(remaining, utf8Buffer);
+
+        remaining = remaining.slice(result.read);
+        for (let index = 0; index < result.written; index++) {
+            hash ^= BigInt(utf8Buffer[index]);
+            hash = BigInt.asUintN(size, hash * fnvPrime);
+        }
+    }
+
+    return hash;
+}
+
+export function fnv1a(
+    value: string | Uint8Array,
+    {
+        size = 32,
+        utf8Buffer,
+    }: {
+        size?: number;
+        utf8Buffer?: Uint8Array;
+    } = {}
+) {
+    if (!FNV_PRIMES[size]) {
+        throw new Error('The `size` option must be one of 32, 64, 128, 256, 512, or 1024');
+    }
+
+    if (typeof value === 'string') {
+        if (utf8Buffer) {
+            return fnv1aEncodeInto(value, size, utf8Buffer);
+        }
+
+        value = cachedEncoder.encode(value);
+    }
+
+    return fnv1aUint8Array(value, size);
+}

package/src/utils/random/generateHashedFloats/generateHashedFloats.ts

@@ -0,0 +1,28 @@
+import crypto from 'node:crypto';
+
+/**
+ * Get independent values from hash sized for experiments
+ */
+export function generateHashedFloats(seed: string, count: number): number[] {
+    // 6 bytes is the maximum for buffer.readUIntBE method
+    const BYTES_PER_INT = 6;
+    const MAX_INT = 2 ** (BYTES_PER_INT * 8) - 1;
+
+    // Get exact number of bytes needed
+    const buffer = crypto
+        .createHash('shake256', { outputLength: count * BYTES_PER_INT })
+        .update(seed)
+        .digest();
+
+    const floats: number[] = [];
+
+    for (let i = 0; i < count; i++) {
+        const offset = i * BYTES_PER_INT;
+        const intValue = buffer.readUIntBE(offset, BYTES_PER_INT);
+        const float = intValue / MAX_INT;
+
+        floats.push(float);
+    }
+
+    return floats;
+}

package/src/utils/random/getRandomIntegerInARange/getRandomIntegerInARange.ts

@@ -0,0 +1,3 @@
+export function getRandomIntegerInARange(min: number, max: number) {
+    return min + (((max - min + 1) * Math.random()) ^ 0);
+}

package/src/utils/random/getSampleIndexByStringHash/getSampleIndexByStringHash.ts

@@ -0,0 +1,10 @@
+import { PositiveInteger } from '../../../types/Number/PositiveInteger';
+import { UnsignedInteger } from '../../../types/Number/UnsignedInteger';
+import { fnv1a } from '../fnv1a/fnv1a';
+
+export function getSampleIndexByStringHash(str: string, samplesCount: PositiveInteger): UnsignedInteger {
+    const bigint = fnv1a(str);
+    const int = Number(bigint);
+
+    return int % samplesCount;
+}

package/src/utils/random/randomBoolean/randomBoolean.ts

@@ -0,0 +1,3 @@
+export function randomBoolean(): boolean {
+    return Math.random() < 0.5;
+}

package/src/utils/random/randomHexString/randomHexString.ts

@@ -0,0 +1,12 @@
+import { UnsignedInteger } from '../../../types/Number/UnsignedInteger';
+import { HexString } from '../../String/HexString/HexString';
+
+export function randomHexString(length: UnsignedInteger): HexString {
+    let x: HexString = '';
+
+    for (let key = 0; key < length; key++) {
+        x += ((Math.random() * 16) | 0).toString(16);
+    }
+
+    return x;
+}

package/src/utils/requestAnimationFrame/requestAnimationFramePromise/requestAnimationFramePromise.ts

@@ -0,0 +1,7 @@
+export function requestAnimationFramePromise() {
+    return new Promise<void>((resolve) => {
+        requestAnimationFrame(() => {
+            resolve();
+        });
+    });
+}

package/src/utils/requestAnimationFrame/requestAnimationFrameThrottle/requestAnimationFrameThrottle.ts

@@ -0,0 +1,6 @@
+import { throttleWithPromiseFunction } from '../../Function/throttleWithPromiseFunction/throttleWithPromiseFunction';
+import { requestAnimationFramePromise } from '../requestAnimationFramePromise/requestAnimationFramePromise';
+
+export function requestAnimationFrameThrottle(callback: VoidFunction) {
+    return throttleWithPromiseFunction(callback, requestAnimationFramePromise);
+}

package/src/utils/retryFunctionWrapper/retryFunctionWrapper.ts

@@ -0,0 +1,40 @@
+import { promiseTimeout } from '../timers/promiseTimeout/promiseTimeout';
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function retryFunctionWrapper<T extends (...args: any[]) => Promise<any>>({
+    fn,
+    attempts,
+    delay,
+    onFailAttempt,
+}: {
+    fn: T;
+    attempts: number;
+    delay: number;
+    onFailAttempt?: (error: unknown, attemptIndex: number) => void;
+}): T {
+    return ((...args: Parameters<T>): Promise<ReturnType<T>> => new Promise<ReturnType<T>>((resolve, reject) => {
+        let attemptIndex = 0;
+
+        const makeAttempt = async () => {
+            try {
+                const fnReturnValue = fn(...args);
+
+                const result = await fnReturnValue as ReturnType<T>;
+
+                resolve(result);
+            } catch (error) {
+                onFailAttempt?.(error, attemptIndex);
+                attemptIndex++;
+
+                if (attemptIndex < attempts) {
+                    promiseTimeout(delay).then(makeAttempt);
+                } else {
+                    // eslint-disable-next-line prefer-promise-reject-errors
+                    reject(error as Error);
+                }
+            }
+        };
+
+        makeAttempt();
+    })) as T;
+}

package/src/utils/runParallelTimescalesProcessing/runParallelTimescalesProcessing.ts

@@ -0,0 +1,113 @@
+import { assertPositiveInteger, PositiveInteger } from '../../types/Number/PositiveInteger';
+import { UnsignedInteger } from '../../types/Number/UnsignedInteger';
+import { RemoteDataProcessingWindowExtractItemsFunction } from '../createRemoteDataProcessingWindow/createRemoteDataProcessingWindow';
+import { MinHeapUniqueNumber } from '../MinHeapUniqueNumber/MinHeapUniqueNumber';
+
+type ObjectWithTime = {
+    time: number;
+};
+
+type ExtractItemsFunctions<T extends ObjectWithTime[]> = {
+    [K in keyof T]: RemoteDataProcessingWindowExtractItemsFunction<T[K]>;
+};
+
+type ObjectsWithTimePortion<T extends ObjectWithTime[]> = {
+    [K in keyof T]: T[K] | undefined;
+};
+
+type TimescaleBufferInfo<T extends ObjectWithTime> = {
+    array: T[];
+    index: UnsignedInteger;
+    isLast: boolean;
+};
+
+type TimescalesBuffersInfo<T extends ObjectWithTime[]> = {
+    [K in keyof T]: TimescaleBufferInfo<T[K]>;
+};
+
+export async function runParallelTimescalesProcessing<T extends ObjectWithTime[]>({
+    extractItemsFunctions,
+    callback,
+    bufferSize,
+}: {
+    extractItemsFunctions: ExtractItemsFunctions<T>;
+    callback: (pointsInfo: ObjectsWithTimePortion<T>, time: ObjectWithTime['time']) => unknown;
+    bufferSize: PositiveInteger;
+}): Promise<void> {
+    assertPositiveInteger(bufferSize, 'runParallelTimescalesProcessing bufferSize should be a positive integer');
+
+    const timescalesCount = extractItemsFunctions.length;
+
+    assertPositiveInteger(timescalesCount, 'runParallelTimescalesProcessing extractItemsFunctions should array should NOT be empty');
+
+    const notFinishedBuffers: Set<UnsignedInteger> = new Set();
+    const buffersToLoadData: UnsignedInteger[] = [];
+    const buffers = extractItemsFunctions.map(<O extends ObjectWithTime>(_: RemoteDataProcessingWindowExtractItemsFunction<O>, i: UnsignedInteger) => {
+        notFinishedBuffers.add(i);
+        buffersToLoadData.push(i);
+
+        const bufferInfo: TimescaleBufferInfo<O> = {
+            array: [],
+            index: 0,
+            isLast: false,
+        };
+
+        return bufferInfo;
+    }) as TimescalesBuffersInfo<T>;
+
+    const minHeapUniqueNumber = new MinHeapUniqueNumber();
+
+    while (true) {
+        if (buffersToLoadData.length > 0) {
+            await Promise.all(buffersToLoadData.map(async (index) => {
+                const { items, isLast } = await extractItemsFunctions[index](bufferSize);
+
+                if (isLast) {
+                    buffers[index].isLast = true;
+                }
+
+                buffers[index].array = items;
+                buffers[index].index = 0;
+
+                if (items[0]) {
+                    minHeapUniqueNumber.push(items[0].time);
+                }
+            }));
+
+            buffersToLoadData.length = 0;
+        }
+
+        const minTime = minHeapUniqueNumber.pop();
+
+        const portion = new Array(timescalesCount) as ObjectsWithTimePortion<T>;
+
+        for (const i of notFinishedBuffers.values()) {
+            const buffer = buffers[i];
+
+            const item = buffer.array.at(buffer.index);
+
+            if (item) {
+                if (item.time === minTime) {
+                    portion[i] = item;
+                    buffer.index++;
+
+                    const nextItem = buffer.array.at(buffer.index);
+
+                    if (nextItem) {
+                        minHeapUniqueNumber.push(nextItem.time);
+                    } else if (!buffer.isLast) {
+                        buffersToLoadData.push(i);
+                    }
+                }
+            } else if (buffer.isLast) {
+                notFinishedBuffers.delete(i);
+            }
+        }
+
+        if (notFinishedBuffers.size === 0) {
+            return;
+        }
+
+        callback(portion, minTime!);
+    }
+}

package/src/utils/stringifyError.ts

@@ -0,0 +1,3 @@
+export function stringifyError(error: Error): string {
+    return `error.message=[${error.message}] error.stack=[${error.stack}]`;
+}

package/src/utils/timers/promiseTimeout/promiseTimeout.ts

@@ -0,0 +1,26 @@
+import { Milliseconds } from '../../../types/Time/Milliseconds';
+import { AbortableProcess } from '../../AbortableProcess';
+
+export function promiseTimeout(timeoutMs: Milliseconds, {
+    abortable,
+}: {
+    abortable?: AbortableProcess;
+} = {}): Promise<void> {
+    return new Promise((resolve) => {
+        const timeoutId = setTimeout(() => {
+            if (abortable) {
+                abortable.unsubscribe(clearTimeoutId);
+            }
+
+            resolve();
+        }, timeoutMs);
+
+        const clearTimeoutId = () => {
+            clearTimeout(timeoutId);
+        };
+
+        if (abortable) {
+            abortable.subscribeAbort(clearTimeoutId);
+        }
+    });
+}

package/src/utils/timers/subscribeSyntheticInterval/subscribeSyntheticInterval.ts

@@ -0,0 +1,47 @@
+import { UnsignedInteger } from '../../../types/Number/UnsignedInteger';
+import { Milliseconds } from '../../../types/Time/Milliseconds';
+import { callFunctions } from '../../Function/callFunctions/callFunctions';
+
+type IntervalSubscription = {
+    intervalId: UnsignedInteger;
+    subscribers: Set<VoidFunction>;
+};
+
+const subscribersMap: Map<Milliseconds, IntervalSubscription> = new Map();
+
+const TIMEUPDATE_INTERVAL: Milliseconds = 1000;
+
+/**
+ * Функция нужна для того, чтобы не дублировать интервалы, предназначенные для обновления состояния видео-рекламы
+ *
+ * Функция принимает коллбек, который будет вызываться по интервалу, возвращает метод для отписки
+ *
+ * Интервал запускается при первом вызове и останавливается после того, как у него не остаётся подписчиков.
+ */
+export function subscribeSyntheticInterval(intervalMs: Milliseconds, subscriber: () => void): () => void {
+    if (!subscribersMap.has(intervalMs)) {
+        subscribersMap.set(intervalMs, {
+            intervalId: 0,
+            subscribers: new Set(),
+        });
+    }
+
+    const subscription: IntervalSubscription = subscribersMap.get(intervalMs)!;
+
+    if (subscription.subscribers.size === 0) {
+        subscription.intervalId = window.setInterval(() => {
+            callFunctions(subscription.subscribers);
+        }, TIMEUPDATE_INTERVAL);
+    }
+
+    subscription.subscribers.add(subscriber);
+
+    return () => {
+        subscription.subscribers.delete(subscriber);
+
+        if (subscription.subscribers.size === 0) {
+            window.clearInterval(subscription.intervalId);
+            subscribersMap.delete(intervalMs);
+        }
+    };
+}

package/src/utils/waitForFunction/waitForFunction.ts

@@ -0,0 +1,50 @@
+import { tryCatch } from '../Function/tryCatch/tryCatch';
+
+export function waitForFunction(
+    condition: () => boolean,
+    {
+        timeout = 250,
+        interval = 10,
+        message = `waitForFunction timeout=[${timeout}]ms`,
+    }: Partial<
+        Readonly<{
+            timeout: number;
+            interval: number;
+            message: string;
+        }>
+    > = {}
+): Promise<void> {
+    return new Promise((resolve, reject) => {
+        // eslint-disable-next-line prefer-const
+        let intervalId: ReturnType<typeof setInterval>;
+        // eslint-disable-next-line prefer-const
+        let timeoutId: ReturnType<typeof setTimeout>;
+
+        const clear = () => {
+            clearInterval(intervalId);
+            clearTimeout(timeoutId);
+        };
+
+        const rejectWithClear = (error: Error) => {
+            clear();
+            reject(error);
+        };
+
+        const check = () => {
+            if (tryCatch(condition, rejectWithClear) === true) {
+                resolve(undefined);
+                clear();
+            }
+        };
+
+        intervalId = setInterval(() => {
+            check();
+        }, interval);
+
+        timeoutId = setTimeout(() => {
+            rejectWithClear(new Error(message));
+        }, timeout);
+
+        check();
+    });
+}