@zajno/common 2.0.3 → 2.0.5

package/src/observing/progressTracker.ts

@@ -1,90 +0,0 @@
-import * as DateHelpers from '../dates';
-import * as MathHelpers from '../math';
-import logger, { ILogger } from '../logger';
-import { Event } from './event';
-
-export class ProgressTracker {
-
-    private readonly _firstTimestamp = Date.now();
-    private _lastTimestamp: number = null;
-    private _lastCompleted: number = null;
-
-    private _completed = 0;
-    private _total = 0;
-
-    private _currentProgress: number = 0;
-
-    private readonly _deltas: number[] = [];
-
-    private readonly _changed = new Event<{ completed: number, total: number, currentProgress: number, totalElapsedMs: number, totalEstimatedMs: number }>();
-
-    constructor(readonly log: boolean | ILogger = true) { }
-
-    public get changed() { return this._changed.expose(); }
-    public get total() { return this._total; }
-    public get completed() { return this._completed; }
-    public get current() { return this._currentProgress; }
-
-    private get logger() {
-        return this.log === true
-            ? logger
-            : (this.log || null);
-    }
-
-    public setTotal(total: number) {
-        this._total = total;
-        return this;
-    }
-
-    public add(amount = 1, restart = false) {
-        this._completed = restart ? amount : (this._completed + amount);
-        this.track(this._completed, this._total);
-    }
-
-    public track(completed: number, total: number) {
-
-        if (!this._lastTimestamp) {
-            this._lastTimestamp = this._firstTimestamp;
-        }
-
-        const elapsedDelta = Date.now() - this._lastTimestamp;
-        const completedDelta = completed - (this._lastCompleted || 0);
-        this._lastCompleted = completed;
-        this._completed = completed;
-        const timePerCompleted = completedDelta > 0 ? (elapsedDelta / completedDelta) : 0;
-
-        this._deltas.push(timePerCompleted);
-        if (this._deltas.length > 20) {
-            this._deltas.shift();
-        }
-
-        this._currentProgress = Math.floor(completed / (total || 100) * 100);
-        const itemsLeft = total - completed;
-        const leftProgressTime = itemsLeft * (MathHelpers.arrayAverage(this._deltas, true) || 1000);
-
-        this._lastTimestamp = Date.now();
-
-        const totalElapsedMs = this._lastTimestamp - this._firstTimestamp;
-
-        if (this.log) {
-            const totalElapsed = msToString(totalElapsedMs);
-            const totalEstimated = msToString(leftProgressTime);
-
-            this.logger.log(`Progress: ${completed}/${total} ${totalElapsed}/${totalEstimated} => ${this._currentProgress}%`);
-        }
-
-        this._changed.trigger({
-            completed,
-            total,
-            currentProgress: this._currentProgress,
-            totalElapsedMs,
-            totalEstimatedMs: leftProgressTime,
-        });
-    }
-}
-
-function msToString(this: void, ms: number) {
-    const decs = DateHelpers.decomposeMs(ms, 'second', 'minute', 'hour');
-    const nf = (n: number) => n.toString().padStart(2, '0');
-    return `${nf(decs.hour)}:${nf(decs.minute)}:${nf(decs.second)}`;
-}

package/src/observing/throttledEvent.ts

@@ -1,20 +0,0 @@
-import { Event } from './event';
-import { ThrottleAction } from '../functions/throttle';
-
-export class ThrottledEvent extends Event {
-
-    private readonly _throttle = new ThrottleAction(100);
-
-    public setTimeout(timeout: number) {
-        this._throttle.timeout = timeout;
-        return this;
-    }
-
-    public trigger() {
-        this._throttle.tryRun(() => super.trigger());
-    }
-
-    public async triggerAsync(): Promise<Error[]> {
-        throw new Error('ThrottledEvent does not support triggerAsync');
-    }
-}

package/src/observing/timer.ts

