@alfresco/aca-shared 7.0.0-15437658909 → 7.0.0-15464606457

package/esm2022/alfresco-aca-shared.mjs

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

package/esm2022/lib/adf-extensions/extensions-data-loader.guard.mjs

@@ -0,0 +1,59 @@
+/*!
+ * Copyright © 2005-2025 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 { InjectionToken, inject } from '@angular/core';
+import { forkJoin, of } from 'rxjs';
+import { tap, map, catchError } from 'rxjs/operators';
+export const DefaultExtensionLoaderFactory = () => [];
+export const EXTENSION_DATA_LOADERS = new InjectionToken('EXTENSION_DATA_LOADERS', {
+    providedIn: 'root',
+    factory: DefaultExtensionLoaderFactory
+});
+let invoked = false;
+export const ExtensionsDataLoaderGuard = (route) => {
+    const extensionDataLoaders = inject(EXTENSION_DATA_LOADERS);
+    if (!invoked) {
+        if (!extensionDataLoaders.length) {
+            invoked = true;
+            return of(true);
+        }
+        const dataLoaderCallbacks = extensionDataLoaders.map((callback) => callback(route));
+        // Undocumented forkJoin behaviour/bug:
+        // https://github.com/ReactiveX/rxjs/issues/3246
+        // So all callbacks need to emit before completion, otherwise forkJoin will short circuit
+        return forkJoin(...dataLoaderCallbacks).pipe(map(() => true), tap(() => (invoked = true)), catchError((e) => {
+            // eslint-disable-next-line no-console
+            console.error('Some of the extension data loader guards has been errored.');
+            // eslint-disable-next-line no-console
+            console.error(e);
+            return of(true);
+        }));
+    }
+    else {
+        return of(true);
+    }
+};
+export const resetInvoked = () => {
+    invoked = false;
+};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,222 @@
+/*!
+ * Copyright © 2005-2025 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 { DestroyRef, Directive, HostListener, inject, ViewChild } from '@angular/core';
+import { Store } from '@ngrx/store';
+import { DocumentBasePageService } from './document-base-page.service';
+import { getAppSelection, getCurrentFolder, isInfoDrawerOpened, SetSelectedNodesAction, ViewNodeAction } 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 { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import * as i0 from "@angular/core";
+/* eslint-disable @angular-eslint/directive-class-suffix */
+export class PageComponent {
+    documentList;
+    title = 'Page';
+    infoDrawerOpened$;
+    node;
+    selection;
+    actions = [];
+    viewerToolbarActions = [];
+    bulkActions = [];
+    canUpdateNode = false;
+    canUpload = false;
+    nodeResult;
+    showHeader = ShowHeaderMode.Data;
+    filterSorting = 'name-asc';
+    createActions = [];
+    isSmallScreen = false;
+    selectedRowItemsCount = 0;
+    selectedNodesState;
+    documentListService = inject(DocumentListService);
+    settings = inject(AppSettingsService);
+    extensions = inject(AppExtensionService);
+    content = inject(DocumentBasePageService);
+    store = inject((Store));
+    breakpointObserver = inject(BreakpointObserver);
+    uploadService = inject(UploadService);
+    router = inject(Router);
+    userPreferencesService = inject(UserPreferencesService);
+    searchAiService = inject(SearchAiService);
+    destroyRef = inject(DestroyRef);
+    autoDownloadService = inject(AutoDownloadService, { optional: true });
+    navigationHistoryService = inject(NavigationHistoryService);
+    subscriptions = [];
+    _searchAiInputState = {
+        active: false
+    };
+    get searchAiInputState() {
+        return this._searchAiInputState;
+    }
+    ngOnInit() {
+        this.extensions
+            .getCreateActions()
+            .pipe(takeUntilDestroyed(this.destroyRef))
+            .subscribe((actions) => {
+            this.createActions = actions;
+        });
+        this.infoDrawerOpened$ = this.store.select(isInfoDrawerOpened);
+        this.store
+            .select(getAppSelection)
+            .pipe(takeUntilDestroyed(this.destroyRef))
+            .subscribe((selection) => {
+            this.selection = selection;
+            this.canUpdateNode = this.selection.count === 1 && this.content.canUpdateNode(selection.first);
+        });
+        this.extensions
+            .getAllowedToolbarActions()
+            .pipe(takeUntilDestroyed(this.destroyRef))
+            .subscribe((actions) => {
+            this.actions = actions;
+        });
+        this.extensions
+            .getBulkActions()
+            .pipe(takeUntilDestroyed(this.destroyRef))
+            .subscribe((actions) => {
+            this.bulkActions = actions;
+        });
+        this.extensions
+            .getViewerToolbarActions()
+            .pipe(takeUntilDestroyed(this.destroyRef))
+            .subscribe((actions) => {
+            this.viewerToolbarActions = actions;
+        });
+        this.store
+            .select(getCurrentFolder)
+            .pipe(takeUntilDestroyed(this.destroyRef))
+            .subscribe((node) => {
+            this.canUpload = node && this.content.canUploadContent(node);
+        });
+        this.breakpointObserver
+            .observe([Breakpoints.HandsetPortrait, Breakpoints.HandsetLandscape])
+            .pipe(takeUntilDestroyed(this.destroyRef))
+            .subscribe((result) => {
+            this.isSmallScreen = result.matches;
+        });
+        this.searchAiService.toggleSearchAiInput$
+            .pipe(takeUntilDestroyed(this.destroyRef))
+            .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.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();
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: PageComponent, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.9", 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: "18.2.9", 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-2025 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 { DestroyRef, Directive, HostListener, inject, OnChanges, OnDestroy, OnInit, SimpleChanges, ViewChild } from '@angular/core';\nimport { Store } from '@ngrx/store';\nimport { Node, NodeEntry, NodePaging } from '@alfresco/js-api';\nimport { Observable, Subscription } from 'rxjs';\nimport { DocumentBasePageService } from './document-base-page.service';\nimport {\n  AppStore,\n  getAppSelection,\n  getCurrentFolder,\n  isInfoDrawerOpened,\n  SetSelectedNodesAction,\n  ViewNodeAction,\n  ViewNodeExtras\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';\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\n\n/* eslint-disable @angular-eslint/directive-class-suffix */\n@Directive()\nexport abstract class PageComponent implements OnInit, OnDestroy, OnChanges {\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\n  protected readonly destroyRef = inject(DestroyRef);\n\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(takeUntilDestroyed(this.destroyRef))\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(takeUntilDestroyed(this.destroyRef))\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(takeUntilDestroyed(this.destroyRef))\n      .subscribe((actions) => {\n        this.actions = actions;\n      });\n\n    this.extensions\n      .getBulkActions()\n      .pipe(takeUntilDestroyed(this.destroyRef))\n      .subscribe((actions) => {\n        this.bulkActions = actions;\n      });\n\n    this.extensions\n      .getViewerToolbarActions()\n      .pipe(takeUntilDestroyed(this.destroyRef))\n      .subscribe((actions) => {\n        this.viewerToolbarActions = actions;\n      });\n\n    this.store\n      .select(getCurrentFolder)\n      .pipe(takeUntilDestroyed(this.destroyRef))\n      .subscribe((node) => {\n        this.canUpload = node && this.content.canUploadContent(node);\n      });\n\n    this.breakpointObserver\n      .observe([Breakpoints.HandsetPortrait, Breakpoints.HandsetLandscape])\n      .pipe(takeUntilDestroyed(this.destroyRef))\n      .subscribe((result) => {\n        this.isSmallScreen = result.matches;\n      });\n\n    this.searchAiService.toggleSearchAiInput$\n      .pipe(takeUntilDestroyed(this.destroyRef))\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.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/esm2022/lib/components/document-base-page/document-base-page.service.mjs

@@ -0,0 +1,26 @@
+/*!
+ * Copyright © 2005-2025 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/>.
+ */
+export class DocumentBasePageService {
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,41 @@
+/*!
+ * Copyright © 2005-2025 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 {
+    text = 'APP.MESSAGES.ERRORS.MISSING_CONTENT';
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: GenericErrorComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.9", 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: "18.2.9", 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/esm2022/lib/components/info-drawer/info-drawer.component.mjs

@@ -0,0 +1,138 @@
+/*!
+ * Copyright © 2005-2025 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, DestroyRef, HostListener, inject, Input, ViewEncapsulation } from '@angular/core';
+import { NodeEntry } from '@alfresco/js-api';
+import { DynamicTabComponent } from '@alfresco/adf-extensions';
+import { Store } from '@ngrx/store';
+import { infoDrawerPreview, SetInfoDrawerStateAction, ToggleInfoDrawerAction } from '@alfresco/aca-shared/store';
+import { AppExtensionService } from '../../services/app.extension.service';
+import { ContentApiService } from '../../services/content-api.service';
+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 { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+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 {
+    store;
+    contentApi;
+    extensions;
+    nodesService;
+    contentService;
+    nodeId;
+    node;
+    isLoading = false;
+    displayNode;
+    tabs = [];
+    actions = [];
+    preventFromClosing = false;
+    icon = null;
+    onEscapeKeyboardEvent() {
+        this.close();
+    }
+    destroyRef = inject(DestroyRef);
+    constructor(store, contentApi, extensions, nodesService, contentService) {
+        this.store = store;
+        this.contentApi = contentApi;
+        this.extensions = extensions;
+        this.nodesService = nodesService;
+        this.contentService = contentService;
+    }
+    ngOnInit() {
+        this.tabs = this.extensions.getSidebarTabs();
+        this.extensions
+            .getAllowedSidebarActions()
+            .pipe(takeUntilDestroyed(this.destroyRef))
+            .subscribe((actions) => {
+            this.actions = actions;
+        });
+        this.store
+            .select(infoDrawerPreview)
+            .pipe(takeUntilDestroyed(this.destroyRef))
+            .subscribe((isInfoDrawerPreviewOpened) => {
+            this.preventFromClosing = isInfoDrawerPreviewOpened;
+        });
+        this.nodesService.nodeUpdated.pipe(takeUntilDestroyed(this.destroyRef)).subscribe((node) => {
+            this.node.entry = node;
+        });
+    }
+    ngOnDestroy() {
+        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);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: InfoDrawerComponent, deps: [{ token: i1.Store }, { token: i2.ContentApiService }, { token: i3.AppExtensionService }, { token: i4.NodesApiService }, { token: i4.ContentService }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.9", 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\" />\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 />\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\" />\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: "18.2.9", 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\" />\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 />\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\" />\n    </adf-info-drawer-tab>\n  </adf-info-drawer>\n</ng-container>\n" }]
+        }], ctorParameters: () => [{ type: i1.Store }, { type: i2.ContentApiService }, { type: i3.AppExtensionService }, { type: i4.NodesApiService }, { type: i4.ContentService }], propDecorators: { nodeId: [{
+                type: Input
+            }], node: [{
+                type: Input,
+                args: [{ required: true }]
+            }], 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-2025 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, DestroyRef, HostListener, inject, Input, OnChanges, OnDestroy, OnInit, ViewEncapsulation } from '@angular/core';\nimport { Node, NodeEntry, SiteEntry } from '@alfresco/js-api';\nimport { ContentActionRef, DynamicTabComponent, SidebarTabRef } from '@alfresco/adf-extensions';\nimport { Store } from '@ngrx/store';\nimport { infoDrawerPreview, SetInfoDrawerStateAction, ToggleInfoDrawerAction } from '@alfresco/aca-shared/store';\nimport { AppExtensionService } from '../../services/app.extension.service';\nimport { ContentApiService } from '../../services/content-api.service';\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';\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\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({ required: true })\n  node: NodeEntry;\n\n  isLoading = false;\n  displayNode: Node | SiteEntry;\n  tabs: Array<SidebarTabRef> = [];\n  actions: Array<ContentActionRef> = [];\n\n  preventFromClosing = false;\n  icon: string = null;\n\n  @HostListener('keydown.escape')\n  onEscapeKeyboardEvent(): void {\n    this.close();\n  }\n\n  private readonly destroyRef = inject(DestroyRef);\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(takeUntilDestroyed(this.destroyRef))\n      .subscribe((actions) => {\n        this.actions = actions;\n      });\n\n    this.store\n      .select(infoDrawerPreview)\n      .pipe(takeUntilDestroyed(this.destroyRef))\n      .subscribe((isInfoDrawerPreviewOpened) => {\n        this.preventFromClosing = isInfoDrawerPreviewOpened;\n      });\n\n    this.nodesService.nodeUpdated.pipe(takeUntilDestroyed(this.destroyRef)).subscribe((node: any) => {\n      this.node.entry = node;\n    });\n  }\n\n  ngOnDestroy() {\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\" />\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 />\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\" />\n    </adf-info-drawer-tab>\n  </adf-info-drawer>\n</ng-container>\n"]}