@zajno/common 1.6.1 → 2.0.0-beta.1

package/src/viewModels/FlagModel.ts

@@ -1,70 +0,0 @@
-import { action, makeObservable, observable } from 'mobx';
-import { IResetableModel } from 'viewModels';
-import { ILabel, IValueModel } from './types';
-
-export interface IFlagModel extends IValueModel<boolean>, IResetableModel {
-    toggle(): void;
-}
-
-export type IFlagModelReadonly = {
-    readonly value: boolean;
-};
-
-export type ILabeledFlagModel = IFlagModel & ILabel<string>;
-
-export class FlagModel implements IFlagModel, IFlagModelReadonly {
-
-    // @observable
-    private _value: boolean = false;
-
-    constructor(initial = false) {
-        makeObservable<FlagModel, '_value'>(this, {
-            _value: observable,
-            setValue: action,
-            setTrue: action,
-            setFalse: action,
-            toggle: action,
-            reset: action,
-        });
-        this._value = initial;
-    }
-
-    get value() {
-        return this._value;
-    }
-
-    set value(value: boolean) {
-        this.setValue(value);
-    }
-
-    // @action
-    public readonly setValue = (value: boolean) => {
-        this._value = value;
-    };
-
-    get isDefault() { return this._value === false; }
-
-    // @action
-    setTrue = () => {
-        const v = this.value;
-        this.value = true;
-        return !v;
-    };
-
-    // @action
-    setFalse = () => {
-        const v = this.value;
-        this.value = false;
-        return v;
-    };
-
-    // @action
-    toggle = () => {
-        this._value = !this._value;
-    };
-
-    // @action
-    reset = () => {
-        this._value = false;
-    };
-}

package/src/viewModels/InitializableModel.ts

@@ -1,17 +0,0 @@
-import NumberModel from './NumberModel';
-
-export class InitializableModel {
-    private readonly _counter = new NumberModel(0);
-
-    public get initializing() { return this._counter.value > 0; }
-
-    protected async runOperation<T>(operation: () => Promise<T> | T): Promise<T> {
-        try {
-            this._counter.increment();
-            const res = await operation();
-            return res;
-        } finally {
-            this._counter.decrement();
-        }
-    }
-}

package/src/viewModels/LoadingModel.ts

@@ -1,52 +0,0 @@
-import { NumberModel } from './NumberModel';
-import { IResetableModel, IValueModel } from './types';
-
-export class LoadingModel implements IValueModel<boolean>, IResetableModel {
-
-    private readonly _number = new NumberModel(0);
-
-    public get isLoading() { return this._number.value > 0; }
-
-    public get value(): boolean { return this.isLoading; }
-    public set value(v: boolean) {
-        if (v) {
-            this._number.increment();
-        } else {
-            this._number.decrement();
-        }
-    }
-
-    public async useLoading<T>(cb: () => (T | Promise<T>)): Promise<T>;
-    public async useLoading<T>(cb: () => (T | Promise<T>), exclusive: false): Promise<T>;
-    public async useLoading<T>(cb: () => (T | Promise<T>), exclusive: true): Promise<T | false>;
-    public async useLoading<T>(cb: () => (T | Promise<T>), exclusive: 'throw'): Promise<T>;
-
-    public useLoading<T>(cb: () => (T | Promise<T>), exclusive: boolean | 'throw' = false): Promise<T | false> {
-        return withLoading(this, cb, exclusive as any);
-    }
-
-    public reset = () => this._number.reset();
-}
-
-export function withLoading<T>(model: IValueModel<boolean>, cb: () => (T | Promise<T>)): Promise<T>;
-export function withLoading<T>(model: IValueModel<boolean>, cb: () => (T | Promise<T>), exclusive: false): Promise<T>;
-export function withLoading<T>(model: IValueModel<boolean>, cb: () => (T | Promise<T>), exclusive: true): Promise<T | false>;
-export function withLoading<T>(model: IValueModel<boolean>, cb: () => (T | Promise<T>), exclusive: 'throw'): Promise<T>;
-
-export async function withLoading<T>(this: void, model: IValueModel<boolean>, cb: () => (T | Promise<T>), exclusive: boolean | 'throw' = false): Promise<T | false> {
-    if (exclusive && model.value) {
-        if (exclusive === 'throw') {
-            throw new Error('Operation cannot be started because another one is in progress already.');
-        }
-        return false;
-    }
-
-    model.value = true;
-
-    try {
-        const res = await cb();
-        return res;
-    } finally {
-        model.value = false;
-    }
-}