@@ -1,40 +0,0 @@
-import { IDisposable } from '../functions/disposer';
-import { Event, EventHandler, IEvent } from './event';
-
-export class Timer implements IDisposable, IEvent<number> {
-    private readonly _event = new Event<number>();
-
-    private _now: number = Date.now();
-    private _handle = null;
-
-    constructor(readonly interval = 3600 * 1000) {
-        this.restart();
-    }
-
-    get now() {
-        return this._now;
-    }
-
-    on(handler: EventHandler<number>): () => void {
-        return this._event.on(handler);
-    }
-
-    off(handler: EventHandler<number>): void {
-        return this._event.off(handler);
-    }
-
-    public restart() {
-        this.dispose();
-
-        // Update _now once an hour
-        this._handle = setInterval(() => {
-            this._now = Date.now();
-            this._event.trigger(this._now);
-        }, this.interval);
-    }
-
-    public dispose(): void {
-        clearInterval(this._handle);
-        this._handle = null;
-    }
-}

package/src/storage/abstractions.ts

@@ -1,18 +0,0 @@
-
-export interface IStorage {
-    getValue(key: string): Promise<string>;
-    setValue(key: string, value: string): Promise<void>;
-
-    hasValue(key: string): Promise<boolean>;
-    remove(key: string): Promise<void>;
-}
-
-export interface IStorageSync {
-    getValue(key: string): string;
-    setValue(key: string, value: string): void;
-
-    removeValue(key: string): boolean;
-    hasValue(key: string): boolean;
-}
-
-export default IStorage;

package/src/storage/asyncWrapper.ts

@@ -1,24 +0,0 @@
-import { IStorage, IStorageSync } from './abstractions';
-
-export class StorageAsyncWrapper implements IStorage {
-
-    constructor(readonly webStorage: IStorageSync) { }
-
-    getValue(key: string) {
-        return Promise.resolve(this.webStorage.getValue(key));
-    }
-
-    setValue(key: string, value: string) {
-        this.webStorage.setValue(key, value);
-        return Promise.resolve();
-    }
-
-    hasValue(key: string) {
-        return Promise.resolve(this.webStorage.hasValue(key));
-    }
-
-    remove(key: string) {
-        this.webStorage.removeValue(key);
-        return Promise.resolve();
-    }
-}

package/src/storage/index.ts

@@ -1,2 +0,0 @@
-
-export * from './abstractions';

package/src/storage/keyStorage.ts

@@ -1,40 +0,0 @@
-import { IStorageSync } from './abstractions';
-
-export class KeyStorage {
-    constructor(readonly storage: IStorageSync, readonly key: string) { }
-
-    get value() { return this.storage.getValue(this.key); }
-    set value(v: string) { this.storage.setValue(this.key, v); }
-
-    public clean() {
-        this.storage.removeValue(this.key);
-    }
-
-    public getHasValue() {
-        return this.storage.hasValue(this.key);
-    }
-}
-
-export class KeyStorageConverted<T> {
-    private readonly _storage: KeyStorage = null;
-
-    constructor(
-        storage: IStorageSync,
-        key: string,
-        readonly input: (v: T) => string = (v => JSON.stringify(v)),
-        readonly output: (s: string) => T = (s => JSON.parse(s || null) as T),
-    ) {
-        this._storage = new KeyStorage(storage, key);
-    }
-
-    get value(): T { return this.output(this._storage.value); }
-    set value(v: T) { this._storage.value = this.input(v); }
-
-    public clean() {
-        this._storage.clean();
-    }
-
-    public getHasValue() {
-        return this._storage.getHasValue();
-    }
-}

package/src/structures/__tests__/enumHelper.test.ts

