@zajno/common 1.6.2 → 2.0.0-beta.1

package/src/__tests__/transitionObserver.test.ts

@@ -1,219 +0,0 @@
-import { observable, runInAction } from 'mobx';
-import { TransitionObserver } from '../transitionObserver';
-
-function createStore<T>(value: T) {
-    const s = observable.object({
-        value: value,
-
-        setValue(v: T) {
-            runInAction(() => s.value = v);
-        },
-    });
-    return s;
-}
-
-describe('TransitionObserver', () => {
-
-    it('constructs', () => {
-        const store = createStore(true);
-
-        let err = null;
-        try {
-            const to1 = new TransitionObserver();
-            to1.observe(() => store.value);
-            to1.from('asd');
-            to1.to({});
-            to1.cb(() => { /* no-op */ });
-            to1.fireOnce();
-        } catch (_err) {
-            err = _err;
-        }
-
-        expect(err).toBeNull();
-    });
-
-    it('tracks only correct transition – 2 way', () => {
-        const store = createStore<boolean>(true);
-
-        const cb = jest.fn();
-
-        new TransitionObserver(() => store.value)
-            .from(true)
-            .to(false)
-            .cb(cb)
-            .fireOnce();
-
-        store.setValue(null);
-
-        expect(cb).not.toHaveBeenCalled();
-
-        store.setValue(false);
-
-        expect(cb).not.toHaveBeenCalled();
-
-        store.setValue(true);
-
-        expect(cb).not.toHaveBeenCalled();
-
-        store.setValue(false);
-
-        expect(cb).toHaveBeenCalledWith(false);
-    });
-
-    it('tracks only correct transition – from', () => {
-        const store = createStore<boolean>(true);
-
-        const cb = jest.fn();
-
-        const to = new TransitionObserver(() => store.value)
-            .from(true)
-            .cb(cb);
-
-        store.setValue(null);
-
-        expect(cb).toHaveBeenCalledWith(null);
-        cb.mockReset();
-
-        store.setValue(false);
-
-        expect(cb).not.toHaveBeenCalled();
-        cb.mockReset();
-
-        store.setValue(true);
-
-        expect(cb).not.toHaveBeenCalled();
-        cb.mockReset();
-
-        store.setValue(false);
-
-        expect(cb).toHaveBeenCalledWith(false);
-        cb.mockReset();
-
-        to.dispose();
-    });
-
-    it('tracks only correct transition – to', () => {
-        const store = createStore<boolean>(true);
-
-        const cb = jest.fn();
-
-        const to = new TransitionObserver(() => store.value)
-            .to(false)
-            .cb(cb);
-
-        store.setValue(null);
-
-        expect(to.currentValue).toBeNull();
-        expect(cb).not.toHaveBeenCalled();
-        cb.mockReset();
-
-        store.setValue(false);
-
-        expect(to.currentValue).toBeFalsy();
-        expect(cb).toHaveBeenCalledWith(false);
-        cb.mockReset();
-
-        store.setValue(true);
-
-        expect(to.currentValue).toBeTruthy();
-        expect(cb).not.toHaveBeenCalled();
-        cb.mockReset();
-
-        store.setValue(false);
-
-        expect(cb).toHaveBeenCalledWith(false);
-        cb.mockReset();
-
-        to.dispose();
-    });
-
-    it('tracks only correct transition – <any>', () => {
-        const store = createStore<boolean>(true);
-
-        const cb = jest.fn();
-        const cbE = jest.fn();
-
-        const to = new TransitionObserver(() => store.value)
-            .cb(cb);
-
-        to.event.on(cbE);
-
-        store.setValue(null);
-
-        expect(cbE).toHaveBeenCalledWith(null);
-        expect(cb).toHaveBeenCalledWith(null);
-        cbE.mockReset();
-        cb.mockReset();
-
-        to.forceCheck();
-
-        expect(cbE).toHaveBeenCalledWith(null);
-        expect(cb).toHaveBeenCalledWith(null);
-        cbE.mockReset();
-        cb.mockReset();
-
-        to.forceCall();
-
-        expect(cb).toHaveBeenCalledWith(null);
-        cb.mockReset();
-
-        store.setValue(false);
-
-        expect(cbE).toHaveBeenCalledWith(false);
-        expect(cb).toHaveBeenCalledWith(false);
-        cbE.mockReset();
-        cb.mockReset();
-
-        store.setValue(true);
-
-        expect(cbE).toHaveBeenCalledWith(true);
-        expect(cb).toHaveBeenCalledWith(true);
-        cbE.mockReset();
-        cb.mockReset();
-
-        to.dispose();
-        store.setValue(false);
-
-        expect(cbE).not.toHaveBeenCalled();
-        expect(cb).not.toHaveBeenCalled();
-    });
-
-    it('promises 2 times', async () => {
-
-        const store = createStore<boolean>(true);
-        const cb = jest.fn();
-
-        const to = new TransitionObserver(() => store.value)
-            .to(false)
-            .cb(cb);
-
-        for (let i = 1; i <= 2; ++i) {
-            store.setValue(true);
-
-            const p = to.getPromise();
-
-            store.setValue(false);
-
-            await expect(p).resolves.toBe(false);
-            expect(cb).not.toHaveBeenCalled();
-            cb.mockReset();
-        }
-    });
-
-    it('promising – aborting', async () => {
-
-        const store = createStore<boolean>(true);
-        const cb = jest.fn();
-
-        const to = new TransitionObserver(() => store.value)
-            .to(false)
-            .cb(cb);
-
-        const p = to.getPromise();
-
-        to.dispose();
-
-        await expect(p).rejects.toThrow(/Aborted/);
-        expect(cb).not.toHaveBeenCalled();
-    });
-});

