@zajno/common 2.0.2 → 2.0.4

package/src/structures/pool.ts

@@ -1,47 +0,0 @@
-import { safeCall } from '../functions/safeCall';
-import type { IDisposable } from '../functions/disposer';
-
-export class Pool<T> {
-
-    private readonly _container: T[] = [];
-
-    constructor(readonly factory: () => T) { }
-
-    public get(): T {
-        if (this._container.length > 0) {
-            return this._container.pop();
-        } else {
-            return this.factory();
-        }
-    }
-
-    public release(e: T | T[]): void {
-        if (Array.isArray(e)) {
-            this._container.push(...e);
-        } else if (e) {
-            this._container.push(e);
-        }
-    }
-}
-
-export class PoolDisposable<T extends IDisposable> extends Pool<T> {
-
-    constructor(factory: () => T, readonly initializer: (item: T) => void = null) {
-        super(factory);
-    }
-
-    public get(): T {
-        const res = super.get();
-        safeCall(this.initializer, res);
-        return res;
-    }
-
-    public release(e: T | T[]): void {
-        if (Array.isArray(e)) {
-            e.forEach(ee => ee.dispose());
-        } else if (e) {
-            e.dispose();
-        }
-        return super.release(e);
-    }
-}

package/src/structures/queue/__tests__/parallel.test.ts

@@ -1,58 +0,0 @@
-import 'jest-extended';
-import { ParallelQueue } from '../parallel';
-import { setTimeoutAsync } from '../../../async/timeout';
-import { setMode } from '../../../logger';
-
-const createLoader = () => jest.fn(() => setTimeoutAsync(100));
-
-setMode('console');
-
-describe('ParallelQueue', () => {
-    it('runs', async () => {
-
-        const q = new ParallelQueue()
-            .withLogger('test');
-
-        expect(q.inProgress).toBeFalsy();
-
-        const f1 = createLoader();
-        const f2 = createLoader();
-        q.enqueue(f1);
-        q.enqueue(f2);
-
-        expect(f1).not.toHaveBeenCalled();
-        expect(f2).not.toHaveBeenCalled();
-
-        const res = q.start();
-        expect(q.inProgress).toBeTruthy();
-
-        expect(q.currentPriority).toBe(0);
-
-        const f3 = createLoader();
-        const f4 = createLoader();
-
-        q.enqueue(f3);
-
-        q.enqueue(f4, 1);
-
-        await expect(q.start()).resolves.toBeUndefined();
-
-        await expect(res).resolves.toBe(true);
-
-        expect(q.inProgress).toBeFalsy();
-        expect(q.currentPriority).toBe(1);
-
-        expect(f1).toHaveBeenCalledBefore(f2);
-        expect(f2).toHaveBeenCalledAfter(f1);
-        expect(f3).toHaveBeenCalledAfter(f2);
-        expect(f4).toHaveBeenCalledAfter(f3);
-
-        const f5 = createLoader();
-
-        q.enqueue(f5);
-
-        await setTimeoutAsync(100);
-
-        expect(f5).toHaveBeenCalledAfter(f4);
-    });
-});

package/src/structures/queue/__tests__/tasks.test.ts

