@acorex/components 7.0.41 → 7.1.1

package/esm2022/form/src/form.component.mjs

@@ -0,0 +1,164 @@
+import { ChangeDetectionStrategy, Component, EventEmitter, Input, Output, ViewEncapsulation, } from '@angular/core';
+import { AXEvent } from '@acorex/components/common';
+import { AXBaseComponentMixin } from '@acorex/components/mixin';
+import * as i0 from "@angular/core";
+/**
+ *  Contains native event
+ * @category Events
+ */
+export class AXFormValidationEvent extends AXEvent {
+    result;
+}
+/**
+ * The Button is a component which detects user interaction and triggers a corresponding event
+ *
+ * @category Components
+ */
+class AXFormComponent extends AXBaseComponentMixin {
+    cdr;
+    validationMessageMode = 'normal';
+    onValidate = new EventEmitter();
+    updateOnChange = new EventEmitter();
+    _updateOn = 'blur';
+    get updateOn() {
+        return this._updateOn;
+    }
+    set updateOn(v) {
+        this._setOption({
+            name: 'updateOn',
+            value: v,
+            afterCallback: (oldValue, newValue) => {
+                this._bindEvents();
+            },
+        });
+    }
+    validateInitValues = false;
+    _observer;
+    _subs = [];
+    /**
+     *  @ignore
+     */
+    constructor(elementRef, cdr) {
+        super(elementRef, cdr);
+        this.cdr = cdr;
+    }
+    _handleSubmit(e) {
+        e.preventDefault();
+        this.validate();
+    }
+    _handleReset(e) {
+        this.clear();
+    }
+    _getComponenets() {
+        return Array.from(this._getHostElement().querySelectorAll('[ax-form-input="true"]')).map(c => c.__axContext__);
+    }
+    onViewInit() {
+        if (this.validateInitValues) {
+            this._validateInitValues();
+        }
+        this._bindEvents();
+        const config = { attributes: false, childList: true, subtree: true };
+        const callback = (mutationList, observer) => {
+            this._bindEvents();
+        };
+        // Create an observer instance linked to the callback function
+        this._observer = new MutationObserver(callback);
+        this._observer.observe(this._getHostElement(), config);
+    }
+    _bindEvents() {
+        this._clearSubs();
+        const widgets = this._getComponenets();
+        //
+        widgets.forEach(w => {
+            if (this.updateOn == 'change') {
+                this._subs.push(w.onValueChanged?.subscribe(v => {
+                    w.validate();
+                }));
+            }
+            else if (this.updateOn == 'blur') {
+                this._subs.push(w.onBlur?.subscribe(v => {
+                    w.validate();
+                }));
+            }
+        });
+    }
+    _clearSubs() {
+        this._subs.forEach(c => c.unsubscribe());
+        this._subs = [];
+    }
+    _validateInitValues() {
+        this._getComponenets()
+            .filter(c => c['value'])
+            .forEach(c => c.validate());
+    }
+    validate(...args) {
+        const widgets = this._getComponenets();
+        if (widgets.length === 0) {
+            this._emitOnValidateEvent({ result: true });
+            return Promise.resolve({ result: true });
+        }
+        //
+        return new Promise((resolve, reject) => {
+            Promise.all(widgets
+                .filter(c => args == null || args.length == 0 || args.includes(c.name))
+                .map(c => c.validate())).then((rules) => {
+                const failed = rules.filter((c) => !c.result);
+                if (failed.length) {
+                    this._emitOnValidateEvent({
+                        result: false,
+                        items: failed,
+                    });
+                    resolve({
+                        result: false,
+                        items: failed,
+                    });
+                }
+                else {
+                    this._emitOnValidateEvent({ result: true });
+                    resolve({ result: true });
+                }
+            });
+        });
+    }
+    _emitOnValidateEvent(e) {
+        this.onValidate.emit({
+            component: this,
+            result: e,
+            htmlElement: this._getHostElement(),
+        });
+    }
+    clear() {
+        const widgets = this._getComponenets();
+        widgets.forEach(w => {
+            w.clear();
+        });
+    }
+    onDestroy() {
+        this._observer.disconnect();
+        this._observer = null;
+        this._clearSubs();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: AXFormComponent, deps: [{ token: i0.ElementRef }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: AXFormComponent, selector: "ax-form", inputs: { validationMessageMode: "validationMessageMode", updateOn: "updateOn", validateInitValues: "validateInitValues" }, outputs: { onValidate: "onValidate", updateOnChange: "updateOnChange" }, usesInheritance: true, ngImport: i0, template: '<form (submit)="_handleSubmit($event)" (reset)="_handleReset($event)" class="ax-{{validationMessageMode}}-error"><ng-content></ng-content></form>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });
+}
+export { AXFormComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: AXFormComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ax-form',
+                    template: '<form (submit)="_handleSubmit($event)" (reset)="_handleReset($event)" class="ax-{{validationMessageMode}}-error"><ng-content></ng-content></form>',
+                    encapsulation: ViewEncapsulation.None,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.ChangeDetectorRef }]; }, propDecorators: { validationMessageMode: [{
+                type: Input
+            }], onValidate: [{
+                type: Output
+            }], updateOnChange: [{
+                type: Output
+            }], updateOn: [{
+                type: Input
+            }], validateInitValues: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"form.component.js","sourceRoot":"","sources":["../../../../../../projects/acorex/components/form/src/form.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  ChangeDetectionStrategy,\r\n  ChangeDetectorRef,\r\n  Component,\r\n  ElementRef,\r\n  EventEmitter,\r\n  Input,\r\n  Output,\r\n  ViewEncapsulation,\r\n} from '@angular/core';\r\nimport { AXEvent } from '@acorex/components/common';\r\nimport { AXFormValidationResult } from './validation.class';\r\nimport { AXBaseComponentMixin } from '@acorex/components/mixin';\r\nimport { Subscription } from 'rxjs';\r\n\r\n/**\r\n *  Contains native event\r\n * @category Events\r\n */\r\nexport class AXFormValidationEvent extends AXEvent {\r\n  result: AXFormValidationResult;\r\n}\r\n\r\n/**\r\n *  Contains native event\r\n * @category Events\r\n */\r\nexport type AXFormUpdateOn = 'change' | 'blur' | 'manual';\r\n\r\n/**\r\n * The Button is a component which detects user interaction and triggers a corresponding event\r\n *\r\n * @category Components\r\n */\r\n@Component({\r\n  selector: 'ax-form',\r\n  template:\r\n    '<form (submit)=\"_handleSubmit($event)\" (reset)=\"_handleReset($event)\" class=\"ax-{{validationMessageMode}}-error\"><ng-content></ng-content></form>',\r\n  encapsulation: ViewEncapsulation.None,\r\n  changeDetection: ChangeDetectionStrategy.OnPush,\r\n})\r\nexport class AXFormComponent extends AXBaseComponentMixin {\r\n  @Input() validationMessageMode: 'normal' | 'tooltip' = 'normal';\r\n\r\n  @Output()\r\n  onValidate: EventEmitter<AXFormValidationEvent> =\r\n    new EventEmitter<AXFormValidationEvent>();\r\n\r\n  @Output()\r\n  updateOnChange: EventEmitter<AXFormUpdateOn> =\r\n    new EventEmitter<AXFormUpdateOn>();\r\n\r\n  private _updateOn: AXFormUpdateOn = 'blur';\r\n  @Input()\r\n  public get updateOn(): AXFormUpdateOn {\r\n    return this._updateOn;\r\n  }\r\n  public set updateOn(v: AXFormUpdateOn) {\r\n    this._setOption({\r\n      name: 'updateOn',\r\n      value: v,\r\n      afterCallback: (oldValue?, newValue?) => {\r\n        this._bindEvents();\r\n      },\r\n    });\r\n  }\r\n\r\n  @Input()\r\n  validateInitValues: boolean = false;\r\n\r\n  private _observer: MutationObserver;\r\n  private _subs: Subscription[] = [];\r\n\r\n  /**\r\n   *  @ignore\r\n   */\r\n  constructor(elementRef: ElementRef, private cdr: ChangeDetectorRef) {\r\n    super(elementRef, cdr);\r\n  }\r\n\r\n  _handleSubmit(e: SubmitEvent) {\r\n    e.preventDefault();\r\n    this.validate();\r\n  }\r\n\r\n  _handleReset(e: Event) {\r\n    this.clear();\r\n  }\r\n\r\n  private _getComponenets() {\r\n    return Array.from(\r\n      this._getHostElement().querySelectorAll('[ax-form-input=\"true\"]')\r\n    ).map(c => (c as any).__axContext__);\r\n  }\r\n\r\n  onViewInit(): void {\r\n    if (this.validateInitValues) {\r\n      this._validateInitValues();\r\n    }\r\n    this._bindEvents();\r\n\r\n    const config = { attributes: false, childList: true, subtree: true };\r\n    const callback = (mutationList, observer) => {\r\n      this._bindEvents();\r\n    };\r\n\r\n    // Create an observer instance linked to the callback function\r\n    this._observer = new MutationObserver(callback);\r\n    this._observer.observe(this._getHostElement(), config);\r\n  }\r\n\r\n  private _bindEvents() {\r\n    this._clearSubs();\r\n    const widgets = this._getComponenets();\r\n    //\r\n    widgets.forEach(w => {\r\n      if (this.updateOn == 'change') {\r\n        this._subs.push(\r\n          w.onValueChanged?.subscribe(v => {\r\n            w.validate();\r\n          })\r\n        );\r\n      } else if (this.updateOn == 'blur') {\r\n        this._subs.push(\r\n          w.onBlur?.subscribe(v => {\r\n            w.validate();\r\n          })\r\n        );\r\n      }\r\n    });\r\n  }\r\n\r\n  private _clearSubs() {\r\n    this._subs.forEach(c => c.unsubscribe());\r\n    this._subs = [];\r\n  }\r\n\r\n  private _validateInitValues() {\r\n    this._getComponenets()\r\n      .filter(c => c['value'])\r\n      .forEach(c => c.validate());\r\n  }\r\n\r\n  validate(...args: string[]): Promise<AXFormValidationResult> {\r\n    const widgets = this._getComponenets();\r\n    if (widgets.length === 0) {\r\n      this._emitOnValidateEvent({ result: true });\r\n      return Promise.resolve({ result: true });\r\n    }\r\n    //\r\n    return new Promise<AXFormValidationResult>((resolve, reject) => {\r\n      Promise.all(\r\n        widgets\r\n          .filter(\r\n            c => args == null || args.length == 0 || args.includes(c.name)\r\n          )\r\n          .map(c => c.validate())\r\n      ).then((rules: any) => {\r\n        const failed = rules.filter((c: any) => !c.result);\r\n        if (failed.length) {\r\n          this._emitOnValidateEvent({\r\n            result: false,\r\n            items: failed,\r\n          });\r\n          resolve({\r\n            result: false,\r\n            items: failed,\r\n          });\r\n        } else {\r\n          this._emitOnValidateEvent({ result: true });\r\n          resolve({ result: true });\r\n        }\r\n      });\r\n    });\r\n  }\r\n\r\n  private _emitOnValidateEvent(e: AXFormValidationResult) {\r\n    this.onValidate.emit({\r\n      component: this,\r\n      result: e,\r\n      htmlElement: this._getHostElement(),\r\n    });\r\n  }\r\n\r\n  clear() {\r\n    const widgets = this._getComponenets();\r\n    widgets.forEach(w => {\r\n      w.clear();\r\n    });\r\n  }\r\n\r\n  onDestroy(): void {\r\n    this._observer.disconnect();\r\n    this._observer = null;\r\n    this._clearSubs();\r\n  }\r\n}\r\n"]}

