@acorex/components 6.5.79 → 6.5.91

package/esm2020/lib/tree-view/tree-view.module.mjs

@@ -0,0 +1,22 @@
+import { NgModule } from '@angular/core';
+import { AXTreeViewComponent } from './tree-view.component';
+import { CommonModule } from '@angular/common';
+import { AXDataSourceModule } from '../data-source/datasource.module';
+import { AXCheckBoxModule } from '../checkbox/checkbox.module';
+import { AXContextMenuModule } from '../context-menu/context-menu.module';
+import * as i0 from "@angular/core";
+export class AXTreeViewModule {
+}
+AXTreeViewModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXTreeViewModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+AXTreeViewModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXTreeViewModule, declarations: [AXTreeViewComponent], imports: [AXDataSourceModule, CommonModule, AXCheckBoxModule, AXContextMenuModule], exports: [AXTreeViewComponent] });
+AXTreeViewModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXTreeViewModule, providers: [], imports: [[AXDataSourceModule, CommonModule, AXCheckBoxModule, AXContextMenuModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXTreeViewModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [AXTreeViewComponent],
+                    imports: [AXDataSourceModule, CommonModule, AXCheckBoxModule, AXContextMenuModule],
+                    exports: [AXTreeViewComponent],
+                    providers: []
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/upload-file/upload-file.component.mjs

@@ -0,0 +1,208 @@
+import { Component, ViewChild, Input, ElementRef, ViewEncapsulation, TemplateRef, Renderer2, EventEmitter, Output, ChangeDetectorRef } from '@angular/core';
+import { AXProgressBarComponent } from '../progress-bar/progress-bar.component';
+import { AXBaseComponent } from '../base/element.class';
+import { AXRenderService } from '@acorex/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@acorex/core";
+import * as i2 from "../form-group/form-group.component";
+import * as i3 from "../textbox/textbox.component";
+import * as i4 from "../button/button.component";
+import * as i5 from "@angular/common";
+export class AXUploadFileComponent extends AXBaseComponent {
+    constructor(el, injectionService, rendrer, cdr) {
+        super();
+        this.el = el;
+        this.injectionService = injectionService;
+        this.rendrer = rendrer;
+        this.cdr = cdr;
+        this.contentType = 'image';
+        this.size = "md";
+        this.type = 'inline';
+        this.disabled = false;
+        this.onLoad = new EventEmitter();
+        this.onProgress = new EventEmitter();
+        this.onRemove = new EventEmitter();
+        this.fileTypes = [
+            {
+                type: 'image',
+                accept: ['image/gif', 'image/jpeg', 'image/png'],
+            },
+            {
+                type: 'audio',
+                accept: ['audio/mp3'],
+            },
+            {
+                type: 'ebook',
+                accept: ['application/pdf'],
+            },
+            {
+                type: 'excel',
+                accept: ['application/vnd.ms-excel', 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'],
+            },
+            {
+                type: 'video',
+                accept: ['video/*'],
+            },
+            {
+                type: 'video/image',
+                accept: ['image/gif', 'image/jpeg', 'image/png', 'video/*'],
+            },
+        ];
+        this.files = [];
+        this.fileName = '';
+    }
+    focus() { }
+    onDeleteClick(e) {
+        e.stopPropagation();
+    }
+    onFileChange(e) {
+        const files = e.target.files;
+        this.addFile(files[0]);
+        this.fileInput.nativeElement.value = null;
+    }
+    open() {
+        this.fileInput.nativeElement.click({ accept: this.accessTypes });
+    }
+    remove() {
+        this.fileInput.nativeElement.value = '';
+        this.files = [];
+        this.fileName = null;
+        this.onRemove.emit();
+    }
+    ngAfterViewInit() {
+        if (this.dropRef != null) {
+        }
+        else {
+            this.dropRef = this.el.nativeElement;
+        }
+        //
+        if (this.progressRef != null) {
+        }
+        else {
+            this.progressRef = this.el.nativeElement;
+        }
+        //
+        if (this.type === 'hidden' || this.type === 'box') {
+            this.overlayDiv = this.rendrer.createElement('div');
+            this.overlayDiv.classList.add('overlay');
+            this.overlayDiv.innerHTML = `
+      <div class="icon-wrapper">
+        <i class="far fa-cloud-upload-alt fa-3x"></i>
+        <span>Drop File(s) Here</span>
+      </div>
+    `;
+            this.overlayDiv.addEventListener('drag', this.handleOverlayDragOver);
+            this.overlayDiv.addEventListener('dragover', this.handleOverlayDragOver);
+            this.overlayDiv.addEventListener('dragleave', this.handleOverlayDragOver);
+            this.rendrer.appendChild(this.dropRef, this.overlayDiv);
+        }
+        //
+        this.dropRef.classList.add('ax-upload-drop-over');
+        this.dropRef.addEventListener('dragover', this.handleDragOver.bind(this));
+        this.dropRef.addEventListener('dragleave', this.handleDragLeave.bind(this));
+        this.dropRef.addEventListener('drop', this.handleDrop.bind(this));
+    }
+    handleOverlayDragOver(e) {
+        e.preventDefault();
+        e.stopPropagation();
+        return false;
+    }
+    handleDragOver(e) {
+        e.preventDefault();
+        e.stopPropagation();
+        this.overlayDiv.classList.add('show');
+        return false;
+    }
+    handleDragLeave(e) {
+        e.preventDefault();
+        e.stopPropagation();
+        this.overlayDiv.classList.remove('show');
+        return false;
+    }
+    handleDrop(e) {
+        this.handleDragLeave(e);
+        for (let i = 0; i < e.dataTransfer.files.length; i++) {
+            const file = e.dataTransfer.files[i];
+            this.addFile(file);
+        }
+    }
+    addFile(file) {
+        const progressDiv = this.rendrer.createElement('div');
+        progressDiv.classList.add('ax-upload-progress-panel');
+        const progressLabel = this.rendrer.createElement('small');
+        progressLabel.innerText = file.name;
+        this.fileName = file.name;
+        this.rendrer.appendChild(this.progressRef, progressDiv);
+        const com = this.injectionService.appendComponent(AXProgressBarComponent, { progress: 0 }, progressDiv).instance;
+        this.rendrer.appendChild(progressDiv, progressLabel);
+        const reader = new FileReader();
+        reader.addEventListener('load', (e) => {
+            this.onLoad.emit({
+                file,
+                data: e.target.result
+            });
+            //
+            // Fake Upload
+            let pv = 0;
+            let uploaded = 0;
+            const intv = setInterval(() => {
+                uploaded += 1024 * 1000;
+                if (uploaded > e.total) {
+                    uploaded = e.total;
+                }
+                pv = Math.ceil((uploaded / e.total) * 100);
+                com.progress = pv;
+                this.onProgress.emit({
+                    file,
+                    total: e.total,
+                    uploaded,
+                    value: pv
+                });
+                //
+                if (com.progress >= 100) {
+                    clearInterval(intv);
+                    setTimeout(() => {
+                        this.rendrer.removeChild(this.progressRef, progressDiv);
+                    }, 1000);
+                }
+            }, 100);
+        });
+        reader.readAsDataURL(file);
+        this.files.push(file);
+    }
+    get accessTypes() {
+        return this.fileTypes.find((item) => item.type == this.contentType).accept;
+    }
+}
+AXUploadFileComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXUploadFileComponent, deps: [{ token: i0.ElementRef }, { token: i1.AXRenderService }, { token: i0.Renderer2 }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+AXUploadFileComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.11", type: AXUploadFileComponent, selector: "ax-upload-file", inputs: { contentType: "contentType", dropRef: "dropRef", progressRef: "progressRef", label: "label", size: "size", type: "type", template: "template", disabled: "disabled" }, outputs: { onLoad: "onLoad", onProgress: "onProgress", onRemove: "onRemove" }, host: { styleAttribute: "display: block; width:100%; position: relative" }, viewQueries: [{ propertyName: "fileInput", first: true, predicate: ["fileInput"], descendants: true }], usesInheritance: true, ngImport: i0, template: "<input #fileInput type=\"file\" [accept]=\"accessTypes.join(',')\" style=\"display: none;\" (change)=\"onFileChange($event)\" />\r\n\r\n<ng-container *ngIf=\"type == 'inline'; else elseTemplate\">\r\n  <ax-form-group size=\"{{size}}\">\r\n    <ax-text-box [value]=\"fileName\" readonly=\"true\" [disabled]=\"disabled\"></ax-text-box>\r\n    <ax-button type=\"blank light\" icon=\"far fa-times\" (click)=\"remove()\" *ngIf=\"fileName\" [tabIndex]=\"-1\">\r\n    </ax-button>\r\n    <ax-button type=\"primary blank\" icon=\"far fa-upload\" (click)=\"open()\" [disabled]=\"disabled\" [tabIndex]=\"-1\">\r\n    </ax-button>\r\n  </ax-form-group>\r\n</ng-container>\r\n\r\n<ng-template #elseTemplate>\r\n  <div class=\"ax upload-file-box\" (click)=\"open()\" #dropRef>\r\n  </div>\r\n</ng-template>\r\n", components: [{ type: i2.AXFormGroupComponent, selector: "ax-form-group", inputs: ["size"] }, { type: i3.AXTextBoxComponent, selector: "ax-text-box", inputs: ["mask", "type", "showMask", "maxLength", "maskGuid", "maskPlaceholder", "maskKeepCharPositions"] }, { type: i4.AXButtonComponent, selector: "ax-button", inputs: ["type", "icon", "submitBehavior", "cancelBehavior", "block", "loading", "selected"] }], directives: [{ type: i5.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXUploadFileComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'ax-upload-file', encapsulation: ViewEncapsulation.None, host: { style: 'display: block; width:100%; position: relative' }, template: "<input #fileInput type=\"file\" [accept]=\"accessTypes.join(',')\" style=\"display: none;\" (change)=\"onFileChange($event)\" />\r\n\r\n<ng-container *ngIf=\"type == 'inline'; else elseTemplate\">\r\n  <ax-form-group size=\"{{size}}\">\r\n    <ax-text-box [value]=\"fileName\" readonly=\"true\" [disabled]=\"disabled\"></ax-text-box>\r\n    <ax-button type=\"blank light\" icon=\"far fa-times\" (click)=\"remove()\" *ngIf=\"fileName\" [tabIndex]=\"-1\">\r\n    </ax-button>\r\n    <ax-button type=\"primary blank\" icon=\"far fa-upload\" (click)=\"open()\" [disabled]=\"disabled\" [tabIndex]=\"-1\">\r\n    </ax-button>\r\n  </ax-form-group>\r\n</ng-container>\r\n\r\n<ng-template #elseTemplate>\r\n  <div class=\"ax upload-file-box\" (click)=\"open()\" #dropRef>\r\n  </div>\r\n</ng-template>\r\n" }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.AXRenderService }, { type: i0.Renderer2 }, { type: i0.ChangeDetectorRef }]; }, propDecorators: { contentType: [{
+                type: Input
+            }], dropRef: [{
+                type: Input
+            }], progressRef: [{
+                type: Input
+            }], label: [{
+                type: Input
+            }], size: [{
+                type: Input
+            }], fileInput: [{
+                type: ViewChild,
+                args: ['fileInput']
+            }], type: [{
+                type: Input
+            }], template: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], onLoad: [{
+                type: Output
+            }], onProgress: [{
+                type: Output
+            }], onRemove: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"upload-file.component.js","sourceRoot":"","sources":["../../../../../../projects/acorex/components/src/lib/upload-file/upload-file.component.ts","../../../../../../projects/acorex/components/src/lib/upload-file/upload-file.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  Component,\r\n  ViewChild,\r\n  Input,\r\n  ElementRef,\r\n  ViewEncapsulation,\r\n  TemplateRef,\r\n  Renderer2,\r\n  EventEmitter,\r\n  Output,\r\n  ChangeDetectorRef\r\n} from '@angular/core';\r\nimport { AXUploadFileLoadEvent, AXUploadFileProgressEvent } from './upload-file.events';\r\nimport { AXProgressBarComponent } from '../progress-bar/progress-bar.component';\r\nimport { AXBaseTextComponent, AXElementSize, AXBaseSizableComponent, AXBaseComponent } from '../base/element.class';\r\nimport { AXRenderService } from '@acorex/core';\r\n\r\n@Component({\r\n  selector: 'ax-upload-file',\r\n  templateUrl: './upload-file.component.html',\r\n  encapsulation: ViewEncapsulation.None,\r\n  host: { style: 'display: block; width:100%; position: relative' }\r\n})\r\nexport class AXUploadFileComponent extends AXBaseComponent implements AXBaseSizableComponent {\r\n  private overlayDiv: HTMLElement;\r\n\r\n  @Input()\r\n  contentType: 'image' | 'excel' | 'audio' | 'video' | 'video/image' | 'pdf' = 'image';\r\n\r\n  @Input()\r\n  dropRef: HTMLElement;\r\n\r\n  @Input()\r\n  progressRef: HTMLElement;\r\n\r\n  @Input()\r\n  label: string;\r\n\r\n  @Input()\r\n  size: AXElementSize = \"md\";\r\n\r\n  @ViewChild('fileInput') fileInput: ElementRef;\r\n\r\n  @Input()\r\n  type: 'box' | 'inline' | 'hidden' = 'inline';\r\n\r\n  @Input()\r\n  public template: TemplateRef<any>;\r\n\r\n  @Input() disabled: boolean = false;\r\n  @Output()\r\n  onLoad: EventEmitter<AXUploadFileLoadEvent> = new EventEmitter<AXUploadFileLoadEvent>();\r\n\r\n  @Output()\r\n  onProgress: EventEmitter<AXUploadFileProgressEvent> = new EventEmitter<AXUploadFileProgressEvent>();\r\n\r\n  @Output()\r\n  onRemove: EventEmitter<any> = new EventEmitter();\r\n\r\n  fileTypes: any[] = [\r\n    {\r\n      type: 'image',\r\n      accept: ['image/gif', 'image/jpeg', 'image/png'],\r\n    },\r\n    {\r\n      type: 'audio',\r\n      accept: ['audio/mp3'],\r\n    },\r\n    {\r\n      type: 'ebook',\r\n      accept: ['application/pdf'],\r\n    },\r\n    {\r\n      type: 'excel',\r\n      accept: ['application/vnd.ms-excel', 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'],\r\n    },\r\n    {\r\n      type: 'video',\r\n      accept: ['video/*'],\r\n    },\r\n    {\r\n      type: 'video/image',\r\n      accept: ['image/gif', 'image/jpeg', 'image/png', 'video/*'],\r\n    },\r\n  ];\r\n\r\n\r\n  files: File[] = [];\r\n  focus() { }\r\n\r\n  fileName: string = '';\r\n  constructor(\r\n    private el: ElementRef<HTMLElement>,\r\n    private injectionService: AXRenderService,\r\n    private rendrer: Renderer2,\r\n    protected cdr: ChangeDetectorRef\r\n  ) {\r\n    super();\r\n  }\r\n\r\n\r\n  onDeleteClick(e) {\r\n    e.stopPropagation();\r\n  }\r\n\r\n  onFileChange(e) {\r\n    const files = e.target.files;\r\n    this.addFile(files[0]);\r\n    (this.fileInput.nativeElement as HTMLInputElement).value = null;\r\n  }\r\n\r\n  open() {\r\n    this.fileInput.nativeElement.click({ accept: this.accessTypes });\r\n  }\r\n  remove() {\r\n    this.fileInput.nativeElement.value = ''\r\n    this.files = [];\r\n    this.fileName = null\r\n    this.onRemove.emit()\r\n  }\r\n  ngAfterViewInit(): void {\r\n    if (this.dropRef != null) {\r\n    } else {\r\n      this.dropRef = this.el.nativeElement;\r\n    }\r\n    //\r\n    if (this.progressRef != null) {\r\n    } else {\r\n      this.progressRef = this.el.nativeElement;\r\n    }\r\n    //\r\n    if (this.type === 'hidden' || this.type === 'box') {\r\n      this.overlayDiv = this.rendrer.createElement('div') as HTMLElement;\r\n      this.overlayDiv.classList.add('overlay');\r\n      this.overlayDiv.innerHTML = `\r\n      <div class=\"icon-wrapper\">\r\n        <i class=\"far fa-cloud-upload-alt fa-3x\"></i>\r\n        <span>Drop File(s) Here</span>\r\n      </div>\r\n    `;\r\n      this.overlayDiv.addEventListener('drag', this.handleOverlayDragOver);\r\n      this.overlayDiv.addEventListener('dragover', this.handleOverlayDragOver);\r\n      this.overlayDiv.addEventListener('dragleave', this.handleOverlayDragOver);\r\n      this.rendrer.appendChild(this.dropRef, this.overlayDiv);\r\n    }\r\n    //\r\n    this.dropRef.classList.add('ax-upload-drop-over');\r\n    this.dropRef.addEventListener('dragover', this.handleDragOver.bind(this));\r\n    this.dropRef.addEventListener('dragleave', this.handleDragLeave.bind(this));\r\n    this.dropRef.addEventListener('drop', this.handleDrop.bind(this));\r\n  }\r\n\r\n  private handleOverlayDragOver(e: DragEvent) {\r\n    e.preventDefault();\r\n    e.stopPropagation();\r\n    return false;\r\n  }\r\n\r\n  private handleDragOver(e: DragEvent) {\r\n    e.preventDefault();\r\n    e.stopPropagation();\r\n    this.overlayDiv.classList.add('show');\r\n    return false;\r\n  }\r\n\r\n  private handleDragLeave(e: DragEvent) {\r\n    e.preventDefault();\r\n    e.stopPropagation();\r\n    this.overlayDiv.classList.remove('show');\r\n    return false;\r\n  }\r\n\r\n  handleDrop(e: DragEvent) {\r\n    this.handleDragLeave(e);\r\n    for (let i = 0; i < e.dataTransfer.files.length; i++) {\r\n      const file = e.dataTransfer.files[i];\r\n      this.addFile(file);\r\n    }\r\n  }\r\n\r\n  private addFile(file: File) {\r\n    const progressDiv = this.rendrer.createElement('div') as HTMLElement;\r\n    progressDiv.classList.add('ax-upload-progress-panel');\r\n    const progressLabel = this.rendrer.createElement('small') as HTMLElement;\r\n    progressLabel.innerText = file.name;\r\n    this.fileName = file.name;\r\n    this.rendrer.appendChild(this.progressRef, progressDiv);\r\n    const com = this.injectionService.appendComponent(AXProgressBarComponent, { progress: 0 }, progressDiv).instance as AXProgressBarComponent;\r\n    this.rendrer.appendChild(progressDiv, progressLabel);\r\n\r\n    const reader = new FileReader();\r\n    reader.addEventListener('load', (e) => {\r\n      this.onLoad.emit({\r\n        file,\r\n        data: (e as any).target.result\r\n      });\r\n      //\r\n      // Fake Upload\r\n      let pv = 0;\r\n      let uploaded = 0;\r\n      const intv = setInterval(() => {\r\n        uploaded += 1024 * 1000;\r\n        if (uploaded > e.total) {\r\n          uploaded = e.total;\r\n        }\r\n        pv = Math.ceil((uploaded / e.total) * 100);\r\n        com.progress = pv;\r\n        this.onProgress.emit({\r\n          file,\r\n          total: e.total,\r\n          uploaded,\r\n          value: pv\r\n        });\r\n        //\r\n        if (com.progress >= 100) {\r\n          clearInterval(intv);\r\n          setTimeout(() => {\r\n            this.rendrer.removeChild(this.progressRef, progressDiv);\r\n          }, 1000);\r\n        }\r\n      }, 100);\r\n    });\r\n    reader.readAsDataURL(file);\r\n    this.files.push(file);\r\n  }\r\n\r\n  get accessTypes(): string[] {\r\n    return this.fileTypes.find((item) => item.type == this.contentType).accept;\r\n  }\r\n}\r\n","<input #fileInput type=\"file\" [accept]=\"accessTypes.join(',')\" style=\"display: none;\" (change)=\"onFileChange($event)\" />\r\n\r\n<ng-container *ngIf=\"type == 'inline'; else elseTemplate\">\r\n  <ax-form-group size=\"{{size}}\">\r\n    <ax-text-box [value]=\"fileName\" readonly=\"true\" [disabled]=\"disabled\"></ax-text-box>\r\n    <ax-button type=\"blank light\" icon=\"far fa-times\" (click)=\"remove()\" *ngIf=\"fileName\" [tabIndex]=\"-1\">\r\n    </ax-button>\r\n    <ax-button type=\"primary blank\" icon=\"far fa-upload\" (click)=\"open()\" [disabled]=\"disabled\" [tabIndex]=\"-1\">\r\n    </ax-button>\r\n  </ax-form-group>\r\n</ng-container>\r\n\r\n<ng-template #elseTemplate>\r\n  <div class=\"ax upload-file-box\" (click)=\"open()\" #dropRef>\r\n  </div>\r\n</ng-template>\r\n"]}

