@zajno/common 1.4.15 → 1.4.18

package/src/validation/helpers.ts

@@ -1,5 +1,10 @@
-import { ValidationError, ValidatorFunction } from './types';
 import { ValidationErrors } from './ValidationErrors';
+import {
+    ValidationConfig,
+    ValidationError,
+    ValidationResults,
+    ValidatorFunction,
+} from './types';
 
 export function createShouldBeEqualTo<T = string>(getter: () => T): ValidatorFunction<T> {
     return (val: T) => getter() === val ? ValidationErrors.None : ValidationErrors.ShouldBeEqualTo;
@@ -11,33 +16,27 @@ export function throwNotOk(result: ValidationErrors, message = 'Validation error
     }
 }
 
-export function validateObject<T>(
+export function validateObject<T, TErrors = ValidationErrors>(
     obj: T,
-    validators: { [P in keyof T]?: ValidatorFunction<T[P]> },
-): { [P in keyof T]?: ValidationErrors } {
+    validators: ValidationConfig<T, TErrors>,
+    onlyTruethy = false,
+): ValidationResults<T, TErrors> {
 
-    const res: { [P in keyof T]?: ValidationErrors } = { };
+    const res: ValidationResults<T, TErrors> = { };
 
     Object.keys(obj).forEach(k => {
         const kk = k as keyof T;
-        const validator: ValidatorFunction<T[typeof kk]> = validators[kk];
+        const validator: ValidatorFunction<T[typeof kk], TErrors, T> = validators[kk];
         if (!validator) {
             return;
         }
 
         const v = obj[k as keyof T];
-        // let str: string;
-        // if (typeof v === 'number') {
-        //     str = v + '';
-        // }
-
-        // if (typeof v !== 'string') {
-        //     return; // skip non-strings
-        // }
-
-        // str = v;
+        if (onlyTruethy && !v) {
+            return;
+        }
 
-        const err = validator(v);
+        const err = validator(v, obj);
         if (err) {
             res[kk] = err;
         }
@@ -45,4 +44,3 @@ export function validateObject<T>(
 
     return res;
 }
-

package/src/validation/types.ts

@@ -1,7 +1,10 @@
 import { ValidationErrors } from './ValidationErrors';
 
-export type ValidatorFunction<T = string, TErrors = ValidationErrors> = (val: T) => TErrors;
-export type ValidatorFunctionAsync<T = string, TErrors = ValidationErrors> = (val: T) => Promise<TErrors>;
+export type ValidatorFunction<T = string, TErrors = ValidationErrors, TContext = any> = (val: T, ctx?: TContext) => TErrors;
+export type ValidatorFunctionAsync<T = string, TErrors = ValidationErrors, TContext = any> = (val: T, ctx?: TContext) => Promise<TErrors>;
+
+export type ValidationConfig<T, TErrors> = { [P in keyof T]?: ValidatorFunction<T[P], TErrors, T> };
+export type ValidationResults<T, TErrors> = { [P in keyof T]?: TErrors };
 
 export type WrapperFunction = (val: ValidatorFunction) => ValidatorFunction;
 

package/src/viewModels/LoadingModel.ts

@@ -4,6 +4,10 @@ export class LoadingModel extends NumberModel {
 
     public get isLoading() { return this.value > 0; }
 
+    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') {