@acorex/components 6.5.28 → 6.5.30

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

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)\" />\n\n<ng-container *ngIf=\"type == 'inline'; else elseTemplate\">\n  <ax-form-group size=\"{{size}}\">\n    <ax-text-box [value]=\"fileName\" readonly=\"true\" [disabled]=\"disabled\"></ax-text-box>\n    <ax-button type=\"blank light\" icon=\"far fa-times\" (click)=\"remove()\" *ngIf=\"fileName\" [tabIndex]=\"-1\">\n    </ax-button>\n    <ax-button type=\"primary blank\" icon=\"far fa-upload\" (click)=\"open()\" [disabled]=\"disabled\" [tabIndex]=\"-1\">\n    </ax-button>\n  </ax-form-group>\n</ng-container>\n\n<ng-template #elseTemplate>\n  <div class=\"ax upload-file-box\" (click)=\"open()\" #dropRef>\n  </div>\n</ng-template>\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)\" />\n\n<ng-container *ngIf=\"type == 'inline'; else elseTemplate\">\n  <ax-form-group size=\"{{size}}\">\n    <ax-text-box [value]=\"fileName\" readonly=\"true\" [disabled]=\"disabled\"></ax-text-box>\n    <ax-button type=\"blank light\" icon=\"far fa-times\" (click)=\"remove()\" *ngIf=\"fileName\" [tabIndex]=\"-1\">\n    </ax-button>\n    <ax-button type=\"primary blank\" icon=\"far fa-upload\" (click)=\"open()\" [disabled]=\"disabled\" [tabIndex]=\"-1\">\n    </ax-button>\n  </ax-form-group>\n</ng-container>\n\n<ng-template #elseTemplate>\n  <div class=\"ax upload-file-box\" (click)=\"open()\" #dropRef>\n  </div>\n</ng-template>\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 {\n  Component,\n  ViewChild,\n  Input,\n  ElementRef,\n  ViewEncapsulation,\n  TemplateRef,\n  Renderer2,\n  EventEmitter,\n  Output,\n  ChangeDetectorRef\n} from '@angular/core';\nimport { AXUploadFileLoadEvent, AXUploadFileProgressEvent } from './upload-file.events';\nimport { AXProgressBarComponent } from '../progress-bar/progress-bar.component';\nimport { AXBaseTextComponent, AXElementSize, AXBaseSizableComponent, AXBaseComponent } from '../base/element.class';\nimport { AXRenderService } from '@acorex/core';\n\n@Component({\n  selector: 'ax-upload-file',\n  templateUrl: './upload-file.component.html',\n  encapsulation: ViewEncapsulation.None,\n  host: { style: 'display: block; width:100%; position: relative' }\n})\nexport class AXUploadFileComponent extends AXBaseComponent implements AXBaseSizableComponent {\n  private overlayDiv: HTMLElement;\n\n  @Input()\n  contentType: 'image' | 'excel' | 'audio' | 'video' | 'video/image' = 'image';\n\n  @Input()\n  dropRef: HTMLElement;\n\n  @Input()\n  progressRef: HTMLElement;\n\n  @Input()\n  label: string;\n\n  @Input()\n  size: AXElementSize = \"md\";\n\n  @ViewChild('fileInput') fileInput: ElementRef;\n\n  @Input()\n  type: 'box' | 'inline' | 'hidden' = 'inline';\n\n  @Input()\n  public template: TemplateRef<any>;\n\n  @Input() disabled: boolean = false;\n  @Output()\n  onLoad: EventEmitter<AXUploadFileLoadEvent> = new EventEmitter<AXUploadFileLoadEvent>();\n\n  @Output()\n  onProgress: EventEmitter<AXUploadFileProgressEvent> = new EventEmitter<AXUploadFileProgressEvent>();\n\n  @Output()\n  onRemove: EventEmitter<any> = new EventEmitter();\n\n  fileTypes:any[] = [\n    {\n      type: 'image',\n      accept: ['image/gif', 'image/jpeg', 'image/png'],\n    },\n    {\n      type: 'audio',\n      accept: ['audio/mp3'],\n    },\n    {\n      type: 'ebook',\n      accept: ['application/pdf'],\n    },\n    {\n      type: 'excel',\n      accept: ['application/vnd.ms-excel', 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'],\n    },\n    {\n      type: 'video',\n      accept: ['video/*'],\n    },\n    {\n      type: 'video/image',\n      accept: ['image/gif', 'image/jpeg', 'image/png', 'video/*'],\n    },\n  ];\n\n\n  files: File[] = [];\n  focus() { }\n\n  fileName: string = '';\n  constructor(\n    private el: ElementRef<HTMLElement>,\n    private injectionService: AXRenderService,\n    private rendrer: Renderer2,\n    protected cdr: ChangeDetectorRef\n  ) {\n    super();\n  }\n\n\n  onDeleteClick(e) {\n    e.stopPropagation();\n  }\n\n  onFileChange(e) {\n    const files = e.target.files;\n    this.addFile(files[0]);\n    (this.fileInput.nativeElement as HTMLInputElement).value = null;\n  }\n\n  open() {\n    this.fileInput.nativeElement.click({accept:this.accessTypes});\n  }\n  remove() {\n    this.fileInput.nativeElement.value = ''\n    this.files = [];\n    this.fileName = null\n    this.onRemove.emit()\n  }\n  ngAfterViewInit(): void {\n    if (this.dropRef != null) {\n    } else {\n      this.dropRef = this.el.nativeElement;\n    }\n    //\n    if (this.progressRef != null) {\n    } else {\n      this.progressRef = this.el.nativeElement;\n    }\n    //\n    if (this.type === 'hidden' || this.type === 'box') {\n      this.overlayDiv = this.rendrer.createElement('div') as HTMLElement;\n      this.overlayDiv.classList.add('overlay');\n      this.overlayDiv.innerHTML = `\n      <div class=\"icon-wrapper\">\n        <i class=\"far fa-cloud-upload-alt fa-3x\"></i>\n        <span>Drop File(s) Here</span>\n      </div>\n    `;\n      this.overlayDiv.addEventListener('drag', this.handleOverlayDragOver);\n      this.overlayDiv.addEventListener('dragover', this.handleOverlayDragOver);\n      this.overlayDiv.addEventListener('dragleave', this.handleOverlayDragOver);\n      this.rendrer.appendChild(this.dropRef, this.overlayDiv);\n    }\n    //\n    this.dropRef.classList.add('ax-upload-drop-over');\n    this.dropRef.addEventListener('dragover', this.handleDragOver.bind(this));\n    this.dropRef.addEventListener('dragleave', this.handleDragLeave.bind(this));\n    this.dropRef.addEventListener('drop', this.handleDrop.bind(this));\n  }\n\n  private handleOverlayDragOver(e: DragEvent) {\n    e.preventDefault();\n    e.stopPropagation();\n    return false;\n  }\n\n  private handleDragOver(e: DragEvent) {\n    e.preventDefault();\n    e.stopPropagation();\n    this.overlayDiv.classList.add('show');\n    return false;\n  }\n\n  private handleDragLeave(e: DragEvent) {\n    e.preventDefault();\n    e.stopPropagation();\n    this.overlayDiv.classList.remove('show');\n    return false;\n  }\n\n  handleDrop(e: DragEvent) {\n    this.handleDragLeave(e);\n    for (let i = 0; i < e.dataTransfer.files.length; i++) {\n      const file = e.dataTransfer.files[i];\n      this.addFile(file);\n    }\n  }\n\n  private addFile(file: File) {\n    const progressDiv = this.rendrer.createElement('div') as HTMLElement;\n    progressDiv.classList.add('ax-upload-progress-panel');\n    const progressLabel = this.rendrer.createElement('small') as HTMLElement;\n    progressLabel.innerText = file.name;\n    this.fileName = file.name;\n    this.rendrer.appendChild(this.progressRef, progressDiv);\n    const com = this.injectionService.appendComponent(AXProgressBarComponent, { progress: 0 }, progressDiv).instance as AXProgressBarComponent;\n    this.rendrer.appendChild(progressDiv, progressLabel);\n\n    const reader = new FileReader();\n    reader.addEventListener('load', (e) => {\n      this.onLoad.emit({\n        file,\n        data: (e as any).target.result\n      });\n      //\n      // Fake Upload\n      let pv = 0;\n      let uploaded = 0;\n      const intv = setInterval(() => {\n        uploaded += 1024 * 1000;\n        if (uploaded > e.total) {\n          uploaded = e.total;\n        }\n        pv = Math.ceil((uploaded / e.total) * 100);\n        com.progress = pv;\n        this.onProgress.emit({\n          file,\n          total: e.total,\n          uploaded,\n          value: pv\n        });\n        //\n        if (com.progress >= 100) {\n          clearInterval(intv);\n          setTimeout(() => {\n            this.rendrer.removeChild(this.progressRef, progressDiv);\n          }, 1000);\n        }\n      }, 100);\n    });\n    reader.readAsDataURL(file);\n    this.files.push(file);\n  }\n\n  get accessTypes(): string[] {\n    return this.fileTypes.find((item) => item.type == this.contentType).accept;\n  }\n}\n","<input #fileInput type=\"file\" [accept]=\"accessTypes.join(',')\" style=\"display: none;\" (change)=\"onFileChange($event)\" />\n\n<ng-container *ngIf=\"type == 'inline'; else elseTemplate\">\n  <ax-form-group size=\"{{size}}\">\n    <ax-text-box [value]=\"fileName\" readonly=\"true\" [disabled]=\"disabled\"></ax-text-box>\n    <ax-button type=\"blank light\" icon=\"far fa-times\" (click)=\"remove()\" *ngIf=\"fileName\" [tabIndex]=\"-1\">\n    </ax-button>\n    <ax-button type=\"primary blank\" icon=\"far fa-upload\" (click)=\"open()\" [disabled]=\"disabled\" [tabIndex]=\"-1\">\n    </ax-button>\n  </ax-form-group>\n</ng-container>\n\n<ng-template #elseTemplate>\n  <div class=\"ax upload-file-box\" (click)=\"open()\" #dropRef>\n  </div>\n</ng-template>\n"]}

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

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

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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmFsaWRhdGlvbi1mb3JtLmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2Fjb3JleC9jb21wb25lbnRzL3NyYy9saWIvdmFsaWRhdGlvbi92YWxpZGF0aW9uLWZvcm0uY29tcG9uZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFDTCxTQUFTLEVBRVQsU0FBUyxFQUNULGVBQWUsRUFDZixLQUFLLEVBQ0wsTUFBTSxFQUNOLFlBQVksRUFDWixVQUFVLEVBQ1YsaUJBQWlCLEVBQ2xCLE1BQU0sZUFBZSxDQUFDO0FBRXZCLE9BQU8sRUFBRSxzQkFBc0IsRUFBRSxNQUFNLHVCQUF1QixDQUFDOztBQU0vRCxNQUFNLE9BQU8seUJBQXlCO0lBRXBDLFlBQW9CLEdBQWUsRUFBVSxHQUFzQjtRQUEvQyxRQUFHLEdBQUgsR0FBRyxDQUFZO1FBQVUsUUFBRyxHQUFILEdBQUcsQ0FBbUI7UUFHM0QsWUFBTyxHQUE2QixFQUFFLENBQUM7UUFPL0MsZUFBVSxHQUFpQyxRQUFRLENBQUM7UUFHcEQsV0FBTSxHQUE4QixJQUFJLFlBQVksRUFBZSxDQUFDO0lBYkcsQ0FBQztJQWdCeEUsZUFBZTtRQUNiLElBQUksQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDO1lBQ2YsU0FBUyxFQUFFLElBQUk7WUFDZixXQUFXLEVBQUUsSUFBSSxDQUFDLEdBQUcsQ0FBQyxhQUFhO1NBQ3BDLENBQUMsQ0FBQztJQUNMLENBQUM7SUFFRCxRQUFRO1FBQ04sSUFBSSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsR0FBRyxJQUFJLENBQUMsWUFBWSxDQUFDLE9BQU8sRUFBRSxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxRQUFRLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDO1FBQ3pGLEVBQUU7UUFDRixJQUFJLENBQUMsT0FBTyxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsRUFBRTtZQUN2QixJQUFJLENBQUMsQ0FBQyxVQUFVLElBQUksQ0FBQyxDQUFDLFVBQVUsQ0FBQyxVQUFVLElBQUksSUFBSSxFQUFFO2dCQUNuRCxDQUFDLENBQUMsVUFBVSxDQUFDLFVBQVUsR0FBRyxJQUFJLENBQUMsVUFBVSxDQUFDO2FBQzNDO1FBQ0gsQ0FBQyxDQUFDLENBQUM7UUFFSCxPQUFPLElBQUksT0FBTyxDQUFxQixPQUFPLENBQUMsRUFBRTtZQUMvQyxJQUFJLENBQUMsSUFBSSxDQUFDLE9BQU8sSUFBSSxJQUFJLENBQUMsT0FBTyxDQUFDLE1BQU0sS0FBSyxDQUFDLEVBQUU7Z0JBQzlDLE9BQU8sT0FBTyxDQUFDLE9BQU8sQ0FBQyxFQUFFLE1BQU0sRUFBRSxJQUFJLEVBQUUsQ0FBQyxDQUFDO2FBQzFDO1lBQ0QsT0FBTyxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsRUFBRSxFQUFFLENBQUMsQ0FBQyxDQUFDLFFBQVEsRUFBRSxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsQ0FBQyxLQUFVLEVBQUUsRUFBRTtnQkFDckUsTUFBTSxNQUFNLEdBQUcsS0FBSyxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQU0sRUFBRSxFQUFFLENBQUMsQ0FBQyxDQUFDLENBQUMsTUFBTSxDQUFDLENBQUM7Z0JBQ25ELElBQUksTUFBTSxDQUFDLE1BQU0sRUFBRTtvQkFDakIsT0FBTyxDQUFDO3dCQUNOLE1BQU0sRUFBRSxLQUFLO3dCQUNiLEtBQUssRUFBRSxNQUFNO3FCQUNkLENBQUMsQ0FBQztpQkFDSjtxQkFDSTtvQkFDSCxPQUFPLENBQUMsRUFBRSxNQUFNLEVBQUUsSUFBSSxFQUFFLENBQUMsQ0FBQztpQkFDM0I7WUFDSCxDQUFDLENBQUMsQ0FBQztRQUNMLENBQUMsQ0FBQyxDQUFDO0lBQ0wsQ0FBQztJQUdELFNBQVMsQ0FBQyxNQUE4QjtRQUN0QyxJQUFHLE1BQU07WUFDUCxJQUFJLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsQ0FBQztJQUM5QixDQUFDOzt1SEF6RFUseUJBQXlCOzJHQUF6Qix5QkFBeUIsNEpBUW5CLHNCQUFzQixnREFWN0IsMkJBQTJCOzRGQUUxQix5QkFBeUI7a0JBSnJDLFNBQVM7bUJBQUM7b0JBQ1QsUUFBUSxFQUFFLG9CQUFvQjtvQkFDOUIsUUFBUSxFQUFFLDJCQUEyQjtpQkFDdEM7aUlBVVMsWUFBWTtzQkFEbkIsZUFBZTt1QkFBQyxzQkFBc0IsRUFBRSxFQUFFLFdBQVcsRUFBRSxJQUFJLEVBQUU7Z0JBSTlELFVBQVU7c0JBRFQsS0FBSztnQkFJTixNQUFNO3NCQURMLE1BQU0iLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge1xuICBDb21wb25lbnQsXG4gIE9uSW5pdCxcbiAgUXVlcnlMaXN0LFxuICBDb250ZW50Q2hpbGRyZW4sXG4gIElucHV0LFxuICBPdXRwdXQsXG4gIEV2ZW50RW1pdHRlcixcbiAgRWxlbWVudFJlZixcbiAgQ2hhbmdlRGV0ZWN0b3JSZWZcbn0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBBWFZhbGlkYXRpb25SZXN1bHQgfSBmcm9tICcuL3ZhbGlkYXRpb24uY2xhc3MnO1xuaW1wb3J0IHsgQVhWYWxpZGF0YWJsZUNvbXBvbmVudCB9IGZyb20gJy4uL2Jhc2UvZWxlbWVudC5jbGFzcyc7XG5pbXBvcnQgeyBBWEJhc2VFdmVudCB9IGZyb20gJy4uL2Jhc2UvZXZlbnRzLmNsYXNzJztcbkBDb21wb25lbnQoe1xuICBzZWxlY3RvcjogJ2F4LXZhbGlkYXRpb24tZm9ybScsXG4gIHRlbXBsYXRlOiAnPG5nLWNvbnRlbnQ+PC9uZy1jb250ZW50Pidcbn0pXG5leHBvcnQgY2xhc3MgQVhWYWxpZGF0aW9uRm9ybUNvbXBvbmVudCB7XG5cbiAgY29uc3RydWN0b3IocHJpdmF0ZSByZWY6IEVsZW1lbnRSZWYsIHByaXZhdGUgY2RyOiBDaGFuZ2VEZXRlY3RvclJlZikgeyB9XG5cblxuICBwcml2YXRlIHdpZGdldHM6IEFYVmFsaWRhdGFibGVDb21wb25lbnRbXSA9IFtdO1xuXG5cbiAgQENvbnRlbnRDaGlsZHJlbihBWFZhbGlkYXRhYmxlQ29tcG9uZW50LCB7IGRlc2NlbmRhbnRzOiB0cnVlIH0pXG4gIHByaXZhdGUgd2lkZ2V0c1F1ZXJ5OiBRdWVyeUxpc3Q8QVhWYWxpZGF0YWJsZUNvbXBvbmVudD47XG5cbiAgQElucHV0KClcbiAgdmFsaWRhdGVPbjogJ2JsdXInIHwgJ2NoYW5nZScgfCAnc3VibWl0JyA9ICdzdWJtaXQnO1xuXG4gIEBPdXRwdXQoKVxuICBvbkluaXQ6IEV2ZW50RW1pdHRlcjxBWEJhc2VFdmVudD4gPSBuZXcgRXZlbnRFbWl0dGVyPEFYQmFzZUV2ZW50PigpO1xuXG5cbiAgbmdBZnRlclZpZXdJbml0KCkge1xuICAgIHRoaXMub25Jbml0LmVtaXQoe1xuICAgICAgY29tcG9uZW50OiB0aGlzLFxuICAgICAgaHRtbEVsZW1lbnQ6IHRoaXMucmVmLm5hdGl2ZUVsZW1lbnRcbiAgICB9KTtcbiAgfVxuXG4gIHZhbGlkYXRlKCk6IFByb21pc2U8QVhWYWxpZGF0aW9uUmVzdWx0PiB7XG4gICAgdGhpcy53aWRnZXRzLnB1c2goLi4udGhpcy53aWRnZXRzUXVlcnkudG9BcnJheSgpLmZpbHRlcihjID0+ICF0aGlzLndpZGdldHMuaW5jbHVkZXMoYykpKTtcbiAgICAvL1xuICAgIHRoaXMud2lkZ2V0cy5mb3JFYWNoKHcgPT4ge1xuICAgICAgaWYgKHcudmFsaWRhdGlvbiAmJiB3LnZhbGlkYXRpb24udmFsaWRhdGVPbiA9PSBudWxsKSB7XG4gICAgICAgIHcudmFsaWRhdGlvbi52YWxpZGF0ZU9uID0gdGhpcy52YWxpZGF0ZU9uO1xuICAgICAgfVxuICAgIH0pO1xuXG4gICAgcmV0dXJuIG5ldyBQcm9taXNlPEFYVmFsaWRhdGlvblJlc3VsdD4ocmVzb2x2ZSA9PiB7XG4gICAgICBpZiAoIXRoaXMud2lkZ2V0cyB8fCB0aGlzLndpZGdldHMubGVuZ3RoID09PSAwKSB7XG4gICAgICAgIHJldHVybiBQcm9taXNlLnJlc29sdmUoeyByZXN1bHQ6IHRydWUgfSk7XG4gICAgICB9XG4gICAgICBQcm9taXNlLmFsbCh0aGlzLndpZGdldHMubWFwKChjKSA9PiBjLnZhbGlkYXRlKCkpKS50aGVuKChydWxlczogYW55KSA9PiB7XG4gICAgICAgIGNvbnN0IGZhaWxlZCA9IHJ1bGVzLmZpbHRlcigoYzogYW55KSA9PiAhYy5yZXN1bHQpO1xuICAgICAgICBpZiAoZmFpbGVkLmxlbmd0aCkge1xuICAgICAgICAgIHJlc29sdmUoe1xuICAgICAgICAgICAgcmVzdWx0OiBmYWxzZSxcbiAgICAgICAgICAgIGl0ZW1zOiBmYWlsZWRcbiAgICAgICAgICB9KTtcbiAgICAgICAgfVxuICAgICAgICBlbHNlIHtcbiAgICAgICAgICByZXNvbHZlKHsgcmVzdWx0OiB0cnVlIH0pO1xuICAgICAgICB9XG4gICAgICB9KTtcbiAgICB9KTtcbiAgfVxuXG5cbiAgYWRkV2lkZ2V0KHdpZGdldDogQVhWYWxpZGF0YWJsZUNvbXBvbmVudCkge1xuICAgIGlmKHdpZGdldClcbiAgICAgIHRoaXMud2lkZ2V0cy5wdXNoKHdpZGdldCk7XG4gIH1cblxufVxuIl19

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":"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","sourcesContent":["import { Component, ElementRef, Inject, inject, Input, Optional } from '@angular/core';\nimport { AXValidationRuleResult, AXValidationRule, AXValidationRuleTypes } from './validation.class';\nimport { AXTranslator } from '@acorex/core';\n\n\n// @dynamic\nexport class AXValidationRules {\n  private static registredRules: { name: string, rule: AXValidationRule }[] = [];\n\n  public static addRule(name: string, rule: AXValidationRule) {\n    const exists = AXValidationRules.get(name);\n    if (exists) {\n      exists.rule = rule;\n    }\n    else {\n      AXValidationRules.registredRules.push({\n        name,\n        rule\n      });\n    }\n  }\n\n  public static get(name: string) {\n    return this.registredRules.find(c => c.name === name);\n  }\n}\n\n\n@Component({\n  selector: 'ax-validation-rule',\n  template: ''\n})\nexport class AXValidationRuleComponent implements AXValidationRule {\n  @Input()\n  type: AXValidationRuleTypes = 'required';\n  @Input()\n  message: string;\n  @Input()\n  value: any;\n\n  @Input()\n  enabled: boolean = true;\n\n\n  constructor(\n    @Inject(ElementRef)\n    @Optional()\n    private ref?: ElementRef) {\n    if (ref)\n      ref.nativeElement[\"__axContext__\"] = this;\n  }\n\n  validate(value: any): Promise<AXValidationRuleResult> {\n    if (this.enabled === false) {\n      return Promise.resolve({ result: true });\n    }\n    const regRule = AXValidationRules.get(this.type);\n    if (regRule) {\n      return this.internalValidate(regRule.rule.type, value, this.message || regRule.rule.message, regRule.rule.value);\n    }\n    else {\n      return this.internalValidate(this.type, value, this.message, this.value);\n    }\n  }\n\n\n  private internalValidate(type: string, value?: any, message?: string, ruleValue?: any): Promise<AXValidationRuleResult> {\n    return new Promise<AXValidationRuleResult>(resolve => {\n      switch (type) {\n        case 'required':\n          resolve({\n            message: message || AXTranslator.get('validation.messages.required'),\n            result: value != null && value != '' && (!Array.isArray(value) || (Array.isArray(value) && value.length > 0))\n          });\n          break;\n        case 'regex':\n          const ex = new RegExp(ruleValue);\n          resolve({\n            message: message || AXTranslator.get('validation.messages.regex'),\n            result: ex.test(value)\n          });\n          break;\n        case 'custom':\n        case 'callback':\n          if (typeof ruleValue === 'function') {\n            const res: any = {};\n            res.message = message;\n            const val = ruleValue({ value, message });\n            if (val instanceof Promise) {\n              val.then(c => {\n                res.result = c;\n              }).catch(c => {\n                res.result = false;\n              }).finally(() => {\n                resolve(res);\n              });\n            }\n            else {\n              res.result = val;\n              resolve(res);\n            }\n          }\n          else {\n            resolve({ result: true });\n          }\n          break;\n        default:\n          resolve({ result: true });\n      }\n    });\n  }\n}\n"]}

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

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

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