package/esm2022/form/src/form.module.mjs

@@ -0,0 +1,64 @@
+import { AXAlertModule } from '@acorex/components/alert';
+import { AXButtonModule } from '@acorex/components/button';
+import { AXDecoratorModule } from '@acorex/components/decorators';
+import { AXConfig } from '@acorex/core/config';
+import { AXTranslator } from '@acorex/core/translation';
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { AXFormFieldComponent } from './form-field.component';
+import { AXFormComponent } from './form.component';
+import { AXValidationRuleComponent } from './validation-rule.widget';
+import { AXValidationSummaryComponent } from './validation-summary.component';
+import * as i0 from "@angular/core";
+class AXFormModule {
+    constructor() {
+        AXConfig.set({
+            form: {
+                validation: {
+                    rules: {
+                        email: {
+                            rule: 'regex',
+                            value: /^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/,
+                            message: AXTranslator.get('validation.messages.email'),
+                        },
+                        phone: {
+                            rule: 'regex',
+                            value: /^[+]*[(]{0,1}[0-9]{1,4}[)]{0,1}[-\s\./0-9]*$/,
+                            message: AXTranslator.get('validation.messages.phone'),
+                        },
+                    },
+                },
+            },
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: AXFormModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.0.0", ngImport: i0, type: AXFormModule, declarations: [AXFormFieldComponent,
+            AXFormComponent,
+            AXValidationRuleComponent,
+            AXValidationSummaryComponent], imports: [CommonModule, AXDecoratorModule, AXAlertModule, AXButtonModule], exports: [AXFormFieldComponent,
+            AXFormComponent,
+            AXValidationRuleComponent,
+            AXValidationSummaryComponent] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: AXFormModule, imports: [CommonModule, AXDecoratorModule, AXAlertModule, AXButtonModule] });
+}
+export { AXFormModule };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: AXFormModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        AXFormFieldComponent,
+                        AXFormComponent,
+                        AXValidationRuleComponent,
+                        AXValidationSummaryComponent,
+                    ],
+                    imports: [CommonModule, AXDecoratorModule, AXAlertModule, AXButtonModule],
+                    exports: [
+                        AXFormFieldComponent,
+                        AXFormComponent,
+                        AXValidationRuleComponent,
+                        AXValidationSummaryComponent,
+                    ],
+                    providers: [],
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/form/src/validation-rule.widget.mjs

