@zajno/common 2.0.2 → 2.0.4

package/src/fields/__tests__/fields.update.test.ts

@@ -1,73 +0,0 @@
-import { updateArray } from '../update';
-
-describe('fields/update', () => {
-    it('empty input', () => {
-        expect(updateArray(null, null)).toStrictEqual({ changed: 0, result: null });
-    });
-
-    it('updates primitives | numbers', () => {
-        const target = [1, 5, 3];
-        const source = [4, 3, 2];
-
-        const results1 = updateArray(target, source, { clone: true });
-        expect(results1.changed).toBe(4);
-        expect(results1.result).toStrictEqual([2, 3, 4]);
-
-        const results2 = updateArray(target, source, { sorter: null });
-        expect(results2.changed).toBe(4);
-        expect(results2.result).toStrictEqual([3, 4, 2]);
-    });
-
-    it('updates primitives | strings', () => {
-        const target = ['a', 'b', 'c'];
-        const source = ['b', 'c', 'd'];
-
-        const results = updateArray(target, source);
-
-        expect(results.changed).toBe(2);
-        expect(results.result).toStrictEqual(source);
-    });
-
-    describe('updates objects', () => {
-        it('no options', () => {
-            const res = updateArray([
-                { id: 1, v: 'a' },
-                { id: 5, v: 'e' },
-                { id: 3, v: 'c' },
-            ], [
-                { id: 2, v: 'b' },
-            ]);
-
-            expect(res.changed).toBe(4);
-            expect(res.result).toStrictEqual([
-                { id: 2, v: 'b' },
-            ]);
-        });
-
-        // eslint-disable-next-line jest/expect-expect
-        it('full options', () => {
-            const res = updateArray([
-                { id: 1, v: 'a' },
-                { id: 5, v: 'e' },
-                { id: 3, v: 'c' },
-            ], [
-                { id: 2, v: 'b' },
-                { id: 1, v: '1K' },
-            ], {
-                clone: true,
-                comparator: (v1, v2) => v1.id === v2.id,
-                updater: (t, s) => {
-                    t.v = s.v + '_' + t.id;
-                    return t;
-                },
-                sorter: (v1, v2) => v1.id - v2.id,
-            });
-
-            expect(res.changed).toBe(3);
-            expect(res.result).toStrictEqual([
-                { id: 1, v: '1K_1' },
-                { id: 2, v: 'b' },
-            ]);
-        });
-    });
-});

package/src/fields/filter.ts

@@ -1,27 +0,0 @@
-
-export type FieldFilter<T> = (value: T[keyof T]) => boolean;
-
-export function filterFields<T>(source: Partial<T>, ...fields: ((keyof T) | { key: keyof T, filter: FieldFilter<T>})[]): Partial<T> {
-    const res: Partial<T> = { };
-
-    fields.forEach(k => {
-        if (typeof k === 'object') {
-            const v = source[k.key];
-            if (k.filter(v)) {
-                res[k.key] = v;
-            }
-        } else {
-            const v = source[k];
-            if (v) {
-                res[k] = v;
-            }
-        }
-    });
-
-    return res;
-}
-
-export namespace filterFields {
-    export function Truethy<T>(): FieldFilter<T> { return (v) => !!v; }
-    export function NotNull<T>(): FieldFilter<T> { return v => v != null; }
-}

package/src/fields/index.ts

@@ -1,4 +0,0 @@
-
-export * from './filter';
-export * from './update';
-export * from './transfer';

package/src/fields/transfer.ts

