@rs-pk/asset-management 1.0.0

package/esm2015/lib/components/partial/asset-list/asset-list.component.js

@@ -0,0 +1,239 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { Component, Input, ViewChild, } from '@angular/core';
+import { MatPaginator } from '@angular/material/paginator';
+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 } from '../../../store/actions.action';
+import { select } from '../../../store/reducer';
+export class AssetListComponent {
+    /**
+     * @param {?} assetService
+     * @param {?} svc
+     */
+    constructor(assetService, svc) {
+        this.assetService = assetService;
+        this.svc = svc;
+        this.unsubscribe$ = new Subject();
+        this.selectedAssets = [];
+    }
+    /**
+     * @return {?}
+     */
+    ngOnInit() {
+        this.bindSubscriber();
+    }
+    /**
+     * @param {?} changes
+     * @return {?}
+     */
+    ngOnChanges(changes) {
+        if (changes.assets) {
+            this.paginator.pageIndex = this.assetService.pageIndex;
+            this.paginator.pageSize = this.assetService.pageSize;
+            this.paginator.length = this.assetService.fileTotal;
+        }
+    }
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    onSelectAsset(event) {
+        /** @type {?} */
+        const index = this.selectedAssets.findIndex((/**
+         * @param {?} asset
+         * @return {?}
+         */
+        (asset) => asset.AssetId === event.AssetId));
+        /** @type {?} */
+        const newSelectedAssets = index > -1
+            ? this.selectedAssets.filter((/**
+             * @param {?} asset
+             * @param {?} i
+             * @return {?}
+             */
+            (asset, i) => index !== i))
+            : [...this.selectedAssets, event];
+        this.svc.dispatch({
+            type: ActionTypes.SET_SELECTED_ASSETS,
+            payload: newSelectedAssets,
+        });
+    }
+    /**
+     * @private
+     * @return {?}
+     */
+    bindSubscriber() {
+        select((/**
+         * @param {?} state
+         * @return {?}
+         */
+        (state) => state.deletedAssetId))
+            .pipe(takeUntil(this.unsubscribe$))
+            .subscribe((/**
+         * @param {?} id
+         * @return {?}
+         */
+        (id) => {
+            if (this.selectedAssets && this.selectedAssets.length) {
+                /** @type {?} */
+                const newSelectedAssets = this.selectedAssets.filter((/**
+                 * @param {?} asset
+                 * @return {?}
+                 */
+                (asset) => asset.AssetId !== id));
+                this.svc.dispatch({
+                    type: ActionTypes.SET_SELECTED_ASSETS,
+                    payload: newSelectedAssets,
+                });
+            }
+        }));
+        select((/**
+         * @param {?} state
+         * @return {?}
+         */
+        (state) => state.currentFolderId))
+            .pipe(takeUntil(this.unsubscribe$))
+            .subscribe((/**
+         * @param {?} currentFolderId
+         * @return {?}
+         */
+        (currentFolderId) => {
+            this.currentFolderId = currentFolderId;
+            this.svc.dispatch({
+                type: ActionTypes.SET_SELECTED_ASSETS,
+                payload: [],
+            });
+        }));
+        select((/**
+         * @param {?} state
+         * @return {?}
+         */
+        (state) => state.selectedAssets))
+            .pipe(takeUntil(this.unsubscribe$))
+            .subscribe((/**
+         * @param {?} selectedAssets
+         * @return {?}
+         */
+        (selectedAssets) => {
+            this.selectedAssets = selectedAssets;
+        }));
+        select((/**
+         * @param {?} state
+         * @return {?}
+         */
+        (state) => state.reloadCurrentAssets))
+            .pipe(takeUntil(this.unsubscribe$), switchMap((/**
+         * @param {?} res
+         * @return {?}
+         */
+        (res) => of(res))))
+            .subscribe((/**
+         * @return {?}
+         */
+        () => {
+            this.fetchChildrenAssets();
+        }));
+    }
+    /**
+     * @param {?=} event
+     * @return {?}
+     */
+    pageChange(event) {
+        this.assetService.pageSize = event.pageSize;
+        this.assetService.pageIndex = event.pageIndex;
+        this.fetchChildrenAssets();
+    }
+    /**
+     * @private
+     * @return {?}
+     */
+    fetchChildrenAssets() {
+        if (!this.currentFolderId) {
+            return;
+        }
+        this.svc.dispatch({
+            type: ActionTypes.SET_GLOBAL_LOADING,
+            payload: true,
+        });
+        this.assetService
+            .getChildrenAssets({ assetId: this.currentFolderId })
+            .pipe(takeUntil(this.unsubscribe$))
+            .subscribe((/**
+         * @param {?} res
+         * @return {?}
+         */
+        (res) => {
+            this.assetService.setAssetList(res.Data.Children, res.Meta);
+        }))
+            .add((/**
+         * @return {?}
+         */
+        () => {
+            this.svc.dispatch({
+                type: ActionTypes.SET_GLOBAL_LOADING,
+                payload: false,
+            });
+        }));
+    }
+    /**
+     * @return {?}
+     */
+    ngOnDestroy() {
+        this.unsubscribe$.next();
+        this.unsubscribe$.complete();
+    }
+}
+AssetListComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'lib-asset-list',
+                template: "<div class=\"asset-container\">\n  <div class=\"asset-heading\">\n    <h6 class=\"asset-heading__title\">Files</h6>\n    <lib-sort-items\n      [hidden]=\"!assets?.length\"\n      class=\"asset-heading__sort\"\n    ></lib-sort-items>\n  </div>\n  <ng-container *ngIf=\"assets && !assets.length; else assetsTemplate\">\n    <div class=\"asset-empty\">\n      <span>This asset is empty.</span>\n    </div>\n  </ng-container>\n  <ng-template #assetsTemplate>\n    <div class=\"asset-list\">\n      <lib-asset-item\n        class=\"asset-list__item\"\n        *ngFor=\"let asset of assets\"\n        [asset]=\"asset\"\n        (selectAsset)=\"onSelectAsset($event)\"\n      >\n      </lib-asset-item>\n    </div>\n  </ng-template>\n  <div [hidden]=\"!assets?.length\">\n    <mat-paginator\n      #paginator\n      [pageSizeOptions]=\"[12, 24, 60, 120]\"\n      (page)=\"pageChange($event)\"\n      [showFirstLastButtons]=\"true\"\n    >\n    </mat-paginator>\n  </div>\n</div>\n",
+                styles: [":host::ng-deep .asset-container .asset-heading{display:flex;justify-content:space-between;align-items:center;margin-bottom:.5rem}:host::ng-deep .asset-container .asset-heading__title{margin-bottom:0;color:#979797}:host::ng-deep .asset-container .asset-list{display:flex;flex-wrap:wrap;justify-content:flex-start;align-items:stretch;margin:0 -5px}:host::ng-deep .asset-container .asset-list__item{width:25%}@media only screen and (max-width:1200px){:host::ng-deep .asset-container .asset-list__item{width:calc(100% / 3)}}@media only screen and (max-width:960px){:host::ng-deep .asset-container .asset-list__item{width:50%}}:host::ng-deep .asset-container .asset-empty{text-align:center;color:#979797;font-size:14px}"]
+            }] }
+];
+/** @nocollapse */
+AssetListComponent.ctorParameters = () => [
+    { type: AssetService },
+    { type: AssetManagementService }
+];
+AssetListComponent.propDecorators = {
+    paginator: [{ type: ViewChild, args: [MatPaginator, { static: true },] }],
+    assets: [{ type: Input }]
+};
+if (false) {
+    /** @type {?} */
+    AssetListComponent.prototype.paginator;
+    /** @type {?} */
+    AssetListComponent.prototype.assets;
+    /**
+     * @type {?}
+     * @private
+     */
+    AssetListComponent.prototype.unsubscribe$;
+    /**
+     * @type {?}
+     * @private
+     */
+    AssetListComponent.prototype.currentFolderId;
+    /**
+     * @type {?}
+     * @private
+     */
+    AssetListComponent.prototype.selectedAssets;
+    /**
+     * @type {?}
+     * @private
+     */
+    AssetListComponent.prototype.assetService;
+    /**
+     * @type {?}
+     * @private
+     */
+    AssetListComponent.prototype.svc;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"asset-list.component.js","sourceRoot":"ng://@rs-pk/asset-management/","sources":["lib/components/partial/asset-list/asset-list.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Component,\n  Input,\n  OnChanges,\n  OnDestroy,\n  OnInit,\n  SimpleChanges,\n  ViewChild,\n} from '@angular/core';\nimport { MatPaginator, PageEvent } from '@angular/material/paginator';\nimport { of } from 'rxjs/internal/observable/of';\nimport { Subject } from 'rxjs/internal/Subject';\nimport { switchMap, takeUntil } from 'rxjs/operators';\nimport { AssetManagementService } from '../../../asset-management.service';\nimport { AssetModel } from '../../../models';\nimport { AssetService } from '../../../services/asset.service';\nimport { ActionTypes } from '../../../store/actions.action';\nimport { select } from '../../../store/reducer';\n\n@Component({\n  selector: 'lib-asset-list',\n  templateUrl: './asset-list.component.html',\n  styleUrls: ['./asset-list.component.scss'],\n})\nexport class AssetListComponent implements OnInit, OnChanges, OnDestroy {\n  constructor(\n    private assetService: AssetService,\n    private svc: AssetManagementService\n  ) {}\n\n  @ViewChild(MatPaginator, { static: true }) paginator: MatPaginator;\n  @Input() assets: AssetModel[];\n\n  private unsubscribe$ = new Subject<void>();\n  private currentFolderId: string;\n  private selectedAssets: Array<AssetModel> = [];\n\n  ngOnInit() {\n    this.bindSubscriber();\n  }\n\n  ngOnChanges(changes: SimpleChanges) {\n    if (changes.assets) {\n      this.paginator.pageIndex = this.assetService.pageIndex;\n      this.paginator.pageSize = this.assetService.pageSize;\n      this.paginator.length = this.assetService.fileTotal;\n    }\n  }\n\n  public onSelectAsset(event: AssetModel) {\n    const index = this.selectedAssets.findIndex(\n      (asset) => asset.AssetId === event.AssetId\n    );\n    const newSelectedAssets: AssetModel[] =\n      index > -1\n        ? this.selectedAssets.filter((asset, i) => index !== i)\n        : [...this.selectedAssets, event];\n\n    this.svc.dispatch({\n      type: ActionTypes.SET_SELECTED_ASSETS,\n      payload: newSelectedAssets,\n    });\n  }\n\n  private bindSubscriber() {\n    select((state) => state.deletedAssetId)\n      .pipe(takeUntil(this.unsubscribe$))\n      .subscribe((id) => {\n        if (this.selectedAssets && this.selectedAssets.length) {\n          const newSelectedAssets = this.selectedAssets.filter(\n            (asset) => asset.AssetId !== id\n          );\n          this.svc.dispatch({\n            type: ActionTypes.SET_SELECTED_ASSETS,\n            payload: newSelectedAssets,\n          });\n        }\n      });\n\n    select((state) => state.currentFolderId)\n      .pipe(takeUntil(this.unsubscribe$))\n      .subscribe((currentFolderId) => {\n        this.currentFolderId = currentFolderId;\n        this.svc.dispatch({\n          type: ActionTypes.SET_SELECTED_ASSETS,\n          payload: [],\n        });\n      });\n\n    select((state) => state.selectedAssets)\n      .pipe(takeUntil(this.unsubscribe$))\n      .subscribe((selectedAssets) => {\n        this.selectedAssets = selectedAssets;\n      });\n\n    select((state) => state.reloadCurrentAssets)\n      .pipe(\n        takeUntil(this.unsubscribe$),\n        switchMap((res) => of(res))\n      )\n      .subscribe(() => {\n        this.fetchChildrenAssets();\n      });\n  }\n\n  public pageChange(event?: PageEvent) {\n    this.assetService.pageSize = event.pageSize;\n    this.assetService.pageIndex = event.pageIndex;\n    this.fetchChildrenAssets();\n  }\n\n  private fetchChildrenAssets() {\n    if (!this.currentFolderId) {\n      return;\n    }\n    this.svc.dispatch({\n      type: ActionTypes.SET_GLOBAL_LOADING,\n      payload: true,\n    });\n\n    this.assetService\n      .getChildrenAssets({ assetId: this.currentFolderId })\n      .pipe(takeUntil(this.unsubscribe$))\n      .subscribe((res) => {\n        this.assetService.setAssetList(res.Data.Children, res.Meta);\n      })\n      .add(() => {\n        this.svc.dispatch({\n          type: ActionTypes.SET_GLOBAL_LOADING,\n          payload: false,\n        });\n      });\n  }\n\n  ngOnDestroy() {\n    this.unsubscribe$.next();\n    this.unsubscribe$.complete();\n  }\n}\n"]}

