@zajno/common 1.6.3 → 2.0.0-beta.2

package/src/viewModels/TextModel.ts

@@ -1,127 +0,0 @@
-import { observable, makeObservable, reaction, action } from 'mobx';
-import { Getter } from '../types';
-import { IValueModel } from './types';
-import logger from '../logger';
-import { ValidatableModel } from './Validatable';
-import { IResetableModel } from 'viewModels';
-
-export type TextInputConfig = {
-    name?: Getter<string>;
-    title?: Getter<string>;
-    value?: Getter<string>;
-    async?: boolean;
-
-    noSubscribe?: boolean;
-};
-
-function FromGetter(getter: Getter<string>, setter: (val: string) => void, autorunDelay: number = null, noAutorun: boolean = null) {
-    if (noAutorun || typeof getter !== 'function') {
-        setter(Getter.getValue(getter));
-        return null;
-    }
-
-    return reaction(
-        () => Getter.getValue(getter),
-        setter,
-        { delay: autorunDelay, fireImmediately: true },
-    );
-}
-
-export class Text {
-    @observable
-    private _value: string = null;
-
-    constructor(config: { value: Getter<string>, async?: boolean, noSubscribe?: boolean }) {
-        makeObservable(this);
-        FromGetter(config.value, val => this._value = val, config.async ? 100 : null, config.noSubscribe);
-    }
-
-    get value() { return this._value; }
-}
-
-export class TextInputVM extends ValidatableModel<string> implements IValueModel<string>, IResetableModel {
-    // @observable
-    private _value = '';
-
-    // @observable
-    private _focused = false;
-
-    private _name: string = null;
-    private _title: string = null;
-
-    private readonly _valueObserving: () => void = null;
-
-    constructor(config?: TextInputConfig) {
-        super();
-        makeObservable<TextInputVM, '_value' | '_focused'>(this, {
-            _value: observable,
-            _focused: observable,
-            setValue: action,
-            setFocused: action,
-        });
-        config = config || {};
-
-        const delay = config.async ? 100 : null;
-
-        FromGetter(config.name, val => this._name = val, delay);
-        FromGetter(config.title, val => this._title = val, delay);
-        this._valueObserving = FromGetter(config.value, val => this._value = val, delay);
-    }
-
-    get value() { return this._value; }
-    get name() { return this._name; }
-    get title() { return this._title; }
-
-    set value(val) {
-        this.setValue(val);
-    }
-
-    // @action
-    public readonly setValue = (value: string) => {
-        if (!this._valueObserving) {
-            this._value = value;
-
-            if (this._validateOnChange) {
-                this.validate();
-            }
-        } else {
-            logger.warn('[TextInputViewModel] Setting value is not allowed when value is observing');
-        }
-    };
-
-    get isEmpty() {
-        return !this._value;
-    }
-
-    get focused() {
-        return this._focused;
-    }
-
-    set focused(val: boolean) {
-        this.setFocused(val);
-    }
-
-    // @action
-    public readonly setFocused = (value = true) => {
-        this._focused = value;
-        if (!value) {
-            this.onBlur();
-            return;
-        }
-
-        super.reset();
-    };
-
-    protected get valueToValidate() { return (this.value ?? '').trim(); }
-
-    private onBlur() {
-        this.validate();
-    }
-
-    reset = () => {
-        this._value = '';
-        this._focused = false;
-        super.reset();
-    };
-
-}

package/src/viewModels/Validatable.ts