@@ -1,85 +0,0 @@
-
-export function transferFields<T>(
-    source: T,
-    predicate: (f: keyof T, v: T[keyof T]) => boolean,
-    destination: Partial<T>,
-    ...fields: (keyof T)[]
-): number {
-    let count = 0;
-    fields.forEach(f => {
-        const v = source[f];
-        if (!predicate || predicate(f, v)) {
-            destination[f] = v;
-            ++count;
-        }
-    });
-
-    return count;
-}
-
-export namespace transferFields {
-    export function truthy<T>(
-        source: T,
-        destination: Partial<T>,
-        ...fields: (keyof T)[]
-    ): number {
-        return transferFields(source, (f, v) => !!v, destination, ...fields);
-    }
-
-    export function notNull<T>(
-        source: T,
-        destination: Partial<T>,
-        ...fields: (keyof T)[]
-    ): number {
-        return transferFields(source, (f, v) => v != null, destination, ...fields);
-    }
-
-    export function defined<T>(
-        source: T,
-        destination: Partial<T>,
-        ...fields: (keyof T)[]
-    ): number {
-        return transferFields(source, (f, v) => v !== undefined, destination, ...fields);
-    }
-
-    export function changed<T>(
-        source: T,
-        compare: T,
-        destination: Partial<T>,
-        ...fields: (keyof T)[]
-    ): number {
-        return transferFields(
-            source,
-            (f, v) => v !== undefined && source[f] !== compare[f],
-            destination,
-            ...fields
-        );
-    }
-}
-
-export function hasChangedFields<T>(left: T, right: T, ...fields: (keyof T)[]) {
-    return fields.some(f => left[f] !== right[f]);
-}
-
-type ExtractChangedFieldsResult<T> = {
-    transferred: number;
-    result: Partial<T>;
-};
-
-export function extractChangedFields<T>(
-    source: Partial<T>,
-    image: T,
-    ...fields: (keyof T)[]
-): ExtractChangedFieldsResult<T> {
-    const res: Partial<T> = {};
-    const count = transferFields<Partial<T>>(
-        source,
-        (f, v) => v !== undefined && v !== image[f],
-        res,
-        ...fields
-    );
-    return {
-        transferred: count,
-        result: res,
-    };
-}

package/src/fields/update.ts

@@ -1,124 +0,0 @@
-import { safeCall } from '../functions/safeCall';
-import { Comparator } from '../types';
-
-export namespace Fields {
-    export type Getter<T> = (obj: Partial<T>) => T[keyof T];
-    export type Setter<T> = (obj: Partial<T>, val: T[keyof T]) => void;
-    export type Comparer<T> = (source: Partial<T>, target: Partial<T>) => boolean;
-    export type Updater<T> = (target: T, source: T) => T;
-}
-
-
-export function updateField<T>(target: T, source: Partial<T>, diff: Partial<T>, key: keyof T, hasChanged: null | Fields.Comparer<T> = null): boolean {
-    return updateFieldExtended(target, source, diff, t => t[key], (t, v) => t[key] = v, hasChanged);
-}
-
-export function updateFieldExtended<T>(
-    target: T,
-    source: Partial<T>,
-    diff: Partial<T>,
-    get: Fields.Getter<T>,
-    set: Fields.Setter<T>,
-    hasChanged: null | Fields.Comparer<T> = null,
-): boolean {
-
-    hasChanged = hasChanged || ((v1: T, v2: T) => (get(v1) !== get(v2)));
-
-    let changed = true;
-
-    if (get(source) !== undefined && hasChanged(source, target)) {
-        changed = true;
-        set(diff, get(target));
-        set(target, get(source));
-    }
-
-    return changed;
-
-}
-
-const DefaultComparator: Comparator<any> = (v1, v2) => v1 === v2;
-const DefaultUpdater: Fields.Updater<any> = (v1, v2) => Object.assign(v1, v2);
-
-export type UpdateArrayOptions<T> = {
-    additive?: boolean,
-    unshift?: boolean,
-    clone?: boolean,
-    comparator?: Comparator<T>,
-    updater?: Fields.Updater<T>,
-    sorter?: Comparator<T, number> | null | undefined,
-    hooks?: UpdateArrayHooks<T>,
-};
-
-export type UpdateArrayHooks<T> = {
-    onAdded?: (item: T, index?: number) => void,
-    onDeleted?: (item: T, index?: number) => void,
-    onUpdated?: (previous: T, next: T, index?: number) => void,
-};
-
-export function updateArray<T>(
-    target: T[] | null,
-    source: T[] | null,
-    options?: UpdateArrayOptions<T>,
-): { changed: number, result: T[] } {
-    if (!source) {
-        return { changed: 0, result: target };
-    }
-
-    let changed = 0;
-    const result = Array.isArray(target)
-        ? (options?.clone ? target.slice() : target)
-        : [];
-
-    const comparator = options?.comparator || DefaultComparator;
-    const updater = options?.updater || DefaultUpdater;
-    const onDeleted = options?.hooks?.onDeleted;
-    const onUpdate = options?.hooks?.onUpdated;
-    const onAdded = options?.hooks?.onAdded;
-
-    // remove all missing elements
-    if (!options?.additive) {
-        for (let i = 0; i < result.length; ++i) {
-            if (source.find(item => comparator(item, result[i])) == null) {
-                // DELETE
-                const removed = result.splice(i, 1);
-                safeCall(onDeleted, removed[0], i);
-
-                ++changed;
-                --i;
-            }
-        }
-    }
-
-    const unshift = options?.unshift || false;
-
-    // add all new elements and update existing
-    source.forEach(item => {
-        const existingIndex = result.findIndex(i => comparator(item, i));
-        const existingItem = result[existingIndex];
-        if (existingIndex < 0) {
-            if (unshift) {
-                result.unshift(item);
-            } else {
-                result.push(item);
-            }
-            safeCall(onAdded, item, unshift ? 0 : result.length - 1);
-            ++changed;
-        } else if (typeof existingItem === 'object') {
-            const before = onUpdate != null ? { ...existingItem } : undefined;
-            result[existingIndex] = updater(existingItem, item);
-            if (onUpdate != null) {
-                onUpdate(before!, result[existingIndex], existingIndex);
-            }
-        }
-    });
-
-    const sorter = options?.sorter;
-    if (sorter !== null) {
-        result.sort(sorter || undefined);
-    }
-
-    return {
-        result,
-        changed,
-    };
-}

