@alauda-fe/common 1.0.0-hotfix-znx-3.16.1-1

package/esm2022/effect-directive/event.directive.mjs

@@ -0,0 +1,56 @@
+import { __decorate, __metadata } from "tslib";
+import { Directive, Input } from '@angular/core';
+import { isBoolean } from 'lodash-es';
+import { ValueHook } from '../core/utils/public-api';
+import * as i0 from "@angular/core";
+export class PreventDirective {
+    constructor() {
+        this.prevent = true;
+    }
+    static { this.ɵfac = function PreventDirective_Factory(t) { return new (t || PreventDirective)(); }; }
+    static { this.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: PreventDirective, selectors: [["", "prevent", ""]], hostAttrs: ["click", "prevent && $event.preventDefault()"], inputs: { prevent: "prevent" }, standalone: true }); }
+}
+__decorate([
+    ValueHook(isBoolean),
+    __metadata("design:type", Object)
+], PreventDirective.prototype, "prevent", void 0);
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PreventDirective, [{
+        type: Directive,
+        args: [{
+                // eslint-disable-next-line @angular-eslint/directive-selector
+                selector: '[prevent]',
+                // eslint-disable-next-line @angular-eslint/no-host-metadata-property
+                host: {
+                    click: 'prevent && $event.preventDefault()',
+                },
+                standalone: true,
+            }]
+    }], null, { prevent: [{
+            type: Input
+        }] }); })();
+export class StopDirective {
+    constructor() {
+        this.stop = true;
+    }
+    static { this.ɵfac = function StopDirective_Factory(t) { return new (t || StopDirective)(); }; }
+    static { this.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: StopDirective, selectors: [["", "stop", ""]], hostAttrs: ["click", "stop && $event.stopPropagation()"], inputs: { stop: "stop" }, standalone: true }); }
+}
+__decorate([
+    ValueHook(isBoolean),
+    __metadata("design:type", Object)
+], StopDirective.prototype, "stop", void 0);
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(StopDirective, [{
+        type: Directive,
+        args: [{
+                // eslint-disable-next-line @angular-eslint/directive-selector
+                selector: '[stop]',
+                // eslint-disable-next-line @angular-eslint/no-host-metadata-property
+                host: {
+                    click: 'stop && $event.stopPropagation()',
+                },
+                standalone: true,
+            }]
+    }], null, { stop: [{
+            type: Input
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/effect-directive/min-max.directive.mjs

@@ -0,0 +1,111 @@
+import { Directive, HostBinding, Input, forwardRef, } from '@angular/core';
+import { NG_VALIDATORS, Validators, } from '@angular/forms';
+import * as i0 from "@angular/core";
+/**
+ * Angular form directives for min/max.
+ */
+export class MaxValidatorDirective {
+    get maxValue() {
+        return this.max || this.max === 0 ? this.max : null;
+    }
+    ngOnChanges(changes) {
+        if ('max' in changes) {
+            this._createValidator();
+            if (this._onChange) {
+                this._onChange();
+            }
+        }
+    }
+    validate(c) {
+        return this.max == null ? null : this._validator(c);
+    }
+    registerOnValidatorChange(fn) {
+        this._onChange = fn;
+    }
+    _createValidator() {
+        this._validator = Validators.max(typeof this.max === 'number' ? this.max : parseFloat(this.max));
+    }
+    static { this.ɵfac = function MaxValidatorDirective_Factory(t) { return new (t || MaxValidatorDirective)(); }; }
+    static { this.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: MaxValidatorDirective, selectors: [["", "max", "", "formControlName", ""], ["", "max", "", "formControl", ""], ["", "max", "", "ngModel", ""]], hostVars: 1, hostBindings: function MaxValidatorDirective_HostBindings(rf, ctx) { if (rf & 2) {
+            i0.ɵɵattribute("max", ctx.maxValue);
+        } }, inputs: { max: "max" }, standalone: true, features: [i0.ɵɵProvidersFeature([
+                {
+                    provide: NG_VALIDATORS,
+                    useExisting: forwardRef(() => MaxValidatorDirective),
+                    multi: true,
+                },
+            ]), i0.ɵɵNgOnChangesFeature] }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(MaxValidatorDirective, [{
+        type: Directive,
+        args: [{
+                // eslint-disable-next-line @angular-eslint/directive-selector
+                selector: '[max][formControlName],[max][formControl],[max][ngModel]',
+                providers: [
+                    {
+                        provide: NG_VALIDATORS,
+                        useExisting: forwardRef(() => MaxValidatorDirective),
+                        multi: true,
+                    },
+                ],
+                standalone: true,
+            }]
+    }], null, { max: [{
+            type: Input
+        }], maxValue: [{
+            type: HostBinding,
+            args: ['attr.max']
+        }] }); })();
+export class MinValidatorDirective {
+    get maxValue() {
+        return this.min || this.min === 0 ? this.min : null;
+    }
+    ngOnChanges(changes) {
+        if ('min' in changes) {
+            this._createValidator();
+            if (this._onChange) {
+                this._onChange();
+            }
+        }
+    }
+    validate(c) {
+        return this.min == null ? null : this._validator(c);
+    }
+    registerOnValidatorChange(fn) {
+        this._onChange = fn;
+    }
+    _createValidator() {
+        this._validator = Validators.min(typeof this.min === 'number' ? this.min : parseFloat(this.min));
+    }
+    static { this.ɵfac = function MinValidatorDirective_Factory(t) { return new (t || MinValidatorDirective)(); }; }
+    static { this.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: MinValidatorDirective, selectors: [["", "min", "", "formControlName", ""], ["", "min", "", "formControl", ""], ["", "min", "", "ngModel", ""]], hostVars: 1, hostBindings: function MinValidatorDirective_HostBindings(rf, ctx) { if (rf & 2) {
+            i0.ɵɵattribute("min", ctx.maxValue);
+        } }, inputs: { min: "min" }, standalone: true, features: [i0.ɵɵProvidersFeature([
+                {
+                    provide: NG_VALIDATORS,
+                    useExisting: forwardRef(() => MinValidatorDirective),
+                    multi: true,
+                },
+            ]), i0.ɵɵNgOnChangesFeature] }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(MinValidatorDirective, [{
+        type: Directive,
+        args: [{
+                // eslint-disable-next-line @angular-eslint/directive-selector
+                selector: '[min][formControlName],[min][formControl],[min][ngModel]',
+                providers: [
+                    {
+                        provide: NG_VALIDATORS,
+                        useExisting: forwardRef(() => MinValidatorDirective),
+                        multi: true,
+                    },
+                ],
+                standalone: true,
+            }]
+    }], null, { maxValue: [{
+            type: HostBinding,
+            args: ['attr.min']
+        }], min: [{
+            type: Input
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/effect-directive/module.mjs

@@ -0,0 +1,46 @@
+import { NgModule } from '@angular/core';
+import { E2eAttributeBindingDirective } from './e2e-attribute-binding.directive';
+import { PreventDirective, StopDirective } from './event.directive';
+import { MaxValidatorDirective, MinValidatorDirective, } from './min-max.directive';
+import { TrimDirective } from './trim.directive';
+import { ValidatorsDirective } from './validators.directive';
+import * as i0 from "@angular/core";
+const directives = [
+    E2eAttributeBindingDirective,
+    MaxValidatorDirective,
+    MinValidatorDirective,
+    TrimDirective,
+    ValidatorsDirective,
+    PreventDirective,
+    StopDirective,
+];
+/**
+ * 扩展已有属性行为的副作用指令module
+ */
+export class EffectDirectiveModule {
+    static { this.ɵfac = function EffectDirectiveModule_Factory(t) { return new (t || EffectDirectiveModule)(); }; }
+    static { this.ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: EffectDirectiveModule }); }
+    static { this.ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({}); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(EffectDirectiveModule, [{
+        type: NgModule,
+        args: [{
+                imports: [...directives],
+                exports: [...directives],
+            }]
+    }], null, null); })();
+(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(EffectDirectiveModule, { imports: [E2eAttributeBindingDirective,
+        MaxValidatorDirective,
+        MinValidatorDirective,
+        TrimDirective,
+        ValidatorsDirective,
+        PreventDirective,
+        StopDirective], exports: [E2eAttributeBindingDirective,
+        MaxValidatorDirective,
+        MinValidatorDirective,
+        TrimDirective,
+        ValidatorsDirective,
+        PreventDirective,
+        StopDirective] }); })();
+export const EFFECT_DIRECTIVE_MODULE = directives;
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/effect-directive/public-api.mjs

@@ -0,0 +1,8 @@
+export * from './module';
+export * from './coerce-number.directive';
+export * from './e2e-attribute-binding.directive';
+export * from './event.directive';
+export * from './min-max.directive';
+export * from './trim.directive';
+export * from './validators.directive';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL2xpYnMvY29tbW9uL3NyYy9lZmZlY3QtZGlyZWN0aXZlL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxVQUFVLENBQUM7QUFDekIsY0FBYywyQkFBMkIsQ0FBQztBQUMxQyxjQUFjLG1DQUFtQyxDQUFDO0FBQ2xELGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsd0JBQXdCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL21vZHVsZSc7XG5leHBvcnQgKiBmcm9tICcuL2NvZXJjZS1udW1iZXIuZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vZTJlLWF0dHJpYnV0ZS1iaW5kaW5nLmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL2V2ZW50LmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL21pbi1tYXguZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vdHJpbS5kaXJlY3RpdmUnO1xuZXhwb3J0ICogZnJvbSAnLi92YWxpZGF0b3JzLmRpcmVjdGl2ZSc7XG4iXX0=

package/esm2022/effect-directive/trim.directive.mjs

@@ -0,0 +1,43 @@
+import { Directive, forwardRef } from '@angular/core';
+import { DefaultValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';
+import * as i0 from "@angular/core";
+export class TrimDirective extends DefaultValueAccessor {
+    _handleInput(value) {
+        if (value != null) {
+            this.onChange(value.trim());
+        }
+    }
+    static { this.ɵfac = /*@__PURE__*/ function () { let ɵTrimDirective_BaseFactory; return function TrimDirective_Factory(t) { return (ɵTrimDirective_BaseFactory || (ɵTrimDirective_BaseFactory = i0.ɵɵgetInheritedFactory(TrimDirective)))(t || TrimDirective); }; }(); }
+    static { this.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: TrimDirective, selectors: [["input", "trim", ""], ["textarea", "trim", ""]], hostBindings: function TrimDirective_HostBindings(rf, ctx) { if (rf & 1) {
+            i0.ɵɵlistener("input", function TrimDirective_input_HostBindingHandler($event) { return ctx._handleInput($event.target.value); })("blur", function TrimDirective_blur_HostBindingHandler() { return ctx.onTouched(); })("compositionstart", function TrimDirective_compositionstart_HostBindingHandler() { return ctx._compositionStart(); })("compositionend", function TrimDirective_compositionend_HostBindingHandler($event) { return ctx._compositionEnd($event.target.value); });
+        } }, standalone: true, features: [i0.ɵɵProvidersFeature([
+                {
+                    provide: NG_VALUE_ACCESSOR,
+                    useExisting: forwardRef(() => TrimDirective),
+                    multi: true,
+                },
+            ]), i0.ɵɵInheritDefinitionFeature] }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(TrimDirective, [{
+        type: Directive,
+        args: [{
+                // eslint-disable-next-line @angular-eslint/directive-selector
+                selector: 'input[trim],textarea[trim]]',
+                // eslint-disable-next-line @angular-eslint/no-host-metadata-property
+                host: {
+                    '(input)': '$any(this)._handleInput($event.target.value)',
+                    '(blur)': 'onTouched()',
+                    '(compositionstart)': '$any(this)._compositionStart()',
+                    '(compositionend)': '$any(this)._compositionEnd($event.target.value)',
+                },
+                providers: [
+                    {
+                        provide: NG_VALUE_ACCESSOR,
+                        useExisting: forwardRef(() => TrimDirective),
+                        multi: true,
+                    },
+                ],
+                standalone: true,
+            }]
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJpbS5kaXJlY3RpdmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL2NvbW1vbi9zcmMvZWZmZWN0LWRpcmVjdGl2ZS90cmltLmRpcmVjdGl2ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN0RCxPQUFPLEVBQUUsb0JBQW9CLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQzs7QUFxQnpFLE1BQU0sT0FBTyxhQUFjLFNBQVEsb0JBQW9CO0lBQ3JELFlBQVksQ0FBQyxLQUFhO1FBQ3hCLElBQUksS0FBSyxJQUFJLElBQUksRUFBRTtZQUNqQixJQUFJLENBQUMsUUFBUSxDQUFDLEtBQUssQ0FBQyxJQUFJLEVBQUUsQ0FBQyxDQUFDO1NBQzdCO0lBQ0gsQ0FBQzs2TkFMVSxhQUFhLFNBQWIsYUFBYTtvRUFBYixhQUFhO29HQUFiLHFDQUE0Qyx1RUFBNUMsZUFBVywrRkFBWCx1QkFBOEIsaUdBQTlCLHdDQUNYO2dFQVZXO2dCQUNUO29CQUNFLE9BQU8sRUFBRSxpQkFBaUI7b0JBQzFCLFdBQVcsRUFBRSxVQUFVLENBQUMsR0FBRyxFQUFFLENBQUMsYUFBYSxDQUFDO29CQUM1QyxLQUFLLEVBQUUsSUFBSTtpQkFDWjthQUNGOzt1RkFHVSxhQUFhO2NBbkJ6QixTQUFTO2VBQUM7Z0JBQ1QsOERBQThEO2dCQUM5RCxRQUFRLEVBQUUsNkJBQTZCO2dCQUN2QyxxRUFBcUU7Z0JBQ3JFLElBQUksRUFBRTtvQkFDSixTQUFTLEVBQUUsOENBQThDO29CQUN6RCxRQUFRLEVBQUUsYUFBYTtvQkFDdkIsb0JBQW9CLEVBQUUsZ0NBQWdDO29CQUN0RCxrQkFBa0IsRUFBRSxpREFBaUQ7aUJBQ3RFO2dCQUNELFNBQVMsRUFBRTtvQkFDVDt3QkFDRSxPQUFPLEVBQUUsaUJBQWlCO3dCQUMxQixXQUFXLEVBQUUsVUFBVSxDQUFDLEdBQUcsRUFBRSxjQUFjLENBQUM7d0JBQzVDLEtBQUssRUFBRSxJQUFJO3FCQUNaO2lCQUNGO2dCQUNELFVBQVUsRUFBRSxJQUFJO2FBQ2pCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRGlyZWN0aXZlLCBmb3J3YXJkUmVmIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBEZWZhdWx0VmFsdWVBY2Nlc3NvciwgTkdfVkFMVUVfQUNDRVNTT1IgfSBmcm9tICdAYW5ndWxhci9mb3Jtcyc7XG5cbkBEaXJlY3RpdmUoe1xuICAvLyBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgQGFuZ3VsYXItZXNsaW50L2RpcmVjdGl2ZS1zZWxlY3RvclxuICBzZWxlY3RvcjogJ2lucHV0W3RyaW1dLHRleHRhcmVhW3RyaW1dXScsXG4gIC8vIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBAYW5ndWxhci1lc2xpbnQvbm8taG9zdC1tZXRhZGF0YS1wcm9wZXJ0eVxuICBob3N0OiB7XG4gICAgJyhpbnB1dCknOiAnJGFueSh0aGlzKS5faGFuZGxlSW5wdXQoJGV2ZW50LnRhcmdldC52YWx1ZSknLFxuICAgICcoYmx1ciknOiAnb25Ub3VjaGVkKCknLFxuICAgICcoY29tcG9zaXRpb25zdGFydCknOiAnJGFueSh0aGlzKS5fY29tcG9zaXRpb25TdGFydCgpJyxcbiAgICAnKGNvbXBvc2l0aW9uZW5kKSc6ICckYW55KHRoaXMpLl9jb21wb3NpdGlvbkVuZCgkZXZlbnQudGFyZ2V0LnZhbHVlKScsXG4gIH0sXG4gIHByb3ZpZGVyczogW1xuICAgIHtcbiAgICAgIHByb3ZpZGU6IE5HX1ZBTFVFX0FDQ0VTU09SLFxuICAgICAgdXNlRXhpc3Rpbmc6IGZvcndhcmRSZWYoKCkgPT4gVHJpbURpcmVjdGl2ZSksXG4gICAgICBtdWx0aTogdHJ1ZSxcbiAgICB9LFxuICBdLFxuICBzdGFuZGFsb25lOiB0cnVlLFxufSlcbmV4cG9ydCBjbGFzcyBUcmltRGlyZWN0aXZlIGV4dGVuZHMgRGVmYXVsdFZhbHVlQWNjZXNzb3Ige1xuICBfaGFuZGxlSW5wdXQodmFsdWU6IHN0cmluZykge1xuICAgIGlmICh2YWx1ZSAhPSBudWxsKSB7XG4gICAgICB0aGlzLm9uQ2hhbmdlKHZhbHVlLnRyaW0oKSk7XG4gICAgfVxuICB9XG59XG4iXX0=

package/esm2022/effect-directive/validators.directive.mjs

@@ -0,0 +1,43 @@
+import { Directive } from '@angular/core';
+import { NgControl } from '@angular/forms';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+function getSelector(validator) {
+    return `[ngModel][${validator}],[formControl][${validator}],[formControlName][${validator}]`;
+}
+export class ValidatorsDirective {
+    constructor(ngControl) {
+        this.ngControl = ngControl;
+    }
+    ngAfterViewInit() {
+        this.validate();
+    }
+    ngOnDestroy() {
+        this.validate();
+    }
+    validate() {
+        this.ngControl.control?.updateValueAndValidity();
+    }
+    static { this.ɵfac = function ValidatorsDirective_Factory(t) { return new (t || ValidatorsDirective)(i0.ɵɵdirectiveInject(i1.NgControl)); }; }
+    static { this.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: ValidatorsDirective, selectors: [["", "ngModel", "", "required", ""], ["", "formControl", "", "required", ""], ["", "formControlName", "", "required", ""], ["", "ngModel", "", "pattern", ""], ["", "formControl", "", "pattern", ""], ["", "formControlName", "", "pattern", ""], ["", "ngModel", "", "min", ""], ["", "formControl", "", "min", ""], ["", "formControlName", "", "min", ""], ["", "ngModel", "", "max", ""], ["", "formControl", "", "max", ""], ["", "formControlName", "", "max", ""], ["", "ngModel", "", "minlength", ""], ["", "formControl", "", "minlength", ""], ["", "formControlName", "", "minlength", ""], ["", "ngModel", "", "maxlength", ""], ["", "formControl", "", "maxlength", ""], ["", "formControlName", "", "maxlength", ""], ["", "ngModel", "", "email", ""], ["", "formControl", "", "email", ""], ["", "formControlName", "", "email", ""]], standalone: true }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ValidatorsDirective, [{
+        type: Directive,
+        args: [{
+                selector: getSelector('required') +
+                    ',' +
+                    getSelector('pattern') +
+                    ',' +
+                    getSelector('min') +
+                    ',' +
+                    getSelector('max') +
+                    ',' +
+                    getSelector('minlength') +
+                    ',' +
+                    getSelector('maxlength') +
+                    ',' +
+                    getSelector('email'),
+                standalone: true,
+            }]
+    }], function () { return [{ type: i1.NgControl }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/errors-mapper/base-errors-mapper.mjs

@@ -0,0 +1,42 @@
+import { Directive, Injector } from '@angular/core';
+import { TranslateService } from '../translate/public-api';
+import { DefaultErrorsMapperService } from './default-errors-mapper.service';
+import * as i0 from "@angular/core";
+export class BaseErrorsMapper {
+    getErrorMessage(errors, errorsMapper, errorsMapperFn, namePrefix, ignoreUnknownError = false) {
+        const firstError = Object.keys(errors || {})[0];
+        if (!firstError) {
+            return;
+        }
+        if (errorsMapper?.[firstError]) {
+            return errorsMapper[firstError];
+        }
+        if (errorsMapperFn) {
+            const res = errorsMapperFn(errors);
+            if (res) {
+                return res;
+            }
+        }
+        // only required error should be modified
+        if (namePrefix && firstError === 'required') {
+            return this.translate.get('required_item', { name: namePrefix });
+        }
+        // eslint-disable-next-line unicorn/no-array-method-this-argument
+        const definedError = this.mapperService.map(firstError, errors[firstError]);
+        return definedError
+            ? (namePrefix || '') + definedError
+            : ignoreUnknownError
+                ? ''
+                : this.translate.get('the_value_is_invalid');
+    }
+    constructor(injector) {
+        this.translate = injector.get(TranslateService);
+        this.mapperService = injector.get(DefaultErrorsMapperService);
+    }
+    static { this.ɵfac = function BaseErrorsMapper_Factory(t) { return new (t || BaseErrorsMapper)(i0.ɵɵdirectiveInject(i0.Injector)); }; }
+    static { this.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: BaseErrorsMapper }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(BaseErrorsMapper, [{
+        type: Directive
+    }], function () { return [{ type: i0.Injector }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/errors-mapper/default-errors-mapper.service.mjs

@@ -0,0 +1,65 @@
+import { Injectable } from '@angular/core';
+import { TranslateService } from '../translate/public-api';
+import * as i0 from "@angular/core";
+import * as i1 from "../translate/public-api";
+export class DefaultErrorsMapperService {
+    constructor(translate) {
+        this.translate = translate;
+    }
+    map(key, error) {
+        switch (key) {
+            case 'required': {
+                return this.translate.get('field_required');
+            }
+            case 'pattern': {
+                return this.translate.get('invalid_pattern');
+            }
+            case 'minlength': {
+                return this.translate.get('warning_min_length', {
+                    length: error.requiredLength,
+                });
+            }
+            case 'maxlength': {
+                return this.translate.get('warning_max_length', {
+                    length: error.requiredLength,
+                });
+            }
+            case 'min': {
+                return this.translate.get('warning_min', {
+                    value: error.min,
+                });
+            }
+            case 'max': {
+                return this.translate.get('warning_max', {
+                    value: error.max,
+                });
+            }
+            case 'number': {
+                return this.translate.get('invalid_number');
+            }
+            case 'includes': {
+                return this.translate.get('option_has_expired');
+            }
+            case 'dropdown_min_length': {
+                return this.translate.get('dropdown_min_length', {
+                    length: error.minLength,
+                });
+            }
+            case 'dropdown_max_length': {
+                return this.translate.get('dropdown_max_length', {
+                    length: error.maxLength,
+                });
+            }
+            default: {
+                return '';
+            }
+        }
+    }
+    static { this.ɵfac = function DefaultErrorsMapperService_Factory(t) { return new (t || DefaultErrorsMapperService)(i0.ɵɵinject(i1.TranslateService)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: DefaultErrorsMapperService, factory: DefaultErrorsMapperService.ɵfac, providedIn: 'root' }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(DefaultErrorsMapperService, [{
+        type: Injectable,
+        args: [{ providedIn: 'root' }]
+    }], function () { return [{ type: i1.TranslateService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/errors-mapper/errors-mapper-component/component.mjs

@@ -0,0 +1,71 @@
+import { __decorate, __metadata } from "tslib";
+import { AsyncPipe, NgIf } from '@angular/common';
+import { ChangeDetectionStrategy, Component, Input, ViewEncapsulation, } from '@angular/core';
+import { Observable, combineLatest, distinctUntilChanged, map, startWith, } from 'rxjs';
+import { ObservableInput, publishRef } from '../../core/public-api';
+import { BaseErrorsMapper } from '../base-errors-mapper';
+import * as i0 from "@angular/core";
+function ErrorsMapperComponent_span_0_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "span", 1);
+    i0.ɵɵtext(1);
+    i0.ɵɵpipe(2, "async");
+    i0.ɵɵprojection(3);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r0 = i0.ɵɵnextContext();
+    i0.ɵɵadvance(1);
+    i0.ɵɵtextInterpolate1(" ", i0.ɵɵpipeBind1(2, 1, ctx_r0.errorMessage$), " ");
+} }
+const _c0 = ["*"];
+export class ErrorsMapperComponent extends BaseErrorsMapper {
+    constructor() {
+        super(...arguments);
+        this.ignoreUnknownError = false;
+        this.errorMessage$ = combineLatest([
+            this.errors$,
+            this.errorsMapper$,
+            this.errorsMapperFn$,
+            this.controlName$.pipe(startWith('')),
+            this.translate.locale$,
+        ]).pipe(map(([errors, errorsMapper, errorsMapperFn, name]) => this.getErrorMessage(errors, errorsMapper, errorsMapperFn, name, this.ignoreUnknownError)), distinctUntilChanged(), publishRef());
+    }
+    static { this.ɵfac = /*@__PURE__*/ function () { let ɵErrorsMapperComponent_BaseFactory; return function ErrorsMapperComponent_Factory(t) { return (ɵErrorsMapperComponent_BaseFactory || (ɵErrorsMapperComponent_BaseFactory = i0.ɵɵgetInheritedFactory(ErrorsMapperComponent)))(t || ErrorsMapperComponent); }; }(); }
+    static { this.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: ErrorsMapperComponent, selectors: [["acl-errors-mapper"]], inputs: { errors: "errors", errorsMapper: "errorsMapper", errorsMapperFn: "errorsMapperFn", controlName: "controlName", ignoreUnknownError: "ignoreUnknownError" }, standalone: true, features: [i0.ɵɵInheritDefinitionFeature, i0.ɵɵStandaloneFeature], ngContentSelectors: _c0, decls: 2, vars: 3, consts: [["class", "acl-error-hint", 4, "ngIf"], [1, "acl-error-hint"]], template: function ErrorsMapperComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵtemplate(0, ErrorsMapperComponent_span_0_Template, 4, 3, "span", 0);
+            i0.ɵɵpipe(1, "async");
+        } if (rf & 2) {
+            i0.ɵɵproperty("ngIf", i0.ɵɵpipeBind1(1, 1, ctx.errors$));
+        } }, dependencies: [AsyncPipe, NgIf], styles: ["acl-errors-mapper{display:block;color:rgb(var(--aui-color-red));font-size:var(--aui-font-size-s);line-height:var(--aui-line-height-s);font-weight:var(--aui-font-weight-normal)}acl-errors-mapper .acl-error-hint{display:inline-block;margin-top:var(--aui-spacing-s)}.aui-form-item__error-wrapper acl-errors-mapper .acl-error-hint,.aui-form-item__hint-wrapper acl-errors-mapper .acl-error-hint{margin-top:0}\n"], encapsulation: 2, changeDetection: 0 }); }
+}
+__decorate([
+    ObservableInput(),
+    __metadata("design:type", Observable)
+], ErrorsMapperComponent.prototype, "errors$", void 0);
+__decorate([
+    ObservableInput(),
+    __metadata("design:type", Observable)
+], ErrorsMapperComponent.prototype, "errorsMapper$", void 0);
+__decorate([
+    ObservableInput(),
+    __metadata("design:type", Observable)
+], ErrorsMapperComponent.prototype, "errorsMapperFn$", void 0);
+__decorate([
+    ObservableInput(),
+    __metadata("design:type", Observable)
+], ErrorsMapperComponent.prototype, "controlName$", void 0);
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ErrorsMapperComponent, [{
+        type: Component,
+        args: [{ selector: 'acl-errors-mapper', changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.None, preserveWhitespaces: false, standalone: true, imports: [AsyncPipe, NgIf], template: "<span\n  *ngIf=\"errors$ | async\"\n  class=\"acl-error-hint\"\n>\n  {{ errorMessage$ | async }}\n  <ng-content></ng-content>\n</span>\n", styles: ["acl-errors-mapper{display:block;color:rgb(var(--aui-color-red));font-size:var(--aui-font-size-s);line-height:var(--aui-line-height-s);font-weight:var(--aui-font-weight-normal)}acl-errors-mapper .acl-error-hint{display:inline-block;margin-top:var(--aui-spacing-s)}.aui-form-item__error-wrapper acl-errors-mapper .acl-error-hint,.aui-form-item__hint-wrapper acl-errors-mapper .acl-error-hint{margin-top:0}\n"] }]
+    }], null, { errors: [{
+            type: Input
+        }], errors$: [], errorsMapper: [{
+            type: Input
+        }], errorsMapper$: [], errorsMapperFn: [{
+            type: Input
+        }], errorsMapperFn$: [], controlName: [{
+            type: Input
+        }], controlName$: [], ignoreUnknownError: [{
+            type: Input
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,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