@acorex/components 6.5.91 → 6.6.0

package/esm2022/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 {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AXTreeViewModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: AXTreeViewModule, declarations: [AXTreeViewComponent], imports: [AXDataSourceModule, CommonModule, AXCheckBoxModule, AXContextMenuModule], exports: [AXTreeViewComponent] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AXTreeViewModule, imports: [AXDataSourceModule, CommonModule, AXCheckBoxModule, AXContextMenuModule] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AXTreeViewModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [AXTreeViewComponent],
+                    imports: [AXDataSourceModule, CommonModule, AXCheckBoxModule, AXContextMenuModule],
+                    exports: [AXTreeViewComponent],
+                    providers: []
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJlZS12aWV3Lm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY29tcG9uZW50cy9zcmMvbGliL3RyZWUtdmlldy90cmVlLXZpZXcubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFDNUQsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQy9DLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLGtDQUFrQyxDQUFDO0FBQ3RFLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLDZCQUE2QixDQUFDO0FBQy9ELE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLHFDQUFxQyxDQUFDOztBQVUxRSxNQUFNLE9BQU8sZ0JBQWdCO3dHQUFoQixnQkFBZ0I7eUdBQWhCLGdCQUFnQixpQkFOVixtQkFBbUIsYUFDeEIsa0JBQWtCLEVBQUUsWUFBWSxFQUFFLGdCQUFnQixFQUFFLG1CQUFtQixhQUN2RSxtQkFBbUI7eUdBSXBCLGdCQUFnQixZQUxmLGtCQUFrQixFQUFFLFlBQVksRUFBRSxnQkFBZ0IsRUFBRSxtQkFBbUI7OzRGQUt4RSxnQkFBZ0I7a0JBUDVCLFFBQVE7bUJBQUM7b0JBQ04sWUFBWSxFQUFFLENBQUMsbUJBQW1CLENBQUM7b0JBQ25DLE9BQU8sRUFBRSxDQUFDLGtCQUFrQixFQUFFLFlBQVksRUFBRSxnQkFBZ0IsRUFBRSxtQkFBbUIsQ0FBQztvQkFDbEYsT0FBTyxFQUFFLENBQUMsbUJBQW1CLENBQUM7b0JBQzlCLFNBQVMsRUFBRSxFQUFFO2lCQUNoQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBBWFRyZWVWaWV3Q29tcG9uZW50IH0gZnJvbSAnLi90cmVlLXZpZXcuY29tcG9uZW50JztcbmltcG9ydCB7IENvbW1vbk1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbic7XG5pbXBvcnQgeyBBWERhdGFTb3VyY2VNb2R1bGUgfSBmcm9tICcuLi9kYXRhLXNvdXJjZS9kYXRhc291cmNlLm1vZHVsZSc7XG5pbXBvcnQgeyBBWENoZWNrQm94TW9kdWxlIH0gZnJvbSAnLi4vY2hlY2tib3gvY2hlY2tib3gubW9kdWxlJztcbmltcG9ydCB7IEFYQ29udGV4dE1lbnVNb2R1bGUgfSBmcm9tICcuLi9jb250ZXh0LW1lbnUvY29udGV4dC1tZW51Lm1vZHVsZSc7XG5cblxuQE5nTW9kdWxlKHtcbiAgICBkZWNsYXJhdGlvbnM6IFtBWFRyZWVWaWV3Q29tcG9uZW50XSxcbiAgICBpbXBvcnRzOiBbQVhEYXRhU291cmNlTW9kdWxlLCBDb21tb25Nb2R1bGUsIEFYQ2hlY2tCb3hNb2R1bGUsIEFYQ29udGV4dE1lbnVNb2R1bGVdLFxuICAgIGV4cG9ydHM6IFtBWFRyZWVWaWV3Q29tcG9uZW50XSxcbiAgICBwcm92aWRlcnM6IFtdXG59KVxuXG5leHBvcnQgY2xhc3MgQVhUcmVlVmlld01vZHVsZSB7IH0iXX0=

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

@@ -0,0 +1,226 @@
+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 "@angular/common";
+import * as i3 from "../button/button.component";
+import * as i4 from "../textbox/textbox.component";
+import * as i5 from "../form-group/form-group.component";
+export class AXUploadFileComponent extends AXBaseComponent {
+    el;
+    injectionService;
+    rendrer;
+    cdr;
+    overlayDiv;
+    contentType = 'image';
+    dropRef;
+    progressRef;
+    label;
+    size = "md";
+    fileInput;
+    type = 'inline';
+    template;
+    disabled = false;
+    onLoad = new EventEmitter();
+    onProgress = new EventEmitter();
+    onRemove = new EventEmitter();
+    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/*'],
+        },
+        {
+            type: 'json',
+            accept: ['application/json'],
+        },
+        {
+            type: 'any',
+            accept: ['*/*'],
+        },
+    ];
+    files = [];
+    focus() { }
+    fileName = '';
+    constructor(el, injectionService, rendrer, cdr) {
+        super();
+        this.el = el;
+        this.injectionService = injectionService;
+        this.rendrer = rendrer;
+        this.cdr = cdr;
+    }
+    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;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AXUploadFileComponent, deps: [{ token: i0.ElementRef }, { token: i1.AXRenderService }, { token: i0.Renderer2 }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", 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", dependencies: [{ kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i3.AXButtonComponent, selector: "ax-button", inputs: ["type", "icon", "submitBehavior", "cancelBehavior", "block", "loading", "selected"] }, { kind: "component", type: i4.AXTextBoxComponent, selector: "ax-text-box", inputs: ["mask", "showMask", "type", "maxLength", "maskGuid", "maskPlaceholder", "maskKeepCharPositions"] }, { kind: "component", type: i5.AXFormGroupComponent, selector: "ax-form-group", inputs: ["size"] }], encapsulation: i0.ViewEncapsulation.None });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", 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":["../../../../../../libs/components/src/lib/upload-file/upload-file.component.ts","../../../../../../libs/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' | 'any' | 'json' = '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      type: 'json',\n      accept: ['application/json'],\n    },\n    {\n      type: 'any',\n      accept: ['*/*'],\n    },\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/esm2022/lib/upload-file/upload-file.events.mjs

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

package/esm2022/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 {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AXUploadFileModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: AXUploadFileModule, declarations: [AXUploadFileComponent], imports: [CommonModule, AXButtonModule, AXTextBoxModule, AXProgressBarModule, AXLabelModule, AXFormGroupModule], exports: [AXUploadFileComponent] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AXUploadFileModule, imports: [CommonModule, AXButtonModule, AXTextBoxModule, AXProgressBarModule, AXLabelModule, AXFormGroupModule] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", 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/esm2022/lib/validation/validation-form.component.mjs

@@ -0,0 +1,68 @@
+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 {
+    ref;
+    cdr;
+    constructor(ref, cdr) {
+        this.ref = ref;
+        this.cdr = cdr;
+    }
+    widgets = [];
+    widgetsQuery;
+    validateOn = 'submit';
+    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);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AXValidationFormComponent, deps: [{ token: i0.ElementRef }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", 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: "16.2.12", 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/esm2022/lib/validation/validation-rule.widget.mjs

@@ -0,0 +1,114 @@
+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 registredRules = [];
+    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);
+    }
+}
+export class AXValidationRuleComponent {
+    ref;
+    type = 'required';
+    message;
+    value;
+    enabled = true;
+    constructor(ref) {
+        this.ref = ref;
+        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 });
+            }
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AXValidationRuleComponent, deps: [{ token: ElementRef, optional: true }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", 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: "16.2.12", 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":["../../../../../../libs/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/esm2022/lib/validation/validation.class.mjs

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

package/esm2022/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 {
+    validateOn = 'submit';
+    showMessage;
+    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 });
+                }
+            });
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AXValidation, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AXValidation });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AXValidation, decorators: [{
+            type: Injectable
+        }] });
+export class AXValidationComponent extends AXValidation {
+    ref;
+    _getComponenets() {
+        return Array.from(this.ref?.nativeElement.querySelectorAll('ax-validation-rule')).map(c => c["__axContext__"]);
+    }
+    constructor(ref) {
+        super();
+        this.ref = ref;
+    }
+    rulesChange = new EventEmitter();
+    showMessage = true;
+    _rules = [];
+    get rules() {
+        return this._rules;
+    }
+    set rules(v) {
+        this._rules = v;
+        if (this.rulesChange) {
+            this.rulesChange.emit(v);
+        }
+    }
+    validateOn = null;
+    ngAfterContentInit() {
+        if (this.rules && this.rules.length === 0) {
+            this.rules.push(...this._getComponenets());
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AXValidationComponent, deps: [{ token: ElementRef, optional: true }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", 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: "16.2.12", 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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