@wemake4u/form-player-se 1.0.28 → 1.0.29

package/esm2022/lib/services/validation.service.mjs

@@ -0,0 +1,179 @@
+import { Injectable } from '@angular/core';
+import { Validators } from '@angular/forms';
+import { localize } from '../locale/localize';
+import { isObservable, map, of, catchError, take } from 'rxjs';
+import { toFeelable } from '../utils/feelable';
+import { CallbackRegistry } from '../utils/CallbackRegistry';
+import * as i0 from "@angular/core";
+import * as i1 from "@wemake4u/interact";
+import * as i2 from "../services/programmability.service";
+export class ValidationService {
+    languageService;
+    programmability;
+    constructor(languageService, programmability) {
+        this.languageService = languageService;
+        this.programmability = programmability;
+    }
+    suppress = false;
+    createCollection() {
+        return new Map();
+    }
+    addToCollection(collection, control, component, formGroup) {
+        collection.set(control, { component, formGroup });
+    }
+    setupCollection(collection) {
+        collection.forEach((componentValidation, control) => {
+            const component = componentValidation.component;
+            const currentGroup = componentValidation.formGroup;
+            const required = component?.validate?.required;
+            const rules = this.getRules(component);
+            const [validators, asyncValidators, watching] = this.validateRules(currentGroup, component, required, rules);
+            control.setValidators(validators);
+            control.setAsyncValidators(asyncValidators);
+            watching(control);
+        });
+    }
+    getRules(component) {
+        if (!Array.isArray(component.validations))
+            return [];
+        return component.validations?.map((rule) => {
+            return {
+                expression: rule.expression,
+                type: rule.type,
+                message: this.locale(rule, 'message'),
+                async: rule.async === true
+            };
+        });
+    }
+    validateRules(formGroup, component, required, validations) {
+        const validators = [];
+        const asyncValidators = [];
+        const noWatching = () => { };
+        if (required === true) {
+            validators.push(Validators.required);
+        }
+        if (!Array.isArray(validations)) {
+            return [validators, asyncValidators, noWatching];
+        }
+        const callbacks = new CallbackRegistry();
+        validations.forEach((item) => {
+            if (!this.programmability.isExpression(item.expression))
+                return;
+            const logger = (control, result) => this.logValidation(component, item, control, result);
+            if (item.type === "validate" || item.type === "invalidate") {
+                const predicate = item.type === "validate"
+                    ? (result) => result
+                    : (result) => !result;
+                if (item.async) {
+                    asyncValidators.push(this.createAsyncValidator(formGroup, item, callbacks, predicate, logger));
+                }
+                else {
+                    validators.push(this.createValidator(formGroup, item, predicate, logger));
+                }
+            }
+        });
+        const watching = (control) => {
+            this.watchForValidation(formGroup, control, component.key, validations, callbacks);
+        };
+        return [validators, asyncValidators, watching];
+    }
+    createValidator(formGroup, item, predicate, callback) {
+        return (control) => {
+            if (this.suppress)
+                return null;
+            const result = this.programmability.evaluateUnary(formGroup, item.expression, control.value);
+            if (isObservable(result)) {
+                console.warn("[Validator] Unexpected observable result in createValidator", { expression: item.expression, value: control.value, rule: item });
+                return null;
+            }
+            const validate = predicate(result) ? null : this.validationErrors(formGroup, item);
+            callback(control, validate);
+            return validate;
+        };
+    }
+    createAsyncValidator(formGroup, item, callbacks, predicate, callback) {
+        const unsetState = () => ({ value: Symbol('unset'), result: null });
+        let state = unsetState();
+        callbacks.register(() => state = unsetState());
+        const getResult = (control) => this.programmability.evaluate(formGroup, item.expression, {
+            cacheable: false,
+            extendContext: () => { return { "?": control.value }; }
+        });
+        const computeOnce = (control) => {
+            const v = control.value;
+            if (state.value !== v) {
+                let result = getResult(control);
+                if (isObservable(result)) {
+                    result = result.pipe(take(1), map((value) => {
+                        const validate = predicate(value) ? null : this.validationErrors(formGroup, item);
+                        callback(control, validate);
+                        return validate;
+                    }), catchError(err => {
+                        console.error("[AsyncValidator] Evaluation error", { expression: item.expression, err });
+                        return this.nullObserver;
+                    }));
+                }
+                state = { value: v, result: result };
+            }
+            return state.result;
+        };
+        return (control) => {
+            if (this.suppress)
+                return this.nullObserver;
+            const result = computeOnce(control);
+            if (!isObservable(result)) {
+                console.warn("[AsyncValidator] Expected observable but got non-observable result", { expression: item.expression, value: control.value, result, rule: item });
+                return this.nullObserver;
+            }
+            return result;
+        };
+    }
+    validationErrors(formGroup, item) {
+        const message = this.programmability.evaluateString(formGroup, item.message);
+        const validationError = { error: true, message };
+        return validationError;
+    }
+    watchForValidation(formGroup, control, key, validations, callbacks) {
+        if (Array.isArray(validations)) {
+            const expressions = validations
+                .filter(item => this.programmability.isExpression(item.expression))
+                .map(item => "=" + this.programmability.getExpression(item.expression));
+            if (expressions.length === 0)
+                return;
+            const feelable = toFeelable(expressions);
+            const dependencies = this.programmability.getDependencies(feelable)
+                .filter(dep => dep !== key);
+            if (dependencies.length === 0)
+                return;
+            this.programmability.watch(formGroup, dependencies, () => {
+                setTimeout(() => {
+                    callbacks.invoke();
+                    control.updateValueAndValidity({ emitEvent: false });
+                });
+            });
+        }
+    }
+    logValidation = (component, rule, control, result) => {
+        if (this.programmability.verbose) {
+            if (result != null) {
+                console.warn("[Validation] Failed", { control, component, rule, result });
+            }
+            else {
+                console.log("[Validation] Success", { control, component, rule, result });
+            }
+        }
+    };
+    nullObserver = of(null);
+    get language() {
+        return this.languageService.getLanguage();
+    }
+    locale(component, key) {
+        return localize(this.language, component, key);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ValidationService, deps: [{ token: i1.LanguageService }, { token: i2.ProgrammabilityService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ValidationService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ValidationService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.LanguageService }, { type: i2.ProgrammabilityService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"validation.service.js","sourceRoot":"","sources":["../../../../../projects/ngx-sirio/src/lib/services/validation.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { ProgrammabilityService } from '../services/programmability.service';\r\nimport { AbstractControl, AsyncValidatorFn, FormGroup, ValidationErrors, ValidatorFn, Validators } from '@angular/forms';\r\nimport { LanguageService } from '@wemake4u/interact';\r\nimport { localize } from '../locale/localize';\r\nimport { isObservable, map, Observable, of, catchError, take } from 'rxjs';\r\nimport { toFeelable } from '../utils/feelable';\r\nimport { CallbackRegistry } from '../utils/CallbackRegistry';\r\n\r\n@Injectable()\r\nexport class ValidationService  {\r\n\r\n  constructor(\r\n    private languageService: LanguageService,\r\n    private programmability: ProgrammabilityService) {\r\n  }\r\n\r\n  suppress: boolean = false;\r\n\r\n  createCollection(): ValidationCollection {\r\n    return new Map<AbstractControl, ComponentContext>();\r\n  }\r\n\r\n  addToCollection(collection: ValidationCollection, control: AbstractControl, component: any, formGroup: FormGroup) {\r\n    collection.set(control, { component, formGroup });\r\n  }\r\n\r\n  setupCollection(collection: ValidationCollection) {\r\n    collection.forEach((componentValidation, control) => {\r\n      const component = componentValidation.component;\r\n      const currentGroup = componentValidation.formGroup;\r\n      const required = component?.validate?.required;\r\n      const rules = this.getRules(component);\r\n      const [validators, asyncValidators, watching] = this.validateRules(currentGroup, component, required, rules);\r\n      control.setValidators(validators);\r\n      control.setAsyncValidators(asyncValidators);\r\n      watching(control);\r\n    });\r\n  }\r\n\r\n  private getRules(component: any): ValidationRule[] {\r\n    if (!Array.isArray(component.validations)) return [];\r\n    return component.validations?.map((rule: any) => {\r\n      return {\r\n        expression: rule.expression,\r\n        type: rule.type,\r\n        message: this.locale(rule, 'message'),\r\n        async: rule.async === true\r\n      } as ValidationRule;\r\n    });\r\n  }\r\n\r\n  private validateRules(formGroup: FormGroup\r\n    , component: any\r\n    , required?: boolean\r\n    , validations?: ValidationRule[]): [ValidatorFn[], AsyncValidatorFn[], (control: AbstractControl) => void] {\r\n    const validators: ValidatorFn[] = [];\r\n\r\n    const asyncValidators: AsyncValidatorFn[] = [];\r\n\r\n    const noWatching = () => { };\r\n\r\n    if (required === true) {\r\n      validators.push(Validators.required);\r\n    }\r\n\r\n    if (!Array.isArray(validations)) {\r\n      return [validators, asyncValidators, noWatching];\r\n    }\r\n\r\n    const callbacks = new CallbackRegistry();\r\n\r\n    validations.forEach((item: ValidationRule) => {\r\n      if (!this.programmability.isExpression(item.expression))\r\n        return;\r\n\r\n      const logger: ValidationCallback = (control: AbstractControl, result: ValidationErrors | null) =>\r\n        this.logValidation(component, item, control, result);\r\n      \r\n      if (item.type === \"validate\" || item.type === \"invalidate\") {\r\n        const predicate = item.type === \"validate\"\r\n          ? (result: any) => result\r\n          : (result: any) => !result;\r\n\r\n        if (item.async) {\r\n          asyncValidators.push(this.createAsyncValidator(formGroup, item, callbacks, predicate, logger));\r\n        }\r\n        else {\r\n          validators.push(this.createValidator(formGroup, item, predicate, logger));\r\n        }\r\n      }\r\n    });\r\n\r\n    const watching = (control: AbstractControl): void => {\r\n      this.watchForValidation(formGroup, control, component.key, validations, callbacks);\r\n    };\r\n\r\n    return [validators, asyncValidators, watching];\r\n  }\r\n\r\n  private createValidator(formGroup: FormGroup\r\n    , item: ValidationRule\r\n    , predicate: (result: any) => boolean\r\n    , callback: ValidationCallback): ValidatorFn {\r\n    return (control: AbstractControl): ValidationErrors | null => {\r\n      if (this.suppress) return null;\r\n      const result = this.programmability.evaluateUnary(formGroup, item.expression, control.value)\r\n      if (isObservable(result)) {\r\n        console.warn(\r\n          \"[Validator] Unexpected observable result in createValidator\",\r\n          { expression: item.expression, value: control.value, rule: item }\r\n        );\r\n        return null;\r\n      }\r\n      const validate = predicate(result) ? null : this.validationErrors(formGroup, item);\r\n      callback(control, validate);\r\n      return validate;\r\n    };\r\n  }\r\n\r\n  private createAsyncValidator(formGroup: FormGroup\r\n    , item: ValidationRule\r\n    , callbacks: CallbackRegistry\r\n    , predicate: (result: any) => boolean\r\n    , callback: ValidationCallback): AsyncValidatorFn {\r\n\r\n    const unsetState = () => ({ value: Symbol('unset'), result: null });\r\n\r\n    let state = unsetState();\r\n\r\n    callbacks.register(() => state = unsetState());\r\n\r\n    const getResult = (control: AbstractControl): any => this.programmability.evaluate(formGroup, item.expression, {\r\n      cacheable: false,\r\n      extendContext: () => { return { \"?\": control.value } }\r\n    });\r\n\r\n    const computeOnce = (control: AbstractControl): any => {\r\n      const v = control.value;\r\n      if (state.value !== v) {\r\n        let result = getResult(control);\r\n        if (isObservable(result)) {\r\n          result = (result as Observable<any>).pipe(\r\n            take(1),\r\n            map((value: any) => {\r\n              const validate = predicate(value) ? null : this.validationErrors(formGroup, item);\r\n              callback(control, validate);\r\n              return validate;\r\n            }),\r\n            catchError(err => {\r\n              console.error(\"[AsyncValidator] Evaluation error\", { expression: item.expression, err });\r\n              return this.nullObserver;\r\n            })\r\n          );\r\n        }\r\n        state = { value: v, result: result };\r\n      }\r\n      return state.result;\r\n    };\r\n\r\n    return (control: AbstractControl) => {\r\n      if (this.suppress) return this.nullObserver;\r\n      const result = computeOnce(control);      \r\n      if (!isObservable(result)) {\r\n        console.warn(\r\n          \"[AsyncValidator] Expected observable but got non-observable result\",\r\n          { expression: item.expression, value: control.value, result, rule: item }\r\n        );\r\n        return this.nullObserver;\r\n      }\r\n      return result as Observable<any>;\r\n    };\r\n  }\r\n\r\n  private validationErrors(formGroup: FormGroup, item: ValidationRule) {\r\n    const message = this.programmability.evaluateString(formGroup, item.message);\r\n    const validationError = { error: true, message };\r\n    return validationError;\r\n  }\r\n\r\n  private watchForValidation(formGroup: FormGroup\r\n    , control: AbstractControl\r\n    , key: string\r\n    , validations: ValidationRule[]\r\n    , callbacks: CallbackRegistry): void {\r\n\r\n    if (Array.isArray(validations)) {\r\n      const expressions = validations\r\n        .filter(item => this.programmability.isExpression(item.expression))\r\n        .map(item => \"=\" + this.programmability.getExpression(item.expression));\r\n\r\n      if (expressions.length === 0) return;\r\n\r\n      const feelable = toFeelable(expressions);\r\n\r\n      const dependencies = this.programmability.getDependencies(feelable)\r\n        .filter(dep => dep !== key);\r\n\r\n      if (dependencies.length === 0) return;\r\n\r\n      this.programmability.watch(formGroup, dependencies, () => {\r\n        setTimeout(() => {\r\n          callbacks.invoke();\r\n          control.updateValueAndValidity({ emitEvent: false });\r\n        });\r\n\r\n      });\r\n    }\r\n  }\r\n\r\n  private logValidation = (component: any, rule: ValidationRule, control: AbstractControl, result: ValidationErrors | null) => {\r\n    if (this.programmability.verbose) {\r\n      if (result != null) {\r\n        console.warn(\"[Validation] Failed\", { control, component, rule, result });\r\n      }\r\n      else {\r\n        console.log(\"[Validation] Success\", { control, component, rule, result });\r\n      }\r\n    }\r\n  }\r\n\r\n  private readonly nullObserver = of(null);\r\n\r\n  private get language(): string {\r\n    return this.languageService.getLanguage();\r\n  }\r\n\r\n  private locale(component: any, key: string): string {\r\n    return localize(this.language, component, key);\r\n  }\r\n}\r\n\r\ntype ValidationCallback = (control: AbstractControl, result: ValidationErrors | null) => void;\r\n\r\nexport interface ComponentContext {\r\n  component: any;\r\n  formGroup: FormGroup;\r\n}\r\n\r\nexport interface ValidationRule {\r\n  expression: string;\r\n  type: \"validate\" | \"invalidate\";\r\n  message: string,\r\n  async: boolean\r\n}\r\n\r\nexport type ValidationCollection = Map<AbstractControl, ComponentContext>;\r\n"]}

package/esm2022/lib/utils/CallbackRegistry.mjs

@@ -0,0 +1,16 @@
+export class CallbackRegistry {
+    callbacks = [];
+    register(callback) {
+        if (callback)
+            this.callbacks.push(callback);
+    }
+    clear() {
+        this.callbacks = [];
+    }
+    invoke() {
+        for (const cb of this.callbacks) {
+            cb();
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ2FsbGJhY2tSZWdpc3RyeS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25neC1zaXJpby9zcmMvbGliL3V0aWxzL0NhbGxiYWNrUmVnaXN0cnkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxPQUFPLGdCQUFnQjtJQUNuQixTQUFTLEdBQW1CLEVBQUUsQ0FBQztJQUV2QyxRQUFRLENBQUMsUUFBb0I7UUFDM0IsSUFBSSxRQUFRO1lBQ1YsSUFBSSxDQUFDLFNBQVMsQ0FBQyxJQUFJLENBQUMsUUFBUSxDQUFDLENBQUM7SUFDbEMsQ0FBQztJQUVELEtBQUs7UUFDSCxJQUFJLENBQUMsU0FBUyxHQUFHLEVBQUUsQ0FBQztJQUN0QixDQUFDO0lBRUQsTUFBTTtRQUNKLEtBQUssTUFBTSxFQUFFLElBQUksSUFBSSxDQUFDLFNBQVMsRUFBRSxDQUFDO1lBQ2hDLEVBQUUsRUFBRSxDQUFDO1FBQ1AsQ0FBQztJQUNILENBQUM7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBjbGFzcyBDYWxsYmFja1JlZ2lzdHJ5IHtcclxuICBwcml2YXRlIGNhbGxiYWNrczogKCgpID0+IHZvaWQpW10gPSBbXTtcclxuXHJcbiAgcmVnaXN0ZXIoY2FsbGJhY2s6ICgpID0+IHZvaWQpIHtcclxuICAgIGlmIChjYWxsYmFjaylcclxuICAgICAgdGhpcy5jYWxsYmFja3MucHVzaChjYWxsYmFjayk7XHJcbiAgfVxyXG5cclxuICBjbGVhcigpIHtcclxuICAgIHRoaXMuY2FsbGJhY2tzID0gW107XHJcbiAgfVxyXG5cclxuICBpbnZva2UoKSB7XHJcbiAgICBmb3IgKGNvbnN0IGNiIG9mIHRoaXMuY2FsbGJhY2tzKSB7XHJcbiAgICAgIGNiKCk7XHJcbiAgICB9XHJcbiAgfVxyXG59XHJcbiJdfQ==