@acorex/components 16.0.2 → 17.0.1

package/esm2022/common/lib/components/interactive-component.class.mjs

@@ -0,0 +1,107 @@
+import { AXHtmlUtil } from '@acorex/core/utils';
+import { coerceBooleanProperty, coerceNumberProperty, } from '@angular/cdk/coercion';
+import { EventEmitter } from '@angular/core';
+import { noop } from 'rxjs';
+import { MXBaseComponent } from './base-component.class';
+export class MXInteractiveComponent extends MXBaseComponent {
+    constructor() {
+        super(...arguments);
+        this.onTouchedCallback = noop;
+        this._touched = false;
+        this.disabledChange = new EventEmitter();
+        this._tabIndex = 0;
+        /**
+         *  Fires each time the component gets focused.
+         *  @event
+         */
+        this.onFocus = new EventEmitter();
+        /**
+         *  Fires each time the component gets blurred.
+         *  @event
+         */
+        this.onBlur = new EventEmitter();
+    }
+    registerOnTouched(fn) {
+        this.onTouchedCallback = fn;
+    }
+    get touched() {
+        return this._touched;
+    }
+    markAsTouched() {
+        if (!this.touched) {
+            this.onTouchedCallback();
+            this._touched = true;
+        }
+    }
+    /**
+     *  If set to true, it disables the component.
+     */
+    get disabled() {
+        return this._disabled;
+    }
+    set disabled(value) {
+        value = coerceBooleanProperty(value);
+        this.setOption({
+            name: 'disabled',
+            value,
+            afterCallback: () => {
+                this.cdr.markForCheck();
+            },
+        });
+    }
+    setDisabledState(isDisabled) {
+        this.disabled = isDisabled;
+    }
+    /**
+     *  Specifies the tabindex of the component.
+     */
+    get tabIndex() {
+        return this.disabled ? -1 : this._tabIndex;
+    }
+    set tabIndex(value) {
+        this.setOption({
+            name: 'tabIndex',
+            value: value != null ? coerceNumberProperty(value) : 0,
+        });
+    }
+    emitOnFocusEvent(e) {
+        this.onFocus.emit({
+            component: this,
+            htmlElement: this.getHostElement(),
+            nativeEvent: e,
+        });
+    }
+    emitOnBlurEvent(e) {
+        this.markAsTouched();
+        this.onBlur.emit({
+            component: this,
+            htmlElement: this.getHostElement(),
+            nativeEvent: e,
+        });
+    }
+    // /**
+    //  *  Fires each time the user clicks the button.
+    //  *  @event
+    //  */
+    // onClick: EventEmitter<AXClickEvent> = new EventEmitter<AXClickEvent>();
+    // protected emitOnClickEvent(e: MouseEvent): void {
+    //   this.onClick.emit({
+    //     component: this,
+    //     htmlElement: this.getHostElement(),
+    //     nativeEvent: e,
+    //   });
+    // }
+    focus() {
+        AXHtmlUtil.focusElement(this.getHostElement());
+    }
+    blur() {
+        AXHtmlUtil.blurElement(this.getHostElement());
+    }
+    /**
+     *  Check component is focused or has any focused element.
+     */
+    hasFocus() {
+        return AXHtmlUtil.hasFocus(this.getHostElement());
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/common/lib/components/look-component.class.mjs

@@ -0,0 +1,33 @@
+import { EventEmitter, Injectable } from '@angular/core';
+import { MXBaseComponent } from './base-component.class';
+import * as i0 from "@angular/core";
+export class MXLookableComponent {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: MXLookableComponent, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: MXLookableComponent }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: MXLookableComponent, decorators: [{
+            type: Injectable
+        }] });
+export class MXLookComponent extends MXBaseComponent {
+    constructor() {
+        super(...arguments);
+        this.lookChange = new EventEmitter();
+        this._look = 'solid';
+    }
+    /**
+     *  Predefined look schemes
+     */
+    get look() {
+        return this._look;
+    }
+    set look(value) {
+        this.setOption({
+            name: 'look',
+            value,
+            afterCallback: () => {
+                this.cdr.markForCheck();
+            },
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9vay1jb21wb25lbnQuY2xhc3MuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2NvbXBvbmVudHMvY29tbW9uL3NyYy9saWIvY29tcG9uZW50cy9sb29rLWNvbXBvbmVudC5jbGFzcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsWUFBWSxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUV6RCxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0sd0JBQXdCLENBQUM7O0FBR3pELE1BQU0sT0FBZ0IsbUJBQW1COzhHQUFuQixtQkFBbUI7a0hBQW5CLG1CQUFtQjs7MkZBQW5CLG1CQUFtQjtrQkFEeEMsVUFBVTs7QUFLWCxNQUFNLE9BQU8sZUFBZ0IsU0FBUSxlQUFlO0lBQXBEOztRQUNFLGVBQVUsR0FBa0MsSUFBSSxZQUFZLEVBQUUsQ0FBQztRQUN2RCxVQUFLLEdBQXFCLE9BQU8sQ0FBQztJQWdCNUMsQ0FBQztJQWZDOztPQUVHO0lBQ0gsSUFBSSxJQUFJO1FBQ04sT0FBTyxJQUFJLENBQUMsS0FBSyxDQUFDO0lBQ3BCLENBQUM7SUFDRCxJQUFJLElBQUksQ0FBQyxLQUFzQjtRQUM3QixJQUFJLENBQUMsU0FBUyxDQUFDO1lBQ2IsSUFBSSxFQUFFLE1BQU07WUFDWixLQUFLO1lBQ0wsYUFBYSxFQUFFLEdBQUcsRUFBRTtnQkFDbEIsSUFBSSxDQUFDLEdBQUcsQ0FBQyxZQUFZLEVBQUUsQ0FBQztZQUMxQixDQUFDO1NBQ0YsQ0FBQyxDQUFDO0lBQ0wsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRXZlbnRFbWl0dGVyLCBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBBWFN0eWxlTG9va1R5cGUgfSBmcm9tICcuLi9jbGFzc2VzL3N0eWxlcy5jbGFzcyc7XG5pbXBvcnQgeyBNWEJhc2VDb21wb25lbnQgfSBmcm9tICcuL2Jhc2UtY29tcG9uZW50LmNsYXNzJztcblxuQEluamVjdGFibGUoKVxuZXhwb3J0IGFic3RyYWN0IGNsYXNzIE1YTG9va2FibGVDb21wb25lbnQge1xuICBsb29rOiBBWFN0eWxlTG9va1R5cGU7XG59XG5cbmV4cG9ydCBjbGFzcyBNWExvb2tDb21wb25lbnQgZXh0ZW5kcyBNWEJhc2VDb21wb25lbnQge1xuICBsb29rQ2hhbmdlOiBFdmVudEVtaXR0ZXI8QVhTdHlsZUxvb2tUeXBlPiA9IG5ldyBFdmVudEVtaXR0ZXIoKTtcbiAgcHJpdmF0ZSBfbG9vaz86IEFYU3R5bGVMb29rVHlwZSA9ICdzb2xpZCc7XG4gIC8qKlxuICAgKiAgUHJlZGVmaW5lZCBsb29rIHNjaGVtZXNcbiAgICovXG4gIGdldCBsb29rKCk6IEFYU3R5bGVMb29rVHlwZSB7XG4gICAgcmV0dXJuIHRoaXMuX2xvb2s7XG4gIH1cbiAgc2V0IGxvb2sodmFsdWU6IEFYU3R5bGVMb29rVHlwZSkge1xuICAgIHRoaXMuc2V0T3B0aW9uKHtcbiAgICAgIG5hbWU6ICdsb29rJyxcbiAgICAgIHZhbHVlLFxuICAgICAgYWZ0ZXJDYWxsYmFjazogKCkgPT4ge1xuICAgICAgICB0aGlzLmNkci5tYXJrRm9yQ2hlY2soKTtcbiAgICAgIH0sXG4gICAgfSk7XG4gIH1cbn1cbiJdfQ==

package/esm2022/common/lib/components/selection-base.component.class.mjs

@@ -0,0 +1,196 @@
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import { Injectable, InjectionToken, inject } from '@angular/core';
+import { MXValueComponent } from './value-component.class';
+import * as i0 from "@angular/core";
+export class MXSelectionBridgeService {
+    constructor() {
+        this.selectedItems = [];
+        this.cacheList = {};
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: MXSelectionBridgeService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: MXSelectionBridgeService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: MXSelectionBridgeService, decorators: [{
+            type: Injectable
+        }] });
+export const AX_SELECTION_DATA_TOKEN = new InjectionToken('AX_SELECTION_DATA_TOKEN');
+export class MXSelectionValueComponent extends MXValueComponent {
+    constructor() {
+        super(...arguments);
+        this.dataService = inject(AX_SELECTION_DATA_TOKEN);
+        this._valueField = 'id';
+        this._textField = 'text';
+        this._disabledField = 'disabled';
+        this._multiple = false;
+    }
+    get valueField() {
+        return this._valueField;
+    }
+    set valueField(v) {
+        this.setOption({
+            name: 'valueField',
+            value: v,
+        });
+    }
+    get textField() {
+        return this._textField;
+    }
+    set textField(v) {
+        this.setOption({
+            name: 'textField',
+            value: v,
+        });
+    }
+    get disabledField() {
+        return this._disabledField;
+    }
+    set disabledField(v) {
+        this.setOption({
+            name: 'disabledField',
+            value: v,
+        });
+    }
+    get multiple() {
+        return this._multiple;
+    }
+    set multiple(v) {
+        this.setOption({
+            name: 'multiple',
+            value: v,
+            afterCallback: () => {
+                this.clear(false);
+            },
+        });
+    }
+    get selectedItems() {
+        return this.dataService.selectedItems || [];
+    }
+    internalSetValue(value) {
+        const isArray = Array.isArray(value);
+        if (value == null || (isArray && value.length == 0)) {
+            return this.multiple ? [] : null;
+        }
+        const normalizedItems = isArray ? this.normalizeItemsList(value, true) : this.normalizeItemsList([value], true);
+        if (normalizedItems.length == 0) {
+            return this.multiple ? [] : null;
+        }
+        const result = this.multiple ? normalizedItems.map((c) => c[this.valueField]) : normalizedItems[0][this.valueField];
+        return result;
+    }
+    emitOnValueChangedEvent(oldValue, newValue) {
+        this._normalizeSelectedItems();
+        super.emitOnValueChangedEvent(oldValue, newValue);
+    }
+    normalizeItemsList(items, findBykey = false) {
+        if (items == null)
+            return [];
+        return items.filter((c) => c != null).map((i) => this.normalizeItem(i, findBykey));
+    }
+    normalizeItem(item, findBykey = false) {
+        const complex = typeof item == 'object';
+        const key = complex ? item[this.valueField] : `${item}`;
+        const cacheKey = `k-${key}`;
+        const hasText = !complex || item[this.textField] != null;
+        //
+        if (this.dataService.cacheList[cacheKey] && this.dataService.cacheList[cacheKey][this.textField])
+            return this.dataService.cacheList[cacheKey];
+        //
+        const obj = {};
+        if (complex && hasText) {
+            Object.assign(obj, item);
+        }
+        else {
+            const existsItem = findBykey ? this.getItemByKey(key) : null;
+            if (existsItem && existsItem instanceof Promise) {
+                obj[this.valueField] = key;
+                obj['isLoading'] = true;
+                //
+                existsItem
+                    .then((r) => {
+                    if (typeof r === 'object') {
+                        obj[this.valueField] = r[this.valueField];
+                        obj[this.textField] = r[this.textField];
+                    }
+                    else {
+                        obj[this.valueField] = r || key;
+                    }
+                })
+                    .finally(() => {
+                    obj['isLoading'] = false;
+                    this.dataService.cacheList[cacheKey] = obj;
+                    this.cdr.markForCheck();
+                });
+            }
+            else if (existsItem) {
+                obj[this.valueField] = complex ? existsItem[this.valueField] : existsItem;
+            }
+            else {
+                obj[this.valueField] = complex ? item[this.valueField] : item;
+            }
+        }
+        this.dataService.cacheList[cacheKey] = obj;
+        return obj;
+    }
+    _normalizeSelectedItems() {
+        const values = Array.isArray(this.value) ? this.value : this.value != null ? [this.value] : [];
+        this.dataService.selectedItems = values.map((v) => this.normalizeItem(v));
+    }
+    unselectItems(...items) {
+        if (!items || items.length === 0) {
+            this.commitValue([], true);
+            return;
+        }
+        const normalizeItems = Array.isArray(items) ? this.normalizeItemsList(items) : [this.normalizeItem(items)];
+        const newSelectedItems = this.selectedItems.filter((i) => !normalizeItems.some((n) => n[this.valueField] == i[this.valueField]));
+        this.commitValue(newSelectedItems, true);
+    }
+    selectItems(...items) {
+        if (items && items.length) {
+            let newSelectedItems = Array.isArray(this.value) ? this.value : [this.value];
+            const normalizeItems = Array.isArray(items) ? this.normalizeItemsList(items) : [this.normalizeItem(items)];
+            if (this.multiple) {
+                newSelectedItems = [...newSelectedItems, ...normalizeItems];
+            }
+            else {
+                newSelectedItems = normalizeItems;
+            }
+            this.commitValue(newSelectedItems, true);
+        }
+    }
+    toggleSelect(...items) {
+        items?.forEach((item) => {
+            if (this.multiple) {
+                this.isItemSelected(item) ? this.unselectItems(item) : this.selectItems(item);
+            }
+            else {
+                this.selectItems(item);
+            }
+        });
+    }
+    isItemSelected(item) {
+        return this.selectedItems.some((c) => c[this.valueField] === this.normalizeItem(item)[this.valueField]);
+    }
+    isItemDisabled(item) {
+        return (this.disabled ||
+            coerceBooleanProperty(item[this.disabledField]) === true ||
+            (this.disabledCallback ? this.disabledCallback({ item, index: -1 }) : false));
+    }
+    getDisplayText(item) {
+        const normalizeItem = this.normalizeItem(item);
+        return normalizeItem[this.textField] || normalizeItem[this.valueField];
+    }
+    getValue(item) {
+        const normalizeItem = this.normalizeItem(item);
+        return normalizeItem[this.valueField];
+    }
+    clearSelectionCache() {
+        this.dataService.cacheList = {};
+        this.dataService.selectedItems = [];
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: MXSelectionValueComponent, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: MXSelectionValueComponent }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: MXSelectionValueComponent, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"selection-base.component.class.js","sourceRoot":"","sources":["../../../../../../../libs/components/common/src/lib/components/selection-base.component.class.ts"],"names":[],"mappings":"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","sourcesContent":["import { coerceBooleanProperty } from '@angular/cdk/coercion';\nimport { Injectable, InjectionToken, inject } from '@angular/core';\nimport { MXValueComponent } from './value-component.class';\n\n@Injectable()\nexport class MXSelectionBridgeService {\n  public selectedItems: unknown[] = [];\n  public cacheList: { [key: string | number]: unknown } = {};\n}\n\nexport const AX_SELECTION_DATA_TOKEN = new InjectionToken<MXSelectionBridgeService>('AX_SELECTION_DATA_TOKEN');\n\n@Injectable()\nexport abstract class MXSelectionValueComponent<T = unknown> extends MXValueComponent<unknown> {\n  private dataService = inject(AX_SELECTION_DATA_TOKEN);\n\n  disabledCallback: (e: { item: T; index: number }) => boolean;\n\n  private _valueField = 'id';\n  public get valueField(): string {\n    return this._valueField;\n  }\n  public set valueField(v: string) {\n    this.setOption({\n      name: 'valueField',\n      value: v,\n    });\n  }\n\n  private _textField = 'text';\n  public get textField(): string {\n    return this._textField;\n  }\n  public set textField(v: string) {\n    this.setOption({\n      name: 'textField',\n      value: v,\n    });\n  }\n\n  private _disabledField = 'disabled';\n  public get disabledField(): string {\n    return this._disabledField;\n  }\n  public set disabledField(v: string) {\n    this.setOption({\n      name: 'disabledField',\n      value: v,\n    });\n  }\n\n  private _multiple = false;\n  public get multiple(): boolean {\n    return this._multiple;\n  }\n  public set multiple(v: boolean) {\n    this.setOption({\n      name: 'multiple',\n      value: v,\n      afterCallback: () => {\n        this.clear(false);\n      },\n    });\n  }\n\n  get selectedItems(): unknown[] {\n    return this.dataService.selectedItems || [];\n  }\n\n  override internalSetValue(value: unknown) {\n    const isArray = Array.isArray(value);\n    if (value == null || (isArray && value.length == 0)) {\n      return this.multiple ? [] : null;\n    }\n    const normalizedItems = isArray ? this.normalizeItemsList(value, true) : this.normalizeItemsList([value], true);\n\n    if (normalizedItems.length == 0) {\n      return this.multiple ? [] : null;\n    }\n    const result = this.multiple ? normalizedItems.map((c) => c[this.valueField]) : normalizedItems[0][this.valueField];\n    return result;\n  }\n\n  override emitOnValueChangedEvent(oldValue?: unknown, newValue?: unknown) {\n    this._normalizeSelectedItems();\n    super.emitOnValueChangedEvent(oldValue, newValue);\n  }\n\n  abstract getItemByKey(key: unknown): unknown | Promise<unknown>;\n\n  protected normalizeItemsList(items: unknown[], findBykey = false): unknown[] {\n    if (items == null) return [];\n    return items.filter((c) => c != null).map((i) => this.normalizeItem(i, findBykey));\n  }\n\n  private normalizeItem(item: unknown, findBykey = false): unknown {\n    const complex = typeof item == 'object';\n    const key = complex ? item[this.valueField] : `${item}`;\n    const cacheKey = `k-${key}`;\n    const hasText = !complex || item[this.textField] != null;\n    //\n    if (this.dataService.cacheList[cacheKey] && this.dataService.cacheList[cacheKey][this.textField])\n      return this.dataService.cacheList[cacheKey];\n    //\n    const obj: unknown = {};\n    if (complex && hasText) {\n      Object.assign(obj, item);\n    } else {\n      const existsItem = findBykey ? this.getItemByKey(key) : null;\n      if (existsItem && existsItem instanceof Promise) {\n        obj[this.valueField] = key;\n        obj['isLoading'] = true;\n        //\n        existsItem\n          .then((r) => {\n            if (typeof r === 'object') {\n              obj[this.valueField] = r[this.valueField];\n              obj[this.textField] = r[this.textField];\n            } else {\n              obj[this.valueField] = r || key;\n            }\n          })\n          .finally(() => {\n            obj['isLoading'] = false;\n            this.dataService.cacheList[cacheKey] = obj;\n            this.cdr.markForCheck();\n          });\n      } else if (existsItem) {\n        obj[this.valueField] = complex ? existsItem[this.valueField] : existsItem;\n      } else {\n        obj[this.valueField] = complex ? item[this.valueField] : item;\n      }\n    }\n    this.dataService.cacheList[cacheKey] = obj;\n    return obj;\n  }\n\n  private _normalizeSelectedItems() {\n    const values = Array.isArray(this.value) ? this.value : this.value != null ? [this.value] : [];\n    this.dataService.selectedItems = values.map((v) => this.normalizeItem(v));\n  }\n\n  public unselectItems(...items: T[]) {\n    if (!items || items.length === 0) {\n      this.commitValue([], true);\n      return;\n    }\n    const normalizeItems = Array.isArray(items) ? this.normalizeItemsList(items) : [this.normalizeItem(items)];\n    const newSelectedItems = this.selectedItems.filter((i) => !normalizeItems.some((n) => n[this.valueField] == i[this.valueField]));\n    this.commitValue(newSelectedItems, true);\n  }\n\n  public selectItems(...items: T[]) {\n    if (items && items.length) {\n      let newSelectedItems = Array.isArray(this.value) ? this.value : [this.value];\n      const normalizeItems = Array.isArray(items) ? this.normalizeItemsList(items) : [this.normalizeItem(items)];\n      if (this.multiple) {\n        newSelectedItems = [...newSelectedItems, ...normalizeItems];\n      } else {\n        newSelectedItems = normalizeItems;\n      }\n      this.commitValue(newSelectedItems, true);\n    }\n  }\n\n  public toggleSelect(...items: T[]) {\n    items?.forEach((item) => {\n      if (this.multiple) {\n        this.isItemSelected(item) ? this.unselectItems(item) : this.selectItems(item);\n      } else {\n        this.selectItems(item);\n      }\n    });\n  }\n\n  public isItemSelected(item: T): boolean {\n    return this.selectedItems.some((c) => c[this.valueField] === this.normalizeItem(item)[this.valueField]);\n  }\n\n  public isItemDisabled(item: T): boolean {\n    return (\n      this.disabled ||\n      coerceBooleanProperty(item[this.disabledField]) === true ||\n      (this.disabledCallback ? this.disabledCallback({ item, index: -1 }) : false)\n    );\n  }\n\n  protected getDisplayText(item: T) {\n    const normalizeItem = this.normalizeItem(item) as any;\n    return normalizeItem[this.textField] || normalizeItem[this.valueField];\n  }\n\n  protected getValue(item: T) {\n    const normalizeItem = this.normalizeItem(item) as any;\n    return normalizeItem[this.valueField];\n  }\n\n  protected clearSelectionCache() {\n    this.dataService.cacheList = {};\n    this.dataService.selectedItems = [];\n  }\n}\n"]}

package/esm2022/common/lib/components/value-component.class.mjs

@@ -0,0 +1,223 @@
+import { isBrowser } from '@acorex/core/platform';
+import { AXValidationService } from '@acorex/core/validation';
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import { EventEmitter, Injectable, inject } from '@angular/core';
+import { clone, isEqual } from 'lodash-es';
+import { noop } from 'rxjs';
+import { MXInteractiveComponent } from './interactive-component.class';
+import * as i0 from "@angular/core";
+export class MXValueComponent extends MXInteractiveComponent {
+    constructor() {
+        super(...arguments);
+        /**
+         *  Fires each time the user press a key.
+         *  @event
+         */
+        this.onValueChanged = new EventEmitter();
+        /**
+         * @deprecated The event should not be used, use ngModelChange instead
+         */
+        this.valueChange = new EventEmitter();
+        this.readonlyChange = new EventEmitter();
+        this._readonly = false;
+        this._dirty = false;
+        this._isUserInteraction = false;
+        this.stateChange = new EventEmitter();
+        this._state = 'clear';
+        this.validationService = inject(AXValidationService);
+        this.validationRulesChange = new EventEmitter();
+        this.validationRules = [];
+        this.onChangeCallback = noop;
+    }
+    /**
+     *  If set to true, user cannot change the value of component.
+     */
+    get readonly() {
+        return this._readonly;
+    }
+    set readonly(value) {
+        value = coerceBooleanProperty(value);
+        this.setOption({
+            name: 'readonly',
+            value,
+            afterCallback: () => {
+                this.cdr.markForCheck();
+            },
+        });
+    }
+    get name() {
+        return this._name;
+    }
+    set name(value) {
+        this._name = value;
+    }
+    get dirty() {
+        return this._dirty;
+    }
+    markAsDirty() {
+        this._dirty = true;
+    }
+    /**
+     * @deprecated The property should not be used, use ngModel instead
+     */
+    get value() {
+        return this.internalGetValue(this._value) ?? this.defaultValue;
+    }
+    set value(v) {
+        v = this.internalSetValue(v);
+        const old = clone(this.value);
+        if (!isEqual(old, v)) {
+            this._value = v;
+            this.emitOnValueChangedEvent(old, this.value);
+            this.internalValueChanged(this.value);
+        }
+        if (v == null || v == undefined || v == '' || (Array.isArray(v) && v.length == 0)) {
+            this.setState('clear');
+        }
+    }
+    get state() {
+        return this._state;
+    }
+    set state(value) {
+        this.setState(value);
+        this.stateChange.emit(value);
+    }
+    emitOnValueChangedEvent(oldValue, newValue) {
+        this.valueChange.emit(newValue);
+        this.onValueChanged.emit({
+            component: this,
+            value: newValue,
+            oldValue: oldValue,
+            name: this.name,
+            isUserInteraction: this._isUserInteraction,
+        });
+        this.onChangeCallback(newValue);
+        this.cdr.markForCheck();
+        this._isUserInteraction = false;
+    }
+    internalSetValue(value) {
+        return value;
+    }
+    internalGetValue(value) {
+        return value;
+    }
+    internalValueChanged(value) { }
+    ngOnInit() {
+        super.ngOnInit();
+        //
+        this.registerValidation();
+    }
+    ngOnDestroy() {
+        this.onValueChanged?.unsubscribe();
+        this.onOptionChanged?.unsubscribe();
+    }
+    registerValidation() {
+        const a = this.getHostElement().querySelectorAll('[ax-form-item="true"]');
+        a.forEach((c) => {
+            c.removeAttribute('ax-form-item');
+        });
+        this.getHostElement().setAttribute('ax-form-item', 'true');
+    }
+    get isRequired() {
+        return this.validationRules?.some((c) => c.rule == 'required');
+    }
+    addValidationRule(rule) {
+        this.validationRules.push(rule);
+        this.validationRulesChange.emit(this.validationRules);
+    }
+    removeValidationRule(rule) {
+        this.validationRules = this.validationRules.filter((r) => r.rule !== rule.rule || !isEqual(r.options, rule.options));
+        this.validationRulesChange.emit(this.validationRules);
+    }
+    async validate() {
+        const container_classes = ['ax-editor-container', 'ax-checkbox', 'ax-radio'];
+        const container = container_classes.some((c) => this.getHostElement().classList.contains(c))
+            ? this.getHostElement()
+            : this.getHostElement().querySelector('.ax-editor-container');
+        const formField = container?.closest('ax-form-field') || container?.closest('ax-checkbox');
+        const label = formField?.querySelector('ax-label') || formField?.querySelector('label');
+        //
+        const rules = this.validationService.ruleFor(this.value);
+        this.validationRules.forEach((r) => {
+            r.options['title'] = (label?.firstChild?.textContent ?? this.name)?.replace('*', '').trim();
+            rules.addRule(r.rule, r.options);
+        });
+        const result = await rules.validate();
+        if (result.result) {
+            this.setState('clear');
+        }
+        else {
+            const message = result.rules.find((c) => !c.result).message;
+            this.setState('error', message);
+        }
+        return result;
+    }
+    setState(state, ...args) {
+        //TODO: find a better solution
+        if (isBrowser()) {
+            const container = this.getHostElement().classList.contains('ax-editor-container')
+                ? this.getHostElement()
+                : this.getHostElement().querySelector('.ax-editor-container');
+            const formField = container?.closest('ax-form-field');
+            const label = formField?.querySelector('ax-label') || formField?.querySelector('label');
+            let target = container || this.getHostElement().firstElementChild;
+            if (target?.querySelector('.ax-error-container')) {
+                target = target.querySelector('.ax-error-container');
+            }
+            const parent = target?.parentElement;
+            if (!target || !parent)
+                return;
+            switch (state) {
+                case 'clear':
+                    this._state = 'clear';
+                    if (parent.querySelector('span.ax-error-message')) {
+                        parent.removeChild(parent.querySelector('span.ax-error-message'));
+                    }
+                    label?.classList.remove('ax-state-error');
+                    target.classList.remove('ax-state-error', 'ax-state-success');
+                    break;
+                case 'success':
+                    this.setState('clear');
+                    target.classList.add('ax-state-success');
+                    this._state = 'success';
+                    break;
+                case 'error':
+                    this.setState('clear');
+                    if (args[0]) {
+                        const span = document.createElement('span');
+                        span.innerHTML = args[0];
+                        span.classList.add('ax-error-message');
+                        parent.appendChild(span);
+                    }
+                    label?.classList.add('ax-state-error');
+                    target.classList.add('ax-state-error');
+                    this._state = 'error';
+                    break;
+            }
+            this.cdr.markForCheck();
+        }
+    }
+    registerOnChange(fn) {
+        this.onChangeCallback = fn;
+    }
+    writeValue(value) {
+        this.value = value;
+    }
+    commitValue(value, u = false) {
+        if (u) {
+            this.markAsTouched();
+            this.markAsDirty();
+            this._isUserInteraction = true;
+        }
+        this.writeValue(value);
+    }
+    clear(e = false) {
+        this.commitValue(null, e);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: MXValueComponent, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: MXValueComponent }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: MXValueComponent, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"value-component.class.js","sourceRoot":"","sources":["../../../../../../../libs/components/common/src/lib/components/value-component.class.ts"],"names":[],"mappings":"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","sourcesContent":["import { isBrowser } from '@acorex/core/platform';\nimport { AXValidationService, AXValidationSummary } from '@acorex/core/validation';\nimport { coerceBooleanProperty } from '@angular/cdk/coercion';\nimport { EventEmitter, Injectable, inject } from '@angular/core';\nimport { ControlValueAccessor } from '@angular/forms';\nimport { clone, isEqual } from 'lodash-es';\nimport { noop } from 'rxjs';\nimport { AXFormValidationRule } from '../classes/components.class';\nimport { AXValueChangedEvent } from '../classes/events.class';\nimport { AXComponentState } from './base-component.class';\nimport { MXInteractiveComponent } from './interactive-component.class';\n\n@Injectable()\nexport class MXValueComponent<T = any> extends MXInteractiveComponent implements ControlValueAccessor {\n  /**\n   *  Fires each time the user press a key.\n   *  @event\n   */\n  onValueChanged: EventEmitter<AXValueChangedEvent<any>> = new EventEmitter<AXValueChangedEvent<any>>();\n\n  /**\n   * @deprecated The event should not be used, use ngModelChange instead\n   */\n  valueChange: EventEmitter<any> = new EventEmitter<any>();\n\n  readonlyChange: EventEmitter<boolean> = new EventEmitter<boolean>();\n  private _readonly = false;\n  /**\n   *  If set to true, user cannot change the value of component.\n   */\n  get readonly() {\n    return this._readonly;\n  }\n  set readonly(value: boolean) {\n    value = coerceBooleanProperty(value);\n    this.setOption({\n      name: 'readonly',\n      value,\n      afterCallback: () => {\n        this.cdr.markForCheck();\n      },\n    });\n  }\n\n  private _name: string;\n  get name() {\n    return this._name;\n  }\n  set name(value: string) {\n    this._name = value;\n  }\n\n  private _dirty = false;\n  public get dirty() {\n    return this._dirty;\n  }\n\n  markAsDirty() {\n    this._dirty = true;\n  }\n\n  private _isUserInteraction = false;\n\n  initValue: T;\n  defaultValue: T;\n\n  private _value: T;\n  /**\n   * @deprecated The property should not be used, use ngModel instead\n   */\n  get value(): T {\n    return this.internalGetValue(this._value) ?? this.defaultValue;\n  }\n  set value(v: T) {\n    v = this.internalSetValue(v);\n    const old = clone(this.value);\n    if (!isEqual(old, v)) {\n      this._value = v;\n      this.emitOnValueChangedEvent(old, this.value);\n\n      this.internalValueChanged(this.value);\n    }\n    if (v == null || v == undefined || v == '' || (Array.isArray(v) && v.length == 0)) {\n      this.setState('clear');\n    }\n  }\n\n  stateChange: EventEmitter<AXComponentState> = new EventEmitter<AXComponentState>();\n\n  private _state: AXComponentState = 'clear';\n\n  get state(): AXComponentState {\n    return this._state;\n  }\n\n  set state(value: AXComponentState) {\n    this.setState(value);\n    this.stateChange.emit(value);\n  }\n\n  protected emitOnValueChangedEvent(oldValue?: any, newValue?: any) {\n    this.valueChange.emit(newValue);\n    this.onValueChanged.emit({\n      component: this,\n      value: newValue,\n      oldValue: oldValue,\n      name: this.name,\n      isUserInteraction: this._isUserInteraction,\n    });\n    this.onChangeCallback(newValue);\n    this.cdr.markForCheck();\n    this._isUserInteraction = false;\n  }\n\n  protected internalSetValue(value: any): T {\n    return value;\n  }\n\n  protected internalGetValue(value: any): T {\n    return value;\n  }\n\n  protected internalValueChanged(value: any): void {}\n\n  protected override ngOnInit(): void {\n    super.ngOnInit();\n    //\n    this.registerValidation();\n  }\n\n  protected ngOnDestroy() {\n    this.onValueChanged?.unsubscribe();\n    this.onOptionChanged?.unsubscribe();\n  }\n\n  protected registerValidation() {\n    const a = this.getHostElement().querySelectorAll('[ax-form-item=\"true\"]');\n    a.forEach((c) => {\n      c.removeAttribute('ax-form-item');\n    });\n    this.getHostElement().setAttribute('ax-form-item', 'true');\n  }\n\n  private validationService = inject(AXValidationService);\n\n  public validationRulesChange: EventEmitter<AXFormValidationRule[]> = new EventEmitter<AXFormValidationRule[]>();\n  private validationRules: AXFormValidationRule[] = [];\n\n  public get isRequired(): boolean {\n    return this.validationRules?.some((c) => c.rule == 'required');\n  }\n\n  addValidationRule(rule: AXFormValidationRule) {\n    this.validationRules.push(rule);\n    this.validationRulesChange.emit(this.validationRules);\n  }\n\n  removeValidationRule(rule: AXFormValidationRule) {\n    this.validationRules = this.validationRules.filter((r) => r.rule !== rule.rule || !isEqual(r.options, rule.options));\n    this.validationRulesChange.emit(this.validationRules);\n  }\n\n  async validate(): Promise<AXValidationSummary> {\n    const container_classes = ['ax-editor-container', 'ax-checkbox', 'ax-radio'];\n    const container = container_classes.some((c) => this.getHostElement().classList.contains(c))\n      ? this.getHostElement()\n      : this.getHostElement().querySelector('.ax-editor-container');\n    const formField = container?.closest('ax-form-field') || container?.closest('ax-checkbox');\n    const label = formField?.querySelector('ax-label') || formField?.querySelector('label');\n    //\n    const rules = this.validationService.ruleFor(this.value);\n    this.validationRules.forEach((r) => {\n      r.options['title'] = (label?.firstChild?.textContent ?? this.name)?.replace('*', '').trim();\n      rules.addRule(r.rule as any, r.options);\n    });\n    const result = await rules.validate();\n    if (result.result) {\n      this.setState('clear');\n    } else {\n      const message = result.rules.find((c) => !c.result).message;\n      this.setState('error', message);\n    }\n    return result;\n  }\n\n  protected setState(state: AXComponentState, ...args) {\n    //TODO: find a better solution\n    if (isBrowser()) {\n      const container = this.getHostElement().classList.contains('ax-editor-container')\n        ? this.getHostElement()\n        : this.getHostElement().querySelector('.ax-editor-container');\n      const formField = container?.closest('ax-form-field');\n      const label = formField?.querySelector('ax-label') || formField?.querySelector('label');\n      let target = container || this.getHostElement().firstElementChild;\n      if (target?.querySelector('.ax-error-container')) {\n        target = target.querySelector('.ax-error-container');\n      }\n      const parent = target?.parentElement;\n      if (!target || !parent) return;\n\n      switch (state) {\n        case 'clear':\n          this._state = 'clear';\n          if (parent.querySelector('span.ax-error-message')) {\n            parent.removeChild(parent.querySelector('span.ax-error-message')!);\n          }\n          label?.classList.remove('ax-state-error');\n          target.classList.remove('ax-state-error', 'ax-state-success');\n          break;\n        case 'success':\n          this.setState('clear');\n          target.classList.add('ax-state-success');\n          this._state = 'success';\n          break;\n        case 'error':\n          this.setState('clear');\n          if (args[0]) {\n            const span = document.createElement('span');\n            span.innerHTML = args[0];\n            span.classList.add('ax-error-message');\n            parent.appendChild(span);\n          }\n          label?.classList.add('ax-state-error');\n          target.classList.add('ax-state-error');\n\n          this._state = 'error';\n          break;\n      }\n      this.cdr.markForCheck();\n    }\n  }\n\n  protected onChangeCallback: (value: T) => void = noop;\n\n  registerOnChange(fn: (value: T) => void): void {\n    this.onChangeCallback = fn;\n  }\n\n  writeValue(value: T): void {\n    this.value = value;\n  }\n\n  public commitValue(value: T, u = false) {\n    if (u) {\n      this.markAsTouched();\n      this.markAsDirty();\n      this._isUserInteraction = true;\n    }\n    this.writeValue(value);\n  }\n\n  clear(e = false) {\n    this.commitValue(null, e);\n  }\n}\n"]}