@@ -1,87 +0,0 @@
-import { TasksQueue } from '../tasks';
-import { setTimeoutAsync } from '../../../async/timeout';
-import { safeCall } from '../../../functions/safeCall';
-import 'jest-extended';
-
-describe('TasksQueue', () => {
-
-    const createFactory = <T>(res: T, cb?: () => void) => {
-        return async () => {
-            await setTimeoutAsync(50);
-            safeCall(cb);
-            return res;
-        };
-    };
-
-    it('correctly initializes', async () => {
-        const fnZero = async () => {
-            return new TasksQueue(0);
-        };
-        const fnNegative = async () => {
-            return new TasksQueue(-12);
-        };
-        const fnPositive = async () => {
-            return new TasksQueue(12);
-        };
-
-        await expect(fnZero()).rejects.toThrow();
-        await expect(fnNegative()).rejects.toThrow();
-        await expect(fnPositive()).resolves.not.toBeNull();
-
-        const failEnqueue = async () => {
-            const q = new TasksQueue<number>(123);
-            q.enqueue(null as any);
-        };
-
-        await expect(failEnqueue()).rejects.toThrow();
-    });
-
-    it('runs without limit', async () => {
-        const queue = new TasksQueue(5);
-
-        expect(queue.isFull).toBeFalsy();
-        expect(queue.running).toBe(0);
-
-        const val1 = 123;
-
-        const res1 = queue.enqueue(createFactory(val1));
-
-        expect(queue.isFull).toBeFalsy();
-        expect(queue.running).toBe(1);
-
-        await expect(res1).resolves.toBe(val1);
-    });
-
-    it('runs with limit 1', async () => {
-        const queue = new TasksQueue(1);
-
-        const val1 = 123;
-        const cb1 = jest.fn();
-        const res1 = queue.enqueue(createFactory(val1, cb1));
-
-        const val2 = 321;
-        const cb2 = jest.fn();
-        const res2 = queue.enqueue(createFactory(val2, cb2));
-
-        const val3 = 111;
-        const cb3 = jest.fn();
-        const res3 = queue.enqueue(createFactory(val3, cb3));
-
-        expect(queue.isFull).toBeTruthy();
-        expect(queue.running).toBe(1);
-
-        await expect(res1).resolves.toBe(val1);
-        expect(queue.running).toBe(1);
-
-        await expect(res2).resolves.toBe(val2);
-
-        expect(queue.running).toBe(1);
-        await expect(res3).resolves.toBe(val3);
-
-        expect(queue.running).toBe(0);
-
-        expect(cb1).toHaveBeenCalledBefore(cb2);
-        expect(cb2).toHaveBeenCalledBefore(cb3);
-        expect(cb3).toHaveBeenCalled();
-    });
-});

package/src/structures/queue/parallel.ts

@@ -1,142 +0,0 @@
-import { createLogger, ILogger } from '../../logger';
-import { Event } from '../../observing/event';
-
-export type QueueItem = () => void | Promise<void>;
-
-type Queue = QueueItem[];
-
-export class ParallelQueue {
-
-    private readonly _queues: Record<number, Queue> = { };
-
-    private _inProgress: boolean = null;
-    private _currentIndex = 0;
-    private _maxIndex = 0;
-
-    private _logger: ILogger = null;
-
-    private readonly _beforePriorityRun = new Event<number>();
-    private readonly _afterPriorityRun = new Event<number>();
-    private readonly _finished = new Event();
-
-    public get currentPriority() { return this._currentIndex; }
-    public get inProgress() { return this._inProgress; }
-
-    public get beforePriorityRun() { return this._beforePriorityRun.expose(); }
-    public get afterPriorityRun() { return this._afterPriorityRun.expose(); }
-
-    public get finished() { return this._finished.expose(); }
-
-    public withLogger(name?: string) {
-        this._logger = createLogger(`[Queue:${name || '?'}]`);
-        return this;
-    }
-
-    /** @returns A callback that will try to cancel queued item */
-    public enqueue(cb: QueueItem, priority?: number): () => void {
-        const p = Math.round(priority || 0);
-
-        // if it's started and the priority has been processing already
-        // or it has just finished
-        if (this._inProgress && p < this._currentIndex || this._inProgress === false) {
-            // just start the loader
-            this._executeLoader(cb, p, 1000);
-            return () => false;
-        }
-
-        // Enqueue for future execution
-        const q = this.getQueue(p);
-        q.push(cb);
-        this._maxIndex = Math.max(this._maxIndex, p);
-
-        // Return callback for removing the item from the queue
-        return () => {
-            // The processing has started and this queue has been passed already
-            if (this._inProgress != null && this._currentIndex >= p) {
-                return false;
-            }
-
-            // find and remove the item
-            const i = q.findIndex(qi => qi === cb);
-            if (i >= 0) {
-                q.splice(i, 1);
-                // return true if we're sure that the item hasn't been executed yet
-                return true;
-            }
-            return false;
-        };
-    }
-
-    public async start() {
-        if (this._inProgress) {
-            return undefined;
-        }
-
-        this._inProgress = true;
-        try {
-            await this.tryStartQueue();
-        } catch (err) {
-            this._logger?.warn('Failed to process queue:', err);
-            return false;
-        }
-
-        return true;
-    }
-
-    private getQueue(priority: number = 0) {
-        let q = this._queues[priority];
-        if (!q) {
-            q = [];
-            this._queues[priority] = q;
-        }
-
-        return q;
-    }
-
-    private async tryStartQueue() {
-        let current: QueueItem[] = null;
-        let iterations = 0;
-
-        await this._beforePriorityRun.triggerAsync(this._currentIndex);
-
-        while ((current = this._queues[this._currentIndex])?.length) {
-            if (iterations++ > 5) {
-                break;
-            }
-
-            this._logger?.log('Processing priority =', this._currentIndex, '; count =', current.length);
-
-            const items = current.slice();
-            current.length = 0;
-
-            await Promise.all(items.map((loader, index) => this._executeLoader(loader, this._currentIndex, index)));
-        }
-
-        if (!current?.length && iterations === 0) {
-            this._logger?.log('Skipping priority =', this._currentIndex, '; no items');
-        }
-
-        await this._afterPriorityRun.triggerAsync(this._currentIndex);
-
-        const next = this._currentIndex + 1;
-        if (next > this._maxIndex) {
-            // looks like we've finished!
-            this._inProgress = false;
-            this._logger?.log('Finished processing at index =', this._currentIndex);
-            this._finished.trigger();
-            return;
-        }
-
-        ++this._currentIndex;
-        await this.tryStartQueue();
-    }
-
-    private _executeLoader = async (l: QueueItem, priority: number, index?: number) => {
-        try {
-            await l();
-        } catch (err) {
-            this._logger?.warn('Failed to process queue item at priority =', priority, ' at index =', index || '?');
-            this._logger?.error(err);
-        }
-    };
-}