@@ -1,102 +0,0 @@
-import { observable, makeObservable, action, runInAction } from 'mobx';
-import { ValidatorFunction, ValidatorFunctionAsync, ValidationErrors, ValidationError } from '../validation';
-import { someAsync } from '../async/arrays';
-
-export type ValueValidator<T, TErrors = ValidationErrors> = ValidatorFunction<T, TErrors> | ValidatorFunctionAsync<T, TErrors>;
-export type ValidationErrorsStrings<TErrors extends string | number = number> = Partial<Omit<Record<TErrors, string>, 0 | null>>;
-
-export type ValidationConfig<T, TErrors extends string | number = ValidationErrors> = {
-    validator: ValueValidator<Readonly<T>, TErrors>,
-    errors: ValidationErrorsStrings<TErrors>,
-};
-
-const EmptyValidator = () => 0;
-
-export abstract class ValidatableModel<T = string> {
-
-    private _validator: ValueValidator<T | Readonly<T>, any> = null;
-    private _strings: ValidationErrorsStrings<any> = null;
-
-    // @observable
-    private _error: string = null;
-
-    private _validationError: ValidationError = null;
-    protected _validateOnChange = false;
-
-    constructor() {
-        makeObservable<ValidatableModel<T>, '_error'>(this, {
-            '_error': observable,
-            reset: action,
-        });
-    }
-
-    protected abstract get valueToValidate(): T | Readonly<T>;
-
-    get isValid() { return !this._error; }
-
-    get error() { return this._error; }
-
-    public setValidationConfig<TErrors extends string | number = ValidationErrors>(config?: ValidationConfig<T, TErrors>) {
-        this._validator = config?.validator || EmptyValidator;
-        this._strings = config?.errors;
-        return this;
-    }
-
-    public validateOnChange(enable = true) {
-        this._validateOnChange = enable;
-        return this;
-    }
-
-    public async testValidate(value: T) {
-        if (this._validator) {
-            const res = await this._validator(value);
-            return res;
-        }
-        return null;
-    }
-
-    async validate() {
-        if (!this._validator) {
-            return true;
-        }
-
-        try {
-            const validationResult = await this._validator(this.valueToValidate);
-            this._validationError = !validationResult
-                ? null
-                : new ValidationError('Unknown error', validationResult);
-        } catch (err) {
-            this._validationError = err as ValidationError;
-        }
-
-        runInAction(() => {
-            if (!this._validationError) {
-                this._error = null;
-            } else {
-                const code = this._validationError.code;
-                this._error = this._strings && this._strings[code];
-            }
-        });
-        return this._validationError == null;
-    }
-
-    async getIsInvalid() {
-        const valid = await this.validate();
-        return !valid;
-    }
-
-    // @action
-    reset() {
-        this._validationError = null;
-        this._error = null;
-    }
-
-    static async IsSomeInvalid(validatables: ReadonlyArray<ValidatableModel<any>>, stopOnFail = true) {
-        if (stopOnFail) {
-            return someAsync(validatables, async v => !(await v.validate()));
-        }
-
-        const results = await Promise.all(validatables.map(v => v.validate()));
-        return results.some(r => !r);
-    }
-}

package/src/viewModels/ValueModel.ts

@@ -1,34 +0,0 @@
-import { action, makeObservable, observable } from 'mobx';
-import { Getter } from '../types';
-import { IValueModel } from './types';
-
-export class ValueModel<T> implements IValueModel<T> {
-    // observable[.ref]
-    private _value: T;
-
-    private _defaultValue: Getter<T> = null;
-
-    constructor(v: Getter<T> = null, useRefObservable = true) {
-        this._value = Getter.getValue(v) || null;
-        this._defaultValue = v;
-
-        makeObservable<ValueModel<T>, '_value'>(this, {
-            _value: useRefObservable ? observable.ref : observable,
-            setValue: action,
-        });
-    }
-
-    public get value() { return this._value; }
-    public set value(v: T) {
-        this.setValue(v);
-    }
-
-    // action
-    public readonly setValue = (value: T) => {
-        this._value = value;
-    };
-
-    reset = () => {
-        this._value = Getter.getValue(this._defaultValue);
-    };
-}

package/src/viewModels/ValuesCollector.ts

@@ -1,81 +0,0 @@
-import { IValueModel } from './types';
-
-export interface IValueCollector<TSource, TValue> {
-    getValue(source: TSource): TValue;
-    setValue(source: TSource, value: TValue): void;
-}
-
-type SimpleCollector<T> = {
-    get: () => T,
-    set: (t: T) => void,
-};
-
-type SimpleCollectorsMap<T> = {
-    [P in keyof T]?: SimpleCollector<T[P]>;
-};
-
-export type ModelCollectorsMap<T> = {
-    [P in keyof T]?: IValueModel<T[P]>;
-};
-
-export type CollectorsMap<T> = {
-    [P in keyof T]?: SimpleCollector<T[P]>;
-};
-
-export class ModelCollector<T extends Object> {
-
-    private readonly _collectors: SimpleCollectorsMap<T> = { };
-
-    public addModels(models: ModelCollectorsMap<T>) {
-        Object.entries(models).forEach(pair => this.addModel(pair[0] as keyof T, pair[1]));
-        return this;
-    }
-
-    public addModel<TKey extends keyof T, TSource extends IValueModel<T[TKey]>>(key: TKey, source: TSource) {
-        this._collectors[key] = {
-            get: () => source.value,
-            set: v => { source.value = v; },
-        };
-
-        return this;
-    }
-
-    public addCollector<TKey extends keyof T, TModel, TCollector extends IValueCollector<TModel, T[TKey]>>(key: TKey, model: TModel, collector: TCollector) {
-        this._collectors[key] = {
-            get: () => collector.getValue(model),
-            set: v => collector.setValue(model, v),
-        };
-
-        return this;
-    }
-
-    public remove(key: keyof T) {
-        delete this._collectors[key];
-
-        return this;
-    }
-
-    public collect(): T {
-        const res = { } as T;
-
-        Object.entries(this._collectors).forEach(pair => {
-            const key = pair[0] as keyof T;
-            const collector = pair[1] as SimpleCollector<T[keyof T]>;
-            res[key] = collector.get();
-        });
-
-        return res;
-    }
-
-    public populate(data: T) {
-        Object.entries(data).forEach(pair => {
-            const key = pair[0] as keyof T;
-            const value = pair[1] as T[keyof T];
-
-            const collector = this._collectors[key];
-            if (collector) {
-                collector.set(value);
-            }
-        });
-    }
-}