package/src/viewModels/MultiSelectModel.ts

@@ -1,178 +0,0 @@
-import { createLazy } from '../lazy/light';
-import { action, computed, makeObservable, observable, reaction } from 'mobx';
-import { FlagModel, ILabeledFlagModel } from './FlagModel';
-import { ValidatableModel } from './Validatable';
-import { IValueModel } from './types';
-import { withLabel } from './wrappers';
-import { ICountableModel, IResetableModel } from 'viewModels';
-import { arraysCompareDistinct } from '../math';
-
-export class MultiSelect<T = any> extends ValidatableModel<ReadonlyArray<T>> implements IValueModel<readonly string[]>, IResetableModel, ICountableModel {
-
-    // @observable
-    private readonly _indexes = new Set<number>();
-
-    public readonly opened = new FlagModel();
-    private readonly _initial: number[] = null;
-
-    private readonly _flags = createLazy(() => this.createFlags());
-    private _indexesLocked = false;
-
-    constructor(
-        private readonly _items: readonly T[],
-        private readonly _accessor: (item: T) => string,
-        ...selected: number[]
-    ) {
-        super();
-        makeObservable<MultiSelect<T>, '_indexes'>(this, {
-            '_indexes': observable,
-            selectedIndexes: computed,
-            values: computed,
-            selectedItems: computed,
-            selectedValues: computed,
-            isDefault: computed,
-            selectItems: action,
-            selectValues: action,
-            setIndexSelected: action,
-        });
-        this._initial = selected;
-        this.setInitialIndexes();
-    }
-
-    // @computed
-    get selectedIndexes(): ReadonlyArray<number> { return Array.from(this._indexes); }
-
-    get items(): ReadonlyArray<T> { return this._items; }
-
-    get flags() { return this._flags.value; }
-
-    // @computed
-    get values(): ReadonlyArray<string> {
-        return this._items.map(i => this._accessor(i));
-    }
-
-    // @computed
-    get selectedItems(): ReadonlyArray<T> {
-        return this.selectedIndexes.map(i => this._items[i]);
-    }
-
-    // @computed
-    get selectedValues(): ReadonlyArray<string> {
-        const values = this.values;
-        return this.selectedIndexes.map(i => values[i]);
-    }
-
-    get value() { return this.selectedValues; }
-    set value(v: readonly string[]) { this.selectValues(v); }
-
-    isIndexSelected(index: number) { return this._indexes.has(index); }
-    isValueSelected(value: string) { return this.selectedValues.includes(value); }
-
-    get count() { return this._items.length; }
-    get selectedCount() { return this._indexes.size; }
-    get isEmpty() { return this.selectedCount === 0; }
-
-    // @computed
-    get isDefault() { return arraysCompareDistinct(this.selectedIndexes, this._initial)?.diff === 0; }
-
-    protected get valueToValidate() { return this.selectedItems; }
-
-    setItemSelected = (item: T, selected: boolean) => {
-        const i = this.items.indexOf(item);
-        if (i >= 0) {
-            this.setIndexSelected(i, selected);
-        }
-    };
-
-    selectItem = (item: T) => this.setItemSelected(item, true);
-    deSelectItem = (item: T) => this.setItemSelected(item, false);
-
-    // @action
-    selectItems = (items: readonly T[]) => {
-        items.forEach(this.selectItem);
-    };
-
-    setValueSelected = (value: string, selected: boolean) => {
-        const i = this.values.indexOf(value);
-        if (i >= 0) {
-            this.setIndexSelected(i, selected);
-        }
-    };
-
-    selectValue = (value: string) => this.setValueSelected(value, true);
-    deSelectValue = (value: string) => this.setValueSelected(value, false);
-
-    // @action
-    selectValues = (values: readonly string[]) => {
-        values.forEach(this.selectValue);
-    };
-
-    // @action
-    setIndexSelected = (index: number, selected: boolean) => {
-        if (this._indexesLocked) {
-            return;
-        }
-
-        if (selected) {
-            this._indexes.add(index);
-        } else {
-            this._indexes.delete(index);
-        }
-
-        if (this._validateOnChange) {
-            this.validate();
-        }
-
-        if (!this._flags.hasValue) {
-            return;
-        }
-
-        try {
-            this._indexesLocked = true;
-            this._flags.value[index].value = selected;
-        } finally {
-            this._indexesLocked = false;
-        }
-    };
-
-    selectIndex = (index: number) => this.setIndexSelected(index, true);
-    deSelectIndex = (index: number) => this.setIndexSelected(index, false);
-
-    reset = () => {
-        super.reset();
-        this.setInitialIndexes();
-    };
-
-    private setInitialIndexes() {
-        this._indexes.clear();
-        this._initial.forEach(i => this._indexes.add(i));
-
-        if (this._flags.hasValue) {
-            this._flags.value.forEach((flag, index) => flag.value = this._indexes.has(index));
-        }
-    }
-
-    private createFlags() {
-        const flags: ReadonlyArray<ILabeledFlagModel> = this._items
-            .map((item, index) => {
-                const flag = withLabel(
-                    new FlagModel(this._indexes.has(index)),
-                    () => this._accessor(item),
-                );
-
-                // react on every flag is changed directly
-                reaction(() => flag.value, isSelected => {
-                    this.setIndexSelected(index, isSelected);
-                });
-                return flag;
-            });
-        return flags;
-    }
-}
-
-export class MultiSelectString<T extends string = string> extends MultiSelect<T> {
-
-    constructor(items: ReadonlyArray<T>, ...selected: number[]) {
-        super(items, v => v, ...selected);
-    }
-}

