@zajno/common 2.0.3 → 2.0.4

package/src/math/__tests__/calc.test.ts

@@ -1,67 +0,0 @@
-import * as calc from '../calc';
-
-describe('math/calc', () => {
-    it('clamp', () => {
-        expect(calc.clamp(123)).toBe(123);
-        expect(calc.clamp(123, 10)).toBe(123);
-        expect(calc.clamp(0, 1, 2, false)).toBe(1);
-        expect(calc.clamp(0, 1, 2, true)).toBe(2);
-        expect(calc.clamp(3, 1, 2, false)).toBe(2);
-        expect(calc.clamp(3, 1, 2, true)).toBe(1);
-        expect(calc.clamp(15, 10, 20, false)).toBe(15);
-        expect(calc.clamp(15, 10, 20, true)).toBe(15);
-    });
-
-    it('clamp01', () => {
-        expect(calc.clamp01(-1)).toBe(0);
-        expect(calc.clamp01(0)).toBe(0);
-        expect(calc.clamp01(0.5)).toBe(0.5);
-        expect(calc.clamp01(1)).toBe(1);
-        expect(calc.clamp01(2)).toBe(1);
-    });
-
-    it('contains', () => {
-        expect(calc.contains(1, 2, 3)).toBe(false);
-        expect(calc.contains(1, 3, 2)).toBe(false);
-        expect(calc.contains(15, 10, 20)).toBe(true);
-        expect(calc.contains(15, 20, 10)).toBe(true);
-    });
-
-    it('getIntersection', () => {
-        expect(calc.getIntersection(1, 2, 3, 4)).toBeFalsy();
-        expect(calc.getIntersection(1, 3, 1, 4)).toBeTruthy();
-    });
-
-    it('roundNumber', () => {
-        expect(calc.roundNumber(10)).toBe(10);
-        expect(calc.roundNumber(10.1)).toBe(10.1);
-        expect(calc.roundNumber(10.12)).toBe(10.12);
-        expect(calc.roundNumber(10.123)).toBe(10.12);
-        expect(calc.roundNumber(10.1234)).toBe(10.12);
-        expect(calc.roundNumber(10.1234, 4)).toBe(10.1234);
-        expect(calc.roundNumber(10.1235, 3)).toBe(10.124);
-        expect(calc.roundNumber(10.1234, 3, 'ceil')).toBe(10.124);
-        expect(calc.roundNumber(10.1239, 3, 'floor')).toBe(10.123);
-    });
-
-    it('roundHalf', () => {
-        expect(calc.roundHalf(12.213)).toBe(12);
-        expect(calc.roundHalf(12.999)).toBe(13);
-    });
-
-    describe('random', () => {
-        const testRandom = (min: number, max: number, trunc = true) => {
-            it(`[${min}, ${max}, ${trunc}]`, () => {
-                const v = calc.random(min, max, trunc);
-                expect(v).toBeGreaterThanOrEqual(min);
-                expect(v).toBeLessThanOrEqual(max);
-                expect(v - Math.trunc(v) > 0).not.toEqual(trunc);
-            });
-        };
-
-        testRandom(0, 1, true);
-        testRandom(0, 1, false);
-        testRandom(1, 100, true);
-        testRandom(1, 100, false);
-    });
-});

package/src/math/__tests__/distribution.test.ts

@@ -1,25 +0,0 @@
-import * as distribution from '../distribution';
-
-describe('math/distribution', () => {
-    it('extendDistribution', () => {
-        type TKeys = 'type1' | 'type2';
-
-        const r1 = distribution.extendDistribution<TKeys>(1, 'type1');
-        expect(r1).toBeTruthy();
-        expect(r1.total).toBe(1);
-        expect(r1.byType.type1).toBe(1);
-
-        distribution.extendDistribution(3, 'type2', r1);
-        expect(r1.total).toBe(4);
-        expect(r1.byType.type1).toBe(1);
-        expect(r1.byType.type2).toBe(3);
-
-        const d: distribution.Distribution<TKeys> = { total: 0, byType: null };
-        distribution.extendDistribution(1, 'type1', d);
-        expect(d.total).toBe(1);
-        expect(d.byType.type1).toBe(1);
-        expect(d.byType.type2).toBeUndefined();
-
-        expect(distribution.extendDistribution(0, 'type1').total).toBe(0);
-    });
-});

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

