@zajno/common 2.0.3 → 2.0.4

package/global-test-setup.js

@@ -1,3 +0,0 @@
-module.exports = async () => {
-    process.env.TZ = 'UTC';
-};

package/jest.config.js

@@ -1,10 +0,0 @@
-module.exports = {
-    preset: 'ts-jest',
-    testEnvironment: 'node',
-    testMatch: [
-        '**/__tests__/**/(*.)+(spec|test).+(ts|tsx)',
-    ],
-    collectCoverage: true,
-    globalSetup: './global-test-setup.js',
-    setupFilesAfterEnv: ["jest-extended/all"]
-};

package/src/__tests__/helpers/expect.ts

@@ -1,3 +0,0 @@
-import 'jest-extended';
-
-export const expectAnythingOrNothing = expect.toBeOneOf([expect.anything(), undefined, null]);

package/src/__tests__/helpers/main.ts

@@ -1,12 +0,0 @@
-import fc from 'fast-check';
-import { faker } from '@faker-js/faker';
-
-export const toArbitrary = (fakerGen) => {
-    return fc.integer()
-        .noBias()
-        .noShrink()
-        .map(seed => {
-            faker.seed(seed);
-            return fakerGen();
-        });
-};

package/src/abstractions/controllers/IPluggableController.ts

@@ -1,7 +0,0 @@
-
-export interface IPluggableController {
-
-    readonly enabled: boolean;
-
-    setEnabledAsync(enabled: boolean): Promise<void>;
-}

package/src/async/__tests__/timeout.test.ts

@@ -1,74 +0,0 @@
-
-import { timeoutPromise } from '../timeout';
-import { Event, oneTimeSubscription } from '../../observing/event';
-
-describe('Timeouts', () => {
-
-    describe('one-time subscription to event', () => {
-        const createOneTimePromise = (finishOnStep = 3, totalSteps = 5) => {
-            const e = new Event<number>();
-            let currentValue = 0;
-
-            const p = oneTimeSubscription(e, v => v === finishOnStep);
-
-            const intervalRef = setInterval(() => {
-                e.trigger(++currentValue);
-                if (currentValue === totalSteps) {
-                    clearInterval(intervalRef);
-                }
-            }, 100);
-
-            return p;
-        };
-
-        it('just works as expected', async () => {
-
-            const p = createOneTimePromise();
-
-            await expect(p).resolves.toBe(3);
-        });
-
-        it('works with timing out', async () => {
-            const p = createOneTimePromise();
-
-            const timeoutResult = timeoutPromise(p, 200);
-
-            await expect(timeoutResult).resolves.not.toBeNull();
-
-            const res = await timeoutResult;
-
-            expect(res.resolved).toBeUndefined();
-            expect(res.timedOut).toBe(true);
-            expect(res.elapsed).toBeLessThanOrEqual(210);
-        });
-
-        it('works without timing out', async () => {
-            const p = createOneTimePromise();
-
-            const timeoutResult = timeoutPromise(p, 400);
-
-            await expect(timeoutResult).resolves.not.toBeNull();
-
-            const res = await timeoutResult;
-
-            expect(res.resolved).toBe(3);
-            expect(res.timedOut).toBe(false);
-            expect(res.elapsed).toBeLessThanOrEqual(410);
-        });
-
-        it('works without timing out with minimal run', async () => {
-            const p = createOneTimePromise();
-
-            const timeoutResult = timeoutPromise(p, 400, 350);
-
-            await expect(timeoutResult).resolves.not.toBeNull();
-
-            const res = await timeoutResult;
-
-            expect(res.resolved).toBe(3);
-            expect(res.timedOut).toBe(false);
-            expect(res.elapsed).toBeGreaterThanOrEqual(349);
-            expect(res.elapsed).toBeLessThanOrEqual(410);
-        });
-    });
-});

package/src/async/arrays.extend.ts

@@ -1,17 +0,0 @@
-import { someAsync, everyAsync, forEachAsync, mapAsync } from './arrays';
-
-declare global {
-    interface Array<T> {
-        someAsync(this: T[], cond: (v: T, index?: number, arr?: T[]) => Promise<boolean>): Promise<boolean>;
-        everyAsync(this: T[], cond: (v: T, index?: number, arr?: T[]) => Promise<boolean>): Promise<boolean>;
-
-        forEachAsync(this: T[], cb: (v: T, index?: number, arr?: T[]) => Promise<void>): Promise<void>;
-        mapAsync<R>(this: T[], cb: (v: T, index?: number, arr?: T[]) => Promise<R>): Promise<R[]>;
-    }
-}
-
-
-Array.prototype.someAsync = function(this, ...args) { return someAsync(this, ...args); };
-Array.prototype.everyAsync = function(this, ...args) { return everyAsync(this, ...args); };
-Array.prototype.forEachAsync = function(this, ...args) { return forEachAsync(this, ...args); };
-Array.prototype.mapAsync = function(this, ...args) { return mapAsync(this, ...args); };

package/src/async/arrays.ts

