@zajno/common 1.5.0 → 1.5.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zajno/common",
-  "version": "1.5.0",
+  "version": "1.5.3",
   "description": "Zajno's re-usable utilities for JS/TS projects",
   "repository": {
     "type": "git",

package/src/services/storage/index.ts

@@ -28,6 +28,14 @@ export class KeyStorage {
 
     get value() { return this.storage.getValue(this.key); }
     set value(v: string) { this.storage.setValue(this.key, v); }
+
+    public clean() {
+        this.storage.removeValue(this.key);
+    }
+
+    public getHasValue() {
+        return this.storage.hasValue(this.key);
+    }
 }
 
 export class KeyStorageConverted<T> {
@@ -37,11 +45,19 @@ export class KeyStorageConverted<T> {
         storage: IStorageSync,
         key: string,
         readonly input: (v: T) => string = (v => JSON.stringify(v)),
-        readonly output: (s: string) => T = (s => JSON.parse(s) as T),
+        readonly output: (s: string) => T = (s => JSON.parse(s || null) as T),
     ) {
         this._storage = new KeyStorage(storage, key);
     }
 
     get value(): T { return this.output(this._storage.value); }
     set value(v: T) { this._storage.value = this.input(v); }
+
+    public clean() {
+        this._storage.clean();
+    }
+
+    public getHasValue() {
+        return this._storage.getHasValue();
+    }
 }

package/src/validation/helpers.ts

@@ -20,6 +20,7 @@ export function validateObject<T, TErrors = ValidationErrors>(
     obj: T,
     validators: ValidationConfig<T, TErrors>,
     onlyTruethy = false,
+    context?: T,
 ): ValidationResults<T, TErrors> {
 
     const res: ValidationResults<T, TErrors> = { };
@@ -36,7 +37,7 @@ export function validateObject<T, TErrors = ValidationErrors>(
             return;
         }
 
-        const err = validator(v, obj);
+        const err = validator(v, context || obj);
         if (err) {
             res[kk] = err;
         }

package/src/viewModels/LoadingModel.ts

@@ -1,28 +1,52 @@
 import { NumberModel } from './NumberModel';
+import { IResetableModel, IValueModel } from './types';
 
-export class LoadingModel extends NumberModel {
+export class LoadingModel implements IValueModel<boolean>, IResetableModel {
 
-    public get isLoading() { return this.value > 0; }
+    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 | 'throw'): Promise<T | false>;
-
-    public async useLoading<T>(cb: () => (T | Promise<T>), exclusive: boolean | 'throw' = false): Promise<T | false> {
-        if (exclusive && this.isLoading) {
-            if (exclusive === 'throw') {
-                throw new Error('Operation cannot be started because another one is in progress already.');
-            }
-            return false;
-        }
+    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();
+}
 
-        this.increment();
+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>;
 
-        try {
-            const res = await cb();
-            return res;
-        } finally {
-            this.decrement();
+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/__tests__/common.test.ts

@@ -51,19 +51,18 @@ describe('CommonModel', () => {
     });
 });
 
-describe('LoadingModel', () => {
+describe('LoadingModel works', () => {
+    const worker = async () => {
+        await setTimeoutAsync(100);
+        return 100;
+    };
 
-    it('works', async () => {
+    it('basic', async () => {
 
         const m = new LoadingModel();
-        expect(m.value).toBe(0);
+        expect(m.value).toBe(false);
         expect(m.isLoading).toBeFalsy();
 
-        const worker = async () => {
-            await setTimeoutAsync(100);
-            return 100;
-        };
-
         const promise = m.useLoading(worker);
         expect(m.isLoading).toBeTruthy();
 
@@ -71,6 +70,26 @@ describe('LoadingModel', () => {
 
         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', () => {

package/src/viewModels/types.ts

@@ -1,5 +1,9 @@
 
-export interface IValueModel<TValue> {
+export interface IValueModelReadonly<TValue> {
+    readonly value: TValue;
+}
+
+export interface IValueModel<TValue> extends IValueModelReadonly<TValue> {
     value: TValue;
 }