package/src/functions/assert.ts

@@ -1,19 +0,0 @@
-import { Getter } from '../types';
-import logger from '../logger';
-
-export function assert(condition: boolean, error: Getter<string | Error>, objectToLog?: Getter<any>): asserts condition {
-    if (condition) {
-        return;
-    }
-
-    const e = Getter.getValue(error);
-    if (objectToLog) {
-        logger.error('Assertion failed:', e, Getter.getValue(objectToLog));
-    }
-
-    if (typeof e === 'string') {
-        throw new Error(e);
-    }
-
-    throw e;
-}

package/src/functions/disposer.ts

@@ -1,97 +0,0 @@
-import logger from '../logger';
-
-export interface IDisposable {
-    dispose(): void;
-}
-
-export interface DisposeFunction {
-    (): void;
-}
-
-export class Disposer {
-
-    private readonly _disposers: DisposeFunction[] = [];
-    private readonly _map = new Map<string, DisposeFunction>();
-
-    private _loggerName: string = null;
-
-    constructor(loggerName: string = null) {
-        this._loggerName = loggerName;
-    }
-
-    public setLoggerName(loggerName: string) {
-        this._loggerName = loggerName;
-        return this;
-    }
-
-    public add(d: DisposeFunction | IDisposable, id?: string) {
-        if (!d) {
-            return;
-        }
-
-        const dd: DisposeFunction = typeof d !== 'function'
-            ? (() => d.dispose ? d.dispose() : null)
-            : d;
-
-        this._disposers.push(dd);
-
-        if (id) {
-            // dispose previous identified disposer
-            if (this._map.has(id)) {
-                this.execute(id);
-            }
-
-            this._map.set(id, dd);
-        }
-    }
-
-    public execute(id: string) {
-        const d = this._map.get(id);
-        if (!d) {
-            return;
-        }
-
-        this._map.delete(id);
-        const i = this._disposers.indexOf(d);
-        if (i >= 0) {
-            this._disposers.splice(i, 1);
-        }
-
-        d();
-    }
-
-    public dispose(log = false) {
-        if (log) {
-            logger.log(
-                `[Disposer:${this._loggerName || '<unknown>'}] Disposing ${this._disposers.length} items including named ones:`,
-                Array.from(this._map.entries()).map(e => e[0]),
-            );
-        }
-
-        const copy = this._disposers.slice().reverse();
-        this._disposers.length = 0;
-        this._map.clear();
-
-        // this should separate side effects
-        copy.forEach(d => d());
-    }
-}
-
-export function combineDisposers(...items: DisposeFunction[]): DisposeFunction {
-    return () => items.forEach(i => i());
-}
-
-export class Disposable implements IDisposable {
-
-    protected readonly disposer: Disposer;
-    protected _isDisposed = false;
-
-    constructor(loggerName: string = null) {
-        this.disposer = new Disposer(loggerName);
-    }
-
-    public dispose = () => {
-        this._isDisposed = true;
-        this.disposer.dispose();
-    };
-}