package/src/viewModels/__tests__/common.test.ts

@@ -1,107 +0,0 @@
-import { ValidationErrors } from '../../validation';
-import { CommonModel } from '../CommonModel';
-import { LoadingModel } from '../LoadingModel';
-import { setTimeoutAsync } from '../../async/timeout';
-import { SelectString } from '../SelectModel';
-import { TextInputVM } from '../TextModel';
-
-describe('CommonModel', () => {
-    const NotEmptyError = 'should be not empty';
-
-    it('works', async () => {
-
-        let m: CommonModel<string[]>;
-
-        const fn = async () => {
-            m = new CommonModel<string[]>(() => [], true)
-                .setValidationConfig({
-                    validator: (v: readonly any[]) => v.length > 0 ? ValidationErrors.None : ValidationErrors.ShouldBeNonEmpty,
-                    errors: {
-                        [ValidationErrors.ShouldBeNonEmpty]: NotEmptyError,
-                    },
-                });
-        };
-
-        await expect(fn()).resolves.not.toThrow();
-        expect(m).toBeDefined();
-
-        m.value = ['1'];
-
-        expect(m.value).toStrictEqual(['1']);
-        const valid1 = await m.validate();
-        expect(valid1).toBeTruthy();
-
-        m.reset();
-
-        expect(m.value).toStrictEqual([]);
-
-        const valid2 = await m.validate();
-        expect(valid2).toBeFalsy();
-
-        m.reset();
-        expect(m.error).toBeFalsy();
-
-        m.validateOnChange(true);
-        m.value = [];
-
-        // skip one frame
-        await Promise.resolve();
-
-        expect(m.error).toEqual(NotEmptyError);
-    });
-});
-
-describe('LoadingModel works', () => {
-    const worker = async () => {
-        await setTimeoutAsync(100);
-        return 100;
-    };
-
-    it('basic', async () => {
-
-        const m = new LoadingModel();
-        expect(m.value).toBe(false);
-        expect(m.isLoading).toBeFalsy();
-
-        const promise = m.useLoading(worker);
-        expect(m.isLoading).toBeTruthy();
-
-        await promise;
-
-        expect(m.isLoading).toBeFalsy();
-    });
-
-    it('with exclusive', async () => {
-        const m = new LoadingModel();
-
-        const first = m.useLoading(worker, true);
-        expect(m.isLoading).toBeTruthy();
-
-        const second = m.useLoading(worker, true);
-        expect(m.isLoading).toBeTruthy();
-
-        await expect(() => m.useLoading(worker, 'throw')).rejects.toThrow();
-
-        expect(m.isLoading).toBeTruthy();
-
-        await expect(second).resolves.toBe(false);
-        await expect(first).resolves.toBe(100);
-
-        expect(m.value).toBe(false);
-        expect(m.isLoading).toBeFalsy();
-    });
-});
-
-describe('Others', () => {
-    it('has no mobx errors', async () => {
-
-        await expect((async () => {
-            return new SelectString([]);
-        })()).resolves.not.toThrow();
-
-        await expect((async () => {
-            return new TextInputVM();
-        })()).resolves.not.toThrow();
-
-    });
-});

package/src/viewModels/__tests__/multiSelect.test.ts

