@acorex/components 6.5.70 → 6.5.90

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

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

@@ -0,0 +1,218 @@
+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/*'],
+        },
+    ];
+    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.0", 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.0", 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", 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", "type", "showMask", "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.0", 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":["../../../../../../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 {\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' = '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/esm2022/lib/upload-file/upload-file.events.mjs

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

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.0", ngImport: i0, type: AXUploadFileModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.2.0", 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.0", ngImport: i0, type: AXUploadFileModule, imports: [CommonModule, AXButtonModule, AXTextBoxModule, AXProgressBarModule, AXLabelModule, AXFormGroupModule] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.0", 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.0", 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.0", 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.0", 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.0", ngImport: i0, type: AXValidationRuleComponent, deps: [{ token: ElementRef, optional: true }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.0", 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.0", 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';\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/esm2022/lib/validation/validation.class.mjs

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

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.0", ngImport: i0, type: AXValidation, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.0", ngImport: i0, type: AXValidation });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.0", 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.0", ngImport: i0, type: AXValidationComponent, deps: [{ token: ElementRef, optional: true }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.0", 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.0", 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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