@acorex/components 7.0.41 → 7.1.1

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

@@ -0,0 +1,207 @@
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import { EventEmitter, Injectable } from '@angular/core';
+import { AXObjectUtil } from '@acorex/core/utils';
+import { MXBaseComponent } from './base-component.class';
+import * as i0 from "@angular/core";
+class MXValueComponent extends MXBaseComponent {
+    /**
+     *  Fires each time the user press a key.
+     *  @event
+     */
+    onValueChanged = new EventEmitter();
+    valueChange = new EventEmitter();
+    stateChange = new EventEmitter();
+    _readonly = false;
+    /**
+     *  If set to true, user cannot change the value of component.
+     */
+    get readonly() {
+        return this._readonly;
+    }
+    set readonly(value) {
+        this._readonly = coerceBooleanProperty(value);
+    }
+    _name;
+    get name() {
+        return this._name;
+    }
+    set name(value) {
+        this._name = value;
+    }
+    _isUserInteraction = false;
+    get isUserInteraction() {
+        return this._isUserInteraction;
+    }
+    set isUserInteraction(value) {
+        this._isUserInteraction = value;
+    }
+    initValue;
+    defaultValue;
+    _value;
+    get value() {
+        return this.getValue(this._value) || this.defaultValue;
+    }
+    set value(v) {
+        v = this.setValue(v);
+        //if (!this._isInited ) {
+        const old = AXObjectUtil.deepJSONClone(this.value);
+        // TODO: check real equality
+        if (v != old) {
+            this._value = v;
+            this.emitOnValueChangedEvent(old, this.value);
+            this.cdr.markForCheck();
+            if (v == null || v == undefined || v == '' || (Array.isArray(v) && v.length == 0)) {
+                this.setState('clear');
+            }
+            // else {
+            //   if (this._isInited) {
+            //     this.validate();
+            //   }
+            // }
+        }
+        this._isUserInteraction = false;
+        //}
+    }
+    _state = '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._isUserInteraction = false;
+    }
+    setValue(value) {
+        return value;
+    }
+    getValue(value) {
+        return value;
+    }
+    ngOnInit() {
+        this.getHostElement().setAttribute('ax-form-input', 'true');
+    }
+    ngAfterViewInit() {
+        this._checkRequired();
+    }
+    ngOnDestroy() {
+        debugger;
+        this.onValueChanged?.unsubscribe();
+        this.onOptionChanged?.unsubscribe();
+    }
+    clear() {
+        this.value = null;
+    }
+    _checkRequired() {
+        const isRequired = Array.from(this.getHostElement().querySelectorAll('ax-validation-rule')).some(c => c.__axContext__.enabled && c.__axContext__.rule == 'required');
+        //
+        if (isRequired) {
+            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')?.__axContext__;
+            if (label)
+                label.required = true;
+        }
+    }
+    validate() {
+        const rules = Array.from(this.getHostElement().querySelectorAll('ax-validation-rule')).filter(c => c.__axContext__.enabled);
+        //
+        if (!rules || rules.length === 0) {
+            this.setState('clear');
+            return Promise.resolve({
+                result: true,
+                value: this.value,
+                name: this.name,
+                id: this.id,
+            });
+        }
+        return new Promise(resolve => {
+            Promise.all(rules
+                .filter(c => typeof c?.validate === 'function')
+                .map(c => {
+                return c.validate(this.value);
+            })).then(d => {
+                const error = d.find(c => c.result === false);
+                if (error) {
+                    this.setState('error', error.message);
+                    resolve({
+                        result: false,
+                        value: this.value,
+                        message: error.message,
+                        name: this.name,
+                        id: this.id,
+                    });
+                }
+                else {
+                    this.setState('success');
+                    resolve({
+                        result: true,
+                        value: this.value,
+                        name: this.name,
+                        id: this.id,
+                    });
+                }
+            });
+        });
+    }
+    setState(state, ...args) {
+        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.innerText = 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();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: MXValueComponent, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: MXValueComponent });
+}
+export { MXValueComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: MXValueComponent, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"value-component.class.js","sourceRoot":"","sources":["../../../../../../../projects/acorex/components/common/src/components/value-component.class.ts"],"names":[],"mappings":"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","sourcesContent":["import { coerceBooleanProperty } from '@angular/cdk/coercion';\r\nimport { EventEmitter, Injectable } from '@angular/core';\r\nimport { AXObjectUtil } from '@acorex/core/utils';\r\nimport { AXComponentState, MXBaseComponent } from './base-component.class';\r\nimport { AXValueChangedEvent } from '../classes/events.class';\r\n\r\n@Injectable()\r\nexport class MXValueComponent<T = any> extends MXBaseComponent {\r\n  /**\r\n   *  Fires each time the user press a key.\r\n   *  @event\r\n   */\r\n  onValueChanged: EventEmitter<AXValueChangedEvent<any>> = new EventEmitter<AXValueChangedEvent<any>>();\r\n\r\n  valueChange: EventEmitter<any> = new EventEmitter<any>();\r\n  stateChange: EventEmitter<AXComponentState> = new EventEmitter<AXComponentState>();\r\n\r\n  private _readonly: boolean = false;\r\n\r\n  /**\r\n   *  If set to true, user cannot change the value of component.\r\n   */\r\n  get readonly() {\r\n    return this._readonly;\r\n  }\r\n  set readonly(value: boolean) {\r\n    this._readonly = coerceBooleanProperty(value);\r\n  }\r\n\r\n  private _name: string;\r\n  get name() {\r\n    return this._name;\r\n  }\r\n  set name(value: string) {\r\n    this._name = value;\r\n  }\r\n\r\n  private _isUserInteraction: boolean = false;\r\n\r\n  get isUserInteraction(): boolean {\r\n    return this._isUserInteraction;\r\n  }\r\n\r\n  set isUserInteraction(value: boolean) {\r\n    this._isUserInteraction = value;\r\n  }\r\n\r\n\r\n  initValue:T;\r\n  defaultValue:T;\r\n\r\n  private _value: T;\r\n  get value(): T {\r\n    return this.getValue(this._value) || this.defaultValue;\r\n  }\r\n  set value(v: T) {\r\n    v = this.setValue(v);\r\n    //if (!this._isInited ) {\r\n    const old = AXObjectUtil.deepJSONClone(this.value);\r\n    // TODO: check real equality\r\n    if (v != old) {\r\n      this._value = v;\r\n      this.emitOnValueChangedEvent(old, this.value);\r\n      this.cdr.markForCheck();\r\n      if (v == null || v == undefined || v == '' || (Array.isArray(v) && v.length == 0)) {\r\n        this.setState('clear');\r\n      }\r\n      // else {\r\n      //   if (this._isInited) {\r\n      //     this.validate();\r\n      //   }\r\n      // }\r\n    }\r\n    this._isUserInteraction = false;\r\n    //}\r\n  }\r\n\r\n  private _state: AXComponentState = 'clear';\r\n\r\n  get state(): AXComponentState {\r\n    return this._state;\r\n  }\r\n\r\n  set state(value: AXComponentState) {\r\n    this.setState(value);\r\n    this.stateChange.emit(value);\r\n  }\r\n\r\n  protected emitOnValueChangedEvent(oldValue?: any, newValue?: any) {\r\n    this.valueChange.emit(newValue);\r\n    this.onValueChanged.emit({\r\n      component: this,\r\n      value: newValue,\r\n      oldValue: oldValue,\r\n      name: this.name,\r\n      isUserInteraction: this.isUserInteraction,\r\n    });\r\n    this._isUserInteraction = false;\r\n  }\r\n\r\n\r\n  protected setValue(value: any) {\r\n    return value;\r\n  }\r\n\r\n  protected getValue(value: any) {\r\n    return value;\r\n  }\r\n\r\n  protected ngOnInit(): void {\r\n    this.getHostElement().setAttribute('ax-form-input', 'true');\r\n  }\r\n\r\n  protected ngAfterViewInit(): void {\r\n    this._checkRequired();\r\n  }\r\n\r\n  protected ngOnDestroy() {\r\n    debugger\r\n    this.onValueChanged?.unsubscribe();\r\n    this.onOptionChanged?.unsubscribe();\r\n  }\r\n\r\n  clear() {\r\n    this.value = null;\r\n  }\r\n\r\n  private _checkRequired() {\r\n    const isRequired = Array.from(this.getHostElement().querySelectorAll('ax-validation-rule')).some(\r\n      c => (c as any).__axContext__.enabled && (c as any).__axContext__.rule == 'required'\r\n    );\r\n    //\r\n    if (isRequired) {\r\n      const container = this.getHostElement().classList.contains('ax-editor-container')\r\n        ? this.getHostElement()\r\n        : this.getHostElement().querySelector('.ax-editor-container');\r\n      const formField = container?.closest('.ax-form-field');\r\n      const label = (formField?.querySelector('ax-label') as any)?.__axContext__;\r\n      if (label) label.required = true;\r\n    }\r\n  }\r\n\r\n  validate(): Promise<any> {\r\n    const rules = Array.from(this.getHostElement().querySelectorAll('ax-validation-rule')).filter(c => (c as any).__axContext__.enabled);\r\n    //\r\n    if (!rules || rules.length === 0) {\r\n      this.setState('clear');\r\n      return Promise.resolve({\r\n        result: true,\r\n        value: this.value,\r\n        name: this.name,\r\n        id: this.id,\r\n      });\r\n    }\r\n\r\n    return new Promise<any>(resolve => {\r\n      Promise.all(\r\n        rules\r\n          .filter(c => typeof (c as any)?.validate === 'function')\r\n          .map(c => {\r\n            return (c as any).validate(this.value);\r\n          })\r\n      ).then(d => {\r\n        const error = d.find(c => c.result === false);\r\n        if (error) {\r\n          this.setState('error', error.message);\r\n          resolve({\r\n            result: false,\r\n            value: this.value,\r\n            message: error.message,\r\n            name: this.name,\r\n            id: this.id,\r\n          });\r\n        } else {\r\n          this.setState('success');\r\n          resolve({\r\n            result: true,\r\n            value: this.value,\r\n            name: this.name,\r\n            id: this.id,\r\n          });\r\n        }\r\n      });\r\n    });\r\n  }\r\n\r\n\r\n  protected setState(state: AXComponentState, ...args) {\r\n    const container = this.getHostElement().classList.contains('ax-editor-container')\r\n      ? this.getHostElement()\r\n      : this.getHostElement().querySelector('.ax-editor-container');\r\n    const formField = container?.closest('.ax-form-field');\r\n    const label = formField?.querySelector('ax-label') || formField?.querySelector('label');\r\n    let target = container || this.getHostElement().firstElementChild;\r\n    if (target?.querySelector('.ax-error-container')) {\r\n      target = target.querySelector('.ax-error-container');\r\n    }\r\n    const parent = target?.parentElement;\r\n    if (!target || !parent) return;\r\n\r\n    switch (state) {\r\n      case 'clear':\r\n        this._state = 'clear';\r\n        if (parent.querySelector('span.ax-error-message')) {\r\n          parent.removeChild(parent.querySelector('span.ax-error-message')!);\r\n        }\r\n        label?.classList.remove('ax-state-error');\r\n        target.classList.remove('ax-state-error', 'ax-state-success');\r\n        break;\r\n      case 'success':\r\n        this.setState('clear');\r\n        target.classList.add('ax-state-success');\r\n        this._state = 'success';\r\n        break;\r\n      case 'error':\r\n        this.setState('clear');\r\n        if (args[0]) {\r\n          const span = document.createElement('span');\r\n          span.innerText = args[0];\r\n          span.classList.add('ax-error-message');\r\n          parent.appendChild(span);\r\n        }\r\n        label?.classList.add('ax-state-error');\r\n        target.classList.add('ax-state-error');\r\n\r\n        this._state = 'error';\r\n        break;\r\n    }\r\n    this.cdr.markForCheck();\r\n  }\r\n\r\n}\r\n"]}