package/src/viewModels/NumberModel.ts

@@ -1,50 +0,0 @@
-import { action, makeObservable, observable } from 'mobx';
-import { IResetableModel } from 'viewModels';
-import { IValueModel } from './types';
-
-export interface INumberModel extends IResetableModel {
-    value: number;
-}
-
-export class NumberModel implements INumberModel, IValueModel<number> {
-
-    // @observable
-    private _value: number = 0;
-
-    private _initial: number = 0;
-
-    constructor(initial: number = 0) {
-        makeObservable<NumberModel, '_value'>(this, {
-            _value: observable,
-            setValue: action,
-            reset: action,
-            increment: action,
-            decrement: action,
-        });
-        this._initial = initial;
-        this._value = this._initial;
-    }
-
-    get value() { return this._value; }
-    set value(v: number) { this.setValue(v); }
-
-    // @action
-    public readonly setValue = (v: number) => {
-        this._value = v;
-    };
-
-    get isDefault() { return this._value === this._initial; }
-
-    // @action
-    reset = () => {
-        this._value = this._initial;
-    };
-
-    // @action
-    increment = (d = 1) => this.value += d;
-
-    // @action
-    decrement = (d = 1) => this.value -= d;
-}
-
-export default NumberModel;

package/src/viewModels/PromptModal.ts

@@ -1,65 +0,0 @@
-import { observable, makeObservable, action } from 'mobx';
-import { FlagModel } from './FlagModel';
-
-export type BaseModalAction = {
-    title?: string;
-    message?: string;
-};
-
-export class ModalActionModel<T extends BaseModalAction = BaseModalAction> {
-    public readonly isActive = new FlagModel();
-
-    @observable.ref
-    private _currentAction: T = null;
-
-    constructor() {
-        makeObservable(this);
-    }
-
-    get currentAction() { return this._currentAction; }
-
-    @action
-    public openModal = (action: T) => {
-        this._currentAction = action;
-        this.isActive.value = true;
-    };
-
-    @action
-    public closeModal = () => {
-        this.isActive.value = false;
-        this._currentAction = null;
-    };
-
-    protected runAction = async (cb: () => Promise<void> | void, close = true, awaitAction = false) => {
-        if (cb) {
-            const promise = cb();
-            if (awaitAction) {
-                await promise;
-            }
-        }
-
-        if (close) {
-            this.closeModal();
-        }
-    };
-}
-
-export type PromptModalAction = BaseModalAction & {
-    confirmText?: string;
-    rejectText?: string;
-    onConfirm?: () => Promise<void> | void;
-    onReject?: () => Promise<void> | void;
-    awaitActions?: boolean;
-    modalImage?: any;
-    confirmColor?: string;
-    rejectColor?: string;
-};
-
-export class PromptModalViewModel extends ModalActionModel<PromptModalAction> {
-    get confirmColor() { return this.currentAction.confirmColor; }
-
-    get rejectColor() { return this.currentAction.rejectColor; }
-
-    onConfirm = () => this.runAction(this.currentAction.onConfirm, true, this.currentAction.awaitActions);
-    onReject = () => this.runAction(this.currentAction.onReject, true, this.currentAction.awaitActions);
-}