package/src/cache.ts

@@ -1,181 +0,0 @@
-import { observable, makeObservable, runInAction, action } from 'mobx';
-import { NumberModel } from './viewModels/NumberModel';
-import { createLogger, ILogger } from './logger';
-
-export type DeferredGetter<T> = {
-    readonly current: T;
-    readonly promise: Promise<T>;
-    readonly busy: boolean;
-};
-
-export namespace DeferredGetter {
-    const _resolvedPromise = Promise.resolve<undefined>(undefined);
-    export const Empty = {
-        get current(): undefined { return undefined; },
-        get promise(): Promise<undefined> { return _resolvedPromise; },
-        get busy() { return undefined; },
-        isEmpty: true,
-    } as DeferredGetter<null>;
-}
-
-export class PromiseCache<T, K = string> {
-
-    @observable.shallow
-    private readonly _itemsCache: Record<string, T> = { };
-
-    @observable
-    private readonly _itemsStatus: Record<string, boolean> = { };
-
-    private readonly _fetchCache: Record<string, Promise<T>> = { };
-
-    private _logger: ILogger = null;
-    private _observeItems = false;
-
-    private readonly _busyCount = new NumberModel(0);
-
-    constructor(
-        readonly fetcher: (id: K) => Promise<T>,
-        readonly keyAdapter?: K extends string ? null : (k: K) => string,
-        readonly keyParser?: K extends string ? null : (id: string) => K,
-        observeItems = false,
-    ) {
-        makeObservable(this);
-        this._observeItems = observeItems;
-    }
-
-    public get busyCount() { return this._busyCount.value; }
-
-    useObserveItems(observeItems: boolean) {
-        this._observeItems = observeItems;
-        return this;
-    }
-
-    private _pk(k: K): string {
-        if (k == null) {
-            throw new Error('PromiseCache: null keys are not supported');
-        }
-
-        if (typeof k === 'string') {
-            return k;
-        }
-
-        if (!this.keyAdapter) {
-            throw new Error('Provide key adapter for non-string keys');
-        }
-
-        return this.keyAdapter(k);
-    }
-
-    useLogger(name?: string) {
-        this._logger = createLogger(`[PromiseCache:${name || '?'}]`);
-        return this;
-    }
-
-    getDeferred(key: K): DeferredGetter<T> {
-        const self = this;
-        return {
-            get current() { return self.getCurrent(key); },
-            get promise() { return self.get(key); },
-            get busy() { return self.getIsBusy(key); },
-        };
-    }
-
-    getIsBusy(id: K): boolean {
-        const key = this._pk(id);
-        return this._itemsStatus[key];
-    }
-
-    getCurrent(id: K, initiateFetch = true): T {
-        const key = this._pk(id);
-        const item = this._itemsCache[key];
-        if (initiateFetch) {
-            this.get(id);
-        }
-        this._logger?.log(key, 'getCurrent returns', item);
-        return item;
-    }
-
-    get(id: K): Promise<T> {
-        const key = this._pk(id);
-        const item = this._itemsCache[key];
-        if (item !== undefined) {
-            this._logger?.log(key, 'item resolved to', item);
-            return Promise.resolve(item);
-        }
-
-        let promise = this._fetchCache[key];
-        if (promise) {
-            this._logger?.log(key, 'item resolved to <promise>');
-            return promise;
-        }
-
-        runInAction(() => this._itemsStatus[key] = true);
-        promise = this._doFetchAsync(id, key);
-
-        runInAction(() => this._fetchCache[key] = promise);
-        return promise;
-    }
-
-    private _doFetchAsync = async (id: K, key: string) => {
-        try {
-            this._busyCount.increment();
-            const res = await this.fetcher(id);
-            if (this._fetchCache[key]) {
-                this._logger?.log(key, 'item\'s <promise> resolved to', res);
-                const result = res
-                    ? (this._observeItems ? observable.object(res) : res)
-                    : null;
-                runInAction(() => this._itemsCache[key] = result);
-            }
-            return res;
-        } finally {
-            runInAction(() => {
-                this._busyCount.decrement();
-                delete this._fetchCache[key];
-                this._itemsStatus[key] = false;
-            });
-        }
-    };
-
-    invalidate(id: K) {
-        const key = this._pk(id);
-        this._set(key, undefined, undefined, undefined);
-    }
-
-    updateValueDirectly(id: K, value: T) {
-        const key = this._pk(id);
-        this._set(key, value, undefined, undefined);
-    }
-
-    hasKey(id: K) {
-        const key = this._pk(id);
-        return this._itemsCache[key] !== undefined || this._itemsStatus[key] !== undefined;
-    }
-
-    keys() {
-        return Object.keys(this._itemsCache);
-    }
-
-    keysParsed() {
-        if (!this.keyParser) {
-            return null;
-        }
-
-        return this.keys().map(this.keyParser);
-    }
-
-    @action
-    private _set(key: string, item: T, promise: Promise<T>, busy: boolean) {
-        _setX(key, this._fetchCache, promise);
-        _setX(key, this._itemsStatus, busy);
-        _setX(key, this._itemsCache, item);
-    }
-}
-
-function _setX<T>(key: string, obj: Record<string, T>, val: T) {
-    if (val === undefined) {
-        delete obj[key];
-    } else {
-        obj[key] = val;
-    }
-}