@@ -1,85 +0,0 @@
-import EnumHelper, { EnumBitwiseHelper, EnumStringHelper } from '../helpers/enum';
-
-enum Enum {
-    Val1 = 1,
-    Val2 = 2,
-}
-
-describe('EnumHelper', () => {
-    const helper = new EnumHelper(Enum);
-
-    it('runs correctly', () => {
-        expect(helper.Keys).toEqual(['Val1', 'Val2']);
-        expect(helper.Values).toEqual([Enum.Val1, Enum.Val2]);
-        expect(helper.keyToString('Val1', { [Enum.Val1]: 'kek' })).toBe('kek');
-        expect(helper.keyToValue('Val1')).toBe(Enum.Val1);
-        expect(helper.valueToString(Enum.Val1, { [Enum.Val1]: 'kek' })).toBe('kek');
-        expect(helper.validateValue(1)).toBe(Enum.Val1);
-        expect(helper.validateValue(123)).toBeNull();
-        expect(helper.validateValue(null)).toBeNull();
-    });
-});
-
-enum EnumString {
-    A = 'a',
-    B = 'b',
-}
-
-describe('EnumStringHelper', () => {
-    const helper = new EnumStringHelper<EnumString>(EnumString);
-
-    it('runs correctly', () => {
-        expect(helper.Keys).toEqual(['A', 'B']);
-        expect(helper.Values).toEqual([EnumString.A, EnumString.B]);
-        expect(helper.keyToString('A')).toBe('A');
-        expect(helper.valueToString(EnumString.A)).toBe(EnumString.A);
-
-        expect(helper.validateValue('a')).toBe(EnumString.A);
-        expect(helper.validateValue('123')).toBeNull();
-        expect(helper.validateValue(null)).toBeNull();
-    });
-});
-
-enum EnumBitwise {
-    One = 1 << 0,
-    Two = 1 << 1,
-
-    Three = One | Two,
-}
-
-describe('EnumBitwiseHelper', () => {
-    const helper = new EnumBitwiseHelper<EnumBitwise>(EnumBitwise, {
-        [EnumBitwise.One]: 'one',
-        [EnumBitwise.Two]: 'two',
-        [EnumBitwise.Three]: 'three',
-    });
-
-    it('runs correctly', () => {
-        expect(helper.Keys).toEqual(['One', 'Two', 'Three']);
-        expect(helper.Values).toEqual([EnumBitwise.One, EnumBitwise.Two, EnumBitwise.Three]);
-        expect(helper.keyToString('One')).toBe('one');
-        expect(helper.valueToString(EnumBitwise.One)).toBe('one');
-
-        expect(helper.validateValue(EnumBitwise.One)).toBe(EnumBitwise.One);
-        expect(helper.validateValue(6)).toBeNull();
-        expect(helper.validateValue(null)).toBeNull();
-
-        expect(helper.toStrings(0)).toStrictEqual([undefined]);
-        expect(helper.toStrings(EnumBitwise.One)).toStrictEqual(['one']);
-        expect(helper.toStrings(EnumBitwise.Three)).toStrictEqual(['one', 'two', 'three']);
-
-        expect(helper.toString(EnumBitwise.Three)).toBe('one, two, three');
-
-        expect(helper.contains(EnumBitwise.Three, EnumBitwise.One)).toBe(true);
-        expect(helper.contains(EnumBitwise.Three, EnumBitwise.Two)).toBe(true);
-        expect(helper.contains(EnumBitwise.One, EnumBitwise.Two)).toBe(false);
-        expect(helper.contains(EnumBitwise.Two, EnumBitwise.One)).toBe(false);
-        expect(helper.contains(EnumBitwise.One, 0)).toBe(true);
-
-        expect(helper.combine(EnumBitwise.One, EnumBitwise.Two)).toBe(EnumBitwise.Three);
-        expect(helper.combine(EnumBitwise.One)).toBe(EnumBitwise.One);
-        expect(helper.combine(EnumBitwise.One, 0)).toBe(EnumBitwise.One);
-
-        expect(helper.remove(EnumBitwise.Three, EnumBitwise.Two)).toBe(EnumBitwise.One);
-    });
-});

package/src/structures/__tests__/tempoCache.test.ts

@@ -1,31 +0,0 @@
-import { TempoCache } from '../tempoCache';
-import { setTimeoutAsync } from '../../async/timeout';
-
-describe('TempoCache', () => {
-    it('just works', async () => {
-        let incrementer = 1;
-
-        const example = new TempoCache(() => Promise.resolve(incrementer++), 199);
-
-        expect(await example.current).toBe(1);
-        await expect(example.current).resolves.toBe(1);
-
-        await setTimeoutAsync(100);
-
-        await expect(example.current).resolves.toBe(1);
-
-        await setTimeoutAsync(200);
-
-        await expect(example.current).resolves.toBe(2);
-
-        await setTimeoutAsync(100);
-
-        await expect(example.current).resolves.toBe(2);
-        await expect(example.current).resolves.toBe(2);
-
-        await setTimeoutAsync(300);
-
-        await expect(example.current).resolves.toBe(3);
-        await expect(example.current).resolves.toBe(3);
-    });
-});