package/src/viewModels/SelectModel.ts

@@ -1,152 +0,0 @@
-import { observable, computed, makeObservable, reaction, action } from 'mobx';
-import { createLazy } from '../lazy/light';
-import { FlagModel, ILabeledFlagModel } from './FlagModel';
-import { ValidatableModel } from './Validatable';
-import { IValueModel } from './types';
-import { withLabel } from './wrappers';
-import { IResetableModel } from './types';
-import { Getter } from '../types';
-
-export class Select<T = any> extends ValidatableModel<T> implements IValueModel<string>, IResetableModel {
-    // @observable
-    private _index: number = undefined;
-
-    private readonly _items: Getter<readonly T[]>;
-
-    private _indexLocked = false;
-    private _initialIndex: number = null;
-
-    private readonly _flags = createLazy(() => this.createFlags());
-
-    public readonly opened = new FlagModel();
-
-    constructor(
-        items: Getter<readonly T[]>,
-        private readonly _accessor: (item: T) => string,
-        initialIndex: number = 0,
-    ) {
-        super();
-
-        this._items = items;
-
-        makeObservable<Select<T>, '_index' | '_items'>(this, {
-            '_index': observable,
-            '_items': observable.ref,
-            values: computed,
-            items: computed,
-            setIndex: action,
-        });
-
-        this._initialIndex = initialIndex;
-        this._index = initialIndex;
-    }
-
-    protected get valueToValidate() { return this.selectedItem; }
-
-    // @computed
-    get values(): readonly string[] {
-        return this.items.map(i => this._accessor(i));
-    }
-
-    get flags() {
-        return this._flags.value;
-    }
-
-    // @computed
-    get items(): readonly T[] {
-        return Getter.getValue(this._items);
-    }
-
-    get value() { return this.selectedValue; }
-    get selectedValue() {
-        const vs = this.values;
-        return vs.length ? vs[this._index] : null;
-    }
-
-    set value(v: string) { this.selectedValue = v; }
-    set selectedValue(value: string) {
-        const index = this.values.indexOf(value);
-        if (index >= 0) {
-            this.index = index;
-        }
-    }
-
-    get selectedItem(): T {
-        const items = this.items;
-        return items.length ? items[this._index] : null;
-    }
-
-    set selectedItem(item: T) {
-        const index = this.items.indexOf(item);
-        if (index >= 0) {
-            this.index = index;
-        }
-    }
-
-    get isDefault() { return this._index === this._initialIndex; }
-
-    get index() {
-        return this._index;
-    }
-
-    set index(val: number) {
-       this.setIndex(val);
-    }
-
-    // @action
-    public setIndex = (val: number) => {
-        if (this._indexLocked) {
-            return;
-        }
-
-        this._index = val;
-
-        if (this._validateOnChange) {
-            this.validate();
-        }
-
-        // update all flags to be properly selected
-        try {
-            this._indexLocked = true;
-
-            if (this._flags.hasValue) {
-                this._flags.value.forEach((f, i) => f.value = (i === this._index));
-            }
-        } finally {
-            this._indexLocked = false;
-        }
-    };
-
-    public reset = () => {
-        super.reset();
-        this.index = this._initialIndex;
-    };
-
-    private createFlags() {
-        const flags: ReadonlyArray<ILabeledFlagModel> = this.items
-            .map((item, index) => {
-                const flag: ILabeledFlagModel = withLabel(
-                    new FlagModel(index === this.index),
-                    () => this._accessor(item),
-                );
-
-                // react on every flag is changed directly
-                reaction(() => flag.value, isSelected => {
-                    if (isSelected) {
-                        this.index = index;
-                    }
-                });
-
-                return flag;
-            });
-
-        return flags;
-    }
-}
-
-
-export class SelectString<T extends string = string> extends Select<T> {
-    constructor(items: readonly T[], initialIndex: number = 0) {
-        super(items, v => v, initialIndex);
-    }
-}