@alfresco/adf-content-services 8.1.0-15972188736 → 8.1.0-15979090800

package/esm2022/lib/document-list/components/document-list.component.mjs

@@ -0,0 +1,963 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/* eslint-disable rxjs/no-subject-value */
+/* eslint-disable @typescript-eslint/naming-convention */
+import { AppConfigService, ColumnsSelectorComponent, CustomEmptyContentTemplateDirective, CustomLoadingContentTemplateDirective, CustomNoPermissionTemplateDirective, DataColumnListComponent, DataSorting, DataTableComponent, DataTableSchema, DataTableService, EmptyListComponent, LoadingContentTemplateDirective, MainMenuDataTableTemplateDirective, NoContentTemplateDirective, NoPermissionTemplateDirective, ShowHeaderMode, ThumbnailService, UserPreferencesService, UserPreferenceValues } from '@alfresco/adf-core';
+import { NodePaging, NodesApi, Pagination } from '@alfresco/js-api';
+import { Component, ContentChild, DestroyRef, ElementRef, EventEmitter, HostListener, inject, Input, Output, ViewChild, ViewEncapsulation } from '@angular/core';
+import { MatDialog } from '@angular/material/dialog';
+import { BehaviorSubject, of, Subject } from 'rxjs';
+import { ContentService, NodesApiService } from '../../common';
+import { ShareDataTableAdapter } from '../data/share-datatable-adapter';
+import { ContentActionModel } from '../models/content-action.model';
+import { presetsDefaultModel } from '../models/preset.model';
+import { DocumentListService } from '../services/document-list.service';
+import { LockService } from '../services/lock.service';
+import { ADF_DOCUMENT_PARENT_COMPONENT } from './document-list.token';
+import { FileAutoDownloadComponent } from './file-auto-download/file-auto-download.component';
+import { NodeEntityEvent, NodeEntryEvent } from './node.event';
+import { CommonModule } from '@angular/common';
+import { FilterHeaderComponent } from './filter-header/filter-header.component';
+import { TranslatePipe } from '@ngx-translate/core';
+import { MatIconModule } from '@angular/material/icon';
+import { MatProgressSpinnerModule } from '@angular/material/progress-spinner';
+import { AlfrescoApiService } from '../../services/alfresco-api.service';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import * as i0 from "@angular/core";
+import * as i1 from "../services/document-list.service";
+import * as i2 from "@alfresco/adf-core";
+import * as i3 from "../../common";
+import * as i4 from "../../services/alfresco-api.service";
+import * as i5 from "../services/lock.service";
+import * as i6 from "@angular/material/dialog";
+import * as i7 from "@angular/common";
+import * as i8 from "@angular/material/icon";
+import * as i9 from "@angular/material/progress-spinner";
+const BYTES_TO_MB_CONVERSION_VALUE = 1048576;
+export class DocumentListComponent extends DataTableSchema {
+    static { this.SINGLE_CLICK_NAVIGATION = 'click'; }
+    static { this.DOUBLE_CLICK_NAVIGATION = 'dblclick'; }
+    /**
+     * Custom function to choose whether to show or hide rows.
+     * See the [Row Filter Model](row-filter.model.md) page for
+     * more information.
+     */
+    set rowFilter(rowFilter) {
+        this._rowFilter = rowFilter;
+        if (this.data) {
+            this.data.setFilter(this._rowFilter);
+            if (this.currentFolderId) {
+                this.reload();
+            }
+        }
+    }
+    get rowFilter() {
+        return this._rowFilter;
+    }
+    /** Sets columns visibility for DataTableSchema */
+    set setColumnsVisibility(columnsVisibility) {
+        this.columnsVisibility = columnsVisibility;
+    }
+    /** Sets columns width for DataTableSchema */
+    set setColumnsWidths(columnsWidths) {
+        this.columnsWidths = columnsWidths;
+    }
+    /** Sets columns order for DataTableSchema */
+    set setColumnsOrder(columnsOrder) {
+        this.columnsOrder = columnsOrder;
+    }
+    get nodesApi() {
+        this._nodesApi = this._nodesApi ?? new NodesApi(this.alfrescoApiService.getInstance());
+        return this._nodesApi;
+    }
+    constructor(documentListService, elementRef, appConfig, userPreferencesService, contentService, thumbnailService, alfrescoApiService, nodeService, dataTableService, lockService, dialog) {
+        super(appConfig, 'default', presetsDefaultModel);
+        this.documentListService = documentListService;
+        this.elementRef = elementRef;
+        this.appConfig = appConfig;
+        this.userPreferencesService = userPreferencesService;
+        this.contentService = contentService;
+        this.thumbnailService = thumbnailService;
+        this.alfrescoApiService = alfrescoApiService;
+        this.nodeService = nodeService;
+        this.dataTableService = dataTableService;
+        this.lockService = lockService;
+        this.dialog = dialog;
+        this.DEFAULT_PAGINATION = new Pagination({
+            hasMoreItems: false,
+            skipCount: 0,
+            maxItems: 25,
+            totalItems: 0
+        });
+        this.DEFAULT_SORTING = [new DataSorting('name', 'asc'), new DataSorting('isFolder', 'desc')];
+        /**
+         * Define a set of CSS styles to apply depending on the permission
+         * of the user on that node. See the Permission Style model
+         * page for further details and examples.
+         */
+        this.permissionsStyle = [];
+        /** The default route for all the location-based columns (if declared). */
+        this.locationFormat = '/';
+        /** Toggles navigation to folder content or file preview */
+        this.navigate = true;
+        /** Toggles the header */
+        this.showHeader = ShowHeaderMode.Data;
+        /**
+         * User interaction for folder navigation or file preview.
+         * Valid values are "click" and "dblclick". Default value: "dblclick"
+         */
+        this.navigationMode = DocumentListComponent.DOUBLE_CLICK_NAVIGATION; // click|dblclick
+        /** Show document thumbnails rather than icons */
+        this.thumbnails = false;
+        /**
+         * Row selection mode. Can be null, `single` or `multiple`. For `multiple` mode,
+         * you can use Cmd (macOS) or Ctrl (Win) modifier key to toggle selection for multiple rows.
+         */
+        this.selectionMode = 'single'; // null|single|multiple
+        /** Toggles multiselect mode */
+        this.multiselect = false;
+        /** Toggles content actions for each row */
+        this.contentActions = false;
+        /** Position of the content actions dropdown menu. Can be set to "left" or "right". */
+        this.contentActionsPosition = 'right'; // left|right
+        /** Toggles context menus for each row */
+        this.contextMenuActions = false;
+        /** Custom image for empty folder. Default value: './assets/images/empty_doc_lib.svg' */
+        this.emptyFolderImageUrl = './assets/images/empty_doc_lib.svg';
+        /**
+         * When true, this enables you to drop files directly into subfolders shown
+         * as items in the list or into another file to trigger updating it's version.
+         * When false, the dropped file will be added to the
+         * current folder (ie, the one containing all the items shown in the list).
+         * See the Upload directive for further details about how the file drop is
+         * handled.
+         */
+        this.allowDropFiles = false;
+        /**
+         * Defines default sorting. The format is an array of 2 strings `[key, direction]`
+         * i.e. `['name', 'desc']` or `['name', 'asc']`. Set this value only if you want to
+         * override the default sorting detected by the component based on columns.
+         */
+        this.sorting = ['name', 'asc'];
+        /**
+         * Defines default sorting. The format is an array of strings `[key direction, otherKey otherDirection]`
+         * i.e. `['name desc', 'nodeType asc']` or `['name asc']`. Set this value if you want a base
+         * rule to be added to the sorting apart from the one driven by the header.
+         */
+        this.additionalSorting = new DataSorting('isFolder', 'desc');
+        /**
+         * Defines sorting mode. Can be either `client` (items in the list
+         * are sorted client-side) or `server` (the ordering supplied by the
+         * server is used without further client-side sorting).
+         * Note that the `server` option *does not* request the server to sort the data
+         * before delivering it.
+         */
+        this.sortingMode = 'server';
+        /**
+         * Toggles the loading state and animated spinners for the component. Used in
+         * combination with `navigate=false` to perform custom navigation and loading
+         * state indication.
+         */
+        this.loading = false;
+        this._rowFilter = null;
+        /**
+         * Custom function to choose image file paths to show. See the
+         * [Image Resolver Model](image-resolver.model.md) page for
+         * more information.
+         */
+        this.imageResolver = null;
+        /** Toggles the sticky header mode. */
+        this.stickyHeader = false;
+        /** Toggles the header filters mode. */
+        this.headerFilters = false;
+        /** The ID of the folder node to display or a reserved string alias for special sources */
+        this.currentFolderId = null;
+        /**
+         * Array of nodes to be pre-selected. All nodes in the
+         * array are pre-selected in multi selection mode, but only the first node
+         * is pre-selected in single selection mode.
+         */
+        this.preselectNodes = [];
+        /** The Document list will show all the nodes contained in the NodePaging entity */
+        this.node = null;
+        /** Default value is stored in the user preference settings. Use this only if you are not using pagination. */
+        this.maxItems = this.DEFAULT_PAGINATION.maxItems;
+        /** Enables column resizing for datatable */
+        this.isResizingEnabled = false;
+        /** Enables blur when resizing datatable columns */
+        this.blurOnResize = true;
+        /** Display checkboxes in datatable rows on hover only */
+        this.displayCheckboxesOnHover = false;
+        /** Display drag and drop hint. */
+        this.displayDragAndDropHint = true;
+        /** Emitted when the user clicks a list node */
+        this.nodeClick = new EventEmitter();
+        /** Emitted when the user double-clicks a list node */
+        this.nodeDblClick = new EventEmitter();
+        /** Emitted when the current display folder changes */
+        this.folderChange = new EventEmitter();
+        /**
+         * Emitted when the user acts upon files with either single or double click
+         * (depends on `navigation-mode`). Useful for integration with the
+         * Viewer component.
+         */
+        this.preview = new EventEmitter();
+        /** Emitted when the Document List has loaded all items and is ready for use */
+        this.ready = new EventEmitter();
+        /** Emitted when the API fails to get the Document List data */
+        this.error = new EventEmitter();
+        /** Emitted when the node selection change */
+        this.nodeSelected = new EventEmitter();
+        /** Emitted when a filter value is selected */
+        this.filterSelection = new EventEmitter();
+        /** Emitted when column widths change */
+        this.columnsWidthChanged = new EventEmitter();
+        /** Emitted when columns visibility change */
+        this.columnsVisibilityChanged = new EventEmitter();
+        /** Emitted when columns order change */
+        this.columnsOrderChanged = new EventEmitter();
+        /** Emitted when the selected row items count in the table changed. */
+        this.selectedItemsCountChanged = new EventEmitter();
+        this.actions = [];
+        this.contextActionHandler = new Subject();
+        this.noPermission = false;
+        this.selection = new Array();
+        this.$folderNode = new Subject();
+        this.allowFiltering = true;
+        this.orderBy = null;
+        this.preselectedRows = [];
+        this._pagination = this.DEFAULT_PAGINATION;
+        this.pagination = new BehaviorSubject(this.DEFAULT_PAGINATION);
+        this.sortingSubject = new BehaviorSubject(this.DEFAULT_SORTING);
+        this.rowMenuCache = {};
+        this.destroyRef = inject(DestroyRef);
+        this.nodeService.nodeUpdated.pipe(takeUntilDestroyed()).subscribe((node) => {
+            this.dataTableService.rowUpdate.next({ id: node.id, obj: { entry: node } });
+        });
+        this.userPreferencesService
+            .select(UserPreferenceValues.PaginationSize)
+            .pipe(takeUntilDestroyed())
+            .subscribe((pagSize) => {
+            this.maxItems = this._pagination.maxItems = pagSize;
+        });
+    }
+    getContextActions(node) {
+        if (node?.entry) {
+            const actions = this.getNodeActions(node);
+            if (actions && actions.length > 0) {
+                return actions.map((currentAction) => ({
+                    model: currentAction,
+                    node,
+                    subject: this.contextActionHandler
+                }));
+            }
+        }
+        return null;
+    }
+    getDefaultSorting() {
+        let defaultSorting;
+        if (Array.isArray(this.sorting)) {
+            const [key, direction] = this.sorting;
+            defaultSorting = new DataSorting(key, direction);
+        }
+        else {
+            defaultSorting = new DataSorting(this.sorting.key, this.sorting.direction);
+        }
+        return defaultSorting;
+    }
+    isMobile() {
+        return !!/Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent);
+    }
+    isEmpty() {
+        return !this.data || this.data.getRows().length === 0;
+    }
+    ngOnInit() {
+        this.rowMenuCache = {};
+        this.loadLayoutPresets();
+        this.data = new ShareDataTableAdapter(this.thumbnailService, this.contentService, null, this.getDefaultSorting(), this.sortingMode, this.allowDropFiles);
+        this.data.thumbnails = this.thumbnails;
+        this.data.permissionsStyle = this.permissionsStyle;
+        if (this._rowFilter) {
+            this.data.setFilter(this._rowFilter);
+        }
+        if (this.imageResolver) {
+            this.data.setImageResolver(this.imageResolver);
+        }
+        this.contextActionHandler.pipe(takeUntilDestroyed(this.destroyRef)).subscribe((val) => this.contextActionCallback(val));
+        this.enforceSingleClickNavigationForMobile();
+        if (this.filterValue && Object.keys(this.filterValue).length > 0) {
+            this.showHeader = ShowHeaderMode.Always;
+        }
+        if (this.columnsPresetKey) {
+            this.setPresetKey(this.columnsPresetKey);
+        }
+        this.documentListService.reload$.pipe(takeUntilDestroyed(this.destroyRef)).subscribe(() => {
+            this.resetSelection();
+            this.reload();
+        });
+        this.documentListService.resetSelection$.pipe(takeUntilDestroyed(this.destroyRef)).subscribe(() => {
+            this.resetSelection();
+        });
+    }
+    ngAfterContentInit() {
+        if (this.columnList) {
+            this.columnList.columns.changes.pipe(takeUntilDestroyed(this.destroyRef)).subscribe(() => {
+                this.createColumns();
+                this.data.setColumns(this.columns);
+            });
+        }
+        this.createDatatableSchema();
+        this.data.setColumns(this.columns);
+    }
+    ngOnChanges(changes) {
+        if (!changes['preselectNodes']) {
+            this.resetSelection();
+        }
+        if (Array.isArray(this.sorting)) {
+            const [key, direction] = this.sorting;
+            this.orderBy = this.buildOrderByArray(key, direction);
+        }
+        else {
+            this.orderBy = this.buildOrderByArray(this.sorting.key, this.sorting.direction);
+        }
+        if (this.data) {
+            this.data.thumbnails = this.thumbnails;
+        }
+        if (changes.sortingMode && !changes.sortingMode.firstChange && this.data) {
+            this.data.sortingMode = changes.sortingMode.currentValue;
+        }
+        if (changes.sorting && !changes.sorting.firstChange && this.data) {
+            const newValue = changes.sorting.currentValue;
+            if (newValue && newValue.length > 0) {
+                const [key, direction] = newValue;
+                this.data.setSorting(new DataSorting(key, direction));
+            }
+        }
+        if (this.currentFolderId && changes['currentFolderId']?.currentValue !== changes['currentFolderId']?.previousValue) {
+            this.loadFolder();
+        }
+        if (this.data) {
+            if (changes.node?.currentValue) {
+                const merge = this._pagination ? this._pagination.merge : false;
+                this.data.loadPage(changes.node.currentValue, merge, null);
+                this.preserveExistingSelection();
+                this.onPreselectNodes();
+                this.onDataReady(changes.node.currentValue);
+            }
+            else if (changes.imageResolver) {
+                this.data.setImageResolver(changes.imageResolver.currentValue);
+            }
+        }
+    }
+    reload(hideLoadingSpinner = false) {
+        this.resetSelection();
+        this.reloadWithoutResettingSelection(hideLoadingSpinner);
+    }
+    reloadWithoutResettingSelection(hideLoadingSpinner = false) {
+        if (this.node) {
+            if (this.data) {
+                this.data.loadPage(this.node, this._pagination.merge, null);
+                this.preserveExistingSelection();
+            }
+            this.onPreselectNodes();
+            this.syncPagination();
+            this.onDataReady(this.node);
+        }
+        else {
+            this.loadFolder(hideLoadingSpinner);
+        }
+    }
+    contextActionCallback(action) {
+        if (action) {
+            this.executeContentAction(action.node, action.model);
+        }
+    }
+    getNodeActions(node) {
+        if (node?.entry) {
+            let target = null;
+            if (node.entry.isFile) {
+                target = 'document';
+            }
+            else if (node.entry.isFolder) {
+                target = 'folder';
+            }
+            if (target) {
+                const actions = this.rowMenuCache[node.entry.id];
+                if (actions) {
+                    actions.forEach((action) => {
+                        this.refreshAction(action, node);
+                    });
+                    return actions;
+                }
+                const actionsByTarget = this.actions
+                    .filter((entry) => {
+                    const isVisible = typeof entry.visible === 'function' ? entry.visible(node) : entry.visible;
+                    return isVisible && entry.target.toLowerCase() === target;
+                })
+                    .map((action) => new ContentActionModel(action));
+                actionsByTarget.forEach((action) => {
+                    this.refreshAction(action, node);
+                });
+                this.rowMenuCache[node.entry.id] = actionsByTarget;
+                return actionsByTarget;
+            }
+        }
+        return [];
+    }
+    refreshAction(action, node) {
+        action.disabled = this.isActionDisabled(action, node);
+        action.visible = this.isActionVisible(action, node);
+    }
+    isActionVisible(action, node) {
+        if (typeof action.visible === 'function') {
+            return action.visible(node);
+        }
+        return action.visible;
+    }
+    isActionDisabled(action, node) {
+        if (typeof action.disabled === 'function') {
+            return action.disabled(node);
+        }
+        if ((action.permission && action.disableWithNoPermission && !this.contentService.hasAllowableOperations(node.entry, action.permission)) ||
+            this.lockService.isLocked(node.entry)) {
+            return true;
+        }
+        else {
+            return action.disabled;
+        }
+    }
+    onShowContextMenu(e) {
+        if (e && this.contextMenuActions) {
+            e.preventDefault();
+        }
+    }
+    navigateTo(node) {
+        if (typeof node === 'string') {
+            this.resetNewFolderPagination();
+            this.currentFolderId = node;
+            this.folderChange.emit(new NodeEntryEvent({ id: node }));
+            this.reload();
+            return true;
+        }
+        else {
+            if (this.canNavigateFolder(node)) {
+                this.resetNewFolderPagination();
+                this.currentFolderId = this.getNodeFolderDestinationId(node);
+                this.folderChange.emit(new NodeEntryEvent({ id: this.currentFolderId }));
+                this.reload();
+                return true;
+            }
+        }
+        return false;
+    }
+    getNodeFolderDestinationId(node) {
+        return this.isLinkFolder(node) ? node.properties['cm:destination'] : node.id;
+    }
+    isLinkFolder(node) {
+        return node.nodeType === 'app:folderlink' && node.properties?.['cm:destination'];
+    }
+    updateCustomSourceData(nodeId) {
+        this.currentFolderId = nodeId;
+    }
+    /**
+     * Invoked when executing content action for a document or folder.
+     *
+     * @param node Node to be the context of the execution.
+     * @param action Action to be executed against the context.
+     */
+    executeContentAction(node, action) {
+        if (node?.entry && action) {
+            const handlerSub = typeof action.handler === 'function' ? action.handler(node, this, action.permission) : of(true);
+            if (typeof action.execute === 'function' && handlerSub) {
+                handlerSub.pipe(takeUntilDestroyed(this.destroyRef)).subscribe(() => action.execute(node));
+            }
+        }
+    }
+    setLoadingState(value) {
+        if (this.data?.getRows().length > 0) {
+            if (value) {
+                clearTimeout(this.loadingTimeout);
+                this.loadingTimeout = setTimeout(() => {
+                    this.loading = true;
+                }, 1000);
+            }
+            else {
+                clearTimeout(this.loadingTimeout);
+                this.loading = false;
+            }
+        }
+        else {
+            clearTimeout(this.loadingTimeout);
+            this.loading = value;
+        }
+    }
+    loadFolder(hideLoadingSpinner = false) {
+        if (!hideLoadingSpinner) {
+            this.setLoadingState(true);
+        }
+        if (this.documentListService.isCustomSourceService(this.currentFolderId)) {
+            this.updateCustomSourceData(this.currentFolderId);
+        }
+        this.documentListService.loadFolderByNodeId(this.currentFolderId, this._pagination, this.includeFields, this.where, this.orderBy).subscribe((documentNode) => {
+            if (documentNode.currentNode) {
+                this.folderNode = documentNode.currentNode.entry;
+                this.$folderNode.next(documentNode.currentNode.entry);
+            }
+            this.onPageLoaded(documentNode.children);
+        }, (err) => {
+            this.handleError(err);
+        });
+    }
+    resetSelection() {
+        this.dataTable.resetSelection();
+        this.selection = [];
+        this.noPermission = false;
+    }
+    onPageLoaded(nodePaging) {
+        if (nodePaging) {
+            if (this.data) {
+                this.data.loadPage(nodePaging, this._pagination.merge, this.allowDropFiles);
+                this.preserveExistingSelection();
+            }
+            this.onPreselectNodes();
+            this.setLoadingState(false);
+            this.onDataReady(nodePaging);
+        }
+    }
+    onSortingChanged(event) {
+        this.orderBy = this.buildOrderByArray(event.detail.sortingKey, event.detail.direction);
+        this.sorting = [event.detail.sortingKey, event.detail.direction];
+        this.sortingSubject.next([this.additionalSorting, event.detail]);
+        if (this.sortingMode === 'server') {
+            this.reload();
+        }
+    }
+    buildOrderByArray(currentKey, currentDirection) {
+        return [`${this.additionalSorting.key} ${this.additionalSorting.direction}`, `${currentKey} ${currentDirection}`];
+    }
+    onPreviewFile(node) {
+        if (node) {
+            const sizeInMB = node.entry?.content?.sizeInBytes / BYTES_TO_MB_CONVERSION_VALUE;
+            const fileAutoDownloadFlag = this.appConfig.get('viewer.enableFileAutoDownload', true);
+            const sizeThreshold = this.appConfig.get('viewer.fileAutoDownloadSizeThresholdInMB', 15);
+            if (fileAutoDownloadFlag && sizeInMB && sizeInMB > sizeThreshold) {
+                this.dialog.open(FileAutoDownloadComponent, { disableClose: true, data: node });
+            }
+            else {
+                this.preview.emit(new NodeEntityEvent(node));
+            }
+        }
+    }
+    onColumnsVisibilityChange(columns) {
+        this.columnsVisibility = columns.reduce((visibleColumnsMap, column) => {
+            if (column.isHidden !== undefined) {
+                visibleColumnsMap[column.id] = !column.isHidden;
+            }
+            return visibleColumnsMap;
+        }, {});
+        this.createColumns();
+        this.data.setColumns(this.columns);
+        this.columnsVisibilityChanged.emit(this.columnsVisibility);
+    }
+    onColumnOrderChange(columnsWithNewOrder) {
+        this.columnsOrder = columnsWithNewOrder.map((column) => column.id);
+        this.createColumns();
+        this.columnsOrderChanged.emit(this.columnsOrder);
+    }
+    onColumnsWidthChange(columns) {
+        const newColumnsWidths = columns.reduce((widthsColumnsMap, column) => {
+            if (column.width) {
+                widthsColumnsMap[column.id] = Math.ceil(column.width);
+            }
+            return widthsColumnsMap;
+        }, {});
+        this.columnsWidths = { ...this.columnsWidths, ...newColumnsWidths };
+        this.createColumns();
+        this.columnsWidthChanged.emit(this.columnsWidths);
+    }
+    onSelectedItemsCountChanged(count) {
+        this.selectedItemsCountChanged.emit(count);
+    }
+    onNodeClick(nodeEntry) {
+        const domEvent = new CustomEvent('node-click', {
+            detail: {
+                sender: this,
+                node: nodeEntry
+            },
+            bubbles: true
+        });
+        this.elementRef.nativeElement.dispatchEvent(domEvent);
+        const event = new NodeEntityEvent(nodeEntry);
+        this.nodeClick.emit(event);
+        if (!event.defaultPrevented) {
+            if (this.navigate && this.navigationMode === DocumentListComponent.SINGLE_CLICK_NAVIGATION) {
+                this.executeActionClick(nodeEntry);
+            }
+        }
+    }
+    onNodeDblClick(nodeEntry) {
+        const domEvent = new CustomEvent('node-dblclick', {
+            detail: {
+                sender: this,
+                node: nodeEntry
+            },
+            bubbles: true
+        });
+        this.elementRef.nativeElement.dispatchEvent(domEvent);
+        const event = new NodeEntityEvent(nodeEntry);
+        this.nodeDblClick.emit(event);
+        if (!event.defaultPrevented) {
+            if (this.navigate && this.navigationMode === DocumentListComponent.DOUBLE_CLICK_NAVIGATION) {
+                this.executeActionClick(nodeEntry);
+            }
+        }
+    }
+    executeActionClick(nodeEntry) {
+        if (nodeEntry?.entry) {
+            if (nodeEntry.entry.isFile) {
+                this.onPreviewFile(nodeEntry);
+            }
+            if (nodeEntry.entry.isFolder) {
+                this.navigateTo(nodeEntry.entry);
+            }
+            if (nodeEntry.entry['guid']) {
+                const options = {
+                    include: this.includeFields
+                };
+                this.nodesApi.getNode(nodeEntry.entry['guid'], options).then((node) => {
+                    this.navigateTo(node.entry);
+                });
+            }
+        }
+    }
+    onNodeSelect(event) {
+        this.selection = event.selection.map((entry) => entry.node);
+        const domEvent = new CustomEvent('node-select', {
+            detail: {
+                node: event.row ? event.row.node : null,
+                selection: this.selection
+            },
+            bubbles: true
+        });
+        this.nodeSelected.emit(this.selection);
+        this.elementRef.nativeElement.dispatchEvent(domEvent);
+    }
+    onNodeUnselect(event) {
+        this.selection = event.selection.map((entry) => entry.node);
+        const domEvent = new CustomEvent('node-unselect', {
+            detail: {
+                node: event.row ? event.row.node : null,
+                selection: this.selection
+            },
+            bubbles: true
+        });
+        this.nodeSelected.emit(this.selection);
+        this.elementRef.nativeElement.dispatchEvent(domEvent);
+    }
+    onShowRowContextMenu(event) {
+        if (this.contextMenuActions) {
+            const args = event.value;
+            const node = args.row.node;
+            if (node) {
+                args.actions = this.getContextActions(node) || [];
+            }
+        }
+    }
+    onShowRowActionsMenu(event) {
+        if (this.contentActions) {
+            const args = event.value;
+            const node = args.row.node;
+            if (node) {
+                args.actions = this.getNodeActions(node) || [];
+            }
+        }
+    }
+    onExecuteRowAction(event) {
+        if (this.contentActions) {
+            const args = event.value;
+            const node = args.row.node;
+            const action = args.action;
+            this.executeContentAction(node, action);
+        }
+    }
+    enforceSingleClickNavigationForMobile() {
+        if (this.isMobile()) {
+            this.navigationMode = DocumentListComponent.SINGLE_CLICK_NAVIGATION;
+        }
+    }
+    canNavigateFolder(node) {
+        let canNavigateFolder = false;
+        if (node?.isFolder) {
+            canNavigateFolder = true;
+        }
+        return canNavigateFolder;
+    }
+    onDataReady(nodePaging) {
+        this.ready.emit(nodePaging);
+        this.pagination.next(nodePaging.list.pagination);
+    }
+    updatePagination(requestPaginationModel) {
+        this._pagination.maxItems = requestPaginationModel.maxItems;
+        this._pagination.skipCount = requestPaginationModel.skipCount;
+        this.reload(requestPaginationModel.merge);
+    }
+    syncPagination() {
+        this.node.list.pagination.maxItems = this._pagination.maxItems;
+        this.node.list.pagination.skipCount = this._pagination.skipCount;
+    }
+    onFilterSelectionChange(activeFilters) {
+        this.filterSelection.emit(activeFilters);
+    }
+    resetNewFolderPagination() {
+        this._pagination.skipCount = 0;
+        this._pagination.maxItems = this.maxItems;
+    }
+    handleError(err) {
+        if (err.message) {
+            try {
+                if (JSON.parse(err.message).error.statusCode === 403) {
+                    this.noPermission = true;
+                }
+            }
+            catch (error) {
+                /* empty */
+            }
+        }
+        this.setLoadingState(false);
+        this.error.emit(err);
+    }
+    getPreselectedNodesBasedOnSelectionMode() {
+        return this.hasPreselectedNodes() ? (this.isSingleSelectionMode() ? [this.preselectNodes[0]] : this.preselectNodes) : [];
+    }
+    getPreselectedRowsBasedOnSelectionMode() {
+        return this.hasPreselectedRows() ? (this.isSingleSelectionMode() ? [this.preselectedRows[0]] : this.preselectedRows) : [];
+    }
+    getSelectionBasedOnSelectionMode() {
+        return this.hasPreselectedRows()
+            ? this.isSingleSelectionMode()
+                ? [this.preselectedRows[0]]
+                : this.data.getSelectedRows()
+            : this.data.getSelectedRows();
+    }
+    onPreselectNodes() {
+        if (this.hasPreselectedNodes()) {
+            this.preselectRowsOfPreselectedNodes();
+            const preselectedRows = this.getPreselectedRowsBasedOnSelectionMode();
+            const selection = this.data.getSelectedRows();
+            for (const node of preselectedRows) {
+                this.dataTable.selectRow(node, true);
+            }
+            this.onNodeSelect({ row: undefined, selection });
+        }
+    }
+    preserveExistingSelection() {
+        if (this.isMultipleSelectionMode()) {
+            for (const selection of this.selection) {
+                const rowOfSelection = this.data.getRowByNodeId(selection.entry.id);
+                if (rowOfSelection) {
+                    rowOfSelection.isSelected = true;
+                }
+            }
+        }
+    }
+    preselectRowsOfPreselectedNodes() {
+        this.preselectedRows = [];
+        const preselectedNodes = this.getPreselectedNodesBasedOnSelectionMode();
+        preselectedNodes.forEach((preselectedNode) => {
+            const rowOfPreselectedNode = this.data.getRowByNodeId(preselectedNode.entry.id);
+            if (rowOfPreselectedNode) {
+                rowOfPreselectedNode.isSelected = true;
+                this.preselectedRows.push(rowOfPreselectedNode);
+            }
+        });
+    }
+    unselectRowFromNodeId(nodeId) {
+        const rowToUnselect = this.data.getRowByNodeId(nodeId);
+        if (rowToUnselect?.isSelected) {
+            rowToUnselect.isSelected = false;
+            this.dataTable.selectRow(rowToUnselect, false);
+            const selection = this.getSelectionBasedOnSelectionMode();
+            this.onNodeUnselect({ row: undefined, selection });
+        }
+    }
+    isSingleSelectionMode() {
+        return this.selectionMode === 'single';
+    }
+    isMultipleSelectionMode() {
+        return this.selectionMode === 'multiple';
+    }
+    hasPreselectedNodes() {
+        return this.preselectNodes?.length > 0;
+    }
+    hasPreselectedRows() {
+        return this.preselectedRows?.length > 0;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DocumentListComponent, deps: [{ token: i1.DocumentListService }, { token: i0.ElementRef }, { token: i2.AppConfigService }, { token: i2.UserPreferencesService }, { token: i3.ContentService }, { token: i2.ThumbnailService }, { token: i4.AlfrescoApiService }, { token: i3.NodesApiService }, { token: i2.DataTableService }, { token: i5.LockService }, { token: i6.MatDialog }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: DocumentListComponent, isStandalone: true, selector: "adf-document-list", inputs: { includeFields: "includeFields", where: "where", permissionsStyle: "permissionsStyle", locationFormat: "locationFormat", navigate: "navigate", showHeader: "showHeader", navigationMode: "navigationMode", thumbnails: "thumbnails", selectionMode: "selectionMode", multiselect: "multiselect", contentActions: "contentActions", contentActionsPosition: "contentActionsPosition", contextMenuActions: "contextMenuActions", emptyFolderImageUrl: "emptyFolderImageUrl", allowDropFiles: "allowDropFiles", sorting: "sorting", additionalSorting: "additionalSorting", sortingMode: "sortingMode", rowStyle: "rowStyle", rowStyleClass: "rowStyleClass", loading: "loading", _rowFilter: "_rowFilter", rowFilter: "rowFilter", imageResolver: "imageResolver", stickyHeader: "stickyHeader", headerFilters: "headerFilters", filterValue: "filterValue", currentFolderId: "currentFolderId", preselectNodes: "preselectNodes", node: "node", maxItems: "maxItems", columnsPresetKey: "columnsPresetKey", setColumnsVisibility: "setColumnsVisibility", setColumnsWidths: "setColumnsWidths", setColumnsOrder: "setColumnsOrder", maxColumnsVisible: "maxColumnsVisible", isResizingEnabled: "isResizingEnabled", blurOnResize: "blurOnResize", displayCheckboxesOnHover: "displayCheckboxesOnHover", displayDragAndDropHint: "displayDragAndDropHint" }, outputs: { nodeClick: "nodeClick", nodeDblClick: "nodeDblClick", folderChange: "folderChange", preview: "preview", ready: "ready", error: "error", nodeSelected: "nodeSelected", filterSelection: "filterSelection", columnsWidthChanged: "columnsWidthChanged", columnsVisibilityChanged: "columnsVisibilityChanged", columnsOrderChanged: "columnsOrderChanged", selectedItemsCountChanged: "selectedItemsCountChanged" }, host: { listeners: { "contextmenu": "onShowContextMenu($event)" }, classAttribute: "adf-document-list" }, providers: [
+            {
+                provide: ADF_DOCUMENT_PARENT_COMPONENT,
+                useExisting: DocumentListComponent
+            },
+            DataTableService
+        ], queries: [{ propertyName: "columnList", first: true, predicate: DataColumnListComponent, descendants: true }, { propertyName: "customLoadingContent", first: true, predicate: CustomLoadingContentTemplateDirective, descendants: true }, { propertyName: "customNoPermissionsTemplate", first: true, predicate: CustomNoPermissionTemplateDirective, descendants: true }, { propertyName: "customNoContentTemplate", first: true, predicate: CustomEmptyContentTemplateDirective, descendants: true }], viewQueries: [{ propertyName: "dataTable", first: true, predicate: ["dataTable"], descendants: true, static: true }], usesInheritance: true, usesOnChanges: true, ngImport: i0, template: "<adf-datatable\n    #dataTable\n    [selectionMode]=\"selectionMode\"\n    [data]=\"data\"\n    [actions]=\"contentActions\"\n    [actionsPosition]=\"contentActionsPosition\"\n    [multiselect]=\"multiselect\"\n    [contextMenu]=\"contextMenuActions\"\n    [rowStyle]=\"rowStyle\"\n    [rowStyleClass]=\"rowStyleClass\"\n    [showMainDatatableActions]=\"true\"\n    [loading]=\"loading\"\n    [noPermission]=\"noPermission\"\n    [showHeader]=\"showHeader\"\n    [rowMenuCacheEnabled]=\"false\"\n    [stickyHeader]=\"stickyHeader\"\n    [allowFiltering]=\"allowFiltering\"\n    [isResizingEnabled]=\"isResizingEnabled\"\n    [blurOnResize]=\"blurOnResize\"\n    [displayCheckboxesOnHover]=\"displayCheckboxesOnHover\"\n    (showRowContextMenu)=\"onShowRowContextMenu($event)\"\n    (showRowActionsMenu)=\"onShowRowActionsMenu($event)\"\n    (executeRowAction)=\"onExecuteRowAction($event)\"\n    (columnsWidthChanged)=\"onColumnsWidthChange($event)\"\n    (columnOrderChanged)=\"onColumnOrderChange($event)\"\n    (selectedItemsCountChanged)=\"onSelectedItemsCountChanged($event)\"\n    (rowClick)=\"onNodeClick($event.value?.node)\"\n    (rowDblClick)=\"onNodeDblClick($event.value?.node)\"\n    (row-select)=\"onNodeSelect($any($event).detail)\"\n    (row-unselect)=\"onNodeUnselect($any($event).detail)\"\n    (sorting-changed)=\"onSortingChanged($any($event))\"\n    [class.adf-datatable-gallery-thumbnails]=\"data.thumbnails\">\n\n    <div *ngIf=\"headerFilters\">\n        <adf-filter-header\n            [currentFolderId]=\"currentFolderId\"\n            [value]=\"filterValue\"\n            (filterSelection)=\"onFilterSelectionChange($event)\" />\n    </div>\n\n    <adf-no-content-template>\n        <ng-template>\n            <adf-empty-list *ngIf=\"!customNoContentTemplate\">\n                <div class=\"adf-empty-list_template adf-empty-folder\">\n                    <div class=\"adf-empty-folder-this-space-is-empty\">{{'ADF-DOCUMENT-LIST.EMPTY.HEADER' | translate}}</div>\n                    <ng-container *ngIf=\"displayDragAndDropHint\">\n                        <div class=\"adf-empty-folder-drag-drop\">{{ 'ADF-DATATABLE.EMPTY.DRAG-AND-DROP.TITLE' | translate }}</div>\n                        <div class=\"adf-empty-folder-any-files-here-to-add\">{{ 'ADF-DATATABLE.EMPTY.DRAG-AND-DROP.SUBTITLE' | translate }}</div>\n                    </ng-container>\n                    <img [alt]=\"'ADF-DATATABLE.EMPTY.DRAG-AND-DROP.TITLE' | translate\" class=\"adf-empty-folder-image\" [src]=\"emptyFolderImageUrl\">\n                </div>\n            </adf-empty-list>\n            <ng-content select=\"adf-custom-empty-content-template, empty-folder-content\" />\n        </ng-template>\n    </adf-no-content-template>\n\n    <adf-no-permission-template>\n        <ng-template>\n            <div class=\"adf-no-permission__template\" *ngIf=\"!customNoPermissionsTemplate\">\n                <mat-icon>error</mat-icon>\n                <p class=\"adf-no-permission__template--text\">{{ 'ADF-DOCUMENT-LIST.NO_PERMISSION' | translate }}</p>\n            </div>\n            <ng-content select=\"adf-custom-no-permission-template, no-permission-content\" />\n        </ng-template>\n    </adf-no-permission-template>\n\n    <adf-loading-content-template>\n        <ng-template>\n            <div class=\"adf-document-list-loading-container\" *ngIf=\"!customLoadingContent\">\n                <mat-progress-spinner\n                    id=\"adf-document-list-loading\"\n                    class=\"adf-document-list-loading-margin\"\n                    [attr.aria-label]=\"'ADF-DOCUMENT-LIST.LOADER_LABEL' | translate\"\n                    [color]=\"'primary'\"\n                    [mode]=\"'indeterminate'\" />\n            </div>\n            <ng-content select=\"adf-custom-loading-content-template\" />\n        </ng-template>\n    </adf-loading-content-template>\n\n    <adf-main-menu-datatable-template>\n        <ng-template let-mainMenuTrigger>\n            <adf-datatable-column-selector\n              [columns]=\"columns\"\n              [mainMenuTrigger]=\"mainMenuTrigger\"\n              [columnsSorting]=\"false\"\n              [maxColumnsVisible]=\"maxColumnsVisible\"\n              (submitColumnsVisibility)=\"onColumnsVisibilityChange($event)\" />\n        </ng-template>\n    </adf-main-menu-datatable-template>\n\n</adf-datatable>\n", styles: [".adf-document-list{min-height:0;height:100%;background-color:var(--theme-background-color)}.adf-sticky-document-list{height:310px;overflow-y:auto}.adf-datatable-card .adf-datatable-selected>svg{fill:var(--theme-accent-color);width:30px;height:30px;position:absolute;top:10px}.adf-datatable-list .adf-datatable-selected{display:inline-table}.adf-datatable-list .adf-datatable-selected>svg{fill:var(--theme-accent-color);width:30px;height:30px}.adf-document-list_empty_template{text-align:center;margin-top:20px;margin-bottom:20px}.adf-no-permission__template{display:flex;align-items:center;justify-content:center;flex-direction:column;width:100%;height:100%;min-height:300px}.adf-no-permission__template mat-icon{font-size:52px;height:52px;width:52px}.adf-no-permission__template--text{color:var(--adf-theme-foreground-text-color);font-size:var(--theme-subheading-2-font-size)}.adf-document-list__this-space-is-empty{height:32px;opacity:.26;font-size:var(--theme-headline-font-size);line-height:1.33;letter-spacing:-1px;color:var(--adf-theme-foreground-text-color)}.adf-document-list__drag-drop{height:56px;opacity:.54;font-size:56px;line-height:1;letter-spacing:-2px;color:var(--adf-theme-foreground-text-color);margin-top:40px}.adf-document-list__any-files-here-to-add{height:24px;opacity:.54;font-size:var(--theme-subheading-2-font-size);line-height:1.5;letter-spacing:-.4px;color:var(--adf-theme-foreground-text-color);margin-top:17px}.adf-document-list__empty_doc_lib{width:565px;height:161px;object-fit:contain;margin-top:17px}.adf-document-list-loading-margin{margin:auto}.adf-document-list-loading-container{min-height:300px;display:flex;flex-direction:row;height:100%}.adf-empty-list-header{height:32px;opacity:.26;font-size:var(--theme-headline-font-size);line-height:1.33;letter-spacing:-1px;color:var(--adf-theme-foreground-text-color)}.adf-documentlist-pagination{color:var(--adf-theme-foreground-text-color)}.adf-documentlist-pagination .adf-pagination__block{border-right:none}.adf-empty-folder-this-space-is-empty{height:32px;font-size:var(--theme-headline-font-size);line-height:1.33;letter-spacing:-1px;color:var(--adf-theme-foreground-text-color-054)}.adf-empty-folder-drag-drop{min-height:56px;font-size:53px;line-height:1;letter-spacing:-2px;color:var(--adf-theme-foreground-text-color);margin-top:40px;word-break:break-all;white-space:pre-line}@media (max-width: 599.9px){.adf-empty-folder-drag-drop{font-size:48px}}.adf-empty-folder-any-files-here-to-add{min-height:24px;font-size:var(--theme-subheading-2-font-size);line-height:1.5;letter-spacing:-.4px;color:var(--adf-theme-foreground-text-color);margin-top:17px;word-break:break-all;white-space:pre-line}.adf-empty-folder-image{width:565px;max-width:100%;object-fit:contain;margin-top:17px}@media (max-width: 599.9px){.adf-empty-folder-image{width:250px}}@media (max-width: 959.9px){.adf-empty-folder-drag-drop,.adf-empty-folder-any-files-here-to-add{display:none}}.adf-datatable-gallery-thumbnails .adf-datatable-card .adf-datatable-row:is(adf-datatable-row){height:300px}.adf-datatable-gallery-thumbnails .adf-datatable-card .adf-datatable-row:is(adf-datatable-row) img{height:130px}.adf-datatable-gallery-thumbnails .adf-datatable-card .adf-datatable-row:is(adf-datatable-row) .adf-datatable-cell{overflow:visible}.adf-datatable-gallery-thumbnails .adf-datatable-card .adf-datatable-row:is(adf-datatable-row) .adf-datatable-cell.adf-datatable-cell--image{flex:0 0 auto;display:flex;flex-direction:column-reverse;justify-content:space-between}.adf-datatable-gallery-thumbnails .adf-datatable-card .adf-datatable-row:is(adf-datatable-row) .adf-datatable-cell.adf-datatable-cell--image .adf-cell-value{display:flex;justify-content:center}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i7.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: DataTableComponent, selector: "adf-datatable", inputs: ["data", "rows", "sorting", "columns", "selectionMode", "multiselect", "mainTableAction", "actions", "showMainDatatableActions", "showProvidedActions", "actionsPosition", "actionsVisibleOnHover", "fallbackThumbnail", "contextMenu", "rowStyle", "rowStyleClass", "showHeader", "stickyHeader", "loading", "noPermission", "rowMenuCacheEnabled", "resolverFn", "allowFiltering", "isResizingEnabled", "blurOnResize", "displayCheckboxesOnHover", "enableDragRows"], outputs: ["rowClick", "rowDblClick", "showRowContextMenu", "showRowActionsMenu", "executeRowAction", "columnOrderChanged", "columnsWidthChanged", "selectedItemsCountChanged", "dragDropped"] }, { kind: "component", type: FilterHeaderComponent, selector: "adf-filter-header", inputs: ["value", "currentFolderId"], outputs: ["filterSelection"] }, { kind: "directive", type: NoContentTemplateDirective, selector: "adf-no-content-template, no-content-template" }, { kind: "component", type: EmptyListComponent, selector: "adf-empty-list" }, { kind: "pipe", type: TranslatePipe, name: "translate" }, { kind: "directive", type: NoPermissionTemplateDirective, selector: "adf-no-permission-template, no-permission-template" }, { kind: "ngmodule", type: MatIconModule }, { kind: "component", type: i8.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "directive", type: LoadingContentTemplateDirective, selector: "adf-loading-content-template, loading-content-template" }, { kind: "ngmodule", type: MatProgressSpinnerModule }, { kind: "component", type: i9.MatProgressSpinner, selector: "mat-progress-spinner, mat-spinner", inputs: ["color", "mode", "value", "diameter", "strokeWidth"], exportAs: ["matProgressSpinner"] }, { kind: "directive", type: MainMenuDataTableTemplateDirective, selector: "adf-main-menu-datatable-template" }, { kind: "component", type: ColumnsSelectorComponent, selector: "adf-datatable-column-selector", inputs: ["columns", "mainMenuTrigger", "columnsSorting", "maxColumnsVisible"], outputs: ["submitColumnsVisibility"] }], encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DocumentListComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'adf-document-list', standalone: true, imports: [
+                        CommonModule,
+                        DataTableComponent,
+                        FilterHeaderComponent,
+                        NoContentTemplateDirective,
+                        EmptyListComponent,
+                        TranslatePipe,
+                        NoPermissionTemplateDirective,
+                        MatIconModule,
+                        LoadingContentTemplateDirective,
+                        MatProgressSpinnerModule,
+                        MainMenuDataTableTemplateDirective,
+                        ColumnsSelectorComponent
+                    ], providers: [
+                        {
+                            provide: ADF_DOCUMENT_PARENT_COMPONENT,
+                            useExisting: DocumentListComponent
+                        },
+                        DataTableService
+                    ], encapsulation: ViewEncapsulation.None, host: { class: 'adf-document-list' }, template: "<adf-datatable\n    #dataTable\n    [selectionMode]=\"selectionMode\"\n    [data]=\"data\"\n    [actions]=\"contentActions\"\n    [actionsPosition]=\"contentActionsPosition\"\n    [multiselect]=\"multiselect\"\n    [contextMenu]=\"contextMenuActions\"\n    [rowStyle]=\"rowStyle\"\n    [rowStyleClass]=\"rowStyleClass\"\n    [showMainDatatableActions]=\"true\"\n    [loading]=\"loading\"\n    [noPermission]=\"noPermission\"\n    [showHeader]=\"showHeader\"\n    [rowMenuCacheEnabled]=\"false\"\n    [stickyHeader]=\"stickyHeader\"\n    [allowFiltering]=\"allowFiltering\"\n    [isResizingEnabled]=\"isResizingEnabled\"\n    [blurOnResize]=\"blurOnResize\"\n    [displayCheckboxesOnHover]=\"displayCheckboxesOnHover\"\n    (showRowContextMenu)=\"onShowRowContextMenu($event)\"\n    (showRowActionsMenu)=\"onShowRowActionsMenu($event)\"\n    (executeRowAction)=\"onExecuteRowAction($event)\"\n    (columnsWidthChanged)=\"onColumnsWidthChange($event)\"\n    (columnOrderChanged)=\"onColumnOrderChange($event)\"\n    (selectedItemsCountChanged)=\"onSelectedItemsCountChanged($event)\"\n    (rowClick)=\"onNodeClick($event.value?.node)\"\n    (rowDblClick)=\"onNodeDblClick($event.value?.node)\"\n    (row-select)=\"onNodeSelect($any($event).detail)\"\n    (row-unselect)=\"onNodeUnselect($any($event).detail)\"\n    (sorting-changed)=\"onSortingChanged($any($event))\"\n    [class.adf-datatable-gallery-thumbnails]=\"data.thumbnails\">\n\n    <div *ngIf=\"headerFilters\">\n        <adf-filter-header\n            [currentFolderId]=\"currentFolderId\"\n            [value]=\"filterValue\"\n            (filterSelection)=\"onFilterSelectionChange($event)\" />\n    </div>\n\n    <adf-no-content-template>\n        <ng-template>\n            <adf-empty-list *ngIf=\"!customNoContentTemplate\">\n                <div class=\"adf-empty-list_template adf-empty-folder\">\n                    <div class=\"adf-empty-folder-this-space-is-empty\">{{'ADF-DOCUMENT-LIST.EMPTY.HEADER' | translate}}</div>\n                    <ng-container *ngIf=\"displayDragAndDropHint\">\n                        <div class=\"adf-empty-folder-drag-drop\">{{ 'ADF-DATATABLE.EMPTY.DRAG-AND-DROP.TITLE' | translate }}</div>\n                        <div class=\"adf-empty-folder-any-files-here-to-add\">{{ 'ADF-DATATABLE.EMPTY.DRAG-AND-DROP.SUBTITLE' | translate }}</div>\n                    </ng-container>\n                    <img [alt]=\"'ADF-DATATABLE.EMPTY.DRAG-AND-DROP.TITLE' | translate\" class=\"adf-empty-folder-image\" [src]=\"emptyFolderImageUrl\">\n                </div>\n            </adf-empty-list>\n            <ng-content select=\"adf-custom-empty-content-template, empty-folder-content\" />\n        </ng-template>\n    </adf-no-content-template>\n\n    <adf-no-permission-template>\n        <ng-template>\n            <div class=\"adf-no-permission__template\" *ngIf=\"!customNoPermissionsTemplate\">\n                <mat-icon>error</mat-icon>\n                <p class=\"adf-no-permission__template--text\">{{ 'ADF-DOCUMENT-LIST.NO_PERMISSION' | translate }}</p>\n            </div>\n            <ng-content select=\"adf-custom-no-permission-template, no-permission-content\" />\n        </ng-template>\n    </adf-no-permission-template>\n\n    <adf-loading-content-template>\n        <ng-template>\n            <div class=\"adf-document-list-loading-container\" *ngIf=\"!customLoadingContent\">\n                <mat-progress-spinner\n                    id=\"adf-document-list-loading\"\n                    class=\"adf-document-list-loading-margin\"\n                    [attr.aria-label]=\"'ADF-DOCUMENT-LIST.LOADER_LABEL' | translate\"\n                    [color]=\"'primary'\"\n                    [mode]=\"'indeterminate'\" />\n            </div>\n            <ng-content select=\"adf-custom-loading-content-template\" />\n        </ng-template>\n    </adf-loading-content-template>\n\n    <adf-main-menu-datatable-template>\n        <ng-template let-mainMenuTrigger>\n            <adf-datatable-column-selector\n              [columns]=\"columns\"\n              [mainMenuTrigger]=\"mainMenuTrigger\"\n              [columnsSorting]=\"false\"\n              [maxColumnsVisible]=\"maxColumnsVisible\"\n              (submitColumnsVisibility)=\"onColumnsVisibilityChange($event)\" />\n        </ng-template>\n    </adf-main-menu-datatable-template>\n\n</adf-datatable>\n", styles: [".adf-document-list{min-height:0;height:100%;background-color:var(--theme-background-color)}.adf-sticky-document-list{height:310px;overflow-y:auto}.adf-datatable-card .adf-datatable-selected>svg{fill:var(--theme-accent-color);width:30px;height:30px;position:absolute;top:10px}.adf-datatable-list .adf-datatable-selected{display:inline-table}.adf-datatable-list .adf-datatable-selected>svg{fill:var(--theme-accent-color);width:30px;height:30px}.adf-document-list_empty_template{text-align:center;margin-top:20px;margin-bottom:20px}.adf-no-permission__template{display:flex;align-items:center;justify-content:center;flex-direction:column;width:100%;height:100%;min-height:300px}.adf-no-permission__template mat-icon{font-size:52px;height:52px;width:52px}.adf-no-permission__template--text{color:var(--adf-theme-foreground-text-color);font-size:var(--theme-subheading-2-font-size)}.adf-document-list__this-space-is-empty{height:32px;opacity:.26;font-size:var(--theme-headline-font-size);line-height:1.33;letter-spacing:-1px;color:var(--adf-theme-foreground-text-color)}.adf-document-list__drag-drop{height:56px;opacity:.54;font-size:56px;line-height:1;letter-spacing:-2px;color:var(--adf-theme-foreground-text-color);margin-top:40px}.adf-document-list__any-files-here-to-add{height:24px;opacity:.54;font-size:var(--theme-subheading-2-font-size);line-height:1.5;letter-spacing:-.4px;color:var(--adf-theme-foreground-text-color);margin-top:17px}.adf-document-list__empty_doc_lib{width:565px;height:161px;object-fit:contain;margin-top:17px}.adf-document-list-loading-margin{margin:auto}.adf-document-list-loading-container{min-height:300px;display:flex;flex-direction:row;height:100%}.adf-empty-list-header{height:32px;opacity:.26;font-size:var(--theme-headline-font-size);line-height:1.33;letter-spacing:-1px;color:var(--adf-theme-foreground-text-color)}.adf-documentlist-pagination{color:var(--adf-theme-foreground-text-color)}.adf-documentlist-pagination .adf-pagination__block{border-right:none}.adf-empty-folder-this-space-is-empty{height:32px;font-size:var(--theme-headline-font-size);line-height:1.33;letter-spacing:-1px;color:var(--adf-theme-foreground-text-color-054)}.adf-empty-folder-drag-drop{min-height:56px;font-size:53px;line-height:1;letter-spacing:-2px;color:var(--adf-theme-foreground-text-color);margin-top:40px;word-break:break-all;white-space:pre-line}@media (max-width: 599.9px){.adf-empty-folder-drag-drop{font-size:48px}}.adf-empty-folder-any-files-here-to-add{min-height:24px;font-size:var(--theme-subheading-2-font-size);line-height:1.5;letter-spacing:-.4px;color:var(--adf-theme-foreground-text-color);margin-top:17px;word-break:break-all;white-space:pre-line}.adf-empty-folder-image{width:565px;max-width:100%;object-fit:contain;margin-top:17px}@media (max-width: 599.9px){.adf-empty-folder-image{width:250px}}@media (max-width: 959.9px){.adf-empty-folder-drag-drop,.adf-empty-folder-any-files-here-to-add{display:none}}.adf-datatable-gallery-thumbnails .adf-datatable-card .adf-datatable-row:is(adf-datatable-row){height:300px}.adf-datatable-gallery-thumbnails .adf-datatable-card .adf-datatable-row:is(adf-datatable-row) img{height:130px}.adf-datatable-gallery-thumbnails .adf-datatable-card .adf-datatable-row:is(adf-datatable-row) .adf-datatable-cell{overflow:visible}.adf-datatable-gallery-thumbnails .adf-datatable-card .adf-datatable-row:is(adf-datatable-row) .adf-datatable-cell.adf-datatable-cell--image{flex:0 0 auto;display:flex;flex-direction:column-reverse;justify-content:space-between}.adf-datatable-gallery-thumbnails .adf-datatable-card .adf-datatable-row:is(adf-datatable-row) .adf-datatable-cell.adf-datatable-cell--image .adf-cell-value{display:flex;justify-content:center}\n"] }]
+        }], ctorParameters: () => [{ type: i1.DocumentListService }, { type: i0.ElementRef }, { type: i2.AppConfigService }, { type: i2.UserPreferencesService }, { type: i3.ContentService }, { type: i2.ThumbnailService }, { type: i4.AlfrescoApiService }, { type: i3.NodesApiService }, { type: i2.DataTableService }, { type: i5.LockService }, { type: i6.MatDialog }], propDecorators: { columnList: [{
+                type: ContentChild,
+                args: [DataColumnListComponent]
+            }], customLoadingContent: [{
+                type: ContentChild,
+                args: [CustomLoadingContentTemplateDirective]
+            }], customNoPermissionsTemplate: [{
+                type: ContentChild,
+                args: [CustomNoPermissionTemplateDirective]
+            }], customNoContentTemplate: [{
+                type: ContentChild,
+                args: [CustomEmptyContentTemplateDirective]
+            }], includeFields: [{
+                type: Input
+            }], where: [{
+                type: Input
+            }], permissionsStyle: [{
+                type: Input
+            }], locationFormat: [{
+                type: Input
+            }], navigate: [{
+                type: Input
+            }], showHeader: [{
+                type: Input
+            }], navigationMode: [{
+                type: Input
+            }], thumbnails: [{
+                type: Input
+            }], selectionMode: [{
+                type: Input
+            }], multiselect: [{
+                type: Input
+            }], contentActions: [{
+                type: Input
+            }], contentActionsPosition: [{
+                type: Input
+            }], contextMenuActions: [{
+                type: Input
+            }], emptyFolderImageUrl: [{
+                type: Input
+            }], allowDropFiles: [{
+                type: Input
+            }], sorting: [{
+                type: Input
+            }], additionalSorting: [{
+                type: Input
+            }], sortingMode: [{
+                type: Input
+            }], rowStyle: [{
+                type: Input
+            }], rowStyleClass: [{
+                type: Input
+            }], loading: [{
+                type: Input
+            }], _rowFilter: [{
+                type: Input
+            }], rowFilter: [{
+                type: Input
+            }], imageResolver: [{
+                type: Input
+            }], stickyHeader: [{
+                type: Input
+            }], headerFilters: [{
+                type: Input
+            }], filterValue: [{
+                type: Input
+            }], currentFolderId: [{
+                type: Input
+            }], preselectNodes: [{
+                type: Input
+            }], node: [{
+                type: Input
+            }], maxItems: [{
+                type: Input
+            }], columnsPresetKey: [{
+                type: Input
+            }], setColumnsVisibility: [{
+                type: Input
+            }], setColumnsWidths: [{
+                type: Input
+            }], setColumnsOrder: [{
+                type: Input
+            }], maxColumnsVisible: [{
+                type: Input
+            }], isResizingEnabled: [{
+                type: Input
+            }], blurOnResize: [{
+                type: Input
+            }], displayCheckboxesOnHover: [{
+                type: Input
+            }], displayDragAndDropHint: [{
+                type: Input
+            }], nodeClick: [{
+                type: Output
+            }], nodeDblClick: [{
+                type: Output
+            }], folderChange: [{
+                type: Output
+            }], preview: [{
+                type: Output
+            }], ready: [{
+                type: Output
+            }], error: [{
+                type: Output
+            }], nodeSelected: [{
+                type: Output
+            }], filterSelection: [{
+                type: Output
+            }], columnsWidthChanged: [{
+                type: Output
+            }], columnsVisibilityChanged: [{
+                type: Output
+            }], columnsOrderChanged: [{
+                type: Output
+            }], selectedItemsCountChanged: [{
+                type: Output
+            }], dataTable: [{
+                type: ViewChild,
+                args: ['dataTable', { static: true }]
+            }], onShowContextMenu: [{
+                type: HostListener,
+                args: ['contextmenu', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"document-list.component.js","sourceRoot":"","sources":["../../../../../../../lib/content-services/src/lib/document-list/components/document-list.component.ts","../../../../../../../lib/content-services/src/lib/document-list/components/document-list.component.html"],"names":[],"mappings":"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","sourcesContent":["/*!\n * @license\n * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/* eslint-disable rxjs/no-subject-value */\n/* eslint-disable @typescript-eslint/naming-convention */\n\nimport {\n    AppConfigService,\n    ColumnsSelectorComponent,\n    CustomEmptyContentTemplateDirective,\n    CustomLoadingContentTemplateDirective,\n    CustomNoPermissionTemplateDirective,\n    DataCellEvent,\n    DataColumn,\n    DataColumnListComponent,\n    DataRow,\n    DataRowActionEvent,\n    DataSorting,\n    DataTableComponent,\n    DataTableSchema,\n    DataTableService,\n    EmptyListComponent,\n    LoadingContentTemplateDirective,\n    MainMenuDataTableTemplateDirective,\n    NoContentTemplateDirective,\n    NoPermissionTemplateDirective,\n    PaginatedComponent,\n    PaginationModel,\n    RequestPaginationModel,\n    ShowHeaderMode,\n    ThumbnailService,\n    UserPreferencesService,\n    UserPreferenceValues\n} from '@alfresco/adf-core';\nimport { Node, NodeEntry, NodePaging, NodesApi, Pagination } from '@alfresco/js-api';\nimport {\n    AfterContentInit,\n    Component,\n    ContentChild,\n    DestroyRef,\n    ElementRef,\n    EventEmitter,\n    HostListener,\n    inject,\n    Input,\n    OnChanges,\n    OnInit,\n    Output,\n    SimpleChanges,\n    ViewChild,\n    ViewEncapsulation\n} from '@angular/core';\nimport { MatDialog } from '@angular/material/dialog';\nimport { BehaviorSubject, of, Subject } from 'rxjs';\nimport { ContentService, NodesApiService } from '../../common';\nimport { FilterSearch } from '../../search';\nimport { RowFilter } from '../data/row-filter.model';\nimport { ShareDataRow } from '../data/share-data-row.model';\nimport { ShareDataTableAdapter } from '../data/share-datatable-adapter';\nimport { ContentActionModel } from '../models/content-action.model';\nimport { DocumentLoaderNode } from '../models/document-folder.model';\nimport { PermissionStyleModel } from '../models/permissions-style.model';\nimport { presetsDefaultModel } from '../models/preset.model';\nimport { DocumentListService } from '../services/document-list.service';\nimport { LockService } from '../services/lock.service';\nimport { ADF_DOCUMENT_PARENT_COMPONENT } from './document-list.token';\nimport { FileAutoDownloadComponent } from './file-auto-download/file-auto-download.component';\nimport { NodeEntityEvent, NodeEntryEvent } from './node.event';\nimport { CommonModule } from '@angular/common';\nimport { FilterHeaderComponent } from './filter-header/filter-header.component';\nimport { TranslatePipe } from '@ngx-translate/core';\nimport { MatIconModule } from '@angular/material/icon';\nimport { MatProgressSpinnerModule } from '@angular/material/progress-spinner';\nimport { AlfrescoApiService } from '../../services/alfresco-api.service';\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\n\nconst BYTES_TO_MB_CONVERSION_VALUE = 1048576;\n\n@Component({\n    selector: 'adf-document-list',\n    standalone: true,\n    imports: [\n        CommonModule,\n        DataTableComponent,\n        FilterHeaderComponent,\n        NoContentTemplateDirective,\n        EmptyListComponent,\n        TranslatePipe,\n        NoPermissionTemplateDirective,\n        MatIconModule,\n        LoadingContentTemplateDirective,\n        MatProgressSpinnerModule,\n        MainMenuDataTableTemplateDirective,\n        ColumnsSelectorComponent\n    ],\n    templateUrl: './document-list.component.html',\n    styleUrls: ['./document-list.component.scss'],\n    providers: [\n        {\n            provide: ADF_DOCUMENT_PARENT_COMPONENT,\n            useExisting: DocumentListComponent\n        },\n        DataTableService\n    ],\n    encapsulation: ViewEncapsulation.None,\n    host: { class: 'adf-document-list' }\n})\nexport class DocumentListComponent extends DataTableSchema implements OnInit, OnChanges, AfterContentInit, PaginatedComponent {\n    static SINGLE_CLICK_NAVIGATION: string = 'click';\n    static DOUBLE_CLICK_NAVIGATION: string = 'dblclick';\n\n    DEFAULT_PAGINATION: Pagination = new Pagination({\n        hasMoreItems: false,\n        skipCount: 0,\n        maxItems: 25,\n        totalItems: 0\n    });\n\n    DEFAULT_SORTING: DataSorting[] = [new DataSorting('name', 'asc'), new DataSorting('isFolder', 'desc')];\n\n    @ContentChild(DataColumnListComponent)\n    columnList: DataColumnListComponent;\n\n    @ContentChild(CustomLoadingContentTemplateDirective)\n    customLoadingContent: CustomLoadingContentTemplateDirective;\n\n    @ContentChild(CustomNoPermissionTemplateDirective)\n    customNoPermissionsTemplate: CustomNoPermissionTemplateDirective;\n\n    @ContentChild(CustomEmptyContentTemplateDirective)\n    customNoContentTemplate: CustomEmptyContentTemplateDirective;\n\n    /** Include additional information about the node in the server request. For example: association, isLink, isLocked and others. */\n    @Input()\n    includeFields: string[];\n\n    /**\n     * Filters the Node list using the *where* condition of the REST API\n     * (for example, isFolder=true). See the REST API documentation for more information.\n     */\n    @Input()\n    where: string;\n\n    /**\n     * Define a set of CSS styles to apply depending on the permission\n     * of the user on that node. See the Permission Style model\n     * page for further details and examples.\n     */\n    @Input()\n    permissionsStyle: PermissionStyleModel[] = [];\n\n    /** The default route for all the location-based columns (if declared). */\n    @Input()\n    locationFormat: string = '/';\n\n    /** Toggles navigation to folder content or file preview */\n    @Input()\n    navigate: boolean = true;\n\n    /** Toggles the header */\n    @Input()\n    showHeader = ShowHeaderMode.Data;\n\n    /**\n     * User interaction for folder navigation or file preview.\n     * Valid values are \"click\" and \"dblclick\". Default value: \"dblclick\"\n     */\n    @Input()\n    navigationMode: string = DocumentListComponent.DOUBLE_CLICK_NAVIGATION; // click|dblclick\n\n    /** Show document thumbnails rather than icons */\n    @Input()\n    thumbnails: boolean = false;\n\n    /**\n     * Row selection mode. Can be null, `single` or `multiple`. For `multiple` mode,\n     * you can use Cmd (macOS) or Ctrl (Win) modifier key to toggle selection for multiple rows.\n     */\n    @Input()\n    selectionMode: string = 'single'; // null|single|multiple\n\n    /** Toggles multiselect mode */\n    @Input()\n    multiselect: boolean = false;\n\n    /** Toggles content actions for each row */\n    @Input()\n    contentActions: boolean = false;\n\n    /** Position of the content actions dropdown menu. Can be set to \"left\" or \"right\". */\n    @Input()\n    contentActionsPosition: string = 'right'; // left|right\n\n    /** Toggles context menus for each row */\n    @Input()\n    contextMenuActions: boolean = false;\n\n    /** Custom image for empty folder. Default value: './assets/images/empty_doc_lib.svg' */\n    @Input()\n    emptyFolderImageUrl: string = './assets/images/empty_doc_lib.svg';\n\n    /**\n     * When true, this enables you to drop files directly into subfolders shown\n     * as items in the list or into another file to trigger updating it's version.\n     * When false, the dropped file will be added to the\n     * current folder (ie, the one containing all the items shown in the list).\n     * See the Upload directive for further details about how the file drop is\n     * handled.\n     */\n    @Input()\n    allowDropFiles: boolean = false;\n\n    /**\n     * Defines default sorting. The format is an array of 2 strings `[key, direction]`\n     * i.e. `['name', 'desc']` or `['name', 'asc']`. Set this value only if you want to\n     * override the default sorting detected by the component based on columns.\n     */\n    @Input()\n    sorting: string[] | DataSorting = ['name', 'asc'];\n\n    /**\n     * Defines default sorting. The format is an array of strings `[key direction, otherKey otherDirection]`\n     * i.e. `['name desc', 'nodeType asc']` or `['name asc']`. Set this value if you want a base\n     * rule to be added to the sorting apart from the one driven by the header.\n     */\n    @Input()\n    additionalSorting: DataSorting = new DataSorting('isFolder', 'desc');\n\n    /**\n     * Defines sorting mode. Can be either `client` (items in the list\n     * are sorted client-side) or `server` (the ordering supplied by the\n     * server is used without further client-side sorting).\n     * Note that the `server` option *does not* request the server to sort the data\n     * before delivering it.\n     */\n    @Input()\n    sortingMode: 'server' | 'client' = 'server';\n\n    /**\n     * The inline style to apply to every row. See\n     * the Angular NgStyle\n     * docs for more details and usage examples.\n     */\n    @Input()\n    rowStyle: { [key: string]: any };\n\n    /** The CSS class to apply to every row */\n    @Input()\n    rowStyleClass: string;\n\n    /**\n     * Toggles the loading state and animated spinners for the component. Used in\n     * combination with `navigate=false` to perform custom navigation and loading\n     * state indication.\n     */\n    @Input()\n    loading: boolean = false;\n\n    @Input()\n    _rowFilter: RowFilter | null = null;\n\n    /**\n     * Custom function to choose whether to show or hide rows.\n     * See the [Row Filter Model](row-filter.model.md) page for\n     * more information.\n     */\n    @Input()\n    set rowFilter(rowFilter: RowFilter) {\n        this._rowFilter = rowFilter;\n        if (this.data) {\n            this.data.setFilter(this._rowFilter);\n            if (this.currentFolderId) {\n                this.reload();\n            }\n        }\n    }\n\n    get rowFilter(): RowFilter {\n        return this._rowFilter;\n    }\n\n    /**\n     * Custom function to choose image file paths to show. See the\n     * [Image Resolver Model](image-resolver.model.md) page for\n     * more information.\n     */\n    @Input()\n    imageResolver: any | null = null;\n\n    /** Toggles the sticky header mode. */\n    @Input()\n    stickyHeader: boolean = false;\n\n    /** Toggles the header filters mode. */\n    @Input()\n    headerFilters: boolean = false;\n\n    /** Initial value for filter. */\n    @Input()\n    filterValue: any;\n\n    /** The ID of the folder node to display or a reserved string alias for special sources */\n    @Input()\n    currentFolderId: string = null;\n\n    /**\n     * Array of nodes to be pre-selected. All nodes in the\n     * array are pre-selected in multi selection mode, but only the first node\n     * is pre-selected in single selection mode.\n     */\n    @Input()\n    preselectNodes: NodeEntry[] = [];\n\n    /** The Document list will show all the nodes contained in the NodePaging entity */\n    @Input()\n    node: NodePaging = null;\n\n    /** Default value is stored in the user preference settings. Use this only if you are not using pagination. */\n    @Input()\n    maxItems: number = this.DEFAULT_PAGINATION.maxItems;\n\n    /** Key of columns preset set in extension.json  */\n    @Input()\n    columnsPresetKey?: string;\n\n    /** Sets columns visibility for DataTableSchema */\n    @Input()\n    set setColumnsVisibility(columnsVisibility: { [columnId: string]: boolean } | undefined) {\n        this.columnsVisibility = columnsVisibility;\n    }\n\n    /** Sets columns width for DataTableSchema */\n    @Input()\n    set setColumnsWidths(columnsWidths: { [columnId: string]: number } | undefined) {\n        this.columnsWidths = columnsWidths;\n    }\n\n    /** Sets columns order for DataTableSchema */\n    @Input()\n    set setColumnsOrder(columnsOrder: string[] | undefined) {\n        this.columnsOrder = columnsOrder;\n    }\n\n    /** Limit of possible visible columns, including \"$thumbnail\" column if provided */\n    @Input()\n    maxColumnsVisible?: number;\n\n    /** Enables column resizing for datatable */\n    @Input()\n    isResizingEnabled = false;\n\n    /** Enables blur when resizing datatable columns */\n    @Input()\n    blurOnResize = true;\n\n    /** Display checkboxes in datatable rows on hover only */\n    @Input()\n    displayCheckboxesOnHover = false;\n\n    /** Display drag and drop hint. */\n    @Input()\n    displayDragAndDropHint = true;\n\n    /** Emitted when the user clicks a list node */\n    @Output()\n    nodeClick = new EventEmitter<NodeEntityEvent>();\n\n    /** Emitted when the user double-clicks a list node */\n    @Output()\n    nodeDblClick = new EventEmitter<NodeEntityEvent>();\n\n    /** Emitted when the current display folder changes */\n    @Output()\n    folderChange = new EventEmitter<NodeEntryEvent>();\n\n    /**\n     * Emitted when the user acts upon files with either single or double click\n     * (depends on `navigation-mode`). Useful for integration with the\n     * Viewer component.\n     */\n    @Output()\n    preview = new EventEmitter<NodeEntityEvent>();\n\n    /** Emitted when the Document List has loaded all items and is ready for use */\n    @Output()\n    ready = new EventEmitter<NodePaging>();\n\n    /** Emitted when the API fails to get the Document List data */\n    @Output()\n    error = new EventEmitter<any>();\n\n    /** Emitted when the node selection change */\n    @Output()\n    nodeSelected = new EventEmitter<NodeEntry[]>();\n\n    /** Emitted when a filter value is selected */\n    @Output()\n    filterSelection = new EventEmitter<FilterSearch[]>();\n\n    /** Emitted when column widths change */\n    @Output()\n    columnsWidthChanged = new EventEmitter<{ [columnId: string]: number } | undefined>();\n\n    /** Emitted when columns visibility change */\n    @Output()\n    columnsVisibilityChanged = new EventEmitter<{ [columnId: string]: boolean } | undefined>();\n\n    /** Emitted when columns order change */\n    @Output()\n    columnsOrderChanged = new EventEmitter<string[] | undefined>();\n\n    /** Emitted when the selected row items count in the table changed. */\n    @Output()\n    selectedItemsCountChanged = new EventEmitter<number | undefined>();\n\n    @ViewChild('dataTable', { static: true })\n    dataTable: DataTableComponent;\n\n    actions: ContentActionModel[] = [];\n    contextActionHandler: Subject<any> = new Subject();\n    data: ShareDataTableAdapter;\n    noPermission: boolean = false;\n    selection = new Array<NodeEntry>();\n    $folderNode: Subject<Node> = new Subject<Node>();\n    allowFiltering: boolean = true;\n    orderBy: string[] = null;\n    preselectedRows: DataRow[] = [];\n\n    // @deprecated 3.0.0\n    folderNode: Node;\n\n    private _pagination: PaginationModel = this.DEFAULT_PAGINATION;\n    pagination: BehaviorSubject<PaginationModel> = new BehaviorSubject<PaginationModel>(this.DEFAULT_PAGINATION);\n    sortingSubject: BehaviorSubject<DataSorting[]> = new BehaviorSubject<DataSorting[]>(this.DEFAULT_SORTING);\n\n    private rowMenuCache: { [key: string]: ContentActionModel[] } = {};\n    private loadingTimeout: any;\n\n    private readonly destroyRef = inject(DestroyRef);\n\n    private _nodesApi: NodesApi;\n    get nodesApi(): NodesApi {\n        this._nodesApi = this._nodesApi ?? new NodesApi(this.alfrescoApiService.getInstance());\n        return this._nodesApi;\n    }\n\n    constructor(\n        private documentListService: DocumentListService,\n        private elementRef: ElementRef,\n        private appConfig: AppConfigService,\n        private userPreferencesService: UserPreferencesService,\n        private contentService: ContentService,\n        private thumbnailService: ThumbnailService,\n        private alfrescoApiService: AlfrescoApiService,\n        private nodeService: NodesApiService,\n        private dataTableService: DataTableService,\n        private lockService: LockService,\n        private dialog: MatDialog\n    ) {\n        super(appConfig, 'default', presetsDefaultModel);\n        this.nodeService.nodeUpdated.pipe(takeUntilDestroyed()).subscribe((node) => {\n            this.dataTableService.rowUpdate.next({ id: node.id, obj: { entry: node } });\n        });\n\n        this.userPreferencesService\n            .select(UserPreferenceValues.PaginationSize)\n            .pipe(takeUntilDestroyed())\n            .subscribe((pagSize) => {\n                this.maxItems = this._pagination.maxItems = pagSize;\n            });\n    }\n\n    getContextActions(node: NodeEntry) {\n        if (node?.entry) {\n            const actions = this.getNodeActions(node);\n            if (actions && actions.length > 0) {\n                return actions.map((currentAction: ContentActionModel) => ({\n                    model: currentAction,\n                    node,\n                    subject: this.contextActionHandler\n                }));\n            }\n        }\n        return null;\n    }\n\n    private getDefaultSorting(): DataSorting {\n        let defaultSorting: DataSorting;\n        if (Array.isArray(this.sorting)) {\n            const [key, direction] = this.sorting;\n            defaultSorting = new DataSorting(key, direction);\n        } else {\n            defaultSorting = new DataSorting(this.sorting.key, this.sorting.direction);\n        }\n\n        return defaultSorting;\n    }\n\n    isMobile(): boolean {\n        return !!/Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent);\n    }\n\n    isEmpty() {\n        return !this.data || this.data.getRows().length === 0;\n    }\n\n    ngOnInit() {\n        this.rowMenuCache = {};\n        this.loadLayoutPresets();\n        this.data = new ShareDataTableAdapter(\n            this.thumbnailService,\n            this.contentService,\n            null,\n            this.getDefaultSorting(),\n            this.sortingMode,\n            this.allowDropFiles\n        );\n        this.data.thumbnails = this.thumbnails;\n        this.data.permissionsStyle = this.permissionsStyle;\n\n        if (this._rowFilter) {\n            this.data.setFilter(this._rowFilter);\n        }\n\n        if (this.imageResolver) {\n            this.data.setImageResolver(this.imageResolver);\n        }\n\n        this.contextActionHandler.pipe(takeUntilDestroyed(this.destroyRef)).subscribe((val) => this.contextActionCallback(val));\n\n        this.enforceSingleClickNavigationForMobile();\n        if (this.filterValue && Object.keys(this.filterValue).length > 0) {\n            this.showHeader = ShowHeaderMode.Always;\n        }\n        if (this.columnsPresetKey) {\n            this.setPresetKey(this.columnsPresetKey);\n        }\n\n        this.documentListService.reload$.pipe(takeUntilDestroyed(this.destroyRef)).subscribe(() => {\n            this.resetSelection();\n            this.reload();\n        });\n\n        this.documentListService.resetSelection$.pipe(takeUntilDestroyed(this.destroyRef)).subscribe(() => {\n            this.resetSelection();\n        });\n    }\n\n    ngAfterContentInit() {\n        if (this.columnList) {\n            this.columnList.columns.changes.pipe(takeUntilDestroyed(this.destroyRef)).subscribe(() => {\n                this.createColumns();\n                this.data.setColumns(this.columns);\n            });\n        }\n        this.createDatatableSchema();\n        this.data.setColumns(this.columns);\n    }\n\n    ngOnChanges(changes: SimpleChanges) {\n        if (!changes['preselectNodes']) {\n            this.resetSelection();\n        }\n\n        if (Array.isArray(this.sorting)) {\n            const [key, direction] = this.sorting;\n            this.orderBy = this.buildOrderByArray(key, direction);\n        } else {\n            this.orderBy = this.buildOrderByArray(this.sorting.key, this.sorting.direction);\n        }\n\n        if (this.data) {\n            this.data.thumbnails = this.thumbnails;\n        }\n\n        if (changes.sortingMode && !changes.sortingMode.firstChange && this.data) {\n            this.data.sortingMode = changes.sortingMode.currentValue;\n        }\n\n        if (changes.sorting && !changes.sorting.firstChange && this.data) {\n            const newValue = changes.sorting.currentValue;\n            if (newValue && newValue.length > 0) {\n                const [key, direction] = newValue;\n                this.data.setSorting(new DataSorting(key, direction));\n            }\n        }\n\n        if (this.currentFolderId && changes['currentFolderId']?.currentValue !== changes['currentFolderId']?.previousValue) {\n            this.loadFolder();\n        }\n\n        if (this.data) {\n            if (changes.node?.currentValue) {\n                const merge = this._pagination ? this._pagination.merge : false;\n                this.data.loadPage(changes.node.currentValue, merge, null);\n                this.preserveExistingSelection();\n                this.onPreselectNodes();\n                this.onDataReady(changes.node.currentValue);\n            } else if (changes.imageResolver) {\n                this.data.setImageResolver(changes.imageResolver.currentValue);\n            }\n        }\n    }\n\n    reload(hideLoadingSpinner = false) {\n        this.resetSelection();\n        this.reloadWithoutResettingSelection(hideLoadingSpinner);\n    }\n\n    reloadWithoutResettingSelection(hideLoadingSpinner = false) {\n        if (this.node) {\n            if (this.data) {\n                this.data.loadPage(this.node, this._pagination.merge, null);\n                this.preserveExistingSelection();\n            }\n            this.onPreselectNodes();\n            this.syncPagination();\n            this.onDataReady(this.node);\n        } else {\n            this.loadFolder(hideLoadingSpinner);\n        }\n    }\n\n    contextActionCallback(action) {\n        if (action) {\n            this.executeContentAction(action.node, action.model);\n        }\n    }\n\n    getNodeActions(node: NodeEntry | any): ContentActionModel[] {\n        if (node?.entry) {\n            let target = null;\n\n            if (node.entry.isFile) {\n                target = 'document';\n            } else if (node.entry.isFolder) {\n                target = 'folder';\n            }\n\n            if (target) {\n                const actions = this.rowMenuCache[node.entry.id];\n                if (actions) {\n                    actions.forEach((action) => {\n                        this.refreshAction(action, node);\n                    });\n                    return actions;\n                }\n\n                const actionsByTarget = this.actions\n                    .filter((entry) => {\n                        const isVisible = typeof entry.visible === 'function' ? entry.visible(node) : entry.visible;\n\n                        return isVisible && entry.target.toLowerCase() === target;\n                    })\n                    .map((action) => new ContentActionModel(action));\n\n                actionsByTarget.forEach((action) => {\n                    this.refreshAction(action, node);\n                });\n\n                this.rowMenuCache[node.entry.id] = actionsByTarget;\n                return actionsByTarget;\n            }\n        }\n\n        return [];\n    }\n\n    private refreshAction(action: ContentActionModel, node: NodeEntry) {\n        action.disabled = this.isActionDisabled(action, node);\n        action.visible = this.isActionVisible(action, node);\n    }\n\n    private isActionVisible(action: ContentActionModel, node: NodeEntry): boolean {\n        if (typeof action.visible === 'function') {\n            return action.visible(node);\n        }\n\n        return action.visible;\n    }\n\n    private isActionDisabled(action: ContentActionModel, node: NodeEntry): boolean {\n        if (typeof action.disabled === 'function') {\n            return action.disabled(node);\n        }\n\n        if (\n            (action.permission && action.disableWithNoPermission && !this.contentService.hasAllowableOperations(node.entry, action.permission)) ||\n            this.lockService.isLocked(node.entry)\n        ) {\n            return true;\n        } else {\n            return action.disabled;\n        }\n    }\n\n    @HostListener('contextmenu', ['$event'])\n    onShowContextMenu(e?: Event) {\n        if (e && this.contextMenuActions) {\n            e.preventDefault();\n        }\n    }\n\n    navigateTo(node: Node | string): boolean {\n        if (typeof node === 'string') {\n            this.resetNewFolderPagination();\n            this.currentFolderId = node;\n            this.folderChange.emit(new NodeEntryEvent({ id: node } as Node));\n            this.reload();\n            return true;\n        } else {\n            if (this.canNavigateFolder(node)) {\n                this.resetNewFolderPagination();\n                this.currentFolderId = this.getNodeFolderDestinationId(node);\n                this.folderChange.emit(new NodeEntryEvent({ id: this.currentFolderId } as Node));\n                this.reload();\n                return true;\n            }\n        }\n        return false;\n    }\n\n    private getNodeFolderDestinationId(node: Node) {\n        return this.isLinkFolder(node) ? node.properties['cm:destination'] : node.id;\n    }\n\n    private isLinkFolder(node: Node) {\n        return node.nodeType === 'app:folderlink' && node.properties?.['cm:destination'];\n    }\n\n    private updateCustomSourceData(nodeId: string): void {\n        this.currentFolderId = nodeId;\n    }\n\n    /**\n     * Invoked when executing content action for a document or folder.\n     *\n     * @param node Node to be the context of the execution.\n     * @param action Action to be executed against the context.\n     */\n    executeContentAction(node: NodeEntry, action: ContentActionModel) {\n        if (node?.entry && action) {\n            const handlerSub = typeof action.handler === 'function' ? action.handler(node, this, action.permission) : of(true);\n\n            if (typeof action.execute === 'function' && handlerSub) {\n                handlerSub.pipe(takeUntilDestroyed(this.destroyRef)).subscribe(() => action.execute(node));\n            }\n        }\n    }\n\n    private setLoadingState(value: boolean) {\n        if (this.data?.getRows().length > 0) {\n            if (value) {\n                clearTimeout(this.loadingTimeout);\n                this.loadingTimeout = setTimeout(() => {\n                    this.loading = true;\n                }, 1000);\n            } else {\n                clearTimeout(this.loadingTimeout);\n                this.loading = false;\n            }\n        } else {\n            clearTimeout(this.loadingTimeout);\n            this.loading = value;\n        }\n    }\n\n    loadFolder(hideLoadingSpinner = false) {\n        if (!hideLoadingSpinner) {\n            this.setLoadingState(true);\n        }\n\n        if (this.documentListService.isCustomSourceService(this.currentFolderId)) {\n            this.updateCustomSourceData(this.currentFolderId);\n        }\n\n        this.documentListService.loadFolderByNodeId(this.currentFolderId, this._pagination, this.includeFields, this.where, this.orderBy).subscribe(\n            (documentNode: DocumentLoaderNode) => {\n                if (documentNode.currentNode) {\n                    this.folderNode = documentNode.currentNode.entry;\n                    this.$folderNode.next(documentNode.currentNode.entry);\n                }\n                this.onPageLoaded(documentNode.children);\n            },\n            (err) => {\n                this.handleError(err);\n            }\n        );\n    }\n\n    resetSelection() {\n        this.dataTable.resetSelection();\n        this.selection = [];\n        this.noPermission = false;\n    }\n\n    onPageLoaded(nodePaging: NodePaging) {\n        if (nodePaging) {\n            if (this.data) {\n                this.data.loadPage(nodePaging, this._pagination.merge, this.allowDropFiles);\n                this.preserveExistingSelection();\n            }\n            this.onPreselectNodes();\n            this.setLoadingState(false);\n            this.onDataReady(nodePaging);\n        }\n    }\n\n    onSortingChanged(event: CustomEvent) {\n        this.orderBy = this.buildOrderByArray(event.detail.sortingKey, event.detail.direction);\n        this.sorting = [event.detail.sortingKey, event.detail.direction];\n        this.sortingSubject.next([this.additionalSorting, event.detail]);\n\n        if (this.sortingMode === 'server') {\n            this.reload();\n        }\n    }\n\n    private buildOrderByArray(currentKey: string, currentDirection: string): string[] {\n        return [`${this.additionalSorting.key} ${this.additionalSorting.direction}`, `${currentKey} ${currentDirection}`];\n    }\n\n    onPreviewFile(node: NodeEntry) {\n        if (node) {\n            const sizeInMB = node.entry?.content?.sizeInBytes / BYTES_TO_MB_CONVERSION_VALUE;\n            const fileAutoDownloadFlag: boolean = this.appConfig.get('viewer.enableFileAutoDownload', true);\n            const sizeThreshold: number = this.appConfig.get('viewer.fileAutoDownloadSizeThresholdInMB', 15);\n\n            if (fileAutoDownloadFlag && sizeInMB && sizeInMB > sizeThreshold) {\n                this.dialog.open(FileAutoDownloadComponent, { disableClose: true, data: node });\n            } else {\n                this.preview.emit(new NodeEntityEvent(node));\n            }\n        }\n    }\n\n    onColumnsVisibilityChange(columns: DataColumn[]) {\n        this.columnsVisibility = columns.reduce((visibleColumnsMap, column) => {\n            if (column.isHidden !== undefined) {\n                visibleColumnsMap[column.id] = !column.isHidden;\n            }\n\n            return visibleColumnsMap;\n        }, {});\n\n        this.createColumns();\n        this.data.setColumns(this.columns);\n        this.columnsVisibilityChanged.emit(this.columnsVisibility);\n    }\n\n    onColumnOrderChange(columnsWithNewOrder: DataColumn[]) {\n        this.columnsOrder = columnsWithNewOrder.map((column) => column.id);\n        this.createColumns();\n        this.columnsOrderChanged.emit(this.columnsOrder);\n    }\n\n    onColumnsWidthChange(columns: DataColumn[]) {\n        const newColumnsWidths = columns.reduce((widthsColumnsMap, column) => {\n            if (column.width) {\n                widthsColumnsMap[column.id] = Math.ceil(column.width);\n            }\n            return widthsColumnsMap;\n        }, {});\n\n        this.columnsWidths = { ...this.columnsWidths, ...newColumnsWidths };\n        this.createColumns();\n        this.columnsWidthChanged.emit(this.columnsWidths);\n    }\n\n    onSelectedItemsCountChanged(count: number) {\n        this.selectedItemsCountChanged.emit(count);\n    }\n\n    onNodeClick(nodeEntry: NodeEntry) {\n        const domEvent = new CustomEvent('node-click', {\n            detail: {\n                sender: this,\n                node: nodeEntry\n            },\n            bubbles: true\n        });\n\n        this.elementRef.nativeElement.dispatchEvent(domEvent);\n\n        const event = new NodeEntityEvent(nodeEntry);\n        this.nodeClick.emit(event);\n\n        if (!event.defaultPrevented) {\n            if (this.navigate && this.navigationMode === DocumentListComponent.SINGLE_CLICK_NAVIGATION) {\n                this.executeActionClick(nodeEntry);\n            }\n        }\n    }\n\n    onNodeDblClick(nodeEntry: NodeEntry) {\n        const domEvent = new CustomEvent('node-dblclick', {\n            detail: {\n                sender: this,\n                node: nodeEntry\n            },\n            bubbles: true\n        });\n        this.elementRef.nativeElement.dispatchEvent(domEvent);\n\n        const event = new NodeEntityEvent(nodeEntry);\n        this.nodeDblClick.emit(event);\n\n        if (!event.defaultPrevented) {\n            if (this.navigate && this.navigationMode === DocumentListComponent.DOUBLE_CLICK_NAVIGATION) {\n                this.executeActionClick(nodeEntry);\n            }\n        }\n    }\n\n    executeActionClick(nodeEntry: NodeEntry) {\n        if (nodeEntry?.entry) {\n            if (nodeEntry.entry.isFile) {\n                this.onPreviewFile(nodeEntry);\n            }\n\n            if (nodeEntry.entry.isFolder) {\n                this.navigateTo(nodeEntry.entry);\n            }\n\n            if (nodeEntry.entry['guid']) {\n                const options = {\n                    include: this.includeFields\n                };\n\n                this.nodesApi.getNode(nodeEntry.entry['guid'], options).then((node: NodeEntry) => {\n                    this.navigateTo(node.entry);\n                });\n            }\n        }\n    }\n\n    onNodeSelect(event: { row: ShareDataRow; selection: Array<ShareDataRow> }) {\n        this.selection = event.selection.map((entry) => entry.node);\n        const domEvent = new CustomEvent('node-select', {\n            detail: {\n                node: event.row ? event.row.node : null,\n                selection: this.selection\n            },\n            bubbles: true\n        });\n        this.nodeSelected.emit(this.selection);\n        this.elementRef.nativeElement.dispatchEvent(domEvent);\n    }\n\n    onNodeUnselect(event: { row: ShareDataRow; selection: Array<ShareDataRow> }) {\n        this.selection = event.selection.map((entry) => entry.node);\n        const domEvent = new CustomEvent('node-unselect', {\n            detail: {\n                node: event.row ? event.row.node : null,\n                selection: this.selection\n            },\n            bubbles: true\n        });\n        this.nodeSelected.emit(this.selection);\n        this.elementRef.nativeElement.dispatchEvent(domEvent);\n    }\n\n    onShowRowContextMenu(event: DataCellEvent) {\n        if (this.contextMenuActions) {\n            const args = event.value;\n            const node = args.row.node;\n            if (node) {\n                args.actions = this.getContextActions(node) || [];\n            }\n        }\n    }\n\n    onShowRowActionsMenu(event: DataCellEvent) {\n        if (this.contentActions) {\n            const args = event.value;\n            const node = args.row.node;\n            if (node) {\n                args.actions = this.getNodeActions(node) || [];\n            }\n        }\n    }\n\n    onExecuteRowAction(event: DataRowActionEvent) {\n        if (this.contentActions) {\n            const args = event.value;\n            const node = args.row.node;\n            const action = args.action;\n            this.executeContentAction(node, action);\n        }\n    }\n\n    private enforceSingleClickNavigationForMobile(): void {\n        if (this.isMobile()) {\n            this.navigationMode = DocumentListComponent.SINGLE_CLICK_NAVIGATION;\n        }\n    }\n\n    canNavigateFolder(node: Node): boolean {\n        let canNavigateFolder: boolean = false;\n\n        if (node?.isFolder) {\n            canNavigateFolder = true;\n        }\n\n        return canNavigateFolder;\n    }\n\n    private onDataReady(nodePaging: NodePaging) {\n        this.ready.emit(nodePaging);\n        this.pagination.next(nodePaging.list.pagination);\n    }\n\n    updatePagination(requestPaginationModel: RequestPaginationModel) {\n        this._pagination.maxItems = requestPaginationModel.maxItems;\n        this._pagination.skipCount = requestPaginationModel.skipCount;\n        this.reload(requestPaginationModel.merge);\n    }\n\n    private syncPagination() {\n        this.node.list.pagination.maxItems = this._pagination.maxItems;\n        this.node.list.pagination.skipCount = this._pagination.skipCount;\n    }\n\n    onFilterSelectionChange(activeFilters: FilterSearch[]) {\n        this.filterSelection.emit(activeFilters);\n    }\n\n    resetNewFolderPagination() {\n        this._pagination.skipCount = 0;\n        this._pagination.maxItems = this.maxItems;\n    }\n\n    private handleError(err: any) {\n        if (err.message) {\n            try {\n                if (JSON.parse(err.message).error.statusCode === 403) {\n                    this.noPermission = true;\n                }\n            } catch (error) {\n                /* empty */\n            }\n        }\n        this.setLoadingState(false);\n        this.error.emit(err);\n    }\n\n    getPreselectedNodesBasedOnSelectionMode(): NodeEntry[] {\n        return this.hasPreselectedNodes() ? (this.isSingleSelectionMode() ? [this.preselectNodes[0]] : this.preselectNodes) : [];\n    }\n\n    getPreselectedRowsBasedOnSelectionMode(): DataRow[] {\n        return this.hasPreselectedRows() ? (this.isSingleSelectionMode() ? [this.preselectedRows[0]] : this.preselectedRows) : [];\n    }\n\n    getSelectionBasedOnSelectionMode(): DataRow[] {\n        return this.hasPreselectedRows()\n            ? this.isSingleSelectionMode()\n                ? [this.preselectedRows[0]]\n                : this.data.getSelectedRows()\n            : this.data.getSelectedRows();\n    }\n\n    onPreselectNodes() {\n        if (this.hasPreselectedNodes()) {\n            this.preselectRowsOfPreselectedNodes();\n            const preselectedRows = this.getPreselectedRowsBasedOnSelectionMode();\n            const selection = this.data.getSelectedRows() as ShareDataRow[];\n\n            for (const node of preselectedRows) {\n                this.dataTable.selectRow(node, true);\n            }\n            this.onNodeSelect({ row: undefined, selection });\n        }\n    }\n\n    private preserveExistingSelection() {\n        if (this.isMultipleSelectionMode()) {\n            for (const selection of this.selection) {\n                const rowOfSelection = this.data.getRowByNodeId(selection.entry.id);\n                if (rowOfSelection) {\n                    rowOfSelection.isSelected = true;\n                }\n            }\n        }\n    }\n\n    preselectRowsOfPreselectedNodes() {\n        this.preselectedRows = [];\n        const preselectedNodes = this.getPreselectedNodesBasedOnSelectionMode();\n\n        preselectedNodes.forEach((preselectedNode: NodeEntry) => {\n            const rowOfPreselectedNode = this.data.getRowByNodeId(preselectedNode.entry.id);\n            if (rowOfPreselectedNode) {\n                rowOfPreselectedNode.isSelected = true;\n                this.preselectedRows.push(rowOfPreselectedNode);\n            }\n        });\n    }\n\n    unselectRowFromNodeId(nodeId: string) {\n        const rowToUnselect = this.data.getRowByNodeId(nodeId);\n        if (rowToUnselect?.isSelected) {\n            rowToUnselect.isSelected = false;\n            this.dataTable.selectRow(rowToUnselect, false);\n            const selection = this.getSelectionBasedOnSelectionMode() as ShareDataRow[];\n            this.onNodeUnselect({ row: undefined, selection });\n        }\n    }\n\n    private isSingleSelectionMode(): boolean {\n        return this.selectionMode === 'single';\n    }\n\n    private isMultipleSelectionMode(): boolean {\n        return this.selectionMode === 'multiple';\n    }\n\n    private hasPreselectedNodes(): boolean {\n        return this.preselectNodes?.length > 0;\n    }\n\n    private hasPreselectedRows(): boolean {\n        return this.preselectedRows?.length > 0;\n    }\n}\n","<adf-datatable\n    #dataTable\n    [selectionMode]=\"selectionMode\"\n    [data]=\"data\"\n    [actions]=\"contentActions\"\n    [actionsPosition]=\"contentActionsPosition\"\n    [multiselect]=\"multiselect\"\n    [contextMenu]=\"contextMenuActions\"\n    [rowStyle]=\"rowStyle\"\n    [rowStyleClass]=\"rowStyleClass\"\n    [showMainDatatableActions]=\"true\"\n    [loading]=\"loading\"\n    [noPermission]=\"noPermission\"\n    [showHeader]=\"showHeader\"\n    [rowMenuCacheEnabled]=\"false\"\n    [stickyHeader]=\"stickyHeader\"\n    [allowFiltering]=\"allowFiltering\"\n    [isResizingEnabled]=\"isResizingEnabled\"\n    [blurOnResize]=\"blurOnResize\"\n    [displayCheckboxesOnHover]=\"displayCheckboxesOnHover\"\n    (showRowContextMenu)=\"onShowRowContextMenu($event)\"\n    (showRowActionsMenu)=\"onShowRowActionsMenu($event)\"\n    (executeRowAction)=\"onExecuteRowAction($event)\"\n    (columnsWidthChanged)=\"onColumnsWidthChange($event)\"\n    (columnOrderChanged)=\"onColumnOrderChange($event)\"\n    (selectedItemsCountChanged)=\"onSelectedItemsCountChanged($event)\"\n    (rowClick)=\"onNodeClick($event.value?.node)\"\n    (rowDblClick)=\"onNodeDblClick($event.value?.node)\"\n    (row-select)=\"onNodeSelect($any($event).detail)\"\n    (row-unselect)=\"onNodeUnselect($any($event).detail)\"\n    (sorting-changed)=\"onSortingChanged($any($event))\"\n    [class.adf-datatable-gallery-thumbnails]=\"data.thumbnails\">\n\n    <div *ngIf=\"headerFilters\">\n        <adf-filter-header\n            [currentFolderId]=\"currentFolderId\"\n            [value]=\"filterValue\"\n            (filterSelection)=\"onFilterSelectionChange($event)\" />\n    </div>\n\n    <adf-no-content-template>\n        <ng-template>\n            <adf-empty-list *ngIf=\"!customNoContentTemplate\">\n                <div class=\"adf-empty-list_template adf-empty-folder\">\n                    <div class=\"adf-empty-folder-this-space-is-empty\">{{'ADF-DOCUMENT-LIST.EMPTY.HEADER' | translate}}</div>\n                    <ng-container *ngIf=\"displayDragAndDropHint\">\n                        <div class=\"adf-empty-folder-drag-drop\">{{ 'ADF-DATATABLE.EMPTY.DRAG-AND-DROP.TITLE' | translate }}</div>\n                        <div class=\"adf-empty-folder-any-files-here-to-add\">{{ 'ADF-DATATABLE.EMPTY.DRAG-AND-DROP.SUBTITLE' | translate }}</div>\n                    </ng-container>\n                    <img [alt]=\"'ADF-DATATABLE.EMPTY.DRAG-AND-DROP.TITLE' | translate\" class=\"adf-empty-folder-image\" [src]=\"emptyFolderImageUrl\">\n                </div>\n            </adf-empty-list>\n            <ng-content select=\"adf-custom-empty-content-template, empty-folder-content\" />\n        </ng-template>\n    </adf-no-content-template>\n\n    <adf-no-permission-template>\n        <ng-template>\n            <div class=\"adf-no-permission__template\" *ngIf=\"!customNoPermissionsTemplate\">\n                <mat-icon>error</mat-icon>\n                <p class=\"adf-no-permission__template--text\">{{ 'ADF-DOCUMENT-LIST.NO_PERMISSION' | translate }}</p>\n            </div>\n            <ng-content select=\"adf-custom-no-permission-template, no-permission-content\" />\n        </ng-template>\n    </adf-no-permission-template>\n\n    <adf-loading-content-template>\n        <ng-template>\n            <div class=\"adf-document-list-loading-container\" *ngIf=\"!customLoadingContent\">\n                <mat-progress-spinner\n                    id=\"adf-document-list-loading\"\n                    class=\"adf-document-list-loading-margin\"\n                    [attr.aria-label]=\"'ADF-DOCUMENT-LIST.LOADER_LABEL' | translate\"\n                    [color]=\"'primary'\"\n                    [mode]=\"'indeterminate'\" />\n            </div>\n            <ng-content select=\"adf-custom-loading-content-template\" />\n        </ng-template>\n    </adf-loading-content-template>\n\n    <adf-main-menu-datatable-template>\n        <ng-template let-mainMenuTrigger>\n            <adf-datatable-column-selector\n              [columns]=\"columns\"\n              [mainMenuTrigger]=\"mainMenuTrigger\"\n              [columnsSorting]=\"false\"\n              [maxColumnsVisible]=\"maxColumnsVisible\"\n              (submitColumnsVisibility)=\"onColumnsVisibilityChange($event)\" />\n        </ng-template>\n    </adf-main-menu-datatable-template>\n\n</adf-datatable>\n"]}