@@ -0,0 +1,114 @@
+import { ChangeDetectionStrategy, Component, Input, ViewEncapsulation } from '@angular/core';
+import { AXConfig } from '@acorex/core/config';
+import { AXTranslator } from '@acorex/core/translation';
+import { AXBaseComponentMixin } from '@acorex/components/mixin';
+import * as i0 from "@angular/core";
+class AXValidationRuleComponent extends AXBaseComponentMixin {
+    rule = 'required';
+    message;
+    showMessage = true;
+    value;
+    enabled = true;
+    constructor(elementRef, cdr) {
+        super(elementRef, cdr);
+    }
+    onInit() {
+        this._getHostElement().validate = this.validate.bind(this);
+    }
+    validate(value) {
+        if (this.enabled === false) {
+            return Promise.resolve({ result: true });
+        }
+        if (this.rule == 'custom') {
+            const regRule = AXConfig.get(`form.validation.rules.${this.value}`);
+            if (regRule) {
+                return this._internalValidate(regRule.rule, value, this.message || regRule.message, regRule.value);
+            }
+        }
+        return this._internalValidate(this.rule, value, this.message, this.value);
+    }
+    _internalValidate(type, value, message, ruleValue) {
+        return new Promise(resolve => {
+            switch (type) {
+                case 'required':
+                    resolve({
+                        message: this.showMessage ? message || AXTranslator.get('validation.messages.required') : '',
+                        result: !this._isNullOrEmpty(value),
+                    });
+                    break;
+                case 'regex':
+                    const ex = new RegExp(ruleValue);
+                    resolve({
+                        message: this.showMessage ? message || AXTranslator.get('validation.messages.regex') : '',
+                        result: ex.test(value),
+                    });
+                    break;
+                case 'callback':
+                    if (typeof ruleValue === 'function') {
+                        const res = {};
+                        res.message = this.showMessage ? message : null;
+                        const val = ruleValue({ value, message });
+                        if (val instanceof Promise) {
+                            val
+                                .then(c => {
+                                res.result = c;
+                            })
+                                .catch(c => {
+                                res.result = false;
+                            })
+                                .finally(() => {
+                                resolve(res);
+                            });
+                        }
+                        else {
+                            res.result = val;
+                            resolve(res);
+                        }
+                    }
+                    else {
+                        resolve({
+                            message: AXTranslator.get('validation.messages.invalid-rull-fn'),
+                            result: false,
+                        });
+                    }
+                    break;
+                default:
+                    resolve({
+                        message: AXTranslator.get('validation.messages.invalid-rull-name'),
+                        result: false,
+                    });
+            }
+        });
+    }
+    _isNullOrEmpty(value) {
+        return (value === undefined ||
+            value === null ||
+            Number.isNaN(value) ||
+            //(typeof value === 'object' && Object.keys(value).length === 0) ||
+            (Array.isArray(value) && value.length == 0) ||
+            (typeof value === 'string' && value.trim().length === 0));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: AXValidationRuleComponent, deps: [{ token: i0.ElementRef }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: AXValidationRuleComponent, selector: "ax-validation-rule", inputs: { rule: "rule", message: "message", showMessage: "showMessage", value: "value", enabled: "enabled" }, usesInheritance: true, ngImport: i0, template: '', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });
+}
+export { AXValidationRuleComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: AXValidationRuleComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ax-validation-rule',
+                    template: '',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    encapsulation: ViewEncapsulation.None,
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.ChangeDetectorRef }]; }, propDecorators: { rule: [{
+                type: Input
+            }], message: [{
+                type: Input
+            }], showMessage: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }], enabled: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"validation-rule.widget.js","sourceRoot":"","sources":["../../../../../../projects/acorex/components/form/src/validation-rule.widget.ts"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectionStrategy, ChangeDetectorRef, Component, ElementRef, Input, ViewEncapsulation } from '@angular/core';\r\nimport { AXValidationRuleResult, AXValidationRule, AXValidationRuleTypes } from './validation.class';\r\nimport { AXConfig } from '@acorex/core/config';\r\nimport { AXTranslator } from '@acorex/core/translation';\r\nimport { AXBaseComponentMixin } from '@acorex/components/mixin';\r\n\r\n@Component({\r\n  selector: 'ax-validation-rule',\r\n  template: '',\r\n  changeDetection: ChangeDetectionStrategy.OnPush,\r\n  encapsulation: ViewEncapsulation.None,\r\n})\r\nexport class AXValidationRuleComponent extends AXBaseComponentMixin implements AXValidationRule {\r\n  @Input()\r\n  rule: AXValidationRuleTypes = 'required';\r\n\r\n  @Input()\r\n  message: string;\r\n\r\n  @Input()\r\n  showMessage: boolean = true;\r\n\r\n  @Input()\r\n  value: any;\r\n\r\n  @Input()\r\n  enabled: boolean = true;\r\n\r\n  constructor(elementRef: ElementRef, cdr: ChangeDetectorRef) {\r\n    super(elementRef, cdr);\r\n  }\r\n\r\n  onInit() {\r\n    (this._getHostElement() as any).validate = this.validate.bind(this);\r\n  }\r\n\r\n  validate(value: any): Promise<AXValidationRuleResult> {\r\n    if (this.enabled === false) {\r\n      return Promise.resolve({ result: true });\r\n    }\r\n    if (this.rule == 'custom') {\r\n      const regRule = AXConfig.get(`form.validation.rules.${this.value}`);\r\n      if (regRule) {\r\n        return this._internalValidate(regRule.rule, value, this.message || regRule.message, regRule.value);\r\n      }\r\n    }\r\n    return this._internalValidate(this.rule, value, this.message, this.value);\r\n  }\r\n\r\n  private _internalValidate(type: string, value?: any, message?: string, ruleValue?: any): Promise<AXValidationRuleResult> {\r\n    return new Promise<AXValidationRuleResult>(resolve => {\r\n      switch (type) {\r\n        case 'required':\r\n          resolve({\r\n            message: this.showMessage ? message || AXTranslator.get('validation.messages.required') : '',\r\n            result: !this._isNullOrEmpty(value),\r\n          });\r\n          break;\r\n        case 'regex':\r\n          const ex = new RegExp(ruleValue);\r\n          resolve({\r\n            message: this.showMessage ? message || AXTranslator.get('validation.messages.regex') : '',\r\n            result: ex.test(value),\r\n          });\r\n          break;\r\n        case 'callback':\r\n          if (typeof ruleValue === 'function') {\r\n            const res: any = {};\r\n            res.message = this.showMessage ? message : null;\r\n            const val = ruleValue({ value, message });\r\n            if (val instanceof Promise) {\r\n              val\r\n                .then(c => {\r\n                  res.result = c;\r\n                })\r\n                .catch(c => {\r\n                  res.result = false;\r\n                })\r\n                .finally(() => {\r\n                  resolve(res);\r\n                });\r\n            } else {\r\n              res.result = val;\r\n              resolve(res);\r\n            }\r\n          } else {\r\n            resolve({\r\n              message: AXTranslator.get('validation.messages.invalid-rull-fn'),\r\n              result: false,\r\n            });\r\n          }\r\n          break;\r\n        default:\r\n          resolve({\r\n            message: AXTranslator.get('validation.messages.invalid-rull-name'),\r\n            result: false,\r\n          });\r\n      }\r\n    });\r\n  }\r\n\r\n  private _isNullOrEmpty(value: any): boolean {\r\n    return (\r\n      value === undefined ||\r\n      value === null ||\r\n      Number.isNaN(value) ||\r\n      //(typeof value === 'object' && Object.keys(value).length === 0) ||\r\n      (Array.isArray(value) && value.length == 0) ||\r\n      (typeof value === 'string' && value.trim().length === 0)\r\n    );\r\n  }\r\n}\r\n"]}

package/esm2022/form/src/validation-summary.component.mjs

@@ -0,0 +1,110 @@
+import { AXTranslator } from "@acorex/core/translation";
+import { ChangeDetectionStrategy, Component, Inject, Input, Optional, ViewEncapsulation } from "@angular/core";
+import { AXFormComponent } from "./form.component";
+import { AXBaseComponentMixin } from "@acorex/components/mixin";
+import * as i0 from "@angular/core";
+import * as i1 from "@acorex/components/toast";
+import * as i2 from "@angular/common";
+import * as i3 from "@acorex/components/decorators";
+import * as i4 from "@acorex/components/alert";
+import * as i5 from "@acorex/components/button";
+import * as i6 from "./form.component";
+class AXValidationSummaryComponent extends AXBaseComponentMixin {
+    _tosatService;
+    _parent;
+    _content = '';
+    _title = AXTranslator.get('validation.messages.title');
+    get title() {
+        return this._title;
+    }
+    set title(v) {
+        this._title = v;
+    }
+    displayMode = 'toast';
+    timeOut;
+    autoHide = false;
+    _timeOut;
+    constructor(_elementRef, _cdr, _tosatService, _parent) {
+        super(_elementRef, _cdr);
+        this._tosatService = _tosatService;
+        this._parent = _parent;
+        //
+        _parent.onValidate.subscribe((c) => {
+            if (!c.result.result) {
+                this._content = `<ul>${c.result.items.map(c => `<li>${c.message}</li>`).join('')}</ul>`;
+                this._timeOut = this.autoHide ? (this.timeOut ?? Math.max(c.result.items.length * 1500, 2000)) : 0;
+                //
+                if (this.displayMode == 'toast') {
+                    this._tosatService.show({
+                        color: 'danger',
+                        closeable: true,
+                        timeOut: this._timeOut,
+                        content: this._content,
+                        title: this.title
+                    });
+                }
+            }
+            else {
+                this._content = '';
+            }
+            _cdr.markForCheck();
+        });
+    }
+    _handleOnDismissed(e) {
+        this._content = '';
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: AXValidationSummaryComponent, deps: [{ token: i0.ElementRef }, { token: i0.ChangeDetectorRef }, { token: i1.AXToastService }, { token: AXFormComponent, optional: true }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: AXValidationSummaryComponent, selector: "ax-validation-summary", inputs: { title: "title", displayMode: "displayMode", timeOut: "timeOut", autoHide: "autoHide" }, usesInheritance: true, ngImport: i0, template: `
+      <ax-alert color="danger" *ngIf="displayMode=='alert' && _content" [timeOut]="_timeOut" #a (onClosed)="_handleOnDismissed($event)">
+          <ax-icon></ax-icon>
+          <ax-title>{{title}}</ax-title>
+        <ax-content>
+          <div [innerHTML]="_content">
+          </div>
+        </ax-content>
+        <ax-footer>
+        <ax-suffix>
+          <ax-button text="Dismiss" (onClick)="a.close()"></ax-button>
+        </ax-suffix>
+        </ax-footer>
+      </ax-alert>
+  `, isInline: true, dependencies: [{ kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i3.AXDecoratorSuffixComponent, selector: "ax-suffix" }, { kind: "component", type: i3.AXDecoratorContentComponent, selector: "ax-content" }, { kind: "component", type: i3.AXDecoratorFooterComponent, selector: "ax-footer" }, { kind: "component", type: i3.AXDecoratorIconComponent, selector: "ax-icon", inputs: ["icon"] }, { kind: "component", type: i3.AXDecoratorTitleComponent, selector: "ax-title" }, { kind: "component", type: i4.AXAlertComponent, selector: "ax-alert", inputs: ["color", "timeOut", "visible"], outputs: ["onClosed"] }, { kind: "component", type: i5.AXButtonComponent, selector: "ax-button", inputs: ["disabled", "size", "tabIndex", "color", "look", "text", "toggleable", "selected", "type"], outputs: ["onBlur", "onFocus", "onClick", "selectedChange", "toggleableChange", "lookChange", "colorChange"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });
+}
+export { AXValidationSummaryComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: AXValidationSummaryComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ax-validation-summary',
+                    template: `
+      <ax-alert color="danger" *ngIf="displayMode=='alert' && _content" [timeOut]="_timeOut" #a (onClosed)="_handleOnDismissed($event)">
+          <ax-icon></ax-icon>
+          <ax-title>{{title}}</ax-title>
+        <ax-content>
+          <div [innerHTML]="_content">
+          </div>
+        </ax-content>
+        <ax-footer>
+        <ax-suffix>
+          <ax-button text="Dismiss" (onClick)="a.close()"></ax-button>
+        </ax-suffix>
+        </ax-footer>
+      </ax-alert>
+  `,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    encapsulation: ViewEncapsulation.None
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.ChangeDetectorRef }, { type: i1.AXToastService }, { type: i6.AXFormComponent, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [AXFormComponent]
+                }] }]; }, propDecorators: { title: [{
+                type: Input
+            }], displayMode: [{
+                type: Input
+            }], timeOut: [{
+                type: Input
+            }], autoHide: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/form/src/validation.class.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmFsaWRhdGlvbi5jbGFzcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2Fjb3JleC9jb21wb25lbnRzL2Zvcm0vc3JjL3ZhbGlkYXRpb24uY2xhc3MudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB0eXBlIEFYVmFsaWRhdGlvblJ1bGVUeXBlcyA9XHJcbiAgfCAncmVxdWlyZWQnXHJcbiAgfCAncmVnZXgnXHJcbiAgfCAnY2FsbGJhY2snXHJcbiAgfCAnY3VzdG9tJztcclxuXHJcbmV4cG9ydCBpbnRlcmZhY2UgQVhWYWxpZGF0aW9uUnVsZSB7XHJcbiAgbWVzc2FnZT86IHN0cmluZztcclxuICBydWxlOiBBWFZhbGlkYXRpb25SdWxlVHlwZXM7XHJcbiAgdmFsdWU/OiBhbnk7XHJcbiAgZW5hYmxlZD86IGJvb2xlYW47XHJcbn1cclxuXHJcbmV4cG9ydCBpbnRlcmZhY2UgQVhWYWxpZGF0aW9uUnVsZVJlc3VsdCB7XHJcbiAgbWVzc2FnZT86IHN0cmluZztcclxuICBuYW1lPzogc3RyaW5nO1xyXG4gIHJlc3VsdDogYm9vbGVhbjtcclxuICB2YWx1ZT86IGFueTtcclxuICBpZD86IHN0cmluZztcclxufVxyXG5cclxuZXhwb3J0IGludGVyZmFjZSBBWEZvcm1WYWxpZGF0aW9uUmVzdWx0IHtcclxuICByZXN1bHQ6IGJvb2xlYW47XHJcbiAgaXRlbXM/OiBBWFZhbGlkYXRpb25SdWxlUmVzdWx0W107XHJcbn1cclxuIl19

package/esm2022/image/acorex-components-image.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWNvcmV4LWNvbXBvbmVudHMtaW1hZ2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hY29yZXgvY29tcG9uZW50cy9pbWFnZS9hY29yZXgtY29tcG9uZW50cy1pbWFnZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3B1YmxpYy1hcGknO1xuIl19

package/esm2022/image/public-api.mjs

@@ -0,0 +1,3 @@
+export * from './src/image.component';
+export * from './src/image.module';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2Fjb3JleC9jb21wb25lbnRzL2ltYWdlL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx1QkFBdUIsQ0FBQTtBQUNyQyxjQUFjLG9CQUFvQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9zcmMvaW1hZ2UuY29tcG9uZW50J1xyXG5leHBvcnQgKiBmcm9tICcuL3NyYy9pbWFnZS5tb2R1bGUnOyJdfQ==

package/esm2022/image/src/image.component.mjs

@@ -0,0 +1,80 @@
+import { AXBaseComponent } from '@acorex/components/mixin';
+import { ChangeDetectionStrategy, Component, EventEmitter, HostBinding, Input, Output, ViewEncapsulation, } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+class AXImageComponent extends AXBaseComponent {
+    cdr;
+    /**
+    *  @ignore
+    */
+    constructor(elementRef, cdr) {
+        super(elementRef, cdr);
+        this.cdr = cdr;
+    }
+    src;
+    alt;
+    priority = 'auto';
+    lazy = false;
+    onLoad = new EventEmitter();
+    onError = new EventEmitter();
+    _hasError = false;
+    _isLoaded = false;
+    _isLoading = false;
+    onInit() {
+        this._isLoading = this.src != null;
+    }
+    _handleLoadImage(e) {
+        this._isLoaded = true;
+        this._hasError = false;
+        this._isLoading = false;
+        this.onLoad.emit({
+            component: this,
+            htmlElement: this._getHostElement(),
+            isUserInteraction: false,
+            nativeEvent: e
+        });
+    }
+    _handleErrorImage(e) {
+        this._hasError = true;
+        this._isLoaded = false;
+        this._isLoading = false;
+        this.onError.emit({
+            component: this,
+            htmlElement: this._getHostElement(),
+            isUserInteraction: false,
+            nativeEvent: e
+        });
+    }
+    get __stateError() {
+        return this._hasError || !this.src;
+    }
+    get __stateLoading() {
+        return this._isLoading;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: AXImageComponent, deps: [{ token: i0.ElementRef }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: AXImageComponent, selector: "ax-image", inputs: { src: "src", alt: "alt", priority: "priority", lazy: "lazy" }, outputs: { onLoad: "onLoad", onError: "onError" }, host: { properties: { "class.ax-state-empty": "this.__stateError", "class.ax-state-loading": "this.__stateLoading" } }, providers: [{ provide: 'ax-image', useValue: AXImageComponent }], usesInheritance: true, ngImport: i0, template: "<img\r\n  *ngIf=\"src\"\r\n  class=\"ax-state-hidden\"\r\n  [class.ax-state-loaded]=\"_isLoaded\"\r\n  [src]=\"src\"\r\n  [alt]=\"alt\"\r\n  [attr.fetchpriority]=\"priority\"\r\n  [attr.loading]=\"lazy ? 'lazy' : 'eager'\"\r\n  (load)=\"_handleLoadImage($event)\"\r\n  (error)=\"_handleErrorImage($event)\" />\r\n<ng-content select=\"ax-overlay\"></ng-content>\r\n<ng-container *ngIf=\"!src || _hasError\">\r\n  <ng-content select=\"ax-placeholder\"></ng-content>\r\n</ng-container>\r\n<ng-container *ngIf=\"_isLoading\">\r\n  <ng-content select=\"ax-loading\"></ng-content>\r\n</ng-container>\r\n", styles: ["ax-image{display:block;position:relative;transition-property:all;transition-timing-function:cubic-bezier(.4,0,.2,1);transition-duration:.15s;overflow:hidden}ax-image:not(.ax-state-empty,.ax-state-loading):hover ax-overlay[data-overlay-mode=hover]{display:flex;animation:1s both ax-fadeIn;animation-duration:.5s}@keyframes ax-fadeIn{0%{opacity:0}}ax-image img{width:100%;height:100%}ax-image img.ax-state-hidden{display:none}ax-image img.ax-state-loaded{display:block!important}ax-image ax-overlay{position:absolute;width:100%;height:100%;top:0;display:flex;align-items:center;justify-content:center;background-color:#0009}ax-image ax-overlay[data-overlay-mode=hover]{display:none}ax-image ax-loading{background-color:var(--ax-color-surface);width:100%;height:100%;display:flex;align-items:center;justify-content:center}\n"], dependencies: [{ kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });
+}
+export { AXImageComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: AXImageComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'ax-image', encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, providers: [{ provide: 'ax-image', useValue: AXImageComponent }], template: "<img\r\n  *ngIf=\"src\"\r\n  class=\"ax-state-hidden\"\r\n  [class.ax-state-loaded]=\"_isLoaded\"\r\n  [src]=\"src\"\r\n  [alt]=\"alt\"\r\n  [attr.fetchpriority]=\"priority\"\r\n  [attr.loading]=\"lazy ? 'lazy' : 'eager'\"\r\n  (load)=\"_handleLoadImage($event)\"\r\n  (error)=\"_handleErrorImage($event)\" />\r\n<ng-content select=\"ax-overlay\"></ng-content>\r\n<ng-container *ngIf=\"!src || _hasError\">\r\n  <ng-content select=\"ax-placeholder\"></ng-content>\r\n</ng-container>\r\n<ng-container *ngIf=\"_isLoading\">\r\n  <ng-content select=\"ax-loading\"></ng-content>\r\n</ng-container>\r\n", styles: ["ax-image{display:block;position:relative;transition-property:all;transition-timing-function:cubic-bezier(.4,0,.2,1);transition-duration:.15s;overflow:hidden}ax-image:not(.ax-state-empty,.ax-state-loading):hover ax-overlay[data-overlay-mode=hover]{display:flex;animation:1s both ax-fadeIn;animation-duration:.5s}@keyframes ax-fadeIn{0%{opacity:0}}ax-image img{width:100%;height:100%}ax-image img.ax-state-hidden{display:none}ax-image img.ax-state-loaded{display:block!important}ax-image ax-overlay{position:absolute;width:100%;height:100%;top:0;display:flex;align-items:center;justify-content:center;background-color:#0009}ax-image ax-overlay[data-overlay-mode=hover]{display:none}ax-image ax-loading{background-color:var(--ax-color-surface);width:100%;height:100%;display:flex;align-items:center;justify-content:center}\n"] }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.ChangeDetectorRef }]; }, propDecorators: { src: [{
+                type: Input
+            }], alt: [{
+                type: Input
+            }], priority: [{
+                type: Input
+            }], lazy: [{
+                type: Input
+            }], onLoad: [{
+                type: Output
+            }], onError: [{
+                type: Output
+            }], __stateError: [{
+                type: HostBinding,
+                args: ['class.ax-state-empty']
+            }], __stateLoading: [{
+                type: HostBinding,
+                args: ['class.ax-state-loading']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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