@rs-pk/asset-management 1.0.0

package/esm2015/lib/components/partial/upload-dialog/upload-dialog.component.js

@@ -0,0 +1,136 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { Component, Inject } from '@angular/core';
+import { MatDialogRef, MAT_DIALOG_DATA } from '@angular/material';
+import { takeUntil } from 'rxjs/operators';
+import { Subject } from 'rxjs';
+import { ChangeDetectorRef } from '@angular/core';
+import { UploadAssetsService } from '../../../services/upload-assets.service';
+/**
+ * @record
+ */
+function IData() { }
+if (false) {
+    /** @type {?} */
+    IData.prototype.currentAssetId;
+    /** @type {?|undefined} */
+    IData.prototype.fileType;
+}
+export class UploadDialogComponent {
+    /**
+     * @param {?} data
+     * @param {?} dialogRef
+     * @param {?} changeDetectorRef
+     * @param {?} uploadAssetsService
+     */
+    constructor(data, dialogRef, changeDetectorRef, uploadAssetsService) {
+        this.data = data;
+        this.dialogRef = dialogRef;
+        this.changeDetectorRef = changeDetectorRef;
+        this.uploadAssetsService = uploadAssetsService;
+        this.isLoading = false;
+        this.disabled = true;
+        this.destroy$ = new Subject();
+        if (this.data.fileType) {
+            this.uploadAssetsService.supportedTypes =
+                this.data.fileType === 'Image'
+                    ? [...this.uploadAssetsService.imageExtension]
+                    : [...this.uploadAssetsService.documentExtension];
+        }
+    }
+    /**
+     * @return {?}
+     */
+    ngOnInit() {
+        this.uploadAssetsService
+            .getErrorObs()
+            .pipe(takeUntil(this.destroy$))
+            .subscribe((/**
+         * @param {?} error
+         * @return {?}
+         */
+        error => {
+            this.disabled = error;
+            this.changeDetectorRef.detectChanges();
+        }));
+    }
+    /**
+     * @param {?} hasError
+     * @return {?}
+     */
+    onValidate(hasError) {
+        this.disabled = hasError;
+    }
+    /**
+     * @return {?}
+     */
+    uploadFiles() {
+        this.isLoading = true;
+        this.uploadAssetsService
+            .uploadMultipleAssests(this.data.currentAssetId)
+            .pipe(takeUntil(this.destroy$))
+            .subscribe((/**
+         * @param {?} res
+         * @return {?}
+         */
+        res => {
+            if (res) {
+                this.closeDialog(true);
+            }
+        }));
+    }
+    /**
+     * @param {?=} res
+     * @return {?}
+     */
+    closeDialog(res) {
+        this.dialogRef.close(res);
+    }
+    /**
+     * @return {?}
+     */
+    ngOnDestroy() {
+        this.destroy$.next(true);
+        this.destroy$.complete();
+    }
+}
+UploadDialogComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'lib-upload-dialog',
+                template: "<lib-modal heading=\"Add new assets\">\n  <ng-container content>\n    <lib-upload-file\n      *ngIf=\"!uploadAssetsService?.getFiles?.length\"\n      (revalidate)=\"onValidate($event)\"\n    ></lib-upload-file>\n    <lib-file-list\n      *ngIf=\"uploadAssetsService?.getFiles?.length\"\n      (revalidate)=\"onValidate($event)\"\n    ></lib-file-list>\n  </ng-container>\n  <ng-container actions>\n    <button mat-raised-button mat-dialog-close>Cancel</button>\n    <button\n      class=\"upload__action\"\n      [class.loading]=\"isLoading\"\n      mat-raised-button\n      color=\"primary\"\n      (click)=\"uploadFiles()\"\n      [disabled]=\"disabled || isLoading\"\n    >\n      <ng-container *ngIf=\"isLoading\">\n        <mat-spinner [diameter]=\"20\"></mat-spinner>\n      </ng-container>\n      <span>Upload</span>\n    </button>\n  </ng-container>\n</lib-modal>\n",
+                providers: [UploadAssetsService],
+                styles: [":host::ng-deep{display:block;width:1200px;max-width:100%;font-size:14px;line-height:16px;color:#979797;letter-spacing:.15px}:host::ng-deep .mat-dialog-title{position:relative;margin-bottom:0;padding-bottom:24px;color:#000}:host::ng-deep .mat-dialog-actions{justify-content:flex-end;padding:24px 0 0}:host::ng-deep .upload__action{min-width:100px}:host::ng-deep .upload__action.loading{padding:0 5px}:host::ng-deep .upload__action.loading .mat-button-wrapper{display:flex;width:100%;justify-content:center;align-items:center}:host::ng-deep .upload__action.loading .mat-spinner{margin-right:10px}"]
+            }] }
+];
+/** @nocollapse */
+UploadDialogComponent.ctorParameters = () => [
+    { type: undefined, decorators: [{ type: Inject, args: [MAT_DIALOG_DATA,] }] },
+    { type: MatDialogRef },
+    { type: ChangeDetectorRef },
+    { type: UploadAssetsService }
+];
+if (false) {
+    /** @type {?} */
+    UploadDialogComponent.prototype.isLoading;
+    /** @type {?} */
+    UploadDialogComponent.prototype.disabled;
+    /**
+     * @type {?}
+     * @private
+     */
+    UploadDialogComponent.prototype.destroy$;
+    /** @type {?} */
+    UploadDialogComponent.prototype.data;
+    /** @type {?} */
+    UploadDialogComponent.prototype.dialogRef;
+    /**
+     * @type {?}
+     * @private
+     */
+    UploadDialogComponent.prototype.changeDetectorRef;
+    /** @type {?} */
+    UploadDialogComponent.prototype.uploadAssetsService;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/components/partial/upload-file/upload-file.component.js

@@ -0,0 +1,102 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { Component, Output, EventEmitter } from '@angular/core';
+import { UploadAssetsService } from '../../../services/upload-assets.service';
+import { imageDefault } from '../../../contanst';
+import { DomSanitizer } from '@angular/platform-browser';
+export class UploadFileComponent {
+    /**
+     * @param {?} domSanitizer
+     * @param {?} uploadAssetsService
+     */
+    constructor(domSanitizer, uploadAssetsService) {
+        this.domSanitizer = domSanitizer;
+        this.uploadAssetsService = uploadAssetsService;
+        this.base64Image = this.domSanitizer.bypassSecurityTrustUrl(imageDefault);
+        this.revalidate = new EventEmitter();
+        this.isDragging = false;
+    }
+    /**
+     * @return {?}
+     */
+    ngOnInit() { }
+    /**
+     * @param {?} fileName
+     * @param {?} index
+     * @return {?}
+     */
+    onDelFile(fileName, index) {
+        this.uploadAssetsService.deleteFile(fileName, index);
+        this.revalidate.emit(this.uploadAssetsService.errorFiles);
+    }
+    /**
+     * @param {?} newName
+     * @param {?} originName
+     * @return {?}
+     */
+    onChangeName(newName, originName) {
+        this.uploadAssetsService.newName = { [originName]: newName };
+    }
+    /**
+     * @param {?} newFiles
+     * @return {?}
+     */
+    onFileChange(newFiles) {
+        this.isDragging = false;
+        const { getFiles: files } = this.uploadAssetsService;
+        this.uploadAssetsService.setFiles = [...files, ...newFiles];
+    }
+    /**
+     * @return {?}
+     */
+    onEmitError() {
+        this.revalidate.emit(this.uploadAssetsService.errorFiles);
+    }
+    /**
+     * @param {?} _event
+     * @return {?}
+     */
+    onDragover(_event) {
+        this.isDragging = true;
+    }
+    /**
+     * @param {?} _event
+     * @return {?}
+     */
+    onDragleave(_event) {
+        this.isDragging = false;
+    }
+}
+UploadFileComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'lib-upload-file',
+                template: "<div\n  class=\"upload-file__wrapper\"\n  [class.dragging]=\"isDragging\"\n  libDnDFile\n  (imageDropped)=\"onFileChange($event)\"\n  (dragover)=\"onDragover($event)\"\n  (dragleave)=\"onDragleave($event)\"\n>\n  <div>\n    <img [src]=\"base64Image\" />\n    <div class=\"upload-file__label\">Drag and drop here or</div>\n  </div>\n  <lib-input-file\n    [acceptTypes]=\"uploadAssetsService?.supportedTypes?.join(', ')\"\n    (onFileChange)=\"onFileChange($event)\"\n    color=\"primary\"\n  >\n    <span>Browse files</span>\n  </lib-input-file>\n</div>\n",
+                styles: [":host::ng-deep .upload-file__wrapper{margin-top:30px;margin-bottom:30px;min-height:300px;display:flex;flex-direction:column;justify-content:center;align-items:center;text-align:center;border:1px dashed #017eff;border-radius:10px;box-sizing:border-box}:host::ng-deep .upload-file__wrapper lib-input-file{margin-top:30px}:host::ng-deep .upload-file__wrapper.dragging{background-color:#f5fcff}:host::ng-deep .upload-file__label{margin-top:30px;font-size:24px}:host::ng-deep .upload-file lib-file-item{margin-bottom:20px}:host::ng-deep .upload-file__upload{cursor:pointer}"]
+            }] }
+];
+/** @nocollapse */
+UploadFileComponent.ctorParameters = () => [
+    { type: DomSanitizer },
+    { type: UploadAssetsService }
+];
+UploadFileComponent.propDecorators = {
+    revalidate: [{ type: Output }]
+};
+if (false) {
+    /** @type {?} */
+    UploadFileComponent.prototype.base64Image;
+    /** @type {?} */
+    UploadFileComponent.prototype.revalidate;
+    /** @type {?} */
+    UploadFileComponent.prototype.isDragging;
+    /**
+     * @type {?}
+     * @private
+     */
+    UploadFileComponent.prototype.domSanitizer;
+    /** @type {?} */
+    UploadFileComponent.prototype.uploadAssetsService;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/components/ui/drag-to-resize/drag-to-resize.component.js

@@ -0,0 +1,96 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { Component, EventEmitter, HostListener, Input, Output, } from '@angular/core';
+export class DragToResizeComponent {
+    constructor() {
+        this.resizeCompleted = new EventEmitter();
+        this.grabber = false;
+        this.oldX = 0;
+    }
+    /**
+     * @return {?}
+     */
+    ngOnInit() {
+        this.width = this.minWidth;
+    }
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    onMouseMove(event) {
+        if (!this.grabber) {
+            return;
+        }
+        this.resizer(event.clientX - this.oldX);
+        this.oldX = event.clientX;
+    }
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    onMouseUp(event) {
+        if (this.grabber) {
+            this.grabber = false;
+        }
+    }
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    onMouseDown(event) {
+        this.grabber = true;
+        this.oldX = event.clientX;
+    }
+    /**
+     * @param {?} offsetX
+     * @return {?}
+     */
+    resizer(offsetX) {
+        if (this.width + offsetX > this.maxWidth) {
+            this.width = this.maxWidth;
+        }
+        else if (this.width + offsetX < this.minWidth) {
+            this.width = this.minWidth;
+        }
+        else {
+            this.width += offsetX;
+        }
+        this.resizeCompleted.emit({ width: this.width });
+    }
+}
+DragToResizeComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'lib-drag-to-resize',
+                template: "<div class=\"drag-reszie__wrapper\" [ngStyle]=\"{\n    'width': width+'px',\n    'user-select': grabber? 'none' : 'auto'}\">\n    <ng-content></ng-content>\n    <div class=\"drag-reszie__wrapper--resizer\" (mousedown)=\"onMouseDown($event)\">\n    </div>\n</div>",
+                styles: [":host::ng-deep .drag-reszie__wrapper{position:relative;height:100%}:host::ng-deep .drag-reszie__wrapper--resizer{content:\"\";position:absolute;top:0;right:-15px;z-index:99;cursor:ew-resize;height:100%;width:15px;border-left:3px solid transparent;transition:.3s ease-in-out}:host::ng-deep .drag-reszie__wrapper--resizer:hover{border-left-color:#6fc0ff}"]
+            }] }
+];
+/** @nocollapse */
+DragToResizeComponent.ctorParameters = () => [];
+DragToResizeComponent.propDecorators = {
+    minWidth: [{ type: Input }],
+    maxWidth: [{ type: Input }],
+    resizeCompleted: [{ type: Output }],
+    onMouseMove: [{ type: HostListener, args: ['document:mousemove', ['$event'],] }],
+    onMouseUp: [{ type: HostListener, args: ['document:mouseup', ['$event'],] }]
+};
+if (false) {
+    /** @type {?} */
+    DragToResizeComponent.prototype.minWidth;
+    /** @type {?} */
+    DragToResizeComponent.prototype.maxWidth;
+    /** @type {?} */
+    DragToResizeComponent.prototype.resizeCompleted;
+    /** @type {?} */
+    DragToResizeComponent.prototype.width;
+    /** @type {?} */
+    DragToResizeComponent.prototype.grabber;
+    /**
+     * @type {?}
+     * @private
+     */
+    DragToResizeComponent.prototype.oldX;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/components/ui/input-file/input-file.component.js

@@ -0,0 +1,49 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { Component, Input, Output, EventEmitter } from '@angular/core';
+export class InputFileComponent {
+    constructor() {
+        this.multiple = true;
+        this.fileChange = new EventEmitter();
+    }
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    onFileChange(event) {
+        let { files } = event.target;
+        if (files.length < 1) {
+            return;
+        }
+        files = Array.from(files);
+        this.fileChange.emit(files);
+    }
+}
+InputFileComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'lib-input-file',
+                template: "<input\n  #inputFile\n  class=\"input-file\"\n  type=\"file\"\n  [accept]=\"acceptTypes\"\n  id=\"file-import\"\n  (change)=\"onFileChange($event)\"\n  [multiple]=\"multiple\"\n/>\n<button mat-raised-button [color]=\"color\" (click)=\"inputFile?.click()\">\n  <ng-content></ng-content>\n</button>\n",
+                styles: [":host::ng-deep{display:inline-block}:host::ng-deep .input-file{width:.1px;height:.1px;opacity:0;overflow:hidden;position:absolute;z-index:-1}"]
+            }] }
+];
+/** @nocollapse */
+InputFileComponent.ctorParameters = () => [];
+InputFileComponent.propDecorators = {
+    color: [{ type: Input }],
+    multiple: [{ type: Input }],
+    acceptTypes: [{ type: Input }],
+    fileChange: [{ type: Output, args: ['onFileChange',] }]
+};
+if (false) {
+    /** @type {?} */
+    InputFileComponent.prototype.color;
+    /** @type {?} */
+    InputFileComponent.prototype.multiple;
+    /** @type {?} */
+    InputFileComponent.prototype.acceptTypes;
+    /** @type {?} */
+    InputFileComponent.prototype.fileChange;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5wdXQtZmlsZS5jb21wb25lbnQuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AcnMtcGsvYXNzZXQtbWFuYWdlbWVudC8iLCJzb3VyY2VzIjpbImxpYi9jb21wb25lbnRzL3VpL2lucHV0LWZpbGUvaW5wdXQtZmlsZS5jb21wb25lbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7OztBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsS0FBSyxFQUFFLE1BQU0sRUFBRSxZQUFZLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFPdkUsTUFBTSxPQUFPLGtCQUFrQjtJQU03QjtRQUpTLGFBQVEsR0FBRyxJQUFJLENBQUM7UUFFRCxlQUFVLEdBQUcsSUFBSSxZQUFZLEVBQVMsQ0FBQztJQUVoRCxDQUFDOzs7OztJQUVoQixZQUFZLENBQUMsS0FBVTtZQUNqQixFQUFFLEtBQUssRUFBRSxHQUFHLEtBQUssQ0FBQyxNQUFNO1FBQzVCLElBQUksS0FBSyxDQUFDLE1BQU0sR0FBRyxDQUFDLEVBQUU7WUFDcEIsT0FBTztTQUNSO1FBRUQsS0FBSyxHQUFHLEtBQUssQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUM7UUFDMUIsSUFBSSxDQUFDLFVBQVUsQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUM7SUFDOUIsQ0FBQzs7O1lBckJGLFNBQVMsU0FBQztnQkFDVCxRQUFRLEVBQUUsZ0JBQWdCO2dCQUMxQixzVEFBMEM7O2FBRTNDOzs7OztvQkFFRSxLQUFLO3VCQUNMLEtBQUs7MEJBQ0wsS0FBSzt5QkFDTCxNQUFNLFNBQUMsY0FBYzs7OztJQUh0QixtQ0FBdUI7O0lBQ3ZCLHNDQUF5Qjs7SUFDekIseUNBQTZCOztJQUM3Qix3Q0FBK0QiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb21wb25lbnQsIElucHV0LCBPdXRwdXQsIEV2ZW50RW1pdHRlciB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5AQ29tcG9uZW50KHtcbiAgc2VsZWN0b3I6ICdsaWItaW5wdXQtZmlsZScsXG4gIHRlbXBsYXRlVXJsOiAnLi9pbnB1dC1maWxlLmNvbXBvbmVudC5odG1sJyxcbiAgc3R5bGVVcmxzOiBbJy4vaW5wdXQtZmlsZS5jb21wb25lbnQuc2NzcyddLFxufSlcbmV4cG9ydCBjbGFzcyBJbnB1dEZpbGVDb21wb25lbnQge1xuICBASW5wdXQoKSBjb2xvcjogc3RyaW5nO1xuICBASW5wdXQoKSBtdWx0aXBsZSA9IHRydWU7XG4gIEBJbnB1dCgpIGFjY2VwdFR5cGVzOiBzdHJpbmc7XG4gIEBPdXRwdXQoJ29uRmlsZUNoYW5nZScpIGZpbGVDaGFuZ2UgPSBuZXcgRXZlbnRFbWl0dGVyPEV2ZW50PigpO1xuXG4gIGNvbnN0cnVjdG9yKCkge31cblxuICBvbkZpbGVDaGFuZ2UoZXZlbnQ6IGFueSkge1xuICAgIGxldCB7IGZpbGVzIH0gPSBldmVudC50YXJnZXQ7XG4gICAgaWYgKGZpbGVzLmxlbmd0aCA8IDEpIHtcbiAgICAgIHJldHVybjtcbiAgICB9XG5cbiAgICBmaWxlcyA9IEFycmF5LmZyb20oZmlsZXMpO1xuICAgIHRoaXMuZmlsZUNoYW5nZS5lbWl0KGZpbGVzKTtcbiAgfVxufVxuIl19

package/esm2015/lib/components/ui/modal/modal.component.js

@@ -0,0 +1,34 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { Component, Input } from '@angular/core';
+export class ModalComponent {
+    constructor() {
+        this.customHeader = false;
+    }
+    /**
+     * @return {?}
+     */
+    ngOnInit() { }
+}
+ModalComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'lib-modal',
+                template: "<h4 mat-dialog-title *ngIf=\"!customHeader; else customHeaderTemplate\">\n  <div class=\"lib-modal--title\" [title]=\"heading\">\n    {{ heading }}\n  </div>\n  <div class=\"lib-modal--close\">\n    <mat-icon mat-dialog-close>close</mat-icon>\n  </div>\n</h4>\n<ng-template #customHeaderTemplate>\n  <h4 mat-dialog-title>\n    <div class=\"lib-modal--custom-title\">\n      <span>\n        {{ heading }}\n      </span>\n      <div class=\"lib-modal--custom-subtitle\">\n        <ng-content select=\"[subtitle]\"></ng-content>\n      </div>\n    </div>\n    <div class=\"lib-modal--header-actions\">\n      <ng-content select=\"[headerActions]\"></ng-content>\n    </div>\n    <mat-icon mat-dialog-close class=\"mat-dialog-close\">close</mat-icon>\n  </h4>\n</ng-template>\n<mat-dialog-content class=\"custom-scrollbar\">\n  <ng-content select=\"[content]\"></ng-content>\n</mat-dialog-content>\n<mat-dialog-actions>\n  <ng-content select=\"[actions]\"></ng-content>\n</mat-dialog-actions>\n",
+                styles: [":host::ng-deep{display:flex;flex-direction:column;min-height:150px;position:relative}:host::ng-deep .mat-dialog-title{padding-bottom:24px;margin:0;display:flex;justify-content:space-between;font-size:24px;line-height:1;gap:10px}:host::ng-deep .mat-dialog-title mat-icon{cursor:pointer}:host::ng-deep .lib-modal--custom-title,:host::ng-deep .lib-modal--title{white-space:nowrap;overflow:hidden;text-overflow:ellipsis}:host::ng-deep .lib-modal--custom-subtitle{margin-top:5px}:host::ng-deep .lib-modal--header-actions{display:flex;align-items:center;gap:10px}:host::ng-deep mat-dialog-content{flex:1;padding:0 24px}:host::ng-deep mat-dialog-actions{padding-top:24px;padding-bottom:0;display:flex;justify-content:flex-end;min-height:auto;margin-bottom:0}:host::ng-deep mat-dialog-actions .mat-button-base+.mat-button-base{margin-left:20px}:host::ng-deep .mat-error{margin-top:5px;font-size:14px}:host::ng-deep .no-wrap{white-space:nowrap}:host::ng-deep input,:host::ng-deep textarea{width:100%;padding:10px;border:1px solid #d8d8d8;border-radius:5px;color:#000;margin-top:0;resize:none}::ng-deep .lib-dialog--small{width:400px!important}::ng-deep .lib-dialog--small .file__name{word-break:break-word}::ng-deep .lib-dialog--small .mat-button-base{min-width:70px}::ng-deep .lib-dialog--small .loading{padding:0 5px}::ng-deep .lib-dialog--small .loading .mat-button-wrapper{display:flex;width:100%;justify-content:center;align-items:center}::ng-deep .lib-dialog--small .loading .mat-spinner{margin-right:10px}::ng-deep .lib-dialog--medium{max-width:1200px!important;width:90%!important}::ng-deep .lib-dialog--medium .mat-dialog-content{border-top:1px solid #d8d8d8;border-bottom:1px solid #d8d8d8;overflow-x:hidden}::ng-deep .lib-dialog--large{max-width:1200px!important;width:90vw!important}::ng-deep .lib-dialog--large .mat-dialog-title{padding-bottom:12px;position:relative}::ng-deep .lib-dialog--large .mat-dialog-title .mat-dialog-close{position:absolute;right:-22px;top:-22px}::ng-deep .lib-dialog--large .mat-dialog-content{min-height:70vh;border-top:1px solid #d8d8d8;border-bottom:1px solid #d8d8d8;padding:0}::ng-deep .lib-dialog--large .mat-dialog-content .asset-wrapper .asset-body{max-height:calc(70vh - 2px)!important}::ng-deep .lib-dialog--large .mat-dialog-content .asset-wrapper .asset-body .node-tree{height:calc(70vh - 2px)!important}::ng-deep .lib-dialog--large .mat-dialog-content .asset-wrapper .asset-body .asset-list__item{min-width:25%!important}@media only screen and (max-width:768px){::ng-deep .lib-dialog--large .mat-dialog-content .asset-wrapper .asset-body{max-height:none!important}::ng-deep .lib-dialog--large .mat-dialog-content .asset-wrapper .asset-body .node-tree{height:-webkit-max-content!important;height:-moz-max-content!important;height:max-content!important}}::ng-deep .lib-dialog--large .mat-dialog-actions{padding:12px 0;margin-bottom:-24px!important}"]
+            }] }
+];
+/** @nocollapse */
+ModalComponent.ctorParameters = () => [];
+ModalComponent.propDecorators = {
+    heading: [{ type: Input }],
+    customHeader: [{ type: Input }]
+};
+if (false) {
+    /** @type {?} */
+    ModalComponent.prototype.heading;
+    /** @type {?} */
+    ModalComponent.prototype.customHeader;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9kYWwuY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6Im5nOi8vQHJzLXBrL2Fzc2V0LW1hbmFnZW1lbnQvIiwic291cmNlcyI6WyJsaWIvY29tcG9uZW50cy91aS9tb2RhbC9tb2RhbC5jb21wb25lbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7OztBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsS0FBSyxFQUFVLE1BQU0sZUFBZSxDQUFDO0FBT3pELE1BQU0sT0FBTyxjQUFjO0lBSXpCO1FBRlMsaUJBQVksR0FBRyxLQUFLLENBQUM7SUFFZixDQUFDOzs7O0lBRWhCLFFBQVEsS0FBSSxDQUFDOzs7WUFYZCxTQUFTLFNBQUM7Z0JBQ1QsUUFBUSxFQUFFLFdBQVc7Z0JBQ3JCLDArQkFBcUM7O2FBRXRDOzs7OztzQkFFRSxLQUFLOzJCQUNMLEtBQUs7Ozs7SUFETixpQ0FBeUI7O0lBQ3pCLHNDQUE4QiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbXBvbmVudCwgSW5wdXQsIE9uSW5pdCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5AQ29tcG9uZW50KHtcbiAgc2VsZWN0b3I6ICdsaWItbW9kYWwnLFxuICB0ZW1wbGF0ZVVybDogJy4vbW9kYWwuY29tcG9uZW50Lmh0bWwnLFxuICBzdHlsZVVybHM6IFsnLi9tb2RhbC5jb21wb25lbnQuc2NzcyddLFxufSlcbmV4cG9ydCBjbGFzcyBNb2RhbENvbXBvbmVudCBpbXBsZW1lbnRzIE9uSW5pdCB7XG4gIEBJbnB1dCgpIGhlYWRpbmc6IHN0cmluZztcbiAgQElucHV0KCkgY3VzdG9tSGVhZGVyID0gZmFsc2U7XG5cbiAgY29uc3RydWN0b3IoKSB7fVxuXG4gIG5nT25Jbml0KCkge31cbn1cbiJdfQ==

package/esm2015/lib/components/ui/search-not-found/search-not-found.component.js

@@ -0,0 +1,41 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { Component } from '@angular/core';
+import { searchNotFound } from '../../../contanst';
+import { DomSanitizer } from '@angular/platform-browser';
+export class SearchNotFoundComponent {
+    /**
+     * @param {?} domSanitizer
+     */
+    constructor(domSanitizer) {
+        this.domSanitizer = domSanitizer;
+        this.base64Image = this.domSanitizer.bypassSecurityTrustUrl(searchNotFound);
+    }
+    /**
+     * @return {?}
+     */
+    ngOnInit() { }
+}
+SearchNotFoundComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'lib-search-not-found',
+                template: "<img [src]=\"base64Image\" />\n<span>No result found</span>\n",
+                styles: [":host::ng-deep{display:flex;flex-direction:column;align-items:center;justify-content:center;padding:55px;color:#979797}"]
+            }] }
+];
+/** @nocollapse */
+SearchNotFoundComponent.ctorParameters = () => [
+    { type: DomSanitizer }
+];
+if (false) {
+    /** @type {?} */
+    SearchNotFoundComponent.prototype.base64Image;
+    /**
+     * @type {?}
+     * @private
+     */
+    SearchNotFoundComponent.prototype.domSanitizer;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VhcmNoLW5vdC1mb3VuZC5jb21wb25lbnQuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AcnMtcGsvYXNzZXQtbWFuYWdlbWVudC8iLCJzb3VyY2VzIjpbImxpYi9jb21wb25lbnRzL3VpL3NlYXJjaC1ub3QtZm91bmQvc2VhcmNoLW5vdC1mb3VuZC5jb21wb25lbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7OztBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQVUsTUFBTSxlQUFlLENBQUM7QUFDbEQsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBQ25ELE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQU96RCxNQUFNLE9BQU8sdUJBQXVCOzs7O0lBRWxDLFlBQW9CLFlBQTBCO1FBQTFCLGlCQUFZLEdBQVosWUFBWSxDQUFjO1FBRHZDLGdCQUFXLEdBQUcsSUFBSSxDQUFDLFlBQVksQ0FBQyxzQkFBc0IsQ0FBQyxjQUFjLENBQUMsQ0FBQztJQUM3QixDQUFDOzs7O0lBRWxELFFBQVEsS0FBSSxDQUFDOzs7WUFUZCxTQUFTLFNBQUM7Z0JBQ1QsUUFBUSxFQUFFLHNCQUFzQjtnQkFDaEMseUVBQWdEOzthQUVqRDs7OztZQU5RLFlBQVk7Ozs7SUFRbkIsOENBQThFOzs7OztJQUNsRSwrQ0FBa0MiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb21wb25lbnQsIE9uSW5pdCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgc2VhcmNoTm90Rm91bmQgfSBmcm9tICcuLi8uLi8uLi9jb250YW5zdCc7XG5pbXBvcnQgeyBEb21TYW5pdGl6ZXIgfSBmcm9tICdAYW5ndWxhci9wbGF0Zm9ybS1icm93c2VyJztcblxuQENvbXBvbmVudCh7XG4gIHNlbGVjdG9yOiAnbGliLXNlYXJjaC1ub3QtZm91bmQnLFxuICB0ZW1wbGF0ZVVybDogJy4vc2VhcmNoLW5vdC1mb3VuZC5jb21wb25lbnQuaHRtbCcsXG4gIHN0eWxlVXJsczogWycuL3NlYXJjaC1ub3QtZm91bmQuY29tcG9uZW50LnNjc3MnXSxcbn0pXG5leHBvcnQgY2xhc3MgU2VhcmNoTm90Rm91bmRDb21wb25lbnQgaW1wbGVtZW50cyBPbkluaXQge1xuICBwdWJsaWMgYmFzZTY0SW1hZ2UgPSB0aGlzLmRvbVNhbml0aXplci5ieXBhc3NTZWN1cml0eVRydXN0VXJsKHNlYXJjaE5vdEZvdW5kKTtcbiAgY29uc3RydWN0b3IocHJpdmF0ZSBkb21TYW5pdGl6ZXI6IERvbVNhbml0aXplcikge31cblxuICBuZ09uSW5pdCgpIHt9XG59XG4iXX0=

package/esm2015/lib/configs/admin.config.js

@@ -0,0 +1,22 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/** @type {?} */
+export const AdminConfig = {
+    locale: 'en-US',
+    timeZone: 'local',
+    format: {
+        date: 'MM/DD/YYYY',
+        dayMonth: 'MMM DD',
+        dateTime: 'MM/DD/YYYY HH:mm',
+        fullDateTime: 'MM/DD/YYYY HH:mm:ss',
+        dateTimeAM: 'MM/DD/YYYY hh:mm A',
+        apiDate: 'YYYY/MM/DD',
+        apiDateTime: 'YYYY-MM-DD[T]HH:mm:ssZ',
+        apiDateTimeNoZ: 'YYYY-MM-DD[T]HH:mm:ss',
+        apiDateMonthYear: 'MMM DD YYYY',
+        urlParam: 'YYYY-MM-DD',
+    },
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWRtaW4uY29uZmlnLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQHJzLXBrL2Fzc2V0LW1hbmFnZW1lbnQvIiwic291cmNlcyI6WyJsaWIvY29uZmlncy9hZG1pbi5jb25maWcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFBQSxNQUFNLE9BQU8sV0FBVyxHQUE0QjtJQUNsRCxNQUFNLEVBQUUsT0FBTztJQUNmLFFBQVEsRUFBRSxPQUFPO0lBQ2pCLE1BQU0sRUFBRTtRQUNOLElBQUksRUFBRSxZQUFZO1FBQ2xCLFFBQVEsRUFBRSxRQUFRO1FBQ2xCLFFBQVEsRUFBRSxrQkFBa0I7UUFDNUIsWUFBWSxFQUFFLHFCQUFxQjtRQUNuQyxVQUFVLEVBQUUsb0JBQW9CO1FBQ2hDLE9BQU8sRUFBRSxZQUFZO1FBQ3JCLFdBQVcsRUFBRSx3QkFBd0I7UUFDckMsY0FBYyxFQUFFLHVCQUF1QjtRQUN2QyxnQkFBZ0IsRUFBRSxhQUFhO1FBQy9CLFFBQVEsRUFBRSxZQUFZO0tBQ3ZCO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgY29uc3QgQWRtaW5Db25maWc6IHsgW25hbWU6IHN0cmluZ106IGFueSB9ID0ge1xuICBsb2NhbGU6ICdlbi1VUycsXG4gIHRpbWVab25lOiAnbG9jYWwnLFxuICBmb3JtYXQ6IHtcbiAgICBkYXRlOiAnTU0vREQvWVlZWScsXG4gICAgZGF5TW9udGg6ICdNTU0gREQnLFxuICAgIGRhdGVUaW1lOiAnTU0vREQvWVlZWSBISDptbScsXG4gICAgZnVsbERhdGVUaW1lOiAnTU0vREQvWVlZWSBISDptbTpzcycsXG4gICAgZGF0ZVRpbWVBTTogJ01NL0REL1lZWVkgaGg6bW0gQScsXG4gICAgYXBpRGF0ZTogJ1lZWVkvTU0vREQnLFxuICAgIGFwaURhdGVUaW1lOiAnWVlZWS1NTS1ERFtUXUhIOm1tOnNzWicsXG4gICAgYXBpRGF0ZVRpbWVOb1o6ICdZWVlZLU1NLUREW1RdSEg6bW06c3MnLFxuICAgIGFwaURhdGVNb250aFllYXI6ICdNTU0gREQgWVlZWScsXG4gICAgdXJsUGFyYW06ICdZWVlZLU1NLUREJyxcbiAgfSxcbn07XG4iXX0=

package/esm2015/lib/contanst/data-image.js

@@ -0,0 +1,12 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+// tslint:disable:max-line-length
+/** @type {?} */
+export const imageDefault = 'data:image/png;base64,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';
+/** @type {?} */
+export const searchNotFound = 'data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iODAiIGhlaWdodD0iNzAiIHZpZXdCb3g9IjAgMCA4MCA3MCIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPHBhdGggZD0iTTU5LjM4MDEgNDQuMDRINTYuMjIwMUw1NS4xMDAxIDQyLjk2QzU5LjAyMDEgMzguNCA2MS4zODAxIDMyLjQ4IDYxLjM4MDEgMjYuMDRDNjEuMzgwMSAxMS42OCA0OS43NDAxIDAuMDQwMDM5MSAzNS4zODAxIDAuMDQwMDM5MUMyMS43MDAxIDAuMDQwMDM5MSAxMC41MDAxIDEwLjYgOS41MDAwNiAyNC4wNEgxNy41ODAxQzE4LjU4MDEgMTUuMDQgMjYuMTAwMSA4LjA0MDA0IDM1LjM4MDEgOC4wNDAwNEM0NS4zNDAxIDguMDQwMDQgNTMuMzgwMSAxNi4wOCA1My4zODAxIDI2LjA0QzUzLjM4MDEgMzYgNDUuMzQwMSA0NC4wNCAzNS4zODAxIDQ0LjA0QzM0LjcwMDEgNDQuMDQgMzQuMDYwMSA0My45MiAzMy4zODAxIDQzLjg0VjUxLjkyQzM0LjA2MDEgNTIgMzQuNzAwMSA1Mi4wNCAzNS4zODAxIDUyLjA0QzQxLjgyMDEgNTIuMDQgNDcuNzQwMSA0OS42OCA1Mi4zMDAxIDQ1Ljc2TDUzLjM4MDEgNDYuODhWNTAuMDRMNzMuMzgwMSA3MEw3OS4zNDAxIDY0LjA0TDU5LjM4MDEgNDQuMDRaIiBmaWxsPSIjNkZDMEZGIi8+CjxwYXRoIGQ9Ik0yMy4yNiAzMS4zMjAzTDEzLjM4IDQxLjIwMDNMMy41MDAwMyAzMS4zMjAzTDAuNjYwMDM0IDM0LjE2MDNMMTAuNTQgNDQuMDQwM0wwLjY2MDAzNCA1My45MjAzTDMuNTAwMDMgNTYuNzYwM0wxMy4zOCA0Ni44ODAzTDIzLjI2IDU2Ljc2MDNMMjYuMSA1My45MjAzTDE2LjIyIDQ0LjA0MDNMMjYuMSAzNC4xNjAzTDIzLjI2IDMxLjMyMDNaIiBmaWxsPSIjNkZDMEZGIi8+Cjwvc3ZnPgo=';
+/** @type {?} */
+export const imagePdf = 'data:image/png;base64,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';
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"data-image.js","sourceRoot":"ng://@rs-pk/asset-management/","sources":["lib/contanst/data-image.ts"],"names":[],"mappings":";;;;;;AACA,MAAM,OAAO,YAAY,GACvB,o4IAAo4I;;AAEt4I,MAAM,OAAO,cAAc,GACzB,woCAAwoC;;AAE1oC,MAAM,OAAO,QAAQ,GACnB,w6MAAw6M","sourcesContent":["// tslint:disable:max-line-length\nexport const imageDefault =\n  'data:image/png;base64,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';\n\nexport const searchNotFound =\n  'data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iODAiIGhlaWdodD0iNzAiIHZpZXdCb3g9IjAgMCA4MCA3MCIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPHBhdGggZD0iTTU5LjM4MDEgNDQuMDRINTYuMjIwMUw1NS4xMDAxIDQyLjk2QzU5LjAyMDEgMzguNCA2MS4zODAxIDMyLjQ4IDYxLjM4MDEgMjYuMDRDNjEuMzgwMSAxMS42OCA0OS43NDAxIDAuMDQwMDM5MSAzNS4zODAxIDAuMDQwMDM5MUMyMS43MDAxIDAuMDQwMDM5MSAxMC41MDAxIDEwLjYgOS41MDAwNiAyNC4wNEgxNy41ODAxQzE4LjU4MDEgMTUuMDQgMjYuMTAwMSA4LjA0MDA0IDM1LjM4MDEgOC4wNDAwNEM0NS4zNDAxIDguMDQwMDQgNTMuMzgwMSAxNi4wOCA1My4zODAxIDI2LjA0QzUzLjM4MDEgMzYgNDUuMzQwMSA0NC4wNCAzNS4zODAxIDQ0LjA0QzM0LjcwMDEgNDQuMDQgMzQuMDYwMSA0My45MiAzMy4zODAxIDQzLjg0VjUxLjkyQzM0LjA2MDEgNTIgMzQuNzAwMSA1Mi4wNCAzNS4zODAxIDUyLjA0QzQxLjgyMDEgNTIuMDQgNDcuNzQwMSA0OS42OCA1Mi4zMDAxIDQ1Ljc2TDUzLjM4MDEgNDYuODhWNTAuMDRMNzMuMzgwMSA3MEw3OS4zNDAxIDY0LjA0TDU5LjM4MDEgNDQuMDRaIiBmaWxsPSIjNkZDMEZGIi8+CjxwYXRoIGQ9Ik0yMy4yNiAzMS4zMjAzTDEzLjM4IDQxLjIwMDNMMy41MDAwMyAzMS4zMjAzTDAuNjYwMDM0IDM0LjE2MDNMMTAuNTQgNDQuMDQwM0wwLjY2MDAzNCA1My45MjAzTDMuNTAwMDMgNTYuNzYwM0wxMy4zOCA0Ni44ODAzTDIzLjI2IDU2Ljc2MDNMMjYuMSA1My45MjAzTDE2LjIyIDQ0LjA0MDNMMjYuMSAzNC4xNjAzTDIzLjI2IDMxLjMyMDNaIiBmaWxsPSIjNkZDMEZGIi8+Cjwvc3ZnPgo=';\n\nexport const imagePdf =\n  'data:image/png;base64,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';\n// tslint:enable:max-line-length\n"]}

package/esm2015/lib/contanst/index.js

@@ -0,0 +1,6 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+export { imageDefault, searchNotFound, imagePdf } from './data-image';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AcnMtcGsvYXNzZXQtbWFuYWdlbWVudC8iLCJzb3VyY2VzIjpbImxpYi9jb250YW5zdC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7O0FBQUEsdURBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9kYXRhLWltYWdlJztcbiJdfQ==

package/esm2015/lib/datasources/index.js

@@ -0,0 +1,6 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+export { NodeTreeDataSource } from './node-tree.datasource';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AcnMtcGsvYXNzZXQtbWFuYWdlbWVudC8iLCJzb3VyY2VzIjpbImxpYi9kYXRhc291cmNlcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7O0FBQUEsbUNBQWMsd0JBQXdCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL25vZGUtdHJlZS5kYXRhc291cmNlJztcbiJdfQ==