@alfresco/aca-content 4.0.0-4895233349

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

@@ -0,0 +1,84 @@
+/*!
+ * Copyright © 2005-2023 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Alfresco Example Content Application
+ *
+ * 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
+ * from Hyland Software. 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.3", ngImport: i0, type: DocumentDisplayModeComponent, deps: [{ token: i1.Store }], target: i0.ɵɵFactoryTarget.Component });
+DocumentDisplayModeComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.1.3", 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.3", 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,150 @@
+/*!
+ * Copyright © 2005-2023 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Alfresco Example Content Application
+ *
+ * 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
+ * from Hyland Software. 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.3", 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.3", 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.3", 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":"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","sourcesContent":["/*!\n * Copyright © 2005-2023 Hyland Software, Inc. and its affiliates. All rights reserved.\n *\n * Alfresco Example Content Application\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 * from Hyland Software. 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,79 @@
+/*!
+ * Copyright © 2005-2023 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Alfresco Example Content Application
+ *
+ * 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
+ * from Hyland Software. 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.3", 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.3", 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.3", 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,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

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

@@ -0,0 +1,101 @@
+/*!
+ * Copyright © 2005-2023 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Alfresco Example Content Application
+ *
+ * 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
+ * from Hyland Software. 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.3", 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.3", 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.3", 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,75 @@
+/*!
+ * Copyright © 2005-2023 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Alfresco Example Content Application
+ *
+ * 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
+ * from Hyland Software. 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.3", ngImport: i0, type: ToggleInfoDrawerComponent, deps: [{ token: i1.Store }], target: i0.ɵɵFactoryTarget.Component });
+ToggleInfoDrawerComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.1.3", 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.3", 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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9nZ2xlLWluZm8tZHJhd2VyLmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2FjYS1jb250ZW50L3NyYy9saWIvY29tcG9uZW50cy90b29sYmFyL3RvZ2dsZS1pbmZvLWRyYXdlci90b2dnbGUtaW5mby1kcmF3ZXIuY29tcG9uZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0dBc0JHO0FBRUgsT0FBTyxFQUFFLFNBQVMsRUFBRSxpQkFBaUIsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUU3RCxPQUFPLEVBQUUsS0FBSyxFQUFFLE1BQU0sYUFBYSxDQUFDO0FBQ3BDLE9BQU8sRUFBRSxzQkFBc0IsRUFBRSxrQkFBa0IsRUFBRSxNQUFNLDRCQUE0QixDQUFDOzs7Ozs7O0FBbUJ4RixNQUFNLE9BQU8seUJBQXlCO0lBR3BDLFlBQW9CLEtBQWlCO1FBQWpCLFVBQUssR0FBTCxLQUFLLENBQVk7UUFDbkMsSUFBSSxDQUFDLGlCQUFpQixHQUFHLElBQUksQ0FBQyxLQUFLLENBQUMsTUFBTSxDQUFDLGtCQUFrQixDQUFDLENBQUM7SUFDakUsQ0FBQztJQUVELE9BQU87UUFDTCxJQUFJLENBQUMsS0FBSyxDQUFDLFFBQVEsQ0FBQyxJQUFJLHNCQUFzQixFQUFFLENBQUMsQ0FBQztJQUNwRCxDQUFDOztzSEFUVSx5QkFBeUI7MEdBQXpCLHlCQUF5QixrSEFmMUI7Ozs7Ozs7Ozs7O0dBV1Q7MkZBSVUseUJBQXlCO2tCQWpCckMsU0FBUzttQkFBQztvQkFDVCxRQUFRLEVBQUUsd0JBQXdCO29CQUNsQyxRQUFRLEVBQUU7Ozs7Ozs7Ozs7O0dBV1Q7b0JBQ0QsYUFBYSxFQUFFLGlCQUFpQixDQUFDLElBQUk7b0JBQ3JDLElBQUksRUFBRSxFQUFFLEtBQUssRUFBRSx3QkFBd0IsRUFBRTtpQkFDMUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKiFcbiAqIENvcHlyaWdodCDCqSAyMDA1LTIwMjMgSHlsYW5kIFNvZnR3YXJlLCBJbmMuIGFuZCBpdHMgYWZmaWxpYXRlcy4gQWxsIHJpZ2h0cyByZXNlcnZlZC5cbiAqXG4gKiBBbGZyZXNjbyBFeGFtcGxlIENvbnRlbnQgQXBwbGljYXRpb25cbiAqXG4gKiBUaGlzIGZpbGUgaXMgcGFydCBvZiB0aGUgQWxmcmVzY28gRXhhbXBsZSBDb250ZW50IEFwcGxpY2F0aW9uLlxuICogSWYgdGhlIHNvZnR3YXJlIHdhcyBwdXJjaGFzZWQgdW5kZXIgYSBwYWlkIEFsZnJlc2NvIGxpY2Vuc2UsIHRoZSB0ZXJtcyBvZlxuICogdGhlIHBhaWQgbGljZW5zZSBhZ3JlZW1lbnQgd2lsbCBwcmV2YWlsLiBPdGhlcndpc2UsIHRoZSBzb2Z0d2FyZSBpc1xuICogcHJvdmlkZWQgdW5kZXIgdGhlIGZvbGxvd2luZyBvcGVuIHNvdXJjZSBsaWNlbnNlIHRlcm1zOlxuICpcbiAqIFRoZSBBbGZyZXNjbyBFeGFtcGxlIENvbnRlbnQgQXBwbGljYXRpb24gaXMgZnJlZSBzb2Z0d2FyZTogeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeVxuICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5XG4gKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBlaXRoZXIgdmVyc2lvbiAzIG9mIHRoZSBMaWNlbnNlLCBvclxuICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi5cbiAqXG4gKiBUaGUgQWxmcmVzY28gRXhhbXBsZSBDb250ZW50IEFwcGxpY2F0aW9uIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsXG4gKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZlxuICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiBTZWUgdGhlXG4gKiBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy5cbiAqXG4gKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljIExpY2Vuc2VcbiAqIGZyb20gSHlsYW5kIFNvZnR3YXJlLiBJZiBub3QsIHNlZSA8aHR0cDovL3d3dy5nbnUub3JnL2xpY2Vuc2VzLz4uXG4gKi9cblxuaW1wb3J0IHsgQ29tcG9uZW50LCBWaWV3RW5jYXBzdWxhdGlvbiB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgT2JzZXJ2YWJsZSB9IGZyb20gJ3J4anMnO1xuaW1wb3J0IHsgU3RvcmUgfSBmcm9tICdAbmdyeC9zdG9yZSc7XG5pbXBvcnQgeyBUb2dnbGVJbmZvRHJhd2VyQWN0aW9uLCBpc0luZm9EcmF3ZXJPcGVuZWQgfSBmcm9tICdAYWxmcmVzY28vYWNhLXNoYXJlZC9zdG9yZSc7XG5cbkBDb21wb25lbnQoe1xuICBzZWxlY3RvcjogJ2FwcC10b2dnbGUtaW5mby1kcmF3ZXInLFxuICB0ZW1wbGF0ZTogYFxuICAgIDxidXR0b25cbiAgICAgIG1hdC1pY29uLWJ1dHRvblxuICAgICAgW2NvbG9yXT1cIihpbmZvRHJhd2VyT3BlbmVkJCB8IGFzeW5jKSA/ICdwcmltYXJ5JyA6IG51bGxcIlxuICAgICAgW2F0dHIuYXJpYS1sYWJlbF09XCInQVBQLkFDVElPTlMuREVUQUlMUycgfCB0cmFuc2xhdGVcIlxuICAgICAgW2F0dHIuYXJpYS1leHBhbmRlZF09XCJpbmZvRHJhd2VyT3BlbmVkJCB8IGFzeW5jXCJcbiAgICAgIFthdHRyLnRpdGxlXT1cIidBUFAuQUNUSU9OUy5ERVRBSUxTJyB8IHRyYW5zbGF0ZVwiXG4gICAgICAoY2xpY2spPVwib25DbGljaygpXCJcbiAgICA+XG4gICAgICA8bWF0LWljb24+bWVudV9vcGVuPC9tYXQtaWNvbj5cbiAgICA8L2J1dHRvbj5cbiAgYCxcbiAgZW5jYXBzdWxhdGlvbjogVmlld0VuY2Fwc3VsYXRpb24uTm9uZSxcbiAgaG9zdDogeyBjbGFzczogJ2FwcC10b2dnbGUtaW5mby1kcmF3ZXInIH1cbn0pXG5leHBvcnQgY2xhc3MgVG9nZ2xlSW5mb0RyYXdlckNvbXBvbmVudCB7XG4gIGluZm9EcmF3ZXJPcGVuZWQkOiBPYnNlcnZhYmxlPGJvb2xlYW4+O1xuXG4gIGNvbnN0cnVjdG9yKHByaXZhdGUgc3RvcmU6IFN0b3JlPGFueT4pIHtcbiAgICB0aGlzLmluZm9EcmF3ZXJPcGVuZWQkID0gdGhpcy5zdG9yZS5zZWxlY3QoaXNJbmZvRHJhd2VyT3BlbmVkKTtcbiAgfVxuXG4gIG9uQ2xpY2soKSB7XG4gICAgdGhpcy5zdG9yZS5kaXNwYXRjaChuZXcgVG9nZ2xlSW5mb0RyYXdlckFjdGlvbigpKTtcbiAgfVxufVxuIl19