package/src/functions/safeCall.ts

@@ -1,6 +0,0 @@
-
-export function safeCall<T extends (...args: any) => any>(cb: T | undefined, ...args: Parameters<T>): ReturnType<T> | void {
-    if (cb) {
-        return cb.apply(null, args);
-    }
-}

package/src/functions/throttle.ts

@@ -1,96 +0,0 @@
-import logger from '../logger';
-
-export class ThrottleAction<T = any> {
-
-    private _timeoutRef: any = null;
-    private _postponedCb: () => (T | Promise<T>) = null;
-    private _locked = false;
-
-    private _resolvers: (() => void)[] = [];
-
-    constructor(public timeout = 1000) {}
-
-    clear() {
-        clearTimeout(this._timeoutRef);
-        this._timeoutRef = null;
-        this._postponedCb = null;
-    }
-
-    tryRun(cb: () => T | Promise<T>, restartTimeout = false) {
-        if (!this._timeoutRef) {
-            this._postponedCb = cb;
-            this._timeoutRef = setTimeout(this.forceRun, this.timeout);
-            // logger.log('THROTTLE setTimeout', this.timeout);
-        } else if (restartTimeout) {
-            this.clear();
-            this.tryRun(cb);
-        }
-    }
-
-    forceRun = async () => {
-        const cb = this._postponedCb;
-        this.clear();
-
-        if (this._locked) {
-            logger.warn('THROTTLE LOCKED');
-        } else if (cb) {
-            try {
-                this._locked = true;
-                return await cb();
-            } finally {
-                this._locked = false;
-
-                const resolvers = this._resolvers.slice();
-                this._resolvers.length = 0;
-                // logger.log('getPromise: resolving', resolvers.length);
-                resolvers.forEach(r => r());
-            }
-        }
-    };
-
-    getPromise() {
-        if (!this._locked && !this._timeoutRef) {
-            // logger.log('getPromise: nothing to wait for');
-            return Promise.resolve();
-        }
-
-        return new Promise<void>(resolve => {
-            // logger.log('getPromise: adding resolver');
-            this._resolvers.push(resolve);
-        });
-    }
-}
-
-export class ThrottleProcessor<TSubject> {
-
-    private readonly _queue: TSubject[] = [];
-    private readonly _action: ThrottleAction = null;
-
-    constructor(readonly process: (objs: TSubject[]) => Promise<any>, timeout = 1000) {
-        if (!process) {
-            throw new Error('Arg0 expected: process');
-        }
-
-        this._action = new ThrottleAction(timeout);
-    }
-
-    push(data: TSubject) {
-        this._queue.push(data);
-
-        this._action.tryRun(this._process, true);
-    }
-
-    private _process = async () => {
-        if (!this._queue.length) {
-            return;
-        }
-
-        const objs = this._queue.slice();
-        this._queue.length = 0;
-        await this.process(objs);
-    };
-
-    clear() {
-        this._action.clear();
-    }
-}

package/src/lazy/__tests__/lazy.test.ts