@@ -1,20 +0,0 @@
-import * as math from '../index';
-
-describe('math', () => {
-    it('getNumberSuffix', () => {
-        expect(math.getNumberSuffix(1)).toBe('st');
-        expect(math.getNumberSuffix(11)).toBe('st');
-        expect(math.getNumberSuffix(11111)).toBe('st');
-
-        expect(math.getNumberSuffix(2)).toBe('nd');
-        expect(math.getNumberSuffix(1232)).toBe('nd');
-        expect(math.getNumberSuffix(32412.99)).toBe('th');
-
-        expect(math.getNumberSuffix(3)).toBe('rd');
-        expect(math.getNumberSuffix(323)).toBe('rd');
-        expect(math.getNumberSuffix(1233.233)).toBe('th');
-
-        expect(math.getNumberSuffix(0)).toBe('th');
-        expect(math.getNumberSuffix(145)).toBe('th');
-    });
-});

package/src/math/arrays.ts

@@ -1,274 +0,0 @@
-import { Comparator, Getter, Predicate } from '../types';
-import { random } from './calc';
-
-export function arrayCompareG<T>(arr: ReadonlyArray<T>, cond: (current: T, previous: T) => boolean): T {
-    if (!Array.isArray(arr) || arr.length <= 0) {
-        return null;
-    }
-
-    let result: T = null;
-    for (let i = 0; i < arr.length; i++) {
-        const current: T = arr[i];
-        if (cond(current, result)) {
-            result = current;
-        }
-    }
-
-    return result;
-}
-
-export function arrayCompare(arr: number[], absolute: boolean, cond: (i: number, t: number) => boolean) {
-    if (!Array.isArray(arr) || arr.length <= 0) {
-        return null;
-    }
-
-    let max = arr[0];
-    for (let i = 1; i < arr.length; i++) {
-        const e = absolute ? Math.abs(arr[i]) : arr[i];
-        if (cond(e, max)) {
-            max = e;
-        }
-    }
-
-    return max;
-}
-
-export function arrayMax(arr: number[], absolute = false) {
-    return arrayCompare(arr, absolute, (e, max) => e > max);
-}
-
-export function arrayMin(arr: number[], absolute = false) {
-    return arrayCompare(arr, absolute, (e, min) => e < min);
-}
-
-export function arrayAverage(arr: number[], absolute = false) {
-    if (!Array.isArray(arr) || arr.length <= 0) {
-        return 0;
-    }
-
-    let sum = 0;
-    for (let i = 0; i < arr.length; i++) {
-        const e = absolute ? Math.abs(arr[i]) : arr[i];
-        sum += e;
-    }
-
-    return sum / arr.length;
-}
-
-export function arrayCount<T>(arr: ReadonlyArray<T>, condition: (o: T) => boolean): number {
-    if (!arr || !arr.length) {
-        return 0;
-    }
-
-    let count = 0;
-    arr.forEach(a => {
-        if (condition(a)) {
-            ++count;
-        }
-    });
-    return count;
-}
-
-export function arrayFirstResult<T, V>(arr: ReadonlyArray<T>, mapper: (o: T) => V | null | false): V | null | false {
-    if (arr?.length) {
-        for (let i = 0; i < arr.length; ++i) {
-            const r = mapper(arr[i]);
-            if (r) {
-                return r;
-            }
-        }
-    }
-
-    return false;
-}
-
-export function arraysCompare<T>(base: readonly T[], target: readonly T[], comparator?: Comparator<T>) {
-    if (!base || !target) {
-        return null;
-    }
-
-    const compare = comparator || Comparator.Default;
-    const result = {
-        missing: [] as T[],
-        extra: [] as T[],
-        diff: 0,
-    };
-
-    for (let i = 0; i < base.length; ++i) {
-        const baseItem = base[i];
-        const targetItem = target[i];
-        if (compare(baseItem, targetItem)) {
-            continue;
-        }
-
-        result.missing.push(baseItem);
-    }
-
-    for (let i = base.length; i < target.length; ++i) {
-        result.extra.push(target[i]);
-    }
-
-    result.diff = result.missing.length + result.extra.length;
-    return result;
-}
-
-export function arraysCompareDistinct<T>(base: readonly T[], target: readonly T[]) {
-    if (!base || !target) {
-        return null;
-    }
-
-    const baseSet = new Set(base);
-    const targetSet = new Set(target);
-    const result = {
-        missing: [] as T[],
-        extra: [] as T[],
-        diff: 0,
-    };
-
-    for (const item of baseSet) {
-        if (!targetSet.has(item)) {
-            result.missing.push(item);
-        } else {
-            // reduce iterations for 'extra'
-            targetSet.delete(item);
-        }
-    }
-
-    for (const item of targetSet) {
-        // all items left in 'target' is missing in 'base'
-        result.extra.push(item);
-    }
-
-    result.diff = result.missing.length + result.extra.length;
-    return result;
-}
-
-export function arrayDistinct<T>(arr: readonly T[]) {
-    return Array.from(new Set(arr || []));
-}
-
-export function normalize(arr: number[]): number[] {
-    if (arr.length === 0) {
-        return arr;
-    }
-
-    const min = arrayMin(arr);
-    const max = arrayMax(arr);
-    const dist = max - min;
-    if (Math.abs(dist) < 0.000001) { // almost zero
-        return arr.map(() => 1);
-    }
-
-    return arr.map(x => (x - min) / dist);
-}
-
-export function randomArrayItem<T>(arr: T[]): T {
-    if (!arr.length) {
-        return null;
-    }
-
-    const i = random(0, arr.length - 1);
-    return arr[i];
-}
-
-export function arraySwap<T>(arr: T[], i1: number, i2: number) {
-    const x = arr[i1];
-    arr[i1] = arr[i2];
-    arr[i2] = x;
-}
-
-export function shuffle<T>(arr: T[], slice: false): T[];
-export function shuffle<T>(arr: ReadonlyArray<T>): T[];
-export function shuffle<T>(arr: ReadonlyArray<T>, slice: true): T[];
-
-export function shuffle<T>(arr: T[], slice = true): T[] {
-    const res = (slice ? arr?.slice() : arr) || [];
-
-    for (let i = 0; i < res.length - 1; ++i) {
-        const nextIndex = random(i + 1, res.length - 1);
-        arraySwap(res, i, nextIndex);
-    }
-
-    return res;
-}
-
-export function groupBy<T, K extends string | number>(arr: ReadonlyArray<T>, grouper: (item: T) => K): Partial<Record<K, T[]>> {
-    const result: Partial<Record<K, T[]>> = { };
-    arr.forEach(item => {
-        const k = grouper(item);
-        let g = result[k];
-        if (!g) {
-            g = [];
-            result[k] = g;
-        }
-
-        g.push(item);
-    });
-
-    return result;
-}
-
-export function groupOneBy<T, K extends string | number>(arr: ReadonlyArray<T>, grouper: (item: T) => K): Partial<Record<K, T>> {
-    const result: Partial<Record<K, T>> = { };
-    arr.forEach(item => {
-        const k = grouper(item);
-        result[k] = item;
-    });
-
-    return result;
-}
-
-export function arraySplit<T>(arr: ReadonlyArray<T>, predicate: (t: T) => boolean): [T[], T[]] {
-    const trueArr: T[] = [];
-    const falseArr: T[] = [];
-
-    arr.forEach(a => {
-        (predicate(a)
-            ? trueArr
-            : falseArr).push(a);
-    });
-
-    return [trueArr, falseArr];
-}
-
-export function findIndexLeast(num: number, arr: number[], sort = false) {
-    if (sort) {
-        arr.sort();
-    }
-
-    return arr.findIndex(i => i > num);
-}
-
-type NonFunction<T> = T extends Function ? never : T;
-
-export function removeItem<T>(array: T[], item: NonFunction<T> | Predicate<T>): T {
-    const index = typeof item === 'function'
-        ? array.findIndex(item as Predicate<T>)
-        : array.indexOf(item);
-    if (index < 0) {
-        return null;
-    }
-
-    return array.splice(index, 1)[0];
-}
-
-export function arrayRepeat<T>(factory: Getter<T>, count = 1) {
-    const res: T[] = [];
-    for (let i = 0; i < count; ++i) {
-        res.push(Getter.getValue(factory));
-    }
-    return res;
-}
-
-export function chunkify<T>(array: T[], size: number): T[][] {
-    return array.reduce((res, item) => {
-        let arr = res[res.length - 1];
-        if (!arr || arr.length >= size) {
-            arr = [];
-            res.push(arr);
-        }
-
-        arr.push(item);
-        return res;
-    }, [] as T[][]);
-}