package/esm2022/common/src/constant/positions.mjs

@@ -0,0 +1,75 @@
+export const AXPositions = {
+    topStart: {
+        originX: 'start',
+        originY: 'top',
+        overlayX: 'start',
+        overlayY: 'bottom',
+    },
+    topCenter: {
+        originX: 'center',
+        originY: 'top',
+        overlayX: 'center',
+        overlayY: 'bottom',
+    },
+    topEnd: {
+        originX: 'end',
+        originY: 'top',
+        overlayX: 'end',
+        overlayY: 'bottom',
+    },
+    startStart: {
+        originX: 'start',
+        originY: 'top',
+        overlayX: 'end',
+        overlayY: 'top',
+    },
+    startCenter: {
+        originX: 'start',
+        originY: 'center',
+        overlayX: 'end',
+        overlayY: 'center',
+    },
+    startEnd: {
+        originX: 'start',
+        originY: 'bottom',
+        overlayX: 'end',
+        overlayY: 'bottom',
+    },
+    bottomStart: {
+        originX: 'start',
+        originY: 'bottom',
+        overlayX: 'start',
+        overlayY: 'top',
+    },
+    bottomCenter: {
+        originX: 'center',
+        originY: 'bottom',
+        overlayX: 'center',
+        overlayY: 'top',
+    },
+    bottomEnd: {
+        originX: 'end',
+        originY: 'bottom',
+        overlayX: 'end',
+        overlayY: 'top',
+    },
+    endStart: {
+        originX: 'end',
+        originY: 'top',
+        overlayX: 'start',
+        overlayY: 'top',
+    },
+    endCenter: {
+        originX: 'end',
+        originY: 'center',
+        overlayX: 'start',
+        overlayY: 'center',
+    },
+    endEnd: {
+        originX: 'end',
+        originY: 'bottom',
+        overlayX: 'start',
+        overlayY: 'bottom',
+    },
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG9zaXRpb25zLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvYWNvcmV4L2NvbXBvbmVudHMvY29tbW9uL3NyYy9jb25zdGFudC9wb3NpdGlvbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBY0EsTUFBTSxDQUFDLE1BQU0sV0FBVyxHQUFHO0lBQ3pCLFFBQVEsRUFBRTtRQUNSLE9BQU8sRUFBRSxPQUFPO1FBQ2hCLE9BQU8sRUFBRSxLQUFLO1FBQ2QsUUFBUSxFQUFFLE9BQU87UUFDakIsUUFBUSxFQUFFLFFBQVE7S0FDbkI7SUFDRCxTQUFTLEVBQUU7UUFDVCxPQUFPLEVBQUUsUUFBUTtRQUNqQixPQUFPLEVBQUUsS0FBSztRQUNkLFFBQVEsRUFBRSxRQUFRO1FBQ2xCLFFBQVEsRUFBRSxRQUFRO0tBQ25CO0lBQ0QsTUFBTSxFQUFFO1FBQ04sT0FBTyxFQUFFLEtBQUs7UUFDZCxPQUFPLEVBQUUsS0FBSztRQUNkLFFBQVEsRUFBRSxLQUFLO1FBQ2YsUUFBUSxFQUFFLFFBQVE7S0FDbkI7SUFFRCxVQUFVLEVBQUU7UUFDVixPQUFPLEVBQUUsT0FBTztRQUNoQixPQUFPLEVBQUUsS0FBSztRQUNkLFFBQVEsRUFBRSxLQUFLO1FBQ2YsUUFBUSxFQUFFLEtBQUs7S0FDaEI7SUFDRCxXQUFXLEVBQUU7UUFDWCxPQUFPLEVBQUUsT0FBTztRQUNoQixPQUFPLEVBQUUsUUFBUTtRQUNqQixRQUFRLEVBQUUsS0FBSztRQUNmLFFBQVEsRUFBRSxRQUFRO0tBQ25CO0lBQ0QsUUFBUSxFQUFFO1FBQ1IsT0FBTyxFQUFFLE9BQU87UUFDaEIsT0FBTyxFQUFFLFFBQVE7UUFDakIsUUFBUSxFQUFFLEtBQUs7UUFDZixRQUFRLEVBQUUsUUFBUTtLQUNuQjtJQUVELFdBQVcsRUFBRTtRQUNYLE9BQU8sRUFBRSxPQUFPO1FBQ2hCLE9BQU8sRUFBRSxRQUFRO1FBQ2pCLFFBQVEsRUFBRSxPQUFPO1FBQ2pCLFFBQVEsRUFBRSxLQUFLO0tBQ2hCO0lBQ0QsWUFBWSxFQUFFO1FBQ1osT0FBTyxFQUFFLFFBQVE7UUFDakIsT0FBTyxFQUFFLFFBQVE7UUFDakIsUUFBUSxFQUFFLFFBQVE7UUFDbEIsUUFBUSxFQUFFLEtBQUs7S0FDaEI7SUFDRCxTQUFTLEVBQUU7UUFDVCxPQUFPLEVBQUUsS0FBSztRQUNkLE9BQU8sRUFBRSxRQUFRO1FBQ2pCLFFBQVEsRUFBRSxLQUFLO1FBQ2YsUUFBUSxFQUFFLEtBQUs7S0FDaEI7SUFFRCxRQUFRLEVBQUU7UUFDUixPQUFPLEVBQUUsS0FBSztRQUNkLE9BQU8sRUFBRSxLQUFLO1FBQ2QsUUFBUSxFQUFFLE9BQU87UUFDakIsUUFBUSxFQUFFLEtBQUs7S0FDaEI7SUFDRCxTQUFTLEVBQUU7UUFDVCxPQUFPLEVBQUUsS0FBSztRQUNkLE9BQU8sRUFBRSxRQUFRO1FBQ2pCLFFBQVEsRUFBRSxPQUFPO1FBQ2pCLFFBQVEsRUFBRSxRQUFRO0tBQ25CO0lBQ0QsTUFBTSxFQUFFO1FBQ04sT0FBTyxFQUFFLEtBQUs7UUFDZCxPQUFPLEVBQUUsUUFBUTtRQUNqQixRQUFRLEVBQUUsT0FBTztRQUNqQixRQUFRLEVBQUUsUUFBUTtLQUNuQjtDQUNGLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgdHlwZSBBWFBvc2l0aW9uID1cclxuICB8ICd0b3Atc3RhcnQnXHJcbiAgfCAndG9wLWNlbnRlcidcclxuICB8ICd0b3AtZW5kJ1xyXG4gIHwgJ3N0YXJ0LXN0YXJ0J1xyXG4gIHwgJ3N0YXJ0LWNlbnRlcidcclxuICB8ICdzdGFydC1lbmQnXHJcbiAgfCAnYm90dG9tLXN0YXJ0J1xyXG4gIHwgJ2JvdHRvbS1jZW50ZXInXHJcbiAgfCAnYm90dG9tLWVuZCdcclxuICB8ICdlbmQtc3RhcnQnXHJcbiAgfCAnZW5kLWNlbnRlcidcclxuICB8ICdlbmQtZW5kJztcclxuXHJcbmV4cG9ydCBjb25zdCBBWFBvc2l0aW9ucyA9IHtcclxuICB0b3BTdGFydDoge1xyXG4gICAgb3JpZ2luWDogJ3N0YXJ0JyxcclxuICAgIG9yaWdpblk6ICd0b3AnLFxyXG4gICAgb3ZlcmxheVg6ICdzdGFydCcsXHJcbiAgICBvdmVybGF5WTogJ2JvdHRvbScsXHJcbiAgfSxcclxuICB0b3BDZW50ZXI6IHtcclxuICAgIG9yaWdpblg6ICdjZW50ZXInLFxyXG4gICAgb3JpZ2luWTogJ3RvcCcsXHJcbiAgICBvdmVybGF5WDogJ2NlbnRlcicsXHJcbiAgICBvdmVybGF5WTogJ2JvdHRvbScsXHJcbiAgfSxcclxuICB0b3BFbmQ6IHtcclxuICAgIG9yaWdpblg6ICdlbmQnLFxyXG4gICAgb3JpZ2luWTogJ3RvcCcsXHJcbiAgICBvdmVybGF5WDogJ2VuZCcsXHJcbiAgICBvdmVybGF5WTogJ2JvdHRvbScsXHJcbiAgfSxcclxuXHJcbiAgc3RhcnRTdGFydDoge1xyXG4gICAgb3JpZ2luWDogJ3N0YXJ0JyxcclxuICAgIG9yaWdpblk6ICd0b3AnLFxyXG4gICAgb3ZlcmxheVg6ICdlbmQnLFxyXG4gICAgb3ZlcmxheVk6ICd0b3AnLFxyXG4gIH0sXHJcbiAgc3RhcnRDZW50ZXI6IHtcclxuICAgIG9yaWdpblg6ICdzdGFydCcsXHJcbiAgICBvcmlnaW5ZOiAnY2VudGVyJyxcclxuICAgIG92ZXJsYXlYOiAnZW5kJyxcclxuICAgIG92ZXJsYXlZOiAnY2VudGVyJyxcclxuICB9LFxyXG4gIHN0YXJ0RW5kOiB7XHJcbiAgICBvcmlnaW5YOiAnc3RhcnQnLFxyXG4gICAgb3JpZ2luWTogJ2JvdHRvbScsXHJcbiAgICBvdmVybGF5WDogJ2VuZCcsXHJcbiAgICBvdmVybGF5WTogJ2JvdHRvbScsXHJcbiAgfSxcclxuXHJcbiAgYm90dG9tU3RhcnQ6IHtcclxuICAgIG9yaWdpblg6ICdzdGFydCcsXHJcbiAgICBvcmlnaW5ZOiAnYm90dG9tJyxcclxuICAgIG92ZXJsYXlYOiAnc3RhcnQnLFxyXG4gICAgb3ZlcmxheVk6ICd0b3AnLFxyXG4gIH0sXHJcbiAgYm90dG9tQ2VudGVyOiB7XHJcbiAgICBvcmlnaW5YOiAnY2VudGVyJyxcclxuICAgIG9yaWdpblk6ICdib3R0b20nLFxyXG4gICAgb3ZlcmxheVg6ICdjZW50ZXInLFxyXG4gICAgb3ZlcmxheVk6ICd0b3AnLFxyXG4gIH0sXHJcbiAgYm90dG9tRW5kOiB7XHJcbiAgICBvcmlnaW5YOiAnZW5kJyxcclxuICAgIG9yaWdpblk6ICdib3R0b20nLFxyXG4gICAgb3ZlcmxheVg6ICdlbmQnLFxyXG4gICAgb3ZlcmxheVk6ICd0b3AnLFxyXG4gIH0sXHJcblxyXG4gIGVuZFN0YXJ0OiB7XHJcbiAgICBvcmlnaW5YOiAnZW5kJyxcclxuICAgIG9yaWdpblk6ICd0b3AnLFxyXG4gICAgb3ZlcmxheVg6ICdzdGFydCcsXHJcbiAgICBvdmVybGF5WTogJ3RvcCcsXHJcbiAgfSxcclxuICBlbmRDZW50ZXI6IHtcclxuICAgIG9yaWdpblg6ICdlbmQnLFxyXG4gICAgb3JpZ2luWTogJ2NlbnRlcicsXHJcbiAgICBvdmVybGF5WDogJ3N0YXJ0JyxcclxuICAgIG92ZXJsYXlZOiAnY2VudGVyJyxcclxuICB9LFxyXG4gIGVuZEVuZDoge1xyXG4gICAgb3JpZ2luWDogJ2VuZCcsXHJcbiAgICBvcmlnaW5ZOiAnYm90dG9tJyxcclxuICAgIG92ZXJsYXlYOiAnc3RhcnQnLFxyXG4gICAgb3ZlcmxheVk6ICdib3R0b20nLFxyXG4gIH0sXHJcbn07XHJcbiJdfQ==

package/esm2022/common/src/directives/auto-focus.directive.mjs

@@ -0,0 +1,58 @@
+import { Directive, Host, Input, Optional, Self, } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../classes/components.class";
+class AXAutoFocusDirective {
+    el;
+    _host;
+    autoFocus = true;
+    constructor(el, _host) {
+        this.el = el;
+        this._host = _host;
+    }
+    time = 100;
+    ngAfterContentInit() {
+        if (this.autoFocus) {
+            const list = [
+                'button',
+                'input',
+                '[href]',
+                'select',
+                'textarea',
+                '[tabindex]',
+            ].map((c) => c + ':not([tabindex="-1"])');
+            const focusable = this.el.nativeElement.querySelector(list.join(', ')) ??
+                this.el.nativeElement;
+            const attr = document.createAttribute('autofocus');
+            focusable.setAttributeNode(attr);
+            const hasTabindex = focusable.hasAttribute('tabindex');
+            if (!hasTabindex) {
+                focusable.setAttribute('tabIndex', '0');
+            }
+            setTimeout(() => {
+                focusable.focus();
+            }, 100);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: AXAutoFocusDirective, deps: [{ token: i0.ElementRef }, { token: i1.AXFocusableComponent, host: true, optional: true, self: true }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0", type: AXAutoFocusDirective, selector: "[axAutoFocus]", inputs: { autoFocus: ["axAutoFocus", "autoFocus"], time: ["focus-time", "time"] }, ngImport: i0 });
+}
+export { AXAutoFocusDirective };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: AXAutoFocusDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[axAutoFocus]',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.AXFocusableComponent, decorators: [{
+                    type: Host
+                }, {
+                    type: Self
+                }, {
+                    type: Optional
+                }] }]; }, propDecorators: { autoFocus: [{
+                type: Input,
+                args: ['axAutoFocus']
+            }], time: [{
+                type: Input,
+                args: ['focus-time']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/common/src/directives/debounce-time.directive.mjs

@@ -0,0 +1,50 @@
+import { Directive, EventEmitter, Input, Output } from "@angular/core";
+import { debounceTime, distinctUntilChanged, skip } from "rxjs";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+class AXNgModelChangeDebouncedDirective {
+    ngModel;
+    ngModelChangeDebounced = new EventEmitter();
+    ngModelChangeDebounceTimeChange = new EventEmitter();
+    _ngModelChangeDebounceTime = 0;
+    get ngModelChangeDebounceTime() {
+        return this._ngModelChangeDebounceTime;
+    }
+    set ngModelChangeDebounceTime(v) {
+        if (v != this._ngModelChangeDebounceTime) {
+            this._ngModelChangeDebounceTime = v;
+            this.ngModelChangeDebounceTimeChange.emit(v);
+            this.update();
+        }
+    }
+    subscription;
+    ngOnDestroy() {
+        this.subscription.unsubscribe();
+    }
+    constructor(ngModel) {
+        this.ngModel = ngModel;
+        this.ngModelChangeDebounceTime = 0;
+    }
+    update() {
+        this.subscription?.unsubscribe();
+        //
+        this.subscription = this.ngModel.control.valueChanges.pipe(skip(1), // skip initial value
+        distinctUntilChanged(), debounceTime(this.ngModelChangeDebounceTime)).subscribe((value) => this.ngModelChangeDebounced.emit(value));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: AXNgModelChangeDebouncedDirective, deps: [{ token: i1.NgModel }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0", type: AXNgModelChangeDebouncedDirective, selector: "[ngModelChangeDebounced]", inputs: { ngModelChangeDebounceTime: "ngModelChangeDebounceTime" }, outputs: { ngModelChangeDebounced: "ngModelChangeDebounced", ngModelChangeDebounceTimeChange: "ngModelChangeDebounceTimeChange" }, ngImport: i0 });
+}
+export { AXNgModelChangeDebouncedDirective };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: AXNgModelChangeDebouncedDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[ngModelChangeDebounced]',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.NgModel }]; }, propDecorators: { ngModelChangeDebounced: [{
+                type: Output
+            }], ngModelChangeDebounceTimeChange: [{
+                type: Output
+            }], ngModelChangeDebounceTime: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/common/src/directives/hotkey.directive.mjs

@@ -0,0 +1,83 @@
+import { Directive, Host, Input, Optional, Self, } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../classes/components.class";
+import * as i2 from "../services/hotkey.service";
+class AXHotkeyDirective {
+    el;
+    _host;
+    hs;
+    hotkey = '';
+    _subs = [];
+    constructor(el, _host, hs) {
+        this.el = el;
+        this._host = _host;
+        this.hs = hs;
+    }
+    ngAfterViewInit() {
+        if (!this.hotkey || !this._host)
+            return;
+        if (typeof this.hotkey == 'string') {
+            this._addDefaultAction(this.hotkey);
+        }
+        else if (typeof this.hotkey == 'object' && !Array.isArray(this.hotkey)) {
+            this._addHotKeyAction([this.hotkey]);
+        }
+        else if (Array.isArray(this.hotkey)) {
+            this._addHotKeyAction(this.hotkey);
+        }
+    }
+    _addDefaultAction(hotkey) {
+        this._subs.push(this.hs.addShortcut({ keys: hotkey }).subscribe(() => {
+            ['click', 'toggle', 'open', 'focus'].forEach((a) => {
+                if (this._host[a]) {
+                    this._host[a]();
+                    return;
+                }
+            });
+        }));
+    }
+    _addHotKeyAction(hotkeys) {
+        hotkeys.forEach((k) => {
+            const hotkey = Object.entries(k)[0][0];
+            const action = Object.entries(k)[0][1];
+            if (!action)
+                this._addDefaultAction(hotkey);
+            else {
+                this._subs.push(this.hs.addShortcut({ keys: hotkey }).subscribe(() => {
+                    if (typeof action == 'string' && this._host[action]) {
+                        this._host[action]();
+                        return;
+                    }
+                    if (typeof action == 'function') {
+                        action();
+                        return;
+                    }
+                }));
+            }
+        });
+    }
+    ngOnDestroy() {
+        this._subs.forEach((s) => {
+            s.unsubscribe();
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: AXHotkeyDirective, deps: [{ token: i0.ElementRef }, { token: i1.AXComponent, host: true, optional: true, self: true }, { token: i2.AXHotkeysService }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0", type: AXHotkeyDirective, selector: "[hotkey]", inputs: { hotkey: "hotkey" }, ngImport: i0 });
+}
+export { AXHotkeyDirective };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: AXHotkeyDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[hotkey]',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.AXComponent, decorators: [{
+                    type: Host
+                }, {
+                    type: Self
+                }, {
+                    type: Optional
+                }] }, { type: i2.AXHotkeysService }]; }, propDecorators: { hotkey: [{
+                type: Input,
+                args: ['hotkey']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/common/src/directives/infinite-scroll.directive.mjs

@@ -0,0 +1,70 @@
+import { Directive, Input } from '@angular/core';
+import { fromEvent } from 'rxjs';
+import { exhaustMap, filter, map, pairwise, startWith } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+;
+const AX_DEFAULT_SCROLL_POSITION = {
+    scrollHeight: 0,
+    scrollTop: 0,
+    clientHeight: 0
+};
+class AXInfiniteScrollerDirective {
+    elm;
+    scrollEvent$;
+    userScrolledDown$;
+    requestOnScroll$;
+    scrollCallback;
+    immediateCallback;
+    scrollPercent = 70;
+    constructor(elm) {
+        this.elm = elm;
+    }
+    ngAfterViewInit() {
+        this.registerScrollEvent();
+        this.streamScrollEvents();
+        this.requestCallbackOnScroll();
+    }
+    registerScrollEvent() {
+        this.scrollEvent$ = fromEvent(this.elm.nativeElement, 'scroll');
+    }
+    streamScrollEvents() {
+        this.userScrolledDown$ = this.scrollEvent$
+            .pipe(map((e) => ({
+            scrollHeight: e.target.scrollHeight,
+            scrollTop: e.target.scrollTop,
+            clientHeight: e.target.clientHeight
+        })), pairwise(), filter(positions => this.isUserScrollingDown(positions) && this.isScrollExpectedPercent(positions[1])));
+    }
+    requestCallbackOnScroll() {
+        this.requestOnScroll$ = this.userScrolledDown$;
+        if (this.immediateCallback) {
+            this.requestOnScroll$ = this.requestOnScroll$.pipe(startWith([AX_DEFAULT_SCROLL_POSITION, AX_DEFAULT_SCROLL_POSITION]));
+        }
+        this.requestOnScroll$.pipe(exhaustMap(() => {
+            return this.scrollCallback();
+        }));
+        //.subscribe((data) => { console.log(data) }, (err) => console.log(err));
+    }
+    isUserScrollingDown = (positions) => {
+        return positions[0].sT < positions[1].sT;
+    };
+    isScrollExpectedPercent = (position) => {
+        return ((position.sT + position.cH) / position.sH) > (this.scrollPercent / 100);
+    };
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: AXInfiniteScrollerDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0", type: AXInfiniteScrollerDirective, selector: "[axInfiniteScroller]", inputs: { scrollCallback: "scrollCallback", immediateCallback: "immediateCallback", scrollPercent: "scrollPercent" }, ngImport: i0 });
+}
+export { AXInfiniteScrollerDirective };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: AXInfiniteScrollerDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[axInfiniteScroller]'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { scrollCallback: [{
+                type: Input
+            }], immediateCallback: [{
+                type: Input
+            }], scrollPercent: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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