@@ -1,138 +0,0 @@
-import { reaction, toJS } from 'mobx';
-import { arrayRepeat } from '../../math';
-import { MultiSelect, MultiSelectString } from '../MultiSelectModel';
-
-type SetType<T> = { items: T[], selected: number[], accessor: (item: T) => string };
-
-describe('MultiSelectModel', () => {
-    it('creates', () => {
-        expect(() => new MultiSelect(null, null).values).toThrow();
-        expect(() => new MultiSelect([1], null).values).toThrow();
-    });
-
-    const sets: SetType<any>[] = [
-        { items: [1, 2, 3], selected: [1], accessor: i => `_${i}_` },
-        { items: [1, 2, 3], selected: [], accessor: i => `_${i}_` },
-        { items: ['a', 'b', 'c'], selected: [2], accessor: i => i },
-    ];
-
-    describe('consistent', () => {
-        sets.forEach((set, setIndex) => {
-            it(`variant ${setIndex + 1}`, () => {
-                const items = set.items; // [1, 2, 3];
-                const accessor = set.accessor; // (i: number) => `_${i}_`;
-                const initialSelected = set.selected; // [1];
-                const values = items.map(accessor);
-                const selectedValues = initialSelected.map(i => accessor(items[i]));
-
-                const vm = new MultiSelect(items, accessor, ...initialSelected);
-
-                expect(vm.items).toStrictEqual(items);
-                expect(vm.values).toStrictEqual(values);
-                expect(vm.count).toBe(items.length);
-                expect(vm.selectedCount).toBe(initialSelected.length);
-                expect(vm.selectedIndexes).toStrictEqual(initialSelected);
-                expect(vm.selectedValues).toStrictEqual(selectedValues);
-
-                initialSelected.forEach(index => {
-                    expect(vm.isIndexSelected(index)).toBe(initialSelected.includes(index));
-                });
-
-                values.forEach((value) => {
-                    expect(vm.isValueSelected(value)).toBe(selectedValues.includes(value));
-                });
-            });
-        });
-
-    });
-
-    it('reacts', () => {
-        const vm = new MultiSelectString(['a', 'b', 'c']);
-
-        expect(vm.count).toBe(3);
-        expect(vm.selectedCount).toBe(0);
-        expect(vm.selectedIndexes).toHaveLength(0);
-
-        const mocks = arrayRepeat(() => jest.fn().mockImplementation(null), 5);
-        const [
-            onSelectedIndexes,
-            onSelectedItems,
-            onSelectedValues,
-            onIsIndexSelected,
-            onIsValueSelected,
-        ] = mocks;
-
-        const wrapMock = mock => ((a: any) => mock(toJS(a)));
-
-        const expectEmptyCalls = () => {
-            expect(onSelectedIndexes).toHaveBeenCalledWith([]);
-            expect(onSelectedItems).toHaveBeenCalledWith([]);
-            expect(onSelectedValues).toHaveBeenCalledWith([]);
-            mocks.forEach(m => m.mockClear());
-        };
-
-        reaction(() => vm.selectedIndexes, wrapMock(onSelectedIndexes));
-        reaction(() => vm.selectedItems, wrapMock(onSelectedItems));
-        reaction(() => vm.selectedValues, wrapMock(onSelectedValues));
-
-        // initially – 'false', so expect only when 'true' should be passed
-        reaction(() => vm.isIndexSelected(0), wrapMock(onIsIndexSelected));
-        reaction(() => vm.isValueSelected('a'), wrapMock(onIsValueSelected));
-
-        vm.selectIndex(1);
-
-        expect(onSelectedIndexes).toHaveBeenCalledWith([1]);
-        expect(onSelectedItems).toHaveBeenCalledWith(['b']);
-        expect(onSelectedValues).toHaveBeenCalledWith(['b']);
-        expect(onIsIndexSelected).not.toHaveBeenCalled();
-        expect(onIsValueSelected).not.toHaveBeenCalled();
-        mocks.forEach(m => m.mockClear());
-
-        vm.deSelectIndex(1);
-        expect(onIsIndexSelected).not.toHaveBeenCalled();
-        expect(onIsValueSelected).not.toHaveBeenCalled();
-        expectEmptyCalls();
-
-        vm.selectItem('c');
-
-        expect(onSelectedIndexes).toHaveBeenCalledWith([2]);
-        expect(onSelectedItems).toHaveBeenCalledWith(['c']);
-        expect(onSelectedValues).toHaveBeenCalledWith(['c']);
-        expect(onIsIndexSelected).not.toHaveBeenCalled();
-        expect(onIsValueSelected).not.toHaveBeenCalled();
-        mocks.forEach(m => m.mockClear());
-
-        vm.deSelectItem('c');
-        expect(onIsIndexSelected).not.toHaveBeenCalled();
-        expect(onIsValueSelected).not.toHaveBeenCalled();
-        expectEmptyCalls();
-
-        vm.selectValue('a');
-
-        expect(onSelectedIndexes).toHaveBeenCalledWith([0]);
-        expect(onSelectedItems).toHaveBeenCalledWith(['a']);
-        expect(onSelectedValues).toHaveBeenCalledWith(['a']);
-        expect(onIsIndexSelected).toHaveBeenCalledWith(true);
-        expect(onIsValueSelected).toHaveBeenCalledWith(true);
-        mocks.forEach(m => m.mockClear());
-
-        vm.deSelectValue('a');
-        expect(onIsIndexSelected).toHaveBeenCalledWith(false);
-        expect(onIsValueSelected).toHaveBeenCalledWith(false);
-        expectEmptyCalls();
-
-        vm.selectItems(['a', 'b']);
-
-        expect(onSelectedIndexes).toHaveBeenCalledWith([0, 1]);
-        expect(onSelectedItems).toHaveBeenCalledWith(['a', 'b']);
-        expect(onSelectedValues).toHaveBeenCalledWith(['a', 'b']);
-        expect(onIsIndexSelected).toHaveBeenCalledWith(true);
-        expect(onIsValueSelected).toHaveBeenCalledWith(true);
-        mocks.forEach(m => m.mockClear());
-
-        vm.reset();
-        expect(onIsIndexSelected).toHaveBeenCalledWith(false);
-        expect(onIsValueSelected).toHaveBeenCalledWith(false);
-        expectEmptyCalls();
-    });
-});

