@rs-pk/asset-management 1.0.0

package/esm2015/lib/components/partial/node-tree/node-tree.component.js

@@ -0,0 +1,330 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import * as tslib_1 from "tslib";
+import { FlatTreeControl } from '@angular/cdk/tree';
+import { ChangeDetectorRef, Component, Input } from '@angular/core';
+import { of, Subject } from 'rxjs';
+import { distinctUntilChanged, switchMap, takeUntil } from 'rxjs/operators';
+import { AssetManagementService } from '../../../asset-management.service';
+import { NodeTreeDataSource } from '../../../datasources';
+import { NodeTreeService } from '../../../services/node-tree.service';
+import { ActionTypes, select } from '../../../store/index';
+export class NodeTreeComponent {
+    /**
+     * @param {?} nodeTreeService
+     * @param {?} svc
+     * @param {?} changeDetectorRef
+     */
+    constructor(nodeTreeService, svc, changeDetectorRef) {
+        this.nodeTreeService = nodeTreeService;
+        this.svc = svc;
+        this.changeDetectorRef = changeDetectorRef;
+        this.isRoot = false;
+        this.homeLoading = false;
+        this.loading = false;
+        this.unsubscribe$ = new Subject();
+        this.getLevel = (/**
+         * @param {?} node
+         * @return {?}
+         */
+        (node) => node.level);
+        this.isExpandable = (/**
+         * @param {?} node
+         * @return {?}
+         */
+        (node) => node.expandable);
+        this.hasChild = (/**
+         * @param {?} _
+         * @param {?} _nodeData
+         * @return {?}
+         */
+        (_, _nodeData) => _nodeData.expandable);
+        this.treeControl = new FlatTreeControl(this.getLevel, this.isExpandable);
+        this.dataSource = new NodeTreeDataSource(this.treeControl, nodeTreeService);
+    }
+    /**
+     * @return {?}
+     */
+    ngOnInit() {
+        this.bindSubscriber();
+        this.initialData();
+    }
+    /**
+     * @private
+     * @return {?}
+     */
+    initialData() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            yield this.nodeTreeService.initialData({ dispatchRootId: true });
+            this.changeDetectorRef.detectChanges();
+        });
+    }
+    /**
+     * @private
+     * @return {?}
+     */
+    bindSubscriber() {
+        this.nodeTreeService.loading$
+            .pipe(takeUntil(this.unsubscribe$), distinctUntilChanged())
+            .subscribe((/**
+         * @param {?} loading
+         * @return {?}
+         */
+        (loading) => {
+            this.homeLoading = loading;
+            this.changeDetectorRef.detectChanges();
+        }));
+        this.nodeTreeService.initialData$
+            .pipe(takeUntil(this.unsubscribe$), distinctUntilChanged())
+            .subscribe((/**
+         * @param {?} data
+         * @return {?}
+         */
+        (data) => {
+            const { AssetId: rootId } = this.nodeTreeService.rootFolder || { AssetId: null };
+            this.isRoot = rootId && this.currentFolderId === rootId;
+            this.dataSource.data = data;
+            data.forEach((/**
+             * @param {?} node
+             * @return {?}
+             */
+            (node) => this.nodeTreeService.addNode(node.item, null)));
+            this.changeDetectorRef.detectChanges();
+        }));
+        this.dataSource.dataChange
+            .pipe(takeUntil(this.unsubscribe$))
+            .subscribe((/**
+         * @param {?} data
+         * @return {?}
+         */
+        (data) => {
+            if (data && data.length) {
+                this.changeDetectorRef.detectChanges();
+            }
+        }));
+        select((/**
+         * @param {?} state
+         * @return {?}
+         */
+        (state) => state.currentFolderId))
+            .pipe(takeUntil(this.unsubscribe$))
+            .subscribe((/**
+         * @param {?} id
+         * @return {?}
+         */
+        (id) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (id) {
+                const { AssetId: rootId } = this.nodeTreeService.rootFolder || { AssetId: null };
+                this.isRoot = rootId && id === rootId;
+                this.currentFolderId = id;
+                yield this.nodeTreeService.updateBreadcrumb(id);
+                this.changeDetectorRef.detectChanges();
+            }
+        })));
+        select((/**
+         * @param {?} state
+         * @return {?}
+         */
+        (state) => state.reloadCurrentFolder))
+            .pipe(takeUntil(this.unsubscribe$), switchMap((/**
+         * @param {?} res
+         * @return {?}
+         */
+        (res) => of(res))))
+            .subscribe((/**
+         * @return {?}
+         */
+        () => tslib_1.__awaiter(this, void 0, void 0, function* () {
+            yield this.handleReloadFolder(this.currentFolderId);
+            this.changeDetectorRef.detectChanges();
+        })));
+    }
+    /**
+     * @param {?} node
+     * @return {?}
+     */
+    selectNode(node) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const { AssetId: id } = node.item;
+            if (id === this.currentFolderId) {
+                this.svc.dispatch({
+                    type: ActionTypes.RELOAD_CURRENT_NODE,
+                });
+            }
+            else {
+                this.svc.dispatch({
+                    type: ActionTypes.SET_CURRENT_FOLDER_ID,
+                    payload: id,
+                });
+            }
+            yield this.handleReloadFolder(id);
+            this.changeDetectorRef.detectChanges();
+        });
+    }
+    /**
+     * @return {?}
+     */
+    backToHome() {
+        this.initialData();
+        const { AssetId: rootId } = this.nodeTreeService.rootFolder;
+        if (this.currentFolderId === rootId) {
+            this.svc.dispatch({
+                type: ActionTypes.RELOAD_CURRENT_NODE,
+            });
+        }
+    }
+    /**
+     * @param {?} node
+     * @return {?}
+     */
+    checked(node) {
+        return this.currentFolderId && this.currentFolderId === node.item.AssetId;
+    }
+    /**
+     * @param {?} node
+     * @return {?}
+     */
+    disabled(node) {
+        return node.expandable;
+    }
+    /**
+     * @param {?} node
+     * @return {?}
+     */
+    getParent(node) {
+        /** @type {?} */
+        const currentLevel = this.getLevel(node);
+        if (currentLevel < 1) {
+            return null;
+        }
+        /** @type {?} */
+        const startIndex = this.dataSource.data.indexOf(node) - 1;
+        for (let i = startIndex; i >= 0; i--) {
+            /** @type {?} */
+            const currentNode = this.dataSource.data[i];
+            if (this.getLevel(currentNode) < currentLevel) {
+                return currentNode;
+            }
+        }
+    }
+    /**
+     * @param {?} id
+     * @return {?}
+     */
+    getNodeById(id) {
+        return this.treeControl.dataNodes.find((/**
+         * @param {?} node
+         * @return {?}
+         */
+        (node) => node.item.AssetId === id));
+    }
+    /**
+     * @private
+     * @param {?} id
+     * @return {?}
+     */
+    handleReloadFolder(id) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (!id || this.loading) {
+                return;
+            }
+            this.loading = true;
+            /** @type {?} */
+            const node = this.getNodeById(id);
+            if (node) {
+                /** @type {?} */
+                const parent = this.getParent(node);
+                if (parent) {
+                    yield this.dataSource.reloadNode(parent);
+                    /** @type {?} */
+                    const updatedNode = this.getNodeById(id);
+                    if (updatedNode) {
+                        yield this.treeControl.expand(updatedNode);
+                    }
+                }
+                else {
+                    yield this.nodeTreeService.initialData({ dispatchRootId: false });
+                    /** @type {?} */
+                    const updatedNode = this.getNodeById(id);
+                    if (updatedNode) {
+                        yield this.treeControl.expand(updatedNode);
+                    }
+                }
+            }
+            else {
+                yield this.nodeTreeService.initialData({ dispatchRootId: false });
+            }
+            this.loading = false;
+        });
+    }
+    /**
+     * @return {?}
+     */
+    ngOnDestroy() {
+        this.dataSource.data = [];
+        this.nodeTreeService.data = [];
+        this.unsubscribe$.next();
+        this.unsubscribe$.complete();
+    }
+}
+NodeTreeComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'lib-node-tree',
+                template: "<div class=\"node custom-scrollbar node-tree\">\n  <div class=\"node__home\" (click)=\"backToHome()\" [ngClass]=\"{ active: isRoot,\n    disabled: loading || homeLoading}\">\n    <mat-icon *ngIf=\"!homeLoading\">home</mat-icon>\n    <mat-spinner *ngIf=\"homeLoading\" [diameter]=\"20\"\n      class=\"node__home--loading\"></mat-spinner>\n    <span>Home</span>\n  </div>\n  <mat-tree [dataSource]=\"dataSource\" [treeControl]=\"treeControl\"\n    class=\"node__item\">\n    <mat-tree-node *matTreeNodeDef=\"let node\" matTreeNodePadding\n      [ngClass]=\"{ active: checked(node),disabled: loading || node.isLoading }\"\n      (click)=\"selectNode(node)\">\n      <button mat-icon-button disabled class=\"node__item--pading\"></button>\n      <div class=\"node__item--info\" [style.maxWidth.px]=\"width -50\">\n        <mat-icon class=\"folder-icon\">folder</mat-icon>\n        <div class=\"node-name\">\n          <span>\n            {{ node.item.OriginalFileName }}\n          </span>\n          <span class=\"node-summary\" *ngIf=\"node.item?.TotalFolder ||\n            node.item?.TotalFile\">\n            <small *ngIf=\"node.item?.TotalFolder\">{{ node.item?.TotalFolder}}\n              {{node.item?.TotalFolder> 1 ?\n              'folders':'folder'}}</small>\n            <small *ngIf=\"node.item?.TotalFolder && node.item?.TotalFile\">,\n            </small>\n            <small *ngIf=\"node.item?.TotalFile\">{{ node.item?.TotalFile}}\n              {{node.item?.TotalFile> 1 ?\n              'files':'file'}}</small>\n          </span>\n        </div>\n      </div>\n    </mat-tree-node>\n    <mat-tree-node *matTreeNodeDef=\"let node; when: hasChild\" matTreeNodePadding\n      (click)=\"selectNode(node)\"\n      [ngClass]=\"{ active: checked(node), disabled: loading || node.isLoading\n      }\">\n      <button mat-icon-button [attr.aria-label]=\"'Toggle ' +\n        node.item.OriginalFileName\" matTreeNodeToggle\n        [disabled]=\"node.isLoading\">\n        <mat-icon *ngIf=\"!node.isLoading\" class=\"mat-icon-rtl-mirror\">\n          {{ treeControl.isExpanded(node) ? 'expand_more' : 'chevron_right' }}\n        </mat-icon>\n        <mat-spinner *ngIf=\"node.isLoading\" [diameter]=\"20\"\n          class=\"node__item--loading\"></mat-spinner>\n      </button>\n      <div class=\"node__item--info\" [style.maxWidth.px]=\"width -50\">\n        <mat-icon class=\"folder-icon\">folder</mat-icon>\n        <div class=\"node-name\">\n          <span>\n            {{ node.item.OriginalFileName }}\n          </span>\n          <span class=\"node-summary\">\n            <small *ngIf=\"node.item?.TotalFolder\">{{ node.item?.TotalFolder}}\n              {{node.item?.TotalFolder> 1 ?\n              'folders':'folder'}}</small>\n            <small *ngIf=\"node.item?.TotalFolder && node.item?.TotalFile\">,\n            </small>\n            <small *ngIf=\"node.item?.TotalFile\">{{ node.item?.TotalFile}}\n              {{node.item?.TotalFile> 1 ?\n              'files':'file'}}</small>\n          </span>\n        </div>\n      </div>\n    </mat-tree-node>\n  </mat-tree>\n</div>",
+                styles: [":host::ng-deep .node{overflow-x:hidden;height:100%;display:-ms-grid;display:grid;grid-auto-rows:-webkit-max-content;grid-auto-rows:max-content}:host::ng-deep .node__home{padding:8px 10px;display:flex;align-items:center;height:44px}:host::ng-deep .node__home .mat-icon{color:#979797;margin-right:15px;margin-bottom:10px;font-size:32px}:host::ng-deep .node__home .node__home--loading{margin-right:19px}:host::ng-deep .node__item--loading{margin-left:10px}:host::ng-deep .node__item--info{display:flex;align-items:center}:host::ng-deep .node__item--info .folder-icon{display:flex;align-items:center;color:#6fc0ff;font-size:32px;margin-right:20px}:host::ng-deep .node__item--info .node-name{display:block;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}:host::ng-deep .node__item--info .node-name span{display:block;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}:host::ng-deep .node__item--info .node-name .node-summary{margin-top:-5px;color:#979797}:host::ng-deep .node .mat-tree{width:-webkit-max-content!important;width:-moz-max-content!important;width:max-content!important;min-width:100%}:host::ng-deep .node .mat-tree .mat-tree-node{padding:5px 0;min-height:44px}:host::ng-deep .node .mat-tree .mat-tree-node .node__item--pading{height:20px}:host::ng-deep .node .mat-tree-node:hover,:host::ng-deep .node .node__home{transition:.3s;cursor:pointer}:host::ng-deep .node .mat-tree-node:hover:hover,:host::ng-deep .node .node__home:hover{background-color:#e8e8e8}:host::ng-deep .node .active{background-color:#f0f0f0}:host::ng-deep .node .disabled{pointer-events:none}"]
+            }] }
+];
+/** @nocollapse */
+NodeTreeComponent.ctorParameters = () => [
+    { type: NodeTreeService },
+    { type: AssetManagementService },
+    { type: ChangeDetectorRef }
+];
+NodeTreeComponent.propDecorators = {
+    width: [{ type: Input }]
+};
+if (false) {
+    /** @type {?} */
+    NodeTreeComponent.prototype.width;
+    /** @type {?} */
+    NodeTreeComponent.prototype.currentFolderId;
+    /** @type {?} */
+    NodeTreeComponent.prototype.isRoot;
+    /** @type {?} */
+    NodeTreeComponent.prototype.homeLoading;
+    /** @type {?} */
+    NodeTreeComponent.prototype.loading;
+    /** @type {?} */
+    NodeTreeComponent.prototype.treeControl;
+    /** @type {?} */
+    NodeTreeComponent.prototype.dataSource;
+    /**
+     * @type {?}
+     * @private
+     */
+    NodeTreeComponent.prototype.unsubscribe$;
+    /** @type {?} */
+    NodeTreeComponent.prototype.getLevel;
+    /** @type {?} */
+    NodeTreeComponent.prototype.isExpandable;
+    /** @type {?} */
+    NodeTreeComponent.prototype.hasChild;
+    /**
+     * @type {?}
+     * @private
+     */
+    NodeTreeComponent.prototype.nodeTreeService;
+    /**
+     * @type {?}
+     * @private
+     */
+    NodeTreeComponent.prototype.svc;
+    /**
+     * @type {?}
+     * @private
+     */
+    NodeTreeComponent.prototype.changeDetectorRef;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"node-tree.component.js","sourceRoot":"ng://@rs-pk/asset-management/","sources":["lib/components/partial/node-tree/node-tree.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { FlatTreeControl } from '@angular/cdk/tree';\nimport { ChangeDetectorRef, Component, Input, OnDestroy, OnInit } from '@angular/core';\nimport { of, Subject } from 'rxjs';\nimport { distinctUntilChanged, switchMap, takeUntil } from 'rxjs/operators';\nimport { AssetManagementService } from '../../../asset-management.service';\nimport { NodeTreeDataSource } from '../../../datasources';\nimport { DynamicFlatNode } from '../../../models';\nimport { NodeTreeService } from '../../../services/node-tree.service';\nimport { ActionTypes, select } from '../../../store/index';\n\n@Component({\n  selector: 'lib-node-tree',\n  templateUrl: './node-tree.component.html',\n  styleUrls: ['./node-tree.component.scss'],\n})\nexport class NodeTreeComponent implements OnInit, OnDestroy {\n  constructor(\n    private nodeTreeService: NodeTreeService,\n    private svc: AssetManagementService,\n    private changeDetectorRef: ChangeDetectorRef\n  ) {\n    this.treeControl = new FlatTreeControl<DynamicFlatNode>(\n      this.getLevel,\n      this.isExpandable\n    );\n    this.dataSource = new NodeTreeDataSource(this.treeControl, nodeTreeService);\n  }\n\n  @Input() width: number;\n\n  public currentFolderId: string;\n  public isRoot = false;\n  public homeLoading = false;\n  public loading = false;\n  public treeControl: FlatTreeControl<DynamicFlatNode>;\n  public dataSource: NodeTreeDataSource;\n  private unsubscribe$ = new Subject<void>();\n\n  ngOnInit() {\n    this.bindSubscriber();\n    this.initialData();\n  }\n\n  private async initialData() {\n    await this.nodeTreeService.initialData({ dispatchRootId: true });\n    this.changeDetectorRef.detectChanges();\n  }\n\n  private bindSubscriber() {\n    this.nodeTreeService.loading$\n      .pipe(takeUntil(this.unsubscribe$), distinctUntilChanged())\n      .subscribe((loading) => {\n        this.homeLoading = loading;\n        this.changeDetectorRef.detectChanges();\n      });\n\n    this.nodeTreeService.initialData$\n      .pipe(takeUntil(this.unsubscribe$), distinctUntilChanged())\n      .subscribe((data) => {\n        const { AssetId: rootId } = this.nodeTreeService.rootFolder || {AssetId: null};\n        this.isRoot = rootId && this.currentFolderId === rootId;\n        this.dataSource.data = data;\n        data.forEach((node) => this.nodeTreeService.addNode(node.item, null));\n        this.changeDetectorRef.detectChanges();\n      });\n\n    this.dataSource.dataChange\n      .pipe(takeUntil(this.unsubscribe$))\n      .subscribe((data) => {\n        if (data && data.length) {\n          this.changeDetectorRef.detectChanges();\n        }\n      });\n\n    select((state) => state.currentFolderId)\n      .pipe(takeUntil(this.unsubscribe$))\n      .subscribe(async (id) => {\n        if (id) {\n          const { AssetId: rootId } = this.nodeTreeService.rootFolder || {AssetId: null};\n          this.isRoot = rootId && id === rootId;\n          this.currentFolderId = id;\n          await this.nodeTreeService.updateBreadcrumb(id);\n          this.changeDetectorRef.detectChanges();\n        }\n      });\n\n    select((state) => state.reloadCurrentFolder)\n      .pipe(takeUntil(this.unsubscribe$), switchMap((res) => of(res)))\n      .subscribe(async () => {\n        await this.handleReloadFolder(this.currentFolderId);\n        this.changeDetectorRef.detectChanges();\n      });\n  }\n\n  public async selectNode(node: DynamicFlatNode) {\n    const { AssetId: id } = node.item;\n    if (id === this.currentFolderId) {\n      this.svc.dispatch({\n        type: ActionTypes.RELOAD_CURRENT_NODE,\n      });\n    } else {\n      this.svc.dispatch({\n        type: ActionTypes.SET_CURRENT_FOLDER_ID,\n        payload: id,\n      });\n    }\n    await this.handleReloadFolder(id);\n    this.changeDetectorRef.detectChanges();\n  }\n\n  public backToHome() {\n    this.initialData();\n    const { AssetId: rootId } = this.nodeTreeService.rootFolder;\n    if (this.currentFolderId === rootId) {\n      this.svc.dispatch({\n        type: ActionTypes.RELOAD_CURRENT_NODE,\n      });\n    }\n\n  }\n\n  checked(node: DynamicFlatNode): boolean {\n    return this.currentFolderId && this.currentFolderId === node.item.AssetId;\n  }\n\n  disabled(node: DynamicFlatNode): boolean {\n    return node.expandable;\n  }\n\n  getLevel = (node: DynamicFlatNode) => node.level;\n\n  isExpandable = (node: DynamicFlatNode) => node.expandable;\n\n  hasChild = (_: number, _nodeData: DynamicFlatNode) => _nodeData.expandable;\n\n  getParent(node: DynamicFlatNode): DynamicFlatNode {\n    const currentLevel = this.getLevel(node);\n\n    if (currentLevel < 1) {\n      return null;\n    }\n\n    const startIndex = this.dataSource.data.indexOf(node) - 1;\n\n    for (let i = startIndex; i >= 0; i--) {\n      const currentNode = this.dataSource.data[i];\n      if (this.getLevel(currentNode) < currentLevel) {\n        return currentNode;\n      }\n    }\n  }\n\n  getNodeById(id: string): DynamicFlatNode {\n    return this.treeControl.dataNodes.find((node) => node.item.AssetId === id);\n  }\n\n  private async handleReloadFolder(id: string) {\n    if (!id || this.loading) {\n      return;\n    }\n    this.loading = true;\n    const node = this.getNodeById(id);\n    if (node) {\n      const parent = this.getParent(node);\n      if (parent) {\n        await this.dataSource.reloadNode(parent);\n        const updatedNode = this.getNodeById(id);\n        if (updatedNode) {\n          await this.treeControl.expand(updatedNode);\n        }\n      } else {\n        await this.nodeTreeService.initialData({ dispatchRootId: false });\n        const updatedNode = this.getNodeById(id);\n        if (updatedNode) {\n          await this.treeControl.expand(updatedNode);\n        }\n      }\n    } else {\n      await this.nodeTreeService.initialData({ dispatchRootId: false });\n    }\n    this.loading = false;\n  }\n\n  ngOnDestroy() {\n    this.dataSource.data = [];\n    this.nodeTreeService.data = [];\n    this.unsubscribe$.next();\n    this.unsubscribe$.complete();\n  }\n}\n"]}

