@alauda-fe/common 1.0.0-next.0

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,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

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';
+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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

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

@@ -0,0 +1,115 @@
+import { __decorate, __metadata } from "tslib";
+import { ComponentPortal, DomPortalOutlet } from '@angular/cdk/portal';
+import { ApplicationRef, ChangeDetectionStrategy, ChangeDetectorRef, Component, ComponentFactoryResolver, Directive, Injector, Input, Optional, Self, } from '@angular/core';
+import { FormGroupDirective, NgControl, NgForm } from '@angular/forms';
+import { Observable, Subject, merge, of, debounceTime, map, switchMap, takeUntil, } from 'rxjs';
+import { ObservableInput } from '../core/public-api';
+import { BaseErrorsMapper } from './base-errors-mapper';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+export class ErrorsMapperDirective extends BaseErrorsMapper {
+    constructor(injector, cdr, 
+    // eslint-disable-next-line sonar/deprecation
+    cfr, appRef, control, ngForm, formGroup) {
+        super(injector);
+        this.injector = injector;
+        this.cdr = cdr;
+        this.cfr = cfr;
+        this.appRef = appRef;
+        this.control = control;
+        this.ngForm = ngForm;
+        this.formGroup = formGroup;
+        this.destroy$ = new Subject();
+    }
+    ngAfterViewInit() {
+        if (!this.control) {
+            throw new Error('Errors mapper is not properly configured. No valid control is found.');
+        }
+        this.initPortal();
+        const statusChange = [this.control.statusChanges];
+        if (this.ngForm) {
+            statusChange.push(this.ngForm.ngSubmit);
+        }
+        if (this.formGroup) {
+            statusChange.push(this.formGroup.ngSubmit);
+        }
+        this.aclErrorsMapperDisabled$
+            .pipe(switchMap(isDisable => isDisable
+            ? of(null)
+            : merge(...statusChange, this.translate.locale$).pipe(debounceTime(50), map(() => this.getErrorMessage(this.control.errors, this.aclErrorsMapper || {}, this.aclErrorsMapperFn, this.aclErrorsMapperControlName)))), takeUntil(this.destroy$))
+            .subscribe(content => {
+            this.updateContent(content);
+            this.cdr.markForCheck();
+        });
+    }
+    updateContent(content) {
+        if (!content) {
+            if (this.portalHost.hasAttached()) {
+                this.portalHost.detach();
+            }
+            return;
+        }
+        if (!this.portalHost.hasAttached()) {
+            this.portalAttach = this.portalHost.attach(this.portal).instance;
+        }
+        this.portalAttach.data = content;
+        this.portalAttach.cdr.markForCheck();
+    }
+    initPortal() {
+        this.portalHost = new DomPortalOutlet(this.aclErrorsMapperOutlet, this.cfr, this.appRef, this.injector);
+        this.portal = new ComponentPortal(TextComponent);
+    }
+    ngOnDestroy() {
+        this.destroy$.next();
+        this.portalHost.dispose();
+    }
+    static { this.ɵfac = function ErrorsMapperDirective_Factory(t) { return new (t || ErrorsMapperDirective)(i0.ɵɵdirectiveInject(i0.Injector), i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ComponentFactoryResolver), i0.ɵɵdirectiveInject(i0.ApplicationRef), i0.ɵɵdirectiveInject(i1.NgControl, 2), i0.ɵɵdirectiveInject(i1.NgForm, 8), i0.ɵɵdirectiveInject(i1.FormGroupDirective, 8)); }; }
+    static { this.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: ErrorsMapperDirective, selectors: [["", "aclErrorsMapper", ""]], inputs: { aclErrorsMapper: "aclErrorsMapper", aclErrorsMapperFn: "aclErrorsMapperFn", aclErrorsMapperDisabled: "aclErrorsMapperDisabled", aclErrorsMapperOutlet: "aclErrorsMapperOutlet", aclErrorsMapperControlName: "aclErrorsMapperControlName" }, standalone: true, features: [i0.ɵɵInheritDefinitionFeature] }); }
+}
+__decorate([
+    ObservableInput(),
+    __metadata("design:type", Observable)
+], ErrorsMapperDirective.prototype, "aclErrorsMapperDisabled$", void 0);
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ErrorsMapperDirective, [{
+        type: Directive,
+        args: [{
+                selector: '[aclErrorsMapper]',
+                standalone: true,
+            }]
+    }], function () { return [{ type: i0.Injector }, { type: i0.ChangeDetectorRef }, { type: i0.ComponentFactoryResolver }, { type: i0.ApplicationRef }, { type: i1.NgControl, decorators: [{
+                type: Self
+            }] }, { type: i1.NgForm, decorators: [{
+                type: Optional
+            }] }, { type: i1.FormGroupDirective, decorators: [{
+                type: Optional
+            }] }]; }, { aclErrorsMapper: [{
+            type: Input
+        }], aclErrorsMapperFn: [{
+            type: Input
+        }], aclErrorsMapperDisabled: [{
+            type: Input
+        }], aclErrorsMapperDisabled$: [], aclErrorsMapperOutlet: [{
+            type: Input
+        }], aclErrorsMapperControlName: [{
+            type: Input
+        }] }); })();
+class TextComponent {
+    constructor(cdr) {
+        this.cdr = cdr;
+    }
+    static { this.ɵfac = function TextComponent_Factory(t) { return new (t || TextComponent)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef)); }; }
+    static { this.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: TextComponent, selectors: [["ng-component"]], standalone: true, features: [i0.ɵɵStandaloneFeature], decls: 1, vars: 1, template: function TextComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵtext(0);
+        } if (rf & 2) {
+            i0.ɵɵtextInterpolate1(" ", ctx.data, " ");
+        } }, encapsulation: 2, changeDetection: 0 }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(TextComponent, [{
+        type: Component,
+        args: [{
+                template: ` {{ data }} `,
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                standalone: true,
+            }]
+    }], function () { return [{ type: i0.ChangeDetectorRef }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"errors-mapper.directive.js","sourceRoot":"","sources":["../../../../../libs/common/src/errors-mapper/errors-mapper.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { ComponentPortal, DomPortalOutlet, Portal } from '@angular/cdk/portal';\nimport {\n  AfterViewInit,\n  ApplicationRef,\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  ComponentFactoryResolver,\n  Directive,\n  Injector,\n  Input,\n  OnDestroy,\n  Optional,\n  Self,\n} from '@angular/core';\nimport { FormGroupDirective, NgControl, NgForm } from '@angular/forms';\nimport {\n  Observable,\n  Subject,\n  merge,\n  of,\n  debounceTime,\n  map,\n  switchMap,\n  takeUntil,\n} from 'rxjs';\n\nimport { StringMap } from '../core';\nimport { ObservableInput } from '../core/public-api';\n\nimport { BaseErrorsMapper } from './base-errors-mapper';\nimport { ErrorsMapperFn } from './types';\n\n@Directive({\n  selector: '[aclErrorsMapper]',\n  standalone: true,\n})\nexport class ErrorsMapperDirective\n  extends BaseErrorsMapper\n  implements AfterViewInit, OnDestroy\n{\n  @Input()\n  aclErrorsMapper: StringMap | '';\n\n  @Input()\n  aclErrorsMapperFn: ErrorsMapperFn;\n\n  @Input()\n  aclErrorsMapperDisabled: boolean;\n\n  /**\n   * disable errors mapper\n   */\n  @ObservableInput()\n  aclErrorsMapperDisabled$: Observable<boolean>;\n\n  /**\n   * specify outlet, consider this other than specific control entity to make sure di can always get ngForm\n   */\n  @Input()\n  aclErrorsMapperOutlet: Element;\n\n  @Input()\n  aclErrorsMapperControlName: string;\n\n  private portal: Portal<any>;\n  private portalHost: DomPortalOutlet;\n  private portalAttach: TextComponent;\n  private readonly destroy$ = new Subject<void>();\n\n  constructor(\n    public injector: Injector,\n    private readonly cdr: ChangeDetectorRef,\n    // eslint-disable-next-line sonar/deprecation\n    private readonly cfr: ComponentFactoryResolver,\n    private readonly appRef: ApplicationRef,\n    @Self() private readonly control: NgControl,\n    @Optional() private readonly ngForm: NgForm,\n    @Optional()\n    private readonly formGroup: FormGroupDirective,\n  ) {\n    super(injector);\n  }\n\n  ngAfterViewInit() {\n    if (!this.control) {\n      throw new Error(\n        'Errors mapper is not properly configured. No valid control is found.',\n      );\n    }\n    this.initPortal();\n    const statusChange = [this.control.statusChanges];\n\n    if (this.ngForm) {\n      statusChange.push(this.ngForm.ngSubmit);\n    }\n    if (this.formGroup) {\n      statusChange.push(this.formGroup.ngSubmit);\n    }\n\n    this.aclErrorsMapperDisabled$\n      .pipe(\n        switchMap(isDisable =>\n          isDisable\n            ? of(null)\n            : merge(...statusChange, this.translate.locale$).pipe(\n                debounceTime(50),\n                map(() =>\n                  this.getErrorMessage(\n                    this.control.errors,\n                    this.aclErrorsMapper || {},\n                    this.aclErrorsMapperFn,\n                    this.aclErrorsMapperControlName,\n                  ),\n                ),\n              ),\n        ),\n        takeUntil(this.destroy$),\n      )\n      .subscribe(content => {\n        this.updateContent(content);\n        this.cdr.markForCheck();\n      });\n  }\n\n  updateContent(content: string) {\n    if (!content) {\n      if (this.portalHost.hasAttached()) {\n        this.portalHost.detach();\n      }\n      return;\n    }\n    if (!this.portalHost.hasAttached()) {\n      this.portalAttach = this.portalHost.attach(this.portal).instance;\n    }\n    this.portalAttach.data = content;\n    this.portalAttach.cdr.markForCheck();\n  }\n\n  initPortal() {\n    this.portalHost = new DomPortalOutlet(\n      this.aclErrorsMapperOutlet,\n      this.cfr,\n      this.appRef,\n      this.injector,\n    );\n    this.portal = new ComponentPortal(TextComponent);\n  }\n\n  ngOnDestroy() {\n    this.destroy$.next();\n    this.portalHost.dispose();\n  }\n}\n\n@Component({\n  template: ` {{ data }} `,\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  standalone: true,\n})\nclass TextComponent {\n  data: string;\n  constructor(public cdr: ChangeDetectorRef) {}\n}\n"]}