package/src/structures/helpers/enum.ts

@@ -1,123 +0,0 @@
-export class EnumStringHelper<T extends string> {
-    public readonly Keys: string[] = null;
-    public readonly Values: T[] = null;
-
-    constructor(
-        protected readonly _obj: any,
-        private readonly _valuesToStrings: { [val: string]: string } = null,
-    ) {
-        this.Keys = Object.keys(this._obj)
-            .filter(k => typeof this._obj[k as any] === 'string');
-
-        this.Values = this.Keys.map(k => this._obj[k]);
-    }
-
-    keyToString(key: string): string {
-        return this._valuesToStrings
-            ? this._valuesToStrings[this._obj[key]]
-            : key;
-    }
-
-    valueToString(v: T): string {
-        const custom = this._valuesToStrings && this._valuesToStrings[v];
-        return custom || v;
-    }
-
-    validateValue(v: string | null): T | null {
-        if (!v) {
-            return null;
-        }
-        const i = this.Values.findIndex(vv => vv === v);
-        return i >= 0
-            ? this.Values[i]
-            : null;
-    }
-}
-
-type ValueToStringMap = { [val: number]: string };
-
-export default class EnumHelper<T extends number> {
-    public readonly Keys: string[] = null;
-    public readonly Values: T[] = null;
-
-    constructor(
-        protected readonly _obj: any,
-        private readonly _valuesToStrings: ValueToStringMap = null,
-    ) {
-        this.Keys = Object.keys(this._obj)
-            .filter(k => typeof this._obj[k as any] === 'number');
-
-        this.Values = this.Keys.map(k => this._obj[k]);
-    }
-
-    keyToString(key: string, overrideMap: ValueToStringMap = null): string {
-        const map = overrideMap || this._valuesToStrings;
-        return map
-            ? map[this._obj[key]]
-            : key;
-    }
-
-    keyToValue(key: string): T {
-        const v = this._obj[key];
-        return v == null ? null : v as T;
-    }
-
-    valueToString(v: T, overrideMap: ValueToStringMap = null): string {
-        const map = overrideMap || this._valuesToStrings;
-        const custom = map && map[v];
-        return custom || this._obj[v];
-    }
-
-    validateValue(v: number | null): T | null {
-        if (v == null || Number.isNaN(v)) {
-            return null;
-        }
-        const i = this.Values.findIndex(vv => vv === v);
-        return i >= 0
-            ? this.Values[i]
-            : null;
-    }
-}
-
-export class EnumBitwiseHelper<T extends number> extends EnumHelper<T> {
-    toStrings(value: T, overrideMap: ValueToStringMap = null): string[] {
-        if (value == 0) {
-            return [this.valueToString(value, overrideMap)];
-        }
-
-        return this.Keys
-            .filter(k => this._obj[k] && this.contains(value, this._obj[k]))
-            .map(k => this.keyToString(k, overrideMap));
-    }
-
-    toString(value: T, separator = ', ', overrideMap: ValueToStringMap = null): string {
-        const strs = this.toStrings(value, overrideMap);
-        return strs.length === 0
-            ? this._obj[0]
-            : strs.join(separator);
-    }
-
-    contains(base: T, target: T) {
-        return this.intersection(base, target) === target;
-    }
-
-    combine(...values: T[]) {
-        let res = 0;
-        values.forEach(v => {
-            res = this.add(res as T, v);
-        });
-        return res;
-    }
-
-    add(value: T, other: T) {
-        return value | other;
-    }
-
-    intersection(v1: T, v2: T) {
-        return v1 & v2;
-    }
-
-    remove(value: T, other: T) {
-        return value & ~other;
-    }
-}

package/src/structures/helpers/name.ts