@@ -1,48 +0,0 @@
-import { Lazy } from '../singleton';
-import { LazyPromise } from '../promise';
-import { setTimeoutAsync } from '../../async/timeout';
-
-import '../../__tests__/helpers/expect';
-
-describe('Lazy', () => {
-    it('simple', () => {
-        const VAL = 'abc';
-        const l = new Lazy(() => VAL);
-
-        expect(l.hasValue).toBeFalse();
-        expect(l.value).toBe(VAL);
-        expect(l.hasValue).toBeTrue();
-
-        l.reset();
-        expect(l.hasValue).toBeFalse();
-
-        l.prewarm();
-
-        expect(l.hasValue).toBeTrue();
-        expect(l.value).toBe(VAL);
-    });
-});
-
-describe('LazyPromise', () => {
-
-    it('simple', async () => {
-        const VAL = 'abc';
-        const l = new LazyPromise(() => setTimeoutAsync(100).then(() => VAL));
-
-        expect(l.hasValue).toBeFalse();
-        expect(l.busy).toBeFalse();
-
-        expect(l.value).toBeUndefined();
-        expect(l.busy).toBeTrue();
-
-        await expect(l.promise).resolves.not.toThrow();
-
-        expect(l.hasValue).toBeTrue();
-        expect(l.busy).toBeFalse();
-        expect(l.value).toBe(VAL);
-
-        l.dispose();
-        expect(l.hasValue).toBeFalse();
-    });
-
-});

package/src/lazy/light.ts

@@ -1,29 +0,0 @@
-import type { IDisposable } from '../functions/disposer';
-
-export type LazyLight<T> = IDisposable & {
-    readonly value: T;
-    readonly hasValue: boolean;
-
-    reset(): void;
-};
-
-export function createLazy<T>(factory: () => T) {
-    const _factory = factory;
-    let _instance: T = undefined;
-
-    const res: LazyLight<T> = {
-        get value() {
-            if (_instance === undefined) {
-                _instance = _factory();
-            }
-            return _instance;
-        },
-        get hasValue() { return _instance !== undefined; },
-        reset: () => {
-            _instance = undefined;
-        },
-        dispose: () => res.reset(),
-    };
-
-    return res;
-}

package/src/lazy/promise.ts

@@ -1,52 +0,0 @@
-import type { IDisposable } from '../functions/disposer';
-
-export class LazyPromise<T> implements IDisposable {
-
-    private _instance: T = undefined;
-    private _busy: boolean = null;
-
-    private _promise: Promise<T> = null;
-
-    constructor(
-        private readonly _factory: () => Promise<T>,
-        private readonly initial: T = undefined,
-    ) {
-        this._instance = initial;
-    }
-
-    get busy() { return this._busy || false; }
-    get hasValue() { return this._busy === false; }
-
-    get promise() {
-        this.ensureInstanceLoading();
-        return this._promise;
-    }
-
-    get value() {
-        this.ensureInstanceLoading();
-        return this._instance;
-    }
-
-    protected ensureInstanceLoading() {
-        if (this._busy === null) {
-            this._busy = true;
-            this._promise = this._factory();
-            this._promise.then(this.setInstance);
-        }
-    }
-
-    private setInstance = (res: T) => {
-        this._busy = false;
-        this._instance = res || null;
-
-        // keep this._promise to allow to re-use it outside
-    };
-
-    reset() {
-        this._busy = null;
-        this._instance = this.initial;
-        this._promise = null;
-    }
-
-    dispose = () => this.reset();
-}

package/src/lazy/singleton.ts

@@ -1,32 +0,0 @@
-import type { IDisposable } from '../functions/disposer';
-
-export class Lazy<T> implements IDisposable {
-
-    protected _instance: T = null;
-
-    constructor(protected readonly _factory: (() => T)) { }
-
-    get hasValue() { return this._instance !== null; }
-
-    get value() {
-        this.ensureInstance();
-        return this._instance;
-    }
-
-    private ensureInstance() {
-        if (this._instance === null) {
-            this._instance = this._factory();
-        }
-    }
-
-    prewarm() {
-        this.ensureInstance();
-        return this;
-    }
-
-    reset() {
-        this._instance = null;
-    }
-
-    dispose() { this.reset(); }
-}