package/esm2015/lib/components/partial/search-box/search-box.component.js

@@ -0,0 +1,158 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { Component } from '@angular/core';
+import { combineLatest } from 'rxjs/internal/observable/combineLatest';
+import { of } from 'rxjs/internal/observable/of';
+import { Subject } from 'rxjs/internal/Subject';
+import { switchMap, takeUntil } from 'rxjs/operators';
+import { AssetManagementService } from '../../../asset-management.service';
+import { AssetService } from '../../../services/asset.service';
+import { ActionTypes, select } from '../../../store';
+export class SearchBoxComponent {
+    /**
+     * @param {?} assetService
+     * @param {?} svc
+     */
+    constructor(assetService, svc) {
+        this.assetService = assetService;
+        this.svc = svc;
+        this.destroy$ = new Subject();
+        this.value = '';
+        this.folderId = '';
+        this.bindingSubscriber();
+    }
+    /**
+     * @return {?}
+     */
+    ngOnInit() { }
+    /**
+     * @private
+     * @return {?}
+     */
+    bindingSubscriber() {
+        select((/**
+         * @param {?} state
+         * @return {?}
+         */
+        state => state.currentFolderId))
+            .pipe(takeUntil(this.destroy$), switchMap((/**
+         * @param {?} res
+         * @return {?}
+         */
+        res => of(res))))
+            .subscribe((/**
+         * @param {?} currentFolderId
+         * @return {?}
+         */
+        currentFolderId => (this.folderId = currentFolderId)));
+    }
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    onChange(event) {
+        this.value = ((/** @type {?} */ (event.target))).value;
+    }
+    /**
+     * @return {?}
+     */
+    onSubmit() {
+        if (!this.value && !this.assetService.keyword) {
+            return;
+        }
+        this.assetService.keyword = this.value;
+        this.searchByName();
+    }
+    /**
+     * @return {?}
+     */
+    clearSearch() {
+        if (!this.assetService.keyword) {
+            this.value = '';
+            return;
+        }
+        this.value = '';
+        this.assetService.keyword = '';
+        this.searchByName();
+        this.assetService.setFolderList(null);
+        this.assetService.setAssetList(null);
+    }
+    /**
+     * @private
+     * @return {?}
+     */
+    searchByName() {
+        this.svc.dispatch({
+            type: ActionTypes.SET_GLOBAL_LOADING,
+            payload: true,
+        });
+        combineLatest([
+            this.assetService.getChildrenFolders({ assetId: this.folderId }),
+            this.assetService.getChildrenAssets({
+                assetId: this.folderId,
+                pageIndex: '0',
+            }),
+        ])
+            .pipe(takeUntil(this.destroy$))
+            .subscribe((/**
+         * @param {?} __0
+         * @return {?}
+         */
+        ([folders, assets]) => {
+            this.assetService.setFolderList(folders.Data, folders.Meta.Total);
+            this.assetService.setAssetList(assets.Data.Children, assets.Meta);
+        }))
+            .add((/**
+         * @return {?}
+         */
+        () => {
+            this.svc.dispatch({
+                type: ActionTypes.SET_GLOBAL_LOADING,
+                payload: false,
+            });
+        }));
+    }
+    /**
+     * @return {?}
+     */
+    ngOnDestroy() {
+        this.destroy$.next();
+        this.destroy$.complete();
+    }
+}
+SearchBoxComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'lib-search-box',
+                template: "<form (ngSubmit)=\"onSubmit()\">\n  <label for=\"search-assets\">\n    <mat-icon>search</mat-icon>\n  </label>\n  <input\n    class=\"search-input\"\n    id=\"search-assets\"\n    [value]=\"value\"\n    (input)=\"onChange($event)\"\n    matInput\n    placeholder=\"Search assets...\"\n    autocomplete=\"off\"\n    required\n  />\n  <mat-icon\n    [class.visible]=\"value || assetService.keyword\"\n    (click)=\"clearSearch()\"\n    matTooltip=\"Clear search\"\n    >close</mat-icon\n  >\n</form>\n",
+                styles: [":host::ng-deep{display:flex;align-items:center;width:300px;height:40px}:host::ng-deep form{width:100%;position:relative}:host::ng-deep label{position:absolute;left:10px;top:50%;transform:translateY(-50%);color:rgba(0,0,0,.38);display:flex;align-items:center}:host::ng-deep input.search-input{width:100%;padding:10px 40px;border:1px solid #d8d8d8;border-radius:5px;color:#000;font-size:14px}:host::ng-deep input.search-input+.mat-icon{display:none;position:absolute;right:10px;top:50%;transform:translateY(-50%);color:rgba(0,0,0,.38);font-size:20px;cursor:pointer;align-items:center}:host::ng-deep input.search-input+.mat-icon.visible{display:flex}"]
+            }] }
+];
+/** @nocollapse */
+SearchBoxComponent.ctorParameters = () => [
+    { type: AssetService },
+    { type: AssetManagementService }
+];
+if (false) {
+    /**
+     * @type {?}
+     * @private
+     */
+    SearchBoxComponent.prototype.destroy$;
+    /** @type {?} */
+    SearchBoxComponent.prototype.value;
+    /**
+     * @type {?}
+     * @private
+     */
+    SearchBoxComponent.prototype.folderId;
+    /** @type {?} */
+    SearchBoxComponent.prototype.assetService;
+    /**
+     * @type {?}
+     * @private
+     */
+    SearchBoxComponent.prototype.svc;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/components/partial/sort-items/sort-items.component.js

@@ -0,0 +1,99 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { Component } from '@angular/core';
+import { AssetManagementService } from '../../../asset-management.service';
+import { SortFilesBy, TypeSort } from '../../../models';
+import { AssetService } from '../../../services/asset.service';
+import { ActionTypes } from '../../../store';
+export class SortItemsComponent {
+    /**
+     * @param {?} assetService
+     * @param {?} svc
+     */
+    constructor(assetService, svc) {
+        this.assetService = assetService;
+        this.svc = svc;
+        this.typeSort = TypeSort;
+        this.sortOrder = TypeSort.DESC;
+        this.sortBy = SortFilesBy.MODIFIED_DATE;
+        this.sortList = [
+            { value: SortFilesBy.NAME, label: 'Sort by name' },
+            { value: SortFilesBy.CREATED_DATE, label: 'Sort by created date' },
+            { value: SortFilesBy.MODIFIED_DATE, label: 'Sort by modified date' },
+        ];
+    }
+    /**
+     * @return {?}
+     */
+    ngOnInit() {
+        this.sortBy = this.assetService.sortBy;
+        this.sortOrder = this.assetService.sortOrder;
+    }
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    onSortBy(event) {
+        this.sortBy = event.value;
+        this.assetService.sortBy = this.sortBy;
+        this.svc.dispatch({
+            type: ActionTypes.RELOAD_CURRENT_ASSETS,
+        });
+    }
+    /**
+     * @return {?}
+     */
+    toggleSortOrder() {
+        this.sortOrder =
+            this.sortOrder === TypeSort.ASC ? TypeSort.DESC : TypeSort.ASC;
+        this.assetService.sortOrder = this.sortOrder;
+        this.svc.dispatch({
+            type: ActionTypes.RELOAD_CURRENT_ASSETS,
+        });
+    }
+}
+SortItemsComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'lib-sort-items',
+                template: "<mat-icon\n  [ngClass]=\"{\n    sort__icon: true,\n    asc: sortOrder === typeSort.ASC,\n    desc: sortOrder === typeSort.DESC\n  }\"\n  matTooltip=\"Sort direction\"\n  (click)=\"toggleSortOrder()\"\n  >sort</mat-icon\n>\n<mat-form-field class=\"sort__dropdown\" appearance=\"none\">\n  <mat-select [(value)]=\"sortBy\" (selectionChange)=\"onSortBy($event)\">\n    <mat-option *ngFor=\"let option of sortList\" [value]=\"option.value\">\n      {{ option.label }}\n    </mat-option>\n  </mat-select>\n</mat-form-field>\n",
+                styles: [":host::ng-deep{display:flex;align-items:center}:host::ng-deep .sort__icon{cursor:pointer;transition:transform .3s ease-in-out}:host::ng-deep .sort__icon.asc{transform:scaleY(-1)}:host::ng-deep .sort__dropdown{padding:5px;border:1px solid #d8d8d8;border-radius:5px}:host::ng-deep .sort__dropdown .mat-form-field-wrapper{padding-bottom:0}:host::ng-deep .sort__dropdown .mat-form-field-infix{border-top:0;padding:0}:host::ng-deep .sort__dropdown .mat-select{font-size:14px}:host::ng-deep .sort__dropdown .mat-select-arrow{border:none}"]
+            }] }
+];
+/** @nocollapse */
+SortItemsComponent.ctorParameters = () => [
+    { type: AssetService },
+    { type: AssetManagementService }
+];
+if (false) {
+    /** @type {?} */
+    SortItemsComponent.prototype.typeSort;
+    /** @type {?} */
+    SortItemsComponent.prototype.sortOrder;
+    /** @type {?} */
+    SortItemsComponent.prototype.sortBy;
+    /** @type {?} */
+    SortItemsComponent.prototype.sortList;
+    /**
+     * @type {?}
+     * @private
+     */
+    SortItemsComponent.prototype.assetService;
+    /**
+     * @type {?}
+     * @private
+     */
+    SortItemsComponent.prototype.svc;
+}
+/**
+ * @record
+ */
+function ISort() { }
+if (false) {
+    /** @type {?} */
+    ISort.prototype.value;
+    /** @type {?|undefined} */
+    ISort.prototype.label;
+}
+//# sourceMappingURL=data:application/json;base64,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