@alfresco/aca-content 4.1.0 → 4.2.0-5542991658

package/esm2020/lib/services/node-template.service.mjs

@@ -146,4 +146,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.3", ngImpor
                     providedIn: 'root'
                 }]
         }], ctorParameters: function () { return [{ type: i1.Store }, { type: i2.AlfrescoApiService }, { type: i2.TranslationService }, { type: i3.MatDialog }]; } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"node-template.service.js","sourceRoot":"","sources":["../../../../../../projects/aca-content/src/lib/services/node-template.service.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 { Injectable } from '@angular/core';\nimport { MatDialog, MatDialogRef } from '@angular/material/dialog';\nimport { CreateFromTemplateDialogComponent } from '../dialogs/node-template/create-from-template.dialog';\nimport { Subject, from, of } from 'rxjs';\nimport { Node, MinimalNode, MinimalNodeEntryEntity, ResultNode, PathElement, SearchApi } from '@alfresco/js-api';\nimport { AlfrescoApiService, TranslationService } from '@alfresco/adf-core';\nimport { switchMap, catchError } from 'rxjs/operators';\nimport { Store } from '@ngrx/store';\nimport { AppStore, SnackbarErrorAction } from '@alfresco/aca-shared/store';\nimport { ContentNodeSelectorComponent, ContentNodeSelectorComponentData, ShareDataRow, NodeAction } from '@alfresco/adf-content-services';\n\nexport interface TemplateDialogConfig {\n  primaryPathName: string;\n  selectionType: string;\n}\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class NodeTemplateService {\n  private currentTemplateConfig: TemplateDialogConfig = null;\n  private rootNode: ResultNode;\n\n  _searchApi: SearchApi;\n  get searchApi(): SearchApi {\n    this._searchApi = this._searchApi ?? new SearchApi(this.alfrescoApiService.getInstance());\n    return this._searchApi;\n  }\n\n  constructor(\n    private store: Store<AppStore>,\n    private alfrescoApiService: AlfrescoApiService,\n    private translation: TranslationService,\n    public dialog: MatDialog\n  ) {}\n\n  selectTemplateDialog(config: TemplateDialogConfig): Subject<Node[]> {\n    this.currentTemplateConfig = config;\n\n    const select = new Subject<Node[]>();\n    select.subscribe({\n      complete: this.close.bind(this)\n    });\n\n    const data: ContentNodeSelectorComponentData = {\n      selectionMode: 'single',\n      title: this.title(config.selectionType),\n      actionName: NodeAction.NEXT,\n      dropdownHideMyFiles: true,\n      currentFolderId: null,\n      dropdownSiteList: null,\n      breadcrumbTransform: this.transformNode.bind(this),\n      select,\n      showSearch: false,\n      showDropdownSiteList: false,\n      isSelectionValid: this.isSelectionValid.bind(this),\n      rowFilter: this.rowFilter.bind(this)\n    };\n\n    const query = {\n      query: {\n        query: `PATH:\"//${config.primaryPathName}\"`,\n        language: 'afts'\n      },\n      include: ['path', 'properties', 'allowableOperations', 'permissions']\n    };\n\n    from(this.searchApi.search(query))\n      .pipe(\n        switchMap((response) => {\n          const entry = response.list.entries[0].entry;\n          this.rootNode = entry;\n          data.currentFolderId = entry.id;\n\n          return this.dialog\n            .open(ContentNodeSelectorComponent, {\n              data,\n              panelClass: ['adf-content-node-selector-dialog', 'aca-template-node-selector-dialog'],\n              width: '630px'\n            })\n            .afterClosed();\n        }),\n        catchError((error) => {\n          this.store.dispatch(new SnackbarErrorAction('APP.MESSAGES.ERRORS.GENERIC'));\n          return of(error);\n        })\n      )\n      .subscribe({ next: () => select.complete() });\n\n    return select;\n  }\n\n  createTemplateDialog(node: Node): MatDialogRef<CreateFromTemplateDialogComponent> {\n    const dialog = this.dialog.open(CreateFromTemplateDialogComponent, {\n      data: node,\n      panelClass: 'aca-create-from-template-dialog',\n      width: '630px'\n    });\n    dialog.afterClosed().subscribe(() => NodeTemplateService.focusCreateMenuButton());\n    return dialog;\n  }\n\n  private transformNode(node: MinimalNode): MinimalNode {\n    if (node && node.path && node.path && node.path.elements instanceof Array) {\n      node.path.elements = this.getPathElements(node);\n    }\n    return node;\n  }\n\n  private isSelectionValid(node: Node): boolean {\n    if (!node.path.elements.length) {\n      return false;\n    }\n\n    if (this.currentTemplateConfig.selectionType === 'folder') {\n      return node.isFolder;\n    }\n\n    return node.isFile;\n  }\n\n  private close() {\n    this.dialog.closeAll();\n    NodeTemplateService.focusCreateMenuButton();\n  }\n\n  private title(selectionType: string) {\n    if (selectionType === 'file') {\n      return this.translation.instant('NODE_SELECTOR.SELECT_FILE_TEMPLATE_TITLE');\n    }\n\n    return this.translation.instant('NODE_SELECTOR.SELECT_FOLDER_TEMPLATE_TITLE');\n  }\n\n  private rowFilter(row: ShareDataRow): boolean {\n    const node: MinimalNodeEntryEntity = row.node.entry;\n    return node.nodeType !== 'app:filelink' && node.nodeType !== 'app:folderlink';\n  }\n\n  private getPathElements(node: Node): PathElement[] {\n    return node.path.elements.filter((pathElement) => !this.rootNode.path.elements.some((rootPathElement) => pathElement.id === rootPathElement.id));\n  }\n\n  private static focusCreateMenuButton(): void {\n    document.querySelector<HTMLElement>('app-toolbar-menu button[id=\"app.toolbar.create\"]').focus();\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"node-template.service.js","sourceRoot":"","sources":["../../../../../../projects/aca-content/src/lib/services/node-template.service.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 { Injectable } from '@angular/core';\nimport { MatDialog, MatDialogRef } from '@angular/material/dialog';\nimport { CreateFromTemplateDialogComponent } from '../dialogs/node-template/create-from-template.dialog';\nimport { Subject, from, of } from 'rxjs';\nimport { Node, MinimalNode, MinimalNodeEntryEntity, ResultNode, PathElement, SearchApi } from '@alfresco/js-api';\nimport { AlfrescoApiService, TranslationService } from '@alfresco/adf-core';\nimport { switchMap, catchError } from 'rxjs/operators';\nimport { Store } from '@ngrx/store';\nimport { AppStore, SnackbarErrorAction } from '@alfresco/aca-shared/store';\nimport { ContentNodeSelectorComponent, ContentNodeSelectorComponentData, ShareDataRow, NodeAction } from '@alfresco/adf-content-services';\n\nexport interface TemplateDialogConfig {\n  primaryPathName: string;\n  selectionType: string;\n}\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class NodeTemplateService {\n  private currentTemplateConfig: TemplateDialogConfig = null;\n  private rootNode: ResultNode;\n\n  private _searchApi: SearchApi;\n  get searchApi(): SearchApi {\n    this._searchApi = this._searchApi ?? new SearchApi(this.alfrescoApiService.getInstance());\n    return this._searchApi;\n  }\n\n  constructor(\n    private store: Store<AppStore>,\n    private alfrescoApiService: AlfrescoApiService,\n    private translation: TranslationService,\n    public dialog: MatDialog\n  ) {}\n\n  selectTemplateDialog(config: TemplateDialogConfig): Subject<Node[]> {\n    this.currentTemplateConfig = config;\n\n    const select = new Subject<Node[]>();\n    select.subscribe({\n      complete: this.close.bind(this)\n    });\n\n    const data: ContentNodeSelectorComponentData = {\n      selectionMode: 'single',\n      title: this.title(config.selectionType),\n      actionName: NodeAction.NEXT,\n      dropdownHideMyFiles: true,\n      currentFolderId: null,\n      dropdownSiteList: null,\n      breadcrumbTransform: this.transformNode.bind(this),\n      select,\n      showSearch: false,\n      showDropdownSiteList: false,\n      isSelectionValid: this.isSelectionValid.bind(this),\n      rowFilter: this.rowFilter.bind(this)\n    };\n\n    const query = {\n      query: {\n        query: `PATH:\"//${config.primaryPathName}\"`,\n        language: 'afts'\n      },\n      include: ['path', 'properties', 'allowableOperations', 'permissions']\n    };\n\n    from(this.searchApi.search(query))\n      .pipe(\n        switchMap((response) => {\n          const entry = response.list.entries[0].entry;\n          this.rootNode = entry;\n          data.currentFolderId = entry.id;\n\n          return this.dialog\n            .open(ContentNodeSelectorComponent, {\n              data,\n              panelClass: ['adf-content-node-selector-dialog', 'aca-template-node-selector-dialog'],\n              width: '630px'\n            })\n            .afterClosed();\n        }),\n        catchError((error) => {\n          this.store.dispatch(new SnackbarErrorAction('APP.MESSAGES.ERRORS.GENERIC'));\n          return of(error);\n        })\n      )\n      .subscribe({ next: () => select.complete() });\n\n    return select;\n  }\n\n  createTemplateDialog(node: Node): MatDialogRef<CreateFromTemplateDialogComponent> {\n    const dialog = this.dialog.open(CreateFromTemplateDialogComponent, {\n      data: node,\n      panelClass: 'aca-create-from-template-dialog',\n      width: '630px'\n    });\n    dialog.afterClosed().subscribe(() => NodeTemplateService.focusCreateMenuButton());\n    return dialog;\n  }\n\n  private transformNode(node: MinimalNode): MinimalNode {\n    if (node && node.path && node.path && node.path.elements instanceof Array) {\n      node.path.elements = this.getPathElements(node);\n    }\n    return node;\n  }\n\n  private isSelectionValid(node: Node): boolean {\n    if (!node.path.elements.length) {\n      return false;\n    }\n\n    if (this.currentTemplateConfig.selectionType === 'folder') {\n      return node.isFolder;\n    }\n\n    return node.isFile;\n  }\n\n  private close() {\n    this.dialog.closeAll();\n    NodeTemplateService.focusCreateMenuButton();\n  }\n\n  private title(selectionType: string) {\n    if (selectionType === 'file') {\n      return this.translation.instant('NODE_SELECTOR.SELECT_FILE_TEMPLATE_TITLE');\n    }\n\n    return this.translation.instant('NODE_SELECTOR.SELECT_FOLDER_TEMPLATE_TITLE');\n  }\n\n  private rowFilter(row: ShareDataRow): boolean {\n    const node: MinimalNodeEntryEntity = row.node.entry;\n    return node.nodeType !== 'app:filelink' && node.nodeType !== 'app:folderlink';\n  }\n\n  private getPathElements(node: Node): PathElement[] {\n    return node.path.elements.filter((pathElement) => !this.rootNode.path.elements.some((rootPathElement) => pathElement.id === rootPathElement.id));\n  }\n\n  private static focusCreateMenuButton(): void {\n    document.querySelector<HTMLElement>('app-toolbar-menu button[id=\"app.toolbar.create\"]').focus();\n  }\n}\n"]}

package/esm2020/ms-office/aos-extension.module.mjs

@@ -26,23 +26,21 @@ import { NgModule } from '@angular/core';
 import { EffectsModule } from '@ngrx/effects';
 import { AosEffects } from './effects/aos.effects';
 import { TranslationService } from '@alfresco/adf-core';
-import { AlfrescoOfficeExtensionService } from '@alfresco/aca-shared';
 import { canOpenWithOffice } from '@alfresco/aca-shared/rules';
 import * as i0 from "@angular/core";
 import * as i1 from "@alfresco/adf-extensions";
 import * as i2 from "@alfresco/adf-core";
-import * as i3 from "@alfresco/aca-shared";
-import * as i4 from "@ngrx/effects";
+import * as i3 from "@ngrx/effects";
 export class AosExtensionModule {
-    constructor(extensions, translation, aosService) {
+    constructor(extensions, translation) {
         translation.addTranslationFolder('ms-office', 'assets/ms-office');
         extensions.setEvaluators({
-            'aos.canOpenWithOffice': (context) => aosService.isAosPluginEnabled() && canOpenWithOffice(context)
+            'aos.canOpenWithOffice': canOpenWithOffice
         });
     }
 }
-AosExtensionModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.3", ngImport: i0, type: AosExtensionModule, deps: [{ token: i1.ExtensionService }, { token: i2.TranslationService }, { token: i3.AlfrescoOfficeExtensionService }], target: i0.ɵɵFactoryTarget.NgModule });
-AosExtensionModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.1.3", ngImport: i0, type: AosExtensionModule, imports: [i4.EffectsFeatureModule] });
+AosExtensionModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.3", ngImport: i0, type: AosExtensionModule, deps: [{ token: i1.ExtensionService }, { token: i2.TranslationService }], target: i0.ɵɵFactoryTarget.NgModule });
+AosExtensionModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.1.3", ngImport: i0, type: AosExtensionModule, imports: [i3.EffectsFeatureModule] });
 AosExtensionModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.1.3", ngImport: i0, type: AosExtensionModule, providers: [provideExtensionConfig(['aos.plugin.json'])], imports: [EffectsModule.forFeature([AosEffects])] });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.3", ngImport: i0, type: AosExtensionModule, decorators: [{
             type: NgModule,
@@ -50,5 +48,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.3", ngImpor
                     imports: [EffectsModule.forFeature([AosEffects])],
                     providers: [provideExtensionConfig(['aos.plugin.json'])]
                 }]
-        }], ctorParameters: function () { return [{ type: i1.ExtensionService }, { type: i2.TranslationService }, { type: i3.AlfrescoOfficeExtensionService }]; } });
-//# sourceMappingURL=data:application/json;base64,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
+        }], ctorParameters: function () { return [{ type: i1.ExtensionService }, { type: i2.TranslationService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/preview/alfresco-aca-content-preview.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWxmcmVzY28tYWNhLWNvbnRlbnQtcHJldmlldy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2FjYS1jb250ZW50L3ByZXZpZXcvc3JjL2FsZnJlc2NvLWFjYS1jb250ZW50LXByZXZpZXcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==

package/esm2020/preview/lib/components/preview.component.mjs

@@ -0,0 +1,406 @@
+/*!
+ * 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, HostListener } from '@angular/core';
+import { Location } from '@angular/common';
+import { ActivatedRoute, PRIMARY_OUTLET } from '@angular/router';
+import { debounceTime, map, takeUntil } from 'rxjs/operators';
+import { UserPreferencesService, ObjectUtils } from '@alfresco/adf-core';
+import { ViewerActionTypes, SetSelectedNodesAction } from '@alfresco/aca-shared/store';
+import { PageComponent, AppHookService, ContentApiService } from '@alfresco/aca-shared';
+import { from } from 'rxjs';
+import { Actions, ofType } from '@ngrx/effects';
+import { NodesApiService } from '@alfresco/adf-content-services';
+import * as i0 from "@angular/core";
+import * as i1 from "@alfresco/aca-shared";
+import * as i2 from "@alfresco/adf-core";
+import * as i3 from "@angular/router";
+import * as i4 from "@alfresco/adf-content-services";
+import * as i5 from "@ngrx/effects";
+import * as i6 from "@angular/common";
+export class PreviewComponent extends PageComponent {
+    constructor(contentApi, preferences, route, nodesApiService, actions$, location, appHookService) {
+        super();
+        this.contentApi = contentApi;
+        this.preferences = preferences;
+        this.route = route;
+        this.nodesApiService = nodesApiService;
+        this.actions$ = actions$;
+        this.location = location;
+        this.appHookService = appHookService;
+        this.previewLocation = null;
+        this.routesSkipNavigation = ['shared', 'recent-files', 'favorites'];
+        this.navigateSource = null;
+        this.navigationSources = ['favorites', 'libraries', 'personal-files', 'recent-files', 'shared'];
+        this.folderId = null;
+        this.nodeId = null;
+        this.navigateMultiple = false;
+        this.openWith = [];
+        this.contentExtensions = [];
+        this.showRightSide = false;
+        this.navigateBackAsClose = false;
+        this.simplestMode = false;
+        this.recentFileFilters = [
+            'TYPE:"content"',
+            '-PNAME:"0/wiki"',
+            '-TYPE:"app:filelink"',
+            '-TYPE:"fm:post"',
+            '-TYPE:"cm:thumbnail"',
+            '-TYPE:"cm:failedThumbnail"',
+            '-TYPE:"cm:rating"',
+            '-TYPE:"dl:dataList"',
+            '-TYPE:"dl:todoList"',
+            '-TYPE:"dl:issue"',
+            '-TYPE:"dl:contact"',
+            '-TYPE:"dl:eventAgenda"',
+            '-TYPE:"dl:event"',
+            '-TYPE:"dl:task"',
+            '-TYPE:"dl:simpletask"',
+            '-TYPE:"dl:meetingAgenda"',
+            '-TYPE:"dl:location"',
+            '-TYPE:"fm:topic"',
+            '-TYPE:"fm:post"',
+            '-TYPE:"ia:calendarEvent"',
+            '-TYPE:"lnk:link"'
+        ];
+        this.containersSkipNavigation = ['adf-viewer__sidebar', 'cdk-overlay-container', 'adf-image-viewer'];
+    }
+    ngOnInit() {
+        super.ngOnInit();
+        from(this.infoDrawerOpened$)
+            .pipe(takeUntil(this.onDestroy$))
+            .subscribe((val) => {
+            this.showRightSide = val;
+        });
+        this.previewLocation = this.router.url.substr(0, this.router.url.indexOf('/', 1)).replace(/\//g, '');
+        const routeData = this.route.snapshot.data;
+        this.navigateBackAsClose = !!routeData.navigateBackAsClose;
+        this.simplestMode = !!routeData.simplestMode;
+        if (routeData.navigateMultiple) {
+            this.navigateMultiple = true;
+        }
+        if (routeData.navigateSource) {
+            const source = routeData.navigateSource.toLowerCase();
+            if (this.navigationSources.includes(source)) {
+                this.navigateSource = routeData.navigateSource;
+            }
+        }
+        this.route.params.subscribe((params) => {
+            this.folderId = params.folderId;
+            const id = params.nodeId;
+            if (id) {
+                this.displayNode(id);
+            }
+        });
+        this.subscriptions = this.subscriptions.concat([
+            this.appHookService.nodesDeleted.subscribe(() => this.navigateToFileLocation(true)),
+            this.uploadService.fileUploadDeleted.subscribe(() => this.navigateToFileLocation(true)),
+            this.uploadService.fileUploadComplete.pipe(debounceTime(300)).subscribe((file) => this.nodesApiService.nodeUpdated.next(file.data.entry)),
+            this.actions$
+                .pipe(ofType(ViewerActionTypes.ClosePreview), map(() => this.navigateToFileLocation(true)))
+                .subscribe(() => { })
+        ]);
+        this.extensions
+            .getOpenWithActions()
+            .pipe(takeUntil(this.onDestroy$))
+            .subscribe((actions) => {
+            this.openWith = actions;
+        });
+    }
+    ngOnDestroy() {
+        super.ngOnDestroy();
+    }
+    /**
+     * Loads the particular node into the Viewer
+     *
+     * @param id Unique identifier for the Node to display
+     */
+    async displayNode(id) {
+        if (id) {
+            try {
+                this.node = await this.contentApi.getNodeInfo(id).toPromise();
+                this.store.dispatch(new SetSelectedNodesAction([{ entry: this.node }]));
+                if (this.node && this.node.isFile) {
+                    const nearest = await this.getNearestNodes(this.node.id, this.node.parentId);
+                    this.previousNodeId = nearest.left;
+                    this.nextNodeId = nearest.right;
+                    this.nodeId = this.node.id;
+                    return;
+                }
+                await this.router.navigate([this.previewLocation, id]);
+            }
+            catch (err) {
+                if (!err || err.status !== 401) {
+                    await this.router.navigate([this.previewLocation, id]);
+                }
+            }
+        }
+    }
+    handleKeyboardEvent(event) {
+        const key = event.keyCode;
+        const rightArrow = 39;
+        const leftArrow = 37;
+        if (key === rightArrow || key === leftArrow) {
+            event.preventDefault();
+            event.stopImmediatePropagation();
+        }
+    }
+    /**
+     * Handles the visibility change of the Viewer component.
+     *
+     * @param isVisible Indicator whether Viewer is visible or hidden.
+     */
+    onVisibilityChanged(isVisible) {
+        const shouldNavigate = !isVisible;
+        this.navigateToFileLocation(shouldNavigate);
+    }
+    navigateToFileLocation(shouldNavigate) {
+        if (shouldNavigate) {
+            if (this.navigateBackAsClose) {
+                this.location.back();
+            }
+            else {
+                const shouldSkipNavigation = this.routesSkipNavigation.includes(this.previewLocation);
+                const route = this.getNavigationCommands(this.previewLocation);
+                if (!shouldSkipNavigation && this.folderId) {
+                    route.push(this.folderId);
+                }
+                this.router.navigate(route);
+            }
+        }
+    }
+    /** Handles navigation to a previous document */
+    onNavigateBefore(event) {
+        if (event.type !== 'click' && this.shouldNavigate(event.target)) {
+            return;
+        }
+        if (this.previousNodeId) {
+            this.router.navigate(this.getPreviewPath(this.folderId, this.previousNodeId));
+        }
+    }
+    /** Handles navigation to a next document */
+    onNavigateNext(event) {
+        if (event.type !== 'click' && this.shouldNavigate(event.target)) {
+            return;
+        }
+        if (this.nextNodeId) {
+            this.router.navigate(this.getPreviewPath(this.folderId, this.nextNodeId));
+        }
+    }
+    /**
+     * Generates a node preview route based on folder and node IDs.
+     *
+     * @param folderId Folder ID
+     * @param nodeId Node ID
+     */
+    getPreviewPath(folderId, nodeId) {
+        const route = [this.previewLocation];
+        if (folderId) {
+            route.push(folderId);
+        }
+        if (nodeId) {
+            route.push('preview', nodeId);
+        }
+        return route;
+    }
+    /**
+     * Retrieves nearest node information for the given node and folder.
+     *
+     * @param nodeId Unique identifier of the document node
+     * @param folderId Unique identifier of the containing folder node.
+     */
+    async getNearestNodes(nodeId, folderId) {
+        const empty = {
+            left: null,
+            right: null
+        };
+        if (nodeId && folderId) {
+            try {
+                const ids = await this.getFileIds(this.navigateSource, folderId);
+                const idx = ids.indexOf(nodeId);
+                if (idx >= 0) {
+                    return {
+                        left: ids[idx - 1] || null,
+                        right: ids[idx + 1] || null
+                    };
+                }
+                else {
+                    return empty;
+                }
+            }
+            catch {
+                return empty;
+            }
+        }
+        else {
+            return empty;
+        }
+    }
+    /**
+     * Retrieves a list of node identifiers for the folder and data source.
+     *
+     * @param source Data source name. Allowed values are: personal-files, libraries, favorites, shared, recent-files.
+     * @param folderId Containing folder node identifier for 'personal-files' and 'libraries' sources.
+     */
+    async getFileIds(source, folderId) {
+        if ((source === 'personal-files' || source === 'libraries') && folderId) {
+            const sortKey = this.preferences.get('personal-files.sorting.key') || 'modifiedAt';
+            const sortDirection = this.preferences.get('personal-files.sorting.direction') || 'desc';
+            const nodes = await this.contentApi
+                .getNodeChildren(folderId, {
+                // orderBy: `${sortKey} ${sortDirection}`,
+                fields: ['id', this.getRootField(sortKey)],
+                where: '(isFile=true)'
+            })
+                .toPromise();
+            const entries = nodes.list.entries.map((obj) => obj.entry);
+            this.sort(entries, sortKey, sortDirection);
+            return entries.map((obj) => obj.id);
+        }
+        if (source === 'favorites') {
+            const nodes = await this.contentApi
+                .getFavorites('-me-', {
+                where: '(EXISTS(target/file))',
+                fields: ['target']
+            })
+                .toPromise();
+            const sortKey = this.preferences.get('favorites.sorting.key') || 'modifiedAt';
+            const sortDirection = this.preferences.get('favorites.sorting.direction') || 'desc';
+            const files = nodes.list.entries.map((obj) => obj.entry.target.file);
+            this.sort(files, sortKey, sortDirection);
+            return files.map((f) => f.id);
+        }
+        if (source === 'shared') {
+            const sortingKey = this.preferences.get('shared.sorting.key') || 'modifiedAt';
+            const sortingDirection = this.preferences.get('shared.sorting.direction') || 'desc';
+            const nodes = await this.contentApi
+                .findSharedLinks({
+                fields: ['nodeId', this.getRootField(sortingKey)]
+            })
+                .toPromise();
+            const entries = nodes.list.entries.map((obj) => obj.entry);
+            this.sort(entries, sortingKey, sortingDirection);
+            return entries.map((obj) => obj.nodeId);
+        }
+        if (source === 'recent-files') {
+            const person = await this.contentApi.getPerson('-me-').toPromise();
+            const username = person.entry.id;
+            const sortingKey = this.preferences.get('recent-files.sorting.key') || 'modifiedAt';
+            const sortingDirection = this.preferences.get('recent-files.sorting.direction') || 'desc';
+            const query = {
+                query: {
+                    query: '*',
+                    language: 'afts'
+                },
+                filterQueries: [
+                    { query: `cm:modified:[NOW/DAY-30DAYS TO NOW/DAY+1DAY]` },
+                    { query: `cm:modifier:${username} OR cm:creator:${username}` },
+                    {
+                        query: this.recentFileFilters.join(' AND ')
+                    }
+                ],
+                fields: ['id', this.getRootField(sortingKey)],
+                include: ['path', 'properties', 'allowableOperations'],
+                sort: [
+                    {
+                        type: 'FIELD',
+                        field: 'cm:modified',
+                        ascending: false
+                    }
+                ]
+            };
+            const nodes = await this.contentApi.search(query).toPromise();
+            const entries = nodes.list.entries.map((obj) => obj.entry);
+            this.sort(entries, sortingKey, sortingDirection);
+            return entries.map((obj) => obj.id);
+        }
+        return [];
+    }
+    sort(items, key, direction) {
+        const options = {};
+        if (key.includes('sizeInBytes') || key === 'name') {
+            options.numeric = true;
+        }
+        items.sort((a, b) => {
+            let left = ObjectUtils.getValue(a, key);
+            if (left) {
+                left = left instanceof Date ? left.valueOf().toString() : left.toString();
+            }
+            else {
+                left = '';
+            }
+            let right = ObjectUtils.getValue(b, key);
+            if (right) {
+                right = right instanceof Date ? right.valueOf().toString() : right.toString();
+            }
+            else {
+                right = '';
+            }
+            return direction === 'asc' ? left.localeCompare(right, undefined, options) : right.localeCompare(left, undefined, options);
+        });
+    }
+    /**
+     * Get the root field name from the property path.
+     * Example: 'property1.some.child.property' => 'property1'
+     *
+     * @param path Property path
+     */
+    getRootField(path) {
+        if (path) {
+            return path.split('.')[0];
+        }
+        return path;
+    }
+    getNavigationCommands(url) {
+        const urlTree = this.router.parseUrl(url);
+        const urlSegmentGroup = urlTree.root.children[PRIMARY_OUTLET];
+        if (!urlSegmentGroup) {
+            return [url];
+        }
+        const urlSegments = urlSegmentGroup.segments;
+        return urlSegments.reduce(function (acc, item) {
+            acc.push(item.path, item.parameters);
+            return acc;
+        }, []);
+    }
+    shouldNavigate(element) {
+        let currentElement = element.parentElement;
+        while (currentElement && !this.isChild(currentElement.classList)) {
+            currentElement = currentElement.parentElement;
+        }
+        return !!currentElement;
+    }
+    isChild(list) {
+        return Array.from(list).some((className) => this.containersSkipNavigation.includes(className));
+    }
+}
+PreviewComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.3", ngImport: i0, type: PreviewComponent, deps: [{ token: i1.ContentApiService }, { token: i2.UserPreferencesService }, { token: i3.ActivatedRoute }, { token: i4.NodesApiService }, { token: i5.Actions }, { token: i6.Location }, { token: i1.AppHookService }], target: i0.ɵɵFactoryTarget.Component });
+PreviewComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.1.3", type: PreviewComponent, selector: "app-preview", host: { listeners: { "document:keydown": "handleKeyboardEvent($event)" }, classAttribute: "app-preview" }, usesInheritance: true, ngImport: i0, template: "<ng-container *ngIf=\"nodeId\">\n  <adf-alfresco-viewer\n    [ngClass]=\"{\n      'right_side--hide': !showRightSide\n    }\"\n    [nodeId]=\"nodeId\"\n    [allowNavigate]=\"navigateMultiple\"\n    [allowRightSidebar]=\"true\"\n    [allowPrint]=\"false\"\n    [showRightSidebar]=\"true\"\n    [allowDownload]=\"false\"\n    [allowFullScreen]=\"false\"\n    [canNavigateBefore]=\"!!previousNodeId\"\n    [canNavigateNext]=\"!!nextNodeId\"\n    [overlayMode]=\"true\"\n    (showViewerChange)=\"onVisibilityChanged($event)\"\n    (navigateBefore)=\"onNavigateBefore($event)\"\n    (navigateNext)=\"onNavigateNext($event)\"\n  >\n    <adf-viewer-sidebar *ngIf=\"infoDrawerOpened$ | async\">\n      <aca-info-drawer [node]=\"selection.file\"></aca-info-drawer>\n    </adf-viewer-sidebar>\n\n    <adf-viewer-open-with *ngIf=\"openWith.length\">\n      <ng-container *ngFor=\"let action of openWith; trackBy: trackByActionId\">\n        <app-toolbar-menu-item [actionRef]=\"action\"></app-toolbar-menu-item>\n      </ng-container>\n    </adf-viewer-open-with>\n\n    <adf-viewer-toolbar-actions *ngIf=\"!simplestMode\">\n      <ng-container *ngFor=\"let action of viewerToolbarActions; trackBy: trackByActionId\">\n        <aca-toolbar-action [actionRef]=\"action\"></aca-toolbar-action>\n      </ng-container>\n    </adf-viewer-toolbar-actions>\n  </adf-alfresco-viewer>\n</ng-container>\n", styles: [".app-preview{width:100%;height:100%}.adf-viewer-toolbar .adf-toolbar-divider{display:none}.adf-viewer-toolbar-actions{display:flex;flex-direction:row;align-items:center}.adf-viewer-toolbar-actions .adf-toolbar-divider{display:inline}.adf-viewer-toolbar .mat-toolbar>button:last-child{display:none}.adf-alfresco-viewer.right_side--hide .adf-viewer__sidebar__right{width:0}\n"], dependencies: [{ kind: "directive", type: i6.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i6.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i6.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i2.ViewerSidebarComponent, selector: "adf-viewer-sidebar" }, { kind: "component", type: i2.ViewerOpenWithComponent, selector: "adf-viewer-open-with" }, { kind: "component", type: i2.ViewerToolbarActionsComponent, selector: "adf-viewer-toolbar-actions" }, { kind: "component", type: i4.AlfrescoViewerComponent, selector: "adf-alfresco-viewer", inputs: ["nodeId", "versionId", "sharedLinkId", "showViewer", "maxRetries", "allowGoBack", "showToolbar", "overlayMode", "allowNavigate", "canNavigateBefore", "canNavigateNext", "allowLeftSidebar", "allowRightSidebar", "showRightSidebar", "showLeftSidebar", "allowDownload", "allowPrint", "allowFullScreen", "sidebarRightTemplate", "sidebarLeftTemplate"], outputs: ["invalidSharedLink", "navigateBefore", "navigateNext", "showViewerChange"] }, { kind: "component", type: i1.ToolbarActionComponent, selector: "aca-toolbar-action", inputs: ["data", "type", "color", "actionRef"] }, { kind: "component", type: i1.ToolbarMenuItemComponent, selector: "app-toolbar-menu-item", inputs: ["actionRef", "menuId"] }, { kind: "component", type: i1.InfoDrawerComponent, selector: "aca-info-drawer", inputs: ["nodeId", "node"] }, { kind: "pipe", type: i6.AsyncPipe, name: "async" }], encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.3", ngImport: i0, type: PreviewComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-preview', encapsulation: ViewEncapsulation.None, host: { class: 'app-preview' }, template: "<ng-container *ngIf=\"nodeId\">\n  <adf-alfresco-viewer\n    [ngClass]=\"{\n      'right_side--hide': !showRightSide\n    }\"\n    [nodeId]=\"nodeId\"\n    [allowNavigate]=\"navigateMultiple\"\n    [allowRightSidebar]=\"true\"\n    [allowPrint]=\"false\"\n    [showRightSidebar]=\"true\"\n    [allowDownload]=\"false\"\n    [allowFullScreen]=\"false\"\n    [canNavigateBefore]=\"!!previousNodeId\"\n    [canNavigateNext]=\"!!nextNodeId\"\n    [overlayMode]=\"true\"\n    (showViewerChange)=\"onVisibilityChanged($event)\"\n    (navigateBefore)=\"onNavigateBefore($event)\"\n    (navigateNext)=\"onNavigateNext($event)\"\n  >\n    <adf-viewer-sidebar *ngIf=\"infoDrawerOpened$ | async\">\n      <aca-info-drawer [node]=\"selection.file\"></aca-info-drawer>\n    </adf-viewer-sidebar>\n\n    <adf-viewer-open-with *ngIf=\"openWith.length\">\n      <ng-container *ngFor=\"let action of openWith; trackBy: trackByActionId\">\n        <app-toolbar-menu-item [actionRef]=\"action\"></app-toolbar-menu-item>\n      </ng-container>\n    </adf-viewer-open-with>\n\n    <adf-viewer-toolbar-actions *ngIf=\"!simplestMode\">\n      <ng-container *ngFor=\"let action of viewerToolbarActions; trackBy: trackByActionId\">\n        <aca-toolbar-action [actionRef]=\"action\"></aca-toolbar-action>\n      </ng-container>\n    </adf-viewer-toolbar-actions>\n  </adf-alfresco-viewer>\n</ng-container>\n", styles: [".app-preview{width:100%;height:100%}.adf-viewer-toolbar .adf-toolbar-divider{display:none}.adf-viewer-toolbar-actions{display:flex;flex-direction:row;align-items:center}.adf-viewer-toolbar-actions .adf-toolbar-divider{display:inline}.adf-viewer-toolbar .mat-toolbar>button:last-child{display:none}.adf-alfresco-viewer.right_side--hide .adf-viewer__sidebar__right{width:0}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.ContentApiService }, { type: i2.UserPreferencesService }, { type: i3.ActivatedRoute }, { type: i4.NodesApiService }, { type: i5.Actions }, { type: i6.Location }, { type: i1.AppHookService }]; }, propDecorators: { handleKeyboardEvent: [{
+                type: HostListener,
+                args: ['document:keydown', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"preview.component.js","sourceRoot":"","sources":["../../../../../../../projects/aca-content/preview/src/lib/components/preview.component.ts","../../../../../../../projects/aca-content/preview/src/lib/components/preview.component.html"],"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 { Component, OnInit, OnDestroy, ViewEncapsulation, HostListener } from '@angular/core';\nimport { Location } from '@angular/common';\nimport { ActivatedRoute, UrlTree, UrlSegmentGroup, UrlSegment, PRIMARY_OUTLET } from '@angular/router';\nimport { debounceTime, map, takeUntil } from 'rxjs/operators';\nimport { UserPreferencesService, ObjectUtils } from '@alfresco/adf-core';\nimport { ClosePreviewAction, ViewerActionTypes, SetSelectedNodesAction } from '@alfresco/aca-shared/store';\nimport { PageComponent, AppHookService, ContentApiService } from '@alfresco/aca-shared';\nimport { ContentActionRef, ViewerExtensionRef } from '@alfresco/adf-extensions';\nimport { SearchRequest } from '@alfresco/js-api';\nimport { from } from 'rxjs';\nimport { Actions, ofType } from '@ngrx/effects';\nimport { NodesApiService } from '@alfresco/adf-content-services';\n\n@Component({\n  selector: 'app-preview',\n  templateUrl: './preview.component.html',\n  styleUrls: ['./preview.component.scss'],\n  encapsulation: ViewEncapsulation.None,\n  host: { class: 'app-preview' }\n})\nexport class PreviewComponent extends PageComponent implements OnInit, OnDestroy {\n  previewLocation: string = null;\n  routesSkipNavigation = ['shared', 'recent-files', 'favorites'];\n  navigateSource: string = null;\n  navigationSources = ['favorites', 'libraries', 'personal-files', 'recent-files', 'shared'];\n  folderId: string = null;\n  nodeId: string = null;\n  previousNodeId: string;\n  nextNodeId: string;\n  navigateMultiple = false;\n  openWith: Array<ContentActionRef> = [];\n  contentExtensions: Array<ViewerExtensionRef> = [];\n  showRightSide = false;\n  navigateBackAsClose = false;\n  simplestMode = false;\n\n  recentFileFilters = [\n    'TYPE:\"content\"',\n    '-PNAME:\"0/wiki\"',\n    '-TYPE:\"app:filelink\"',\n    '-TYPE:\"fm:post\"',\n    '-TYPE:\"cm:thumbnail\"',\n    '-TYPE:\"cm:failedThumbnail\"',\n    '-TYPE:\"cm:rating\"',\n    '-TYPE:\"dl:dataList\"',\n    '-TYPE:\"dl:todoList\"',\n    '-TYPE:\"dl:issue\"',\n    '-TYPE:\"dl:contact\"',\n    '-TYPE:\"dl:eventAgenda\"',\n    '-TYPE:\"dl:event\"',\n    '-TYPE:\"dl:task\"',\n    '-TYPE:\"dl:simpletask\"',\n    '-TYPE:\"dl:meetingAgenda\"',\n    '-TYPE:\"dl:location\"',\n    '-TYPE:\"fm:topic\"',\n    '-TYPE:\"fm:post\"',\n    '-TYPE:\"ia:calendarEvent\"',\n    '-TYPE:\"lnk:link\"'\n  ];\n\n  private containersSkipNavigation = ['adf-viewer__sidebar', 'cdk-overlay-container', 'adf-image-viewer'];\n\n  constructor(\n    private contentApi: ContentApiService,\n    private preferences: UserPreferencesService,\n    private route: ActivatedRoute,\n    private nodesApiService: NodesApiService,\n    private actions$: Actions,\n    private location: Location,\n    private appHookService: AppHookService\n  ) {\n    super();\n  }\n\n  ngOnInit() {\n    super.ngOnInit();\n\n    from(this.infoDrawerOpened$)\n      .pipe(takeUntil(this.onDestroy$))\n      .subscribe((val) => {\n        this.showRightSide = val;\n      });\n\n    this.previewLocation = this.router.url.substr(0, this.router.url.indexOf('/', 1)).replace(/\\//g, '');\n\n    const routeData = this.route.snapshot.data;\n    this.navigateBackAsClose = !!routeData.navigateBackAsClose;\n    this.simplestMode = !!routeData.simplestMode;\n\n    if (routeData.navigateMultiple) {\n      this.navigateMultiple = true;\n    }\n\n    if (routeData.navigateSource) {\n      const source = routeData.navigateSource.toLowerCase();\n      if (this.navigationSources.includes(source)) {\n        this.navigateSource = routeData.navigateSource;\n      }\n    }\n\n    this.route.params.subscribe((params) => {\n      this.folderId = params.folderId;\n      const id = params.nodeId;\n      if (id) {\n        this.displayNode(id);\n      }\n    });\n\n    this.subscriptions = this.subscriptions.concat([\n      this.appHookService.nodesDeleted.subscribe(() => this.navigateToFileLocation(true)),\n\n      this.uploadService.fileUploadDeleted.subscribe(() => this.navigateToFileLocation(true)),\n\n      this.uploadService.fileUploadComplete.pipe(debounceTime(300)).subscribe((file) => this.nodesApiService.nodeUpdated.next(file.data.entry)),\n\n      this.actions$\n        .pipe(\n          ofType<ClosePreviewAction>(ViewerActionTypes.ClosePreview),\n          map(() => this.navigateToFileLocation(true))\n        )\n        .subscribe(() => {})\n    ]);\n\n    this.extensions\n      .getOpenWithActions()\n      .pipe(takeUntil(this.onDestroy$))\n      .subscribe((actions) => {\n        this.openWith = actions;\n      });\n  }\n\n  ngOnDestroy() {\n    super.ngOnDestroy();\n  }\n\n  /**\n   * Loads the particular node into the Viewer\n   *\n   * @param id Unique identifier for the Node to display\n   */\n  async displayNode(id: string) {\n    if (id) {\n      try {\n        this.node = await this.contentApi.getNodeInfo(id).toPromise();\n        this.store.dispatch(new SetSelectedNodesAction([{ entry: this.node }]));\n\n        if (this.node && this.node.isFile) {\n          const nearest = await this.getNearestNodes(this.node.id, this.node.parentId);\n\n          this.previousNodeId = nearest.left;\n          this.nextNodeId = nearest.right;\n          this.nodeId = this.node.id;\n          return;\n        }\n        await this.router.navigate([this.previewLocation, id]);\n      } catch (err) {\n        if (!err || err.status !== 401) {\n          await this.router.navigate([this.previewLocation, id]);\n        }\n      }\n    }\n  }\n\n  @HostListener('document:keydown', ['$event'])\n  handleKeyboardEvent(event: KeyboardEvent) {\n    const key = event.keyCode;\n    const rightArrow = 39;\n    const leftArrow = 37;\n\n    if (key === rightArrow || key === leftArrow) {\n      event.preventDefault();\n      event.stopImmediatePropagation();\n    }\n  }\n\n  /**\n   * Handles the visibility change of the Viewer component.\n   *\n   * @param isVisible Indicator whether Viewer is visible or hidden.\n   */\n  onVisibilityChanged(isVisible: boolean): void {\n    const shouldNavigate = !isVisible;\n    this.navigateToFileLocation(shouldNavigate);\n  }\n\n  navigateToFileLocation(shouldNavigate: boolean) {\n    if (shouldNavigate) {\n      if (this.navigateBackAsClose) {\n        this.location.back();\n      } else {\n        const shouldSkipNavigation = this.routesSkipNavigation.includes(this.previewLocation);\n        const route = this.getNavigationCommands(this.previewLocation);\n\n        if (!shouldSkipNavigation && this.folderId) {\n          route.push(this.folderId);\n        }\n        this.router.navigate(route);\n      }\n    }\n  }\n\n  /** Handles navigation to a previous document */\n  onNavigateBefore(event: MouseEvent | KeyboardEvent): void {\n    if (event.type !== 'click' && this.shouldNavigate(event.target as HTMLElement)) {\n      return;\n    }\n\n    if (this.previousNodeId) {\n      this.router.navigate(this.getPreviewPath(this.folderId, this.previousNodeId));\n    }\n  }\n\n  /** Handles navigation to a next document */\n  onNavigateNext(event: MouseEvent | KeyboardEvent): void {\n    if (event.type !== 'click' && this.shouldNavigate(event.target as HTMLElement)) {\n      return;\n    }\n\n    if (this.nextNodeId) {\n      this.router.navigate(this.getPreviewPath(this.folderId, this.nextNodeId));\n    }\n  }\n\n  /**\n   * Generates a node preview route based on folder and node IDs.\n   *\n   * @param folderId Folder ID\n   * @param nodeId Node ID\n   */\n  getPreviewPath(folderId: string, nodeId: string): any[] {\n    const route = [this.previewLocation];\n\n    if (folderId) {\n      route.push(folderId);\n    }\n\n    if (nodeId) {\n      route.push('preview', nodeId);\n    }\n\n    return route;\n  }\n\n  /**\n   * Retrieves nearest node information for the given node and folder.\n   *\n   * @param nodeId Unique identifier of the document node\n   * @param folderId Unique identifier of the containing folder node.\n   */\n  async getNearestNodes(nodeId: string, folderId: string): Promise<{ left: string; right: string }> {\n    const empty = {\n      left: null,\n      right: null\n    };\n\n    if (nodeId && folderId) {\n      try {\n        const ids = await this.getFileIds(this.navigateSource, folderId);\n        const idx = ids.indexOf(nodeId);\n\n        if (idx >= 0) {\n          return {\n            left: ids[idx - 1] || null,\n            right: ids[idx + 1] || null\n          };\n        } else {\n          return empty;\n        }\n      } catch {\n        return empty;\n      }\n    } else {\n      return empty;\n    }\n  }\n\n  /**\n   * Retrieves a list of node identifiers for the folder and data source.\n   *\n   * @param source Data source name. Allowed values are: personal-files, libraries, favorites, shared, recent-files.\n   * @param folderId Containing folder node identifier for 'personal-files' and 'libraries' sources.\n   */\n  async getFileIds(source: string, folderId?: string): Promise<string[]> {\n    if ((source === 'personal-files' || source === 'libraries') && folderId) {\n      const sortKey = this.preferences.get('personal-files.sorting.key') || 'modifiedAt';\n      const sortDirection = this.preferences.get('personal-files.sorting.direction') || 'desc';\n      const nodes = await this.contentApi\n        .getNodeChildren(folderId, {\n          // orderBy: `${sortKey} ${sortDirection}`,\n          fields: ['id', this.getRootField(sortKey)],\n          where: '(isFile=true)'\n        })\n        .toPromise();\n\n      const entries = nodes.list.entries.map((obj) => obj.entry);\n      this.sort(entries, sortKey, sortDirection);\n\n      return entries.map((obj) => obj.id);\n    }\n\n    if (source === 'favorites') {\n      const nodes = await this.contentApi\n        .getFavorites('-me-', {\n          where: '(EXISTS(target/file))',\n          fields: ['target']\n        })\n        .toPromise();\n\n      const sortKey = this.preferences.get('favorites.sorting.key') || 'modifiedAt';\n      const sortDirection = this.preferences.get('favorites.sorting.direction') || 'desc';\n      const files = nodes.list.entries.map((obj) => obj.entry.target.file);\n      this.sort(files, sortKey, sortDirection);\n\n      return files.map((f) => f.id);\n    }\n\n    if (source === 'shared') {\n      const sortingKey = this.preferences.get('shared.sorting.key') || 'modifiedAt';\n      const sortingDirection = this.preferences.get('shared.sorting.direction') || 'desc';\n\n      const nodes = await this.contentApi\n        .findSharedLinks({\n          fields: ['nodeId', this.getRootField(sortingKey)]\n        })\n        .toPromise();\n\n      const entries = nodes.list.entries.map((obj) => obj.entry);\n      this.sort(entries, sortingKey, sortingDirection);\n\n      return entries.map((obj) => obj.nodeId);\n    }\n\n    if (source === 'recent-files') {\n      const person = await this.contentApi.getPerson('-me-').toPromise();\n      const username = person.entry.id;\n      const sortingKey = this.preferences.get('recent-files.sorting.key') || 'modifiedAt';\n      const sortingDirection = this.preferences.get('recent-files.sorting.direction') || 'desc';\n\n      const query: SearchRequest = {\n        query: {\n          query: '*',\n          language: 'afts'\n        },\n        filterQueries: [\n          { query: `cm:modified:[NOW/DAY-30DAYS TO NOW/DAY+1DAY]` },\n          { query: `cm:modifier:${username} OR cm:creator:${username}` },\n          {\n            query: this.recentFileFilters.join(' AND ')\n          }\n        ],\n        fields: ['id', this.getRootField(sortingKey)],\n        include: ['path', 'properties', 'allowableOperations'],\n        sort: [\n          {\n            type: 'FIELD',\n            field: 'cm:modified',\n            ascending: false\n          }\n        ]\n      };\n      const nodes = await this.contentApi.search(query).toPromise();\n\n      const entries = nodes.list.entries.map((obj) => obj.entry);\n      this.sort(entries, sortingKey, sortingDirection);\n\n      return entries.map((obj) => obj.id);\n    }\n\n    return [];\n  }\n\n  private sort(items: any[], key: string, direction: string) {\n    const options: Intl.CollatorOptions = {};\n\n    if (key.includes('sizeInBytes') || key === 'name') {\n      options.numeric = true;\n    }\n\n    items.sort((a: any, b: any) => {\n      let left = ObjectUtils.getValue(a, key);\n      if (left) {\n        left = left instanceof Date ? left.valueOf().toString() : left.toString();\n      } else {\n        left = '';\n      }\n\n      let right = ObjectUtils.getValue(b, key);\n      if (right) {\n        right = right instanceof Date ? right.valueOf().toString() : right.toString();\n      } else {\n        right = '';\n      }\n\n      return direction === 'asc' ? left.localeCompare(right, undefined, options) : right.localeCompare(left, undefined, options);\n    });\n  }\n\n  /**\n   * Get the root field name from the property path.\n   * Example: 'property1.some.child.property' => 'property1'\n   *\n   * @param path Property path\n   */\n  getRootField(path: string) {\n    if (path) {\n      return path.split('.')[0];\n    }\n    return path;\n  }\n\n  private getNavigationCommands(url: string): any[] {\n    const urlTree: UrlTree = this.router.parseUrl(url);\n    const urlSegmentGroup: UrlSegmentGroup = urlTree.root.children[PRIMARY_OUTLET];\n\n    if (!urlSegmentGroup) {\n      return [url];\n    }\n\n    const urlSegments: UrlSegment[] = urlSegmentGroup.segments;\n\n    return urlSegments.reduce(function (acc, item) {\n      acc.push(item.path, item.parameters);\n      return acc;\n    }, []);\n  }\n\n  private shouldNavigate(element: HTMLElement): boolean {\n    let currentElement = element.parentElement;\n\n    while (currentElement && !this.isChild(currentElement.classList)) {\n      currentElement = currentElement.parentElement;\n    }\n\n    return !!currentElement;\n  }\n\n  private isChild(list: DOMTokenList): boolean {\n    return Array.from(list).some((className: string) => this.containersSkipNavigation.includes(className));\n  }\n}\n","<ng-container *ngIf=\"nodeId\">\n  <adf-alfresco-viewer\n    [ngClass]=\"{\n      'right_side--hide': !showRightSide\n    }\"\n    [nodeId]=\"nodeId\"\n    [allowNavigate]=\"navigateMultiple\"\n    [allowRightSidebar]=\"true\"\n    [allowPrint]=\"false\"\n    [showRightSidebar]=\"true\"\n    [allowDownload]=\"false\"\n    [allowFullScreen]=\"false\"\n    [canNavigateBefore]=\"!!previousNodeId\"\n    [canNavigateNext]=\"!!nextNodeId\"\n    [overlayMode]=\"true\"\n    (showViewerChange)=\"onVisibilityChanged($event)\"\n    (navigateBefore)=\"onNavigateBefore($event)\"\n    (navigateNext)=\"onNavigateNext($event)\"\n  >\n    <adf-viewer-sidebar *ngIf=\"infoDrawerOpened$ | async\">\n      <aca-info-drawer [node]=\"selection.file\"></aca-info-drawer>\n    </adf-viewer-sidebar>\n\n    <adf-viewer-open-with *ngIf=\"openWith.length\">\n      <ng-container *ngFor=\"let action of openWith; trackBy: trackByActionId\">\n        <app-toolbar-menu-item [actionRef]=\"action\"></app-toolbar-menu-item>\n      </ng-container>\n    </adf-viewer-open-with>\n\n    <adf-viewer-toolbar-actions *ngIf=\"!simplestMode\">\n      <ng-container *ngFor=\"let action of viewerToolbarActions; trackBy: trackByActionId\">\n        <aca-toolbar-action [actionRef]=\"action\"></aca-toolbar-action>\n      </ng-container>\n    </adf-viewer-toolbar-actions>\n  </adf-alfresco-viewer>\n</ng-container>\n"]}