package/src/structures/queue/tasks.ts

@@ -1,91 +0,0 @@
-import type { ILogger } from '../../logger';
-
-type Factory<T> = () => Promise<T>;
-
-type QueueItem<T> = {
-    factory: Factory<T>;
-    finish?: (res: Promise<T>) => Promise<T>;
-    name?: string;
-};
-
-export class TasksQueue<T> {
-
-    private readonly _items: QueueItem<T>[] = [];
-    private _running = 0;
-    private _logger: ILogger | null = null;
-
-    constructor(readonly limit: number) {
-        if (!limit || limit < 0) {
-            throw new Error('TasksQueue: limit should be a positive number');
-        }
-    }
-
-    public get isFull() { return this._running >= this.limit; }
-    public get running() { return this._running; }
-
-    addLogger(logger: ILogger) {
-        this._logger = logger;
-        return this;
-    }
-
-    public enqueue(factory: Factory<T>, name?: string): Promise<T> {
-        if (typeof factory !== 'function') {
-            throw new Error('Invalid arg: factory not a function');
-        }
-
-        if (this.isFull) {
-
-            const item: QueueItem<T> = {
-                factory,
-                finish: undefined,
-                name,
-            };
-
-            const waitPromise = new Promise<T>((resolve, reject) => {
-                item.finish = async (res) => {
-                    try {
-                        const rr = await res;
-                        resolve(rr);
-                        return rr;
-                    } catch (err) {
-                        reject(err);
-                        throw err;
-                    }
-                };
-            });
-
-            this._items.push(item);
-            return waitPromise;
-        }
-
-        return this._runFactory(factory);
-    }
-
-    private _runFactory = async (factory: Factory<T>, name?: string): Promise<T> => {
-        this._running++;
-        try {
-            const result = await factory();
-            return result;
-        } catch (err) {
-            this._logger?.warn(`Factory "${name || factory.name || '<unknown>'}" thrown. Rethrowing...`);
-            throw err;
-        } finally {
-            this._running--;
-            this._tryRunNext();
-        }
-    };
-
-    private _tryRunNext = async () => {
-        if (!this._items.length || this.isFull) {
-            return;
-        }
-
-        const next = this._items.shift();
-        if (!next || !next.finish || !next.factory) {
-            return;
-        }
-
-        await next.finish(this._runFactory(next.factory));
-    };
-
-}

package/src/structures/tempoCache.ts

@@ -1,18 +0,0 @@
-
-export class TempoCache<T> {
-
-    private _expiringAt: number = 0; // already expired
-    private _current: T = undefined;
-
-    constructor(readonly factory: () => T, readonly lifetimeMs: number) { }
-
-    public get isExpired() { return Date.now() >= this._expiringAt; }
-
-    public get current() {
-        if (this.isExpired) {
-            this._current = this.factory();
-            this._expiringAt = Date.now() + this.lifetimeMs;
-        }
-        return this._current;
-    }
-}