package/esm2015/lib/components/partial/asset-management-dialog/asset-management-dialog.component.js

@@ -0,0 +1,108 @@
+/**
+ * @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/dialog';
+import { Subject } from 'rxjs/internal/Subject';
+import { takeUntil } from 'rxjs/operators';
+import { DialogConfig } from '../../../models';
+import { AssetService } from '../../../services/asset.service';
+import { select } from '../../../store';
+export class AssetManagementDialogComponent {
+    /**
+     * @param {?} data
+     * @param {?} dialogRef
+     * @param {?} assetService
+     */
+    constructor(data, dialogRef, assetService) {
+        this.data = data;
+        this.dialogRef = dialogRef;
+        this.assetService = assetService;
+        this.destroy$ = new Subject();
+        this.selectedAssets = [];
+    }
+    /**
+     * @return {?}
+     */
+    ngOnInit() {
+        this.initDialogConfig(this.data);
+        select((/**
+         * @param {?} state
+         * @return {?}
+         */
+        (state) => state.selectedAssets))
+            .pipe(takeUntil(this.destroy$))
+            .subscribe((/**
+         * @param {?} selectedAssets
+         * @return {?}
+         */
+        (selectedAssets) => {
+            this.selectedAssets = selectedAssets;
+        }));
+    }
+    /**
+     * @return {?}
+     */
+    get disabled() {
+        const { limit } = this.data;
+        return ((!this.selectedAssets || !this.selectedAssets.length) ||
+            (limit && this.selectedAssets.length > limit));
+    }
+    /**
+     * @return {?}
+     */
+    selectAssets() {
+        this.dialogRef.close(this.selectedAssets);
+    }
+    /**
+     * @param {?} data
+     * @return {?}
+     */
+    initDialogConfig(data) {
+        if (!data) {
+            return;
+        }
+        this.assetService.dialogConfig = data;
+    }
+    /**
+     * @return {?}
+     */
+    ngOnDestroy() {
+        this.assetService.dialogConfig = new DialogConfig();
+        this.destroy$.next(true);
+        this.destroy$.complete();
+    }
+}
+AssetManagementDialogComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'lib-asset-management-dialog',
+                template: "<lib-modal heading=\"Asset management\" [customHeader]=\"true\">\n  <ng-container subtitle>\n    <lib-breadcrumb></lib-breadcrumb>\n  </ng-container>\n  <ng-container headerActions>\n    <lib-search-box></lib-search-box>\n  </ng-container>\n  <ng-container content>\n    <lib-asset-wrapper [header]=\"false\"></lib-asset-wrapper>\n  </ng-container>\n  <ng-container actions>\n    <div class=\"asset-management-dialog__footer\">\n      <div class=\"selected-assets\">\n        <ng-container *ngIf=\"data?.limit\">\n          <span>Selected{{' '}}</span>\n          <span class=\"count\" [ngClass]=\"{'error': selectedAssets?.length && disabled}\">\n            {{selectedAssets?.length}}/{{data?.limit}}\n          </span>\n          <span>\n            {{data?.limit > 1 ? \"assets\": \"asset\"}}\n          </span>\n        </ng-container>\n\n      </div>\n      <div>\n        <button mat-raised-button mat-dialog-close>Cancel</button>\n        <button mat-raised-button color=\"primary\" (click)=\"selectAssets()\" [disabled]=\"disabled\">Done</button>\n      </div>\n    </div>\n  </ng-container>\n</lib-modal>",
+                styles: [":host::ng-deep .asset-management-dialog__footer{display:flex;width:100%;align-items:center;justify-content:space-between}:host::ng-deep .asset-management-dialog__footer .selected-assets{font-size:14px;color:#979797}:host::ng-deep .asset-management-dialog__footer .selected-assets .count{color:#000}:host::ng-deep .asset-management-dialog__footer .selected-assets .error{color:#f44336}"]
+            }] }
+];
+/** @nocollapse */
+AssetManagementDialogComponent.ctorParameters = () => [
+    { type: DialogConfig, decorators: [{ type: Inject, args: [MAT_DIALOG_DATA,] }] },
+    { type: MatDialogRef },
+    { type: AssetService }
+];
+if (false) {
+    /**
+     * @type {?}
+     * @private
+     */
+    AssetManagementDialogComponent.prototype.destroy$;
+    /** @type {?} */
+    AssetManagementDialogComponent.prototype.selectedAssets;
+    /** @type {?} */
+    AssetManagementDialogComponent.prototype.data;
+    /** @type {?} */
+    AssetManagementDialogComponent.prototype.dialogRef;
+    /**
+     * @type {?}
+     * @private
+     */
+    AssetManagementDialogComponent.prototype.assetService;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/components/partial/asset-wrapper/asset-wrapper.component.js

@@ -0,0 +1,100 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { Component, EventEmitter, Input, Output, } from '@angular/core';
+import { Subject } from 'rxjs/internal/Subject';
+import { takeUntil } from 'rxjs/operators';
+import { AssetService } from '../../../services/asset.service';
+import { select } from '../../../store';
+export class AssetWrapperComponent {
+    /**
+     * @param {?} assetService
+     */
+    constructor(assetService) {
+        this.assetService = assetService;
+        this.header = true;
+        this.assets = new EventEmitter();
+        this.unsubscribe$ = new Subject();
+        this.nodeTreeMinWidth = 250;
+        this.nodeTreeMaxWidth = 700;
+    }
+    /**
+     * @return {?}
+     */
+    ngOnInit() {
+        this.nodeTreeWidth = this.nodeTreeMinWidth;
+        select((/**
+         * @param {?} state
+         * @return {?}
+         */
+        (state) => state.selectedAssets))
+            .pipe(takeUntil(this.unsubscribe$))
+            .subscribe((/**
+         * @param {?} selectedAssets
+         * @return {?}
+         */
+        (selectedAssets) => {
+            this.assets.emit(selectedAssets);
+        }));
+    }
+    /**
+     * @param {?} __0
+     * @return {?}
+     */
+    onResize({ width }) {
+        this.nodeTreeWidth = width;
+    }
+    /**
+     * @return {?}
+     */
+    get nodeDetailsWidth() {
+        return `calc(100% - ${this.nodeTreeWidth}px)`;
+    }
+    /**
+     * @return {?}
+     */
+    ngOnDestroy() {
+        this.assetService.resetAsset();
+        this.unsubscribe$.next();
+        this.unsubscribe$.complete();
+    }
+}
+AssetWrapperComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'lib-asset-wrapper',
+                template: "<div class=\"asset-wrapper\">\n  <div class=\"asset-header\" *ngIf=\"header\">\n    <div class=\"asset-header__left asset-header__title\" #title>\n      <lib-breadcrumb></lib-breadcrumb>\n    </div>\n    <div class=\"asset-header__right asset-header__actions\" #actions>\n      <lib-search-box></lib-search-box>\n    </div>\n  </div>\n  <div class=\"asset-body\">\n    <lib-drag-to-resize (resizeCompleted)=\"onResize($event)\" class=\"asset-body__node-tree\" [minWidth]=\"nodeTreeMinWidth\" [maxWidth]=\"nodeTreeMaxWidth\">\n      <lib-node-tree [width]=\"nodeTreeWidth\"></lib-node-tree>\n    </lib-drag-to-resize>\n    <lib-node-details class=\"asset-body__node-details\" [style.maxWidth]=\"nodeDetailsWidth\"></lib-node-details>\n  </div>\n</div>",
+                styles: [":host::ng-deep .mat-dialog-title{padding:24px}:host::ng-deep .mat-dialog-title .lib-modal--close{padding:10px;position:absolute;top:10px;right:10px;z-index:1}:host::ng-deep .mat-dialog-actions{padding-left:24px;padding-right:24px}:host::ng-deep .asset-wrapper{display:flex;flex-direction:column;height:100%;width:100%;overflow-x:hidden}:host::ng-deep .asset-wrapper .asset-header{display:flex;padding:20px 15px;border-bottom:1px solid #d8d8d8;justify-content:space-between;align-items:center}:host::ng-deep .asset-wrapper .asset-body{display:flex;align-items:stretch}:host::ng-deep .asset-wrapper .asset-body__node-tree{border-right:1px solid #d8d8d8}:host::ng-deep .asset-wrapper .asset-body__node-details{flex:1}@media screen and (max-width:768px){:host::ng-deep .asset-wrapper .asset-header{flex-direction:column;justify-content:flex-start;align-items:flex-start;gap:10px}:host::ng-deep .asset-wrapper .asset-body{flex-direction:column;justify-content:flex-start}:host::ng-deep .asset-wrapper .asset-body__node-tree{width:100%}:host::ng-deep .asset-wrapper .asset-body__node-details{max-width:100%!important}}::ng-deep .mat-tooltip.width-auto{max-width:100%!important}"]
+            }] }
+];
+/** @nocollapse */
+AssetWrapperComponent.ctorParameters = () => [
+    { type: AssetService }
+];
+AssetWrapperComponent.propDecorators = {
+    header: [{ type: Input }],
+    assets: [{ type: Output }]
+};
+if (false) {
+    /** @type {?} */
+    AssetWrapperComponent.prototype.header;
+    /** @type {?} */
+    AssetWrapperComponent.prototype.assets;
+    /**
+     * @type {?}
+     * @private
+     */
+    AssetWrapperComponent.prototype.unsubscribe$;
+    /** @type {?} */
+    AssetWrapperComponent.prototype.nodeTreeMinWidth;
+    /** @type {?} */
+    AssetWrapperComponent.prototype.nodeTreeMaxWidth;
+    /** @type {?} */
+    AssetWrapperComponent.prototype.nodeTreeWidth;
+    /**
+     * @type {?}
+     * @private
+     */
+    AssetWrapperComponent.prototype.assetService;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/components/partial/breadcrumb/breadcrumb.component.js

@@ -0,0 +1,115 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import * as tslib_1 from "tslib";
+import { Component } from '@angular/core';
+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 { NodeTreeService } from '../../../services/node-tree.service';
+import { ActionTypes, select } from '../../../store';
+export class BreadcrumbComponent {
+    /**
+     * @param {?} nodeTreeService
+     * @param {?} svc
+     */
+    constructor(nodeTreeService, svc) {
+        this.nodeTreeService = nodeTreeService;
+        this.svc = svc;
+        this.unsubscribe$ = new Subject();
+        this.currentFolderHierarchy = [];
+        this.maximumShownLevel = 3;
+        this.bindSubscriber();
+    }
+    /**
+     * @return {?}
+     */
+    ngOnInit() { }
+    /**
+     * @return {?}
+     */
+    ngOnDestroy() {
+        this.unsubscribe$.next();
+        this.unsubscribe$.complete();
+    }
+    /**
+     * @private
+     * @return {?}
+     */
+    bindSubscriber() {
+        select((/**
+         * @param {?} state
+         * @return {?}
+         */
+        (state) => state.currentFolderHierarchy))
+            .pipe(takeUntil(this.unsubscribe$), switchMap((/**
+         * @param {?} res
+         * @return {?}
+         */
+        (res) => of(res))))
+            .subscribe((/**
+         * @param {?} currentFolderHierarchy
+         * @return {?}
+         */
+        (currentFolderHierarchy) => {
+            this.currentFolderHierarchy = currentFolderHierarchy;
+        }));
+    }
+    /**
+     * @param {?} folder
+     * @return {?}
+     */
+    navigateToFolder(folder) {
+        this.svc.dispatch({
+            type: ActionTypes.SET_CURRENT_FOLDER_ID,
+            payload: folder.AssetId,
+        });
+    }
+    /**
+     * @return {?}
+     */
+    backToHome() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            yield this.nodeTreeService.initialData({ dispatchRootId: true });
+            this.svc.dispatch({
+                type: ActionTypes.RELOAD_CURRENT_NODE,
+            });
+        });
+    }
+}
+BreadcrumbComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'lib-breadcrumb',
+                template: "<nav class=\"breadcrumb-wrapper\">\n    <ul class=\"lib-breadcrumb\">\n        <li class=\"lib-breadcrumb__item\">\n            <span class=\"lib-breadcrumb__item--name\" (click)=\"backToHome()\">Home</span>\n        </li>\n        <ng-container *ngIf=\"currentFolderHierarchy.length <= maximumShownLevel\">\n            <li *ngFor=\"let folder of currentFolderHierarchy; let last = last\" class=\"lib-breadcrumb__item\">\n                <mat-icon class=\"lib-breadcrumb__item--icon\">navigate_next</mat-icon>\n                <span class=\"lib-breadcrumb__item--name\" (click)=\"navigateToFolder(folder)\" [ngClass]=\"{ 'current-item' : last }\">\n                    {{folder.OriginalFileName}}\n                </span>\n            </li>\n        </ng-container>\n        <ng-container *ngIf=\"currentFolderHierarchy.length> maximumShownLevel\">\n            <div class=\"lib-breadcrumb__item\">\n                <mat-icon class=\"lib-breadcrumb__item--icon\">navigate_next</mat-icon>\n                <span class=\"lib-breadcrumb__item--name\" [matMenuTriggerFor]=\"menu\">\n                    <mat-icon>more_horiz</mat-icon>\n                </span>\n            </div>\n\n            <li *ngFor=\"let folder of currentFolderHierarchy; let index= index; let last = last\" class=\"lib-breadcrumb__item\">\n                <ng-container *ngIf=\"index> currentFolderHierarchy.length -\n                    maximumShownLevel\">\n                    <mat-icon class=\"lib-breadcrumb__item--icon\">navigate_next</mat-icon>\n                    <span class=\"lib-breadcrumb__item--name\" (click)=\"navigateToFolder(folder)\" [ngClass]=\"{ 'current-item' : last }\">\n                        {{folder.OriginalFileName}}\n                    </span>\n                </ng-container>\n            </li>\n        </ng-container>\n\n    </ul>\n</nav>\n\n<mat-menu #menu=\"matMenu\">\n    <ng-container *ngFor=\"let folder of currentFolderHierarchy; let index=\n        index;\">\n        <button mat-menu-item *ngIf=\"index<= currentFolderHierarchy.length -\n            maximumShownLevel\" (click)=\"navigateToFolder(folder)\">\n            <mat-icon>navigate_next</mat-icon>\n            <span>{{folder.OriginalFileName}}</span>\n        </button>\n    </ng-container>\n</mat-menu>",
+                styles: [":host::ng-deep .breadcrumb-wrapper{color:#979797;background-color:#fff}:host::ng-deep .breadcrumb-wrapper .lib-breadcrumb{display:flex;align-items:center;margin:0;padding:0}:host::ng-deep .breadcrumb-wrapper .lib-breadcrumb__item{height:20px;display:flex;align-items:center;list-style:none}:host::ng-deep .breadcrumb-wrapper .lib-breadcrumb__item--icon{color:#c8c8c8;cursor:default}:host::ng-deep .breadcrumb-wrapper .lib-breadcrumb__item--name{display:block;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;max-width:150px;font-size:14px;padding:0;font-weight:400;cursor:pointer;transition:.3s;height:20px;line-height:20px}:host::ng-deep .breadcrumb-wrapper .lib-breadcrumb__item--name:hover{color:#000}:host::ng-deep .breadcrumb-wrapper .lib-breadcrumb__item--name .mat-icon{color:#979797;height:16px}:host::ng-deep .breadcrumb-wrapper .lib-breadcrumb__item--name .mat-icon:hover{color:#000}:host::ng-deep .breadcrumb-wrapper .lib-breadcrumb__item--name.current-item{cursor:default}:host::ng-deep .breadcrumb-wrapper .lib-breadcrumb__item--name.current-item:hover{color:#979797}"]
+            }] }
+];
+/** @nocollapse */
+BreadcrumbComponent.ctorParameters = () => [
+    { type: NodeTreeService },
+    { type: AssetManagementService }
+];
+if (false) {
+    /**
+     * @type {?}
+     * @private
+     */
+    BreadcrumbComponent.prototype.unsubscribe$;
+    /** @type {?} */
+    BreadcrumbComponent.prototype.currentFolderHierarchy;
+    /** @type {?} */
+    BreadcrumbComponent.prototype.maximumShownLevel;
+    /**
+     * @type {?}
+     * @private
+     */
+    BreadcrumbComponent.prototype.nodeTreeService;
+    /**
+     * @type {?}
+     * @private
+     */
+    BreadcrumbComponent.prototype.svc;
+}
+//# sourceMappingURL=data:application/json;base64,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