@@ -1,58 +0,0 @@
-
-export type DisplayName = { displayName: string };
-export type SplittedName = {
-    firstName: string,
-    lastName: string,
-};
-
-export type FullName = DisplayName & SplittedName;
-
-function splitDisplayName(name: Partial<DisplayName>): SplittedName {
-    if (!name || !name.displayName) {
-        return { firstName: '', lastName: '' };
-    }
-    const names = name.displayName.split(' ');
-    const first = names[0];
-    const last = names.slice(1).join(' ');
-
-    return {
-        firstName: first,
-        lastName: last,
-    };
-}
-
-export const NamesHelper = {
-
-    split(name: Partial<DisplayName>): SplittedName { return splitDisplayName(name); },
-    join(name: Partial<SplittedName>): DisplayName { return { displayName: `${name.firstName} ${name.lastName}` }; },
-
-    ensure(name: Partial<FullName>): FullName {
-        if (name.displayName && name.firstName && name.lastName) {
-            return name as FullName;
-        }
-
-        if (name.displayName) {
-            return {
-                displayName: name.displayName,
-                ...NamesHelper.split(name),
-            };
-        }
-
-        return {
-            ...NamesHelper.join(name),
-            firstName: name.firstName,
-            lastName: name.lastName,
-        };
-    },
-
-    ensureFromUsers(user: Partial<FullName>, authUser: Partial<DisplayName>) {
-        const n = {
-            firstName: user ? user.firstName : '',
-            lastName: user ? user.lastName : '',
-            displayName: (user && user.displayName) || (authUser && authUser.displayName) || '',
-        };
-        return NamesHelper.ensure(n);
-    },
-};
-
-export default NamesHelper;

package/src/structures/linkedList.ts

@@ -1,129 +0,0 @@
-
-export interface ILinkedListItem<T> {
-    readonly value: T;
-    readonly next?: ILinkedListItem<T> | undefined;
-    readonly prev?: ILinkedListItem<T> | undefined;
-
-    readonly position: number;
-
-    readonly list: LinkedList<T>;
-}
-
-export interface ILinkedList<T> extends Iterable<ILinkedListItem<T>> {
-    readonly root: ILinkedListItem<T> | undefined;
-    readonly last: ILinkedListItem<T> | undefined;
-
-    readonly length: number;
-
-    add(value: T): ILinkedListItem<T>;
-    remove(item: ILinkedListItem<T>): void;
-    removeLast(): void;
-    removeFirst(): void;
-    clear(): void;
-}
-
-interface LinkedListItem<T> extends ILinkedListItem<T> {
-    next?: LinkedListItem<T>;
-    prev?: LinkedListItem<T>;
-
-    position: number;
-
-    list: LinkedList<T>;
-}
-
-export class LinkedList<T> implements ILinkedList<T> {
-
-    private _root: LinkedListItem<T> = null;
-    private _last: LinkedListItem<T> = null;
-
-    private _length = 0;
-
-    get root(): ILinkedListItem<T> { return this._root; }
-    get last(): ILinkedListItem<T> { return this._last; }
-    get length() { return this._length; }
-
-    *[Symbol.iterator]() {
-        let current = this._root;
-        while (current) {
-            yield current;
-            current = current.next;
-        }
-    }
-
-    add(value: T) {
-        const next: LinkedListItem<T> = {
-            value: value,
-            list: this,
-            position: null,
-        };
-
-        this._length++;
-
-        if (!this.root || !this.last) {
-            next.position = 0;
-            this._root = this._last = next;
-        } else {
-            next.prev = this._last;
-            this._last.next = next;
-            this._last = next;
-            next.position = this._length - 1;
-        }
-
-        return this.last;
-    }
-
-    remove(item: ILinkedListItem<T>) {
-        if (!item || item.list !== this) {
-            return;
-        }
-
-        const itemInternal = item as LinkedListItem<T>;
-        const { next, prev } = itemInternal;
-        let removed = false;
-
-        if (next && next.prev === item) {
-            next.prev = prev;
-
-            if (this._root === item) {
-                this._root = next;
-            }
-
-            removed = true;
-        }
-
-        if (prev && prev.next === item) {
-            prev.next = next;
-
-            if (this._last === item) {
-                this._last = prev;
-            }
-
-            removed = true;
-        }
-
-        itemInternal.prev = itemInternal.next = null;
-        itemInternal.list = undefined;
-
-        if (removed) {
-            this._length--;
-        }
-    }
-
-    removeLast(): void {
-        this.remove(this._last);
-    }
-
-    removeFirst(): void {
-        this.remove(this._root);
-    }
-
-    clear(): void {
-        for (const item of this) {
-            item.next = item.prev = undefined;
-            item.list = undefined;
-        }
-
-        this._root = this._last = null;
-        this._length = 0;
-    }
-}