@alfresco/aca-content 5.1.1 → 5.2.0

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

@@ -0,0 +1,112 @@
+/*!
+ * Copyright © 2005-2024 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 { CommonModule } from '@angular/common';
+import { TranslateModule } from '@ngx-translate/core';
+import { LibraryFavoriteDirective } from '@alfresco/adf-content-services';
+import { MatIconModule } from '@angular/material/icon';
+import { MatMenuModule } from '@angular/material/menu';
+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 "@ngx-translate/core";
+import * as i6 from "@angular/material/icon";
+import * as i7 from "@angular/material/menu";
+class ToggleFavoriteLibraryComponent {
+    store;
+    appHookService;
+    router;
+    library;
+    onDestroy$ = new Subject();
+    constructor(store, appHookService, router) {
+        this.store = store;
+        this.appHookService = appHookService;
+        this.router = router;
+    }
+    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();
+        this.onDestroy$.complete();
+    }
+    onToggleEvent() {
+        this.appHookService.favoriteLibraryToggle.next();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: ToggleFavoriteLibraryComponent, deps: [{ token: i1.Store }, { token: i2.AppHookService }, { token: i3.Router }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.9", type: ToggleFavoriteLibraryComponent, isStandalone: true, 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: "ngmodule", type: CommonModule }, { kind: "directive", type: i4.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "ngmodule", type: TranslateModule }, { kind: "pipe", type: i5.TranslatePipe, name: "translate" }, { kind: "ngmodule", type: MatIconModule }, { kind: "component", type: i6.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "ngmodule", type: MatMenuModule }, { kind: "component", type: i7.MatMenuItem, selector: "[mat-menu-item]", inputs: ["disabled", "disableRipple", "role"], exportAs: ["matMenuItem"] }, { kind: "directive", type: LibraryFavoriteDirective, selector: "[adf-favorite-library]", inputs: ["adf-favorite-library"], outputs: ["toggle", "error"], exportAs: ["favoriteLibrary"] }], encapsulation: i0.ViewEncapsulation.None });
+}
+export { ToggleFavoriteLibraryComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: ToggleFavoriteLibraryComponent, decorators: [{
+            type: Component,
+            args: [{
+                    standalone: true,
+                    imports: [CommonModule, TranslateModule, MatIconModule, MatMenuModule, LibraryFavoriteDirective],
+                    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/esm2022/lib/components/toolbar/toggle-info-drawer/toggle-info-drawer.component.mjs

@@ -0,0 +1,77 @@
+/*!
+ * Copyright © 2005-2024 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 { CommonModule } from '@angular/common';
+import { MatButtonModule } from '@angular/material/button';
+import { TranslateModule } from '@ngx-translate/core';
+import { MatIconModule } from '@angular/material/icon';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngrx/store";
+import * as i2 from "@angular/common";
+import * as i3 from "@ngx-translate/core";
+import * as i4 from "@angular/material/button";
+import * as i5 from "@angular/material/icon";
+class ToggleInfoDrawerComponent {
+    store;
+    infoDrawerOpened$;
+    constructor(store) {
+        this.store = store;
+        this.infoDrawerOpened$ = this.store.select(isInfoDrawerOpened);
+    }
+    onClick() {
+        this.store.dispatch(new ToggleInfoDrawerAction());
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: ToggleInfoDrawerComponent, deps: [{ token: i1.Store }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.9", type: ToggleInfoDrawerComponent, isStandalone: true, 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>view_sidebar</mat-icon>
+    </button>
+  `, isInline: true, styles: [".app-toggle-info-drawer button:focus{border:2px solid var(--theme-blue-button-color);border-radius:6px;outline:none;background-color:var(--theme-selected-background-color)}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "pipe", type: i2.AsyncPipe, name: "async" }, { kind: "ngmodule", type: TranslateModule }, { kind: "pipe", type: i3.TranslatePipe, name: "translate" }, { kind: "ngmodule", type: MatButtonModule }, { kind: "component", type: i4.MatIconButton, selector: "button[mat-icon-button]", inputs: ["disabled", "disableRipple", "color"], exportAs: ["matButton"] }, { kind: "ngmodule", type: MatIconModule }, { kind: "component", type: i5.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }], encapsulation: i0.ViewEncapsulation.None });
+}
+export { ToggleInfoDrawerComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: ToggleInfoDrawerComponent, decorators: [{
+            type: Component,
+            args: [{ standalone: true, imports: [CommonModule, TranslateModule, MatButtonModule, MatIconModule], 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>view_sidebar</mat-icon>
+    </button>
+  `, encapsulation: ViewEncapsulation.None, host: { class: 'app-toggle-info-drawer' }, styles: [".app-toggle-info-drawer button:focus{border:2px solid var(--theme-blue-button-color);border-radius:6px;outline:none;background-color:var(--theme-selected-background-color)}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.Store }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/toolbar/toggle-join-library/toggle-join-library-button.component.mjs

@@ -0,0 +1,107 @@
+/*!
+ * Copyright © 2005-2024 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 { SetSelectedNodesAction, getAppSelection } from '@alfresco/aca-shared/store';
+import { AppHookService, UserProfileService } from '@alfresco/aca-shared';
+import { Component, inject, ViewEncapsulation } from '@angular/core';
+import { Store } from '@ngrx/store';
+import { LibraryMembershipDirective } from '@alfresco/adf-content-services';
+import { CommonModule } from '@angular/common';
+import { MatButtonModule } from '@angular/material/button';
+import { TranslateModule } from '@ngx-translate/core';
+import { MatIconModule } from '@angular/material/icon';
+import { NotificationService } from '@alfresco/adf-core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@ngx-translate/core";
+import * as i3 from "@angular/material/button";
+import * as i4 from "@angular/material/icon";
+class ToggleJoinLibraryButtonComponent {
+    userProfileService = inject(UserProfileService);
+    notificationService = inject(NotificationService);
+    appHookService = inject(AppHookService);
+    store = inject((Store));
+    selection$;
+    profile$ = this.userProfileService.userProfile$;
+    constructor() {
+        this.selection$ = this.store.select(getAppSelection);
+    }
+    onToggleEvent(event) {
+        this.notificationService.showInfo(event.i18nKey);
+        if (event.shouldReload) {
+            this.appHookService.libraryJoined.next();
+        }
+        else {
+            if (event.updatedEntry) {
+                this.store.dispatch(new SetSelectedNodesAction([{ entry: event.updatedEntry, isLibrary: true }]));
+            }
+            this.appHookService.joinLibraryToggle.next();
+        }
+    }
+    onErrorEvent(event) {
+        this.notificationService.showError(event.i18nKey);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: ToggleJoinLibraryButtonComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.9", type: ToggleJoinLibraryButtonComponent, isStandalone: true, selector: "app-toggle-join-library-button", host: { classAttribute: "app-toggle-join-library" }, ngImport: i0, template: `
+    <button
+      mat-icon-button
+      color="primary"
+      #membership="libraryMembership"
+      (toggle)="onToggleEvent($event)"
+      (error)="onErrorEvent($event)"
+      [adf-library-membership]="(selection$ | async).library"
+      [isAdmin]="(profile$ | async).isAdmin"
+      [attr.title]="(membership.isJoinRequested | async) ? ('APP.ACTIONS.CANCEL_JOIN' | translate) : ('APP.ACTIONS.JOIN' | translate)"
+    >
+      <mat-icon *ngIf="membership.isJoinRequested | async">cancel</mat-icon>
+      <mat-icon *ngIf="!(membership.isJoinRequested | async)">library_add</mat-icon>
+    </button>
+  `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "pipe", type: i1.AsyncPipe, name: "async" }, { kind: "ngmodule", type: TranslateModule }, { kind: "pipe", type: i2.TranslatePipe, name: "translate" }, { kind: "ngmodule", type: MatButtonModule }, { kind: "component", type: i3.MatIconButton, selector: "button[mat-icon-button]", inputs: ["disabled", "disableRipple", "color"], exportAs: ["matButton"] }, { kind: "ngmodule", type: MatIconModule }, { kind: "component", type: i4.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "directive", type: LibraryMembershipDirective, selector: "[adf-library-membership]", inputs: ["adf-library-membership", "isAdmin"], outputs: ["toggle", "error"], exportAs: ["libraryMembership"] }], encapsulation: i0.ViewEncapsulation.None });
+}
+export { ToggleJoinLibraryButtonComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: ToggleJoinLibraryButtonComponent, decorators: [{
+            type: Component,
+            args: [{
+                    standalone: true,
+                    imports: [CommonModule, TranslateModule, MatButtonModule, MatIconModule, LibraryMembershipDirective],
+                    selector: 'app-toggle-join-library-button',
+                    template: `
+    <button
+      mat-icon-button
+      color="primary"
+      #membership="libraryMembership"
+      (toggle)="onToggleEvent($event)"
+      (error)="onErrorEvent($event)"
+      [adf-library-membership]="(selection$ | async).library"
+      [isAdmin]="(profile$ | async).isAdmin"
+      [attr.title]="(membership.isJoinRequested | async) ? ('APP.ACTIONS.CANCEL_JOIN' | translate) : ('APP.ACTIONS.JOIN' | translate)"
+    >
+      <mat-icon *ngIf="membership.isJoinRequested | async">cancel</mat-icon>
+      <mat-icon *ngIf="!(membership.isJoinRequested | async)">library_add</mat-icon>
+    </button>
+  `,
+                    encapsulation: ViewEncapsulation.None,
+                    host: { class: 'app-toggle-join-library' }
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9nZ2xlLWpvaW4tbGlicmFyeS1idXR0b24uY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvYWNhLWNvbnRlbnQvc3JjL2xpYi9jb21wb25lbnRzL3Rvb2xiYXIvdG9nZ2xlLWpvaW4tbGlicmFyeS90b2dnbGUtam9pbi1saWJyYXJ5LWJ1dHRvbi5jb21wb25lbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7R0FzQkc7QUFFSCxPQUFPLEVBQVksc0JBQXNCLEVBQUUsZUFBZSxFQUFFLE1BQU0sNEJBQTRCLENBQUM7QUFDL0YsT0FBTyxFQUFFLGNBQWMsRUFBRSxrQkFBa0IsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBRTFFLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxFQUFFLGlCQUFpQixFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ3JFLE9BQU8sRUFBRSxLQUFLLEVBQUUsTUFBTSxhQUFhLENBQUM7QUFFcEMsT0FBTyxFQUFFLDBCQUEwQixFQUE2RCxNQUFNLGdDQUFnQyxDQUFDO0FBQ3ZJLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUMvQyxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0sMEJBQTBCLENBQUM7QUFDM0QsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBQ3RELE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUN2RCxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQzs7Ozs7O0FBRXpELE1Bc0JhLGdDQUFnQztJQUNuQyxrQkFBa0IsR0FBRyxNQUFNLENBQUMsa0JBQWtCLENBQUMsQ0FBQztJQUNoRCxtQkFBbUIsR0FBRyxNQUFNLENBQUMsbUJBQW1CLENBQUMsQ0FBQztJQUNsRCxjQUFjLEdBQUcsTUFBTSxDQUFDLGNBQWMsQ0FBQyxDQUFDO0lBQ3hDLEtBQUssR0FBRyxNQUFNLENBQUMsQ0FBQSxLQUFlLENBQUEsQ0FBQyxDQUFDO0lBRXhDLFVBQVUsQ0FBNkI7SUFDdkMsUUFBUSxHQUFHLElBQUksQ0FBQyxrQkFBa0IsQ0FBQyxZQUFZLENBQUM7SUFFaEQ7UUFDRSxJQUFJLENBQUMsVUFBVSxHQUFHLElBQUksQ0FBQyxLQUFLLENBQUMsTUFBTSxDQUFDLGVBQWUsQ0FBQyxDQUFDO0lBQ3ZELENBQUM7SUFFRCxhQUFhLENBQUMsS0FBbUM7UUFDL0MsSUFBSSxDQUFDLG1CQUFtQixDQUFDLFFBQVEsQ0FBQyxLQUFLLENBQUMsT0FBTyxDQUFDLENBQUM7UUFFakQsSUFBSSxLQUFLLENBQUMsWUFBWSxFQUFFO1lBQ3RCLElBQUksQ0FBQyxjQUFjLENBQUMsYUFBYSxDQUFDLElBQUksRUFBRSxDQUFDO1NBQzFDO2FBQU07WUFDTCxJQUFJLEtBQUssQ0FBQyxZQUFZLEVBQUU7Z0JBQ3RCLElBQUksQ0FBQyxLQUFLLENBQUMsUUFBUSxDQUFDLElBQUksc0JBQXNCLENBQUMsQ0FBQyxFQUFFLEtBQUssRUFBRSxLQUFLLENBQUMsWUFBWSxFQUFFLFNBQVMsRUFBRSxJQUFJLEVBQVMsQ0FBQyxDQUFDLENBQUMsQ0FBQzthQUMxRztZQUNELElBQUksQ0FBQyxjQUFjLENBQUMsaUJBQWlCLENBQUMsSUFBSSxFQUFFLENBQUM7U0FDOUM7SUFDSCxDQUFDO0lBRUQsWUFBWSxDQUFDLEtBQWtDO1FBQzdDLElBQUksQ0FBQyxtQkFBbUIsQ0FBQyxTQUFTLENBQUMsS0FBSyxDQUFDLE9BQU8sQ0FBQyxDQUFDO0lBQ3BELENBQUM7dUdBNUJVLGdDQUFnQzsyRkFBaEMsZ0NBQWdDLCtJQWxCakM7Ozs7Ozs7Ozs7Ozs7O0dBY1QsMkRBaEJTLFlBQVksdUxBQUUsZUFBZSwyRkFBRSxlQUFlLDJMQUFFLGFBQWEsb0xBQUUsMEJBQTBCOztTQW9CeEYsZ0NBQWdDOzJGQUFoQyxnQ0FBZ0M7a0JBdEI1QyxTQUFTO21CQUFDO29CQUNULFVBQVUsRUFBRSxJQUFJO29CQUNoQixPQUFPLEVBQUUsQ0FBQyxZQUFZLEVBQUUsZUFBZSxFQUFFLGVBQWUsRUFBRSxhQUFhLEVBQUUsMEJBQTBCLENBQUM7b0JBQ3BHLFFBQVEsRUFBRSxnQ0FBZ0M7b0JBQzFDLFFBQVEsRUFBRTs7Ozs7Ozs7Ozs7Ozs7R0FjVDtvQkFDRCxhQUFhLEVBQUUsaUJBQWlCLENBQUMsSUFBSTtvQkFDckMsSUFBSSxFQUFFLEVBQUUsS0FBSyxFQUFFLHlCQUF5QixFQUFFO2lCQUMzQyIsInNvdXJjZXNDb250ZW50IjpbIi8qIVxuICogQ29weXJpZ2h0IMKpIDIwMDUtMjAyNCBIeWxhbmQgU29mdHdhcmUsIEluYy4gYW5kIGl0cyBhZmZpbGlhdGVzLiBBbGwgcmlnaHRzIHJlc2VydmVkLlxuICpcbiAqIEFsZnJlc2NvIEV4YW1wbGUgQ29udGVudCBBcHBsaWNhdGlvblxuICpcbiAqIFRoaXMgZmlsZSBpcyBwYXJ0IG9mIHRoZSBBbGZyZXNjbyBFeGFtcGxlIENvbnRlbnQgQXBwbGljYXRpb24uXG4gKiBJZiB0aGUgc29mdHdhcmUgd2FzIHB1cmNoYXNlZCB1bmRlciBhIHBhaWQgQWxmcmVzY28gbGljZW5zZSwgdGhlIHRlcm1zIG9mXG4gKiB0aGUgcGFpZCBsaWNlbnNlIGFncmVlbWVudCB3aWxsIHByZXZhaWwuIE90aGVyd2lzZSwgdGhlIHNvZnR3YXJlIGlzXG4gKiBwcm92aWRlZCB1bmRlciB0aGUgZm9sbG93aW5nIG9wZW4gc291cmNlIGxpY2Vuc2UgdGVybXM6XG4gKlxuICogVGhlIEFsZnJlc2NvIEV4YW1wbGUgQ29udGVudCBBcHBsaWNhdGlvbiBpcyBmcmVlIHNvZnR3YXJlOiB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5XG4gKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnlcbiAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIGVpdGhlciB2ZXJzaW9uIDMgb2YgdGhlIExpY2Vuc2UsIG9yXG4gKiAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLlxuICpcbiAqIFRoZSBBbGZyZXNjbyBFeGFtcGxlIENvbnRlbnQgQXBwbGljYXRpb24gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCxcbiAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mXG4gKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuIFNlZSB0aGVcbiAqIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLlxuICpcbiAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMgTGljZW5zZVxuICogZnJvbSBIeWxhbmQgU29mdHdhcmUuIElmIG5vdCwgc2VlIDxodHRwOi8vd3d3LmdudS5vcmcvbGljZW5zZXMvPi5cbiAqL1xuXG5pbXBvcnQgeyBBcHBTdG9yZSwgU2V0U2VsZWN0ZWROb2Rlc0FjdGlvbiwgZ2V0QXBwU2VsZWN0aW9uIH0gZnJvbSAnQGFsZnJlc2NvL2FjYS1zaGFyZWQvc3RvcmUnO1xuaW1wb3J0IHsgQXBwSG9va1NlcnZpY2UsIFVzZXJQcm9maWxlU2VydmljZSB9IGZyb20gJ0BhbGZyZXNjby9hY2Etc2hhcmVkJztcbmltcG9ydCB7IFNlbGVjdGlvblN0YXRlIH0gZnJvbSAnQGFsZnJlc2NvL2FkZi1leHRlbnNpb25zJztcbmltcG9ydCB7IENvbXBvbmVudCwgaW5qZWN0LCBWaWV3RW5jYXBzdWxhdGlvbiB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgU3RvcmUgfSBmcm9tICdAbmdyeC9zdG9yZSc7XG5pbXBvcnQgeyBPYnNlcnZhYmxlIH0gZnJvbSAncnhqcyc7XG5pbXBvcnQgeyBMaWJyYXJ5TWVtYmVyc2hpcERpcmVjdGl2ZSwgTGlicmFyeU1lbWJlcnNoaXBFcnJvckV2ZW50LCBMaWJyYXJ5TWVtYmVyc2hpcFRvZ2dsZUV2ZW50IH0gZnJvbSAnQGFsZnJlc2NvL2FkZi1jb250ZW50LXNlcnZpY2VzJztcbmltcG9ydCB7IENvbW1vbk1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbic7XG5pbXBvcnQgeyBNYXRCdXR0b25Nb2R1bGUgfSBmcm9tICdAYW5ndWxhci9tYXRlcmlhbC9idXR0b24nO1xuaW1wb3J0IHsgVHJhbnNsYXRlTW9kdWxlIH0gZnJvbSAnQG5neC10cmFuc2xhdGUvY29yZSc7XG5pbXBvcnQgeyBNYXRJY29uTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvbWF0ZXJpYWwvaWNvbic7XG5pbXBvcnQgeyBOb3RpZmljYXRpb25TZXJ2aWNlIH0gZnJvbSAnQGFsZnJlc2NvL2FkZi1jb3JlJztcblxuQENvbXBvbmVudCh7XG4gIHN0YW5kYWxvbmU6IHRydWUsXG4gIGltcG9ydHM6IFtDb21tb25Nb2R1bGUsIFRyYW5zbGF0ZU1vZHVsZSwgTWF0QnV0dG9uTW9kdWxlLCBNYXRJY29uTW9kdWxlLCBMaWJyYXJ5TWVtYmVyc2hpcERpcmVjdGl2ZV0sXG4gIHNlbGVjdG9yOiAnYXBwLXRvZ2dsZS1qb2luLWxpYnJhcnktYnV0dG9uJyxcbiAgdGVtcGxhdGU6IGBcbiAgICA8YnV0dG9uXG4gICAgICBtYXQtaWNvbi1idXR0b25cbiAgICAgIGNvbG9yPVwicHJpbWFyeVwiXG4gICAgICAjbWVtYmVyc2hpcD1cImxpYnJhcnlNZW1iZXJzaGlwXCJcbiAgICAgICh0b2dnbGUpPVwib25Ub2dnbGVFdmVudCgkZXZlbnQpXCJcbiAgICAgIChlcnJvcik9XCJvbkVycm9yRXZlbnQoJGV2ZW50KVwiXG4gICAgICBbYWRmLWxpYnJhcnktbWVtYmVyc2hpcF09XCIoc2VsZWN0aW9uJCB8IGFzeW5jKS5saWJyYXJ5XCJcbiAgICAgIFtpc0FkbWluXT1cIihwcm9maWxlJCB8IGFzeW5jKS5pc0FkbWluXCJcbiAgICAgIFthdHRyLnRpdGxlXT1cIihtZW1iZXJzaGlwLmlzSm9pblJlcXVlc3RlZCB8IGFzeW5jKSA/ICgnQVBQLkFDVElPTlMuQ0FOQ0VMX0pPSU4nIHwgdHJhbnNsYXRlKSA6ICgnQVBQLkFDVElPTlMuSk9JTicgfCB0cmFuc2xhdGUpXCJcbiAgICA+XG4gICAgICA8bWF0LWljb24gKm5nSWY9XCJtZW1iZXJzaGlwLmlzSm9pblJlcXVlc3RlZCB8IGFzeW5jXCI+Y2FuY2VsPC9tYXQtaWNvbj5cbiAgICAgIDxtYXQtaWNvbiAqbmdJZj1cIiEobWVtYmVyc2hpcC5pc0pvaW5SZXF1ZXN0ZWQgfCBhc3luYylcIj5saWJyYXJ5X2FkZDwvbWF0LWljb24+XG4gICAgPC9idXR0b24+XG4gIGAsXG4gIGVuY2Fwc3VsYXRpb246IFZpZXdFbmNhcHN1bGF0aW9uLk5vbmUsXG4gIGhvc3Q6IHsgY2xhc3M6ICdhcHAtdG9nZ2xlLWpvaW4tbGlicmFyeScgfVxufSlcbmV4cG9ydCBjbGFzcyBUb2dnbGVKb2luTGlicmFyeUJ1dHRvbkNvbXBvbmVudCB7XG4gIHByaXZhdGUgdXNlclByb2ZpbGVTZXJ2aWNlID0gaW5qZWN0KFVzZXJQcm9maWxlU2VydmljZSk7XG4gIHByaXZhdGUgbm90aWZpY2F0aW9uU2VydmljZSA9IGluamVjdChOb3RpZmljYXRpb25TZXJ2aWNlKTtcbiAgcHJpdmF0ZSBhcHBIb29rU2VydmljZSA9IGluamVjdChBcHBIb29rU2VydmljZSk7XG4gIHByaXZhdGUgc3RvcmUgPSBpbmplY3QoU3RvcmU8QXBwU3RvcmU+KTtcblxuICBzZWxlY3Rpb24kOiBPYnNlcnZhYmxlPFNlbGVjdGlvblN0YXRlPjtcbiAgcHJvZmlsZSQgPSB0aGlzLnVzZXJQcm9maWxlU2VydmljZS51c2VyUHJvZmlsZSQ7XG5cbiAgY29uc3RydWN0b3IoKSB7XG4gICAgdGhpcy5zZWxlY3Rpb24kID0gdGhpcy5zdG9yZS5zZWxlY3QoZ2V0QXBwU2VsZWN0aW9uKTtcbiAgfVxuXG4gIG9uVG9nZ2xlRXZlbnQoZXZlbnQ6IExpYnJhcnlNZW1iZXJzaGlwVG9nZ2xlRXZlbnQpIHtcbiAgICB0aGlzLm5vdGlmaWNhdGlvblNlcnZpY2Uuc2hvd0luZm8oZXZlbnQuaTE4bktleSk7XG5cbiAgICBpZiAoZXZlbnQuc2hvdWxkUmVsb2FkKSB7XG4gICAgICB0aGlzLmFwcEhvb2tTZXJ2aWNlLmxpYnJhcnlKb2luZWQubmV4dCgpO1xuICAgIH0gZWxzZSB7XG4gICAgICBpZiAoZXZlbnQudXBkYXRlZEVudHJ5KSB7XG4gICAgICAgIHRoaXMuc3RvcmUuZGlzcGF0Y2gobmV3IFNldFNlbGVjdGVkTm9kZXNBY3Rpb24oW3sgZW50cnk6IGV2ZW50LnVwZGF0ZWRFbnRyeSwgaXNMaWJyYXJ5OiB0cnVlIH0gYXMgYW55XSkpO1xuICAgICAgfVxuICAgICAgdGhpcy5hcHBIb29rU2VydmljZS5qb2luTGlicmFyeVRvZ2dsZS5uZXh0KCk7XG4gICAgfVxuICB9XG5cbiAgb25FcnJvckV2ZW50KGV2ZW50OiBMaWJyYXJ5TWVtYmVyc2hpcEVycm9yRXZlbnQpIHtcbiAgICB0aGlzLm5vdGlmaWNhdGlvblNlcnZpY2Uuc2hvd0Vycm9yKGV2ZW50LmkxOG5LZXkpO1xuICB9XG59XG4iXX0=

package/{esm2020 → esm2022}/lib/components/toolbar/toggle-join-library/toggle-join-library-menu.component.mjs

@@ -33,10 +33,9 @@ import * as i1 from "@angular/common";
 import * as i2 from "@ngx-translate/core";
 import * as i3 from "@angular/material/icon";
 import * as i4 from "@angular/material/menu";
-export class ToggleJoinLibraryMenuComponent extends ToggleJoinLibraryButtonComponent {
-}
-ToggleJoinLibraryMenuComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: ToggleJoinLibraryMenuComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
-ToggleJoinLibraryMenuComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.10", type: ToggleJoinLibraryMenuComponent, isStandalone: true, selector: "app-toggle-join-library-menu", host: { classAttribute: "app-toggle-join-library" }, usesInheritance: true, ngImport: i0, template: `
+class ToggleJoinLibraryMenuComponent extends ToggleJoinLibraryButtonComponent {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: ToggleJoinLibraryMenuComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.9", type: ToggleJoinLibraryMenuComponent, isStandalone: true, selector: "app-toggle-join-library-menu", host: { classAttribute: "app-toggle-join-library" }, usesInheritance: true, ngImport: i0, template: `
     <button
       mat-menu-item
       #membership="libraryMembership"
@@ -50,7 +49,9 @@ ToggleJoinLibraryMenuComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "
       <span>{{ (membership.isJoinRequested | async) ? ('APP.ACTIONS.CANCEL_JOIN' | translate) : ('APP.ACTIONS.JOIN' | translate) }}</span>
     </button>
   `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "pipe", type: i1.AsyncPipe, name: "async" }, { kind: "ngmodule", type: TranslateModule }, { kind: "pipe", type: i2.TranslatePipe, name: "translate" }, { kind: "ngmodule", type: MatIconModule }, { kind: "component", type: i3.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "ngmodule", type: MatMenuModule }, { kind: "component", type: i4.MatMenuItem, selector: "[mat-menu-item]", inputs: ["disabled", "disableRipple", "role"], exportAs: ["matMenuItem"] }, { kind: "directive", type: LibraryMembershipDirective, selector: "[adf-library-membership]", inputs: ["adf-library-membership", "isAdmin"], outputs: ["toggle", "error"], exportAs: ["libraryMembership"] }], encapsulation: i0.ViewEncapsulation.None });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: ToggleJoinLibraryMenuComponent, decorators: [{
+}
+export { ToggleJoinLibraryMenuComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: ToggleJoinLibraryMenuComponent, decorators: [{
             type: Component,
             args: [{
                     standalone: true,
@@ -74,4 +75,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImpo
                     host: { class: 'app-toggle-join-library' }
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/toolbar/view-node/view-node.component.mjs

@@ -0,0 +1,128 @@
+/*!
+ * Copyright © 2005-2024 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, inject } from '@angular/core';
+import { Store } from '@ngrx/store';
+import { ViewNodeAction, getAppSelection } from '@alfresco/aca-shared/store';
+import { ActivatedRoute, Router } from '@angular/router';
+import { take } from 'rxjs/operators';
+import { AutoDownloadService, AppSettingsService } from '@alfresco/aca-shared';
+import { CommonModule } from '@angular/common';
+import { TranslateModule } from '@ngx-translate/core';
+import { MatButtonModule } from '@angular/material/button';
+import { MatIconModule } from '@angular/material/icon';
+import { MatMenuModule } from '@angular/material/menu';
+import { MatDialogModule } from '@angular/material/dialog';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngrx/store";
+import * as i2 from "@angular/router";
+import * as i3 from "@alfresco/aca-shared";
+import * as i4 from "@angular/common";
+import * as i5 from "@ngx-translate/core";
+import * as i6 from "@angular/material/button";
+import * as i7 from "@angular/material/icon";
+import * as i8 from "@angular/material/menu";
+class ViewNodeComponent {
+    store;
+    router;
+    autoDownloadService;
+    activatedRoute;
+    settings = inject(AppSettingsService);
+    data;
+    constructor(store, router, autoDownloadService, activatedRoute) {
+        this.store = store;
+        this.router = router;
+        this.autoDownloadService = autoDownloadService;
+        this.activatedRoute = activatedRoute;
+    }
+    onClick() {
+        this.store
+            .select(getAppSelection)
+            .pipe(take(1))
+            .subscribe((selection) => {
+            if (!this.settings.autoDownloadEnabled || !this.autoDownloadService.tryDownload(selection.file, this.settings.authDownloadThreshold)) {
+                let id;
+                if (selection.file.entry.nodeType === 'app:filelink') {
+                    id = selection.file.entry.properties['cm:destination'];
+                }
+                else {
+                    id = selection.file.entry.nodeId || selection.file.entry.guid || selection.file.entry.id;
+                }
+                this.navigateToViewer(id);
+            }
+        });
+    }
+    navigateToViewer(id) {
+        this.activatedRoute.queryParams.pipe(take(1)).subscribe((params) => {
+            const location = params.location || this.router.url;
+            this.store.dispatch(new ViewNodeAction(id, { location }));
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: ViewNodeComponent, deps: [{ token: i1.Store }, { token: i2.Router }, { token: i3.AutoDownloadService }, { token: i2.ActivatedRoute }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.9", type: ViewNodeComponent, isStandalone: true, selector: "app-view-node", inputs: { data: "data" }, host: { classAttribute: "app-view-node" }, ngImport: i0, template: `
+    <button
+      *ngIf="data.iconButton"
+      mat-icon-button
+      [attr.aria-label]="data.title | translate"
+      [attr.title]="data.title | translate"
+      (click)="onClick()"
+    >
+      <mat-icon>visibility</mat-icon>
+    </button>
+
+    <button *ngIf="data.menuButton" mat-menu-item (click)="onClick()">
+      <mat-icon>visibility</mat-icon>
+      <span>{{ data.title | translate }}</span>
+    </button>
+  `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i4.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "ngmodule", type: TranslateModule }, { kind: "pipe", type: i5.TranslatePipe, name: "translate" }, { kind: "ngmodule", type: MatButtonModule }, { kind: "component", type: i6.MatIconButton, selector: "button[mat-icon-button]", inputs: ["disabled", "disableRipple", "color"], exportAs: ["matButton"] }, { kind: "ngmodule", type: MatIconModule }, { kind: "component", type: i7.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "ngmodule", type: MatMenuModule }, { kind: "component", type: i8.MatMenuItem, selector: "[mat-menu-item]", inputs: ["disabled", "disableRipple", "role"], exportAs: ["matMenuItem"] }, { kind: "ngmodule", type: MatDialogModule }], encapsulation: i0.ViewEncapsulation.None });
+}
+export { ViewNodeComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: ViewNodeComponent, decorators: [{
+            type: Component,
+            args: [{
+                    standalone: true,
+                    imports: [CommonModule, TranslateModule, MatButtonModule, MatIconModule, MatMenuModule, MatDialogModule],
+                    selector: 'app-view-node',
+                    template: `
+    <button
+      *ngIf="data.iconButton"
+      mat-icon-button
+      [attr.aria-label]="data.title | translate"
+      [attr.title]="data.title | translate"
+      (click)="onClick()"
+    >
+      <mat-icon>visibility</mat-icon>
+    </button>
+
+    <button *ngIf="data.menuButton" mat-menu-item (click)="onClick()">
+      <mat-icon>visibility</mat-icon>
+      <span>{{ data.title | translate }}</span>
+    </button>
+  `,
+                    encapsulation: ViewEncapsulation.None,
+                    host: { class: 'app-view-node' }
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Store }, { type: i2.Router }, { type: i3.AutoDownloadService }, { type: i2.ActivatedRoute }]; }, propDecorators: { data: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"view-node.component.js","sourceRoot":"","sources":["../../../../../../../../projects/aca-content/src/lib/components/toolbar/view-node/view-node.component.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAAE,SAAS,EAAE,iBAAiB,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAC5E,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,OAAO,EAAY,cAAc,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AACvF,OAAO,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AACzD,OAAO,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AAEtC,OAAO,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC/E,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAC3D,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;;;;;;;;;;AAE3D,MAuBa,iBAAiB;IAMlB;IACA;IACA;IACA;IARF,QAAQ,GAAG,MAAM,CAAC,kBAAkB,CAAC,CAAC;IAErC,IAAI,CAAiE;IAE9E,YACU,KAAsB,EACtB,MAAc,EACd,mBAAwC,EACxC,cAA8B;QAH9B,UAAK,GAAL,KAAK,CAAiB;QACtB,WAAM,GAAN,MAAM,CAAQ;QACd,wBAAmB,GAAnB,mBAAmB,CAAqB;QACxC,mBAAc,GAAd,cAAc,CAAgB;IACrC,CAAC;IAEJ,OAAO;QACL,IAAI,CAAC,KAAK;aACP,MAAM,CAAC,eAAe,CAAC;aACvB,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;aACb,SAAS,CAAC,CAAC,SAAS,EAAE,EAAE;YACvB,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,mBAAmB,IAAI,CAAC,IAAI,CAAC,mBAAmB,CAAC,WAAW,CAAC,SAAS,CAAC,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC,qBAAqB,CAAC,EAAE;gBACpI,IAAI,EAAU,CAAC;gBAEf,IAAI,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,KAAK,cAAc,EAAE;oBACpD,EAAE,GAAG,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,gBAAgB,CAAC,CAAC;iBACxD;qBAAM;oBACL,EAAE,GAAI,SAAS,CAAC,IAAwB,CAAC,KAAK,CAAC,MAAM,IAAK,SAAS,CAAC,IAAY,CAAC,KAAK,CAAC,IAAI,IAAI,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;iBACxH;gBACD,IAAI,CAAC,gBAAgB,CAAC,EAAE,CAAC,CAAC;aAC3B;QACH,CAAC,CAAC,CAAC;IACP,CAAC;IAEO,gBAAgB,CAAC,EAAU;QACjC,IAAI,CAAC,cAAc,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,MAAM,EAAE,EAAE;YACjE,MAAM,QAAQ,GAAG,MAAM,CAAC,QAAQ,IAAI,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC;YACpD,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,cAAc,CAAC,EAAE,EAAE,EAAE,QAAQ,EAAE,CAAC,CAAC,CAAC;QAC5D,CAAC,CAAC,CAAC;IACL,CAAC;uGAnCU,iBAAiB;2FAAjB,iBAAiB,8IAnBlB;;;;;;;;;;;;;;;GAeT,2DAjBS,YAAY,kIAAE,eAAe,2FAAE,eAAe,2LAAE,aAAa,mLAAE,aAAa,kLAAE,eAAe;;SAqB5F,iBAAiB;2FAAjB,iBAAiB;kBAvB7B,SAAS;mBAAC;oBACT,UAAU,EAAE,IAAI;oBAChB,OAAO,EAAE,CAAC,YAAY,EAAE,eAAe,EAAE,eAAe,EAAE,aAAa,EAAE,aAAa,EAAE,eAAe,CAAC;oBACxG,QAAQ,EAAE,eAAe;oBACzB,QAAQ,EAAE;;;;;;;;;;;;;;;GAeT;oBACD,aAAa,EAAE,iBAAiB,CAAC,IAAI;oBACrC,IAAI,EAAE,EAAE,KAAK,EAAE,eAAe,EAAE;iBACjC;gLAIU,IAAI;sBAAZ,KAAK","sourcesContent":["/*!\n * Copyright © 2005-2024 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 { Component, ViewEncapsulation, Input, inject } from '@angular/core';\nimport { Store } from '@ngrx/store';\nimport { AppStore, ViewNodeAction, getAppSelection } from '@alfresco/aca-shared/store';\nimport { ActivatedRoute, Router } from '@angular/router';\nimport { take } from 'rxjs/operators';\nimport { SharedLinkEntry } from '@alfresco/js-api';\nimport { AutoDownloadService, AppSettingsService } from '@alfresco/aca-shared';\nimport { CommonModule } from '@angular/common';\nimport { TranslateModule } from '@ngx-translate/core';\nimport { MatButtonModule } from '@angular/material/button';\nimport { MatIconModule } from '@angular/material/icon';\nimport { MatMenuModule } from '@angular/material/menu';\nimport { MatDialogModule } from '@angular/material/dialog';\n\n@Component({\n  standalone: true,\n  imports: [CommonModule, TranslateModule, MatButtonModule, MatIconModule, MatMenuModule, MatDialogModule],\n  selector: 'app-view-node',\n  template: `\n    <button\n      *ngIf=\"data.iconButton\"\n      mat-icon-button\n      [attr.aria-label]=\"data.title | translate\"\n      [attr.title]=\"data.title | translate\"\n      (click)=\"onClick()\"\n    >\n      <mat-icon>visibility</mat-icon>\n    </button>\n\n    <button *ngIf=\"data.menuButton\" mat-menu-item (click)=\"onClick()\">\n      <mat-icon>visibility</mat-icon>\n      <span>{{ data.title | translate }}</span>\n    </button>\n  `,\n  encapsulation: ViewEncapsulation.None,\n  host: { class: 'app-view-node' }\n})\nexport class ViewNodeComponent {\n  private settings = inject(AppSettingsService);\n\n  @Input() data: { title?: string; menuButton?: boolean; iconButton?: boolean };\n\n  constructor(\n    private store: Store<AppStore>,\n    private router: Router,\n    private autoDownloadService: AutoDownloadService,\n    private activatedRoute: ActivatedRoute\n  ) {}\n\n  onClick() {\n    this.store\n      .select(getAppSelection)\n      .pipe(take(1))\n      .subscribe((selection) => {\n        if (!this.settings.autoDownloadEnabled || !this.autoDownloadService.tryDownload(selection.file, this.settings.authDownloadThreshold)) {\n          let id: string;\n\n          if (selection.file.entry.nodeType === 'app:filelink') {\n            id = selection.file.entry.properties['cm:destination'];\n          } else {\n            id = (selection.file as SharedLinkEntry).entry.nodeId || (selection.file as any).entry.guid || selection.file.entry.id;\n          }\n          this.navigateToViewer(id);\n        }\n      });\n  }\n\n  private navigateToViewer(id: string): void {\n    this.activatedRoute.queryParams.pipe(take(1)).subscribe((params) => {\n      const location = params.location || this.router.url;\n      this.store.dispatch(new ViewNodeAction(id, { location }));\n    });\n  }\n}\n"]}