package/src/types/comparator.ts

@@ -1,6 +0,0 @@
-
-export type Comparator<T, C = boolean> = (v1: T, v2: T) => C;
-
-export namespace Comparator {
-    export const Default: Comparator<any> = (a, b) => a === b;
-}

package/src/types/deep.ts

@@ -1,18 +0,0 @@
-
-type Primitive = number | string | Symbol | boolean | null | undefined | bigint;
-
-export type DeepReadonly<T> = T extends (Function | Primitive)
-    ? T
-    : (
-        T extends Object
-            ? { readonly [P in keyof T]: DeepReadonly<T[P]>; }
-            : T
-    );
-
-export type DeepPartial<T> = T extends (Function | Primitive)
-    ? T
-    : (
-        T extends Object
-            ? { [P in keyof T]?: DeepPartial<T[P]>; }
-            : T
-    );

package/src/types/functions.ts

@@ -1,8 +0,0 @@
-
-export type PropertiesOf<T> = Exclude<{
-    [K in keyof T]: T[K] extends Function ? never : K
-}[keyof T], undefined>;
-
-export type RemoveFunctionFields<T> = {
-    readonly [P in PropertiesOf<T>]: T[P];
-};

package/src/types/getter.ts

@@ -1,14 +0,0 @@
-
-export type Getter<T> = (() => T) | T | null;
-
-export namespace Getter {
-    export function getValue<T>(getter: Getter<T>): T {
-        if (getter == null) {
-            return undefined;
-        }
-        if (typeof getter === 'function') {
-            return (getter as () => T)();
-        }
-        return getter;
-    }
-}

package/src/types/ident.ts

@@ -1,8 +0,0 @@
-
-export type Ident<T, K extends keyof any = string> = T & {
-    id: K;
-};
-
-export type IdentAny = Ident<{}>;
-
-export default Ident;

package/src/types/index.ts

@@ -1,17 +0,0 @@
-export * from './deep';
-export * from './getter';
-export * from './comparator';
-
-export type Predicate<T> = (value: T) => boolean;
-
-export type TypedKeys<T extends Object, K> = {
-    [P in keyof T]: T[P] extends K ? P : never
-}[keyof T];
-
-export type ArrayTail<T> = T extends [any, ...infer P] ? [...P] : T;
-
-export type NestedPick<T, K extends any[]> = K extends Array<never> // empty arr
-    ? T
-    : {
-        [P in K[0]]: P extends keyof T ? NestedPick<T[P], ArrayTail<K>> : never;
-    };

package/src/validation/ValidationErrors.ts

@@ -1,26 +0,0 @@
-import EnumHelper from '../structures/helpers/enum';
-
-export enum ValidationErrors {
-    None = 0,
-    ShouldBeNonEmpty,
-    ShouldBeEqualTo,
-    InvalidNameFormat,
-    InvalidEmailFormat,
-    InvalidPasswordFormat,
-    OnlyEnglishLetters,
-    InvalidPhoneFormat,
-    InvalidCreditCardFormat,
-    InvalidCreditCardExpiryDateFormat,
-    InvalidCreditCardCvvFormat,
-    OnlyDigit,
-
-    EmailIsInUse,
-    FirstName,
-    LastName,
-    Website,
-    Linkedin,
-}
-
-export namespace ValidationErrors {
-    export const Helper = new EnumHelper<ValidationErrors>(ValidationErrors);
-}

package/src/validation/__tests__/index.test.ts

@@ -1,8 +0,0 @@
-import * as validation from '..';
-import { ValidationErrors } from '../ValidationErrors';
-
-describe('validation (TODO)', () => {
-    it('Validators', () => {
-        expect(validation.Validators.notEmpty('')).toEqual(ValidationErrors.ShouldBeNonEmpty);
-    });
-});

package/src/validation/__tests__/validator.test.ts