package/src/deepPartial.ts

@@ -1,4 +0,0 @@
-
-export type DeepPartial<T> = {
-    [P in keyof T]?: DeepPartial<T[P]>;
-};

package/src/functions.ts

@@ -1,14 +0,0 @@
-
-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];
-};
-
-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/lazy/index.ts

@@ -1,33 +0,0 @@
-
-import { LazyObservable, LazyPromiseObservable } from './observable';
-import logger from '../logger';
-
-// Backward compatibility stuff ...
-
-class LazyObservableWarned<T> extends LazyObservable<T> {
-
-    constructor(factory: () => T) {
-        super(factory);
-
-        logger.log('@zajno/common/lazy: you are using LazyObservable but imported just as Lazy. To avoid this warning import LazyObservable directly from lazy/observable or use non-observable version from lazy/singleton.');
-    }
-
-}
-
-class LazyPromiseObservableWarned<T> extends LazyPromiseObservable<T> {
-
-    constructor(factory: () => Promise<T>, initial?: T) {
-        super(factory, initial);
-
-        logger.log('@zajno/common/lazy: you are using LazyPromiseObservableWarned but imported just as LazyPromise. To avoid this warning import LazyPromiseObservable directly from lazy/observable or use non-observable version from lazy/promise.');
-    }
-
-}
-
-export default LazyObservableWarned;
-
-// In future versions make these imports straight
-export {
-    LazyObservableWarned as Lazy,
-    LazyPromiseObservableWarned as LazyPromise,
-};

package/src/lazy/observable.ts