package/src/math/calc.ts

@@ -1,69 +0,0 @@
-
-export function clamp(val: number, min: number = undefined, max: number = undefined, cycle = false) {
-    if (min != null && val < min) {
-        return (max != null && cycle) ? max : min;
-    }
-
-    if (max != null && val > max) {
-        return (min != null && cycle) ? min : max;
-    }
-
-    return val;
-}
-
-export function clamp01(val: number) {
-    return clamp(val, 0, 1, false);
-}
-
-export function contains(val: number, from: number, to: number) {
-    const s = Math.min(from, to);
-    const e = Math.max(from, to);
-    return val >= s && val <= e;
-}
-
-export function getIntersection(v1: number, v2: number, r1: number, r2: number): false | { ranges: number[][], merged: { s: number, e: number} } {
-    const v = [v1, v2].sort();
-    const r = [r1, r2].sort();
-
-    const res = (v[0] >= r[0] && v[0] <= r[1])
-        || (v[1] >= r[0] && v[1] <= r[1])
-        || (r[0] >= v[0] && r[0] <= v[1])
-        || (r[1] >= v[0] && r[1] <= v[1]);
-
-    if (!res) {
-        return false;
-    }
-
-    return {
-        ranges: [v, r],
-        merged: {
-            s: Math.min(v[0], r[0]),
-            e: Math.max(v[1], r[1]),
-        },
-    };
-}
-
-export function roundNumber(val: number, signs = 2, mode?: 'floor' | 'ceil') {
-    const k = 10 ** signs;
-    let v = (val + Number.EPSILON) * k;
-    switch (mode) {
-        case 'floor': v = Math.floor(v); break;
-        case 'ceil': v = Math.ceil(v); break;
-        default: v = Math.round(v); break;
-    }
-    return v / k;
-}
-
-export function roundHalf(num: number): number {
-    return Math.round(num * 2) / 2;
-}
-
-export function random(min: number = 0, max: number = 1, trunc = true) {
-    const r = Math.random();
-    const res = min + r * (max - min);
-    return trunc ? Math.trunc(res) : res;
-}
-
-export function badRandomString(length = 12) {
-    return Math.random().toString(26).slice(2, clamp(length, 0, 12));
-}