package/esm2020/lib/upload-file/upload-file.events.mjs

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

package/esm2020/lib/upload-file/upload-file.module.mjs

@@ -0,0 +1,24 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { AXUploadFileComponent } from './upload-file.component';
+import { AXButtonModule } from '../button/button.module';
+import { AXTextBoxModule } from '../textbox/textbox.module';
+import { AXProgressBarModule } from '../progress-bar/progress-bar.module';
+import { AXLabelModule } from '../label/label.module';
+import { AXFormGroupModule } from '../form-group/form-group.module';
+import * as i0 from "@angular/core";
+export class AXUploadFileModule {
+}
+AXUploadFileModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXUploadFileModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+AXUploadFileModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXUploadFileModule, declarations: [AXUploadFileComponent], imports: [CommonModule, AXButtonModule, AXTextBoxModule, AXProgressBarModule, AXLabelModule, AXFormGroupModule], exports: [AXUploadFileComponent] });
+AXUploadFileModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXUploadFileModule, providers: [], imports: [[CommonModule, AXButtonModule, AXTextBoxModule, AXProgressBarModule, AXLabelModule, AXFormGroupModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXUploadFileModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [AXUploadFileComponent],
+                    imports: [CommonModule, AXButtonModule, AXTextBoxModule, AXProgressBarModule, AXLabelModule, AXFormGroupModule],
+                    exports: [AXUploadFileComponent],
+                    providers: []
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/validation/validation-form.component.mjs

@@ -0,0 +1,65 @@
+import { Component, QueryList, ContentChildren, Input, Output, EventEmitter, ElementRef, ChangeDetectorRef } from '@angular/core';
+import { AXValidatableComponent } from '../base/element.class';
+import * as i0 from "@angular/core";
+export class AXValidationFormComponent {
+    constructor(ref, cdr) {
+        this.ref = ref;
+        this.cdr = cdr;
+        this.widgets = [];
+        this.validateOn = 'submit';
+        this.onInit = new EventEmitter();
+    }
+    ngAfterViewInit() {
+        this.onInit.emit({
+            component: this,
+            htmlElement: this.ref.nativeElement
+        });
+    }
+    validate() {
+        this.widgets.push(...this.widgetsQuery.toArray().filter(c => !this.widgets.includes(c)));
+        //
+        this.widgets.forEach(w => {
+            if (w.validation && w.validation.validateOn == null) {
+                w.validation.validateOn = this.validateOn;
+            }
+        });
+        return new Promise(resolve => {
+            if (!this.widgets || this.widgets.length === 0) {
+                return Promise.resolve({ result: true });
+            }
+            Promise.all(this.widgets.map((c) => c.validate())).then((rules) => {
+                const failed = rules.filter((c) => !c.result);
+                if (failed.length) {
+                    resolve({
+                        result: false,
+                        items: failed
+                    });
+                }
+                else {
+                    resolve({ result: true });
+                }
+            });
+        });
+    }
+    addWidget(widget) {
+        if (widget)
+            this.widgets.push(widget);
+    }
+}
+AXValidationFormComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXValidationFormComponent, deps: [{ token: i0.ElementRef }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+AXValidationFormComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.11", type: AXValidationFormComponent, selector: "ax-validation-form", inputs: { validateOn: "validateOn" }, outputs: { onInit: "onInit" }, queries: [{ propertyName: "widgetsQuery", predicate: AXValidatableComponent, descendants: true }], ngImport: i0, template: '<ng-content></ng-content>', isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXValidationFormComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ax-validation-form',
+                    template: '<ng-content></ng-content>'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.ChangeDetectorRef }]; }, propDecorators: { widgetsQuery: [{
+                type: ContentChildren,
+                args: [AXValidatableComponent, { descendants: true }]
+            }], validateOn: [{
+                type: Input
+            }], onInit: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/validation/validation-rule.widget.mjs

@@ -0,0 +1,111 @@
+import { Component, ElementRef, Inject, Input, Optional } from '@angular/core';
+import { AXTranslator } from '@acorex/core';
+import * as i0 from "@angular/core";
+// @dynamic
+export class AXValidationRules {
+    static addRule(name, rule) {
+        const exists = AXValidationRules.get(name);
+        if (exists) {
+            exists.rule = rule;
+        }
+        else {
+            AXValidationRules.registredRules.push({
+                name,
+                rule
+            });
+        }
+    }
+    static get(name) {
+        return this.registredRules.find(c => c.name === name);
+    }
+}
+AXValidationRules.registredRules = [];
+export class AXValidationRuleComponent {
+    constructor(ref) {
+        this.ref = ref;
+        this.type = 'required';
+        this.enabled = true;
+        if (ref)
+            ref.nativeElement["__axContext__"] = this;
+    }
+    validate(value) {
+        if (this.enabled === false) {
+            return Promise.resolve({ result: true });
+        }
+        const regRule = AXValidationRules.get(this.type);
+        if (regRule) {
+            return this.internalValidate(regRule.rule.type, value, this.message || regRule.rule.message, regRule.rule.value);
+        }
+        else {
+            return this.internalValidate(this.type, value, this.message, this.value);
+        }
+    }
+    internalValidate(type, value, message, ruleValue) {
+        return new Promise(resolve => {
+            switch (type) {
+                case 'required':
+                    resolve({
+                        message: message || AXTranslator.get('validation.messages.required'),
+                        result: value != null && value != '' && (!Array.isArray(value) || (Array.isArray(value) && value.length > 0))
+                    });
+                    break;
+                case 'regex':
+                    const ex = new RegExp(ruleValue);
+                    resolve({
+                        message: message || AXTranslator.get('validation.messages.regex'),
+                        result: ex.test(value)
+                    });
+                    break;
+                case 'custom':
+                case 'callback':
+                    if (typeof ruleValue === 'function') {
+                        const res = {};
+                        res.message = message;
+                        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({ result: true });
+                    }
+                    break;
+                default:
+                    resolve({ result: true });
+            }
+        });
+    }
+}
+AXValidationRuleComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXValidationRuleComponent, deps: [{ token: ElementRef, optional: true }], target: i0.ɵɵFactoryTarget.Component });
+AXValidationRuleComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.11", type: AXValidationRuleComponent, selector: "ax-validation-rule", inputs: { type: "type", message: "message", value: "value", enabled: "enabled" }, ngImport: i0, template: '', isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXValidationRuleComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ax-validation-rule',
+                    template: ''
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef, decorators: [{
+                    type: Inject,
+                    args: [ElementRef]
+                }, {
+                    type: Optional
+                }] }]; }, propDecorators: { type: [{
+                type: Input
+            }], message: [{
+                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/src/lib/validation/validation-rule.widget.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,EAAU,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAEvF,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;;AAG5C,WAAW;AACX,MAAM,OAAO,iBAAiB;IAGrB,MAAM,CAAC,OAAO,CAAC,IAAY,EAAE,IAAsB;QACxD,MAAM,MAAM,GAAG,iBAAiB,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAC3C,IAAI,MAAM,EAAE;YACV,MAAM,CAAC,IAAI,GAAG,IAAI,CAAC;SACpB;aACI;YACH,iBAAiB,CAAC,cAAc,CAAC,IAAI,CAAC;gBACpC,IAAI;gBACJ,IAAI;aACL,CAAC,CAAC;SACJ;IACH,CAAC;IAEM,MAAM,CAAC,GAAG,CAAC,IAAY;QAC5B,OAAO,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC;IACxD,CAAC;;AAjBc,gCAAc,GAA+C,EAAE,CAAC;AAyBjF,MAAM,OAAO,yBAAyB;IAYpC,YAGU,GAAgB;QAAhB,QAAG,GAAH,GAAG,CAAa;QAb1B,SAAI,GAA0B,UAAU,CAAC;QAOzC,YAAO,GAAY,IAAI,CAAC;QAOtB,IAAI,GAAG;YACL,GAAG,CAAC,aAAa,CAAC,eAAe,CAAC,GAAG,IAAI,CAAC;IAC9C,CAAC;IAED,QAAQ,CAAC,KAAU;QACjB,IAAI,IAAI,CAAC,OAAO,KAAK,KAAK,EAAE;YAC1B,OAAO,OAAO,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC;SAC1C;QACD,MAAM,OAAO,GAAG,iBAAiB,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACjD,IAAI,OAAO,EAAE;YACX,OAAO,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,EAAE,KAAK,EAAE,IAAI,CAAC,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;SAClH;aACI;YACH,OAAO,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,IAAI,EAAE,KAAK,EAAE,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;SAC1E;IACH,CAAC;IAGO,gBAAgB,CAAC,IAAY,EAAE,KAAW,EAAE,OAAgB,EAAE,SAAe;QACnF,OAAO,IAAI,OAAO,CAAyB,OAAO,CAAC,EAAE;YACnD,QAAQ,IAAI,EAAE;gBACZ,KAAK,UAAU;oBACb,OAAO,CAAC;wBACN,OAAO,EAAE,OAAO,IAAI,YAAY,CAAC,GAAG,CAAC,8BAA8B,CAAC;wBACpE,MAAM,EAAE,KAAK,IAAI,IAAI,IAAI,KAAK,IAAI,EAAE,IAAI,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;qBAC9G,CAAC,CAAC;oBACH,MAAM;gBACR,KAAK,OAAO;oBACV,MAAM,EAAE,GAAG,IAAI,MAAM,CAAC,SAAS,CAAC,CAAC;oBACjC,OAAO,CAAC;wBACN,OAAO,EAAE,OAAO,IAAI,YAAY,CAAC,GAAG,CAAC,2BAA2B,CAAC;wBACjE,MAAM,EAAE,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC;qBACvB,CAAC,CAAC;oBACH,MAAM;gBACR,KAAK,QAAQ,CAAC;gBACd,KAAK,UAAU;oBACb,IAAI,OAAO,SAAS,KAAK,UAAU,EAAE;wBACnC,MAAM,GAAG,GAAQ,EAAE,CAAC;wBACpB,GAAG,CAAC,OAAO,GAAG,OAAO,CAAC;wBACtB,MAAM,GAAG,GAAG,SAAS,CAAC,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC,CAAC;wBAC1C,IAAI,GAAG,YAAY,OAAO,EAAE;4BAC1B,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE;gCACX,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC;4BACjB,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE;gCACX,GAAG,CAAC,MAAM,GAAG,KAAK,CAAC;4BACrB,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,EAAE;gCACd,OAAO,CAAC,GAAG,CAAC,CAAC;4BACf,CAAC,CAAC,CAAC;yBACJ;6BACI;4BACH,GAAG,CAAC,MAAM,GAAG,GAAG,CAAC;4BACjB,OAAO,CAAC,GAAG,CAAC,CAAC;yBACd;qBACF;yBACI;wBACH,OAAO,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC;qBAC3B;oBACD,MAAM;gBACR;oBACE,OAAO,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC;aAC7B;QACH,CAAC,CAAC,CAAC;IACL,CAAC;;uHA9EU,yBAAyB,kBAa1B,UAAU;2GAbT,yBAAyB,4IAF1B,EAAE;4FAED,yBAAyB;kBAJrC,SAAS;mBAAC;oBACT,QAAQ,EAAE,oBAAoB;oBAC9B,QAAQ,EAAE,EAAE;iBACb;;0BAcI,MAAM;2BAAC,UAAU;;0BACjB,QAAQ;4CAZX,IAAI;sBADH,KAAK;gBAGN,OAAO;sBADN,KAAK;gBAGN,KAAK;sBADJ,KAAK;gBAIN,OAAO;sBADN,KAAK","sourcesContent":["import { Component, ElementRef, Inject, inject, Input, Optional } from '@angular/core';\r\nimport { AXValidationRuleResult, AXValidationRule, AXValidationRuleTypes } from './validation.class';\r\nimport { AXTranslator } from '@acorex/core';\r\n\r\n\r\n// @dynamic\r\nexport class AXValidationRules {\r\n  private static registredRules: { name: string, rule: AXValidationRule }[] = [];\r\n\r\n  public static addRule(name: string, rule: AXValidationRule) {\r\n    const exists = AXValidationRules.get(name);\r\n    if (exists) {\r\n      exists.rule = rule;\r\n    }\r\n    else {\r\n      AXValidationRules.registredRules.push({\r\n        name,\r\n        rule\r\n      });\r\n    }\r\n  }\r\n\r\n  public static get(name: string) {\r\n    return this.registredRules.find(c => c.name === name);\r\n  }\r\n}\r\n\r\n\r\n@Component({\r\n  selector: 'ax-validation-rule',\r\n  template: ''\r\n})\r\nexport class AXValidationRuleComponent implements AXValidationRule {\r\n  @Input()\r\n  type: AXValidationRuleTypes = 'required';\r\n  @Input()\r\n  message: string;\r\n  @Input()\r\n  value: any;\r\n\r\n  @Input()\r\n  enabled: boolean = true;\r\n\r\n\r\n  constructor(\r\n    @Inject(ElementRef)\r\n    @Optional()\r\n    private ref?: ElementRef) {\r\n    if (ref)\r\n      ref.nativeElement[\"__axContext__\"] = 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    const regRule = AXValidationRules.get(this.type);\r\n    if (regRule) {\r\n      return this.internalValidate(regRule.rule.type, value, this.message || regRule.rule.message, regRule.rule.value);\r\n    }\r\n    else {\r\n      return this.internalValidate(this.type, value, this.message, this.value);\r\n    }\r\n  }\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: message || AXTranslator.get('validation.messages.required'),\r\n            result: value != null && value != '' && (!Array.isArray(value) || (Array.isArray(value) && value.length > 0))\r\n          });\r\n          break;\r\n        case 'regex':\r\n          const ex = new RegExp(ruleValue);\r\n          resolve({\r\n            message: message || AXTranslator.get('validation.messages.regex'),\r\n            result: ex.test(value)\r\n          });\r\n          break;\r\n        case 'custom':\r\n        case 'callback':\r\n          if (typeof ruleValue === 'function') {\r\n            const res: any = {};\r\n            res.message = message;\r\n            const val = ruleValue({ value, message });\r\n            if (val instanceof Promise) {\r\n              val.then(c => {\r\n                res.result = c;\r\n              }).catch(c => {\r\n                res.result = false;\r\n              }).finally(() => {\r\n                resolve(res);\r\n              });\r\n            }\r\n            else {\r\n              res.result = val;\r\n              resolve(res);\r\n            }\r\n          }\r\n          else {\r\n            resolve({ result: true });\r\n          }\r\n          break;\r\n        default:\r\n          resolve({ result: true });\r\n      }\r\n    });\r\n  }\r\n}\r\n"]}

package/esm2020/lib/validation/validation.class.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmFsaWRhdGlvbi5jbGFzcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2Fjb3JleC9jb21wb25lbnRzL3NyYy9saWIvdmFsaWRhdGlvbi92YWxpZGF0aW9uLmNsYXNzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJcclxuZXhwb3J0IHR5cGUgQVhWYWxpZGF0aW9uUnVsZVR5cGVzID0gJ3JlcXVpcmVkJyB8ICdyZWdleCcgfCAnY2FsbGJhY2snIHwgJ2N1c3RvbSc7XHJcblxyXG5leHBvcnQgaW50ZXJmYWNlIEFYVmFsaWRhdGlvblJ1bGUge1xyXG4gIG1lc3NhZ2U/OiBzdHJpbmc7XHJcbiAgdHlwZTogQVhWYWxpZGF0aW9uUnVsZVR5cGVzO1xyXG4gIHZhbHVlPzogYW55O1xyXG4gIGVuYWJsZWQ/OiBib29sZWFuO1xyXG59XHJcblxyXG5leHBvcnQgaW50ZXJmYWNlIEFYVmFsaWRhdGlvblJ1bGVSZXN1bHQge1xyXG4gIG1lc3NhZ2U/OiBzdHJpbmc7XHJcbiAgcmVzdWx0OiBib29sZWFuO1xyXG4gIHRhcmdldD86IGFueTtcclxufVxyXG5cclxuZXhwb3J0IGludGVyZmFjZSBBWFZhbGlkYXRpb25SZXN1bHQge1xyXG4gIHJlc3VsdDogYm9vbGVhbjtcclxuICBpdGVtcz86IEFYVmFsaWRhdGlvblJ1bGVSZXN1bHRbXTtcclxufVxyXG5cclxuXHJcbiJdfQ==

package/esm2020/lib/validation/validation.component.mjs

@@ -0,0 +1,89 @@
+import { Component, Input, Output, EventEmitter, Injectable, ElementRef, Optional, Inject } from '@angular/core';
+import { AXValidationRuleComponent } from './validation-rule.widget';
+import * as i0 from "@angular/core";
+export class AXValidation {
+    constructor() {
+        this.validateOn = 'submit';
+    }
+    validate(value) {
+        if (!this.rules || this.rules.length === 0) {
+            return Promise.resolve({ result: true });
+        }
+        return new Promise(resolve => {
+            Promise.all(this.rules.map(c => {
+                if (c instanceof AXValidationRuleComponent) {
+                    return c.validate(value);
+                }
+                else {
+                    const v = new AXValidationRuleComponent();
+                    Object.assign(v, c);
+                    return v.validate(value);
+                }
+            })).then(d => {
+                const error = d.find(c => c.result === false);
+                if (error) {
+                    resolve(error);
+                }
+                else {
+                    resolve({ result: true });
+                }
+            });
+        });
+    }
+}
+AXValidation.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXValidation, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+AXValidation.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXValidation });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXValidation, decorators: [{
+            type: Injectable
+        }] });
+export class AXValidationComponent extends AXValidation {
+    constructor(ref) {
+        super();
+        this.ref = ref;
+        this.rulesChange = new EventEmitter();
+        this.showMessage = true;
+        this._rules = [];
+        this.validateOn = null;
+    }
+    _getComponenets() {
+        return Array.from(this.ref?.nativeElement.querySelectorAll('ax-validation-rule')).map(c => c["__axContext__"]);
+    }
+    get rules() {
+        return this._rules;
+    }
+    set rules(v) {
+        this._rules = v;
+        if (this.rulesChange) {
+            this.rulesChange.emit(v);
+        }
+    }
+    ngAfterContentInit() {
+        if (this.rules && this.rules.length === 0) {
+            this.rules.push(...this._getComponenets());
+        }
+    }
+}
+AXValidationComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXValidationComponent, deps: [{ token: ElementRef, optional: true }], target: i0.ɵɵFactoryTarget.Component });
+AXValidationComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.11", type: AXValidationComponent, selector: "ax-validation", inputs: { rules: "rules", validateOn: "validateOn" }, outputs: { rulesChange: "rulesChange", showMessage: "showMessage" }, providers: [{ provide: AXValidation, useExisting: AXValidationComponent }], usesInheritance: true, ngImport: i0, template: '<ng-content></ng-content>', isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXValidationComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ax-validation',
+                    template: '<ng-content></ng-content>',
+                    providers: [{ provide: AXValidation, useExisting: AXValidationComponent }]
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef, decorators: [{
+                    type: Inject,
+                    args: [ElementRef]
+                }, {
+                    type: Optional
+                }] }]; }, propDecorators: { rulesChange: [{
+                type: Output
+            }], showMessage: [{
+                type: Output
+            }], rules: [{
+                type: Input
+            }], validateOn: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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