@@ -1,107 +0,0 @@
-import * as validation from '..';
-import { ValidationErrors } from '../ValidationErrors';
-import { faker } from '@faker-js/faker';
-import fc from 'fast-check';
-import { toArbitrary } from '../../__tests__/helpers/main';
-
-describe('validation websites', () => {
-    it('test', () => {
-        const _url: fc.Arbitrary<string> = toArbitrary(() => faker.internet.url());
-
-        fc.assert(
-            fc.property(_url, (url) => {
-                expect(validation.Validators.website(url)).toEqual(ValidationErrors.None);
-            }),
-        );
-    });
-
-    it('test domain name', () => {
-        const _url: fc.Arbitrary<string> = toArbitrary(() => faker.internet.domainName());
-
-        fc.assert(
-            fc.property(_url, (url) => {
-                expect(validation.Validators.website(url)).toEqual(ValidationErrors.None);
-            }),
-        );
-    });
-
-    it('test hard domain name', () => {
-        const _url: fc.Arbitrary<string> = toArbitrary(() => `${ faker.internet.domainWord() }.${ faker.internet.domainName() }`);
-
-        fc.assert(
-            fc.property(_url, (url) => {
-                expect(validation.Validators.website(url)).toEqual(ValidationErrors.None);
-            }),
-        );
-    });
-
-    it('test domainWord', () => {
-        const _url: fc.Arbitrary<string> = toArbitrary(() => faker.internet.domainWord());
-
-        fc.assert(
-            fc.property(_url, (url) => {
-                expect(validation.Validators.website(url)).toEqual(ValidationErrors.Website);
-            }),
-        );
-    });
-
-    it('test domainWord with dot', () => {
-        const _url: fc.Arbitrary<string> = toArbitrary(() => `${ faker.internet.domainWord() }.`);
-
-        fc.assert(
-            fc.property(_url, (url) => {
-                expect(validation.Validators.website(url)).toEqual(ValidationErrors.Website);
-            }),
-        );
-    });
-
-    it('test email', () => {
-        const _url: fc.Arbitrary<string> = toArbitrary(() => faker.internet.email());
-
-        fc.assert(
-            fc.property(_url, (url) => {
-                expect(validation.Validators.website(url)).toEqual(ValidationErrors.Website);
-            }),
-        );
-    });
-
-    it('test ip', () => {
-        const _url: fc.Arbitrary<string> = toArbitrary(() => faker.internet.ip());
-
-        fc.assert(
-            fc.property(_url, (url) => {
-                expect(validation.Validators.website(url)).toEqual(ValidationErrors.Website);
-            }),
-        );
-    });
-
-    it('test website with directory path', () => {
-        const _url: fc.Arbitrary<string> = toArbitrary(() => faker.image.imageUrl());
-
-        fc.assert(
-            fc.property(_url, (url) => {
-                expect(validation.Validators.website(url)).toEqual(ValidationErrors.None);
-            }),
-        );
-    });
-
-    it('long valid website with two dots', () => {
-        expect(validation.Validators.website('ivanivanivanivanivanivanivanivan.zajno.comcomcomcomcomcomcom')).toEqual(ValidationErrors.None);
-    });
-
-    it('valid website with directory path', () => {
-        expect(validation.Validators.website('http://www.regexbuddy.com/index.html?source=library')).toEqual(ValidationErrors.None);
-    });
-
-    it('valid website with many dashes', () => {
-        expect(validation.Validators.website('https://www.test-test-test-test.com')).toEqual(ValidationErrors.None);
-    });
-
-    it('valid website with short domain', () => {
-        expect(validation.Validators.website('https://t.me')).toEqual(ValidationErrors.None);
-    });
-
-    it('test url with few dashes in a row', () => {
-        expect(validation.Validators.website('https://dashedurl-------.com')).toEqual(ValidationErrors.Website);
-    });
-});

package/src/validation/creditCard.ts

@@ -1,25 +0,0 @@
-const regexp = /^\D*3[47]/;
-
-const types: { [digit: number]: string } = {
-    0: 'credit-card-alt',
-    3: 'cc-amex',
-    4: 'cc-visa',
-    5: 'cc-mastercard',
-    6: 'cc-discover',
-};
-
-function getDigitsCount(val: string): number {
-    return regexp.test(val) ? 15 : 16; // 15 digits if Amex
-}
-
-function getType(cardNumber: string) {
-    const val = cardNumber + '';
-    const firstDigit = +(val && val[0]) || 0;
-    return types[firstDigit] || types[0];
-}
-
-export default {
-    DEFAULT: types[0],
-    getDigitsCount,
-    getType,
-};