package/src/math/distribution.ts

@@ -1,20 +0,0 @@
-
-
-export type Distribution<T extends keyof any> = {
-    total: number,
-    byType: Partial<Record<T, number>>,
-};
-
-export function extendDistribution<T extends keyof any>(count: number, type: T, current?: Distribution<T>): Distribution<T> {
-    const res: Distribution<T> = current ?? { total: 0, byType: { } };
-    if (!res.byType) {
-        res.byType = { };
-    }
-
-    if (count > 0) {
-        res.byType[type] = (res.byType[type] || 0) + count;
-        res.total += count;
-    }
-
-    return res;
-}

package/src/math/index.ts

@@ -1,27 +0,0 @@
-
-export * from './calc';
-export * from './arrays';
-export * from './distribution';
-
-export function getNumberSuffix(num: number) {
-    const lastDigit = (num || 0) % 10;
-
-    switch (lastDigit) {
-        case 1:
-            return 'st';
-        case 2:
-            return 'nd';
-        case 3:
-            return 'rd';
-        default:
-            return 'th';
-    }
-}
-
-export function format(n: number, digits?: number) {
-    const res = n.toString();
-    if (digits && digits > res.length) {
-        return res.padStart(digits, '0');
-    }
-    return res;
-}

package/src/models/EntityWithStatus.ts

