@alfresco/aca-shared 6.0.0-11182591049 → 6.0.0-11214869577

package/esm2020/lib/components/document-base-page/document-base-page.component.mjs

@@ -0,0 +1,221 @@
+/*!
+ * 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 { DocumentListComponent, DocumentListService, SearchAiService, UploadService } from '@alfresco/adf-content-services';
+import { ShowHeaderMode, UserPreferencesService } from '@alfresco/adf-core';
+import { ViewChild, Directive, inject, HostListener } from '@angular/core';
+import { Store } from '@ngrx/store';
+import { Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import { DocumentBasePageService } from './document-base-page.service';
+import { getCurrentFolder, getAppSelection, isInfoDrawerOpened, ViewNodeAction, SetSelectedNodesAction } from '@alfresco/aca-shared/store';
+import { AppExtensionService } from '../../services/app.extension.service';
+import { isLibrary, isLocked } from '../../utils/node.utils';
+import { AutoDownloadService } from '../../services/auto-download.service';
+import { BreakpointObserver, Breakpoints } from '@angular/cdk/layout';
+import { Router } from '@angular/router';
+import { AppSettingsService } from '../../services/app-settings.service';
+import { NavigationHistoryService } from '../../services/navigation-history.service';
+import * as i0 from "@angular/core";
+/* eslint-disable @angular-eslint/directive-class-suffix */
+export class PageComponent {
+    constructor() {
+        this.onDestroy$ = new Subject();
+        this.title = 'Page';
+        this.actions = [];
+        this.viewerToolbarActions = [];
+        this.bulkActions = [];
+        this.canUpdateNode = false;
+        this.canUpload = false;
+        this.showHeader = ShowHeaderMode.Data;
+        this.filterSorting = 'name-asc';
+        this.createActions = [];
+        this.isSmallScreen = false;
+        this.selectedRowItemsCount = 0;
+        this.documentListService = inject(DocumentListService);
+        this.settings = inject(AppSettingsService);
+        this.extensions = inject(AppExtensionService);
+        this.content = inject(DocumentBasePageService);
+        this.store = inject((Store));
+        this.breakpointObserver = inject(BreakpointObserver);
+        this.uploadService = inject(UploadService);
+        this.router = inject(Router);
+        this.userPreferencesService = inject(UserPreferencesService);
+        this.searchAiService = inject(SearchAiService);
+        this.autoDownloadService = inject(AutoDownloadService, { optional: true });
+        this.navigationHistoryService = inject(NavigationHistoryService);
+        this.subscriptions = [];
+        this._searchAiInputState = {
+            active: false
+        };
+    }
+    get searchAiInputState() {
+        return this._searchAiInputState;
+    }
+    ngOnInit() {
+        this.extensions
+            .getCreateActions()
+            .pipe(takeUntil(this.onDestroy$))
+            .subscribe((actions) => {
+            this.createActions = actions;
+        });
+        this.infoDrawerOpened$ = this.store.select(isInfoDrawerOpened);
+        this.store
+            .select(getAppSelection)
+            .pipe(takeUntil(this.onDestroy$))
+            .subscribe((selection) => {
+            this.selection = selection;
+            this.canUpdateNode = this.selection.count === 1 && this.content.canUpdateNode(selection.first);
+        });
+        this.extensions
+            .getAllowedToolbarActions()
+            .pipe(takeUntil(this.onDestroy$))
+            .subscribe((actions) => {
+            this.actions = actions;
+        });
+        this.extensions
+            .getBulkActions()
+            .pipe(takeUntil(this.onDestroy$))
+            .subscribe((actions) => {
+            this.bulkActions = actions;
+        });
+        this.extensions
+            .getViewerToolbarActions()
+            .pipe(takeUntil(this.onDestroy$))
+            .subscribe((actions) => {
+            this.viewerToolbarActions = actions;
+        });
+        this.store
+            .select(getCurrentFolder)
+            .pipe(takeUntil(this.onDestroy$))
+            .subscribe((node) => {
+            this.canUpload = node && this.content.canUploadContent(node);
+        });
+        this.breakpointObserver
+            .observe([Breakpoints.HandsetPortrait, Breakpoints.HandsetLandscape])
+            .pipe(takeUntil(this.onDestroy$))
+            .subscribe((result) => {
+            this.isSmallScreen = result.matches;
+        });
+        this.searchAiService.toggleSearchAiInput$
+            .pipe(takeUntil(this.onDestroy$))
+            .subscribe((searchAiInputState) => (this._searchAiInputState = searchAiInputState));
+        this.setKnowledgeRetrievalState();
+    }
+    ngOnChanges(changes) {
+        if (changes.nodeResult?.currentValue) {
+            this.nodeResult = changes.nodeResult.currentValue;
+        }
+    }
+    ngOnDestroy() {
+        this.subscriptions.forEach((subscription) => subscription.unsubscribe());
+        this.subscriptions = [];
+        this.onDestroy$.next(true);
+        this.onDestroy$.complete();
+        this.store.dispatch(new SetSelectedNodesAction([]));
+    }
+    showPreview(node, extras) {
+        if (node?.entry) {
+            if (!this.settings.autoDownloadEnabled || !this.autoDownloadService.tryDownload(node, this.settings.authDownloadThreshold)) {
+                let id;
+                if (node.entry.nodeType === 'app:filelink') {
+                    id = node.entry.properties['cm:destination'];
+                }
+                else {
+                    id = node.entry.nodeId || node.entry.guid || node.entry.id;
+                }
+                this.store.dispatch(new ViewNodeAction(id, extras));
+            }
+        }
+    }
+    onSelectedItemsCountChanged(count) {
+        this.selectedRowItemsCount = count;
+    }
+    getParentNodeId() {
+        return this.node ? this.node.id : null;
+    }
+    imageResolver(row) {
+        if (row) {
+            if (isLocked(row.node)) {
+                return 'material-icons://lock';
+            }
+            if (isLibrary(row.node)) {
+                return 'material-icons://library_books';
+            }
+        }
+        return null;
+    }
+    reload(selectedNode) {
+        if (this.isOutletPreviewUrl()) {
+            return;
+        }
+        this.documentListService.reload();
+        if (selectedNode) {
+            this.store.dispatch(new SetSelectedNodesAction([selectedNode]));
+        }
+    }
+    trackByActionId(_, action) {
+        return action.id;
+    }
+    trackById(_, obj) {
+        return obj.id;
+    }
+    trackByColumnId(_, obj) {
+        return obj.id;
+    }
+    setKnowledgeRetrievalState() {
+        const nodes = this.userPreferencesService.get('knowledgeRetrievalNodes');
+        if (nodes && this.navigationHistoryService.shouldReturnLastSelection('/knowledge-retrieval')) {
+            this.selectedNodesState = JSON.parse(nodes);
+        }
+        if (!this.selectedNodesState && !this.router.url.startsWith('/knowledge-retrieval')) {
+            this.searchAiService.updateSearchAiInputState({
+                active: false
+            });
+        }
+    }
+    isOutletPreviewUrl() {
+        return location.href.includes('viewer:view');
+    }
+    onSortingChanged(event) {
+        this.filterSorting = event.detail.key + '-' + event.detail.direction;
+    }
+    onAllFilterCleared() {
+        if (!this.isOutletPreviewUrl()) {
+            this.documentList.node = null;
+            this.documentListService.reload();
+        }
+    }
+}
+PageComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: PageComponent, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+PageComponent.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.10", type: PageComponent, host: { listeners: { "sorting-changed": "onSortingChanged($event)" } }, viewQueries: [{ propertyName: "documentList", first: true, predicate: DocumentListComponent, descendants: true }], usesOnChanges: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: PageComponent, decorators: [{
+            type: Directive
+        }], propDecorators: { documentList: [{
+                type: ViewChild,
+                args: [DocumentListComponent]
+            }], onSortingChanged: [{
+                type: HostListener,
+                args: ['sorting-changed', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"document-base-page.component.js","sourceRoot":"","sources":["../../../../../../../projects/aca-shared/src/lib/components/document-base-page/document-base-page.component.ts"],"names":[],"mappings":"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","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 {\n  DocumentListComponent,\n  DocumentListService,\n  SearchAiInputState,\n  SearchAiService,\n  ShareDataRow,\n  UploadService\n} from '@alfresco/adf-content-services';\nimport { ShowHeaderMode, UserPreferencesService } from '@alfresco/adf-core';\nimport { ContentActionRef, DocumentListPresetRef, SelectionState } from '@alfresco/adf-extensions';\nimport { OnDestroy, OnInit, OnChanges, ViewChild, SimpleChanges, Directive, inject, HostListener } from '@angular/core';\nimport { Store } from '@ngrx/store';\nimport { NodeEntry, Node, NodePaging } from '@alfresco/js-api';\nimport { Observable, Subject, Subscription } from 'rxjs';\nimport { takeUntil } from 'rxjs/operators';\nimport { DocumentBasePageService } from './document-base-page.service';\nimport {\n  AppStore,\n  getCurrentFolder,\n  getAppSelection,\n  isInfoDrawerOpened,\n  ViewNodeAction,\n  ViewNodeExtras,\n  SetSelectedNodesAction\n} from '@alfresco/aca-shared/store';\nimport { AppExtensionService } from '../../services/app.extension.service';\nimport { isLibrary, isLocked } from '../../utils/node.utils';\nimport { AutoDownloadService } from '../../services/auto-download.service';\nimport { BreakpointObserver, Breakpoints } from '@angular/cdk/layout';\nimport { Router } from '@angular/router';\nimport { AppSettingsService } from '../../services/app-settings.service';\nimport { NavigationHistoryService } from '../../services/navigation-history.service';\n\n/* eslint-disable @angular-eslint/directive-class-suffix */\n@Directive()\nexport abstract class PageComponent implements OnInit, OnDestroy, OnChanges {\n  onDestroy$: Subject<boolean> = new Subject<boolean>();\n\n  @ViewChild(DocumentListComponent)\n  documentList: DocumentListComponent;\n\n  title = 'Page';\n  infoDrawerOpened$: Observable<boolean>;\n  node: Node;\n  selection: SelectionState;\n  actions: Array<ContentActionRef> = [];\n  viewerToolbarActions: Array<ContentActionRef> = [];\n  bulkActions: ContentActionRef[] = [];\n  canUpdateNode = false;\n  canUpload = false;\n  nodeResult: NodePaging;\n  showHeader = ShowHeaderMode.Data;\n  filterSorting = 'name-asc';\n  createActions: ContentActionRef[] = [];\n  isSmallScreen = false;\n  selectedRowItemsCount = 0;\n  selectedNodesState: SelectionState;\n\n  protected documentListService = inject(DocumentListService);\n  protected settings = inject(AppSettingsService);\n  protected extensions = inject(AppExtensionService);\n  protected content = inject(DocumentBasePageService);\n  protected store = inject<Store<AppStore>>(Store<AppStore>);\n  protected breakpointObserver = inject(BreakpointObserver);\n  protected uploadService = inject(UploadService);\n  protected router = inject(Router);\n  protected userPreferencesService = inject(UserPreferencesService);\n  protected searchAiService = inject(SearchAiService);\n  private autoDownloadService = inject(AutoDownloadService, { optional: true });\n  private navigationHistoryService = inject(NavigationHistoryService);\n\n  protected subscriptions: Subscription[] = [];\n\n  private _searchAiInputState: SearchAiInputState = {\n    active: false\n  };\n\n  get searchAiInputState(): SearchAiInputState {\n    return this._searchAiInputState;\n  }\n\n  ngOnInit() {\n    this.extensions\n      .getCreateActions()\n      .pipe(takeUntil(this.onDestroy$))\n      .subscribe((actions) => {\n        this.createActions = actions;\n      });\n\n    this.infoDrawerOpened$ = this.store.select(isInfoDrawerOpened);\n\n    this.store\n      .select(getAppSelection)\n      .pipe(takeUntil(this.onDestroy$))\n      .subscribe((selection) => {\n        this.selection = selection;\n        this.canUpdateNode = this.selection.count === 1 && this.content.canUpdateNode(selection.first);\n      });\n\n    this.extensions\n      .getAllowedToolbarActions()\n      .pipe(takeUntil(this.onDestroy$))\n      .subscribe((actions) => {\n        this.actions = actions;\n      });\n\n    this.extensions\n      .getBulkActions()\n      .pipe(takeUntil(this.onDestroy$))\n      .subscribe((actions) => {\n        this.bulkActions = actions;\n      });\n\n    this.extensions\n      .getViewerToolbarActions()\n      .pipe(takeUntil(this.onDestroy$))\n      .subscribe((actions) => {\n        this.viewerToolbarActions = actions;\n      });\n\n    this.store\n      .select(getCurrentFolder)\n      .pipe(takeUntil(this.onDestroy$))\n      .subscribe((node) => {\n        this.canUpload = node && this.content.canUploadContent(node);\n      });\n\n    this.breakpointObserver\n      .observe([Breakpoints.HandsetPortrait, Breakpoints.HandsetLandscape])\n      .pipe(takeUntil(this.onDestroy$))\n      .subscribe((result) => {\n        this.isSmallScreen = result.matches;\n      });\n\n    this.searchAiService.toggleSearchAiInput$\n      .pipe(takeUntil(this.onDestroy$))\n      .subscribe((searchAiInputState) => (this._searchAiInputState = searchAiInputState));\n\n    this.setKnowledgeRetrievalState();\n  }\n\n  ngOnChanges(changes: SimpleChanges) {\n    if (changes.nodeResult?.currentValue) {\n      this.nodeResult = changes.nodeResult.currentValue;\n    }\n  }\n\n  ngOnDestroy() {\n    this.subscriptions.forEach((subscription) => subscription.unsubscribe());\n    this.subscriptions = [];\n\n    this.onDestroy$.next(true);\n    this.onDestroy$.complete();\n    this.store.dispatch(new SetSelectedNodesAction([]));\n  }\n\n  showPreview(node: NodeEntry, extras?: ViewNodeExtras) {\n    if (node?.entry) {\n      if (!this.settings.autoDownloadEnabled || !this.autoDownloadService.tryDownload(node, this.settings.authDownloadThreshold)) {\n        let id: string;\n\n        if (node.entry.nodeType === 'app:filelink') {\n          id = node.entry.properties['cm:destination'];\n        } else {\n          id = (node as any).entry.nodeId || (node as any).entry.guid || node.entry.id;\n        }\n\n        this.store.dispatch(new ViewNodeAction(id, extras));\n      }\n    }\n  }\n\n  onSelectedItemsCountChanged(count: number) {\n    this.selectedRowItemsCount = count;\n  }\n\n  getParentNodeId(): string {\n    return this.node ? this.node.id : null;\n  }\n\n  imageResolver(row: ShareDataRow): string | null {\n    if (row) {\n      if (isLocked(row.node)) {\n        return 'material-icons://lock';\n      }\n\n      if (isLibrary(row.node)) {\n        return 'material-icons://library_books';\n      }\n    }\n\n    return null;\n  }\n\n  reload(selectedNode?: NodeEntry): void {\n    if (this.isOutletPreviewUrl()) {\n      return;\n    }\n\n    this.documentListService.reload();\n    if (selectedNode) {\n      this.store.dispatch(new SetSelectedNodesAction([selectedNode]));\n    }\n  }\n\n  trackByActionId(_: number, action: ContentActionRef) {\n    return action.id;\n  }\n\n  trackById(_: number, obj: { id: string }) {\n    return obj.id;\n  }\n\n  trackByColumnId(_: number, obj: DocumentListPresetRef): string {\n    return obj.id;\n  }\n\n  private setKnowledgeRetrievalState() {\n    const nodes = this.userPreferencesService.get('knowledgeRetrievalNodes');\n    if (nodes && this.navigationHistoryService.shouldReturnLastSelection('/knowledge-retrieval')) {\n      this.selectedNodesState = JSON.parse(nodes);\n    }\n\n    if (!this.selectedNodesState && !this.router.url.startsWith('/knowledge-retrieval')) {\n      this.searchAiService.updateSearchAiInputState({\n        active: false\n      });\n    }\n  }\n\n  private isOutletPreviewUrl(): boolean {\n    return location.href.includes('viewer:view');\n  }\n\n  @HostListener('sorting-changed', ['$event'])\n  onSortingChanged(event: any) {\n    this.filterSorting = event.detail.key + '-' + event.detail.direction;\n  }\n\n  onAllFilterCleared() {\n    if (!this.isOutletPreviewUrl()) {\n      this.documentList.node = null;\n      this.documentListService.reload();\n    }\n  }\n}\n"]}

package/esm2020/lib/components/generic-error/generic-error.component.mjs

@@ -0,0 +1,43 @@
+/*!
+ * 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, ChangeDetectionStrategy, Input } from '@angular/core';
+import { MatIconModule } from '@angular/material/icon';
+import { TranslateModule } from '@ngx-translate/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/icon";
+import * as i2 from "@ngx-translate/core";
+export class GenericErrorComponent {
+    constructor() {
+        this.text = 'APP.MESSAGES.ERRORS.MISSING_CONTENT';
+    }
+}
+GenericErrorComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: GenericErrorComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+GenericErrorComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.10", type: GenericErrorComponent, isStandalone: true, selector: "aca-generic-error", inputs: { text: "text" }, host: { classAttribute: "aca-generic-error" }, ngImport: i0, template: "<mat-icon class=\"generic-error__icon\">error</mat-icon>\n<p class=\"generic-error__title\">\n  {{ text | translate }}\n</p>\n", styles: [".aca-generic-error{color:var(--theme-text-color, rgba(0, 0, 0, .54));display:flex;align-items:center;justify-content:center;flex-direction:column;width:100%;height:100%}.aca-generic-error__title{font-size:16px}.aca-generic-error__icon{color:var(--theme-warn-color, #f44336);font-size:52px;height:52px;width:52px}\n"], dependencies: [{ kind: "ngmodule", type: MatIconModule }, { kind: "component", type: i1.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "ngmodule", type: TranslateModule }, { kind: "pipe", type: i2.TranslatePipe, name: "translate" }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: GenericErrorComponent, decorators: [{
+            type: Component,
+            args: [{ standalone: true, imports: [MatIconModule, TranslateModule], selector: 'aca-generic-error', encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, host: { class: 'aca-generic-error' }, template: "<mat-icon class=\"generic-error__icon\">error</mat-icon>\n<p class=\"generic-error__title\">\n  {{ text | translate }}\n</p>\n", styles: [".aca-generic-error{color:var(--theme-text-color, rgba(0, 0, 0, .54));display:flex;align-items:center;justify-content:center;flex-direction:column;width:100%;height:100%}.aca-generic-error__title{font-size:16px}.aca-generic-error__icon{color:var(--theme-warn-color, #f44336);font-size:52px;height:52px;width:52px}\n"] }]
+        }], propDecorators: { text: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,132 @@
+/*!
+ * 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, HostListener, Input, ViewEncapsulation } from '@angular/core';
+import { NodeEntry } from '@alfresco/js-api';
+import { DynamicTabComponent } from '@alfresco/adf-extensions';
+import { Store } from '@ngrx/store';
+import { SetInfoDrawerStateAction, ToggleInfoDrawerAction, infoDrawerPreview } from '@alfresco/aca-shared/store';
+import { AppExtensionService } from '../../services/app.extension.service';
+import { ContentApiService } from '../../services/content-api.service';
+import { takeUntil } from 'rxjs/operators';
+import { Subject } from 'rxjs';
+import { CommonModule } from '@angular/common';
+import { MatProgressBarModule } from '@angular/material/progress-bar';
+import { InfoDrawerModule } from '@alfresco/adf-core';
+import { TranslateModule } from '@ngx-translate/core';
+import { A11yModule } from '@angular/cdk/a11y';
+import { ToolbarComponent } from '../toolbar/toolbar.component';
+import { ContentService, NodesApiService } from '@alfresco/adf-content-services';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngrx/store";
+import * as i2 from "../../services/content-api.service";
+import * as i3 from "../../services/app.extension.service";
+import * as i4 from "@alfresco/adf-content-services";
+import * as i5 from "@angular/common";
+import * as i6 from "@ngx-translate/core";
+import * as i7 from "@angular/material/progress-bar";
+import * as i8 from "@alfresco/adf-core";
+export class InfoDrawerComponent {
+    onEscapeKeyboardEvent() {
+        this.close();
+    }
+    constructor(store, contentApi, extensions, nodesService, contentService) {
+        this.store = store;
+        this.contentApi = contentApi;
+        this.extensions = extensions;
+        this.nodesService = nodesService;
+        this.contentService = contentService;
+        this.isLoading = false;
+        this.tabs = [];
+        this.actions = [];
+        this.onDestroy$ = new Subject();
+        this.preventFromClosing = false;
+        this.icon = null;
+    }
+    ngOnInit() {
+        this.tabs = this.extensions.getSidebarTabs();
+        this.extensions
+            .getAllowedSidebarActions()
+            .pipe(takeUntil(this.onDestroy$))
+            .subscribe((actions) => {
+            this.actions = actions;
+        });
+        this.store
+            .select(infoDrawerPreview)
+            .pipe(takeUntil(this.onDestroy$))
+            .subscribe((isInfoDrawerPreviewOpened) => {
+            this.preventFromClosing = isInfoDrawerPreviewOpened;
+        });
+        this.nodesService.nodeUpdated.pipe(takeUntil(this.onDestroy$)).subscribe((node) => {
+            this.node.entry = node;
+        });
+    }
+    ngOnDestroy() {
+        this.onDestroy$.next(true);
+        this.onDestroy$.complete();
+        if (!this.preventFromClosing) {
+            this.store.dispatch(new SetInfoDrawerStateAction(false));
+        }
+    }
+    ngOnChanges() {
+        if (this.node) {
+            if (this.node['isLibrary']) {
+                return this.setDisplayNode(this.node);
+            }
+            const entry = this.node.entry;
+            const id = entry.nodeId || entry.id;
+            return this.loadNodeInfo(id);
+        }
+    }
+    close() {
+        this.store.dispatch(new ToggleInfoDrawerAction());
+    }
+    loadNodeInfo(nodeId) {
+        if (nodeId) {
+            this.isLoading = true;
+            this.contentApi.getNodeInfo(nodeId).subscribe((entity) => {
+                this.setDisplayNode(entity);
+                this.node.entry = entity;
+                this.isLoading = false;
+            }, () => (this.isLoading = false));
+        }
+    }
+    setDisplayNode(node) {
+        this.displayNode = node;
+        this.icon = this.contentService.getNodeIcon(node);
+    }
+}
+InfoDrawerComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: InfoDrawerComponent, deps: [{ token: i1.Store }, { token: i2.ContentApiService }, { token: i3.AppExtensionService }, { token: i4.NodesApiService }, { token: i4.ContentService }], target: i0.ɵɵFactoryTarget.Component });
+InfoDrawerComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.10", type: InfoDrawerComponent, isStandalone: true, selector: "aca-info-drawer", inputs: { nodeId: "nodeId", node: "node" }, host: { listeners: { "keydown.escape": "onEscapeKeyboardEvent()" } }, usesOnChanges: true, ngImport: i0, template: "<div *ngIf=\"isLoading\">\n  <mat-progress-bar mode=\"indeterminate\" [attr.aria-label]=\"'APP.INFO_DRAWER.DATA_LOADING' | translate\"></mat-progress-bar>\n</div>\n<ng-container *ngIf=\"!isLoading && !!displayNode\">\n  <adf-info-drawer [icon]=\"icon\" [title]=\"node?.entry?.name || 'APP.INFO_DRAWER.TITLE'\" cdkTrapFocusAutoCapture>\n    <aca-toolbar [items]=\"actions\" info-drawer-buttons></aca-toolbar>\n\n    <adf-info-drawer-tab *ngFor=\"let tab of tabs\" [icon]=\"tab.icon\" [label]=\"tab.title\">\n      <adf-dynamic-tab [node]=\"$any(displayNode)\" [id]=\"tab.component\" [attr.data-automation-id]=\"tab.component\"> </adf-dynamic-tab>\n    </adf-info-drawer-tab>\n  </adf-info-drawer>\n</ng-container>\n", dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i5.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i5.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "ngmodule", type: TranslateModule }, { kind: "pipe", type: i6.TranslatePipe, name: "translate" }, { kind: "ngmodule", type: MatProgressBarModule }, { kind: "component", type: i7.MatProgressBar, selector: "mat-progress-bar", inputs: ["color", "value", "bufferValue", "mode"], outputs: ["animationEnd"], exportAs: ["matProgressBar"] }, { kind: "ngmodule", type: InfoDrawerModule }, { kind: "component", type: i8.InfoDrawerTabComponent, selector: "adf-info-drawer-tab", inputs: ["label", "icon"] }, { kind: "component", type: i8.InfoDrawerComponent, selector: "adf-info-drawer", inputs: ["title", "icon", "selectedIndex", "showHeader"], outputs: ["currentTab"] }, { kind: "directive", type: i8.InfoDrawerButtonsDirective, selector: "[adf-info-drawer-buttons], [info-drawer-buttons]" }, { kind: "ngmodule", type: A11yModule }, { kind: "component", type: ToolbarComponent, selector: "aca-toolbar", inputs: ["items"] }, { kind: "component", type: DynamicTabComponent, selector: "adf-dynamic-tab", inputs: ["id", "node"] }], encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: InfoDrawerComponent, decorators: [{
+            type: Component,
+            args: [{ standalone: true, imports: [CommonModule, TranslateModule, MatProgressBarModule, InfoDrawerModule, A11yModule, ToolbarComponent, DynamicTabComponent], selector: 'aca-info-drawer', encapsulation: ViewEncapsulation.None, template: "<div *ngIf=\"isLoading\">\n  <mat-progress-bar mode=\"indeterminate\" [attr.aria-label]=\"'APP.INFO_DRAWER.DATA_LOADING' | translate\"></mat-progress-bar>\n</div>\n<ng-container *ngIf=\"!isLoading && !!displayNode\">\n  <adf-info-drawer [icon]=\"icon\" [title]=\"node?.entry?.name || 'APP.INFO_DRAWER.TITLE'\" cdkTrapFocusAutoCapture>\n    <aca-toolbar [items]=\"actions\" info-drawer-buttons></aca-toolbar>\n\n    <adf-info-drawer-tab *ngFor=\"let tab of tabs\" [icon]=\"tab.icon\" [label]=\"tab.title\">\n      <adf-dynamic-tab [node]=\"$any(displayNode)\" [id]=\"tab.component\" [attr.data-automation-id]=\"tab.component\"> </adf-dynamic-tab>\n    </adf-info-drawer-tab>\n  </adf-info-drawer>\n</ng-container>\n" }]
+        }], ctorParameters: function () { return [{ type: i1.Store }, { type: i2.ContentApiService }, { type: i3.AppExtensionService }, { type: i4.NodesApiService }, { type: i4.ContentService }]; }, propDecorators: { nodeId: [{
+                type: Input
+            }], node: [{
+                type: Input
+            }], onEscapeKeyboardEvent: [{
+                type: HostListener,
+                args: ['keydown.escape']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"info-drawer.component.js","sourceRoot":"","sources":["../../../../../../../projects/aca-shared/src/lib/components/info-drawer/info-drawer.component.ts","../../../../../../../projects/aca-shared/src/lib/components/info-drawer/info-drawer.component.html"],"names":[],"mappings":"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","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, HostListener, Input, OnChanges, OnDestroy, OnInit, ViewEncapsulation } from '@angular/core';\nimport { NodeEntry, Node, SiteEntry } from '@alfresco/js-api';\nimport { ContentActionRef, DynamicTabComponent, SidebarTabRef } from '@alfresco/adf-extensions';\nimport { Store } from '@ngrx/store';\nimport { SetInfoDrawerStateAction, ToggleInfoDrawerAction, infoDrawerPreview } from '@alfresco/aca-shared/store';\nimport { AppExtensionService } from '../../services/app.extension.service';\nimport { ContentApiService } from '../../services/content-api.service';\nimport { takeUntil } from 'rxjs/operators';\nimport { Subject } from 'rxjs';\nimport { CommonModule } from '@angular/common';\nimport { MatProgressBarModule } from '@angular/material/progress-bar';\nimport { InfoDrawerModule } from '@alfresco/adf-core';\nimport { TranslateModule } from '@ngx-translate/core';\nimport { A11yModule } from '@angular/cdk/a11y';\nimport { ToolbarComponent } from '../toolbar/toolbar.component';\nimport { ContentService, NodesApiService } from '@alfresco/adf-content-services';\n\n@Component({\n  standalone: true,\n  imports: [CommonModule, TranslateModule, MatProgressBarModule, InfoDrawerModule, A11yModule, ToolbarComponent, DynamicTabComponent],\n  selector: 'aca-info-drawer',\n  templateUrl: './info-drawer.component.html',\n  encapsulation: ViewEncapsulation.None\n})\nexport class InfoDrawerComponent implements OnChanges, OnInit, OnDestroy {\n  @Input()\n  nodeId: string;\n\n  @Input()\n  node: NodeEntry;\n\n  isLoading = false;\n  displayNode: Node | SiteEntry;\n  tabs: Array<SidebarTabRef> = [];\n  actions: Array<ContentActionRef> = [];\n  onDestroy$ = new Subject<boolean>();\n  preventFromClosing = false;\n  icon: string = null;\n\n  @HostListener('keydown.escape')\n  onEscapeKeyboardEvent(): void {\n    this.close();\n  }\n\n  constructor(\n    private store: Store<any>,\n    private contentApi: ContentApiService,\n    private extensions: AppExtensionService,\n    private nodesService: NodesApiService,\n    private contentService: ContentService\n  ) {}\n\n  ngOnInit() {\n    this.tabs = this.extensions.getSidebarTabs();\n    this.extensions\n      .getAllowedSidebarActions()\n      .pipe(takeUntil(this.onDestroy$))\n      .subscribe((actions) => {\n        this.actions = actions;\n      });\n\n    this.store\n      .select(infoDrawerPreview)\n      .pipe(takeUntil(this.onDestroy$))\n      .subscribe((isInfoDrawerPreviewOpened) => {\n        this.preventFromClosing = isInfoDrawerPreviewOpened;\n      });\n\n    this.nodesService.nodeUpdated.pipe(takeUntil(this.onDestroy$)).subscribe((node: any) => {\n      this.node.entry = node;\n    });\n  }\n\n  ngOnDestroy() {\n    this.onDestroy$.next(true);\n    this.onDestroy$.complete();\n    if (!this.preventFromClosing) {\n      this.store.dispatch(new SetInfoDrawerStateAction(false));\n    }\n  }\n\n  ngOnChanges() {\n    if (this.node) {\n      if (this.node['isLibrary']) {\n        return this.setDisplayNode(this.node);\n      }\n\n      const entry: any = this.node.entry;\n\n      const id = entry.nodeId || entry.id;\n      return this.loadNodeInfo(id);\n    }\n  }\n\n  private close() {\n    this.store.dispatch(new ToggleInfoDrawerAction());\n  }\n\n  private loadNodeInfo(nodeId: string) {\n    if (nodeId) {\n      this.isLoading = true;\n\n      this.contentApi.getNodeInfo(nodeId).subscribe(\n        (entity) => {\n          this.setDisplayNode(entity);\n          this.node.entry = entity;\n          this.isLoading = false;\n        },\n        () => (this.isLoading = false)\n      );\n    }\n  }\n\n  private setDisplayNode(node: any) {\n    this.displayNode = node;\n    this.icon = this.contentService.getNodeIcon(node);\n  }\n}\n","<div *ngIf=\"isLoading\">\n  <mat-progress-bar mode=\"indeterminate\" [attr.aria-label]=\"'APP.INFO_DRAWER.DATA_LOADING' | translate\"></mat-progress-bar>\n</div>\n<ng-container *ngIf=\"!isLoading && !!displayNode\">\n  <adf-info-drawer [icon]=\"icon\" [title]=\"node?.entry?.name || 'APP.INFO_DRAWER.TITLE'\" cdkTrapFocusAutoCapture>\n    <aca-toolbar [items]=\"actions\" info-drawer-buttons></aca-toolbar>\n\n    <adf-info-drawer-tab *ngFor=\"let tab of tabs\" [icon]=\"tab.icon\" [label]=\"tab.title\">\n      <adf-dynamic-tab [node]=\"$any(displayNode)\" [id]=\"tab.component\" [attr.data-automation-id]=\"tab.component\"> </adf-dynamic-tab>\n    </adf-info-drawer-tab>\n  </adf-info-drawer>\n</ng-container>\n"]}

package/esm2020/lib/components/locked-by/locked-by.component.mjs

@@ -0,0 +1,54 @@
+/*!
+ * 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, Input, ChangeDetectionStrategy, ViewEncapsulation } from '@angular/core';
+import { NodeEntry } from '@alfresco/js-api';
+import { TranslateModule } from '@ngx-translate/core';
+import { MatIconModule } from '@angular/material/icon';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+import * as i2 from "@angular/material/icon";
+export class LockedByComponent {
+    ngOnInit() {
+        this.text = this.node?.entry?.properties?.['cm:lockOwner']?.displayName;
+    }
+}
+LockedByComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: LockedByComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+LockedByComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.10", type: LockedByComponent, isStandalone: true, selector: "aca-locked-by", inputs: { node: "node" }, host: { classAttribute: "aca-locked-by" }, ngImport: i0, template: `
+    <mat-icon class="aca-locked-by--icon">lock</mat-icon>
+    <span class="aca-locked-by--label">{{ 'APP.LOCKED_BY' | translate }}</span>
+    <span class="aca-locked-by--name">{{ text }}</span>
+  `, isInline: true, styles: [".aca-locked-by{display:flex;align-items:center;color:var(--theme-text-color, rgba(0, 0, 0, .54))}.aca-locked-by--icon{font-size:14px;width:14px;height:14px;min-width:14px}.aca-locked-by--label,.aca-locked-by--name{font-size:12px;padding:0 2px}\n"], dependencies: [{ kind: "ngmodule", type: TranslateModule }, { kind: "pipe", type: i1.TranslatePipe, name: "translate" }, { kind: "ngmodule", type: MatIconModule }, { kind: "component", type: i2.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: LockedByComponent, decorators: [{
+            type: Component,
+            args: [{ standalone: true, imports: [TranslateModule, MatIconModule], selector: 'aca-locked-by', template: `
+    <mat-icon class="aca-locked-by--icon">lock</mat-icon>
+    <span class="aca-locked-by--label">{{ 'APP.LOCKED_BY' | translate }}</span>
+    <span class="aca-locked-by--name">{{ text }}</span>
+  `, changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.None, host: {
+                        class: 'aca-locked-by'
+                    }, styles: [".aca-locked-by{display:flex;align-items:center;color:var(--theme-text-color, rgba(0, 0, 0, .54))}.aca-locked-by--icon{font-size:14px;width:14px;height:14px;min-width:14px}.aca-locked-by--label,.aca-locked-by--name{font-size:12px;padding:0 2px}\n"] }]
+        }], propDecorators: { node: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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