@@ -1,38 +0,0 @@
-
-
-export async function someAsync<T>(target: ReadonlyArray<T>, condition: (v: T, index?: number, arr?: ReadonlyArray<T>) => Promise<boolean>): Promise<boolean> {
-    for (let i = 0; i < target.length; ++i) {
-        const ok = await condition(target[i], i, target);
-        if (ok) {
-            return true;
-        }
-    }
-
-    return false;
-}
-
-export async function everyAsync<T>(target: ReadonlyArray<T>, condition: (v: T, index?: number, arr?: ReadonlyArray<T>) => Promise<boolean>): Promise<boolean> {
-    for (let i = 0; i < target.length; ++i) {
-        const ok = await condition(target[i], i, target);
-        if (!ok) {
-            return false;
-        }
-    }
-
-    return true;
-}
-
-export async function forEachAsync<T>(target: ReadonlyArray<T>, cb: (v: T, index?: number, arr?: ReadonlyArray<T>) => Promise<void>): Promise<void> {
-    for (let i = 0; i < target.length; ++i) {
-        await cb(target[i], i, target);
-    }
-}
-
-export async function mapAsync<T, R>(target: ReadonlyArray<T>, cb: (v: T, index?: number, arr?: ReadonlyArray<T>) => Promise<R>): Promise<R[]> {
-    const results: R[] = [];
-    for (let i = 0; i < target.length; ++i) {
-        const r = await cb(target[i], i, target);
-        results.push(r);
-    }
-    return results;
-}

package/src/async/misc.ts

@@ -1,26 +0,0 @@
-
-export async function OptAwait<T>(cb: () => (T | Promise<T>), doAwait: boolean): Promise<T> {
-    return cb && (doAwait ? (await cb()) : cb());
-}
-
-export async function chainPromises(...promises: (() => Promise<void>)[]) {
-
-    const applyAsync = (acc: Promise<void>, val: () => Promise<void>) => acc.then(val);
-
-    return promises.reduce(applyAsync, Promise.resolve());
-}
-
-export function createManualPromise<T = void>() {
-    let resolve: (res: T) => void = null;
-    let reject: (err: Error) => void = null;
-    const promise = new Promise<T>((_resolve, _reject) => {
-        resolve = _resolve;
-        reject = _reject;
-    });
-
-    return {
-        promise,
-        resolve,
-        reject,
-    };
-}

package/src/async/timeout.ts

@@ -1,84 +0,0 @@
-
-export function setTimeoutAsync(ms: number, useCancel: (cb: () => void) => void = null) {
-    let canceled = false;
-    let _reject: () => void;
-    let token: any;
-    const res = new Promise<void>((resolve, reject) => {
-        _reject = reject;
-        token = setTimeout(() => {
-            _reject = null;
-            if (!canceled) {
-                resolve();
-            }
-        }, ms);
-    });
-
-    if (useCancel) {
-        const cancelCb = () => {
-            clearTimeout(token);
-            canceled = true;
-            if (_reject) {
-                _reject();
-            }
-        };
-        useCancel(cancelCb);
-    }
-
-    return res;
-}
-
-/* global requestAnimationFrame */
-
-export function setTimeoutFramesAsync(frames: number) {
-    if (typeof requestAnimationFrame === 'undefined') {
-        throw new Error('setTimeoutFramesAsync is not supported because "requestAnimationFrame" is not defined.');
-    }
-
-    return new Promise<void>(resolve => {
-        let left = frames || 0;
-
-        const cb = () => {
-            if (--left <= 0) {
-                resolve();
-            } else {
-                requestAnimationFrame(cb);
-            }
-        };
-
-        cb();
-    });
-}
-
-export function timeoutPromise<T>(p: Promise<T>, timeoutMs: number, waitForMinElapsed?: number): Promise<{ resolved: T, timedOut?: boolean, elapsed: number }> {
-    const started = Date.now();
-
-    return new Promise((resolve, reject) => {
-        let finished = false;
-        const finish = (res: T, timedOut: boolean) => {
-            if (finished) {
-                return;
-            }
-
-            finished = true;
-
-            const getElapsed = () => (Date.now() - started);
-            const doFinish = () => resolve({ resolved: res, timedOut: timedOut, elapsed: getElapsed() });
-
-            const left = waitForMinElapsed != null ? (waitForMinElapsed - getElapsed()) : -1;
-            if (left >= 0) {
-                setTimeout(doFinish, left);
-            } else {
-                doFinish();
-            }
-        };
-
-        const timeoutRef = setTimeout(() => {
-            finish(undefined, true);
-        }, timeoutMs);
-
-        p.then(res => {
-            clearTimeout(timeoutRef);
-            finish(res, false);
-        }).catch(reject);
-    });
-}

package/src/controllers/PluggableController.ts

@@ -1,35 +0,0 @@
-import { IPluggableController } from '../abstractions/controllers/IPluggableController';
-
-export { IPluggableController };
-
-export abstract class PluggableController<T = any> implements IPluggableController {
-    private _enabled: boolean = undefined;
-    private _config: T = null;
-
-    get enabled() { return this._enabled; }
-    get config() { return this._config; }
-
-    async setEnabledAsync(enabled: boolean, config: T = undefined) {
-        if (config !== undefined) {
-            this.setConfig(config);
-        }
-
-        if (this._enabled === enabled) {
-            return;
-        }
-
-        this._enabled = enabled;
-        if (this._enabled) {
-            await this.initialize();
-        } else {
-            await this.dispose();
-        }
-    }
-
-    setConfig(config: T) {
-        this._config = config;
-    }
-
-    protected abstract initialize(): Promise<void>;
-    protected abstract dispose(): Promise<void>;
-}