package/src/viewModels/__tests__/select.test.ts

@@ -1,71 +0,0 @@
-import { configure } from 'mobx';
-import { Select, SelectString } from '../SelectModel';
-
-configure({ enforceActions: 'never' });
-
-describe('SelectViewModel', () => {
-    it('consistent', async () => {
-        expect(() => new Select(null, null).values).toThrow();
-        expect(() => new Select([1], null).values).toThrow();
-
-        const emptyVm = new Select([], null);
-        expect(emptyVm.selectedValue).toBeNull();
-
-        const items = [0, 1, 2];
-        const values = ['0!', '1!', '2!'];
-        const initialIndex = -1;
-        const vm = new Select(items, i => `${i}!`, initialIndex);
-
-        expect(vm.index).toEqual(initialIndex);
-        expect(vm.values).toStrictEqual(values);
-        expect(vm.items).toStrictEqual(items);
-
-        expect(vm.selectedItem).toBeUndefined();
-        expect(vm.selectedValue).toBeUndefined();
-
-        vm.selectedItem = 7;
-        expect(vm.index).toBe(initialIndex);
-
-        vm.selectedValue = '123';
-        expect(vm.index).toBe(initialIndex);
-
-        vm.opened.value = true;
-        expect(vm.opened.value).toBe(true);
-
-        vm.index = 1;
-        expect(vm.index).toBe(1);
-
-        expect(vm.flags).toHaveLength(items.length);
-        values.forEach((_currentValue, itemIndex) => {
-            vm.selectedValue = _currentValue;
-            expect(vm.selectedItem).toBe(items[itemIndex]);
-            vm.selectedItem = items[itemIndex];
-            expect(vm.selectedValue).toBe(_currentValue);
-            vm.flags.forEach((f, i) => {
-                expect(f.value).toBe(i === itemIndex);
-                expect(f.label).toBe(values[i]);
-            });
-        });
-
-        vm.flags.forEach((f, i) => {
-            f.value = true;
-            vm.flags.forEach((ff, ii) => {
-                expect(ff.value).toBe(i === ii);
-            });
-            expect(vm.index).toBe(i);
-        });
-
-        vm.selectedItem = items[1];
-        expect(vm.selectedValue).toBe(values[1]);
-
-        vm.reset();
-        expect(vm.index).toBe(initialIndex);
-
-        expect(vm.error).toBeNull();
-
-        await expect(vm.validate()).resolves.toBeTruthy();
-
-        const vmS = new SelectString(values);
-        expect(vmS.values).toStrictEqual(values);
-    });
-});