@@ -1,37 +0,0 @@
-import { Lazy } from './singleton';
-import { LazyPromise } from './promise';
-import { observable, makeObservable, action } from 'mobx';
-
-export class LazyObservable<T> extends Lazy<T> {
-
-    constructor(factory: (() => T)) {
-        super(factory);
-
-        makeObservable<Lazy<T>, '_instance' | 'ensureInstance'>(this, {
-            _instance: observable,
-            reset: action,
-            ensureInstance: action,
-        });
-    }
-}
-
-export class LazyPromiseObservable<T> extends LazyPromise<T> {
-
-    constructor(
-        factory: () => Promise<T>,
-        initial?: T,
-    ) {
-        super(factory, initial);
-
-        makeObservable<
-            LazyPromise<T>,
-            '_instance' | '_busy' | 'setInstance' | 'ensureInstanceLoading'
-        >(this, {
-            _instance: observable.ref,
-            _busy: observable,
-            setInstance: action,
-            ensureInstanceLoading: action,
-            reset: action,
-        });
-    }
-}

package/src/lazy.light.ts

@@ -1,8 +0,0 @@
-
-// DEPRECATED MODULE. Delete in future versions
-
-import logger from './logger';
-
-export * from './lazy/light';
-
-logger.warn('@zajno/common: importing module "lazy.light" is deprecated; please change your import to "lazy/light" module.');

package/src/observersMap.ts

@@ -1,105 +0,0 @@
-import { createLogger, ILogger } from './logger';
-import { combineDisposers, IDisposable } from './disposer';
-import { NumberModel } from './viewModels/NumberModel';
-
-type Unsub = () => void;
-
-export class ObserversMap implements IDisposable {
-    /** Unsusbcrobers map: key => unsub fn */
-    private readonly _map = new Map<string, () => void>();
-    /** Timeouts map: key => timeout handle */
-    private readonly _timeouts = new Map<string, any>();
-
-    private readonly _logger: ILogger = null;
-    private readonly _count = new NumberModel();
-
-    constructor(readonly subscribe: null | ((key: string) => Promise<Unsub[]>), readonly name?: string) {
-        this._logger = createLogger(`[Observers:${this.name || '?'}]`);
-    }
-
-    public get count() { return this._count.value; }
-
-    public getIsObserving(key: string) {
-        return this._map.has(key);
-    }
-
-    public getHasObserveTimeout(key: string) {
-        return this.getIsObserving(key) && this._timeouts.has(key);
-    }
-
-    public async enable(key: string, enable: boolean, clearAfter: number = null, existingUnsubs: Unsub[] = null) {
-        if (enable === this.getIsObserving(key)) {
-            this.refreshTimeout(key, enable, clearAfter, true);
-            return;
-        }
-
-        if (enable) {
-            this._logger.log('Adding observer for key =', key, clearAfter ? `, clearAfter = ${clearAfter}` : '');
-
-            // this marker will help to determine whether unsubscribe was requested while we were in process of subscribing
-            let disabed = false;
-            const marker = () => { disabed = true; };
-
-            this._map.set(key, marker);
-
-            if (!this.subscribe && !existingUnsubs) {
-                throw new Error('Neither subscribe function nor existingUnsubs has been configured');
-            }
-
-            const unsubs = existingUnsubs || await this.subscribe(key);
-            const result = combineDisposers(...unsubs);
-
-            if (disabed) { // unsubscribe was requested
-                result();
-            } else {
-                this._map.set(key, result);
-                this._count.increment();
-                this.refreshTimeout(key, true, clearAfter);
-            }
-        } else {
-            this._logger.log('Removing observer for key =', key);
-            this.refreshTimeout(key, false);
-            const unsub = this._map.get(key);
-            this._map.delete(key);
-            unsub();
-            this._count.decrement();
-        }
-    }
-
-    private refreshTimeout(key: string, enable: boolean, timeout?: number, refresh = false) {
-        const current = this._timeouts.get(key);
-        if (current) {
-            clearTimeout(current);
-            this._timeouts.delete(key);
-        }
-
-        if (enable && refresh && current == null) {
-            // DO NOT setup new timeout because it's not intended to clear subscribtion if it was previously enabled for long term
-            return;
-        }
-
-        if (enable && timeout) {
-            const t = setTimeout(() => this.enable(key, false), timeout);
-            this._timeouts.set(key, t);
-        }
-    }
-
-    public clear() {
-        // Clear timeouts
-        for (const t of this._timeouts.values()) {
-            clearTimeout(t);
-        }
-        this._timeouts.clear();
-
-        // Invoke unsubscribers
-        for (const u of this._map.values()) {
-            u();
-        }
-        this._map.clear();
-        this._count.setValue(0);
-    }
-
-    public dispose() {
-        this.clear();
-    }
-}