@zajno/common 1.3.1 → 1.3.5

package/src/viewModels/MultiSelectModel.ts

@@ -2,10 +2,12 @@ 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 './ValuesCollector';
+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[]> {
+export class MultiSelect<T = any> extends ValidatableModel<ReadonlyArray<T>> implements IValueModel<readonly string[]>, IResetableModel, ICountableModel {
 
     @observable
     private readonly _indexes = new Set<number>();
@@ -54,9 +56,14 @@ export class MultiSelect<T = any> extends ValidatableModel<ReadonlyArray<T>> imp
     set value(v: readonly string[]) { this.selectValues(v); }
 
     isIndexSelected(index: number) { return this._indexes.has(index); }
-    isValueSelected(value: string) { return this.values.includes(value); }
+    isValueSelected(value: string) { return this.selectedValues.includes(value); }
 
-    get isEmpty() { return this._indexes.size === 0; }
+    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; }
 
@@ -114,6 +121,9 @@ export class MultiSelect<T = any> extends ValidatableModel<ReadonlyArray<T>> imp
         }
     };
 
+    selectIndex = (index: number) => this.setIndexSelected(index, true);
+    deSelectIndex = (index: number) => this.setIndexSelected(index, false);
+
     reset = () => {
         super.reset();
         this.setInitialIndexes();

package/src/viewModels/NumberModel.ts

@@ -1,7 +1,8 @@
 import { action, makeObservable, observable } from 'mobx';
-import { IValueModel } from './ValuesCollector';
+import { IResetableModel } from 'viewModels';
+import { IValueModel } from './types';
 
-export interface INumberModel {
+export interface INumberModel extends IResetableModel {
     value: number;
 }
 
@@ -21,6 +22,8 @@ export class NumberModel implements INumberModel, IValueModel<number> {
     get value() { return this._value; }
     set value(v: number) { this._value = v; }
 
+    get isDefault() { return this._value === this._initial; }
+
     @action
     reset = () => {
         this._value = this._initial;

package/src/viewModels/PromptModal.ts

@@ -61,5 +61,5 @@ export class PromptModalViewModel extends ModalActionModel<PromptModalAction> {
     get rejectColor() { return this.currentAction.rejectColor; }
 
     onConfirm = () => this.runAction(this.currentAction.onConfirm, true, this.currentAction.awaitActions);
-    onReject = () => this.runAction(this.currentAction.onConfirm, true, this.currentAction.awaitActions);
+    onReject = () => this.runAction(this.currentAction.onReject, true, this.currentAction.awaitActions);
 }

package/src/viewModels/SelectModel.ts

@@ -2,10 +2,11 @@ import { createLazy } from '../lazy.light';
 import { observable, computed, makeObservable, reaction } from 'mobx';
 import { FlagModel, ILabeledFlagModel } from './FlagModel';
 import { ValidatableModel } from './Validatable';
-import { IValueModel } from './ValuesCollector';
+import { IValueModel } from './types';
 import { withLabel } from './wrappers';
+import { IResetableModel } from 'viewModels';
 
-export class Select<T = any> extends ValidatableModel<T> implements IValueModel<string> {
+export class Select<T = any> extends ValidatableModel<T> implements IValueModel<string>, IResetableModel {
     @observable
     private _index: number = undefined;
 
@@ -67,6 +68,8 @@ export class Select<T = any> extends ValidatableModel<T> implements IValueModel<
         }
     }
 
+    get isDefault() { return this._index === this._initialIndex; }
+
     get index() {
         return this._index;
     }

package/src/viewModels/TextModel.ts

@@ -1,8 +1,9 @@
 import { observable, computed, makeObservable, reaction } from 'mobx';
 import { Getter } from '../types';
+import { IValueModel } from './types';
 import logger from '../logger';
 import { ValidatableModel, ValidationConfig } from './Validatable';
-import { IValueModel } from './ValuesCollector';
+import { IResetableModel } from 'viewModels';
 
 export type TextInputConfig = {
     name?: Getter<string>;
@@ -39,7 +40,7 @@ export class Text {
     get value() { return this._value; }
 }
 
-export class TextInputVM extends ValidatableModel implements IValueModel<string> {
+export class TextInputVM extends ValidatableModel implements IValueModel<string>, IResetableModel {
     @observable
     private _value = '';
 
@@ -103,10 +104,10 @@ export class TextInputVM extends ValidatableModel implements IValueModel<string>
         this.validate();
     }
 
-    reset() {
+    reset = () => {
         this._value = '';
         this._focused = false;
         super.reset();
-    }
+    };
 
 }

package/src/viewModels/Validatable.ts

@@ -38,6 +38,14 @@ export abstract class ValidatableModel<T = string> {
         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;

package/src/viewModels/ValuesCollector.ts

@@ -1,7 +1,4 @@
-
-export interface IValueModel<TValue> {
-    value: TValue;
-}
+import { IValueModel } from './types';
 
 export interface IValueCollector<TSource, TValue> {
     getValue(source: TSource): TValue;

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

@@ -1,23 +1,138 @@
-import { MultiSelect } from '../MultiSelectModel';
+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('consistent', () => {
+    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 items = [1, 2, 3];
-        const accessor = (i: number) => `_${i}_`;
-        const values = items.map(accessor);
-        const initialSelected = [1];
+                const vm = new MultiSelect(items, accessor, ...initialSelected);
 
-        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);
 
-        expect(vm.items).toStrictEqual(items);
-        expect(vm.values).toStrictEqual(values);
-        expect(vm.selectedIndexes).toStrictEqual(initialSelected);
+                initialSelected.forEach(index => {
+                    expect(vm.isIndexSelected(index)).toBe(initialSelected.includes(index));
+                });
 
-        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/index.ts

@@ -1,3 +1,4 @@
+export * from './types';
 export * from './Validatable';
 export * from './TextModel';
 export * from './FlagModel';

package/src/viewModels/types.ts

@@ -0,0 +1,19 @@
+
+export interface IValueModel<TValue> {
+    value: TValue;
+}
+
+export interface ILabel<T> {
+    readonly label: T;
+}
+
+export interface IResetableModel {
+    readonly reset: () => void;
+    readonly isDefault?: boolean;
+}
+
+export interface ICountableModel {
+    readonly count: number;
+    readonly selectedCount?: number;
+    readonly isEmpty: boolean;
+}

package/src/viewModels/wrappers.ts

@@ -1,9 +1,5 @@
 import { Getter } from '../types';
-import { IValueModel } from './ValuesCollector';
-
-export interface ILabel<T> {
-    readonly label: T;
-}
+import { ILabel, IValueModel } from './types';
 
 export function withLabel<T, TModel extends IValueModel<T>, TLabel = string>(model: TModel, label: Getter<TLabel>) {
     const _label = label;