@cqa-lib/cqa-ui 1.1.525 → 1.1.526

package/esm2020/lib/templates/modular-table-template/modular-table-template.component.mjs

@@ -0,0 +1,1475 @@
+import { Component, Input, Output, EventEmitter, ChangeDetectionStrategy, ViewChild, } from '@angular/core';
+import { DynamicFilterComponent } from '../../filters/dynamic-filter/dynamic-filter.component';
+import { EMPTY_STATE_IMAGES } from '../../assets/images/image-assets.constants';
+import { DEFAULT_MODULAR_CONFIG, DEFAULT_MODULAR_LABELS, DEFAULT_REORDER_LABELS, } from './modular-table-template.models';
+import { MoveToFolderDialogComponent } from './dialogs/move-to-folder-dialog.component';
+import { NewFolderDialogComponent } from './dialogs/new-folder-dialog.component';
+import { DeleteFolderDialogComponent } from './dialogs/delete-folder-dialog.component';
+import * as i0 from "@angular/core";
+import * as i1 from "../../dialog/dialog.service";
+import * as i2 from "../../search-bar/search-bar.component";
+import * as i3 from "../../button/button.component";
+import * as i4 from "../../export-code-modal/export-code-modal.component";
+import * as i5 from "../../column-visibility/column-visibility.component";
+import * as i6 from "../../segment-control/segment-control.component";
+import * as i7 from "../../selected-filters/selected-filters.component";
+import * as i8 from "../../filters/dynamic-filter/dynamic-filter.component";
+import * as i9 from "./folder-sidebar/folder-sidebar.component";
+import * as i10 from "@angular/material/icon";
+import * as i11 from "../../table/dynamic-table/dynamic-table.component";
+import * as i12 from "../../empty-state/empty-state.component";
+import * as i13 from "../../pagination/pagination.component";
+import * as i14 from "../../table-action-toolbar/table-action-toolbar.component";
+import * as i15 from "@angular/common";
+import * as i16 from "./directives/folder-drop.directive";
+export class ModularTableTemplateComponent {
+    constructor(cdr, dialogService) {
+        this.cdr = cdr;
+        this.dialogService = dialogService;
+        // Search bar inputs
+        this.searchPlaceholder = 'Search components';
+        this.searchValue = '';
+        this.showClear = true;
+        this.showSearchBar = true;
+        this.showExportButton = false;
+        this.isExporting = false;
+        // Search bar outputs
+        this.onSearchChange = new EventEmitter();
+        this.onExportClick = new EventEmitter();
+        // Filter outputs
+        this.onApplyFilterClick = new EventEmitter();
+        this.onResetFilterClick = new EventEmitter();
+        this.onClearAll = new EventEmitter();
+        this.removeChip = new EventEmitter();
+        // Filter inputs
+        this.filterConfig = [];
+        this.filterModel = {};
+        this.showFilterPanel = false;
+        this.showFilterButton = true;
+        // Other buttons input (array of button templates/components)
+        this.otherButtons = [];
+        // Other dropdown buttons input (array of dropdown button templates/components)
+        this.otherDropDownButtons = [];
+        // Other select dropdown buttons input (array of select dropdown button templates/components)
+        this.otherSelectDropDownButtons = [];
+        // Legacy single button inputs (deprecated, kept for backward compatibility)
+        /** @deprecated Use otherButtons array instead */
+        this.otherButtonLabel = 'Other Button';
+        /** @deprecated Use otherButtons array instead */
+        this.otherButtonVariant = 'filled';
+        /** @deprecated Use otherButtons array instead */
+        this.showOtherButton = true;
+        // Action menu button (three-dot menu in table rows)
+        this.showActionButton = true;
+        // Settings and refresh buttons
+        this.showSettingsButton = true;
+        this.showAutoRefreshButton = true;
+        // View-mode toggle (List | Modular). Hidden by default for backward compatibility.
+        this.showViewModeToggle = false;
+        this.viewMode = 'list';
+        this.viewModeLabels = { list: 'List', modular: 'Modular' };
+        this.viewModeChange = new EventEmitter();
+        // Data input
+        this.data = [];
+        // Empty state inputs
+        this.isEmptyState = false;
+        this.emptyStateConfig = {
+            title: 'No Data Available Yet',
+            description: 'Run or upload your first test to see your analytics and trends here. Watch your quality metrics come to life with real-time insights.',
+            imageUrl: EMPTY_STATE_IMAGES.DASHBOARD,
+            actions: [{ label: 'Run Test Suite', variant: 'filled' }],
+        };
+        // Action bar inputs
+        this.actions = [
+            {
+                id: 'delete',
+                label: 'Delete',
+                icon: 'delete',
+                tooltip: 'Delete selected',
+                onClick: (context) => {
+                    console.log('Delete action clicked:', context);
+                }
+            },
+            {
+                id: 'edit',
+                label: 'Edit',
+                icon: 'edit',
+                tooltip: 'Edit selected',
+                onClick: (context) => {
+                    console.log('Edit action clicked:', context);
+                }
+            },
+            {
+                id: 'add-tag',
+                label: 'Add Tag',
+                icon: 'local_offer',
+                tooltip: 'Add tags',
+                onClick: (context) => {
+                    console.log('Add tag action clicked:', context);
+                }
+            },
+            {
+                id: 'remove-tag',
+                label: 'Remove Tag',
+                icon: 'label_off',
+                tooltip: 'Remove tags',
+                onClick: (context) => {
+                    console.log('Remove tag action clicked:', context);
+                }
+            },
+        ];
+        // Chips inputs
+        this.chips = [];
+        this.filterApplied = false;
+        // Table inputs
+        this.columns = [];
+        this.selectedAutoRefreshInterval = 0;
+        this.pageIndex = 0;
+        this.pageSize = 10;
+        this.pageSizeOptions = [10, 20, 40, 60, 80];
+        this.pageSizeMenuDirection = 'auto';
+        // Server-side pagination controls
+        this.serverSidePagination = false;
+        this.totalElements = 0;
+        this.pageChange = new EventEmitter();
+        /**
+         * When false, header sort does not reorder rows locally (use with serverSidePagination + sortChange).
+         * Default true for backward compatibility.
+         */
+        this.enableLocalSort = true;
+        this.sortChange = new EventEmitter();
+        // Selected items (full objects) for maintaining selection across pagination (server-side)
+        this.selectedItems = [];
+        /**
+         * When true, the action toolbar renders the "Select all" affordance. Defaults to false
+         * for now — host opts in. Matches the current product requirement to hide Select All.
+         */
+        this.showSelectAllInToolbar = false;
+        /**
+         * When true, the action toolbar renders the dismiss (×) affordance. Defaults to false
+         * for now — host opts in. Matches the current product requirement to hide Cancel.
+         */
+        this.showDismissInToolbar = false;
+        /** Bound to the toolbar's "Select all" checkbox — drives the checked state. */
+        this.allSelectedInToolbar = false;
+        // Internal state for column visibility
+        this._columnVisibility = {};
+        this._cachedVisibilityColumns = [];
+        this.filteredRows = [];
+        this.pagedRows = [];
+        // ============================================================================
+        // Folder / modular inputs
+        // ============================================================================
+        this.folders = [];
+        this.selectedFolderId = null;
+        this.expandedFolderIds = [];
+        this.unorganisedCount = 0;
+        this.folderIdAccessor = (row) => row?.folderId ?? null;
+        this.modularConfig = { ...DEFAULT_MODULAR_CONFIG };
+        this.modularLabels = { ...DEFAULT_MODULAR_LABELS };
+        this.bulkActions = [];
+        this.sidebarCollapsed = false;
+        /**
+         * When true (default), the library opens its own Move dialog for convenience
+         * during testing. Hosts taking over API + UX should set this to `false` and
+         * listen on `moveRequested` to render their own.
+         */
+        this.useInternalDialogs = true;
+        // ============================================================================
+        // Folder / modular outputs
+        // ============================================================================
+        this.folderSelected = new EventEmitter();
+        this.folderExpansionToggled = new EventEmitter();
+        this.folderCreated = new EventEmitter();
+        /** Emitted when the user clicks "+ New folder"; host should open a creation modal. */
+        this.folderCreateRequested = new EventEmitter();
+        this.folderRenamed = new EventEmitter();
+        /**
+         * Fires after the user confirms folder deletion via the internal dialog (or
+         * immediately, when `useInternalDialogs` is false and the host drives the UX).
+         * Payload now includes the user's chosen `strategy` for what happens to the
+         * folder's test cases.
+         */
+        this.folderDeleted = new EventEmitter();
+        this.testsMoved = new EventEmitter();
+        // ---------------------------------------------------------------------------
+        // Bulk action toolbar surface — naming mirrors cqa-table-template so consumers
+        // get the same events from either component (plus the folder events below).
+        // ---------------------------------------------------------------------------
+        /** Fires on raw toolbar action click — *before* any internal dialog opens. */
+        this.bulkActionClick = new EventEmitter();
+        /** Fires when the toolbar's "Select all" is toggled. */
+        this.bulkSelectAllChange = new EventEmitter();
+        /** Fires when the toolbar's dismiss (×) is clicked. */
+        this.bulkDismiss = new EventEmitter();
+        /**
+         * Fires *after* the library-internal move-to-folder dialog resolves with a
+         * user confirmation, OR immediately for non-dialog bulk actions supplied by
+         * the host. Hosts with their own UX should listen on `bulkActionClick` +
+         * `moveRequested` and treat this as the "confirmed" signal.
+         */
+        this.bulkActionInvoked = new EventEmitter();
+        this.sidebarCollapsedChange = new EventEmitter();
+        // ============================================================================
+        // Row-reorder surface
+        // ============================================================================
+        /** When true, renders a "Reorder" button in the toolbar. Host-driven. */
+        this.showReorderButton = false;
+        /**
+         * Host flips this true while its bulk-update API call is in-flight. The
+         * component keeps the reorder UI pinned ("Saving...") while true and exits
+         * reorder mode when it flips back to false (the "future API call" hook).
+         */
+        this.reorderSaving = false;
+        this._reorderLabels = { ...DEFAULT_REORDER_LABELS };
+        /** Fires when the user clicks "Reorder" and the component enters reorder mode. */
+        this.reorderStart = new EventEmitter();
+        /** Fires when the user clicks "Cancel" — the original order is already restored. */
+        this.reorderCancel = new EventEmitter();
+        /**
+         * Fires when the user clicks "Done". Host should take `orderedItems`, call its
+         * bulk-update API, refresh `[data]`, and flip `reorderSaving` back to `false` —
+         * the component will then exit reorder mode.
+         *
+         * Note: for server-side pagination, `orderedItems` is the *current page slice*,
+         * not the full dataset — same as the in-memory view the user was dragging.
+         */
+        this.reorderSave = new EventEmitter();
+        /** Internal — true while the user is in reorder mode. */
+        this.isReordering = false;
+        /** Snapshot of `pagedRows` taken on enter; used to revert on cancel. */
+        this.reorderSnapshot = null;
+        /** Draft of the reordered rows (current working state). */
+        this.reorderDraft = null;
+        /** Auto-refresh interval captured on enter, so we can restore on cancel/done. */
+        this.reorderSavedAutoRefresh = 0;
+        /** True after Done has been clicked, awaiting the host's `reorderSaving` → false flip. */
+        this.reorderAwaitingSaveFlip = false;
+        /**
+         * Fires when the user clicks the "Move to folder" bulk action — *before* the
+         * internal dialog opens. Hosts that want to render their own modal should
+         * set `useInternalDialogs = false` and listen here.
+         */
+        this.moveRequested = new EventEmitter();
+        /** Fires whenever the component's `selectedItems` changes from within (Select All / Dismiss). */
+        this.selectedItemsChange = new EventEmitter();
+        /**
+         * Fires when the user clicks a folder's delete affordance — *before* the
+         * internal confirmation dialog opens. Hosts owning the UX listen here.
+         * Payload includes `testCount` + `hasParent` so hosts can render the right
+         * options in their own modal.
+         */
+        this.folderDeleteRequested = new EventEmitter();
+        /**
+         * Fires when the user picks "Move folder" from a folder row's context menu —
+         * *before* any dialog opens. Hosts owning the UX listen here with
+         * `useInternalDialogs = false` and open their own folder picker.
+         */
+        this.folderMoveRequested = new EventEmitter();
+        /**
+         * Fires after the user confirms a folder move via the internal picker
+         * (or immediately when `useInternalDialogs = false` and the host drives it).
+         */
+        this.folderMoved = new EventEmitter();
+        /**
+         * Fires when the user picks "Duplicate folder" from a folder row's context menu.
+         * The library doesn't own persistence, so the host is expected to clone the
+         * folder's subtree server-side and *reference* (not copy) the test cases.
+         */
+        this.folderDuplicateRequested = new EventEmitter();
+        this.onReload = new EventEmitter();
+        this.onAutoRefreshClick = new EventEmitter();
+        this.columnVisibilityChange = new EventEmitter();
+        this.autoRefreshIntervalChange = new EventEmitter();
+        // Derived columns with visibility applied.
+        this.computedColumns = [];
+        // Auto-generated visibility columns from columns input
+        this.visibilityColumns = [];
+        // Export modal state
+        this.isExportModalOpen = false;
+        /**
+         * Row-drag payload builder used by the [cqaRowDrag] directive via (buildPayload).
+         */
+        this.buildRowDragPayload = (row) => {
+            const selected = this.currentSelectedItems;
+            // If the dragged row is part of the current selection, drag the whole selection.
+            const rowId = row?.id;
+            const inSelection = rowId != null && selected.some(s => s?.id === rowId);
+            const ids = (inSelection ? selected : [row]).map(r => r?.id).filter(v => v != null);
+            return ids;
+        };
+    }
+    get viewModeSegments() {
+        return [
+            { label: this.viewModeLabels.list, value: 'list', icon: 'view_list' },
+            { label: this.viewModeLabels.modular, value: 'modular', icon: 'folder' },
+        ];
+    }
+    onViewModeChange(value) {
+        const next = value === 'modular' ? 'modular' : 'list';
+        if (next !== this.viewMode) {
+            this.viewMode = next;
+            this.viewModeChange.emit(next);
+        }
+    }
+    /** Partial override for the default reorder labels ("Reorder", "Done", etc.). */
+    set reorderLabels(partial) {
+        this._reorderLabels = { ...DEFAULT_REORDER_LABELS, ...(partial || {}) };
+    }
+    get reorderLabels() {
+        return this._reorderLabels;
+    }
+    updateComputedColumns() {
+        const visibility = this._columnVisibility || {};
+        const source = this.columns || [];
+        this.computedColumns = source.map(col => {
+            if (['checkbox', 'actions'].includes(col.fieldId)) {
+                return col;
+            }
+            const show = visibility[col.fieldId];
+            return { ...col, isShow: show !== false };
+        });
+        this.cdr.markForCheck();
+    }
+    updateVisibilityColumns() {
+        this._cachedVisibilityColumns = this.mapVisibilityColumns();
+        this.visibilityColumns = this._cachedVisibilityColumns;
+        this.cdr.markForCheck();
+    }
+    // Controlled column visibility: parent can seed and push updates.
+    set columnVisibility(cfg) {
+        if (cfg) {
+            this._columnVisibility = { ...cfg };
+            this.updateComputedColumns();
+            this.cdr.markForCheck();
+        }
+    }
+    get columnVisibility() {
+        return this._columnVisibility;
+    }
+    ngOnInit() {
+        this.initializeComponent();
+        this.updateComputedColumns();
+        this.updateVisibilityColumns();
+    }
+    ngOnChanges(changes) {
+        if (changes['data'] || changes['isEmptyState']) {
+            this.initializeComponent();
+        }
+        if (changes['columns']) {
+            this.initializeColumnVisibility();
+            this.updateComputedColumns();
+            this.updateVisibilityColumns();
+        }
+        if (changes['selectedFolderId'] && !changes['selectedFolderId'].firstChange) {
+            // Per the approved plan: clear selection and reset pagination on folder change.
+            this.selectedItems = [];
+            this.pageIndex = 0;
+            this.rebuildFilteredRows();
+            this.applyPagination();
+        }
+        if (changes['viewMode'] && !changes['viewMode'].firstChange) {
+            // Switching between list and modular changes whether the folder filter applies.
+            this.pageIndex = 0;
+            this.rebuildFilteredRows();
+            this.applyPagination();
+        }
+        if (changes['selectedItems'] || changes['data']) {
+            this.restoreSelectionState();
+        }
+        if (changes['reorderSaving'] && !changes['reorderSaving'].firstChange) {
+            const nowSaving = !!changes['reorderSaving'].currentValue;
+            // Host finished its bulk-update call — exit reorder mode.
+            if (!nowSaving && this.reorderAwaitingSaveFlip) {
+                this.exitReorderMode();
+            }
+        }
+    }
+    initializeComponent() {
+        if (this.isEmptyState) {
+            this.filteredRows = [];
+            this.pagedRows = [];
+            return;
+        }
+        // In server-side mode, assume incoming data is already a page slice
+        if (this.serverSidePagination) {
+            this.filteredRows = [...this.data];
+            this.pagedRows = [...this.filteredRows];
+            this.initializeColumnVisibility();
+            this.restoreSelectionState();
+            return;
+        }
+        this.rebuildFilteredRows();
+        this.applyPagination();
+        this.initializeColumnVisibility();
+        this.updateComputedColumns();
+        this.restoreSelectionState();
+    }
+    /**
+     * Build `filteredRows` from `data` by applying (a) the field filters (status/priority/etc.)
+     * and (b) the folder filter derived from `selectedFolderId` + `folderIdAccessor`.
+     */
+    rebuildFilteredRows() {
+        const effective = this.appliedFilters ?? {};
+        this.filteredRows = this.data.filter(r => this.passFilters(effective, r) && this.passFolder(r));
+    }
+    passFolder(row) {
+        // List view ignores folder filtering entirely — behaves like the traditional flat table.
+        if (!this.isModularView)
+            return true;
+        const folderId = this.folderIdAccessor ? this.folderIdAccessor(row) : row?.folderId;
+        // Root view: show only rows that do not belong to any folder (the "Unorganised" bucket).
+        // Folder tiles above the table are the entry point to per-folder contents.
+        if (this.selectedFolderId == null) {
+            return folderId == null;
+        }
+        return folderId != null && String(folderId) === String(this.selectedFolderId);
+    }
+    /** True when the component should render the modular (folder-aware) UI. */
+    get isModularView() {
+        return this.viewMode === 'modular';
+    }
+    /**
+     * Get selected IDs from selectedItems (objects)
+     */
+    getSelectedIds() {
+        if (this.selectedItems && this.selectedItems.length > 0) {
+            return new Set(this.selectedItems.map(item => Number(item.id)).filter(id => !isNaN(id)));
+        }
+        return new Set();
+    }
+    restoreSelectionState() {
+        const selectedIdsSet = this.getSelectedIds();
+        if (selectedIdsSet.size === 0) {
+            // If no selected IDs, clear all selection states
+            if (this.pagedRows) {
+                this.pagedRows.forEach(row => {
+                    if (row) {
+                        row.isSelected = false;
+                    }
+                });
+            }
+            return;
+        }
+        // Restore selection state based on selectedItems
+        if (this.pagedRows) {
+            this.pagedRows.forEach(row => {
+                if (row && row.id !== undefined) {
+                    row.isSelected = selectedIdsSet.has(Number(row.id));
+                }
+            });
+        }
+        // Also update filteredRows for consistency
+        if (this.filteredRows) {
+            this.filteredRows.forEach(row => {
+                if (row && row.id !== undefined) {
+                    row.isSelected = selectedIdsSet.has(Number(row.id));
+                }
+            });
+        }
+        this.cdr.markForCheck();
+    }
+    initializeColumnVisibility() {
+        // Cache visibility columns to avoid creating new arrays on every change detection
+        this._cachedVisibilityColumns = this.mapVisibilityColumns();
+        // Seed visibility state from each column's isShow (default to true) so consumers
+        // can pre-apply persisted preferences via columns[i].isShow.
+        const source = this.columns || [];
+        for (const col of this._cachedVisibilityColumns) {
+            if (this._columnVisibility[col.id] === undefined) {
+                const srcCol = source.find(c => c.fieldId === col.id);
+                this._columnVisibility[col.id] = srcCol && srcCol.isShow === false ? false : true;
+            }
+        }
+    }
+    get anyRowSelected() {
+        // Check if there are any selected items (either on current page or across all pages via selectedItems)
+        const hasSelectedOnPage = !!(this.pagedRows && this.pagedRows.some(r => !!r.isSelected));
+        const selectedIdsSet = this.getSelectedIds();
+        const hasSelectedAcrossPages = selectedIdsSet.size > 0;
+        return hasSelectedOnPage || hasSelectedAcrossPages;
+    }
+    get currentSelectedItems() {
+        // If selectedItems (full objects) are provided, use them directly
+        // This ensures all selected items are returned, including those from other pages
+        if (this.selectedItems && this.selectedItems.length > 0) {
+            return this.selectedItems;
+        }
+        // Fallback: For client-side pagination or when selectedItems is not provided,
+        // filter pagedRows to get selected items from current page only
+        if (!this.pagedRows || this.pagedRows.length === 0) {
+            return [];
+        }
+        const selectedIdsSet = this.getSelectedIds();
+        // Filter rows that are selected
+        return this.pagedRows
+            .filter(r => {
+            if (!r || r.id === undefined)
+                return false;
+            const rowId = Number(r.id);
+            // Include if either:
+            // 1. The row has isSelected = true (current page selection)
+            // 2. The row's ID is in selectedItems (selected on other pages or restored selection)
+            return !!r.isSelected || selectedIdsSet.has(rowId);
+        });
+    }
+    actionClick(data) {
+        console.log('action toolbar', data);
+    }
+    view(id) {
+        console.log('View', id);
+    }
+    edit(row) {
+        console.log('Edit', row);
+    }
+    delete(row) {
+        console.log('Delete', row);
+    }
+    toggleFilter() {
+        this.showFilterPanel = !this.showFilterPanel;
+    }
+    onColumnVisibilityChange(cfg) {
+        this._columnVisibility = { ...cfg };
+        this.updateComputedColumns();
+        this.cdr.markForCheck();
+        this.columnVisibilityChange.emit({ ...cfg });
+    }
+    onAutoRefreshChange(intervalMs) {
+        this.selectedAutoRefreshInterval = intervalMs;
+        this.setupAutoRefresh(intervalMs);
+        this.autoRefreshIntervalChange.emit(intervalMs);
+        this.triggerReload();
+    }
+    valueChange(value) {
+        console.log('Value changed', value);
+        this.onSearchChange.emit(value);
+    }
+    search(value) {
+        console.log('Search', value);
+    }
+    cleared() {
+        console.log('Cleared');
+    }
+    onEmptyAction(action) {
+        if (action?.label === 'Show filters') {
+            this.toggleFilter();
+        }
+    }
+    onFiltersChanged(current) {
+        // Defer applying filters and updating chips until Apply Filter is clicked
+        this.pendingFilters = current;
+    }
+    onFiltersApplied(applied) {
+        this.showFilterPanel = false;
+        const effective = applied ?? this.pendingFilters ?? {};
+        this.appliedFilters = effective;
+        this.rebuildFilteredRows();
+        this.pageIndex = 0;
+        this.applyPagination();
+        const chips = [];
+        if (effective) {
+            for (const key of Object.keys(effective)) {
+                const value = effective[key];
+                if (value == null || value === '' || (Array.isArray(value) && value.length === 0))
+                    continue;
+                // Find the filter config item for this key
+                const filterConfigItem = this.filterConfig?.find(c => c.key === key);
+                const options = filterConfigItem?.options || [];
+                // Helper function to find display text from options
+                const getDisplayText = (val) => {
+                    // If value is already an object with name/label, use it
+                    if (val && typeof val === 'object' && (val.name || val.label || val.value)) {
+                        return val.name ?? val.label ?? String(val.value ?? val);
+                    }
+                    // Look up the option in the config
+                    const option = options.find((opt) => {
+                        const optId = opt.id ?? opt.value;
+                        const optValue = opt.value;
+                        const valStr = String(val);
+                        return String(optId) === valStr || String(optValue) === valStr;
+                    });
+                    if (option) {
+                        return option.name ?? option.label ?? String(option.value ?? val);
+                    }
+                    // Fallback to the raw value
+                    return String(val);
+                };
+                let text = '';
+                let label = filterConfigItem?.label;
+                if (Array.isArray(value)) {
+                    text = value.map((v) => getDisplayText(v)).join(', ');
+                }
+                else if (typeof value === 'object') {
+                    if ('start' in value || 'end' in value) {
+                        const s = value.start ? new Date(value.start).toLocaleDateString() : '';
+                        const e = value.end ? new Date(value.end).toLocaleDateString() : '';
+                        text = [s, e].filter(Boolean).join(' - ');
+                    }
+                    else {
+                        text = getDisplayText(value);
+                    }
+                }
+                else {
+                    text = getDisplayText(value);
+                }
+                chips.push({ key, label, text, fullText: text, hasMore: text.length > 30 });
+            }
+        }
+        this.chips = chips;
+        this.filterApplied = this.chips.length > 0;
+    }
+    handleResetFilterClick() {
+        // Clear chips and reset filtered data when reset is clicked
+        this.pendingFilters = undefined;
+        this.appliedFilters = undefined;
+        this.chips = [];
+        this.filterApplied = false;
+        this.rebuildFilteredRows();
+        this.pageIndex = 0;
+        this.applyPagination();
+        this.onResetFilterClick.emit();
+    }
+    handleRefreshClick() {
+        this.onAutoRefreshClick.emit();
+        this.triggerReload();
+    }
+    triggerReload() {
+        this.rebuildFilteredRows();
+        this.pageIndex = 0;
+        this.applyPagination();
+        this.onReload.emit();
+    }
+    setupAutoRefresh(intervalMs) {
+        this.clearAutoRefresh();
+        if (intervalMs && intervalMs > 0) {
+            this.autoRefreshTimer = setInterval(() => {
+                this.triggerReload();
+            }, intervalMs);
+        }
+    }
+    clearAutoRefresh() {
+        if (this.autoRefreshTimer) {
+            clearInterval(this.autoRefreshTimer);
+            this.autoRefreshTimer = undefined;
+        }
+    }
+    ngOnDestroy() {
+        this.clearAutoRefresh();
+    }
+    onPaginate(e) {
+        this.pageIndex = e.pageIndex;
+        this.pageSize = e.pageSize;
+        if (this.serverSidePagination) {
+            this.pageChange.emit({ pageIndex: this.pageIndex, pageSize: this.pageSize });
+            return;
+        }
+        this.applyPagination();
+    }
+    onPageSizeChange(size) {
+        this.pageSize = size;
+        this.pageIndex = 0;
+        if (this.serverSidePagination) {
+            this.pageChange.emit({ pageIndex: this.pageIndex, pageSize: this.pageSize });
+            return;
+        }
+        this.applyPagination();
+    }
+    onRemoveChip(chip) {
+        this.chips = this.chips.filter(c => c !== chip);
+        this.filterApplied = this.chips.length > 0;
+        // Emit event to parent component (same pattern as execution tab)
+        this.removeChip.emit(chip);
+    }
+    onClearAllChips() {
+        this.chips = [];
+        this.filterApplied = false;
+        // Reset the dynamic-filter component form when clearing all chips
+        if (this.dynamicFilterComponent) {
+            this.dynamicFilterComponent.reset();
+        }
+    }
+    applyPagination() {
+        if (this.serverSidePagination) {
+            // Server mode: parent supplies already-paginated data
+            this.pagedRows = [...this.filteredRows];
+            return;
+        }
+        const start = this.pageIndex * this.pageSize;
+        const end = start + this.pageSize;
+        this.pagedRows = this.filteredRows.slice(start, end);
+    }
+    mapVisibilityColumns() {
+        return (this.columns || [])
+            .filter(c => c.isDefault === false)
+            .map(c => ({ id: c.fieldId, label: c.fieldName || c.fieldId }));
+    }
+    normalizeDate(d) {
+        if (!d)
+            return null;
+        const ts = Date.parse(d);
+        return isNaN(ts) ? null : ts;
+    }
+    passFilters(filters, row) {
+        if (!filters)
+            return true;
+        if (filters.status && Array.isArray(filters.status) && filters.status.length) {
+            if (!filters.status.includes(row.status))
+                return false;
+        }
+        if (filters.priority && Array.isArray(filters.priority) && filters.priority.length) {
+            if (!filters.priority.includes(row.priorityName))
+                return false;
+        }
+        if (filters.testType && Array.isArray(filters.testType) && filters.testType.length) {
+            if (!filters.testType.includes(row.testType))
+                return false;
+        }
+        if (filters.created_date && (filters.created_date.start || filters.created_date.end)) {
+            const startTs = this.normalizeDate(filters.created_date.start);
+            const endTs = this.normalizeDate(filters.created_date.end);
+            const rowTs = this.normalizeDate(row.createdAt);
+            if (rowTs != null) {
+                if (startTs != null && rowTs < startTs)
+                    return false;
+                if (endTs != null && rowTs > endTs)
+                    return false;
+            }
+        }
+        return true;
+    }
+    trackByTemplateRef(index) {
+        return index;
+    }
+    trackByDropdownTemplateRef(index) {
+        return index;
+    }
+    trackBySelectDropdownTemplateRef(index) {
+        return index;
+    }
+    exportCodeClick() {
+        // Get selected items
+        const selectedItems = this.currentSelectedItems;
+        if (selectedItems.length === 0) {
+            // Emit event to parent to handle the case when no items are selected
+            this.onExportClick.emit();
+            return;
+        }
+        this.isExportModalOpen = true;
+    }
+    closeExportModal() {
+        this.isExportModalOpen = false;
+    }
+    onExportModalExport(result) {
+        this.isExportModalOpen = false;
+        // Emit event to parent with export result
+        this.onExportClick.emit({
+            type: result.type,
+            emails: result.emails,
+            framework: result.framework,
+            selectedItems: this.currentSelectedItems
+        });
+    }
+    get selectedCasesForExport() {
+        return this.currentSelectedItems.map(item => ({
+            id: item.id,
+            name: item.name || item.title || 'Unnamed'
+        }));
+    }
+    get arrowClasses() {
+        const baseClasses = [
+            'cqa-w-4',
+            'cqa-h-4',
+            'cqa-relative',
+            'cqa-transition-transform'
+        ];
+        if (this.showFilterPanel) {
+            baseClasses.push('cqa-rotate-180');
+        }
+        return baseClasses.join(' ');
+    }
+    // ============================================================================
+    // Folder / modular helpers
+    // ============================================================================
+    /**
+     * Flat list of root-level folders for the "Organised" grid on the root view.
+     */
+    get rootFolderTiles() {
+        return this.folders || [];
+    }
+    /**
+     * Subfolders of the currently-selected folder (for the "Subfolders in ..." grid).
+     */
+    get subfolderTiles() {
+        if (this.selectedFolderId == null)
+            return [];
+        const node = this.findFolder(this.folders, this.selectedFolderId);
+        return node?.children ?? [];
+    }
+    /**
+     * Breadcrumb trail from "All folders" down to the currently-selected folder.
+     */
+    get breadcrumbTrail() {
+        if (this.selectedFolderId == null)
+            return [];
+        const trail = [];
+        this.buildTrail(this.folders, this.selectedFolderId, trail);
+        return trail;
+    }
+    buildTrail(nodes, targetId, acc) {
+        for (const n of nodes || []) {
+            acc.push(n);
+            // Use String() coercion for safety in case ids arrive as either number or
+            // string from different API/test data shapes (e.g. raw JSON parse results).
+            if (String(n.id) === String(targetId))
+                return true;
+            if (n.children && this.buildTrail(n.children, targetId, acc))
+                return true;
+            acc.pop();
+        }
+        return false;
+    }
+    findFolder(nodes, targetId) {
+        for (const n of nodes || []) {
+            if (String(n.id) === String(targetId))
+                return n;
+            const found = n.children ? this.findFolder(n.children, targetId) : null;
+            if (found)
+                return found;
+        }
+        return null;
+    }
+    /**
+     * Whether the component is in "root" view (no folder selected). Controls which
+     * sections render on the right-hand pane.
+     */
+    get isRootView() {
+        return this.selectedFolderId == null;
+    }
+    /** The currently-selected folder node (or null at root). */
+    get currentFolderNode() {
+        if (this.selectedFolderId == null)
+            return null;
+        return this.findFolder(this.folders, this.selectedFolderId);
+    }
+    /** Count of test cases directly under the currently-selected folder (excluding descendants). */
+    get currentFolderDirectCount() {
+        if (this.selectedFolderId == null)
+            return 0;
+        return this.filteredRows.length;
+    }
+    /**
+     * Renders the empty-state slot when the host explicitly opts in, OR when the
+     * table would otherwise render blank (no loading + no rows). Using a derived
+     * flag keeps the host contract identical to `cqa-table-template` while letting
+     * the modular view show "No Test Case Found" out of the box — the earlier ask.
+     */
+    get effectiveIsEmptyState() {
+        if (this.isEmptyState)
+            return true;
+        if (this.isTableLoading || this.isTableDataLoading)
+            return false;
+        return !this.pagedRows || this.pagedRows.length === 0;
+    }
+    /**
+     * Picks the host-provided `emptyStateConfig` when the host flagged the state
+     * itself; otherwise falls back to a library-owned "No Test Case Found" config
+     * driven by `modularLabels`.
+     */
+    get effectiveEmptyStateConfig() {
+        if (this.isEmptyState)
+            return this.emptyStateConfig;
+        return {
+            title: this.modularLabels.emptyNoTestsInFolderTitle,
+            description: this.modularLabels.emptyNoTestsInFolderDescription,
+            imageUrl: EMPTY_STATE_IMAGES.TEST_CASE,
+            actions: [],
+        };
+    }
+    onFolderSelected(id) {
+        this.selectedFolderId = id;
+        this.selectedItems = [];
+        this.pageIndex = 0;
+        this.rebuildFilteredRows();
+        this.applyPagination();
+        this.folderSelected.emit(id);
+        this.cdr.markForCheck();
+    }
+    onFolderExpansionToggled(event) {
+        const set = new Set(this.expandedFolderIds || []);
+        if (event.expanded) {
+            set.add(event.id);
+        }
+        else {
+            set.delete(event.id);
+        }
+        this.expandedFolderIds = Array.from(set);
+        this.folderExpansionToggled.emit(event);
+    }
+    onFolderCreated(payload) {
+        this.folderCreated.emit(payload);
+    }
+    onFolderCreateRequested(payload) {
+        // Emit the "requested" event first so a host can intercept when it owns the UX.
+        this.folderCreateRequested.emit(payload);
+        if (!this.useInternalDialogs)
+            return;
+        this.openCreateFolderDialog(payload.parentId);
+    }
+    onFolderRenamed(payload) {
+        this.folderRenamed.emit(payload);
+    }
+    /**
+     * Wired to the sidebar's `folderDeleted` output — which fires on delete-icon
+     * *click*, not on confirmation. We re-emit a `folderDeleteRequested` event
+     * first (so hosts can intercept) and, when `useInternalDialogs` is enabled,
+     * open the confirmation dialog. `folderDeleted` now only fires after confirm.
+     */
+    onFolderDeleted(payload) {
+        const ctx = this.buildDeleteContext(payload.id);
+        this.folderDeleteRequested.emit(ctx);
+        if (!this.useInternalDialogs)
+            return;
+        this.openDeleteFolderDialog(ctx);
+    }
+    /** Builds the { id, name, testCount, hasParent } payload used by delete events/dialogs. */
+    buildDeleteContext(folderId) {
+        const node = this.findFolder(this.folders, folderId);
+        return {
+            id: folderId,
+            name: node?.name ?? '',
+            testCount: this.countTestsInFolder(folderId),
+            hasParent: this.folderHasParent(folderId),
+        };
+    }
+    countTestsInFolder(folderId) {
+        const accessor = this.folderIdAccessor ?? ((r) => r?.folderId);
+        return (this.data || []).filter(r => {
+            const id = accessor(r);
+            return id != null && Number(id) === Number(folderId);
+        }).length;
+    }
+    /** Returns true when the folder is nested (i.e. not a root-level folder). */
+    folderHasParent(folderId) {
+        return !(this.folders || []).some(n => n.id === folderId);
+    }
+    onTestsDropped(event) {
+        if (!this.modularConfig.allowTestDragDrop)
+            return;
+        this.testsMoved.emit(event);
+    }
+    /**
+     * Folder-to-folder drag-drop. The sidebar has already validated against self/descendant
+     * cycles, so the drop is its own confirmation — we emit `folderMoved` directly without
+     * opening the move dialog. Gated on `allowTestDragDrop` (same flag as test drag-drop).
+     */
+    onFolderDropped(event) {
+        if (!this.modularConfig.allowTestDragDrop)
+            return;
+        this.folderMoved.emit(event);
+    }
+    /**
+     * Sidebar emitted `folderMoveRequested` (user picked "Move folder" from the context menu).
+     * We re-emit a richer payload for hosts, and — when running with internal dialogs —
+     * open the existing move-to-folder picker configured for a folder-move (self and
+     * descendants are disabled to prevent cycles).
+     */
+    onFolderMoveRequested(payload) {
+        const node = this.findFolder(this.folders, payload.id);
+        const ctx = {
+            id: payload.id,
+            name: node?.name ?? '',
+            hasParent: this.folderHasParent(payload.id),
+        };
+        this.folderMoveRequested.emit(ctx);
+        if (!this.useInternalDialogs)
+            return;
+        this.openMoveFolderDialog(ctx);
+    }
+    /**
+     * Sidebar emitted `folderDuplicateRequested`. The library can't persist —
+     * emit the host-level event so the host clones the subtree server-side.
+     * Test cases should be *referenced* from the new folders, not duplicated.
+     */
+    onFolderDuplicateRequested(payload) {
+        const node = this.findFolder(this.folders, payload.id);
+        this.folderDuplicateRequested.emit({
+            id: payload.id,
+            name: node?.name ?? '',
+        });
+    }
+    onSidebarCollapsedChange(collapsed) {
+        this.sidebarCollapsed = collapsed;
+        this.sidebarCollapsedChange.emit(collapsed);
+    }
+    toggleSidebar() {
+        this.onSidebarCollapsedChange(!this.sidebarCollapsed);
+    }
+    /**
+     * Default bulk actions shown in the toolbar merged with any host-supplied
+     * `bulkActions`. Currently only "Move to folder" ships by default —
+     * Delete / Add Tag are opt-in per the current product requirement. Hosts
+     * that want them back pass them via `bulkActions`.
+     */
+    get effectiveBulkActions() {
+        const defaults = [
+            { id: 'move', label: this.modularLabels.moveToFolder, icon: 'drive_file_move', tooltip: this.modularLabels.moveToFolder },
+        ];
+        const overrides = new Map((this.bulkActions || []).map(a => [a.id, a]));
+        const merged = defaults.map(d => overrides.get(d.id) ?? d);
+        for (const extra of this.bulkActions || []) {
+            if (!defaults.some(d => d.id === extra.id)) {
+                merged.push(extra);
+            }
+        }
+        return merged;
+    }
+    onBulkAction(event) {
+        // Always emit the raw click so hosts owning the UX can intercept early.
+        this.bulkActionClick.emit({ id: event.id, selected: event.selected });
+        const selectedIds = (event.selected || []).map(r => r?.id).filter(v => v != null);
+        if (event.id === 'move') {
+            this.openMoveDialog(selectedIds, event.selected);
+            return;
+        }
+        // For non-dialog actions (custom entries from host-supplied `bulkActions`), invoke immediately.
+        this.bulkActionInvoked.emit({ id: event.id, selected: event.selected });
+    }
+    onBulkSelectAll(checked) {
+        // Apply the action locally so the action toolbar's "Select all" works out-of-the-box.
+        // When checked, select every row in the *current* filtered set (i.e. all tests in
+        // the selected folder). When unchecked, clear selection.
+        this.selectedItems = checked ? [...this.filteredRows] : [];
+        this.restoreSelectionState();
+        this.selectedItemsChange.emit([...this.selectedItems]);
+        this.bulkSelectAllChange.emit(checked);
+        this.cdr.markForCheck();
+    }
+    onBulkDismiss() {
+        // Clear selection AND the per-row isSelected flags so the action toolbar closes
+        // (it's gated on `anyRowSelected`, which reads both selectedItems and row flags).
+        this.selectedItems = [];
+        this.restoreSelectionState();
+        this.selectedItemsChange.emit([]);
+        this.bulkDismiss.emit();
+        this.cdr.markForCheck();
+    }
+    openMoveDialog(testIds, selected) {
+        // Fire the "requested" event first so a host can intercept when it owns the UX.
+        this.moveRequested.emit({
+            testIds,
+            selected,
+            currentFolderId: this.selectedFolderId,
+            folders: this.folders,
+        });
+        if (!this.useInternalDialogs)
+            return;
+        const count = testIds.length;
+        const description = (count === 1
+            ? this.modularLabels.moveDialogDescriptionSingular
+            : this.modularLabels.moveDialogDescriptionPlural).replace('{n}', '' + count);
+        const ref = this.dialogService.open({
+            title: this.modularLabels.moveDialogTitle,
+            description,
+            width: '500px',
+            content: {
+                type: 'component',
+                component: MoveToFolderDialogComponent,
+                inputs: {
+                    folders: this.folders,
+                    labels: this.modularLabels,
+                    currentFolderId: this.selectedFolderId,
+                },
+            },
+            buttons: [
+                { label: this.modularLabels.moveDialogCancel, role: 'secondary', handler: r => r.close(undefined) },
+                {
+                    label: this.modularLabels.moveDialogConfirm,
+                    role: 'primary',
+                    handler: r => {
+                        const instance = r.getComponentInstance();
+                        r.close(instance ? instance.pickedFolderId : null);
+                    },
+                },
+            ],
+            buttonAlignment: 'right',
+        });
+        ref.afterClosed().subscribe(targetFolderId => {
+            if (targetFolderId === undefined)
+                return; // cancelled
+            this.testsMoved.emit({ testIds, targetFolderId: targetFolderId ?? null });
+            this.bulkActionInvoked.emit({ id: 'move', selected });
+        });
+    }
+    /**
+     * Opens the folder-picker dialog configured for moving a folder (rather than tests).
+     * The source folder itself is marked as the "current" folder so it's rendered as
+     * disabled in the picker. On confirm, emits `folderMoved` with the chosen parent.
+     */
+    openMoveFolderDialog(ctx) {
+        const ref = this.dialogService.open({
+            title: this.modularLabels.folderMenuMove,
+            width: '500px',
+            content: {
+                type: 'component',
+                component: MoveToFolderDialogComponent,
+                inputs: {
+                    folders: this.folders,
+                    labels: this.modularLabels,
+                    // Reuse the "disabled" treatment: the folder being moved can't be its own destination.
+                    currentFolderId: ctx.id,
+                },
+            },
+            buttons: [
+                { label: this.modularLabels.moveDialogCancel, role: 'secondary', handler: r => r.close(undefined) },
+                {
+                    label: this.modularLabels.moveDialogConfirm,
+                    role: 'primary',
+                    handler: r => {
+                        const instance = r.getComponentInstance();
+                        r.close(instance ? instance.pickedFolderId : null);
+                    },
+                },
+            ],
+            buttonAlignment: 'right',
+        });
+        ref.afterClosed().subscribe(targetFolderId => {
+            if (targetFolderId === undefined)
+                return; // cancelled
+            this.folderMoved.emit({ id: ctx.id, newParentId: targetFolderId ?? null });
+        });
+    }
+    openCreateFolderDialog(initialParentId) {
+        const ref = this.dialogService.open({
+            title: this.modularLabels.newFolderDialogTitle,
+            description: this.modularLabels.newFolderDialogDescription,
+            width: '500px',
+            content: {
+                type: 'component',
+                component: NewFolderDialogComponent,
+                inputs: {
+                    folders: this.folders,
+                    labels: this.modularLabels,
+                    name: '',
+                    parentId: initialParentId,
+                },
+            },
+            buttons: [
+                { label: this.modularLabels.newFolderDialogCancel, role: 'secondary', handler: r => r.close(false) },
+                {
+                    label: this.modularLabels.newFolderDialogConfirm,
+                    role: 'primary',
+                    handler: r => {
+                        const inst = r.getComponentInstance();
+                        if (!inst || !inst.isValid)
+                            return false; // keep the dialog open on invalid submit
+                        r.close({ name: (inst.name || '').trim(), parentId: inst.parentId, color: inst.color });
+                        return;
+                    },
+                },
+            ],
+            buttonAlignment: 'right',
+        });
+        ref.afterClosed().subscribe(result => {
+            if (result) {
+                this.folderCreated.emit({ parentId: result.parentId, name: result.name, color: result.color });
+            }
+        });
+    }
+    openDeleteFolderDialog(ctx) {
+        const ref = this.dialogService.open({
+            title: this.modularLabels.deleteFolderDialogTitle,
+            width: '500px',
+            content: {
+                type: 'component',
+                component: DeleteFolderDialogComponent,
+                inputs: {
+                    folderName: ctx.name,
+                    testCount: ctx.testCount,
+                    hasParent: ctx.hasParent,
+                    labels: this.modularLabels,
+                    strategy: ctx.hasParent ? 'move-to-parent' : 'move-to-unorganised',
+                },
+            },
+            buttons: [
+                { label: this.modularLabels.deleteFolderDialogCancel, role: 'secondary', handler: r => r.close(false) },
+                {
+                    label: this.modularLabels.deleteFolderDialogConfirm,
+                    role: 'warn',
+                    handler: r => {
+                        const inst = r.getComponentInstance();
+                        r.close(inst ? { strategy: inst.strategy } : false);
+                    },
+                },
+            ],
+            buttonAlignment: 'right',
+        });
+        ref.afterClosed().subscribe(result => {
+            if (result) {
+                this.folderDeleted.emit({ id: ctx.id, strategy: result.strategy });
+            }
+        });
+    }
+    // ============================================================================
+    // Row-reorder handlers
+    // ============================================================================
+    startReorder() {
+        if (this.isReordering)
+            return;
+        this.reorderSnapshot = [...(this.pagedRows || [])];
+        this.reorderDraft = [...(this.pagedRows || [])];
+        // Pause auto-refresh while reordering — avoids the timer clobbering the draft.
+        this.reorderSavedAutoRefresh = this.selectedAutoRefreshInterval;
+        if (this.reorderSavedAutoRefresh > 0) {
+            this.setupAutoRefresh(0);
+        }
+        this.isReordering = true;
+        this.reorderAwaitingSaveFlip = false;
+        this.reorderStart.emit();
+        this.cdr.markForCheck();
+    }
+    cancelReorder() {
+        if (!this.isReordering)
+            return;
+        // Restore the original page order so the user sees the pre-drag state.
+        if (this.reorderSnapshot) {
+            this.pagedRows = [...this.reorderSnapshot];
+        }
+        this.exitReorderMode();
+        this.reorderCancel.emit();
+    }
+    saveReorder() {
+        if (!this.isReordering)
+            return;
+        const ordered = this.reorderDraft ? [...this.reorderDraft] : [...(this.pagedRows || [])];
+        this.reorderAwaitingSaveFlip = true;
+        this.reorderSave.emit({ orderedItems: ordered });
+        // If the host never flips `reorderSaving` (e.g. synchronous no-op), exit
+        // immediately so the UI doesn't get stuck in "Saving..." state.
+        if (!this.reorderSaving) {
+            // Give the host a microtask to flip `reorderSaving` to true — if it
+            // hasn't, assume no async work and exit.
+            Promise.resolve().then(() => {
+                if (this.reorderAwaitingSaveFlip && !this.reorderSaving) {
+                    this.exitReorderMode();
+                }
+            });
+        }
+    }
+    onRowReorder(event) {
+        if (!this.isReordering)
+            return;
+        this.reorderDraft = [...event.orderedData];
+        this.pagedRows = this.reorderDraft;
+        this.cdr.markForCheck();
+    }
+    exitReorderMode() {
+        this.isReordering = false;
+        this.reorderSnapshot = null;
+        this.reorderDraft = null;
+        this.reorderAwaitingSaveFlip = false;
+        // Restore previously-selected auto-refresh interval (if any).
+        if (this.reorderSavedAutoRefresh > 0) {
+            this.setupAutoRefresh(this.reorderSavedAutoRefresh);
+            this.reorderSavedAutoRefresh = 0;
+        }
+        this.cdr.markForCheck();
+    }
+}
+ModularTableTemplateComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: ModularTableTemplateComponent, deps: [{ token: i0.ChangeDetectorRef }, { token: i1.DialogService }], target: i0.ɵɵFactoryTarget.Component });
+ModularTableTemplateComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.4.0", type: ModularTableTemplateComponent, selector: "cqa-modular-table-template", inputs: { searchPlaceholder: "searchPlaceholder", searchValue: "searchValue", showClear: "showClear", showSearchBar: "showSearchBar", showExportButton: "showExportButton", isExporting: "isExporting", filterConfig: "filterConfig", filterModel: "filterModel", showFilterPanel: "showFilterPanel", showFilterButton: "showFilterButton", otherButtons: "otherButtons", otherDropDownButtons: "otherDropDownButtons", otherSelectDropDownButtons: "otherSelectDropDownButtons", otherButtonLabel: "otherButtonLabel", otherButtonVariant: "otherButtonVariant", showOtherButton: "showOtherButton", showActionButton: "showActionButton", showSettingsButton: "showSettingsButton", showAutoRefreshButton: "showAutoRefreshButton", showViewModeToggle: "showViewModeToggle", viewMode: "viewMode", viewModeLabels: "viewModeLabels", data: "data", isEmptyState: "isEmptyState", emptyStateConfig: "emptyStateConfig", actions: "actions", chips: "chips", filterApplied: "filterApplied", columns: "columns", rowSelectable: "rowSelectable", selectedAutoRefreshInterval: "selectedAutoRefreshInterval", pageIndex: "pageIndex", pageSize: "pageSize", pageSizeOptions: "pageSizeOptions", pageSizeMenuDirection: "pageSizeMenuDirection", serverSidePagination: "serverSidePagination", totalElements: "totalElements", enableLocalSort: "enableLocalSort", isTableLoading: "isTableLoading", isTableDataLoading: "isTableDataLoading", cellJsonPathGetter: "cellJsonPathGetter", onJsonPathCopiedHandler: "onJsonPathCopiedHandler", selectedItems: "selectedItems", showSelectAllInToolbar: "showSelectAllInToolbar", showDismissInToolbar: "showDismissInToolbar", allSelectedInToolbar: "allSelectedInToolbar", folders: "folders", selectedFolderId: "selectedFolderId", expandedFolderIds: "expandedFolderIds", unorganisedCount: "unorganisedCount", folderIdAccessor: "folderIdAccessor", modularConfig: "modularConfig", modularLabels: "modularLabels", bulkActions: "bulkActions", sidebarCollapsed: "sidebarCollapsed", useInternalDialogs: "useInternalDialogs", showReorderButton: "showReorderButton", reorderSaving: "reorderSaving", reorderLabels: "reorderLabels", columnVisibility: "columnVisibility" }, outputs: { onSearchChange: "onSearchChange", onExportClick: "onExportClick", onApplyFilterClick: "onApplyFilterClick", onResetFilterClick: "onResetFilterClick", onClearAll: "onClearAll", removeChip: "removeChip", viewModeChange: "viewModeChange", pageChange: "pageChange", sortChange: "sortChange", folderSelected: "folderSelected", folderExpansionToggled: "folderExpansionToggled", folderCreated: "folderCreated", folderCreateRequested: "folderCreateRequested", folderRenamed: "folderRenamed", folderDeleted: "folderDeleted", testsMoved: "testsMoved", bulkActionClick: "bulkActionClick", bulkSelectAllChange: "bulkSelectAllChange", bulkDismiss: "bulkDismiss", bulkActionInvoked: "bulkActionInvoked", sidebarCollapsedChange: "sidebarCollapsedChange", reorderStart: "reorderStart", reorderCancel: "reorderCancel", reorderSave: "reorderSave", moveRequested: "moveRequested", selectedItemsChange: "selectedItemsChange", folderDeleteRequested: "folderDeleteRequested", folderMoveRequested: "folderMoveRequested", folderMoved: "folderMoved", folderDuplicateRequested: "folderDuplicateRequested", onReload: "onReload", onAutoRefreshClick: "onAutoRefreshClick", columnVisibilityChange: "columnVisibilityChange", autoRefreshIntervalChange: "autoRefreshIntervalChange" }, host: { classAttribute: "cqa-ui-root" }, viewQueries: [{ propertyName: "dynamicFilterComponent", first: true, predicate: DynamicFilterComponent, descendants: true }], usesOnChanges: true, ngImport: i0, template: "<!-- Reusable folder-icon chip. Render via <ng-container *ngTemplateOutlet=\"folderIconChip\"></ng-container>. -->\n<ng-template #folderIconChip>\n  <span class=\"cqa-inline-flex cqa-items-center cqa-justify-center cqa-w-10 cqa-h-10 cqa-rounded-[10px] cqa-bg-neutral-100 cqa-shrink-0\">\n    <svg width=\"17\" height=\"15\" viewBox=\"0 0 17 15\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\" aria-hidden=\"true\">\n      <path d=\"M15.6375 12.6377C15.6375 13.0355 15.4794 13.4171 15.1981 13.6984C14.9168 13.9797 14.5353 14.1377 14.1375 14.1377H2.13745C1.73963 14.1377 1.3581 13.9797 1.07679 13.6984C0.795486 13.4171 0.637451 13.0355 0.637451 12.6377V2.1377C0.637451 1.73987 0.795486 1.35834 1.07679 1.07704C1.3581 0.795731 1.73963 0.637695 2.13745 0.637695H5.88745L7.38745 2.8877H14.1375C14.5353 2.8877 14.9168 3.04573 15.1981 3.32704C15.4794 3.60834 15.6375 3.98987 15.6375 4.3877V12.6377Z\" stroke=\"#6D6D74\" stroke-width=\"1.275\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\n    </svg>\n  </span>\n</ng-template>\n\n<!-- Reusable \"+\" chip used by the \"New folder\" tile. -->\n<ng-template #addIconChip>\n  <span class=\"cqa-inline-flex cqa-items-center cqa-justify-center cqa-w-10 cqa-h-10 cqa-rounded-[10px] cqa-bg-neutral-100 cqa-shrink-0\">\n    <svg width=\"16\" height=\"16\" viewBox=\"0 0 16 16\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\" aria-hidden=\"true\">\n      <path d=\"M8 3V13M3 8H13\" stroke=\"#6D6D74\" stroke-width=\"1.275\" stroke-linecap=\"round\"/>\n    </svg>\n  </span>\n</ng-template>\n\n<div class=\"cqa-ui-root\">\n  <div class=\"cqa-w-full cqa-flex cqa-flex-col cqa-relative\">\n    <div [class]=\"!showSearchBar ? 'cqa-justify-end' : 'cqa-justify-between'\" class=\"cqa-w-full cqa-flex cqa-items-center cqa-gap-3 cqa-flex-wrap cqa-mb-3\">\n      <cqa-search-bar\n        *ngIf=\"showSearchBar\"\n        [placeholder]=\"searchPlaceholder\"\n        [value]=\"searchValue\"\n        [showClear]=\"showClear\"\n        (valueChange)=\"valueChange($event)\"\n        (search)=\"search($event)\"\n        (cleared)=\"cleared()\"\n      ></cqa-search-bar>\n      <div class=\"cqa-flex cqa-items-center cqa-gap-2 cqa-flex-wrap\">\n        <cqa-button\n        *ngIf=\"showExportButton\"\n        variant=\"grey-solid\"\n        icon=\"open_in_new\"\n        [text]=\"isExporting ? 'Exporting...' : 'Export'\"\n        [disabled]=\"isExporting\"\n        (clicked)=\"exportCodeClick()\"\n      >\n        <span>{{ isExporting ? 'Exporting...' : 'Export' }}</span>\n      </cqa-button>\n      \n      <!-- Export Code Modal -->\n      <cqa-export-code-modal\n        *ngIf=\"showExportButton\"\n        [isOpen]=\"isExportModalOpen\"\n        [cases]=\"selectedCasesForExport\"\n        [disabled]=\"false\"\n        (closeModal)=\"closeExportModal()\"\n        (export)=\"onExportModalExport($event)\">\n      </cqa-export-code-modal>\n         <ng-container *ngFor=\"let dropdownTemplate of otherDropDownButtons; trackBy: trackByDropdownTemplateRef\">\n          <ng-container *ngTemplateOutlet=\"dropdownTemplate\"></ng-container>\n        </ng-container>\n\n        <ng-container *ngFor=\"let selectDropdownTemplate of otherSelectDropDownButtons; trackBy: trackBySelectDropdownTemplateRef\">\n          <ng-container *ngTemplateOutlet=\"selectDropdownTemplate\"></ng-container>\n        </ng-container>\n        \n        <cqa-button\n          *ngIf=\"showFilterButton\"\n          variant=\"grey-solid\"\n          icon=\"add\"\n          [disabled]=\"isReordering\"\n          (clicked)=\"toggleFilter()\"\n        >\n        <span class=\"cqa-flex cqa-items-center cqa-gap-1\">\n          Filter          \n           <div [class]=\"arrowClasses\">\n            <svg\n              class=\"cqa-w-2 cqa-h-1 cqa-absolute cqa-left-[4px] cqa-top-[6px]\"\n              viewBox=\"0 0 8 4\"\n              fill=\"none\"\n              xmlns=\"http://www.w3.org/2000/svg\"\n            >\n              <path\n                d=\"M0 0L4 4L8 0\"\n                stroke=\"#0B0B0C\"\n                stroke-width=\"1.33\"\n                stroke-linecap=\"round\"\n                stroke-linejoin=\"round\"\n              />\n            </svg>\n          </div>\n        </span>\n        </cqa-button>\n        <cqa-column-visibility\n          *ngIf=\"showSettingsButton\"\n          [columns]=\"visibilityColumns\"\n          [columnVisibility]=\"columnVisibility\"\n          [selectedAutoRefreshInterval]=\"selectedAutoRefreshInterval\"\n          (columnVisibilityChange)=\"onColumnVisibilityChange($event)\"\n          (autoRefreshChange)=\"onAutoRefreshChange($event)\"\n        ></cqa-column-visibility>\n        <cqa-button\n          *ngIf=\"showAutoRefreshButton\"\n          variant=\"grey-solid\"\n          icon=\"refresh\"\n          (clicked)=\"handleRefreshClick()\"\n          [tooltip]=\"'Refresh'\"\n          tooltipPosition=\"below\"\n          [disabled]=\"isReordering\"\n        ></cqa-button>\n        <ng-container *ngFor=\"let buttonTemplate of otherButtons; trackBy: trackByTemplateRef\">\n          <ng-container *ngTemplateOutlet=\"buttonTemplate\"></ng-container>\n        </ng-container>\n        <cqa-segment-control\n          *ngIf=\"showViewModeToggle\"\n          size=\"lg\"\n          [segments]=\"viewModeSegments\"\n          [value]=\"viewMode\"\n          (valueChange)=\"onViewModeChange($event)\"\n        ></cqa-segment-control>\n        <cqa-button\n          *ngIf=\"showReorderButton && !isReordering\"\n          variant=\"outlined\"\n          icon=\"drag_indicator\"\n          [text]=\"reorderLabels.reorderButton\"\n          [disabled]=\"!pagedRows || pagedRows.length === 0 || isTableLoading || isTableDataLoading\"\n          (clicked)=\"startReorder()\"\n        ></cqa-button>\n        <ng-container *ngIf=\"showReorderButton && isReordering\">\n          <cqa-button\n            variant=\"outlined\"\n            [text]=\"reorderLabels.cancelButton\"\n            [disabled]=\"reorderSaving\"\n            (clicked)=\"cancelReorder()\"\n          ></cqa-button>\n          <cqa-button\n            variant=\"filled\"\n            [icon]=\"reorderSaving ? 'hourglass_empty' : ''\"\n            [text]=\"reorderSaving ? reorderLabels.savingButton : reorderLabels.doneButton\"\n            [disabled]=\"reorderSaving\"\n            (clicked)=\"saveReorder()\"\n          ></cqa-button>\n        </ng-container>\n      </div>\n    </div>\n\n    <!-- Reorder mode banner -->\n    <div *ngIf=\"isReordering\" class=\"cqa-flex cqa-items-center cqa-gap-2 cqa-mb-3 cqa-px-3 cqa-py-2 cqa-rounded-md cqa-bg-[#FFFBEB] cqa-border cqa-border-[#FDE68A]\">\n      <svg width=\"16\" height=\"16\" viewBox=\"0 0 16 16\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\" aria-hidden=\"true\">\n        <circle cx=\"3\" cy=\"3\" r=\"1.5\" fill=\"#92400E\"></circle>\n        <circle cx=\"8\" cy=\"3\" r=\"1.5\" fill=\"#92400E\"></circle>\n        <circle cx=\"13\" cy=\"3\" r=\"1.5\" fill=\"#92400E\"></circle>\n        <circle cx=\"3\" cy=\"8\" r=\"1.5\" fill=\"#92400E\"></circle>\n        <circle cx=\"8\" cy=\"8\" r=\"1.5\" fill=\"#92400E\"></circle>\n        <circle cx=\"13\" cy=\"8\" r=\"1.5\" fill=\"#92400E\"></circle>\n        <circle cx=\"3\" cy=\"13\" r=\"1.5\" fill=\"#92400E\"></circle>\n        <circle cx=\"8\" cy=\"13\" r=\"1.5\" fill=\"#92400E\"></circle>\n        <circle cx=\"13\" cy=\"13\" r=\"1.5\" fill=\"#92400E\"></circle>\n      </svg>\n      <span class=\"cqa-text-sm cqa-font-semibold cqa-text-[#92400E]\">{{ reorderLabels.bannerTitle }}</span>\n      <span class=\"cqa-text-sm cqa-text-[#92400E]\">{{ reorderLabels.bannerDescription }}</span>\n    </div>\n\n    <cqa-selected-filters\n      [filterApplied]=\"filterApplied\"\n      [chips]=\"chips\"\n      (removeChip)=\"onRemoveChip($event)\"\n      (clearAll)=\"onClearAllChips()\"\n      (onClearAll)=\"onClearAll.emit()\"\n    >\n    </cqa-selected-filters>\n\n    <cqa-dynamic-filter\n      *ngIf=\"showFilterPanel\"\n      [config]=\"filterConfig\"\n      [model]=\"filterModel\"\n      [showFilterPanel]=\"showFilterPanel\"\n      (filtersChanged)=\"onFiltersChanged($event)\"\n      (filtersApplied)=\"onFiltersApplied($event)\"\n      (onApplyFilterClick)=\"onApplyFilterClick.emit($event)\"\n      (onResetFilterClick)=\"handleResetFilterClick()\"\n    >\n    </cqa-dynamic-filter>\n\n    <div class=\"cqa-flex cqa-items-stretch cqa-gap-3 cqa-min-h-0\">\n      <!-- Sidebar (only shown in modular view) -->\n      <cqa-folder-sidebar\n        *ngIf=\"isModularView && modularConfig.showSidebar\"\n        [folders]=\"folders\"\n        [selectedFolderId]=\"selectedFolderId\"\n        [expandedFolderIds]=\"expandedFolderIds\"\n        [unorganisedCount]=\"unorganisedCount\"\n        [allowCreate]=\"modularConfig.allowCreateFolder\"\n        [allowRename]=\"modularConfig.allowRenameFolder\"\n        [allowDelete]=\"modularConfig.allowDeleteFolder\"\n        [allowDrop]=\"modularConfig.allowTestDragDrop\"\n        [showCounts]=\"modularConfig.showCounts\"\n        [collapsed]=\"sidebarCollapsed\"\n        [labels]=\"modularLabels\"\n        (folderSelected)=\"onFolderSelected($event)\"\n        (folderExpansionToggled)=\"onFolderExpansionToggled($event)\"\n        (folderCreated)=\"onFolderCreated($event)\"\n        (folderCreateRequested)=\"onFolderCreateRequested($event)\"\n        (folderRenamed)=\"onFolderRenamed($event)\"\n        (folderDeleted)=\"onFolderDeleted($event)\"\n        (folderMoveRequested)=\"onFolderMoveRequested($event)\"\n        (folderDuplicateRequested)=\"onFolderDuplicateRequested($event)\"\n        (testsDropped)=\"onTestsDropped($event)\"\n        (folderDropped)=\"onFolderDropped($event)\"\n        (collapsedChange)=\"onSidebarCollapsedChange($event)\"\n      ></cqa-folder-sidebar>\n\n      <!-- Right pane -->\n      <div class=\"cqa-flex-1 cqa-flex cqa-flex-col cqa-min-w-0\">\n        <!-- Breadcrumb (modular view, folder drilled-in) -->\n        <nav\n          *ngIf=\"isModularView && modularConfig.showBreadcrumb && !isRootView\"\n          aria-label=\"Folder path\"\n          class=\"cqa-flex cqa-items-center cqa-gap-1 cqa-text-sm cqa-text-neutral-600 cqa-mb-3\"\n        >\n          <button type=\"button\" class=\"hover:cqa-text-indigo-600\" (click)=\"onFolderSelected(null)\">\n            <mat-icon class=\"cqa-align-middle\" style=\"font-size:16px;width:16px;height:16px\">folder_open</mat-icon>\n            <span class=\"cqa-align-middle cqa-ml-1\">{{ modularLabels.allFolders }}</span>\n          </button>\n          <ng-container *ngFor=\"let crumb of breadcrumbTrail; let last = last\">\n            <span class=\"cqa-text-neutral-400\">/</span>\n            <button\n              type=\"button\"\n              class=\"hover:cqa-text-indigo-600\"\n              [class.cqa-text-neutral-900]=\"last\"\n              [class.cqa-font-semibold]=\"last\"\n              [disabled]=\"last\"\n              (click)=\"!last && onFolderSelected(crumb.id)\"\n            >{{ crumb.name }}</button>\n          </ng-container>\n        </nav>\n\n        <!-- Folder grid: modular + root view -->\n        <section\n          *ngIf=\"isModularView && isRootView && modularConfig.showFolderGrid && rootFolderTiles.length\"\n          class=\"cqa-mb-4\"\n        >\n          <div class=\"cqa-flex cqa-items-center cqa-gap-2 cqa-mb-2\">\n            <mat-icon class=\"cqa-text-neutral-600\" style=\"font-size:16px;width:16px;height:16px\">folder</mat-icon>\n            <h3 class=\"cqa-text-sm cqa-font-semibold cqa-text-neutral-800\">{{ modularLabels.organised }}</h3>\n            <span class=\"cqa-text-xs cqa-text-neutral-500\">\n              {{ rootFolderTiles.length === 1 ? modularLabels.foldersCountSingular : modularLabels.foldersCountPlural.replace('{n}', '' + rootFolderTiles.length) }}\n            </span>\n          </div>\n          <div class=\"cqa-flex cqa-flex-nowrap cqa-gap-3 cqa-overflow-x-auto cqa-scrollbar-thin cqa-pb-2\">\n            <button\n              *ngFor=\"let f of rootFolderTiles\"\n              type=\"button\"\n              [cqaFolderDrop]=\"f.id\"\n              [dropEnabled]=\"modularConfig.allowTestDragDrop\"\n              (testsDropped)=\"onTestsDropped($event)\"\n              (click)=\"onFolderSelected(f.id)\"\n              class=\"cqa-shrink-0 cqa-w-[240px] cqa-flex cqa-items-center cqa-justify-between cqa-gap-3 cqa-text-left cqa-p-3 cqa-rounded-[10px] cqa-border-solid cqa-border-[0.5px] cqa-border-[#E2E2E3] cqa-bg-white hover:cqa-border-[#D8D9FC] hover:cqa-shadow-sm cqa-transition-colors\"\n            >\n              <div class=\"cqa-flex cqa-items-center cqa-gap-3 cqa-min-w-0\">\n                <ng-container *ngTemplateOutlet=\"folderIconChip\"></ng-container>\n                <div class=\"cqa-flex cqa-flex-col cqa-min-w-0\">\n                  <span class=\"cqa-text-base cqa-font-semibold cqa-text-neutral-900 cqa-truncate cqa-leading-tight\">{{ f.name }}</span>\n                  <span *ngIf=\"modularConfig.showCounts\" class=\"cqa-text-sm cqa-text-neutral-500 cqa-truncate\">\n                    {{ (f.count ?? 0) === 1 ? modularLabels.testsCountSingular : modularLabels.testsCountPlural.replace('{n}', '' + (f.count ?? 0)) }}<ng-container *ngIf=\"f.children?.length\"> \u00B7 {{ f.children!.length === 1 ? modularLabels.oneSubfolder : modularLabels.subfoldersCount.replace('{n}', '' + f.children!.length) }}</ng-container>\n                  </span>\n                </div>\n              </div>\n              <mat-icon class=\"cqa-text-neutral-400 cqa-shrink-0\" style=\"font-size:20px;width:20px;height:20px\">chevron_right</mat-icon>\n            </button>\n\n            <!-- \"+ New folder\" tile -->\n            <button\n              *ngIf=\"modularConfig.allowCreateFolder\"\n              type=\"button\"\n              (click)=\"onFolderCreateRequested({ parentId: null })\"\n              class=\"cqa-shrink-0 cqa-w-[240px] cqa-flex cqa-items-center cqa-gap-3 cqa-text-left cqa-p-3 cqa-rounded-[10px] cqa-border-solid cqa-border-[0.5px] cqa-border-[#E2E2E3] cqa-bg-neutral-50 hover:cqa-border-[#D8D9FC] hover:cqa-bg-white cqa-transition-colors\"\n            >\n              <ng-container *ngTemplateOutlet=\"addIconChip\"></ng-container>\n              <div class=\"cqa-flex cqa-flex-col cqa-min-w-0\">\n                <span class=\"cqa-text-base cqa-font-semibold cqa-text-neutral-600 cqa-truncate cqa-leading-tight\">{{ modularLabels.newFolder }}</span>\n                <span class=\"cqa-text-sm cqa-text-neutral-400\">{{ modularLabels.testsCountPlural.replace('{n}', '0') }}</span>\n              </div>\n            </button>\n          </div>\n        </section>\n\n        <!-- Subfolder section: modular + folder view. Shown whenever drilled in (even if no subfolders, so the \"+ New folder\" tile remains reachable). -->\n        <section\n          *ngIf=\"isModularView && !isRootView && modularConfig.showSubfolderSection && subfolderTiles.length\"\n          class=\"cqa-mb-4\"\n        >\n          <div *ngIf=\"subfolderTiles.length || modularConfig.allowCreateFolder\" class=\"cqa-text-sm cqa-text-neutral-600 cqa-mb-2\">\n            {{ modularLabels.subfoldersIn }} {{ breadcrumbTrail.length ? breadcrumbTrail[breadcrumbTrail.length - 1].name : '' }}\n          </div>\n          <div class=\"cqa-flex cqa-flex-nowrap cqa-gap-3 cqa-overflow-x-auto cqa-scrollbar-thin cqa-pb-2\">\n            <button\n              *ngFor=\"let f of subfolderTiles\"\n              type=\"button\"\n              [cqaFolderDrop]=\"f.id\"\n              [dropEnabled]=\"modularConfig.allowTestDragDrop\"\n              (testsDropped)=\"onTestsDropped($event)\"\n              (click)=\"onFolderSelected(f.id)\"\n              class=\"cqa-shrink-0 cqa-w-[240px] cqa-flex cqa-items-center cqa-justify-between cqa-gap-3 cqa-text-left cqa-p-3 cqa-rounded-[10px] cqa-border-solid cqa-border-[0.5px] cqa-border-[#E2E2E3] cqa-bg-white hover:cqa-border-[#D8D9FC] hover:cqa-shadow-sm cqa-transition-colors\"\n            >\n              <div class=\"cqa-flex cqa-items-center cqa-gap-3 cqa-min-w-0\">\n                <ng-container *ngTemplateOutlet=\"folderIconChip\"></ng-container>\n                <div class=\"cqa-flex cqa-flex-col cqa-min-w-0\">\n                  <span class=\"cqa-text-base cqa-font-semibold cqa-text-neutral-900 cqa-truncate cqa-leading-tight\">{{ f.name }}</span>\n                  <span *ngIf=\"modularConfig.showCounts\" class=\"cqa-text-sm cqa-text-neutral-500 cqa-truncate\">\n                    {{ (f.count ?? 0) === 1 ? modularLabels.testsCountSingular : modularLabels.testsCountPlural.replace('{n}', '' + (f.count ?? 0)) }}\n                  </span>\n                </div>\n              </div>\n              <mat-icon class=\"cqa-text-neutral-400 cqa-shrink-0\" style=\"font-size:20px;width:20px;height:20px\">chevron_right</mat-icon>\n            </button>\n\n            <!-- \"+ New folder\" tile -->\n            <button\n              *ngIf=\"modularConfig.allowCreateFolder\"\n              type=\"button\"\n              (click)=\"onFolderCreateRequested({ parentId: selectedFolderId })\"\n              class=\"cqa-shrink-0 cqa-w-[240px] cqa-flex cqa-items-center cqa-gap-3 cqa-text-left cqa-p-3 cqa-rounded-[10px] cqa-border-solid cqa-border-[0.5px] cqa-border-[#E2E2E3] cqa-bg-neutral-50 hover:cqa-border-[#D8D9FC] hover:cqa-bg-white cqa-transition-colors\"\n            >\n              <ng-container *ngTemplateOutlet=\"addIconChip\"></ng-container>\n              <div class=\"cqa-flex cqa-flex-col cqa-min-w-0\">\n                <span class=\"cqa-text-base cqa-font-semibold cqa-text-neutral-600 cqa-truncate cqa-leading-tight\">{{ modularLabels.newFolder }}</span>\n                <span class=\"cqa-text-sm cqa-text-neutral-400\">{{ modularLabels.testsCountPlural.replace('{n}', '0') }}</span>\n              </div>\n            </button>\n          </div>\n        </section>\n\n        <!-- Folder panel header above the table: \"Hotel Search (3)\" + Clear filter -->\n        <div\n          *ngIf=\"isModularView && !isRootView && modularConfig.showUnorganisedSection\"\n          class=\"cqa-flex cqa-mb-1 cqa-items-center cqa-justify-between cqa-px-4 cqa-py-3 cqa-rounded-t-lg cqa-bg-indigo-50 cqa-border cqa-border-indigo-100\"\n        >\n          <div class=\"cqa-flex cqa-items-center cqa-gap-2\">\n            <mat-icon class=\"cqa-text-indigo-500\" style=\"font-size:18px;width:18px;height:18px\">folder_open</mat-icon>\n            <span class=\"cqa-text-sm cqa-font-semibold cqa-text-indigo-700\">\n              {{ currentFolderNode?.name }} ({{ currentFolderDirectCount }})\n            </span>\n          </div>\n          <button\n            type=\"button\"\n            class=\"cqa-px-3 cqa-py-1 cqa-text-xs cqa-font-medium cqa-text-indigo-700 cqa-bg-white cqa-border cqa-border-indigo-200 cqa-rounded hover:cqa-bg-indigo-50\"\n            (click)=\"onFolderSelected(null)\"\n          >{{ modularLabels.clearFilter }}</button>\n        </div>\n\n        <!-- Unorganised section header at root view -->\n        <div\n          *ngIf=\"isModularView && isRootView && modularConfig.showUnorganisedSection\"\n          class=\"cqa-flex cqa-items-center cqa-gap-2 cqa-mb-2 cqa-mt-2\"\n        >\n          <mat-icon class=\"cqa-text-neutral-600\" style=\"font-size:16px;width:16px;height:16px\">inbox</mat-icon>\n          <h3 class=\"cqa-text-sm cqa-font-semibold cqa-text-neutral-800\">{{ modularLabels.unorganised }}</h3>\n          <span class=\"cqa-text-xs cqa-text-neutral-500\">\n            {{ unorganisedCount === 1 ? modularLabels.testsCountSingular : modularLabels.testsCountPlural.replace('{n}', '' + unorganisedCount) }}\n          </span>\n        </div>\n\n        <!-- Table -->\n        <div class=\"cqa-rounded-[7px] cqa-overflow-hidden cqa-border-t cqa-border-l cqa-border-r cqa-border-grey-200 cqa-relative cqa-overflow-x-auto\">\n          <ng-container *ngIf=\"(isTableLoading || isTableDataLoading) || (!effectiveIsEmptyState && pagedRows && pagedRows.length > 0); else storyEmptyTpl\">\n            <app-dynamic-table\n              [columns]=\"computedColumns\"\n              [data]=\"pagedRows\"\n              [rowSelectable]=\"rowSelectable\"\n              [enableLocalSort]=\"enableLocalSort && !isReordering\"\n              [isTableLoading]=\"isTableLoading\"\n              [isTableDataLoading]=\"isTableDataLoading\"\n              [cellJsonPathGetter]=\"cellJsonPathGetter\"\n              [onJsonPathCopiedHandler]=\"onJsonPathCopiedHandler\"\n              [enableRowReorder]=\"isReordering\"\n              (rowReorder)=\"onRowReorder($event)\"\n              (sortChange)=\"sortChange.emit($event)\">\n              <ng-template #emptyTableTpl>\n                <div class=\"cqa-flex cqa-flex-col cqa-items-center cqa-justify-center cqa-py-8\">\n                  <img src=\"/assets/illustrations/empty-state.svg\" alt=\"No data\" class=\"cqa-w-32 cqa-h-32 cqa-mb-4\" />\n                  <h3 class=\"cqa-text-lg cqa-font-semibold cqa-mb-2\">No test cases</h3>\n                  <p class=\"cqa-text-sm cqa-text-neutral-500 cqa-mb-4\">Try adjusting filters or create a new test case.</p>\n                  <cqa-button variant=\"filled\" (clicked)=\"toggleFilter()\">Show Filters</cqa-button>\n                </div>\n              </ng-template>\n            </app-dynamic-table>\n          </ng-container>\n\n          <ng-template #storyEmptyTpl>\n            <div class=\"cqa-p-6 cqa-flex cqa-flex-col cqa-items-center cqa-justify-center\">\n              <cqa-empty-state\n                *ngIf=\"effectiveIsEmptyState\"\n                [title]=\"effectiveEmptyStateConfig.title\"\n                [description]=\"effectiveEmptyStateConfig.description\"\n                [imageUrl]=\"effectiveEmptyStateConfig.imageUrl\"\n                [actions]=\"effectiveEmptyStateConfig.actions\"\n                (actionClick)=\"onEmptyAction($event)\"\n              >\n              </cqa-empty-state>\n            </div>\n          </ng-template>\n        </div>\n\n        <cqa-pagination\n          [totalElements]=\"serverSidePagination ? totalElements : filteredRows.length\"\n          [pageIndex]=\"pageIndex\"\n          [pageSize]=\"pageSize\"\n          [pageSizeOptions]=\"pageSizeOptions\"\n          [pageSizeMenuDirection]=\"pageSizeMenuDirection\"\n          [pageItemCount]=\"pagedRows.length\"\n          (paginate)=\"onPaginate($event)\"\n          (pageSizeChange)=\"onPageSizeChange($event)\"\n        >\n        </cqa-pagination>\n      </div>\n    </div>\n\n    <!-- Reused bulk action toolbar -->\n    <div *ngIf=\"anyRowSelected && modularConfig.allowBulkSelection && !isReordering\" class=\"cqa-absolute cqa-bottom-[18.75px] cqa-left-[50%] cqa-translate-x-[-50%] cqa-w-full lg:cqa-max-w-[68%] cqa-sm:max-w-[75%] cqa-max-w-[90%] cqa-z-[1]\">\n      <cqa-table-action-toolbar\n        [selectedItems]=\"selectedItems && selectedItems.length > 0 ? selectedItems : currentSelectedItems\"\n        [actions]=\"effectiveBulkActions\"\n        [showSelectAll]=\"showSelectAllInToolbar\"\n        [allSelected]=\"allSelectedInToolbar\"\n        [showDismiss]=\"showDismissInToolbar\"\n        (actionClick)=\"onBulkAction($event)\"\n        (selectAllChange)=\"onBulkSelectAll($event)\"\n        (dismiss)=\"onBulkDismiss()\"\n      ></cqa-table-action-toolbar>\n    </div>\n\n  </div>\n</div>\n\n", components: [{ type: i2.SearchBarComponent, selector: "cqa-search-bar", inputs: ["placeholder", "value", "disabled", "showClear", "ariaLabel", "autoFocus", "size", "fullWidth"], outputs: ["valueChange", "search", "cleared"] }, { type: i3.ButtonComponent, selector: "cqa-button", inputs: ["variant", "btnSize", "disabled", "loading", "icon", "iconPosition", "fullWidth", "iconColor", "type", "text", "customClass", "inlineStyles", "tooltip", "tooltipPosition"], outputs: ["clicked"] }, { type: i4.ExportCodeModalComponent, selector: "cqa-export-code-modal", inputs: ["isOpen", "cases", "disabled"], outputs: ["closeModal", "export"] }, { type: i5.ColumnVisibilityComponent, selector: "cqa-column-visibility", inputs: ["isStepGroup", "columns", "columnVisibility", "selectedAutoRefreshInterval"], outputs: ["columnVisibilityChange", "autoRefreshChange"] }, { type: i6.SegmentControlComponent, selector: "cqa-segment-control", inputs: ["segments", "value", "disabled", "containerBgColor", "fullWidth", "size"], outputs: ["valueChange"] }, { type: i7.SelectedFiltersComponent, selector: "cqa-selected-filters", inputs: ["filterApplied", "chips", "defaultChips", "defaultChipClass"], outputs: ["removeChip", "clearAll", "onClearAll"] }, { type: i8.DynamicFilterComponent, selector: "cqa-dynamic-filter", inputs: ["config", "model", "showFilterPanel", "buttonLayout"], outputs: ["filtersApplied", "filtersChanged", "resetAction", "onApplyFilterClick", "onResetFilterClick"] }, { type: i9.FolderSidebarComponent, selector: "cqa-folder-sidebar", inputs: ["folders", "selectedFolderId", "expandedFolderIds", "unorganisedCount", "allowCreate", "allowRename", "allowDelete", "allowMove", "allowDuplicate", "allowDrop", "showCounts", "collapsed", "labels"], outputs: ["folderSelected", "folderExpansionToggled", "folderCreated", "folderCreateRequested", "folderRenamed", "folderDeleted", "folderMoveRequested", "folderDuplicateRequested", "testsDropped", "folderDropped", "collapsedChange"] }, { type: i10.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { type: i11.DynamicTableComponent, selector: "app-dynamic-table", inputs: ["data", "columns", "emptyState", "gridTemplateColumns", "screenWidth", "enableSelectAll", "rowSelectable", "enableLocalSort", "isTableLoading", "isTableDataLoading", "cellJsonPathGetter", "onJsonPathCopiedHandler", "enableRowReorder", "reorderHandleTooltip"], outputs: ["sortChange", "rowReorder"] }, { type: i12.EmptyStateComponent, selector: "cqa-empty-state", inputs: ["preset", "imageUrl", "title", "description", "actions"], outputs: ["actionClick"] }, { type: i13.PaginationComponent, selector: "cqa-pagination", inputs: ["totalElements", "totalPages", "pageIndex", "pageSize", "pageItemCount", "pageSizeOptions", "pageSizeMenuDirection"], outputs: ["pageIndexChange", "pageSizeChange", "paginate"] }, { type: i14.TableActionToolbarComponent, selector: "cqa-table-action-toolbar", inputs: ["selectedItems", "actions", "showSelectAll", "allSelected", "showDismiss"], outputs: ["actionClick", "selectAllChange", "dismiss"] }], directives: [{ type: i15.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i15.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i15.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet"] }, { type: i16.FolderDropDirective, selector: "[cqaFolderDrop]", inputs: ["cqaFolderDrop", "dropEnabled"], outputs: ["testsDropped", "folderDropped"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: ModularTableTemplateComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'cqa-modular-table-template', host: { class: 'cqa-ui-root' }, changeDetection: ChangeDetectionStrategy.OnPush, template: "<!-- Reusable folder-icon chip. Render via <ng-container *ngTemplateOutlet=\"folderIconChip\"></ng-container>. -->\n<ng-template #folderIconChip>\n  <span class=\"cqa-inline-flex cqa-items-center cqa-justify-center cqa-w-10 cqa-h-10 cqa-rounded-[10px] cqa-bg-neutral-100 cqa-shrink-0\">\n    <svg width=\"17\" height=\"15\" viewBox=\"0 0 17 15\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\" aria-hidden=\"true\">\n      <path d=\"M15.6375 12.6377C15.6375 13.0355 15.4794 13.4171 15.1981 13.6984C14.9168 13.9797 14.5353 14.1377 14.1375 14.1377H2.13745C1.73963 14.1377 1.3581 13.9797 1.07679 13.6984C0.795486 13.4171 0.637451 13.0355 0.637451 12.6377V2.1377C0.637451 1.73987 0.795486 1.35834 1.07679 1.07704C1.3581 0.795731 1.73963 0.637695 2.13745 0.637695H5.88745L7.38745 2.8877H14.1375C14.5353 2.8877 14.9168 3.04573 15.1981 3.32704C15.4794 3.60834 15.6375 3.98987 15.6375 4.3877V12.6377Z\" stroke=\"#6D6D74\" stroke-width=\"1.275\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\n    </svg>\n  </span>\n</ng-template>\n\n<!-- Reusable \"+\" chip used by the \"New folder\" tile. -->\n<ng-template #addIconChip>\n  <span class=\"cqa-inline-flex cqa-items-center cqa-justify-center cqa-w-10 cqa-h-10 cqa-rounded-[10px] cqa-bg-neutral-100 cqa-shrink-0\">\n    <svg width=\"16\" height=\"16\" viewBox=\"0 0 16 16\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\" aria-hidden=\"true\">\n      <path d=\"M8 3V13M3 8H13\" stroke=\"#6D6D74\" stroke-width=\"1.275\" stroke-linecap=\"round\"/>\n    </svg>\n  </span>\n</ng-template>\n\n<div class=\"cqa-ui-root\">\n  <div class=\"cqa-w-full cqa-flex cqa-flex-col cqa-relative\">\n    <div [class]=\"!showSearchBar ? 'cqa-justify-end' : 'cqa-justify-between'\" class=\"cqa-w-full cqa-flex cqa-items-center cqa-gap-3 cqa-flex-wrap cqa-mb-3\">\n      <cqa-search-bar\n        *ngIf=\"showSearchBar\"\n        [placeholder]=\"searchPlaceholder\"\n        [value]=\"searchValue\"\n        [showClear]=\"showClear\"\n        (valueChange)=\"valueChange($event)\"\n        (search)=\"search($event)\"\n        (cleared)=\"cleared()\"\n      ></cqa-search-bar>\n      <div class=\"cqa-flex cqa-items-center cqa-gap-2 cqa-flex-wrap\">\n        <cqa-button\n        *ngIf=\"showExportButton\"\n        variant=\"grey-solid\"\n        icon=\"open_in_new\"\n        [text]=\"isExporting ? 'Exporting...' : 'Export'\"\n        [disabled]=\"isExporting\"\n        (clicked)=\"exportCodeClick()\"\n      >\n        <span>{{ isExporting ? 'Exporting...' : 'Export' }}</span>\n      </cqa-button>\n      \n      <!-- Export Code Modal -->\n      <cqa-export-code-modal\n        *ngIf=\"showExportButton\"\n        [isOpen]=\"isExportModalOpen\"\n        [cases]=\"selectedCasesForExport\"\n        [disabled]=\"false\"\n        (closeModal)=\"closeExportModal()\"\n        (export)=\"onExportModalExport($event)\">\n      </cqa-export-code-modal>\n         <ng-container *ngFor=\"let dropdownTemplate of otherDropDownButtons; trackBy: trackByDropdownTemplateRef\">\n          <ng-container *ngTemplateOutlet=\"dropdownTemplate\"></ng-container>\n        </ng-container>\n\n        <ng-container *ngFor=\"let selectDropdownTemplate of otherSelectDropDownButtons; trackBy: trackBySelectDropdownTemplateRef\">\n          <ng-container *ngTemplateOutlet=\"selectDropdownTemplate\"></ng-container>\n        </ng-container>\n        \n        <cqa-button\n          *ngIf=\"showFilterButton\"\n          variant=\"grey-solid\"\n          icon=\"add\"\n          [disabled]=\"isReordering\"\n          (clicked)=\"toggleFilter()\"\n        >\n        <span class=\"cqa-flex cqa-items-center cqa-gap-1\">\n          Filter          \n           <div [class]=\"arrowClasses\">\n            <svg\n              class=\"cqa-w-2 cqa-h-1 cqa-absolute cqa-left-[4px] cqa-top-[6px]\"\n              viewBox=\"0 0 8 4\"\n              fill=\"none\"\n              xmlns=\"http://www.w3.org/2000/svg\"\n            >\n              <path\n                d=\"M0 0L4 4L8 0\"\n                stroke=\"#0B0B0C\"\n                stroke-width=\"1.33\"\n                stroke-linecap=\"round\"\n                stroke-linejoin=\"round\"\n              />\n            </svg>\n          </div>\n        </span>\n        </cqa-button>\n        <cqa-column-visibility\n          *ngIf=\"showSettingsButton\"\n          [columns]=\"visibilityColumns\"\n          [columnVisibility]=\"columnVisibility\"\n          [selectedAutoRefreshInterval]=\"selectedAutoRefreshInterval\"\n          (columnVisibilityChange)=\"onColumnVisibilityChange($event)\"\n          (autoRefreshChange)=\"onAutoRefreshChange($event)\"\n        ></cqa-column-visibility>\n        <cqa-button\n          *ngIf=\"showAutoRefreshButton\"\n          variant=\"grey-solid\"\n          icon=\"refresh\"\n          (clicked)=\"handleRefreshClick()\"\n          [tooltip]=\"'Refresh'\"\n          tooltipPosition=\"below\"\n          [disabled]=\"isReordering\"\n        ></cqa-button>\n        <ng-container *ngFor=\"let buttonTemplate of otherButtons; trackBy: trackByTemplateRef\">\n          <ng-container *ngTemplateOutlet=\"buttonTemplate\"></ng-container>\n        </ng-container>\n        <cqa-segment-control\n          *ngIf=\"showViewModeToggle\"\n          size=\"lg\"\n          [segments]=\"viewModeSegments\"\n          [value]=\"viewMode\"\n          (valueChange)=\"onViewModeChange($event)\"\n        ></cqa-segment-control>\n        <cqa-button\n          *ngIf=\"showReorderButton && !isReordering\"\n          variant=\"outlined\"\n          icon=\"drag_indicator\"\n          [text]=\"reorderLabels.reorderButton\"\n          [disabled]=\"!pagedRows || pagedRows.length === 0 || isTableLoading || isTableDataLoading\"\n          (clicked)=\"startReorder()\"\n        ></cqa-button>\n        <ng-container *ngIf=\"showReorderButton && isReordering\">\n          <cqa-button\n            variant=\"outlined\"\n            [text]=\"reorderLabels.cancelButton\"\n            [disabled]=\"reorderSaving\"\n            (clicked)=\"cancelReorder()\"\n          ></cqa-button>\n          <cqa-button\n            variant=\"filled\"\n            [icon]=\"reorderSaving ? 'hourglass_empty' : ''\"\n            [text]=\"reorderSaving ? reorderLabels.savingButton : reorderLabels.doneButton\"\n            [disabled]=\"reorderSaving\"\n            (clicked)=\"saveReorder()\"\n          ></cqa-button>\n        </ng-container>\n      </div>\n    </div>\n\n    <!-- Reorder mode banner -->\n    <div *ngIf=\"isReordering\" class=\"cqa-flex cqa-items-center cqa-gap-2 cqa-mb-3 cqa-px-3 cqa-py-2 cqa-rounded-md cqa-bg-[#FFFBEB] cqa-border cqa-border-[#FDE68A]\">\n      <svg width=\"16\" height=\"16\" viewBox=\"0 0 16 16\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\" aria-hidden=\"true\">\n        <circle cx=\"3\" cy=\"3\" r=\"1.5\" fill=\"#92400E\"></circle>\n        <circle cx=\"8\" cy=\"3\" r=\"1.5\" fill=\"#92400E\"></circle>\n        <circle cx=\"13\" cy=\"3\" r=\"1.5\" fill=\"#92400E\"></circle>\n        <circle cx=\"3\" cy=\"8\" r=\"1.5\" fill=\"#92400E\"></circle>\n        <circle cx=\"8\" cy=\"8\" r=\"1.5\" fill=\"#92400E\"></circle>\n        <circle cx=\"13\" cy=\"8\" r=\"1.5\" fill=\"#92400E\"></circle>\n        <circle cx=\"3\" cy=\"13\" r=\"1.5\" fill=\"#92400E\"></circle>\n        <circle cx=\"8\" cy=\"13\" r=\"1.5\" fill=\"#92400E\"></circle>\n        <circle cx=\"13\" cy=\"13\" r=\"1.5\" fill=\"#92400E\"></circle>\n      </svg>\n      <span class=\"cqa-text-sm cqa-font-semibold cqa-text-[#92400E]\">{{ reorderLabels.bannerTitle }}</span>\n      <span class=\"cqa-text-sm cqa-text-[#92400E]\">{{ reorderLabels.bannerDescription }}</span>\n    </div>\n\n    <cqa-selected-filters\n      [filterApplied]=\"filterApplied\"\n      [chips]=\"chips\"\n      (removeChip)=\"onRemoveChip($event)\"\n      (clearAll)=\"onClearAllChips()\"\n      (onClearAll)=\"onClearAll.emit()\"\n    >\n    </cqa-selected-filters>\n\n    <cqa-dynamic-filter\n      *ngIf=\"showFilterPanel\"\n      [config]=\"filterConfig\"\n      [model]=\"filterModel\"\n      [showFilterPanel]=\"showFilterPanel\"\n      (filtersChanged)=\"onFiltersChanged($event)\"\n      (filtersApplied)=\"onFiltersApplied($event)\"\n      (onApplyFilterClick)=\"onApplyFilterClick.emit($event)\"\n      (onResetFilterClick)=\"handleResetFilterClick()\"\n    >\n    </cqa-dynamic-filter>\n\n    <div class=\"cqa-flex cqa-items-stretch cqa-gap-3 cqa-min-h-0\">\n      <!-- Sidebar (only shown in modular view) -->\n      <cqa-folder-sidebar\n        *ngIf=\"isModularView && modularConfig.showSidebar\"\n        [folders]=\"folders\"\n        [selectedFolderId]=\"selectedFolderId\"\n        [expandedFolderIds]=\"expandedFolderIds\"\n        [unorganisedCount]=\"unorganisedCount\"\n        [allowCreate]=\"modularConfig.allowCreateFolder\"\n        [allowRename]=\"modularConfig.allowRenameFolder\"\n        [allowDelete]=\"modularConfig.allowDeleteFolder\"\n        [allowDrop]=\"modularConfig.allowTestDragDrop\"\n        [showCounts]=\"modularConfig.showCounts\"\n        [collapsed]=\"sidebarCollapsed\"\n        [labels]=\"modularLabels\"\n        (folderSelected)=\"onFolderSelected($event)\"\n        (folderExpansionToggled)=\"onFolderExpansionToggled($event)\"\n        (folderCreated)=\"onFolderCreated($event)\"\n        (folderCreateRequested)=\"onFolderCreateRequested($event)\"\n        (folderRenamed)=\"onFolderRenamed($event)\"\n        (folderDeleted)=\"onFolderDeleted($event)\"\n        (folderMoveRequested)=\"onFolderMoveRequested($event)\"\n        (folderDuplicateRequested)=\"onFolderDuplicateRequested($event)\"\n        (testsDropped)=\"onTestsDropped($event)\"\n        (folderDropped)=\"onFolderDropped($event)\"\n        (collapsedChange)=\"onSidebarCollapsedChange($event)\"\n      ></cqa-folder-sidebar>\n\n      <!-- Right pane -->\n      <div class=\"cqa-flex-1 cqa-flex cqa-flex-col cqa-min-w-0\">\n        <!-- Breadcrumb (modular view, folder drilled-in) -->\n        <nav\n          *ngIf=\"isModularView && modularConfig.showBreadcrumb && !isRootView\"\n          aria-label=\"Folder path\"\n          class=\"cqa-flex cqa-items-center cqa-gap-1 cqa-text-sm cqa-text-neutral-600 cqa-mb-3\"\n        >\n          <button type=\"button\" class=\"hover:cqa-text-indigo-600\" (click)=\"onFolderSelected(null)\">\n            <mat-icon class=\"cqa-align-middle\" style=\"font-size:16px;width:16px;height:16px\">folder_open</mat-icon>\n            <span class=\"cqa-align-middle cqa-ml-1\">{{ modularLabels.allFolders }}</span>\n          </button>\n          <ng-container *ngFor=\"let crumb of breadcrumbTrail; let last = last\">\n            <span class=\"cqa-text-neutral-400\">/</span>\n            <button\n              type=\"button\"\n              class=\"hover:cqa-text-indigo-600\"\n              [class.cqa-text-neutral-900]=\"last\"\n              [class.cqa-font-semibold]=\"last\"\n              [disabled]=\"last\"\n              (click)=\"!last && onFolderSelected(crumb.id)\"\n            >{{ crumb.name }}</button>\n          </ng-container>\n        </nav>\n\n        <!-- Folder grid: modular + root view -->\n        <section\n          *ngIf=\"isModularView && isRootView && modularConfig.showFolderGrid && rootFolderTiles.length\"\n          class=\"cqa-mb-4\"\n        >\n          <div class=\"cqa-flex cqa-items-center cqa-gap-2 cqa-mb-2\">\n            <mat-icon class=\"cqa-text-neutral-600\" style=\"font-size:16px;width:16px;height:16px\">folder</mat-icon>\n            <h3 class=\"cqa-text-sm cqa-font-semibold cqa-text-neutral-800\">{{ modularLabels.organised }}</h3>\n            <span class=\"cqa-text-xs cqa-text-neutral-500\">\n              {{ rootFolderTiles.length === 1 ? modularLabels.foldersCountSingular : modularLabels.foldersCountPlural.replace('{n}', '' + rootFolderTiles.length) }}\n            </span>\n          </div>\n          <div class=\"cqa-flex cqa-flex-nowrap cqa-gap-3 cqa-overflow-x-auto cqa-scrollbar-thin cqa-pb-2\">\n            <button\n              *ngFor=\"let f of rootFolderTiles\"\n              type=\"button\"\n              [cqaFolderDrop]=\"f.id\"\n              [dropEnabled]=\"modularConfig.allowTestDragDrop\"\n              (testsDropped)=\"onTestsDropped($event)\"\n              (click)=\"onFolderSelected(f.id)\"\n              class=\"cqa-shrink-0 cqa-w-[240px] cqa-flex cqa-items-center cqa-justify-between cqa-gap-3 cqa-text-left cqa-p-3 cqa-rounded-[10px] cqa-border-solid cqa-border-[0.5px] cqa-border-[#E2E2E3] cqa-bg-white hover:cqa-border-[#D8D9FC] hover:cqa-shadow-sm cqa-transition-colors\"\n            >\n              <div class=\"cqa-flex cqa-items-center cqa-gap-3 cqa-min-w-0\">\n                <ng-container *ngTemplateOutlet=\"folderIconChip\"></ng-container>\n                <div class=\"cqa-flex cqa-flex-col cqa-min-w-0\">\n                  <span class=\"cqa-text-base cqa-font-semibold cqa-text-neutral-900 cqa-truncate cqa-leading-tight\">{{ f.name }}</span>\n                  <span *ngIf=\"modularConfig.showCounts\" class=\"cqa-text-sm cqa-text-neutral-500 cqa-truncate\">\n                    {{ (f.count ?? 0) === 1 ? modularLabels.testsCountSingular : modularLabels.testsCountPlural.replace('{n}', '' + (f.count ?? 0)) }}<ng-container *ngIf=\"f.children?.length\"> \u00B7 {{ f.children!.length === 1 ? modularLabels.oneSubfolder : modularLabels.subfoldersCount.replace('{n}', '' + f.children!.length) }}</ng-container>\n                  </span>\n                </div>\n              </div>\n              <mat-icon class=\"cqa-text-neutral-400 cqa-shrink-0\" style=\"font-size:20px;width:20px;height:20px\">chevron_right</mat-icon>\n            </button>\n\n            <!-- \"+ New folder\" tile -->\n            <button\n              *ngIf=\"modularConfig.allowCreateFolder\"\n              type=\"button\"\n              (click)=\"onFolderCreateRequested({ parentId: null })\"\n              class=\"cqa-shrink-0 cqa-w-[240px] cqa-flex cqa-items-center cqa-gap-3 cqa-text-left cqa-p-3 cqa-rounded-[10px] cqa-border-solid cqa-border-[0.5px] cqa-border-[#E2E2E3] cqa-bg-neutral-50 hover:cqa-border-[#D8D9FC] hover:cqa-bg-white cqa-transition-colors\"\n            >\n              <ng-container *ngTemplateOutlet=\"addIconChip\"></ng-container>\n              <div class=\"cqa-flex cqa-flex-col cqa-min-w-0\">\n                <span class=\"cqa-text-base cqa-font-semibold cqa-text-neutral-600 cqa-truncate cqa-leading-tight\">{{ modularLabels.newFolder }}</span>\n                <span class=\"cqa-text-sm cqa-text-neutral-400\">{{ modularLabels.testsCountPlural.replace('{n}', '0') }}</span>\n              </div>\n            </button>\n          </div>\n        </section>\n\n        <!-- Subfolder section: modular + folder view. Shown whenever drilled in (even if no subfolders, so the \"+ New folder\" tile remains reachable). -->\n        <section\n          *ngIf=\"isModularView && !isRootView && modularConfig.showSubfolderSection && subfolderTiles.length\"\n          class=\"cqa-mb-4\"\n        >\n          <div *ngIf=\"subfolderTiles.length || modularConfig.allowCreateFolder\" class=\"cqa-text-sm cqa-text-neutral-600 cqa-mb-2\">\n            {{ modularLabels.subfoldersIn }} {{ breadcrumbTrail.length ? breadcrumbTrail[breadcrumbTrail.length - 1].name : '' }}\n          </div>\n          <div class=\"cqa-flex cqa-flex-nowrap cqa-gap-3 cqa-overflow-x-auto cqa-scrollbar-thin cqa-pb-2\">\n            <button\n              *ngFor=\"let f of subfolderTiles\"\n              type=\"button\"\n              [cqaFolderDrop]=\"f.id\"\n              [dropEnabled]=\"modularConfig.allowTestDragDrop\"\n              (testsDropped)=\"onTestsDropped($event)\"\n              (click)=\"onFolderSelected(f.id)\"\n              class=\"cqa-shrink-0 cqa-w-[240px] cqa-flex cqa-items-center cqa-justify-between cqa-gap-3 cqa-text-left cqa-p-3 cqa-rounded-[10px] cqa-border-solid cqa-border-[0.5px] cqa-border-[#E2E2E3] cqa-bg-white hover:cqa-border-[#D8D9FC] hover:cqa-shadow-sm cqa-transition-colors\"\n            >\n              <div class=\"cqa-flex cqa-items-center cqa-gap-3 cqa-min-w-0\">\n                <ng-container *ngTemplateOutlet=\"folderIconChip\"></ng-container>\n                <div class=\"cqa-flex cqa-flex-col cqa-min-w-0\">\n                  <span class=\"cqa-text-base cqa-font-semibold cqa-text-neutral-900 cqa-truncate cqa-leading-tight\">{{ f.name }}</span>\n                  <span *ngIf=\"modularConfig.showCounts\" class=\"cqa-text-sm cqa-text-neutral-500 cqa-truncate\">\n                    {{ (f.count ?? 0) === 1 ? modularLabels.testsCountSingular : modularLabels.testsCountPlural.replace('{n}', '' + (f.count ?? 0)) }}\n                  </span>\n                </div>\n              </div>\n              <mat-icon class=\"cqa-text-neutral-400 cqa-shrink-0\" style=\"font-size:20px;width:20px;height:20px\">chevron_right</mat-icon>\n            </button>\n\n            <!-- \"+ New folder\" tile -->\n            <button\n              *ngIf=\"modularConfig.allowCreateFolder\"\n              type=\"button\"\n              (click)=\"onFolderCreateRequested({ parentId: selectedFolderId })\"\n              class=\"cqa-shrink-0 cqa-w-[240px] cqa-flex cqa-items-center cqa-gap-3 cqa-text-left cqa-p-3 cqa-rounded-[10px] cqa-border-solid cqa-border-[0.5px] cqa-border-[#E2E2E3] cqa-bg-neutral-50 hover:cqa-border-[#D8D9FC] hover:cqa-bg-white cqa-transition-colors\"\n            >\n              <ng-container *ngTemplateOutlet=\"addIconChip\"></ng-container>\n              <div class=\"cqa-flex cqa-flex-col cqa-min-w-0\">\n                <span class=\"cqa-text-base cqa-font-semibold cqa-text-neutral-600 cqa-truncate cqa-leading-tight\">{{ modularLabels.newFolder }}</span>\n                <span class=\"cqa-text-sm cqa-text-neutral-400\">{{ modularLabels.testsCountPlural.replace('{n}', '0') }}</span>\n              </div>\n            </button>\n          </div>\n        </section>\n\n        <!-- Folder panel header above the table: \"Hotel Search (3)\" + Clear filter -->\n        <div\n          *ngIf=\"isModularView && !isRootView && modularConfig.showUnorganisedSection\"\n          class=\"cqa-flex cqa-mb-1 cqa-items-center cqa-justify-between cqa-px-4 cqa-py-3 cqa-rounded-t-lg cqa-bg-indigo-50 cqa-border cqa-border-indigo-100\"\n        >\n          <div class=\"cqa-flex cqa-items-center cqa-gap-2\">\n            <mat-icon class=\"cqa-text-indigo-500\" style=\"font-size:18px;width:18px;height:18px\">folder_open</mat-icon>\n            <span class=\"cqa-text-sm cqa-font-semibold cqa-text-indigo-700\">\n              {{ currentFolderNode?.name }} ({{ currentFolderDirectCount }})\n            </span>\n          </div>\n          <button\n            type=\"button\"\n            class=\"cqa-px-3 cqa-py-1 cqa-text-xs cqa-font-medium cqa-text-indigo-700 cqa-bg-white cqa-border cqa-border-indigo-200 cqa-rounded hover:cqa-bg-indigo-50\"\n            (click)=\"onFolderSelected(null)\"\n          >{{ modularLabels.clearFilter }}</button>\n        </div>\n\n        <!-- Unorganised section header at root view -->\n        <div\n          *ngIf=\"isModularView && isRootView && modularConfig.showUnorganisedSection\"\n          class=\"cqa-flex cqa-items-center cqa-gap-2 cqa-mb-2 cqa-mt-2\"\n        >\n          <mat-icon class=\"cqa-text-neutral-600\" style=\"font-size:16px;width:16px;height:16px\">inbox</mat-icon>\n          <h3 class=\"cqa-text-sm cqa-font-semibold cqa-text-neutral-800\">{{ modularLabels.unorganised }}</h3>\n          <span class=\"cqa-text-xs cqa-text-neutral-500\">\n            {{ unorganisedCount === 1 ? modularLabels.testsCountSingular : modularLabels.testsCountPlural.replace('{n}', '' + unorganisedCount) }}\n          </span>\n        </div>\n\n        <!-- Table -->\n        <div class=\"cqa-rounded-[7px] cqa-overflow-hidden cqa-border-t cqa-border-l cqa-border-r cqa-border-grey-200 cqa-relative cqa-overflow-x-auto\">\n          <ng-container *ngIf=\"(isTableLoading || isTableDataLoading) || (!effectiveIsEmptyState && pagedRows && pagedRows.length > 0); else storyEmptyTpl\">\n            <app-dynamic-table\n              [columns]=\"computedColumns\"\n              [data]=\"pagedRows\"\n              [rowSelectable]=\"rowSelectable\"\n              [enableLocalSort]=\"enableLocalSort && !isReordering\"\n              [isTableLoading]=\"isTableLoading\"\n              [isTableDataLoading]=\"isTableDataLoading\"\n              [cellJsonPathGetter]=\"cellJsonPathGetter\"\n              [onJsonPathCopiedHandler]=\"onJsonPathCopiedHandler\"\n              [enableRowReorder]=\"isReordering\"\n              (rowReorder)=\"onRowReorder($event)\"\n              (sortChange)=\"sortChange.emit($event)\">\n              <ng-template #emptyTableTpl>\n                <div class=\"cqa-flex cqa-flex-col cqa-items-center cqa-justify-center cqa-py-8\">\n                  <img src=\"/assets/illustrations/empty-state.svg\" alt=\"No data\" class=\"cqa-w-32 cqa-h-32 cqa-mb-4\" />\n                  <h3 class=\"cqa-text-lg cqa-font-semibold cqa-mb-2\">No test cases</h3>\n                  <p class=\"cqa-text-sm cqa-text-neutral-500 cqa-mb-4\">Try adjusting filters or create a new test case.</p>\n                  <cqa-button variant=\"filled\" (clicked)=\"toggleFilter()\">Show Filters</cqa-button>\n                </div>\n              </ng-template>\n            </app-dynamic-table>\n          </ng-container>\n\n          <ng-template #storyEmptyTpl>\n            <div class=\"cqa-p-6 cqa-flex cqa-flex-col cqa-items-center cqa-justify-center\">\n              <cqa-empty-state\n                *ngIf=\"effectiveIsEmptyState\"\n                [title]=\"effectiveEmptyStateConfig.title\"\n                [description]=\"effectiveEmptyStateConfig.description\"\n                [imageUrl]=\"effectiveEmptyStateConfig.imageUrl\"\n                [actions]=\"effectiveEmptyStateConfig.actions\"\n                (actionClick)=\"onEmptyAction($event)\"\n              >\n              </cqa-empty-state>\n            </div>\n          </ng-template>\n        </div>\n\n        <cqa-pagination\n          [totalElements]=\"serverSidePagination ? totalElements : filteredRows.length\"\n          [pageIndex]=\"pageIndex\"\n          [pageSize]=\"pageSize\"\n          [pageSizeOptions]=\"pageSizeOptions\"\n          [pageSizeMenuDirection]=\"pageSizeMenuDirection\"\n          [pageItemCount]=\"pagedRows.length\"\n          (paginate)=\"onPaginate($event)\"\n          (pageSizeChange)=\"onPageSizeChange($event)\"\n        >\n        </cqa-pagination>\n      </div>\n    </div>\n\n    <!-- Reused bulk action toolbar -->\n    <div *ngIf=\"anyRowSelected && modularConfig.allowBulkSelection && !isReordering\" class=\"cqa-absolute cqa-bottom-[18.75px] cqa-left-[50%] cqa-translate-x-[-50%] cqa-w-full lg:cqa-max-w-[68%] cqa-sm:max-w-[75%] cqa-max-w-[90%] cqa-z-[1]\">\n      <cqa-table-action-toolbar\n        [selectedItems]=\"selectedItems && selectedItems.length > 0 ? selectedItems : currentSelectedItems\"\n        [actions]=\"effectiveBulkActions\"\n        [showSelectAll]=\"showSelectAllInToolbar\"\n        [allSelected]=\"allSelectedInToolbar\"\n        [showDismiss]=\"showDismissInToolbar\"\n        (actionClick)=\"onBulkAction($event)\"\n        (selectAllChange)=\"onBulkSelectAll($event)\"\n        (dismiss)=\"onBulkDismiss()\"\n      ></cqa-table-action-toolbar>\n    </div>\n\n  </div>\n</div>\n\n", styles: [] }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i1.DialogService }]; }, propDecorators: { searchPlaceholder: [{
+                type: Input
+            }], searchValue: [{
+                type: Input
+            }], showClear: [{
+                type: Input
+            }], showSearchBar: [{
+                type: Input
+            }], showExportButton: [{
+                type: Input
+            }], isExporting: [{
+                type: Input
+            }], onSearchChange: [{
+                type: Output
+            }], onExportClick: [{
+                type: Output
+            }], onApplyFilterClick: [{
+                type: Output
+            }], onResetFilterClick: [{
+                type: Output
+            }], onClearAll: [{
+                type: Output
+            }], removeChip: [{
+                type: Output
+            }], filterConfig: [{
+                type: Input
+            }], filterModel: [{
+                type: Input
+            }], showFilterPanel: [{
+                type: Input
+            }], showFilterButton: [{
+                type: Input
+            }], otherButtons: [{
+                type: Input
+            }], otherDropDownButtons: [{
+                type: Input
+            }], otherSelectDropDownButtons: [{
+                type: Input
+            }], otherButtonLabel: [{
+                type: Input
+            }], otherButtonVariant: [{
+                type: Input
+            }], showOtherButton: [{
+                type: Input
+            }], showActionButton: [{
+                type: Input
+            }], showSettingsButton: [{
+                type: Input
+            }], showAutoRefreshButton: [{
+                type: Input
+            }], showViewModeToggle: [{
+                type: Input
+            }], viewMode: [{
+                type: Input
+            }], viewModeLabels: [{
+                type: Input
+            }], viewModeChange: [{
+                type: Output
+            }], data: [{
+                type: Input
+            }], isEmptyState: [{
+                type: Input
+            }], emptyStateConfig: [{
+                type: Input
+            }], actions: [{
+                type: Input
+            }], chips: [{
+                type: Input
+            }], filterApplied: [{
+                type: Input
+            }], columns: [{
+                type: Input
+            }], rowSelectable: [{
+                type: Input
+            }], selectedAutoRefreshInterval: [{
+                type: Input
+            }], pageIndex: [{
+                type: Input
+            }], pageSize: [{
+                type: Input
+            }], pageSizeOptions: [{
+                type: Input
+            }], pageSizeMenuDirection: [{
+                type: Input
+            }], serverSidePagination: [{
+                type: Input
+            }], totalElements: [{
+                type: Input
+            }], pageChange: [{
+                type: Output
+            }], enableLocalSort: [{
+                type: Input
+            }], sortChange: [{
+                type: Output
+            }], isTableLoading: [{
+                type: Input
+            }], isTableDataLoading: [{
+                type: Input
+            }], cellJsonPathGetter: [{
+                type: Input
+            }], onJsonPathCopiedHandler: [{
+                type: Input
+            }], selectedItems: [{
+                type: Input
+            }], showSelectAllInToolbar: [{
+                type: Input
+            }], showDismissInToolbar: [{
+                type: Input
+            }], allSelectedInToolbar: [{
+                type: Input
+            }], folders: [{
+                type: Input
+            }], selectedFolderId: [{
+                type: Input
+            }], expandedFolderIds: [{
+                type: Input
+            }], unorganisedCount: [{
+                type: Input
+            }], folderIdAccessor: [{
+                type: Input
+            }], modularConfig: [{
+                type: Input
+            }], modularLabels: [{
+                type: Input
+            }], bulkActions: [{
+                type: Input
+            }], sidebarCollapsed: [{
+                type: Input
+            }], useInternalDialogs: [{
+                type: Input
+            }], folderSelected: [{
+                type: Output
+            }], folderExpansionToggled: [{
+                type: Output
+            }], folderCreated: [{
+                type: Output
+            }], folderCreateRequested: [{
+                type: Output
+            }], folderRenamed: [{
+                type: Output
+            }], folderDeleted: [{
+                type: Output
+            }], testsMoved: [{
+                type: Output
+            }], bulkActionClick: [{
+                type: Output
+            }], bulkSelectAllChange: [{
+                type: Output
+            }], bulkDismiss: [{
+                type: Output
+            }], bulkActionInvoked: [{
+                type: Output
+            }], sidebarCollapsedChange: [{
+                type: Output
+            }], showReorderButton: [{
+                type: Input
+            }], reorderSaving: [{
+                type: Input
+            }], reorderLabels: [{
+                type: Input
+            }], reorderStart: [{
+                type: Output
+            }], reorderCancel: [{
+                type: Output
+            }], reorderSave: [{
+                type: Output
+            }], moveRequested: [{
+                type: Output
+            }], selectedItemsChange: [{
+                type: Output
+            }], folderDeleteRequested: [{
+                type: Output
+            }], folderMoveRequested: [{
+                type: Output
+            }], folderMoved: [{
+                type: Output
+            }], folderDuplicateRequested: [{
+                type: Output
+            }], onReload: [{
+                type: Output
+            }], onAutoRefreshClick: [{
+                type: Output
+            }], columnVisibilityChange: [{
+                type: Output
+            }], autoRefreshIntervalChange: [{
+                type: Output
+            }], dynamicFilterComponent: [{
+                type: ViewChild,
+                args: [DynamicFilterComponent]
+            }], columnVisibility: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"modular-table-template.component.js","sourceRoot":"","sources":["../../../../../../src/lib/templates/modular-table-template/modular-table-template.component.ts","../../../../../../src/lib/templates/modular-table-template/modular-table-template.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  Component,\n  Input,\n  Output,\n  EventEmitter,\n  OnChanges,\n  OnInit,\n  SimpleChanges,\n  OnDestroy,\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  TemplateRef,\n  ViewChild,\n} from '@angular/core';\nimport { DynamicFilterItem, DynamicFilterComponent } from '../../filters/dynamic-filter/dynamic-filter.component';\nimport { DynamicTableColumn } from '../../table/dynamic-table/dynamic-table.component';\nimport { ColumnVisibilityConfig } from '../../column-visibility/column-visibility.component';\nimport { TableAction } from '../../table-action-toolbar/table-action-toolbar.component';\nimport { EmptyStateConfig } from '../../empty-state/empty-state-config.interface';\nimport { EMPTY_STATE_IMAGES } from '../../assets/images/image-assets.constants';\nimport { DialogService } from '../../dialog/dialog.service';\nimport {\n  DEFAULT_MODULAR_CONFIG,\n  DEFAULT_MODULAR_LABELS,\n  DEFAULT_REORDER_LABELS,\n  FolderCreatedPayload,\n  FolderDeleteRequestedPayload,\n  FolderDeleteStrategy,\n  FolderDeletedPayload,\n  FolderIdAccessor,\n  FolderNode,\n  FolderRenamedPayload,\n  FolderMoveRequestedPayload,\n  FolderMovedPayload,\n  FolderDuplicateRequestedPayload,\n  ModularConfig,\n  ModularLabels,\n  ReorderLabels,\n  ReorderSavePayload,\n  TestsMovedPayload,\n  BulkActionInvokedPayload,\n} from './modular-table-template.models';\nimport { MoveToFolderDialogComponent } from './dialogs/move-to-folder-dialog.component';\nimport { NewFolderDialogComponent } from './dialogs/new-folder-dialog.component';\nimport { DeleteFolderDialogComponent } from './dialogs/delete-folder-dialog.component';\n\n@Component({\n  selector: 'cqa-modular-table-template',\n  templateUrl: './modular-table-template.component.html',\n  styleUrls: [],\n  host: { class: 'cqa-ui-root' },\n  changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class ModularTableTemplateComponent implements OnInit, OnChanges, OnDestroy {\n  // Search bar inputs\n  @Input() searchPlaceholder: string = 'Search components';\n  @Input() searchValue: string = '';\n  @Input() showClear: boolean = true;\n  @Input() showSearchBar: boolean = true;\n  @Input() showExportButton: boolean = false;\n  @Input() isExporting: boolean = false;\n  // Search bar outputs\n  @Output() onSearchChange = new EventEmitter<string>();\n  @Output() onExportClick = new EventEmitter<{ type: 'local' | 'email'; emails?: string[]; framework?: 'WEBDRIVER_IO' | 'SELENIUM_JAVA'; selectedItems: any[] } | void>();\n  // Filter outputs\n  @Output() onApplyFilterClick = new EventEmitter<any>();\n  @Output() onResetFilterClick = new EventEmitter<void>();\n  @Output() onClearAll = new EventEmitter<void>();\n  @Output() removeChip = new EventEmitter<any>();\n\n  // Filter inputs\n  @Input() filterConfig: DynamicFilterItem[] = [];\n  @Input() filterModel: Record<string, any> = {};\n  @Input() showFilterPanel: boolean = false;\n  @Input() showFilterButton: boolean = true;\n\n  // Other buttons input (array of button templates/components)\n  @Input() otherButtons: TemplateRef<any>[] = [];\n  \n  // Other dropdown buttons input (array of dropdown button templates/components)\n  @Input() otherDropDownButtons: TemplateRef<any>[] = [];\n  \n  // Other select dropdown buttons input (array of select dropdown button templates/components)\n  @Input() otherSelectDropDownButtons: TemplateRef<any>[] = [];\n  \n  // Legacy single button inputs (deprecated, kept for backward compatibility)\n  /** @deprecated Use otherButtons array instead */\n  @Input() otherButtonLabel: string = 'Other Button';\n  /** @deprecated Use otherButtons array instead */\n  @Input() otherButtonVariant: 'filled' | 'outlined' | 'text' | 'elevated' | 'tonal' | 'grey-solid' = 'filled';\n  /** @deprecated Use otherButtons array instead */\n  @Input() showOtherButton: boolean = true;\n  \n  // Action menu button (three-dot menu in table rows)\n  @Input() showActionButton: boolean = true;\n\n  // Settings and refresh buttons\n  @Input() showSettingsButton: boolean = true;\n  @Input() showAutoRefreshButton: boolean = true;\n\n  // View-mode toggle (List | Modular). Hidden by default for backward compatibility.\n  @Input() showViewModeToggle: boolean = false;\n  @Input() viewMode: 'list' | 'modular' = 'list';\n  @Input() viewModeLabels: { list: string; modular: string } = { list: 'List', modular: 'Modular' };\n  @Output() viewModeChange = new EventEmitter<'list' | 'modular'>();\n\n  get viewModeSegments(): Array<{ label: string; value: string; icon?: string }> {\n    return [\n      { label: this.viewModeLabels.list, value: 'list', icon: 'view_list' },\n      { label: this.viewModeLabels.modular, value: 'modular', icon: 'folder' },\n    ];\n  }\n\n  onViewModeChange(value: string): void {\n    const next = value === 'modular' ? 'modular' : 'list';\n    if (next !== this.viewMode) {\n      this.viewMode = next;\n      this.viewModeChange.emit(next);\n    }\n  }\n\n  // Data input\n  @Input() data: any[] = [];\n\n  // Empty state inputs\n  @Input() isEmptyState: boolean = false;\n  @Input() emptyStateConfig: EmptyStateConfig = {\n    title: 'No Data Available Yet',\n    description: 'Run or upload your first test to see your analytics and trends here. Watch your quality metrics come to life with real-time insights.',\n    imageUrl: EMPTY_STATE_IMAGES.DASHBOARD,\n    actions: [{ label: 'Run Test Suite', variant: 'filled' }],\n  };\n\n  // Action bar inputs\n  @Input() actions: TableAction[] = [\n    { \n      id: 'delete', \n      label: 'Delete', \n      icon: 'delete', \n      tooltip: 'Delete selected',\n      onClick: (context) => {\n        console.log('Delete action clicked:', context);\n      }\n    },\n    { \n      id: 'edit', \n      label: 'Edit', \n      icon: 'edit', \n      tooltip: 'Edit selected',\n      onClick: (context) => {\n        console.log('Edit action clicked:', context);\n      }\n    },\n    { \n      id: 'add-tag', \n      label: 'Add Tag', \n      icon: 'local_offer', \n      tooltip: 'Add tags',\n      onClick: (context) => {\n        console.log('Add tag action clicked:', context);\n      }\n    },\n    { \n      id: 'remove-tag', \n      label: 'Remove Tag', \n      icon: 'label_off', \n      tooltip: 'Remove tags',\n      onClick: (context) => {\n        console.log('Remove tag action clicked:', context);\n      }\n    },\n  ];\n\n  // Chips inputs\n  @Input() chips: Array<{ key?: string; label?: string; text: string; fullText?: string; hasMore?: boolean }> = [];\n  @Input() filterApplied: boolean = false;\n\n  // Table inputs\n  @Input() columns: DynamicTableColumn[] = [];\n  @Input() rowSelectable?: (row: any) => boolean;\n  @Input() selectedAutoRefreshInterval: number = 0;\n  @Input() pageIndex: number = 0;\n  @Input() pageSize: number = 10;\n  @Input() pageSizeOptions: number[] = [10, 20, 40, 60, 80];\n  @Input() pageSizeMenuDirection: 'auto' | 'up' | 'down' = 'auto';\n  // Server-side pagination controls\n  @Input() serverSidePagination: boolean = false;\n  @Input() totalElements: number = 0;\n  @Output() pageChange = new EventEmitter<{ pageIndex: number; pageSize: number }>();\n  /**\n   * When false, header sort does not reorder rows locally (use with serverSidePagination + sortChange).\n   * Default true for backward compatibility.\n   */\n  @Input() enableLocalSort: boolean = true;\n  @Output() sortChange = new EventEmitter<{\n    fieldId: string;\n    fieldValue?: string;\n    direction: 'asc' | 'desc' | null;\n  }>();\n  // Loader controls (passed down to dynamic table)\n  @Input() isTableLoading?: boolean;\n  @Input() isTableDataLoading?: boolean;\n  // Backward-compatibility flag; if provided, dynamic table will use it when specific flags are undefined\n\n  // Optional getter for JSON path per cell. When provided, double-clicking a cell copies the path.\n  @Input() cellJsonPathGetter?: (rowIndex: number, colId: string, row: any) => string;\n\n  // Optional handler called when a JSON path is copied from a table cell\n  @Input() onJsonPathCopiedHandler?: (event: { path: string; source: string }) => void;\n\n  // Selected items (full objects) for maintaining selection across pagination (server-side)\n  @Input() selectedItems: any[] = [];\n\n  /**\n   * When true, the action toolbar renders the \"Select all\" affordance. Defaults to false\n   * for now — host opts in. Matches the current product requirement to hide Select All.\n   */\n  @Input() showSelectAllInToolbar: boolean = false;\n  /**\n   * When true, the action toolbar renders the dismiss (×) affordance. Defaults to false\n   * for now — host opts in. Matches the current product requirement to hide Cancel.\n   */\n  @Input() showDismissInToolbar: boolean = false;\n  /** Bound to the toolbar's \"Select all\" checkbox — drives the checked state. */\n  @Input() allSelectedInToolbar: boolean = false;\n\n  // Internal state for column visibility\n  private _columnVisibility: ColumnVisibilityConfig = {};\n  private _cachedVisibilityColumns: Array<{ id: string; label: string }> = [];\n  filteredRows: any[] = [];\n  pagedRows: any[] = [];\n\n  // ============================================================================\n  // Folder / modular inputs\n  // ============================================================================\n  @Input() folders: FolderNode[] = [];\n  @Input() selectedFolderId: number | null = null;\n  @Input() expandedFolderIds: number[] = [];\n  @Input() unorganisedCount: number = 0;\n  @Input() folderIdAccessor: FolderIdAccessor = (row: any) => row?.folderId ?? null;\n  @Input() modularConfig: ModularConfig = { ...DEFAULT_MODULAR_CONFIG };\n  @Input() modularLabels: ModularLabels = { ...DEFAULT_MODULAR_LABELS };\n  @Input() bulkActions: TableAction[] = [];\n  @Input() sidebarCollapsed: boolean = false;\n\n  /**\n   * When true (default), the library opens its own Move dialog for convenience\n   * during testing. Hosts taking over API + UX should set this to `false` and\n   * listen on `moveRequested` to render their own.\n   */\n  @Input() useInternalDialogs: boolean = true;\n\n  // ============================================================================\n  // Folder / modular outputs\n  // ============================================================================\n  @Output() folderSelected = new EventEmitter<number | null>();\n  @Output() folderExpansionToggled = new EventEmitter<{ id: number; expanded: boolean }>();\n  @Output() folderCreated = new EventEmitter<FolderCreatedPayload>();\n  /** Emitted when the user clicks \"+ New folder\"; host should open a creation modal. */\n  @Output() folderCreateRequested = new EventEmitter<{ parentId: number | null }>();\n  @Output() folderRenamed = new EventEmitter<FolderRenamedPayload>();\n  /**\n   * Fires after the user confirms folder deletion via the internal dialog (or\n   * immediately, when `useInternalDialogs` is false and the host drives the UX).\n   * Payload now includes the user's chosen `strategy` for what happens to the\n   * folder's test cases.\n   */\n  @Output() folderDeleted = new EventEmitter<FolderDeletedPayload>();\n  @Output() testsMoved = new EventEmitter<TestsMovedPayload>();\n\n  // ---------------------------------------------------------------------------\n  // Bulk action toolbar surface — naming mirrors cqa-table-template so consumers\n  // get the same events from either component (plus the folder events below).\n  // ---------------------------------------------------------------------------\n\n  /** Fires on raw toolbar action click — *before* any internal dialog opens. */\n  @Output() bulkActionClick = new EventEmitter<{ id: string; selected: any[] }>();\n  /** Fires when the toolbar's \"Select all\" is toggled. */\n  @Output() bulkSelectAllChange = new EventEmitter<boolean>();\n  /** Fires when the toolbar's dismiss (×) is clicked. */\n  @Output() bulkDismiss = new EventEmitter<void>();\n\n  /**\n   * Fires *after* the library-internal move-to-folder dialog resolves with a\n   * user confirmation, OR immediately for non-dialog bulk actions supplied by\n   * the host. Hosts with their own UX should listen on `bulkActionClick` +\n   * `moveRequested` and treat this as the \"confirmed\" signal.\n   */\n  @Output() bulkActionInvoked = new EventEmitter<BulkActionInvokedPayload>();\n\n  @Output() sidebarCollapsedChange = new EventEmitter<boolean>();\n\n  // ============================================================================\n  // Row-reorder surface\n  // ============================================================================\n  /** When true, renders a \"Reorder\" button in the toolbar. Host-driven. */\n  @Input() showReorderButton: boolean = false;\n  /**\n   * Host flips this true while its bulk-update API call is in-flight. The\n   * component keeps the reorder UI pinned (\"Saving...\") while true and exits\n   * reorder mode when it flips back to false (the \"future API call\" hook).\n   */\n  @Input() reorderSaving: boolean = false;\n  /** Partial override for the default reorder labels (\"Reorder\", \"Done\", etc.). */\n  @Input() set reorderLabels(partial: Partial<ReorderLabels> | undefined) {\n    this._reorderLabels = { ...DEFAULT_REORDER_LABELS, ...(partial || {}) };\n  }\n  get reorderLabels(): ReorderLabels {\n    return this._reorderLabels;\n  }\n  private _reorderLabels: ReorderLabels = { ...DEFAULT_REORDER_LABELS };\n\n  /** Fires when the user clicks \"Reorder\" and the component enters reorder mode. */\n  @Output() reorderStart = new EventEmitter<void>();\n  /** Fires when the user clicks \"Cancel\" — the original order is already restored. */\n  @Output() reorderCancel = new EventEmitter<void>();\n  /**\n   * Fires when the user clicks \"Done\". Host should take `orderedItems`, call its\n   * bulk-update API, refresh `[data]`, and flip `reorderSaving` back to `false` —\n   * the component will then exit reorder mode.\n   *\n   * Note: for server-side pagination, `orderedItems` is the *current page slice*,\n   * not the full dataset — same as the in-memory view the user was dragging.\n   */\n  @Output() reorderSave = new EventEmitter<ReorderSavePayload>();\n\n  /** Internal — true while the user is in reorder mode. */\n  isReordering: boolean = false;\n  /** Snapshot of `pagedRows` taken on enter; used to revert on cancel. */\n  private reorderSnapshot: any[] | null = null;\n  /** Draft of the reordered rows (current working state). */\n  private reorderDraft: any[] | null = null;\n  /** Auto-refresh interval captured on enter, so we can restore on cancel/done. */\n  private reorderSavedAutoRefresh: number = 0;\n  /** True after Done has been clicked, awaiting the host's `reorderSaving` → false flip. */\n  private reorderAwaitingSaveFlip: boolean = false;\n\n  /**\n   * Fires when the user clicks the \"Move to folder\" bulk action — *before* the\n   * internal dialog opens. Hosts that want to render their own modal should\n   * set `useInternalDialogs = false` and listen here.\n   */\n  @Output() moveRequested = new EventEmitter<{\n    testIds: Array<string | number>;\n    selected: any[];\n    currentFolderId: number | null;\n    folders: FolderNode[];\n  }>();\n\n  /** Fires whenever the component's `selectedItems` changes from within (Select All / Dismiss). */\n  @Output() selectedItemsChange = new EventEmitter<any[]>();\n\n  /**\n   * Fires when the user clicks a folder's delete affordance — *before* the\n   * internal confirmation dialog opens. Hosts owning the UX listen here.\n   * Payload includes `testCount` + `hasParent` so hosts can render the right\n   * options in their own modal.\n   */\n  @Output() folderDeleteRequested = new EventEmitter<FolderDeleteRequestedPayload>();\n\n  /**\n   * Fires when the user picks \"Move folder\" from a folder row's context menu —\n   * *before* any dialog opens. Hosts owning the UX listen here with\n   * `useInternalDialogs = false` and open their own folder picker.\n   */\n  @Output() folderMoveRequested = new EventEmitter<FolderMoveRequestedPayload>();\n  /**\n   * Fires after the user confirms a folder move via the internal picker\n   * (or immediately when `useInternalDialogs = false` and the host drives it).\n   */\n  @Output() folderMoved = new EventEmitter<FolderMovedPayload>();\n  /**\n   * Fires when the user picks \"Duplicate folder\" from a folder row's context menu.\n   * The library doesn't own persistence, so the host is expected to clone the\n   * folder's subtree server-side and *reference* (not copy) the test cases.\n   */\n  @Output() folderDuplicateRequested = new EventEmitter<FolderDuplicateRequestedPayload>();\n\n  constructor(private cdr: ChangeDetectorRef, private dialogService: DialogService) {}\n  private pendingFilters: any;\n  private appliedFilters: any;\n  private autoRefreshTimer?: ReturnType<typeof setInterval>;\n  @Output() onReload = new EventEmitter<void>();\n  @Output() onAutoRefreshClick = new EventEmitter<void>();\n  @Output() columnVisibilityChange = new EventEmitter<ColumnVisibilityConfig>();\n  @Output() autoRefreshIntervalChange = new EventEmitter<number>();\n  @ViewChild(DynamicFilterComponent) dynamicFilterComponent?: DynamicFilterComponent;\n\n  // Derived columns with visibility applied.\n  computedColumns: DynamicTableColumn[] = [];\n  // Auto-generated visibility columns from columns input\n  visibilityColumns: Array<{ id: string; label: string }> = [];\n\n  private updateComputedColumns(): void {\n    const visibility = this._columnVisibility || {};\n    const source = this.columns || [];\n    this.computedColumns = source.map(col => {\n      if (['checkbox', 'actions'].includes(col.fieldId)) {\n        return col;\n      }\n      const show = visibility[col.fieldId];\n      return { ...col, isShow: show !== false };\n    });\n    this.cdr.markForCheck();\n  }\n\n  private updateVisibilityColumns(): void {\n    this._cachedVisibilityColumns = this.mapVisibilityColumns();\n    this.visibilityColumns = this._cachedVisibilityColumns;\n    this.cdr.markForCheck();\n  }\n\n  // Controlled column visibility: parent can seed and push updates.\n  @Input() set columnVisibility(cfg: ColumnVisibilityConfig | undefined) {\n    if (cfg) {\n      this._columnVisibility = { ...cfg };\n      this.updateComputedColumns();\n      this.cdr.markForCheck();\n    }\n  }\n  get columnVisibility(): ColumnVisibilityConfig {\n    return this._columnVisibility;\n  }\n  ngOnInit(): void {\n    this.initializeComponent();\n    this.updateComputedColumns();\n    this.updateVisibilityColumns();\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    if (changes['data'] || changes['isEmptyState']) {\n      this.initializeComponent();\n    }\n    if (changes['columns']) {\n      this.initializeColumnVisibility();\n      this.updateComputedColumns();\n      this.updateVisibilityColumns();\n    }\n    if (changes['selectedFolderId'] && !changes['selectedFolderId'].firstChange) {\n      // Per the approved plan: clear selection and reset pagination on folder change.\n      this.selectedItems = [];\n      this.pageIndex = 0;\n      this.rebuildFilteredRows();\n      this.applyPagination();\n    }\n    if (changes['viewMode'] && !changes['viewMode'].firstChange) {\n      // Switching between list and modular changes whether the folder filter applies.\n      this.pageIndex = 0;\n      this.rebuildFilteredRows();\n      this.applyPagination();\n    }\n    if (changes['selectedItems'] || changes['data']) {\n      this.restoreSelectionState();\n    }\n    if (changes['reorderSaving'] && !changes['reorderSaving'].firstChange) {\n      const nowSaving = !!changes['reorderSaving'].currentValue;\n      // Host finished its bulk-update call — exit reorder mode.\n      if (!nowSaving && this.reorderAwaitingSaveFlip) {\n        this.exitReorderMode();\n      }\n    }\n  }\n\n  private initializeComponent(): void {\n    if (this.isEmptyState) {\n      this.filteredRows = [];\n      this.pagedRows = [];\n      return;\n    }\n\n    // In server-side mode, assume incoming data is already a page slice\n    if (this.serverSidePagination) {\n      this.filteredRows = [...this.data];\n      this.pagedRows = [...this.filteredRows];\n      this.initializeColumnVisibility();\n      this.restoreSelectionState();\n      return;\n    }\n\n    this.rebuildFilteredRows();\n    this.applyPagination();\n    this.initializeColumnVisibility();\n    this.updateComputedColumns();\n    this.restoreSelectionState();\n  }\n\n  /**\n   * Build `filteredRows` from `data` by applying (a) the field filters (status/priority/etc.)\n   * and (b) the folder filter derived from `selectedFolderId` + `folderIdAccessor`.\n   */\n  private rebuildFilteredRows(): void {\n    const effective = this.appliedFilters ?? {};\n    this.filteredRows = this.data.filter(r => this.passFilters(effective, r) && this.passFolder(r));\n  }\n\n  private passFolder(row: any): boolean {\n    // List view ignores folder filtering entirely — behaves like the traditional flat table.\n    if (!this.isModularView) return true;\n    const folderId = this.folderIdAccessor ? this.folderIdAccessor(row) : row?.folderId;\n    // Root view: show only rows that do not belong to any folder (the \"Unorganised\" bucket).\n    // Folder tiles above the table are the entry point to per-folder contents.\n    if (this.selectedFolderId == null) {\n      return folderId == null;\n    }\n    return folderId != null && String(folderId) === String(this.selectedFolderId);\n  }\n\n  /** True when the component should render the modular (folder-aware) UI. */\n  get isModularView(): boolean {\n    return this.viewMode === 'modular';\n  }\n\n  /**\n   * Get selected IDs from selectedItems (objects)\n   */\n  private getSelectedIds(): Set<number> {\n    if (this.selectedItems && this.selectedItems.length > 0) {\n      return new Set(this.selectedItems.map(item => Number(item.id)).filter(id => !isNaN(id)));\n    }\n    return new Set();\n  }\n\n  private restoreSelectionState(): void {\n    const selectedIdsSet = this.getSelectedIds();\n\n    if (selectedIdsSet.size === 0) {\n      // If no selected IDs, clear all selection states\n      if (this.pagedRows) {\n        this.pagedRows.forEach(row => {\n          if (row) {\n            (row as any).isSelected = false;\n          }\n        });\n      }\n      return;\n    }\n\n    // Restore selection state based on selectedItems\n    if (this.pagedRows) {\n      this.pagedRows.forEach(row => {\n        if (row && row.id !== undefined) {\n          (row as any).isSelected = selectedIdsSet.has(Number(row.id));\n        }\n      });\n    }\n\n    // Also update filteredRows for consistency\n    if (this.filteredRows) {\n      this.filteredRows.forEach(row => {\n        if (row && row.id !== undefined) {\n          (row as any).isSelected = selectedIdsSet.has(Number(row.id));\n        }\n      });\n    }\n\n    this.cdr.markForCheck();\n  }\n\n  private initializeColumnVisibility(): void {\n    // Cache visibility columns to avoid creating new arrays on every change detection\n    this._cachedVisibilityColumns = this.mapVisibilityColumns();\n    // Seed visibility state from each column's isShow (default to true) so consumers\n    // can pre-apply persisted preferences via columns[i].isShow.\n    const source = this.columns || [];\n    for (const col of this._cachedVisibilityColumns) {\n      if (this._columnVisibility[col.id] === undefined) {\n        const srcCol = source.find(c => c.fieldId === col.id);\n        this._columnVisibility[col.id] = srcCol && srcCol.isShow === false ? false : true;\n      }\n    }\n  }\n\n  get anyRowSelected(): boolean {\n    // Check if there are any selected items (either on current page or across all pages via selectedItems)\n    const hasSelectedOnPage = !!(this.pagedRows && this.pagedRows.some(r => !!(r as any).isSelected));\n    const selectedIdsSet = this.getSelectedIds();\n    const hasSelectedAcrossPages = selectedIdsSet.size > 0;\n    return hasSelectedOnPage || hasSelectedAcrossPages;\n  }\n\n  get currentSelectedItems(): any[] {\n    // If selectedItems (full objects) are provided, use them directly\n    // This ensures all selected items are returned, including those from other pages\n    if (this.selectedItems && this.selectedItems.length > 0) {\n      return this.selectedItems;\n    }\n    // Fallback: For client-side pagination or when selectedItems is not provided,\n    // filter pagedRows to get selected items from current page only\n    if (!this.pagedRows || this.pagedRows.length === 0) {\n      return [];\n    }\n\n    const selectedIdsSet = this.getSelectedIds();\n    \n    // Filter rows that are selected\n    return this.pagedRows\n      .filter(r => {\n        if (!r || r.id === undefined) return false;\n        const rowId = Number(r.id);\n        // Include if either:\n        // 1. The row has isSelected = true (current page selection)\n        // 2. The row's ID is in selectedItems (selected on other pages or restored selection)\n        return !!(r as any).isSelected || selectedIdsSet.has(rowId);\n      });\n  }\n\n  actionClick(data: any) {\n    console.log('action toolbar', data);\n  }\n\n  view(id: number | string): void {\n    console.log('View', id);\n  }\n\n  edit(row: any): void {\n    console.log('Edit', row);\n  }\n\n  delete(row: any): void {\n    console.log('Delete', row);\n  }\n\n  toggleFilter(): void {\n    this.showFilterPanel = !this.showFilterPanel;\n  }\n\n  onColumnVisibilityChange(cfg: ColumnVisibilityConfig): void {\n    this._columnVisibility = { ...cfg };\n    this.updateComputedColumns();\n    this.cdr.markForCheck();\n    this.columnVisibilityChange.emit({ ...cfg });\n  }\n\n  onAutoRefreshChange(intervalMs: number): void {\n    this.selectedAutoRefreshInterval = intervalMs;\n    this.setupAutoRefresh(intervalMs);\n    this.autoRefreshIntervalChange.emit(intervalMs);\n    this.triggerReload();\n  }\n\n  valueChange(value: string): void {\n    console.log('Value changed', value);\n    this.onSearchChange.emit(value);\n  }\n\n  search(value: string): void {\n    console.log('Search', value);\n  }\n\n  cleared(): void {\n    console.log('Cleared');\n  }\n\n  onEmptyAction(action: any) {\n    if (action?.label === 'Show filters') {\n      this.toggleFilter();\n    }\n  }\n\n  onFiltersChanged(current: any): void {\n    // Defer applying filters and updating chips until Apply Filter is clicked\n    this.pendingFilters = current;\n  }\n\n  onFiltersApplied(applied: any): void {\n    this.showFilterPanel = false;\n    const effective = applied ?? this.pendingFilters ?? {};\n    this.appliedFilters = effective;\n    this.rebuildFilteredRows();\n    this.pageIndex = 0;\n    this.applyPagination();\n    const chips: Array<{ key?: string; label?: string; text: string; fullText?: string; hasMore?: boolean }> = [];\n    if (effective) {\n      for (const key of Object.keys(effective)) {\n        const value = effective[key];\n        if (value == null || value === '' || (Array.isArray(value) && value.length === 0)) continue;\n        \n        // Find the filter config item for this key\n        const filterConfigItem = this.filterConfig?.find(c => c.key === key);\n        const options = filterConfigItem?.options || [];\n        \n        // Helper function to find display text from options\n        const getDisplayText = (val: any): string => {\n          // If value is already an object with name/label, use it\n          if (val && typeof val === 'object' && (val.name || val.label || val.value)) {\n            return val.name ?? val.label ?? String(val.value ?? val);\n          }\n          \n          // Look up the option in the config\n          const option = options.find((opt: any) => {\n            const optId = opt.id ?? opt.value;\n            const optValue = opt.value;\n            const valStr = String(val);\n            return String(optId) === valStr || String(optValue) === valStr;\n          });\n          \n          if (option) {\n            return option.name ?? option.label ?? String(option.value ?? val);\n          }\n          \n          // Fallback to the raw value\n          return String(val);\n        };\n        \n        let text = '';\n        let label = filterConfigItem?.label;\n        \n        if (Array.isArray(value)) {\n          text = value.map((v: any) => getDisplayText(v)).join(', ');\n        } else if (typeof value === 'object') {\n          if ('start' in value || 'end' in value) {\n            const s = value.start ? new Date(value.start).toLocaleDateString() : '';\n            const e = value.end ? new Date(value.end).toLocaleDateString() : '';\n            text = [s, e].filter(Boolean).join(' - ');\n          } else {\n            text = getDisplayText(value);\n          }\n        } else {\n          text = getDisplayText(value);\n        }\n        chips.push({ key, label, text, fullText: text, hasMore: text.length > 30 });\n      }\n    }\n    this.chips = chips;\n    this.filterApplied = this.chips.length > 0;\n  }\n\n  handleResetFilterClick(): void {\n    // Clear chips and reset filtered data when reset is clicked\n    this.pendingFilters = undefined;\n    this.appliedFilters = undefined;\n    this.chips = [];\n    this.filterApplied = false;\n    this.rebuildFilteredRows();\n    this.pageIndex = 0;\n    this.applyPagination();\n    this.onResetFilterClick.emit();\n  }\n\n  handleRefreshClick(): void {\n    this.onAutoRefreshClick.emit();\n    this.triggerReload();\n  }\n\n  private triggerReload(): void {\n    this.rebuildFilteredRows();\n    this.pageIndex = 0;\n    this.applyPagination();\n    this.onReload.emit();\n  }\n\n  private setupAutoRefresh(intervalMs: number): void {\n    this.clearAutoRefresh();\n    if (intervalMs && intervalMs > 0) {\n      this.autoRefreshTimer = setInterval(() => {\n        this.triggerReload();\n      }, intervalMs);\n    }\n  }\n\n  private clearAutoRefresh(): void {\n    if (this.autoRefreshTimer) {\n      clearInterval(this.autoRefreshTimer);\n      this.autoRefreshTimer = undefined;\n    }\n  }\n\n  ngOnDestroy(): void {\n    this.clearAutoRefresh();\n  }\n\n  onPaginate(e: { pageIndex: number; pageSize: number }): void {\n    this.pageIndex = e.pageIndex;\n    this.pageSize = e.pageSize;\n    if (this.serverSidePagination) {\n      this.pageChange.emit({ pageIndex: this.pageIndex, pageSize: this.pageSize });\n      return;\n    }\n    this.applyPagination();\n  }\n\n  onPageSizeChange(size: number): void {\n    this.pageSize = size;\n    this.pageIndex = 0;\n    if (this.serverSidePagination) {\n      this.pageChange.emit({ pageIndex: this.pageIndex, pageSize: this.pageSize });\n      return;\n    }\n    this.applyPagination();\n  }\n\n  onRemoveChip(chip: any): void {\n    this.chips = this.chips.filter(c => c !== chip);\n    this.filterApplied = this.chips.length > 0;\n    // Emit event to parent component (same pattern as execution tab)\n    this.removeChip.emit(chip);\n  }\n\n  onClearAllChips(): void {\n    this.chips = [];\n    this.filterApplied = false;\n    // Reset the dynamic-filter component form when clearing all chips\n    if (this.dynamicFilterComponent) {\n      this.dynamicFilterComponent.reset();\n    }\n  }\n\n  private applyPagination(): void {\n    if (this.serverSidePagination) {\n      // Server mode: parent supplies already-paginated data\n      this.pagedRows = [...this.filteredRows];\n      return;\n    }\n    const start = this.pageIndex * this.pageSize;\n    const end = start + this.pageSize;\n    this.pagedRows = this.filteredRows.slice(start, end);\n  }\n\n  private mapVisibilityColumns(): Array<{ id: string; label: string }> {\n    return (this.columns || [])\n      .filter(c => c.isDefault === false)\n      .map(c => ({ id: c.fieldId, label: c.fieldName || c.fieldId }));\n  }\n\n  private normalizeDate(d: any): number | null {\n    if (!d) return null;\n    const ts = Date.parse(d);\n    return isNaN(ts) ? null : ts;\n  }\n\n  private passFilters(filters: any, row: any): boolean {\n    if (!filters) return true;\n    if (filters.status && Array.isArray(filters.status) && filters.status.length) {\n      if (!filters.status.includes(row.status)) return false;\n    }\n    if (filters.priority && Array.isArray(filters.priority) && filters.priority.length) {\n      if (!filters.priority.includes(row.priorityName)) return false;\n    }\n    if (filters.testType && Array.isArray(filters.testType) && filters.testType.length) {\n      if (!filters.testType.includes(row.testType)) return false;\n    }\n    if (filters.created_date && (filters.created_date.start || filters.created_date.end)) {\n      const startTs = this.normalizeDate(filters.created_date.start);\n      const endTs = this.normalizeDate(filters.created_date.end);\n      const rowTs = this.normalizeDate(row.createdAt);\n      if (rowTs != null) {\n        if (startTs != null && rowTs < startTs) return false;\n        if (endTs != null && rowTs > endTs) return false;\n      }\n    }\n    return true;\n  }\n\n  trackByTemplateRef(index: number): number {\n    return index;\n  }\n\n  trackByDropdownTemplateRef(index: number): number {\n    return index;\n  }\n\n  trackBySelectDropdownTemplateRef(index: number): number {\n    return index;\n  }\n\n  // Export modal state\n  isExportModalOpen: boolean = false;\n\n  exportCodeClick(): void {\n    // Get selected items\n    const selectedItems = this.currentSelectedItems;\n    if (selectedItems.length === 0) {\n      // Emit event to parent to handle the case when no items are selected\n      this.onExportClick.emit();\n      return;\n    }\n    this.isExportModalOpen = true;\n  }\n\n  closeExportModal(): void {\n    this.isExportModalOpen = false;\n  }\n\n  onExportModalExport(result: { type: 'local' | 'email'; emails?: string[]; framework: 'WEBDRIVER_IO' | 'SELENIUM_JAVA' }): void {\n    this.isExportModalOpen = false;\n    // Emit event to parent with export result\n    this.onExportClick.emit({\n      type: result.type,\n      emails: result.emails,\n      framework: result.framework,\n      selectedItems: this.currentSelectedItems\n    });\n  }\n\n  get selectedCasesForExport(): Array<{ id?: number; name?: string }> {\n    return this.currentSelectedItems.map(item => ({\n      id: item.id,\n      name: item.name || item.title || 'Unnamed'\n    }));\n  }\n  get arrowClasses(): string {\n    const baseClasses = [\n      'cqa-w-4',\n      'cqa-h-4',\n      'cqa-relative',\n      'cqa-transition-transform'\n    ];\n\n    if (this.showFilterPanel) {\n      baseClasses.push('cqa-rotate-180');\n    }\n\n    return baseClasses.join(' ');\n  }\n\n  // ============================================================================\n  // Folder / modular helpers\n  // ============================================================================\n\n  /**\n   * Flat list of root-level folders for the \"Organised\" grid on the root view.\n   */\n  get rootFolderTiles(): FolderNode[] {\n    return this.folders || [];\n  }\n\n  /**\n   * Subfolders of the currently-selected folder (for the \"Subfolders in ...\" grid).\n   */\n  get subfolderTiles(): FolderNode[] {\n    if (this.selectedFolderId == null) return [];\n    const node = this.findFolder(this.folders, this.selectedFolderId);\n    return node?.children ?? [];\n  }\n\n  /**\n   * Breadcrumb trail from \"All folders\" down to the currently-selected folder.\n   */\n  get breadcrumbTrail(): FolderNode[] {\n    if (this.selectedFolderId == null) return [];\n    const trail: FolderNode[] = [];\n    this.buildTrail(this.folders, this.selectedFolderId, trail);\n    return trail;\n  }\n\n  private buildTrail(nodes: FolderNode[], targetId: number, acc: FolderNode[]): boolean {\n    for (const n of nodes || []) {\n      acc.push(n);\n      // Use String() coercion for safety in case ids arrive as either number or\n      // string from different API/test data shapes (e.g. raw JSON parse results).\n      if (String(n.id) === String(targetId)) return true;\n      if (n.children && this.buildTrail(n.children, targetId, acc)) return true;\n      acc.pop();\n    }\n    return false;\n  }\n\n  private findFolder(nodes: FolderNode[], targetId: number): FolderNode | null {\n    for (const n of nodes || []) {\n      if (String(n.id) === String(targetId)) return n;\n      const found = n.children ? this.findFolder(n.children, targetId) : null;\n      if (found) return found;\n    }\n    return null;\n  }\n\n  /**\n   * Whether the component is in \"root\" view (no folder selected). Controls which\n   * sections render on the right-hand pane.\n   */\n  get isRootView(): boolean {\n    return this.selectedFolderId == null;\n  }\n\n  /** The currently-selected folder node (or null at root). */\n  get currentFolderNode(): FolderNode | null {\n    if (this.selectedFolderId == null) return null;\n    return this.findFolder(this.folders, this.selectedFolderId);\n  }\n\n  /** Count of test cases directly under the currently-selected folder (excluding descendants). */\n  get currentFolderDirectCount(): number {\n    if (this.selectedFolderId == null) return 0;\n    return this.filteredRows.length;\n  }\n\n  /**\n   * Renders the empty-state slot when the host explicitly opts in, OR when the\n   * table would otherwise render blank (no loading + no rows). Using a derived\n   * flag keeps the host contract identical to `cqa-table-template` while letting\n   * the modular view show \"No Test Case Found\" out of the box — the earlier ask.\n   */\n  get effectiveIsEmptyState(): boolean {\n    if (this.isEmptyState) return true;\n    if (this.isTableLoading || this.isTableDataLoading) return false;\n    return !this.pagedRows || this.pagedRows.length === 0;\n  }\n\n  /**\n   * Picks the host-provided `emptyStateConfig` when the host flagged the state\n   * itself; otherwise falls back to a library-owned \"No Test Case Found\" config\n   * driven by `modularLabels`.\n   */\n  get effectiveEmptyStateConfig(): EmptyStateConfig {\n    if (this.isEmptyState) return this.emptyStateConfig;\n    return {\n      title: this.modularLabels.emptyNoTestsInFolderTitle,\n      description: this.modularLabels.emptyNoTestsInFolderDescription,\n      imageUrl: EMPTY_STATE_IMAGES.TEST_CASE,\n      actions: [],\n    };\n  }\n\n  onFolderSelected(id: number | null): void {\n    this.selectedFolderId = id;\n    this.selectedItems = [];\n    this.pageIndex = 0;\n    this.rebuildFilteredRows();\n    this.applyPagination();\n    this.folderSelected.emit(id);\n    this.cdr.markForCheck();\n  }\n\n  onFolderExpansionToggled(event: { id: number; expanded: boolean }): void {\n    const set = new Set(this.expandedFolderIds || []);\n    if (event.expanded) {\n      set.add(event.id);\n    } else {\n      set.delete(event.id);\n    }\n    this.expandedFolderIds = Array.from(set);\n    this.folderExpansionToggled.emit(event);\n  }\n\n  onFolderCreated(payload: FolderCreatedPayload): void {\n    this.folderCreated.emit(payload);\n  }\n\n  onFolderCreateRequested(payload: { parentId: number | null }): void {\n    // Emit the \"requested\" event first so a host can intercept when it owns the UX.\n    this.folderCreateRequested.emit(payload);\n    if (!this.useInternalDialogs) return;\n    this.openCreateFolderDialog(payload.parentId);\n  }\n\n  onFolderRenamed(payload: FolderRenamedPayload): void {\n    this.folderRenamed.emit(payload);\n  }\n\n  /**\n   * Wired to the sidebar's `folderDeleted` output — which fires on delete-icon\n   * *click*, not on confirmation. We re-emit a `folderDeleteRequested` event\n   * first (so hosts can intercept) and, when `useInternalDialogs` is enabled,\n   * open the confirmation dialog. `folderDeleted` now only fires after confirm.\n   */\n  onFolderDeleted(payload: { id: number }): void {\n    const ctx = this.buildDeleteContext(payload.id);\n    this.folderDeleteRequested.emit(ctx);\n    if (!this.useInternalDialogs) return;\n    this.openDeleteFolderDialog(ctx);\n  }\n\n  /** Builds the { id, name, testCount, hasParent } payload used by delete events/dialogs. */\n  private buildDeleteContext(folderId: number): FolderDeleteRequestedPayload {\n    const node = this.findFolder(this.folders, folderId);\n    return {\n      id: folderId,\n      name: node?.name ?? '',\n      testCount: this.countTestsInFolder(folderId),\n      hasParent: this.folderHasParent(folderId),\n    };\n  }\n\n  private countTestsInFolder(folderId: number): number {\n    const accessor = this.folderIdAccessor ?? ((r: any) => r?.folderId);\n    return (this.data || []).filter(r => {\n      const id = accessor(r);\n      return id != null && Number(id) === Number(folderId);\n    }).length;\n  }\n\n  /** Returns true when the folder is nested (i.e. not a root-level folder). */\n  private folderHasParent(folderId: number): boolean {\n    return !(this.folders || []).some(n => n.id === folderId);\n  }\n\n  onTestsDropped(event: { testIds: Array<string | number>; targetFolderId: number | null }): void {\n    if (!this.modularConfig.allowTestDragDrop) return;\n    this.testsMoved.emit(event);\n  }\n\n  /**\n   * Folder-to-folder drag-drop. The sidebar has already validated against self/descendant\n   * cycles, so the drop is its own confirmation — we emit `folderMoved` directly without\n   * opening the move dialog. Gated on `allowTestDragDrop` (same flag as test drag-drop).\n   */\n  onFolderDropped(event: { id: number; newParentId: number | null }): void {\n    if (!this.modularConfig.allowTestDragDrop) return;\n    this.folderMoved.emit(event);\n  }\n\n  /**\n   * Sidebar emitted `folderMoveRequested` (user picked \"Move folder\" from the context menu).\n   * We re-emit a richer payload for hosts, and — when running with internal dialogs —\n   * open the existing move-to-folder picker configured for a folder-move (self and\n   * descendants are disabled to prevent cycles).\n   */\n  onFolderMoveRequested(payload: { id: number }): void {\n    const node = this.findFolder(this.folders, payload.id);\n    const ctx: FolderMoveRequestedPayload = {\n      id: payload.id,\n      name: node?.name ?? '',\n      hasParent: this.folderHasParent(payload.id),\n    };\n    this.folderMoveRequested.emit(ctx);\n    if (!this.useInternalDialogs) return;\n    this.openMoveFolderDialog(ctx);\n  }\n\n  /**\n   * Sidebar emitted `folderDuplicateRequested`. The library can't persist —\n   * emit the host-level event so the host clones the subtree server-side.\n   * Test cases should be *referenced* from the new folders, not duplicated.\n   */\n  onFolderDuplicateRequested(payload: { id: number }): void {\n    const node = this.findFolder(this.folders, payload.id);\n    this.folderDuplicateRequested.emit({\n      id: payload.id,\n      name: node?.name ?? '',\n    });\n  }\n\n  onSidebarCollapsedChange(collapsed: boolean): void {\n    this.sidebarCollapsed = collapsed;\n    this.sidebarCollapsedChange.emit(collapsed);\n  }\n\n  toggleSidebar(): void {\n    this.onSidebarCollapsedChange(!this.sidebarCollapsed);\n  }\n\n  /**\n   * Default bulk actions shown in the toolbar merged with any host-supplied\n   * `bulkActions`. Currently only \"Move to folder\" ships by default —\n   * Delete / Add Tag are opt-in per the current product requirement. Hosts\n   * that want them back pass them via `bulkActions`.\n   */\n  get effectiveBulkActions(): TableAction[] {\n    const defaults: TableAction[] = [\n      { id: 'move', label: this.modularLabels.moveToFolder, icon: 'drive_file_move', tooltip: this.modularLabels.moveToFolder },\n    ];\n    const overrides = new Map((this.bulkActions || []).map(a => [a.id, a] as const));\n    const merged = defaults.map(d => overrides.get(d.id) ?? d);\n    for (const extra of this.bulkActions || []) {\n      if (!defaults.some(d => d.id === extra.id)) {\n        merged.push(extra);\n      }\n    }\n    return merged;\n  }\n\n  onBulkAction(event: { id: string; selected: any[] }): void {\n    // Always emit the raw click so hosts owning the UX can intercept early.\n    this.bulkActionClick.emit({ id: event.id, selected: event.selected });\n\n    const selectedIds = (event.selected || []).map(r => r?.id).filter(v => v != null);\n    if (event.id === 'move') {\n      this.openMoveDialog(selectedIds, event.selected);\n      return;\n    }\n    // For non-dialog actions (custom entries from host-supplied `bulkActions`), invoke immediately.\n    this.bulkActionInvoked.emit({ id: event.id, selected: event.selected });\n  }\n\n  onBulkSelectAll(checked: boolean): void {\n    // Apply the action locally so the action toolbar's \"Select all\" works out-of-the-box.\n    // When checked, select every row in the *current* filtered set (i.e. all tests in\n    // the selected folder). When unchecked, clear selection.\n    this.selectedItems = checked ? [...this.filteredRows] : [];\n    this.restoreSelectionState();\n    this.selectedItemsChange.emit([...this.selectedItems]);\n    this.bulkSelectAllChange.emit(checked);\n    this.cdr.markForCheck();\n  }\n\n  onBulkDismiss(): void {\n    // Clear selection AND the per-row isSelected flags so the action toolbar closes\n    // (it's gated on `anyRowSelected`, which reads both selectedItems and row flags).\n    this.selectedItems = [];\n    this.restoreSelectionState();\n    this.selectedItemsChange.emit([]);\n    this.bulkDismiss.emit();\n    this.cdr.markForCheck();\n  }\n\n  private openMoveDialog(testIds: Array<string | number>, selected: any[]): void {\n    // Fire the \"requested\" event first so a host can intercept when it owns the UX.\n    this.moveRequested.emit({\n      testIds,\n      selected,\n      currentFolderId: this.selectedFolderId,\n      folders: this.folders,\n    });\n    if (!this.useInternalDialogs) return;\n\n    const count = testIds.length;\n    const description = (count === 1\n      ? this.modularLabels.moveDialogDescriptionSingular\n      : this.modularLabels.moveDialogDescriptionPlural\n    ).replace('{n}', '' + count);\n    const ref = this.dialogService.open<any, number | null>({\n      title: this.modularLabels.moveDialogTitle,\n      description,\n      width: '500px',\n      content: {\n        type: 'component',\n        component: MoveToFolderDialogComponent,\n        inputs: {\n          folders: this.folders,\n          labels: this.modularLabels,\n          currentFolderId: this.selectedFolderId,\n        },\n      },\n      buttons: [\n        { label: this.modularLabels.moveDialogCancel, role: 'secondary', handler: r => r.close(undefined as any) },\n        {\n          label: this.modularLabels.moveDialogConfirm,\n          role: 'primary',\n          handler: r => {\n            const instance = r.getComponentInstance<MoveToFolderDialogComponent>();\n            r.close(instance ? instance.pickedFolderId : null);\n          },\n        },\n      ],\n      buttonAlignment: 'right',\n    });\n    ref.afterClosed().subscribe(targetFolderId => {\n      if (targetFolderId === undefined) return; // cancelled\n      this.testsMoved.emit({ testIds, targetFolderId: targetFolderId ?? null });\n      this.bulkActionInvoked.emit({ id: 'move', selected });\n    });\n  }\n\n  /**\n   * Opens the folder-picker dialog configured for moving a folder (rather than tests).\n   * The source folder itself is marked as the \"current\" folder so it's rendered as\n   * disabled in the picker. On confirm, emits `folderMoved` with the chosen parent.\n   */\n  private openMoveFolderDialog(ctx: FolderMoveRequestedPayload): void {\n    const ref = this.dialogService.open<any, number | null | undefined>({\n      title: this.modularLabels.folderMenuMove,\n      width: '500px',\n      content: {\n        type: 'component',\n        component: MoveToFolderDialogComponent,\n        inputs: {\n          folders: this.folders,\n          labels: this.modularLabels,\n          // Reuse the \"disabled\" treatment: the folder being moved can't be its own destination.\n          currentFolderId: ctx.id,\n        },\n      },\n      buttons: [\n        { label: this.modularLabels.moveDialogCancel, role: 'secondary', handler: r => r.close(undefined as any) },\n        {\n          label: this.modularLabels.moveDialogConfirm,\n          role: 'primary',\n          handler: r => {\n            const instance = r.getComponentInstance<MoveToFolderDialogComponent>();\n            r.close(instance ? instance.pickedFolderId : null);\n          },\n        },\n      ],\n      buttonAlignment: 'right',\n    });\n    ref.afterClosed().subscribe(targetFolderId => {\n      if (targetFolderId === undefined) return; // cancelled\n      this.folderMoved.emit({ id: ctx.id, newParentId: targetFolderId ?? null });\n    });\n  }\n\n  private openCreateFolderDialog(initialParentId: number | null): void {\n    const ref = this.dialogService.open<any, { name: string; parentId: number | null; color: string } | false>({\n      title: this.modularLabels.newFolderDialogTitle,\n      description: this.modularLabels.newFolderDialogDescription,\n      width: '500px',\n      content: {\n        type: 'component',\n        component: NewFolderDialogComponent,\n        inputs: {\n          folders: this.folders,\n          labels: this.modularLabels,\n          name: '',\n          parentId: initialParentId,\n        },\n      },\n      buttons: [\n        { label: this.modularLabels.newFolderDialogCancel, role: 'secondary', handler: r => r.close(false) },\n        {\n          label: this.modularLabels.newFolderDialogConfirm,\n          role: 'primary',\n          handler: r => {\n            const inst = r.getComponentInstance<NewFolderDialogComponent>();\n            if (!inst || !inst.isValid) return false; // keep the dialog open on invalid submit\n            r.close({ name: (inst.name || '').trim(), parentId: inst.parentId, color: inst.color });\n            return;\n          },\n        },\n      ],\n      buttonAlignment: 'right',\n    });\n    ref.afterClosed().subscribe(result => {\n      if (result) {\n        this.folderCreated.emit({ parentId: result.parentId, name: result.name, color: result.color });\n      }\n    });\n  }\n\n  private openDeleteFolderDialog(ctx: FolderDeleteRequestedPayload): void {\n    const ref = this.dialogService.open<any, { strategy: FolderDeleteStrategy } | false>({\n      title: this.modularLabels.deleteFolderDialogTitle,\n      width: '500px',\n      content: {\n        type: 'component',\n        component: DeleteFolderDialogComponent,\n        inputs: {\n          folderName: ctx.name,\n          testCount: ctx.testCount,\n          hasParent: ctx.hasParent,\n          labels: this.modularLabels,\n          strategy: ctx.hasParent ? 'move-to-parent' : 'move-to-unorganised',\n        },\n      },\n      buttons: [\n        { label: this.modularLabels.deleteFolderDialogCancel, role: 'secondary', handler: r => r.close(false) },\n        {\n          label: this.modularLabels.deleteFolderDialogConfirm,\n          role: 'warn',\n          handler: r => {\n            const inst = r.getComponentInstance<DeleteFolderDialogComponent>();\n            r.close(inst ? { strategy: inst.strategy } : false);\n          },\n        },\n      ],\n      buttonAlignment: 'right',\n    });\n    ref.afterClosed().subscribe(result => {\n      if (result) {\n        this.folderDeleted.emit({ id: ctx.id, strategy: result.strategy });\n      }\n    });\n  }\n\n  // ============================================================================\n  // Row-reorder handlers\n  // ============================================================================\n\n  startReorder(): void {\n    if (this.isReordering) return;\n    this.reorderSnapshot = [...(this.pagedRows || [])];\n    this.reorderDraft = [...(this.pagedRows || [])];\n    // Pause auto-refresh while reordering — avoids the timer clobbering the draft.\n    this.reorderSavedAutoRefresh = this.selectedAutoRefreshInterval;\n    if (this.reorderSavedAutoRefresh > 0) {\n      this.setupAutoRefresh(0);\n    }\n    this.isReordering = true;\n    this.reorderAwaitingSaveFlip = false;\n    this.reorderStart.emit();\n    this.cdr.markForCheck();\n  }\n\n  cancelReorder(): void {\n    if (!this.isReordering) return;\n    // Restore the original page order so the user sees the pre-drag state.\n    if (this.reorderSnapshot) {\n      this.pagedRows = [...this.reorderSnapshot];\n    }\n    this.exitReorderMode();\n    this.reorderCancel.emit();\n  }\n\n  saveReorder(): void {\n    if (!this.isReordering) return;\n    const ordered = this.reorderDraft ? [...this.reorderDraft] : [...(this.pagedRows || [])];\n    this.reorderAwaitingSaveFlip = true;\n    this.reorderSave.emit({ orderedItems: ordered });\n    // If the host never flips `reorderSaving` (e.g. synchronous no-op), exit\n    // immediately so the UI doesn't get stuck in \"Saving...\" state.\n    if (!this.reorderSaving) {\n      // Give the host a microtask to flip `reorderSaving` to true — if it\n      // hasn't, assume no async work and exit.\n      Promise.resolve().then(() => {\n        if (this.reorderAwaitingSaveFlip && !this.reorderSaving) {\n          this.exitReorderMode();\n        }\n      });\n    }\n  }\n\n  onRowReorder(event: { previousIndex: number; currentIndex: number; orderedData: any[] }): void {\n    if (!this.isReordering) return;\n    this.reorderDraft = [...event.orderedData];\n    this.pagedRows = this.reorderDraft;\n    this.cdr.markForCheck();\n  }\n\n  private exitReorderMode(): void {\n    this.isReordering = false;\n    this.reorderSnapshot = null;\n    this.reorderDraft = null;\n    this.reorderAwaitingSaveFlip = false;\n    // Restore previously-selected auto-refresh interval (if any).\n    if (this.reorderSavedAutoRefresh > 0) {\n      this.setupAutoRefresh(this.reorderSavedAutoRefresh);\n      this.reorderSavedAutoRefresh = 0;\n    }\n    this.cdr.markForCheck();\n  }\n\n  /**\n   * Row-drag payload builder used by the [cqaRowDrag] directive via (buildPayload).\n   */\n  buildRowDragPayload = (row: any): Array<string | number> => {\n    const selected = this.currentSelectedItems;\n    // If the dragged row is part of the current selection, drag the whole selection.\n    const rowId = row?.id;\n    const inSelection = rowId != null && selected.some(s => s?.id === rowId);\n    const ids = (inSelection ? selected : [row]).map(r => r?.id).filter(v => v != null);\n    return ids;\n  };\n}\n","<!-- Reusable folder-icon chip. Render via <ng-container *ngTemplateOutlet=\"folderIconChip\"></ng-container>. -->\n<ng-template #folderIconChip>\n  <span class=\"cqa-inline-flex cqa-items-center cqa-justify-center cqa-w-10 cqa-h-10 cqa-rounded-[10px] cqa-bg-neutral-100 cqa-shrink-0\">\n    <svg width=\"17\" height=\"15\" viewBox=\"0 0 17 15\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\" aria-hidden=\"true\">\n      <path d=\"M15.6375 12.6377C15.6375 13.0355 15.4794 13.4171 15.1981 13.6984C14.9168 13.9797 14.5353 14.1377 14.1375 14.1377H2.13745C1.73963 14.1377 1.3581 13.9797 1.07679 13.6984C0.795486 13.4171 0.637451 13.0355 0.637451 12.6377V2.1377C0.637451 1.73987 0.795486 1.35834 1.07679 1.07704C1.3581 0.795731 1.73963 0.637695 2.13745 0.637695H5.88745L7.38745 2.8877H14.1375C14.5353 2.8877 14.9168 3.04573 15.1981 3.32704C15.4794 3.60834 15.6375 3.98987 15.6375 4.3877V12.6377Z\" stroke=\"#6D6D74\" stroke-width=\"1.275\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\n    </svg>\n  </span>\n</ng-template>\n\n<!-- Reusable \"+\" chip used by the \"New folder\" tile. -->\n<ng-template #addIconChip>\n  <span class=\"cqa-inline-flex cqa-items-center cqa-justify-center cqa-w-10 cqa-h-10 cqa-rounded-[10px] cqa-bg-neutral-100 cqa-shrink-0\">\n    <svg width=\"16\" height=\"16\" viewBox=\"0 0 16 16\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\" aria-hidden=\"true\">\n      <path d=\"M8 3V13M3 8H13\" stroke=\"#6D6D74\" stroke-width=\"1.275\" stroke-linecap=\"round\"/>\n    </svg>\n  </span>\n</ng-template>\n\n<div class=\"cqa-ui-root\">\n  <div class=\"cqa-w-full cqa-flex cqa-flex-col cqa-relative\">\n    <div [class]=\"!showSearchBar ? 'cqa-justify-end' : 'cqa-justify-between'\" class=\"cqa-w-full cqa-flex cqa-items-center cqa-gap-3 cqa-flex-wrap cqa-mb-3\">\n      <cqa-search-bar\n        *ngIf=\"showSearchBar\"\n        [placeholder]=\"searchPlaceholder\"\n        [value]=\"searchValue\"\n        [showClear]=\"showClear\"\n        (valueChange)=\"valueChange($event)\"\n        (search)=\"search($event)\"\n        (cleared)=\"cleared()\"\n      ></cqa-search-bar>\n      <div class=\"cqa-flex cqa-items-center cqa-gap-2 cqa-flex-wrap\">\n        <cqa-button\n        *ngIf=\"showExportButton\"\n        variant=\"grey-solid\"\n        icon=\"open_in_new\"\n        [text]=\"isExporting ? 'Exporting...' : 'Export'\"\n        [disabled]=\"isExporting\"\n        (clicked)=\"exportCodeClick()\"\n      >\n        <span>{{ isExporting ? 'Exporting...' : 'Export' }}</span>\n      </cqa-button>\n      \n      <!-- Export Code Modal -->\n      <cqa-export-code-modal\n        *ngIf=\"showExportButton\"\n        [isOpen]=\"isExportModalOpen\"\n        [cases]=\"selectedCasesForExport\"\n        [disabled]=\"false\"\n        (closeModal)=\"closeExportModal()\"\n        (export)=\"onExportModalExport($event)\">\n      </cqa-export-code-modal>\n         <ng-container *ngFor=\"let dropdownTemplate of otherDropDownButtons; trackBy: trackByDropdownTemplateRef\">\n          <ng-container *ngTemplateOutlet=\"dropdownTemplate\"></ng-container>\n        </ng-container>\n\n        <ng-container *ngFor=\"let selectDropdownTemplate of otherSelectDropDownButtons; trackBy: trackBySelectDropdownTemplateRef\">\n          <ng-container *ngTemplateOutlet=\"selectDropdownTemplate\"></ng-container>\n        </ng-container>\n        \n        <cqa-button\n          *ngIf=\"showFilterButton\"\n          variant=\"grey-solid\"\n          icon=\"add\"\n          [disabled]=\"isReordering\"\n          (clicked)=\"toggleFilter()\"\n        >\n        <span class=\"cqa-flex cqa-items-center cqa-gap-1\">\n          Filter          \n           <div [class]=\"arrowClasses\">\n            <svg\n              class=\"cqa-w-2 cqa-h-1 cqa-absolute cqa-left-[4px] cqa-top-[6px]\"\n              viewBox=\"0 0 8 4\"\n              fill=\"none\"\n              xmlns=\"http://www.w3.org/2000/svg\"\n            >\n              <path\n                d=\"M0 0L4 4L8 0\"\n                stroke=\"#0B0B0C\"\n                stroke-width=\"1.33\"\n                stroke-linecap=\"round\"\n                stroke-linejoin=\"round\"\n              />\n            </svg>\n          </div>\n        </span>\n        </cqa-button>\n        <cqa-column-visibility\n          *ngIf=\"showSettingsButton\"\n          [columns]=\"visibilityColumns\"\n          [columnVisibility]=\"columnVisibility\"\n          [selectedAutoRefreshInterval]=\"selectedAutoRefreshInterval\"\n          (columnVisibilityChange)=\"onColumnVisibilityChange($event)\"\n          (autoRefreshChange)=\"onAutoRefreshChange($event)\"\n        ></cqa-column-visibility>\n        <cqa-button\n          *ngIf=\"showAutoRefreshButton\"\n          variant=\"grey-solid\"\n          icon=\"refresh\"\n          (clicked)=\"handleRefreshClick()\"\n          [tooltip]=\"'Refresh'\"\n          tooltipPosition=\"below\"\n          [disabled]=\"isReordering\"\n        ></cqa-button>\n        <ng-container *ngFor=\"let buttonTemplate of otherButtons; trackBy: trackByTemplateRef\">\n          <ng-container *ngTemplateOutlet=\"buttonTemplate\"></ng-container>\n        </ng-container>\n        <cqa-segment-control\n          *ngIf=\"showViewModeToggle\"\n          size=\"lg\"\n          [segments]=\"viewModeSegments\"\n          [value]=\"viewMode\"\n          (valueChange)=\"onViewModeChange($event)\"\n        ></cqa-segment-control>\n        <cqa-button\n          *ngIf=\"showReorderButton && !isReordering\"\n          variant=\"outlined\"\n          icon=\"drag_indicator\"\n          [text]=\"reorderLabels.reorderButton\"\n          [disabled]=\"!pagedRows || pagedRows.length === 0 || isTableLoading || isTableDataLoading\"\n          (clicked)=\"startReorder()\"\n        ></cqa-button>\n        <ng-container *ngIf=\"showReorderButton && isReordering\">\n          <cqa-button\n            variant=\"outlined\"\n            [text]=\"reorderLabels.cancelButton\"\n            [disabled]=\"reorderSaving\"\n            (clicked)=\"cancelReorder()\"\n          ></cqa-button>\n          <cqa-button\n            variant=\"filled\"\n            [icon]=\"reorderSaving ? 'hourglass_empty' : ''\"\n            [text]=\"reorderSaving ? reorderLabels.savingButton : reorderLabels.doneButton\"\n            [disabled]=\"reorderSaving\"\n            (clicked)=\"saveReorder()\"\n          ></cqa-button>\n        </ng-container>\n      </div>\n    </div>\n\n    <!-- Reorder mode banner -->\n    <div *ngIf=\"isReordering\" class=\"cqa-flex cqa-items-center cqa-gap-2 cqa-mb-3 cqa-px-3 cqa-py-2 cqa-rounded-md cqa-bg-[#FFFBEB] cqa-border cqa-border-[#FDE68A]\">\n      <svg width=\"16\" height=\"16\" viewBox=\"0 0 16 16\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\" aria-hidden=\"true\">\n        <circle cx=\"3\" cy=\"3\" r=\"1.5\" fill=\"#92400E\"></circle>\n        <circle cx=\"8\" cy=\"3\" r=\"1.5\" fill=\"#92400E\"></circle>\n        <circle cx=\"13\" cy=\"3\" r=\"1.5\" fill=\"#92400E\"></circle>\n        <circle cx=\"3\" cy=\"8\" r=\"1.5\" fill=\"#92400E\"></circle>\n        <circle cx=\"8\" cy=\"8\" r=\"1.5\" fill=\"#92400E\"></circle>\n        <circle cx=\"13\" cy=\"8\" r=\"1.5\" fill=\"#92400E\"></circle>\n        <circle cx=\"3\" cy=\"13\" r=\"1.5\" fill=\"#92400E\"></circle>\n        <circle cx=\"8\" cy=\"13\" r=\"1.5\" fill=\"#92400E\"></circle>\n        <circle cx=\"13\" cy=\"13\" r=\"1.5\" fill=\"#92400E\"></circle>\n      </svg>\n      <span class=\"cqa-text-sm cqa-font-semibold cqa-text-[#92400E]\">{{ reorderLabels.bannerTitle }}</span>\n      <span class=\"cqa-text-sm cqa-text-[#92400E]\">{{ reorderLabels.bannerDescription }}</span>\n    </div>\n\n    <cqa-selected-filters\n      [filterApplied]=\"filterApplied\"\n      [chips]=\"chips\"\n      (removeChip)=\"onRemoveChip($event)\"\n      (clearAll)=\"onClearAllChips()\"\n      (onClearAll)=\"onClearAll.emit()\"\n    >\n    </cqa-selected-filters>\n\n    <cqa-dynamic-filter\n      *ngIf=\"showFilterPanel\"\n      [config]=\"filterConfig\"\n      [model]=\"filterModel\"\n      [showFilterPanel]=\"showFilterPanel\"\n      (filtersChanged)=\"onFiltersChanged($event)\"\n      (filtersApplied)=\"onFiltersApplied($event)\"\n      (onApplyFilterClick)=\"onApplyFilterClick.emit($event)\"\n      (onResetFilterClick)=\"handleResetFilterClick()\"\n    >\n    </cqa-dynamic-filter>\n\n    <div class=\"cqa-flex cqa-items-stretch cqa-gap-3 cqa-min-h-0\">\n      <!-- Sidebar (only shown in modular view) -->\n      <cqa-folder-sidebar\n        *ngIf=\"isModularView && modularConfig.showSidebar\"\n        [folders]=\"folders\"\n        [selectedFolderId]=\"selectedFolderId\"\n        [expandedFolderIds]=\"expandedFolderIds\"\n        [unorganisedCount]=\"unorganisedCount\"\n        [allowCreate]=\"modularConfig.allowCreateFolder\"\n        [allowRename]=\"modularConfig.allowRenameFolder\"\n        [allowDelete]=\"modularConfig.allowDeleteFolder\"\n        [allowDrop]=\"modularConfig.allowTestDragDrop\"\n        [showCounts]=\"modularConfig.showCounts\"\n        [collapsed]=\"sidebarCollapsed\"\n        [labels]=\"modularLabels\"\n        (folderSelected)=\"onFolderSelected($event)\"\n        (folderExpansionToggled)=\"onFolderExpansionToggled($event)\"\n        (folderCreated)=\"onFolderCreated($event)\"\n        (folderCreateRequested)=\"onFolderCreateRequested($event)\"\n        (folderRenamed)=\"onFolderRenamed($event)\"\n        (folderDeleted)=\"onFolderDeleted($event)\"\n        (folderMoveRequested)=\"onFolderMoveRequested($event)\"\n        (folderDuplicateRequested)=\"onFolderDuplicateRequested($event)\"\n        (testsDropped)=\"onTestsDropped($event)\"\n        (folderDropped)=\"onFolderDropped($event)\"\n        (collapsedChange)=\"onSidebarCollapsedChange($event)\"\n      ></cqa-folder-sidebar>\n\n      <!-- Right pane -->\n      <div class=\"cqa-flex-1 cqa-flex cqa-flex-col cqa-min-w-0\">\n        <!-- Breadcrumb (modular view, folder drilled-in) -->\n        <nav\n          *ngIf=\"isModularView && modularConfig.showBreadcrumb && !isRootView\"\n          aria-label=\"Folder path\"\n          class=\"cqa-flex cqa-items-center cqa-gap-1 cqa-text-sm cqa-text-neutral-600 cqa-mb-3\"\n        >\n          <button type=\"button\" class=\"hover:cqa-text-indigo-600\" (click)=\"onFolderSelected(null)\">\n            <mat-icon class=\"cqa-align-middle\" style=\"font-size:16px;width:16px;height:16px\">folder_open</mat-icon>\n            <span class=\"cqa-align-middle cqa-ml-1\">{{ modularLabels.allFolders }}</span>\n          </button>\n          <ng-container *ngFor=\"let crumb of breadcrumbTrail; let last = last\">\n            <span class=\"cqa-text-neutral-400\">/</span>\n            <button\n              type=\"button\"\n              class=\"hover:cqa-text-indigo-600\"\n              [class.cqa-text-neutral-900]=\"last\"\n              [class.cqa-font-semibold]=\"last\"\n              [disabled]=\"last\"\n              (click)=\"!last && onFolderSelected(crumb.id)\"\n            >{{ crumb.name }}</button>\n          </ng-container>\n        </nav>\n\n        <!-- Folder grid: modular + root view -->\n        <section\n          *ngIf=\"isModularView && isRootView && modularConfig.showFolderGrid && rootFolderTiles.length\"\n          class=\"cqa-mb-4\"\n        >\n          <div class=\"cqa-flex cqa-items-center cqa-gap-2 cqa-mb-2\">\n            <mat-icon class=\"cqa-text-neutral-600\" style=\"font-size:16px;width:16px;height:16px\">folder</mat-icon>\n            <h3 class=\"cqa-text-sm cqa-font-semibold cqa-text-neutral-800\">{{ modularLabels.organised }}</h3>\n            <span class=\"cqa-text-xs cqa-text-neutral-500\">\n              {{ rootFolderTiles.length === 1 ? modularLabels.foldersCountSingular : modularLabels.foldersCountPlural.replace('{n}', '' + rootFolderTiles.length) }}\n            </span>\n          </div>\n          <div class=\"cqa-flex cqa-flex-nowrap cqa-gap-3 cqa-overflow-x-auto cqa-scrollbar-thin cqa-pb-2\">\n            <button\n              *ngFor=\"let f of rootFolderTiles\"\n              type=\"button\"\n              [cqaFolderDrop]=\"f.id\"\n              [dropEnabled]=\"modularConfig.allowTestDragDrop\"\n              (testsDropped)=\"onTestsDropped($event)\"\n              (click)=\"onFolderSelected(f.id)\"\n              class=\"cqa-shrink-0 cqa-w-[240px] cqa-flex cqa-items-center cqa-justify-between cqa-gap-3 cqa-text-left cqa-p-3 cqa-rounded-[10px] cqa-border-solid cqa-border-[0.5px] cqa-border-[#E2E2E3] cqa-bg-white hover:cqa-border-[#D8D9FC] hover:cqa-shadow-sm cqa-transition-colors\"\n            >\n              <div class=\"cqa-flex cqa-items-center cqa-gap-3 cqa-min-w-0\">\n                <ng-container *ngTemplateOutlet=\"folderIconChip\"></ng-container>\n                <div class=\"cqa-flex cqa-flex-col cqa-min-w-0\">\n                  <span class=\"cqa-text-base cqa-font-semibold cqa-text-neutral-900 cqa-truncate cqa-leading-tight\">{{ f.name }}</span>\n                  <span *ngIf=\"modularConfig.showCounts\" class=\"cqa-text-sm cqa-text-neutral-500 cqa-truncate\">\n                    {{ (f.count ?? 0) === 1 ? modularLabels.testsCountSingular : modularLabels.testsCountPlural.replace('{n}', '' + (f.count ?? 0)) }}<ng-container *ngIf=\"f.children?.length\"> · {{ f.children!.length === 1 ? modularLabels.oneSubfolder : modularLabels.subfoldersCount.replace('{n}', '' + f.children!.length) }}</ng-container>\n                  </span>\n                </div>\n              </div>\n              <mat-icon class=\"cqa-text-neutral-400 cqa-shrink-0\" style=\"font-size:20px;width:20px;height:20px\">chevron_right</mat-icon>\n            </button>\n\n            <!-- \"+ New folder\" tile -->\n            <button\n              *ngIf=\"modularConfig.allowCreateFolder\"\n              type=\"button\"\n              (click)=\"onFolderCreateRequested({ parentId: null })\"\n              class=\"cqa-shrink-0 cqa-w-[240px] cqa-flex cqa-items-center cqa-gap-3 cqa-text-left cqa-p-3 cqa-rounded-[10px] cqa-border-solid cqa-border-[0.5px] cqa-border-[#E2E2E3] cqa-bg-neutral-50 hover:cqa-border-[#D8D9FC] hover:cqa-bg-white cqa-transition-colors\"\n            >\n              <ng-container *ngTemplateOutlet=\"addIconChip\"></ng-container>\n              <div class=\"cqa-flex cqa-flex-col cqa-min-w-0\">\n                <span class=\"cqa-text-base cqa-font-semibold cqa-text-neutral-600 cqa-truncate cqa-leading-tight\">{{ modularLabels.newFolder }}</span>\n                <span class=\"cqa-text-sm cqa-text-neutral-400\">{{ modularLabels.testsCountPlural.replace('{n}', '0') }}</span>\n              </div>\n            </button>\n          </div>\n        </section>\n\n        <!-- Subfolder section: modular + folder view. Shown whenever drilled in (even if no subfolders, so the \"+ New folder\" tile remains reachable). -->\n        <section\n          *ngIf=\"isModularView && !isRootView && modularConfig.showSubfolderSection && subfolderTiles.length\"\n          class=\"cqa-mb-4\"\n        >\n          <div *ngIf=\"subfolderTiles.length || modularConfig.allowCreateFolder\" class=\"cqa-text-sm cqa-text-neutral-600 cqa-mb-2\">\n            {{ modularLabels.subfoldersIn }} {{ breadcrumbTrail.length ? breadcrumbTrail[breadcrumbTrail.length - 1].name : '' }}\n          </div>\n          <div class=\"cqa-flex cqa-flex-nowrap cqa-gap-3 cqa-overflow-x-auto cqa-scrollbar-thin cqa-pb-2\">\n            <button\n              *ngFor=\"let f of subfolderTiles\"\n              type=\"button\"\n              [cqaFolderDrop]=\"f.id\"\n              [dropEnabled]=\"modularConfig.allowTestDragDrop\"\n              (testsDropped)=\"onTestsDropped($event)\"\n              (click)=\"onFolderSelected(f.id)\"\n              class=\"cqa-shrink-0 cqa-w-[240px] cqa-flex cqa-items-center cqa-justify-between cqa-gap-3 cqa-text-left cqa-p-3 cqa-rounded-[10px] cqa-border-solid cqa-border-[0.5px] cqa-border-[#E2E2E3] cqa-bg-white hover:cqa-border-[#D8D9FC] hover:cqa-shadow-sm cqa-transition-colors\"\n            >\n              <div class=\"cqa-flex cqa-items-center cqa-gap-3 cqa-min-w-0\">\n                <ng-container *ngTemplateOutlet=\"folderIconChip\"></ng-container>\n                <div class=\"cqa-flex cqa-flex-col cqa-min-w-0\">\n                  <span class=\"cqa-text-base cqa-font-semibold cqa-text-neutral-900 cqa-truncate cqa-leading-tight\">{{ f.name }}</span>\n                  <span *ngIf=\"modularConfig.showCounts\" class=\"cqa-text-sm cqa-text-neutral-500 cqa-truncate\">\n                    {{ (f.count ?? 0) === 1 ? modularLabels.testsCountSingular : modularLabels.testsCountPlural.replace('{n}', '' + (f.count ?? 0)) }}\n                  </span>\n                </div>\n              </div>\n              <mat-icon class=\"cqa-text-neutral-400 cqa-shrink-0\" style=\"font-size:20px;width:20px;height:20px\">chevron_right</mat-icon>\n            </button>\n\n            <!-- \"+ New folder\" tile -->\n            <button\n              *ngIf=\"modularConfig.allowCreateFolder\"\n              type=\"button\"\n              (click)=\"onFolderCreateRequested({ parentId: selectedFolderId })\"\n              class=\"cqa-shrink-0 cqa-w-[240px] cqa-flex cqa-items-center cqa-gap-3 cqa-text-left cqa-p-3 cqa-rounded-[10px] cqa-border-solid cqa-border-[0.5px] cqa-border-[#E2E2E3] cqa-bg-neutral-50 hover:cqa-border-[#D8D9FC] hover:cqa-bg-white cqa-transition-colors\"\n            >\n              <ng-container *ngTemplateOutlet=\"addIconChip\"></ng-container>\n              <div class=\"cqa-flex cqa-flex-col cqa-min-w-0\">\n                <span class=\"cqa-text-base cqa-font-semibold cqa-text-neutral-600 cqa-truncate cqa-leading-tight\">{{ modularLabels.newFolder }}</span>\n                <span class=\"cqa-text-sm cqa-text-neutral-400\">{{ modularLabels.testsCountPlural.replace('{n}', '0') }}</span>\n              </div>\n            </button>\n          </div>\n        </section>\n\n        <!-- Folder panel header above the table: \"Hotel Search (3)\" + Clear filter -->\n        <div\n          *ngIf=\"isModularView && !isRootView && modularConfig.showUnorganisedSection\"\n          class=\"cqa-flex cqa-mb-1 cqa-items-center cqa-justify-between cqa-px-4 cqa-py-3 cqa-rounded-t-lg cqa-bg-indigo-50 cqa-border cqa-border-indigo-100\"\n        >\n          <div class=\"cqa-flex cqa-items-center cqa-gap-2\">\n            <mat-icon class=\"cqa-text-indigo-500\" style=\"font-size:18px;width:18px;height:18px\">folder_open</mat-icon>\n            <span class=\"cqa-text-sm cqa-font-semibold cqa-text-indigo-700\">\n              {{ currentFolderNode?.name }} ({{ currentFolderDirectCount }})\n            </span>\n          </div>\n          <button\n            type=\"button\"\n            class=\"cqa-px-3 cqa-py-1 cqa-text-xs cqa-font-medium cqa-text-indigo-700 cqa-bg-white cqa-border cqa-border-indigo-200 cqa-rounded hover:cqa-bg-indigo-50\"\n            (click)=\"onFolderSelected(null)\"\n          >{{ modularLabels.clearFilter }}</button>\n        </div>\n\n        <!-- Unorganised section header at root view -->\n        <div\n          *ngIf=\"isModularView && isRootView && modularConfig.showUnorganisedSection\"\n          class=\"cqa-flex cqa-items-center cqa-gap-2 cqa-mb-2 cqa-mt-2\"\n        >\n          <mat-icon class=\"cqa-text-neutral-600\" style=\"font-size:16px;width:16px;height:16px\">inbox</mat-icon>\n          <h3 class=\"cqa-text-sm cqa-font-semibold cqa-text-neutral-800\">{{ modularLabels.unorganised }}</h3>\n          <span class=\"cqa-text-xs cqa-text-neutral-500\">\n            {{ unorganisedCount === 1 ? modularLabels.testsCountSingular : modularLabels.testsCountPlural.replace('{n}', '' + unorganisedCount) }}\n          </span>\n        </div>\n\n        <!-- Table -->\n        <div class=\"cqa-rounded-[7px] cqa-overflow-hidden cqa-border-t cqa-border-l cqa-border-r cqa-border-grey-200 cqa-relative cqa-overflow-x-auto\">\n          <ng-container *ngIf=\"(isTableLoading || isTableDataLoading) || (!effectiveIsEmptyState && pagedRows && pagedRows.length > 0); else storyEmptyTpl\">\n            <app-dynamic-table\n              [columns]=\"computedColumns\"\n              [data]=\"pagedRows\"\n              [rowSelectable]=\"rowSelectable\"\n              [enableLocalSort]=\"enableLocalSort && !isReordering\"\n              [isTableLoading]=\"isTableLoading\"\n              [isTableDataLoading]=\"isTableDataLoading\"\n              [cellJsonPathGetter]=\"cellJsonPathGetter\"\n              [onJsonPathCopiedHandler]=\"onJsonPathCopiedHandler\"\n              [enableRowReorder]=\"isReordering\"\n              (rowReorder)=\"onRowReorder($event)\"\n              (sortChange)=\"sortChange.emit($event)\">\n              <ng-template #emptyTableTpl>\n                <div class=\"cqa-flex cqa-flex-col cqa-items-center cqa-justify-center cqa-py-8\">\n                  <img src=\"/assets/illustrations/empty-state.svg\" alt=\"No data\" class=\"cqa-w-32 cqa-h-32 cqa-mb-4\" />\n                  <h3 class=\"cqa-text-lg cqa-font-semibold cqa-mb-2\">No test cases</h3>\n                  <p class=\"cqa-text-sm cqa-text-neutral-500 cqa-mb-4\">Try adjusting filters or create a new test case.</p>\n                  <cqa-button variant=\"filled\" (clicked)=\"toggleFilter()\">Show Filters</cqa-button>\n                </div>\n              </ng-template>\n            </app-dynamic-table>\n          </ng-container>\n\n          <ng-template #storyEmptyTpl>\n            <div class=\"cqa-p-6 cqa-flex cqa-flex-col cqa-items-center cqa-justify-center\">\n              <cqa-empty-state\n                *ngIf=\"effectiveIsEmptyState\"\n                [title]=\"effectiveEmptyStateConfig.title\"\n                [description]=\"effectiveEmptyStateConfig.description\"\n                [imageUrl]=\"effectiveEmptyStateConfig.imageUrl\"\n                [actions]=\"effectiveEmptyStateConfig.actions\"\n                (actionClick)=\"onEmptyAction($event)\"\n              >\n              </cqa-empty-state>\n            </div>\n          </ng-template>\n        </div>\n\n        <cqa-pagination\n          [totalElements]=\"serverSidePagination ? totalElements : filteredRows.length\"\n          [pageIndex]=\"pageIndex\"\n          [pageSize]=\"pageSize\"\n          [pageSizeOptions]=\"pageSizeOptions\"\n          [pageSizeMenuDirection]=\"pageSizeMenuDirection\"\n          [pageItemCount]=\"pagedRows.length\"\n          (paginate)=\"onPaginate($event)\"\n          (pageSizeChange)=\"onPageSizeChange($event)\"\n        >\n        </cqa-pagination>\n      </div>\n    </div>\n\n    <!-- Reused bulk action toolbar -->\n    <div *ngIf=\"anyRowSelected && modularConfig.allowBulkSelection && !isReordering\" class=\"cqa-absolute cqa-bottom-[18.75px] cqa-left-[50%] cqa-translate-x-[-50%] cqa-w-full lg:cqa-max-w-[68%] cqa-sm:max-w-[75%] cqa-max-w-[90%] cqa-z-[1]\">\n      <cqa-table-action-toolbar\n        [selectedItems]=\"selectedItems && selectedItems.length > 0 ? selectedItems : currentSelectedItems\"\n        [actions]=\"effectiveBulkActions\"\n        [showSelectAll]=\"showSelectAllInToolbar\"\n        [allSelected]=\"allSelectedInToolbar\"\n        [showDismiss]=\"showDismissInToolbar\"\n        (actionClick)=\"onBulkAction($event)\"\n        (selectAllChange)=\"onBulkSelectAll($event)\"\n        (dismiss)=\"onBulkDismiss()\"\n      ></cqa-table-action-toolbar>\n    </div>\n\n  </div>\n</div>\n\n"]}