@@ -1,58 +0,0 @@
-export type StatusWithDate<TStatus extends string = string> = {
-    status: TStatus,
-    date: number,
-};
-
-export type EntityWithStatus<TStatus extends string> = StatusWithDate<TStatus> & {
-    history?: { d: number, s: TStatus }[],
-};
-
-export namespace EntityWithStatus {
-
-    export function changeStatus<T extends EntityWithStatus<TStatus>, TStatus extends string>(entity: Partial<T>, status: TStatus, date: number = null, allowStatusUpdate = false) {
-        if (!entity) {
-            return false;
-        }
-
-        if (entity.status === status && !allowStatusUpdate) {
-            return false;
-        }
-
-        if (!entity.history) {
-            entity.history = [];
-        }
-
-        entity.history.push({ d: entity.date || null, s: entity.status || null });
-        entity.date = date || Date.now();
-        entity.status = status;
-        return true;
-    }
-
-    export function getLastStatusDate<T extends EntityWithStatus<TStatus>, TStatus extends string>(entity: T, ...statuses: TStatus[]) {
-        if (!entity || !statuses.length) {
-            return null;
-        }
-
-        if (statuses.includes(entity.status)) {
-            return entity.date;
-        }
-
-        if (entity.history && entity.history.length) {
-            const t = entity.history.find(h => statuses.includes(h.s));
-            if (t) {
-                return t.d;
-            }
-        }
-
-        return null;
-    }
-
-    export function getFullHistory<T extends EntityWithStatus<TStatus>, TStatus extends string>(entity: T): StatusWithDate<TStatus>[] {
-        const result: { date: number, status: TStatus }[] = [];
-        if (entity.history?.length) {
-            result.push(...entity.history.map(h => ({ date: h.d, status: h.s })));
-        }
-        result.push({ date: entity.date, status: entity.status });
-        return result;
-    }
-}

package/src/models/File.ts

@@ -1,14 +0,0 @@
-
-export type FileMetadata = {
-    name: string;
-
-    /** size in bytes */
-    size: number;
-
-    /** refers to MIME type */
-    type: string;
-
-    format?: string;
-
-    lang?: string;
-};

package/src/observing/event.ts

@@ -1,91 +0,0 @@
-import type { Predicate } from '../types';
-import { forEachAsync } from '../async/arrays';
-import { ILogger, createLogger } from '../logger';
-
-export type EventHandler<T = any> = (data?: T) => void | Promise<void>;
-
-export interface IEvent<T = any> {
-    on(handler: EventHandler<T>): () => void;
-    off(handler: EventHandler<T>): void;
-}
-
-export class Event<T = any> implements IEvent<T> {
-    private _handlers: EventHandler<T>[] = [];
-    private _logger: ILogger = null;
-
-    constructor();
-    constructor(logger?: ILogger);
-    constructor(name?: string);
-
-    constructor(loggerOrName?: ILogger | string) {
-        this._logger = (!loggerOrName || typeof loggerOrName === 'string')
-            ? createLogger(`[Event:${loggerOrName || '?'}]`)
-            : loggerOrName;
-    }
-
-    public on(handler: EventHandler<T>): () => void {
-        this._handlers.push(handler);
-        return () => {
-            this.off(handler);
-        };
-    }
-
-    public off(handler: EventHandler<T>): void {
-        this._handlers = this._handlers.filter(h => h !== handler);
-    }
-
-    public trigger(data?: T) {
-        if (!this._handlers.length) {
-            return;
-        }
-
-        const hh = this._handlers.slice(0);
-        hh.forEach(cb => {
-            try {
-                cb(data);
-            } catch (err) {
-                this.logError(data, cb, err);
-            }
-        });
-    }
-
-    public async triggerAsync(data?: T): Promise<Error[]> {
-        if (!this._handlers.length) {
-            return [];
-        }
-
-        const hh = this._handlers.slice(0);
-
-        const errors: Error[] = [];
-
-        await forEachAsync(hh, async (cb: EventHandler<T>) => {
-            try {
-                await cb(data);
-            } catch (err) {
-                this.logError(data, cb, err);
-                errors.push(err);
-            }
-        });
-
-        return errors;
-    }
-
-    public expose(): IEvent<T> {
-        return this;
-    }
-
-    private logError(data: T, cb: EventHandler<T>, err: Error) {
-        this._logger.error(`[Event.${typeof data}] Handler ${cb.name} thrown an exception: `, err);
-    }
-}
-
-export function oneTimeSubscription<T>(e: IEvent<T>, filter?: Predicate<T>): Promise<T> {
-    return new Promise<T>((resolve) => {
-        const unsub = e.on(v => {
-            if (!filter || filter(v)) {
-                unsub();
-                resolve(v);
-            }
-        });
-    });
-}