@alfresco/aca-content 4.0.0-A.2-9984

package/esm2020/lib/components/toolbar/document-display-mode/document-display-mode.component.mjs

@@ -0,0 +1,85 @@
+/*!
+ * @license
+ * Alfresco Example Content Application
+ *
+ * Copyright (C) 2005 - 2020 Alfresco Software Limited
+ *
+ * This file is part of the Alfresco Example Content Application.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail.  Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * The Alfresco Example Content Application is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * The Alfresco Example Content Application is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Alfresco. If not, see <http://www.gnu.org/licenses/>.
+ */
+import { Component, ViewEncapsulation } from '@angular/core';
+import { Store } from '@ngrx/store';
+import { ToggleDocumentDisplayMode, getDocumentDisplayMode } from '@alfresco/aca-shared/store';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngrx/store";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/material/button";
+import * as i4 from "@angular/material/icon";
+import * as i5 from "@ngx-translate/core";
+export class DocumentDisplayModeComponent {
+    constructor(store) {
+        this.store = store;
+        this.displayMode$ = store.select(getDocumentDisplayMode);
+    }
+    getTitle(displayMode) {
+        return displayMode === 'list' ? 'APP.ACTIONS.LIST_MODE' : 'APP.ACTIONS.GALLERY_MODE';
+    }
+    onClick() {
+        this.store.dispatch(new ToggleDocumentDisplayMode());
+    }
+}
+DocumentDisplayModeComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: DocumentDisplayModeComponent, deps: [{ token: i1.Store }], target: i0.ɵɵFactoryTarget.Component });
+DocumentDisplayModeComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.1.2", type: DocumentDisplayModeComponent, selector: "app-document-display-mode", host: { classAttribute: "app-document-display-mode" }, ngImport: i0, template: `
+    <ng-container *ngIf="displayMode$ | async as displayMode">
+      <button
+        id="app-document-display-mode-button"
+        [attr.title]="getTitle(displayMode) | translate"
+        [attr.aria-label]="getTitle(displayMode) | translate"
+        mat-icon-button
+        color="primary"
+        (click)="onClick()"
+      >
+        <mat-icon *ngIf="displayMode === 'list'">view_comfy</mat-icon>
+        <mat-icon *ngIf="displayMode === 'gallery'">list</mat-icon>
+      </button>
+    </ng-container>
+  `, isInline: true, dependencies: [{ kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i3.MatButton, selector: "button[mat-button], button[mat-raised-button], button[mat-icon-button],             button[mat-fab], button[mat-mini-fab], button[mat-stroked-button],             button[mat-flat-button]", inputs: ["disabled", "disableRipple", "color"], exportAs: ["matButton"] }, { kind: "component", type: i4.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "pipe", type: i2.AsyncPipe, name: "async" }, { kind: "pipe", type: i5.TranslatePipe, name: "translate" }], encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: DocumentDisplayModeComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'app-document-display-mode',
+                    template: `
+    <ng-container *ngIf="displayMode$ | async as displayMode">
+      <button
+        id="app-document-display-mode-button"
+        [attr.title]="getTitle(displayMode) | translate"
+        [attr.aria-label]="getTitle(displayMode) | translate"
+        mat-icon-button
+        color="primary"
+        (click)="onClick()"
+      >
+        <mat-icon *ngIf="displayMode === 'list'">view_comfy</mat-icon>
+        <mat-icon *ngIf="displayMode === 'gallery'">list</mat-icon>
+      </button>
+    </ng-container>
+  `,
+                    encapsulation: ViewEncapsulation.None,
+                    host: { class: 'app-document-display-mode' }
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Store }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/components/toolbar/toggle-edit-offline/toggle-edit-offline.component.mjs

@@ -0,0 +1,151 @@
+/*!
+ * @license
+ * Alfresco Example Content Application
+ *
+ * Copyright (C) 2005 - 2020 Alfresco Software Limited
+ *
+ * This file is part of the Alfresco Example Content Application.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail.  Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * The Alfresco Example Content Application is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * The Alfresco Example Content Application is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Alfresco. If not, see <http://www.gnu.org/licenses/>.
+ */
+import { DownloadNodesAction, EditOfflineAction, SnackbarErrorAction, getAppSelection } from '@alfresco/aca-shared/store';
+import { NodesApi } from '@alfresco/js-api';
+import { Component, ViewEncapsulation } from '@angular/core';
+import { Store } from '@ngrx/store';
+import { isLocked } from '@alfresco/aca-shared';
+import { AlfrescoApiService } from '@alfresco/adf-core';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngrx/store";
+import * as i2 from "@alfresco/adf-core";
+import * as i3 from "@angular/common";
+import * as i4 from "@angular/material/icon";
+import * as i5 from "@angular/material/menu";
+import * as i6 from "@ngx-translate/core";
+export class ToggleEditOfflineComponent {
+    constructor(store, alfrescoApiService) {
+        this.store = store;
+        this.alfrescoApiService = alfrescoApiService;
+        this.nodesApi = new NodesApi(this.alfrescoApiService.getInstance());
+    }
+    ngOnInit() {
+        this.store.select(getAppSelection).subscribe(({ file }) => {
+            this.selection = file;
+        });
+    }
+    get isNodeLocked() {
+        return !!(this.selection && isLocked(this.selection));
+    }
+    async onClick() {
+        await this.toggleLock(this.selection);
+    }
+    async toggleLock(node) {
+        const id = node.entry.nodeId || node.entry.id;
+        if (isLocked(this.selection)) {
+            try {
+                const response = await this.unlockNode(id);
+                this.update(response?.entry);
+                this.store.dispatch(new EditOfflineAction(this.selection));
+            }
+            catch {
+                this.onUnlockError();
+            }
+        }
+        else {
+            try {
+                const response = await this.lockNode(id);
+                this.update(response?.entry);
+                this.store.dispatch(new DownloadNodesAction([this.selection]));
+                this.store.dispatch(new EditOfflineAction(this.selection));
+            }
+            catch {
+                this.onLockError();
+            }
+        }
+    }
+    onLockError() {
+        this.store.dispatch(new SnackbarErrorAction('APP.MESSAGES.ERRORS.LOCK_NODE', {
+            fileName: this.selection.entry.name
+        }));
+    }
+    onUnlockError() {
+        this.store.dispatch(new SnackbarErrorAction('APP.MESSAGES.ERRORS.UNLOCK_NODE', {
+            fileName: this.selection.entry.name
+        }));
+    }
+    lockNode(nodeId) {
+        return this.nodesApi.lockNode(nodeId, {
+            type: 'ALLOW_OWNER_CHANGES',
+            lifetime: 'PERSISTENT'
+        });
+    }
+    unlockNode(nodeId) {
+        return this.nodesApi.unlockNode(nodeId);
+    }
+    update(data) {
+        if (data && data.properties) {
+            const properties = this.selection.entry.properties || {};
+            properties['cm:lockLifetime'] = data.properties['cm:lockLifetime'];
+            properties['cm:lockOwner'] = data.properties['cm:lockOwner'];
+            properties['cm:lockType'] = data.properties['cm:lockType'];
+            this.selection.entry.properties = properties;
+        }
+    }
+}
+ToggleEditOfflineComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: ToggleEditOfflineComponent, deps: [{ token: i1.Store }, { token: i2.AlfrescoApiService }], target: i0.ɵɵFactoryTarget.Component });
+ToggleEditOfflineComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.1.2", type: ToggleEditOfflineComponent, selector: "app-toggle-edit-offline", host: { classAttribute: "app-toggle-edit-offline" }, ngImport: i0, template: `
+    <button
+      mat-menu-item
+      [attr.title]="(isNodeLocked ? 'APP.ACTIONS.EDIT_OFFLINE_CANCEL' : 'APP.ACTIONS.EDIT_OFFLINE') | translate"
+      (click)="onClick()"
+    >
+      <ng-container *ngIf="isNodeLocked">
+        <mat-icon>cancel</mat-icon>
+        <span>{{ 'APP.ACTIONS.EDIT_OFFLINE_CANCEL' | translate }}</span>
+      </ng-container>
+
+      <ng-container *ngIf="!isNodeLocked">
+        <mat-icon>edit</mat-icon>
+        <span>{{ 'APP.ACTIONS.EDIT_OFFLINE' | translate }}</span>
+      </ng-container>
+    </button>
+  `, isInline: true, dependencies: [{ kind: "directive", type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i4.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "component", type: i5.MatMenuItem, selector: "[mat-menu-item]", inputs: ["disabled", "disableRipple", "role"], exportAs: ["matMenuItem"] }, { kind: "pipe", type: i6.TranslatePipe, name: "translate" }], encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: ToggleEditOfflineComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'app-toggle-edit-offline',
+                    template: `
+    <button
+      mat-menu-item
+      [attr.title]="(isNodeLocked ? 'APP.ACTIONS.EDIT_OFFLINE_CANCEL' : 'APP.ACTIONS.EDIT_OFFLINE') | translate"
+      (click)="onClick()"
+    >
+      <ng-container *ngIf="isNodeLocked">
+        <mat-icon>cancel</mat-icon>
+        <span>{{ 'APP.ACTIONS.EDIT_OFFLINE_CANCEL' | translate }}</span>
+      </ng-container>
+
+      <ng-container *ngIf="!isNodeLocked">
+        <mat-icon>edit</mat-icon>
+        <span>{{ 'APP.ACTIONS.EDIT_OFFLINE' | translate }}</span>
+      </ng-container>
+    </button>
+  `,
+                    encapsulation: ViewEncapsulation.None,
+                    host: { class: 'app-toggle-edit-offline' }
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Store }, { type: i2.AlfrescoApiService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"toggle-edit-offline.component.js","sourceRoot":"","sources":["../../../../../../../../projects/aca-content/src/lib/components/toolbar/toggle-edit-offline/toggle-edit-offline.component.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,EAAY,mBAAmB,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AACpI,OAAO,EAAuD,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AACjG,OAAO,EAAE,SAAS,EAAU,iBAAiB,EAAE,MAAM,eAAe,CAAC;AACrE,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAChD,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;;;;;;;;AAwBxD,MAAM,OAAO,0BAA0B;IAIrC,YAAoB,KAAsB,EAAU,kBAAsC;QAAtE,UAAK,GAAL,KAAK,CAAiB;QAAU,uBAAkB,GAAlB,kBAAkB,CAAoB;QACxF,IAAI,CAAC,QAAQ,GAAG,IAAI,QAAQ,CAAC,IAAI,CAAC,kBAAkB,CAAC,WAAW,EAAE,CAAC,CAAC;IACtE,CAAC;IAED,QAAQ;QACN,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,eAAe,CAAC,CAAC,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE;YACxD,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;QACxB,CAAC,CAAC,CAAC;IACL,CAAC;IAED,IAAI,YAAY;QACd,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,IAAI,QAAQ,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC;IACxD,CAAC;IAED,KAAK,CAAC,OAAO;QACX,MAAM,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;IACxC,CAAC;IAEO,KAAK,CAAC,UAAU,CAAC,IAAiC;QACxD,MAAM,EAAE,GAAI,IAAwB,CAAC,KAAK,CAAC,MAAM,IAAI,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;QAEnE,IAAI,QAAQ,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE;YAC5B,IAAI;gBACF,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC;gBAE3C,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;gBAC7B,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,iBAAiB,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC;aAC5D;YAAC,MAAM;gBACN,IAAI,CAAC,aAAa,EAAE,CAAC;aACtB;SACF;aAAM;YACL,IAAI;gBACF,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;gBAEzC,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;gBAC7B,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,mBAAmB,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;gBAC/D,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,iBAAiB,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC;aAC5D;YAAC,MAAM;gBACN,IAAI,CAAC,WAAW,EAAE,CAAC;aACpB;SACF;IACH,CAAC;IAED,WAAW;QACT,IAAI,CAAC,KAAK,CAAC,QAAQ,CACjB,IAAI,mBAAmB,CAAC,+BAA+B,EAAE;YACvD,QAAQ,EAAE,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI;SACpC,CAAC,CACH,CAAC;IACJ,CAAC;IAED,aAAa;QACX,IAAI,CAAC,KAAK,CAAC,QAAQ,CACjB,IAAI,mBAAmB,CAAC,iCAAiC,EAAE;YACzD,QAAQ,EAAE,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI;SACpC,CAAC,CACH,CAAC;IACJ,CAAC;IAED,QAAQ,CAAC,MAAc;QACrB,OAAO,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,MAAM,EAAE;YACpC,IAAI,EAAE,qBAAqB;YAC3B,QAAQ,EAAE,YAAY;SACvB,CAAC,CAAC;IACL,CAAC;IAED,UAAU,CAAC,MAAc;QACvB,OAAO,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;IAC1C,CAAC;IAEO,MAAM,CAAC,IAAU;QACvB,IAAI,IAAI,IAAI,IAAI,CAAC,UAAU,EAAE;YAC3B,MAAM,UAAU,GAAG,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,UAAU,IAAI,EAAE,CAAC;YAEzD,UAAU,CAAC,iBAAiB,CAAC,GAAG,IAAI,CAAC,UAAU,CAAC,iBAAiB,CAAC,CAAC;YACnE,UAAU,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,UAAU,CAAC,cAAc,CAAC,CAAC;YAC7D,UAAU,CAAC,aAAa,CAAC,GAAG,IAAI,CAAC,UAAU,CAAC,aAAa,CAAC,CAAC;YAE3D,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,UAAU,GAAG,UAAU,CAAC;SAC9C;IACH,CAAC;;uHApFU,0BAA0B;2GAA1B,0BAA0B,oHApB3B;;;;;;;;;;;;;;;;GAgBT;2FAIU,0BAA0B;kBAtBtC,SAAS;mBAAC;oBACT,QAAQ,EAAE,yBAAyB;oBACnC,QAAQ,EAAE;;;;;;;;;;;;;;;;GAgBT;oBACD,aAAa,EAAE,iBAAiB,CAAC,IAAI;oBACrC,IAAI,EAAE,EAAE,KAAK,EAAE,yBAAyB,EAAE;iBAC3C","sourcesContent":["/*!\n * @license\n * Alfresco Example Content Application\n *\n * Copyright (C) 2005 - 2020 Alfresco Software Limited\n *\n * This file is part of the Alfresco Example Content Application.\n * If the software was purchased under a paid Alfresco license, the terms of\n * the paid license agreement will prevail.  Otherwise, the software is\n * provided under the following open source license terms:\n *\n * The Alfresco Example Content Application is free software: you can redistribute it and/or modify\n * it under the terms of the GNU Lesser General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * The Alfresco Example Content Application is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * along with Alfresco. If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport { AppStore, DownloadNodesAction, EditOfflineAction, SnackbarErrorAction, getAppSelection } from '@alfresco/aca-shared/store';\nimport { MinimalNodeEntity, NodeEntry, SharedLinkEntry, Node, NodesApi } from '@alfresco/js-api';\nimport { Component, OnInit, ViewEncapsulation } from '@angular/core';\nimport { Store } from '@ngrx/store';\nimport { isLocked } from '@alfresco/aca-shared';\nimport { AlfrescoApiService } from '@alfresco/adf-core';\n\n@Component({\n  selector: 'app-toggle-edit-offline',\n  template: `\n    <button\n      mat-menu-item\n      [attr.title]=\"(isNodeLocked ? 'APP.ACTIONS.EDIT_OFFLINE_CANCEL' : 'APP.ACTIONS.EDIT_OFFLINE') | translate\"\n      (click)=\"onClick()\"\n    >\n      <ng-container *ngIf=\"isNodeLocked\">\n        <mat-icon>cancel</mat-icon>\n        <span>{{ 'APP.ACTIONS.EDIT_OFFLINE_CANCEL' | translate }}</span>\n      </ng-container>\n\n      <ng-container *ngIf=\"!isNodeLocked\">\n        <mat-icon>edit</mat-icon>\n        <span>{{ 'APP.ACTIONS.EDIT_OFFLINE' | translate }}</span>\n      </ng-container>\n    </button>\n  `,\n  encapsulation: ViewEncapsulation.None,\n  host: { class: 'app-toggle-edit-offline' }\n})\nexport class ToggleEditOfflineComponent implements OnInit {\n  private nodesApi: NodesApi;\n  selection: MinimalNodeEntity;\n\n  constructor(private store: Store<AppStore>, private alfrescoApiService: AlfrescoApiService) {\n    this.nodesApi = new NodesApi(this.alfrescoApiService.getInstance());\n  }\n\n  ngOnInit() {\n    this.store.select(getAppSelection).subscribe(({ file }) => {\n      this.selection = file;\n    });\n  }\n\n  get isNodeLocked(): boolean {\n    return !!(this.selection && isLocked(this.selection));\n  }\n\n  async onClick() {\n    await this.toggleLock(this.selection);\n  }\n\n  private async toggleLock(node: NodeEntry | SharedLinkEntry) {\n    const id = (node as SharedLinkEntry).entry.nodeId || node.entry.id;\n\n    if (isLocked(this.selection)) {\n      try {\n        const response = await this.unlockNode(id);\n\n        this.update(response?.entry);\n        this.store.dispatch(new EditOfflineAction(this.selection));\n      } catch {\n        this.onUnlockError();\n      }\n    } else {\n      try {\n        const response = await this.lockNode(id);\n\n        this.update(response?.entry);\n        this.store.dispatch(new DownloadNodesAction([this.selection]));\n        this.store.dispatch(new EditOfflineAction(this.selection));\n      } catch {\n        this.onLockError();\n      }\n    }\n  }\n\n  onLockError() {\n    this.store.dispatch(\n      new SnackbarErrorAction('APP.MESSAGES.ERRORS.LOCK_NODE', {\n        fileName: this.selection.entry.name\n      })\n    );\n  }\n\n  onUnlockError() {\n    this.store.dispatch(\n      new SnackbarErrorAction('APP.MESSAGES.ERRORS.UNLOCK_NODE', {\n        fileName: this.selection.entry.name\n      })\n    );\n  }\n\n  lockNode(nodeId: string) {\n    return this.nodesApi.lockNode(nodeId, {\n      type: 'ALLOW_OWNER_CHANGES',\n      lifetime: 'PERSISTENT'\n    });\n  }\n\n  unlockNode(nodeId: string) {\n    return this.nodesApi.unlockNode(nodeId);\n  }\n\n  private update(data: Node) {\n    if (data && data.properties) {\n      const properties = this.selection.entry.properties || {};\n\n      properties['cm:lockLifetime'] = data.properties['cm:lockLifetime'];\n      properties['cm:lockOwner'] = data.properties['cm:lockOwner'];\n      properties['cm:lockType'] = data.properties['cm:lockType'];\n\n      this.selection.entry.properties = properties;\n    }\n  }\n}\n"]}

