@sumaris-net/ngx-components 2.6.26 → 2.7.0-rc10

package/esm2022/src/app/shared/validator/form-error-adapter.class.mjs

@@ -0,0 +1,106 @@
+import { changeCaseToUnderscore, isEmptyArray, isNil } from '../functions';
+import { Inject, Injectable, InjectionToken, Optional } from '@angular/core';
+import { AppFormUtils } from '../../core/form/form.utils';
+import { SharedValidators } from './validators';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+export const APP_FORM_ERROR_I18N_KEYS = new InjectionToken('appFormErrorKeys');
+export class FormErrorTranslator {
+    translate;
+    errorI18nKeys;
+    constructor(translate, errorI18nKeys) {
+        this.translate = translate;
+        this.errorI18nKeys = {
+            ...SharedValidators.I18N_ERROR_KEYS,
+            ...errorI18nKeys
+        };
+    }
+    translateFormErrors(control, opts) {
+        if (!control || !control.invalid)
+            return '';
+        const separator = opts && opts.separator || ', ';
+        const recursive = !opts || opts.recursive !== false;
+        const errors = AppFormUtils.getFormErrors(control, { recursive });
+        return errors && Object.keys(errors).reduce((res, path) => {
+            const childControl = control.get(path);
+            // Should be a control map of errors
+            if (childControl) {
+                // Try to convert the control path
+                const i18nPath = this.translateControlPath(path, opts);
+                // OK, we have a field name: use it
+                const columnErrors = Object.keys(childControl.errors).map(errorKey => this.translateError(errorKey, childControl.errors[errorKey]));
+                if (isEmptyArray(columnErrors))
+                    return res;
+                // Add separator
+                if (res.length)
+                    res += separator;
+                return res + i18nPath + ': ' + columnErrors.join(separator);
+            }
+            // Or try as global form error
+            const formError = this.translateError(path, errors[path]);
+            if (isNil(formError))
+                return res;
+            return res + (res.length ? separator : '') + formError;
+        }, '');
+    }
+    translateErrors(errors, opts) {
+        const separator = opts && opts.separator || ', ';
+        return errors && Object.keys(errors).reduce((res, path) => {
+            const pathErrors = errors[path];
+            // Should be a control map of errors
+            if (pathErrors) {
+                // Try to convert the control path
+                const i18nPath = this.translateControlPath(path, opts);
+                // OK, we have a field name: use it
+                const columnErrors = Object.keys(pathErrors).map(errorKey => this.translateError(errorKey, pathErrors[errorKey]));
+                if (isEmptyArray(columnErrors))
+                    return res;
+                // Add separator
+                if (res.length)
+                    res += separator;
+                return res + i18nPath + ': ' + columnErrors.join(separator);
+            }
+            // Or try as global form error
+            const formError = this.translateError(path, pathErrors);
+            if (isNil(formError))
+                return res;
+            return res + (res.length ? separator : '') + formError;
+        }, '');
+    }
+    translateControlPath(path, opts) {
+        if (opts?.controlPathTranslator) {
+            return opts?.controlPathTranslator.translateControlPath(path);
+        }
+        const i18nKey = (opts && opts.i18nPrefix || '') + changeCaseToUnderscore(path).toUpperCase();
+        return this.translate.instant(i18nKey);
+    }
+    translateError(errorKey, errorContent) {
+        const i18nKey = this.errorI18nKeys[errorKey]
+            // Try to generate a standard error key, like 'ERROR.FIELD_xxx_xxx'
+            || ('ERROR.FIELD_' + changeCaseToUnderscore(errorKey).toUpperCase());
+        let i18nMessage = this.translate.instant(i18nKey, errorContent);
+        if (i18nKey !== i18nMessage)
+            return i18nMessage;
+        // Try to use the error content, as an i18n key
+        if (typeof errorContent === 'string') {
+            i18nMessage = this.translate.instant(errorContent);
+            if (errorContent !== i18nMessage)
+                return i18nMessage;
+        }
+        // Not translated: show error
+        console.error(`[form-error-adapter] Cannot translate error key '${errorKey}'. Please add more formErrorsKey into APP_FORM_ERROR_I18N_KEYS injection token`);
+        return errorKey;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.1", ngImport: i0, type: FormErrorTranslator, deps: [{ token: i1.TranslateService }, { token: APP_FORM_ERROR_I18N_KEYS, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.1", ngImport: i0, type: FormErrorTranslator, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.1", ngImport: i0, type: FormErrorTranslator, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i1.TranslateService }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [APP_FORM_ERROR_I18N_KEYS]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"form-error-adapter.class.js","sourceRoot":"","sources":["../../../../../../src/app/shared/validator/form-error-adapter.class.ts"],"names":[],"mappings":"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","sourcesContent":["import {changeCaseToUnderscore, isEmptyArray, isNil} from '../functions';\nimport {Inject, Injectable, InjectionToken, Optional} from '@angular/core';\nimport {TranslateService} from '@ngx-translate/core';\nimport {AbstractControl} from '@angular/forms';\nimport {AppFormUtils} from '../../core/form/form.utils';\nimport {SharedValidators} from './validators';\nimport {ObjectMap} from '../types';\nimport {FormErrors} from '../forms';\n\n\nexport const APP_FORM_ERROR_I18N_KEYS = new InjectionToken<ObjectMap<string>>('appFormErrorKeys');\n\nexport interface IFormControlPathTranslator {\n  translateControlPath: (controlPath: string) => string;\n}\n\nexport interface FormErrorTranslatorOptions {\n  i18nPrefix?: string;\n  controlPathTranslator?: IFormControlPathTranslator;\n  separator?: string;\n  recursive?: boolean;\n}\n\n@Injectable({providedIn: 'root'})\nexport class FormErrorTranslator implements IFormControlPathTranslator {\n\n  private readonly errorI18nKeys: ObjectMap<string>;\n\n  constructor(\n    private translate: TranslateService,\n    @Optional() @Inject(APP_FORM_ERROR_I18N_KEYS) errorI18nKeys: ObjectMap<string>\n  ) {\n    this.errorI18nKeys = {\n      ...SharedValidators.I18N_ERROR_KEYS,\n      ...errorI18nKeys\n    };\n  }\n\n  translateFormErrors(control: AbstractControl, opts?: FormErrorTranslatorOptions): string {\n    if (!control || !control.invalid) return '';\n\n    const separator = opts && opts.separator || ', ';\n    const recursive = !opts || opts.recursive !== false;\n    const errors = AppFormUtils.getFormErrors(control, {recursive});\n    return errors && Object.keys(errors).reduce((res, path) => {\n\n      const childControl = control.get(path);\n      // Should be a control map of errors\n      if (childControl) {\n        // Try to convert the control path\n        const i18nPath = this.translateControlPath(path, opts);\n\n        // OK, we have a field name: use it\n        const columnErrors = Object.keys(childControl.errors).map(errorKey => this.translateError(errorKey, childControl.errors[errorKey]));\n        if (isEmptyArray(columnErrors)) return res;\n        // Add separator\n        if (res.length) res += separator;\n        return res + i18nPath + ': ' + columnErrors.join(separator);\n      }\n\n      // Or try as global form error\n      const formError = this.translateError(path, errors[path]);\n      if (isNil(formError)) return res;\n      return res + (res.length ? separator : '') + formError;\n    }, '');\n  }\n\n  translateErrors(errors: FormErrors, opts?: FormErrorTranslatorOptions): string {\n\n    const separator = opts && opts.separator || ', ';\n    return errors && Object.keys(errors).reduce((res, path) => {\n\n      const pathErrors = errors[path];\n      // Should be a control map of errors\n\n      if (pathErrors) {\n        // Try to convert the control path\n        const i18nPath = this.translateControlPath(path, opts);\n\n        // OK, we have a field name: use it\n        const columnErrors = Object.keys(pathErrors).map(errorKey => this.translateError(errorKey, pathErrors[errorKey]));\n        if (isEmptyArray(columnErrors)) return res;\n        // Add separator\n        if (res.length) res += separator;\n        return res + i18nPath + ': ' + columnErrors.join(separator);\n      }\n\n      // Or try as global form error\n      const formError = this.translateError(path, pathErrors);\n      if (isNil(formError)) return res;\n      return res + (res.length ? separator : '') + formError;\n    }, '');\n  }\n\n  translateControlPath(path: string, opts?: FormErrorTranslatorOptions): string{\n    if (opts?.controlPathTranslator) {\n      return opts?.controlPathTranslator.translateControlPath(path);\n    }\n    const i18nKey = (opts && opts.i18nPrefix || '') + changeCaseToUnderscore(path).toUpperCase();\n    return this.translate.instant(i18nKey);\n  }\n\n  translateError(errorKey: string, errorContent?: any) {\n\n    const i18nKey = this.errorI18nKeys[errorKey]\n      // Try to generate a standard error key, like 'ERROR.FIELD_xxx_xxx'\n      || ('ERROR.FIELD_' + changeCaseToUnderscore(errorKey).toUpperCase());\n\n    let i18nMessage = this.translate.instant(i18nKey, errorContent);\n    if (i18nKey !== i18nMessage) return i18nMessage;\n\n    // Try to use the error content, as an i18n key\n    if (typeof errorContent === 'string') {\n      i18nMessage = this.translate.instant(errorContent);\n      if (errorContent !== i18nMessage) return i18nMessage;\n    }\n\n    // Not translated: show error\n    console.error(`[form-error-adapter] Cannot translate error key '${errorKey}'. Please add more formErrorsKey into APP_FORM_ERROR_I18N_KEYS injection token`);\n\n    return errorKey;\n  }\n}\n"]}