package/esm2020/lib/components/toolbar/toggle-favorite/toggle-favorite.component.mjs

@@ -0,0 +1,80 @@
+/*!
+ * @license
+ * Alfresco Example Content Application
+ *
+ * Copyright (C) 2005 - 2020 Alfresco Software Limited
+ *
+ * This file is part of the Alfresco Example Content Application.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail.  Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * The Alfresco Example Content Application is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * The Alfresco Example Content Application is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Alfresco. If not, see <http://www.gnu.org/licenses/>.
+ */
+import { Component, ViewEncapsulation, Input } from '@angular/core';
+import { Store } from '@ngrx/store';
+import { ReloadDocumentListAction, getAppSelection } from '@alfresco/aca-shared/store';
+import { Router } from '@angular/router';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngrx/store";
+import * as i2 from "@angular/router";
+import * as i3 from "@angular/common";
+import * as i4 from "@angular/material/icon";
+import * as i5 from "@angular/material/menu";
+import * as i6 from "@alfresco/adf-content-services";
+import * as i7 from "@ngx-translate/core";
+export class ToggleFavoriteComponent {
+    constructor(store, router) {
+        this.store = store;
+        this.router = router;
+        this.reloadOnRoutes = [];
+        this.selection$ = this.store.select(getAppSelection);
+    }
+    ngOnInit() {
+        if (this.data) {
+            this.reloadOnRoutes = JSON.parse(this.data.replace(/'/g, '"'));
+        }
+    }
+    onToggleEvent() {
+        if (this.reloadOnRoutes.includes(this.router.url)) {
+            this.store.dispatch(new ReloadDocumentListAction());
+        }
+    }
+}
+ToggleFavoriteComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: ToggleFavoriteComponent, deps: [{ token: i1.Store }, { token: i2.Router }], target: i0.ɵɵFactoryTarget.Component });
+ToggleFavoriteComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.1.2", type: ToggleFavoriteComponent, selector: "app-toggle-favorite", inputs: { data: "data" }, host: { classAttribute: "app-toggle-favorite" }, ngImport: i0, template: `
+    <button mat-menu-item #favorites="adfFavorite" (toggle)="onToggleEvent()" [adf-node-favorite]="(selection$ | async).nodes">
+      <mat-icon *ngIf="favorites.hasFavorites()">star</mat-icon>
+      <mat-icon *ngIf="!favorites.hasFavorites()">star_border</mat-icon>
+      <span>{{ (favorites.hasFavorites() ? 'APP.ACTIONS.REMOVE_FAVORITE' : 'APP.ACTIONS.FAVORITE') | translate }}</span>
+    </button>
+  `, isInline: true, dependencies: [{ kind: "directive", type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i4.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "component", type: i5.MatMenuItem, selector: "[mat-menu-item]", inputs: ["disabled", "disableRipple", "role"], exportAs: ["matMenuItem"] }, { kind: "directive", type: i6.NodeFavoriteDirective, selector: "[adf-node-favorite]", inputs: ["adf-node-favorite"], outputs: ["toggle", "error"], exportAs: ["adfFavorite"] }, { kind: "pipe", type: i3.AsyncPipe, name: "async" }, { kind: "pipe", type: i7.TranslatePipe, name: "translate" }], encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: ToggleFavoriteComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'app-toggle-favorite',
+                    template: `
+    <button mat-menu-item #favorites="adfFavorite" (toggle)="onToggleEvent()" [adf-node-favorite]="(selection$ | async).nodes">
+      <mat-icon *ngIf="favorites.hasFavorites()">star</mat-icon>
+      <mat-icon *ngIf="!favorites.hasFavorites()">star_border</mat-icon>
+      <span>{{ (favorites.hasFavorites() ? 'APP.ACTIONS.REMOVE_FAVORITE' : 'APP.ACTIONS.FAVORITE') | translate }}</span>
+    </button>
+  `,
+                    encapsulation: ViewEncapsulation.None,
+                    host: { class: 'app-toggle-favorite' }
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Store }, { type: i2.Router }]; }, propDecorators: { data: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9nZ2xlLWZhdm9yaXRlLmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2FjYS1jb250ZW50L3NyYy9saWIvY29tcG9uZW50cy90b29sYmFyL3RvZ2dsZS1mYXZvcml0ZS90b2dnbGUtZmF2b3JpdGUuY29tcG9uZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztHQXVCRztBQUVILE9BQU8sRUFBRSxTQUFTLEVBQUUsaUJBQWlCLEVBQVUsS0FBSyxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQzVFLE9BQU8sRUFBRSxLQUFLLEVBQUUsTUFBTSxhQUFhLENBQUM7QUFHcEMsT0FBTyxFQUFZLHdCQUF3QixFQUFFLGVBQWUsRUFBRSxNQUFNLDRCQUE0QixDQUFDO0FBQ2pHLE9BQU8sRUFBRSxNQUFNLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQzs7Ozs7Ozs7O0FBY3pDLE1BQU0sT0FBTyx1QkFBdUI7SUFLbEMsWUFBb0IsS0FBc0IsRUFBVSxNQUFjO1FBQTlDLFVBQUssR0FBTCxLQUFLLENBQWlCO1FBQVUsV0FBTSxHQUFOLE1BQU0sQ0FBUTtRQUYxRCxtQkFBYyxHQUFhLEVBQUUsQ0FBQztRQUdwQyxJQUFJLENBQUMsVUFBVSxHQUFHLElBQUksQ0FBQyxLQUFLLENBQUMsTUFBTSxDQUFDLGVBQWUsQ0FBQyxDQUFDO0lBQ3ZELENBQUM7SUFFRCxRQUFRO1FBQ04sSUFBSSxJQUFJLENBQUMsSUFBSSxFQUFFO1lBQ2IsSUFBSSxDQUFDLGNBQWMsR0FBRyxJQUFJLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLElBQUksRUFBRSxHQUFHLENBQUMsQ0FBQyxDQUFDO1NBQ2hFO0lBQ0gsQ0FBQztJQUVELGFBQWE7UUFDWCxJQUFJLElBQUksQ0FBQyxjQUFjLENBQUMsUUFBUSxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsR0FBRyxDQUFDLEVBQUU7WUFDakQsSUFBSSxDQUFDLEtBQUssQ0FBQyxRQUFRLENBQUMsSUFBSSx3QkFBd0IsRUFBRSxDQUFDLENBQUM7U0FDckQ7SUFDSCxDQUFDOztvSEFuQlUsdUJBQXVCO3dHQUF2Qix1QkFBdUIsc0lBVnhCOzs7Ozs7R0FNVDsyRkFJVSx1QkFBdUI7a0JBWm5DLFNBQVM7bUJBQUM7b0JBQ1QsUUFBUSxFQUFFLHFCQUFxQjtvQkFDL0IsUUFBUSxFQUFFOzs7Ozs7R0FNVDtvQkFDRCxhQUFhLEVBQUUsaUJBQWlCLENBQUMsSUFBSTtvQkFDckMsSUFBSSxFQUFFLEVBQUUsS0FBSyxFQUFFLHFCQUFxQixFQUFFO2lCQUN2QztpSEFFVSxJQUFJO3NCQUFaLEtBQUsiLCJzb3VyY2VzQ29udGVudCI6WyIvKiFcbiAqIEBsaWNlbnNlXG4gKiBBbGZyZXNjbyBFeGFtcGxlIENvbnRlbnQgQXBwbGljYXRpb25cbiAqXG4gKiBDb3B5cmlnaHQgKEMpIDIwMDUgLSAyMDIwIEFsZnJlc2NvIFNvZnR3YXJlIExpbWl0ZWRcbiAqXG4gKiBUaGlzIGZpbGUgaXMgcGFydCBvZiB0aGUgQWxmcmVzY28gRXhhbXBsZSBDb250ZW50IEFwcGxpY2F0aW9uLlxuICogSWYgdGhlIHNvZnR3YXJlIHdhcyBwdXJjaGFzZWQgdW5kZXIgYSBwYWlkIEFsZnJlc2NvIGxpY2Vuc2UsIHRoZSB0ZXJtcyBvZlxuICogdGhlIHBhaWQgbGljZW5zZSBhZ3JlZW1lbnQgd2lsbCBwcmV2YWlsLiAgT3RoZXJ3aXNlLCB0aGUgc29mdHdhcmUgaXNcbiAqIHByb3ZpZGVkIHVuZGVyIHRoZSBmb2xsb3dpbmcgb3BlbiBzb3VyY2UgbGljZW5zZSB0ZXJtczpcbiAqXG4gKiBUaGUgQWxmcmVzY28gRXhhbXBsZSBDb250ZW50IEFwcGxpY2F0aW9uIGlzIGZyZWUgc29mdHdhcmU6IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnlcbiAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieVxuICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgZWl0aGVyIHZlcnNpb24gMyBvZiB0aGUgTGljZW5zZSwgb3JcbiAqIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uXG4gKlxuICogVGhlIEFsZnJlc2NvIEV4YW1wbGUgQ29udGVudCBBcHBsaWNhdGlvbiBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLFxuICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2ZcbiAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGVcbiAqIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLlxuICpcbiAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMgTGljZW5zZVxuICogYWxvbmcgd2l0aCBBbGZyZXNjby4gSWYgbm90LCBzZWUgPGh0dHA6Ly93d3cuZ251Lm9yZy9saWNlbnNlcy8+LlxuICovXG5cbmltcG9ydCB7IENvbXBvbmVudCwgVmlld0VuY2Fwc3VsYXRpb24sIE9uSW5pdCwgSW5wdXQgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IFN0b3JlIH0gZnJvbSAnQG5ncngvc3RvcmUnO1xuaW1wb3J0IHsgT2JzZXJ2YWJsZSB9IGZyb20gJ3J4anMnO1xuaW1wb3J0IHsgU2VsZWN0aW9uU3RhdGUgfSBmcm9tICdAYWxmcmVzY28vYWRmLWV4dGVuc2lvbnMnO1xuaW1wb3J0IHsgQXBwU3RvcmUsIFJlbG9hZERvY3VtZW50TGlzdEFjdGlvbiwgZ2V0QXBwU2VsZWN0aW9uIH0gZnJvbSAnQGFsZnJlc2NvL2FjYS1zaGFyZWQvc3RvcmUnO1xuaW1wb3J0IHsgUm91dGVyIH0gZnJvbSAnQGFuZ3VsYXIvcm91dGVyJztcblxuQENvbXBvbmVudCh7XG4gIHNlbGVjdG9yOiAnYXBwLXRvZ2dsZS1mYXZvcml0ZScsXG4gIHRlbXBsYXRlOiBgXG4gICAgPGJ1dHRvbiBtYXQtbWVudS1pdGVtICNmYXZvcml0ZXM9XCJhZGZGYXZvcml0ZVwiICh0b2dnbGUpPVwib25Ub2dnbGVFdmVudCgpXCIgW2FkZi1ub2RlLWZhdm9yaXRlXT1cIihzZWxlY3Rpb24kIHwgYXN5bmMpLm5vZGVzXCI+XG4gICAgICA8bWF0LWljb24gKm5nSWY9XCJmYXZvcml0ZXMuaGFzRmF2b3JpdGVzKClcIj5zdGFyPC9tYXQtaWNvbj5cbiAgICAgIDxtYXQtaWNvbiAqbmdJZj1cIiFmYXZvcml0ZXMuaGFzRmF2b3JpdGVzKClcIj5zdGFyX2JvcmRlcjwvbWF0LWljb24+XG4gICAgICA8c3Bhbj57eyAoZmF2b3JpdGVzLmhhc0Zhdm9yaXRlcygpID8gJ0FQUC5BQ1RJT05TLlJFTU9WRV9GQVZPUklURScgOiAnQVBQLkFDVElPTlMuRkFWT1JJVEUnKSB8IHRyYW5zbGF0ZSB9fTwvc3Bhbj5cbiAgICA8L2J1dHRvbj5cbiAgYCxcbiAgZW5jYXBzdWxhdGlvbjogVmlld0VuY2Fwc3VsYXRpb24uTm9uZSxcbiAgaG9zdDogeyBjbGFzczogJ2FwcC10b2dnbGUtZmF2b3JpdGUnIH1cbn0pXG5leHBvcnQgY2xhc3MgVG9nZ2xlRmF2b3JpdGVDb21wb25lbnQgaW1wbGVtZW50cyBPbkluaXQge1xuICBASW5wdXQoKSBkYXRhOiBhbnk7XG4gIHNlbGVjdGlvbiQ6IE9ic2VydmFibGU8U2VsZWN0aW9uU3RhdGU+O1xuICBwcml2YXRlIHJlbG9hZE9uUm91dGVzOiBzdHJpbmdbXSA9IFtdO1xuXG4gIGNvbnN0cnVjdG9yKHByaXZhdGUgc3RvcmU6IFN0b3JlPEFwcFN0b3JlPiwgcHJpdmF0ZSByb3V0ZXI6IFJvdXRlcikge1xuICAgIHRoaXMuc2VsZWN0aW9uJCA9IHRoaXMuc3RvcmUuc2VsZWN0KGdldEFwcFNlbGVjdGlvbik7XG4gIH1cblxuICBuZ09uSW5pdCgpIHtcbiAgICBpZiAodGhpcy5kYXRhKSB7XG4gICAgICB0aGlzLnJlbG9hZE9uUm91dGVzID0gSlNPTi5wYXJzZSh0aGlzLmRhdGEucmVwbGFjZSgvJy9nLCAnXCInKSk7XG4gICAgfVxuICB9XG5cbiAgb25Ub2dnbGVFdmVudCgpIHtcbiAgICBpZiAodGhpcy5yZWxvYWRPblJvdXRlcy5pbmNsdWRlcyh0aGlzLnJvdXRlci51cmwpKSB7XG4gICAgICB0aGlzLnN0b3JlLmRpc3BhdGNoKG5ldyBSZWxvYWREb2N1bWVudExpc3RBY3Rpb24oKSk7XG4gICAgfVxuICB9XG59XG4iXX0=

package/esm2020/lib/components/toolbar/toggle-favorite-library/toggle-favorite-library.component.mjs

@@ -0,0 +1,102 @@
+/*!
+ * @license
+ * Alfresco Example Content Application
+ *
+ * Copyright (C) 2005 - 2020 Alfresco Software Limited
+ *
+ * This file is part of the Alfresco Example Content Application.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail.  Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * The Alfresco Example Content Application is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * The Alfresco Example Content Application is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Alfresco. If not, see <http://www.gnu.org/licenses/>.
+ */
+import { Component, ViewEncapsulation } from '@angular/core';
+import { Store } from '@ngrx/store';
+import { AppHookService } from '@alfresco/aca-shared';
+import { getAppSelection } from '@alfresco/aca-shared/store';
+import { distinctUntilChanged, takeUntil } from 'rxjs/operators';
+import { Router } from '@angular/router';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngrx/store";
+import * as i2 from "@alfresco/aca-shared";
+import * as i3 from "@angular/router";
+import * as i4 from "@angular/common";
+import * as i5 from "@angular/material/icon";
+import * as i6 from "@angular/material/menu";
+import * as i7 from "@alfresco/adf-content-services";
+import * as i8 from "@ngx-translate/core";
+export class ToggleFavoriteLibraryComponent {
+    constructor(store, appHookService, router) {
+        this.store = store;
+        this.appHookService = appHookService;
+        this.router = router;
+        this.onDestroy$ = new Subject();
+    }
+    ngOnInit() {
+        const isFavoriteLibraries = this.router.url.startsWith('/favorite/libraries');
+        this.store
+            .select(getAppSelection)
+            .pipe(distinctUntilChanged(), takeUntil(this.onDestroy$))
+            .subscribe((selection) => {
+            this.library = { ...selection.library };
+            // favorite libraries list should already be marked as favorite
+            if (selection.library && isFavoriteLibraries) {
+                this.library.isFavorite = true;
+            }
+        });
+    }
+    ngOnDestroy() {
+        this.onDestroy$.next(true);
+        this.onDestroy$.complete();
+    }
+    onToggleEvent() {
+        this.appHookService.favoriteLibraryToggle.next();
+    }
+}
+ToggleFavoriteLibraryComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: ToggleFavoriteLibraryComponent, deps: [{ token: i1.Store }, { token: i2.AppHookService }, { token: i3.Router }], target: i0.ɵɵFactoryTarget.Component });
+ToggleFavoriteLibraryComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.1.2", type: ToggleFavoriteLibraryComponent, selector: "app-toggle-favorite-library", host: { classAttribute: "app-toggle-favorite-library" }, ngImport: i0, template: `
+    <button
+      mat-menu-item
+      (toggle)="onToggleEvent()"
+      [adf-favorite-library]="library"
+      [attr.title]="library.isFavorite ? ('APP.ACTIONS.REMOVE_FAVORITE' | translate) : ('APP.ACTIONS.FAVORITE' | translate)"
+    >
+      <mat-icon *ngIf="library.isFavorite">star</mat-icon>
+      <mat-icon *ngIf="!library.isFavorite">star_border</mat-icon>
+      <span>{{ (library.isFavorite ? 'APP.ACTIONS.REMOVE_FAVORITE' : 'APP.ACTIONS.FAVORITE') | translate }}</span>
+    </button>
+  `, isInline: true, dependencies: [{ kind: "directive", type: i4.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i5.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "component", type: i6.MatMenuItem, selector: "[mat-menu-item]", inputs: ["disabled", "disableRipple", "role"], exportAs: ["matMenuItem"] }, { kind: "directive", type: i7.LibraryFavoriteDirective, selector: "[adf-favorite-library]", inputs: ["adf-favorite-library"], outputs: ["toggle", "error"], exportAs: ["favoriteLibrary"] }, { kind: "pipe", type: i8.TranslatePipe, name: "translate" }], encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: ToggleFavoriteLibraryComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'app-toggle-favorite-library',
+                    template: `
+    <button
+      mat-menu-item
+      (toggle)="onToggleEvent()"
+      [adf-favorite-library]="library"
+      [attr.title]="library.isFavorite ? ('APP.ACTIONS.REMOVE_FAVORITE' | translate) : ('APP.ACTIONS.FAVORITE' | translate)"
+    >
+      <mat-icon *ngIf="library.isFavorite">star</mat-icon>
+      <mat-icon *ngIf="!library.isFavorite">star_border</mat-icon>
+      <span>{{ (library.isFavorite ? 'APP.ACTIONS.REMOVE_FAVORITE' : 'APP.ACTIONS.FAVORITE') | translate }}</span>
+    </button>
+  `,
+                    encapsulation: ViewEncapsulation.None,
+                    host: { class: 'app-toggle-favorite-library' }
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Store }, { type: i2.AppHookService }, { type: i3.Router }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/components/toolbar/toggle-info-drawer/toggle-info-drawer.component.mjs

@@ -0,0 +1,76 @@
+/*!
+ * @license
+ * Alfresco Example Content Application
+ *
+ * Copyright (C) 2005 - 2020 Alfresco Software Limited
+ *
+ * This file is part of the Alfresco Example Content Application.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail.  Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * The Alfresco Example Content Application is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * The Alfresco Example Content Application is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Alfresco. If not, see <http://www.gnu.org/licenses/>.
+ */
+import { Component, ViewEncapsulation } from '@angular/core';
+import { Store } from '@ngrx/store';
+import { ToggleInfoDrawerAction, isInfoDrawerOpened } from '@alfresco/aca-shared/store';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngrx/store";
+import * as i2 from "@angular/material/button";
+import * as i3 from "@angular/material/icon";
+import * as i4 from "@angular/common";
+import * as i5 from "@ngx-translate/core";
+export class ToggleInfoDrawerComponent {
+    constructor(store) {
+        this.store = store;
+        this.infoDrawerOpened$ = this.store.select(isInfoDrawerOpened);
+    }
+    onClick() {
+        this.store.dispatch(new ToggleInfoDrawerAction());
+    }
+}
+ToggleInfoDrawerComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: ToggleInfoDrawerComponent, deps: [{ token: i1.Store }], target: i0.ɵɵFactoryTarget.Component });
+ToggleInfoDrawerComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.1.2", type: ToggleInfoDrawerComponent, selector: "app-toggle-info-drawer", host: { classAttribute: "app-toggle-info-drawer" }, ngImport: i0, template: `
+    <button
+      mat-icon-button
+      [color]="(infoDrawerOpened$ | async) ? 'primary' : null"
+      [attr.aria-label]="'APP.ACTIONS.DETAILS' | translate"
+      [attr.aria-expanded]="infoDrawerOpened$ | async"
+      [attr.title]="'APP.ACTIONS.DETAILS' | translate"
+      (click)="onClick()"
+    >
+      <mat-icon>menu_open</mat-icon>
+    </button>
+  `, isInline: true, dependencies: [{ kind: "component", type: i2.MatButton, selector: "button[mat-button], button[mat-raised-button], button[mat-icon-button],             button[mat-fab], button[mat-mini-fab], button[mat-stroked-button],             button[mat-flat-button]", inputs: ["disabled", "disableRipple", "color"], exportAs: ["matButton"] }, { kind: "component", type: i3.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "pipe", type: i4.AsyncPipe, name: "async" }, { kind: "pipe", type: i5.TranslatePipe, name: "translate" }], encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: ToggleInfoDrawerComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'app-toggle-info-drawer',
+                    template: `
+    <button
+      mat-icon-button
+      [color]="(infoDrawerOpened$ | async) ? 'primary' : null"
+      [attr.aria-label]="'APP.ACTIONS.DETAILS' | translate"
+      [attr.aria-expanded]="infoDrawerOpened$ | async"
+      [attr.title]="'APP.ACTIONS.DETAILS' | translate"
+      (click)="onClick()"
+    >
+      <mat-icon>menu_open</mat-icon>
+    </button>
+  `,
+                    encapsulation: ViewEncapsulation.None,
+                    host: { class: 'app-toggle-info-drawer' }
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Store }]; } });
+//# sourceMappingURL=data:application/json;base64,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