cloud-ide-element 0.0.1 → 1.0.0

package/esm2022/lib/components/data-grid/data-grid.component.mjs

@@ -0,0 +1,1363 @@
+import { Component, Input, Output, EventEmitter, signal, computed } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { FormsModule } from '@angular/forms';
+import { DEFAULT_GRID_CONFIG } from './data-grid.types';
+import { CideInputComponent } from '../../elements/input/input.component';
+import { CideSelectComponent } from '../../elements/select/select.component';
+import { CideIconComponent } from '../../elements/icon/icon.component';
+import { CideEleButtonComponent } from '../../../public-api';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@angular/forms";
+export class CideEleDataGridComponent {
+    constructor() {
+        this.customRenderers = {};
+        this.templateRenderers = {};
+        this.customFormatters = {};
+        this.actionHandlers = {};
+        this.serverSidePagination = false;
+        this.totalServerItems = 0;
+        this.currentServerPage = 1;
+        this.currentServerPageSize = 10;
+        this.dragDropEnabled = false;
+        this.gridEvent = new EventEmitter();
+        // Internal state using Angular Signals
+        this.internalData = signal([]);
+        this.filteredData = signal([]);
+        // Grid state
+        this.currentPage = signal(1);
+        this.pageSize = signal(10);
+        this.totalItems = signal(0);
+        this.totalPages = signal(0);
+        this.searchQuery = signal('');
+        this.loading = signal(false);
+        this.isRefreshing = signal(false);
+        this.pageChangeLoading = signal(false);
+        this.jumpToPage = 1;
+        this.isDragOverRow = null;
+        this.isDragging = signal(false);
+        this.hasOrderChanged = signal(false);
+        this.originalOrderIds = []; // Store only IDs for order tracking
+        this.initialDataOrderIds = []; // Store only IDs for initial order
+        this.rowOrderMap = new Map();
+        this.localReorderedData = []; // Local data for visual reordering
+        this.isDataUpdate = false;
+        // Computed properties
+        this.hasNextPage = computed(() => this.currentPage() < this.totalPages());
+        this.hasPreviousPage = computed(() => this.currentPage() > 1);
+        // Merged configuration with defaults
+        this.mergedConfig = signal(this.config);
+    }
+    ngOnInit() {
+        this.initializeGrid();
+        this.initializeOriginalOrder();
+    }
+    ngOnDestroy() {
+        // Clean up search debounce timer
+        if (this.searchDebounceTimer) {
+            clearTimeout(this.searchDebounceTimer);
+        }
+    }
+    ngOnChanges(changes) {
+        if (changes['config']) {
+            // Store current search query to preserve it during re-initialization
+            const currentSearchQuery = this.searchQuery();
+            this.mergeConfigWithDefaults();
+            // Check if this is a data-only update (same config except data)
+            const isDataOnlyUpdate = this.isDataOnlyUpdate(changes['config']);
+            if (isDataOnlyUpdate && this.serverSidePagination) {
+                console.log('🔄 DataGrid: isDataOnlyUpdate', isDataOnlyUpdate);
+                // For data-only updates, preserve search query and use updateDataOnly
+                this.updateDataOnly(changes['config'].currentValue.data || []);
+                if (currentSearchQuery) {
+                    // this.searchQuery.set(currentSearchQuery);
+                }
+            }
+            else {
+                // For full config changes, use initializeGrid
+                this.initializeGrid();
+                // Restore search query after initialization
+                if (currentSearchQuery) {
+                    // this.searchQuery.set(currentSearchQuery);
+                }
+            }
+            // Reinitialize original order when data changes
+            this.initializeOriginalOrder();
+            // Also refresh order tracking to ensure it's up to date
+            this.refreshOrderTracking();
+        }
+        if (this.serverSidePagination) {
+            if (changes['totalServerItems']) {
+                // console.log('🔄 DataGrid: totalServerItems changed:', this.totalServerItems);
+                this.totalItems.set(this.totalServerItems);
+                this.updatePaginationState();
+            }
+            if (changes['currentServerPage']) {
+                // console.log('🔄 DataGrid: currentServerPage changed:', this.currentServerPage);
+                this.currentPage.set(this.currentServerPage);
+            }
+            if (changes['currentServerPageSize']) {
+                // console.log('🔄 DataGrid: currentServerPageSize changed:', this.currentServerPageSize);
+                this.pageSize.set(this.currentServerPageSize);
+                this.updatePaginationState();
+            }
+            // Clear page change loading when server-side data is updated
+            if (changes['config'] && this.pageChangeLoading()) {
+                this.clearPageChangeLoading();
+            }
+        }
+    }
+    /**
+     * Check if the config change is only a data update
+     */
+    isDataOnlyUpdate(change) {
+        if (change.firstChange || !change.previousValue || !change.currentValue) {
+            return false;
+        }
+        const prev = change.previousValue;
+        const curr = change.currentValue;
+        // Check if all properties except 'data' are the same
+        const prevWithoutData = { ...prev };
+        const currWithoutData = { ...curr };
+        delete prevWithoutData.data;
+        delete currWithoutData.data;
+        return JSON.stringify(prevWithoutData) === JSON.stringify(currWithoutData);
+    }
+    /**
+     * Update only the data without triggering full grid re-initialization
+     * This prevents the search input and other UI state from being reset
+     */
+    updateDataOnly(data) {
+        let processedData = data;
+        // Transform to tree structure if tree config is enabled
+        if (this.mergedConfig().tree?.enabled) {
+            processedData = this.transformToTree(data);
+            console.log('processedData', processedData);
+        }
+        this.internalData.set(processedData);
+        console.log('processedData', processedData);
+        // For server-side pagination, set filtered data directly
+        if (this.serverSidePagination) {
+            console.log('processedData', processedData);
+            this.filteredData.set(processedData);
+        }
+        else {
+            // For client-side pagination, apply filters
+            this.applyFilters();
+        }
+        // Refresh order tracking when data changes
+        this.refreshOrderTracking();
+        this.clearPageChangeLoading();
+    }
+    mergeConfigWithDefaults() {
+        this.mergedConfig.set({
+            ...DEFAULT_GRID_CONFIG,
+            ...this.config,
+            pagination: { ...DEFAULT_GRID_CONFIG.pagination, ...this.config.pagination },
+            search: { ...DEFAULT_GRID_CONFIG.search, ...this.config.search },
+            loading: { ...DEFAULT_GRID_CONFIG.loading, ...this.config.loading },
+            scroll: { ...DEFAULT_GRID_CONFIG.scroll, ...this.config.scroll }
+        });
+    }
+    initializeGrid() {
+        // Ensure we have valid data
+        let data = this.config?.data || [];
+        // Transform to tree structure if tree config is enabled
+        if (this.mergedConfig().tree?.enabled) {
+            data = this.transformToTree(data);
+        }
+        this.internalData.set(data);
+        // Set pagination values based on mode
+        if (this.serverSidePagination) {
+            this.currentPage.set(this.currentServerPage);
+            this.pageSize.set(this.currentServerPageSize);
+            this.totalItems.set(this.totalServerItems);
+            // For server-side pagination, set filtered data directly without applying filters
+            this.filteredData.set(data);
+        }
+        else {
+            // Client-side pagination
+            const pageSize = this.mergedConfig().pagination?.pageSize || 10;
+            this.pageSize.set(pageSize);
+            this.totalItems.set(data.length);
+            // For client-side pagination, apply filters
+            this.applyFilters();
+        }
+        this.updatePaginationState();
+        // Initialize original order for drag and drop
+        this.initializeOriginalOrder();
+        // Also refresh order tracking to ensure it's up to date
+        this.refreshOrderTracking();
+    }
+    /**
+     * Get the unique identifier for an item
+     */
+    getItemId(item) {
+        if (item && typeof item === 'object') {
+            const id = item['_id'];
+            return id ? String(id) : null;
+        }
+        return null;
+    }
+    /**
+     * Get the order value for an item from the config
+     */
+    getItemOrder(item) {
+        const dragDropConfig = this.getDragDropConfig();
+        if (dragDropConfig?.orderField) {
+            const orderValue = this.getNestedValue(item, dragDropConfig.orderField);
+            return typeof orderValue === 'number' ? orderValue : 0;
+        }
+        return 0;
+    }
+    /**
+     * Initialize the original order for drag and drop
+     */
+    initializeOriginalOrder() {
+        if (this.isDragDropEnabled()) {
+            // Get the full dataset from the config (not just displayedData)
+            const fullData = this.mergedConfig().data || [];
+            // Completely build the order tracking from current data
+            this.rowOrderMap.clear();
+            this.initialDataOrderIds = [];
+            // Build the order tracking with current data
+            fullData.forEach((item, index) => {
+                const itemId = this.getItemId(item);
+                if (itemId) {
+                    const actualOrder = this.getItemOrder(item);
+                    this.initialDataOrderIds.push(itemId);
+                    this.rowOrderMap.set(itemId, {
+                        oldPosition: actualOrder || (index + 1), // Use actual order or fallback to index
+                        newPosition: actualOrder || (index + 1)
+                    });
+                }
+            });
+            // Clear any existing local reordered data
+            this.localReorderedData = [];
+            console.log('🔍 Initial order tracking built from full dataset:', this.initialDataOrderIds.length, 'items');
+            console.log('🔍 Initial order map created with actual order values:', Array.from(this.rowOrderMap.entries()));
+        }
+    }
+    /**
+     * Refresh order tracking with current data (called when data updates)
+     */
+    refreshOrderTracking() {
+        if (this.isDragDropEnabled()) {
+            // Get the current full dataset
+            const fullData = this.mergedConfig().data || [];
+            // Completely rebuild the order tracking from current data
+            this.rowOrderMap.clear();
+            this.initialDataOrderIds = [];
+            // Rebuild the order tracking with current data
+            fullData.forEach((item, index) => {
+                const itemId = this.getItemId(item);
+                if (itemId) {
+                    const actualOrder = this.getItemOrder(item);
+                    this.initialDataOrderIds.push(itemId);
+                    this.rowOrderMap.set(itemId, {
+                        oldPosition: actualOrder || (index + 1),
+                        newPosition: actualOrder || (index + 1)
+                    });
+                }
+            });
+            // Clear any local reordered data since data has changed
+            this.localReorderedData = [];
+            this.hasOrderChanged.set(false);
+            console.log('🔍 Order tracking completely rebuilt with current data:', this.initialDataOrderIds.length, 'items');
+        }
+    }
+    // ===== Data Processing =====
+    applyFilters() {
+        let filtered = [...this.internalData()];
+        // Apply search filter only for client-side pagination
+        // For server-side pagination, search is handled by the server
+        if (!this.serverSidePagination) {
+            const query = this.searchQuery()?.toLowerCase();
+            if (query && this.mergedConfig().search.enabled) {
+                filtered = filtered.filter(item => this.mergedConfig().search.searchableColumns.some(columnKey => {
+                    const value = this.getNestedValue(item, columnKey);
+                    return String(value || '')?.toLowerCase()?.includes(query);
+                }));
+            }
+        }
+        // Flatten tree structure for display if tree is enabled
+        if (this.mergedConfig().tree?.enabled) {
+            filtered = this.flattenTreeForDisplay(filtered);
+        }
+        this.filteredData.set(filtered);
+        // For server-side pagination, totalItems should always be totalServerItems
+        // For client-side pagination, totalItems should be the filtered data length
+        if (this.serverSidePagination) {
+            this.totalItems.set(this.totalServerItems);
+        }
+        else {
+            this.totalItems.set(filtered.length);
+        }
+        this.updatePaginationState();
+    }
+    /**
+     * Transform flat data to tree structure based on foreign key relationships
+     */
+    transformToTree(data) {
+        console.log('transformToTree - input data:', data.length, 'items');
+        const treeConfig = this.mergedConfig().tree;
+        if (!treeConfig)
+            return data;
+        const { primaryKey, foreignKey, childrenKey = 'children', levelKey = 'level', expandedKey = 'isExpanded', hasChildrenKey = 'hasChildren' } = treeConfig;
+        // Always add level key to each row during processing
+        // Create a map for quick lookup
+        const itemMap = new Map();
+        const processedItems = new Set();
+        const rootItems = [];
+        // First pass: create tree items with default properties and level key
+        data.forEach(item => {
+            const treeItem = {
+                ...item,
+                [levelKey]: 0,
+                level: 0, // Always add 'level' property for consistent access
+                [expandedKey]: false,
+                [hasChildrenKey]: false,
+                [childrenKey]: []
+            };
+            itemMap.set(String(this.getNestedValue(item, primaryKey) || ''), treeItem);
+        });
+        // Multi-pass hierarchy building to handle items in any order
+        let remainingItems = [...data];
+        const maxIterations = data.length; // Prevent infinite loops
+        let iteration = 0;
+        while (remainingItems.length > 0 && iteration < maxIterations) {
+            const itemsToProcess = [...remainingItems];
+            remainingItems = [];
+            console.log(`Iteration ${iteration + 1}: Processing ${itemsToProcess.length} items`);
+            itemsToProcess.forEach(item => {
+                const itemId = String(this.getNestedValue(item, primaryKey) || '');
+                const parentIdValue = this.getNestedValue(item, foreignKey);
+                const parentId = parentIdValue !== null && parentIdValue !== undefined ? String(parentIdValue) : '';
+                const treeItem = itemMap.get(itemId);
+                // Skip if already processed
+                if (processedItems.has(itemId)) {
+                    return;
+                }
+                if (treeItem && parentId && itemMap.has(parentId)) {
+                    // This is a child item - check if parent is processed or is a root
+                    const parent = itemMap.get(parentId);
+                    const parentParentId = this.getNestedValue(parent, foreignKey);
+                    const isParentRoot = !parentParentId || parentParentId === null || parentParentId === undefined;
+                    if (isParentRoot || processedItems.has(parentId)) {
+                        // Parent is processed or is root, we can process this child
+                        const parentChildren = this.getNestedValue(parent, childrenKey) || [];
+                        // Avoid adding duplicates
+                        const childExists = parentChildren.some(child => String(this.getNestedValue(child, primaryKey) || '') === itemId);
+                        if (!childExists) {
+                            // Calculate level based on parent - automatically set level key
+                            const parentLevel = this.getNestedValue(parent, 'level') || 0;
+                            const childLevel = parentLevel + 1;
+                            // Update child item with correct level
+                            const updatedTreeItem = {
+                                ...treeItem,
+                                [levelKey]: childLevel,
+                                level: childLevel // Always add 'level' property for consistent access
+                            };
+                            itemMap.set(itemId, updatedTreeItem);
+                            // Add updated child to parent's children array
+                            parentChildren.push(updatedTreeItem);
+                            // Update parent properties
+                            const updatedParent = {
+                                ...parent,
+                                [childrenKey]: parentChildren,
+                                [hasChildrenKey]: true
+                            };
+                            itemMap.set(parentId, updatedParent);
+                            processedItems.add(itemId);
+                        }
+                    }
+                    else {
+                        // Parent not processed yet, defer this item
+                        remainingItems.push(item);
+                    }
+                }
+                else if (treeItem) {
+                    // This is a root item - automatically set level to 0
+                    const updatedRootItem = {
+                        ...treeItem,
+                        [levelKey]: 0,
+                        level: 0 // Always add 'level' property for consistent access
+                    };
+                    itemMap.set(itemId, updatedRootItem);
+                    if (!rootItems.some(rootItem => String(this.getNestedValue(rootItem, primaryKey) || '') === itemId)) {
+                        rootItems.push(updatedRootItem);
+                        processedItems.add(itemId);
+                    }
+                }
+            });
+            iteration++;
+        }
+        // Handle any remaining unprocessed items as roots (orphaned items)
+        remainingItems.forEach(item => {
+            const itemId = String(this.getNestedValue(item, primaryKey) || '');
+            if (!processedItems.has(itemId)) {
+                const treeItem = itemMap.get(itemId);
+                if (treeItem && !rootItems.includes(treeItem)) {
+                    console.log(`Adding orphaned item ${itemId} as root`);
+                    rootItems.push(treeItem);
+                }
+            }
+        });
+        // Final pass: Update hasChildren property for all items in the tree
+        const updateHasChildren = (items) => {
+            items.forEach((item, index) => {
+                const itemId = String(this.getNestedValue(item, primaryKey) || '');
+                const children = this.getNestedValue(item, childrenKey) || [];
+                const hasChildren = children.length > 0;
+                // Update the item with correct hasChildren property
+                const updatedItem = {
+                    ...item,
+                    [hasChildrenKey]: hasChildren
+                };
+                // Update in the map
+                itemMap.set(itemId, updatedItem);
+                // Update the item in the array
+                items[index] = updatedItem;
+                // Recursively update children
+                if (children.length > 0) {
+                    updateHasChildren(children);
+                }
+            });
+        };
+        // Get updated root items from the map to ensure we have the latest versions
+        const updatedRootItems = rootItems.map(rootItem => {
+            const rootId = String(this.getNestedValue(rootItem, primaryKey) || '');
+            return itemMap.get(rootId) || rootItem;
+        });
+        // Update all root items and their descendants
+        updateHasChildren(updatedRootItems);
+        console.log('transformToTree - root items:', updatedRootItems.length);
+        console.log('CC - processed items:', processedItems.size);
+        console.log('transformToTree - sample root item with level:', updatedRootItems[0]);
+        return updatedRootItems;
+    }
+    /**
+     * Recursively calculate item level in hierarchy for unlimited depth support
+     */
+    calculateItemLevel(item, itemMap, primaryKey, foreignKey, levelKey) {
+        // Check if level is already set correctly
+        const currentLevel = this.getNestedValue(item, levelKey);
+        if (currentLevel !== undefined && currentLevel > 0) {
+            return currentLevel;
+        }
+        // Get parent information
+        const itemId = String(this.getNestedValue(item, primaryKey) || '');
+        const parentIdValue = this.getNestedValue(item, foreignKey);
+        const parentId = parentIdValue !== null && parentIdValue !== undefined ? String(parentIdValue) : '';
+        // If no parent, this is a root item (level 0)
+        if (!parentId || !itemMap.has(parentId)) {
+            return 0;
+        }
+        // Recursively calculate parent level and add 1
+        const parent = itemMap.get(parentId);
+        const parentLevel = this.calculateItemLevel(parent, itemMap, primaryKey, foreignKey, levelKey);
+        // Update the item's level in the map
+        const updatedItem = {
+            ...item,
+            [levelKey]: parentLevel + 1
+        };
+        itemMap.set(itemId, updatedItem);
+        return parentLevel + 1;
+    }
+    /**
+     * Flatten tree structure for display, respecting expansion state with unlimited nesting
+     */
+    flattenTreeForDisplay(treeItems) {
+        const result = [];
+        const treeConfig = this.mergedConfig().tree;
+        if (!treeConfig)
+            return treeItems;
+        const { childrenKey = 'children', expandedKey = 'isExpanded' } = treeConfig;
+        const flatten = (items, currentLevel = 0) => {
+            items.forEach(item => {
+                result.push(item);
+                const children = this.getNestedValue(item, childrenKey) || [];
+                const isExpanded = this.getNestedValue(item, expandedKey) || false;
+                if (children.length > 0 && isExpanded) {
+                    console.log(`Flattening children for item at level ${currentLevel}, children count: ${children.length}`);
+                    flatten(children, currentLevel + 1);
+                }
+            });
+        };
+        flatten(treeItems);
+        console.log('flattenTreeForDisplay - result:', result.length, 'items');
+        return result;
+    }
+    /**
+     * Toggle expand/collapse state of a tree item with unlimited nesting support
+     */
+    toggleTreeExpand(item) {
+        const treeConfig = this.mergedConfig().tree;
+        if (!treeConfig)
+            return;
+        const { expandedKey = 'isExpanded', primaryKey } = treeConfig;
+        const currentExpanded = this.getNestedValue(item, expandedKey) || false;
+        const itemId = String(this.getNestedValue(item, primaryKey) || '');
+        console.log(`toggleTreeExpand - item: ${itemId}, current expanded: ${currentExpanded}`);
+        // Update the expanded state
+        const updatedItem = {
+            ...item,
+            [expandedKey]: !currentExpanded
+        };
+        // Update the item in the tree structure recursively
+        const updateItemInTree = (treeData) => {
+            return treeData.map(treeItem => {
+                const treeItemId = String(this.getNestedValue(treeItem, primaryKey) || '');
+                if (treeItemId === itemId) {
+                    console.log(`Found item to update: ${itemId}, new expanded state: ${!currentExpanded}`);
+                    return updatedItem;
+                }
+                // Check children recursively
+                const children = this.getNestedValue(treeItem, 'children') || [];
+                if (children.length > 0) {
+                    const updatedChildren = updateItemInTree(children);
+                    return {
+                        ...treeItem,
+                        children: updatedChildren
+                    };
+                }
+                return treeItem;
+            });
+        };
+        // Update the internal data
+        const updatedData = updateItemInTree([...this.internalData()]);
+        this.internalData.set(updatedData);
+        // Re-apply filters to update the display
+        this.applyFilters();
+    }
+    updatePaginationState() {
+        const total = Math.ceil(this.totalItems() / this.pageSize());
+        this.totalPages.set(total);
+        // Ensure current page is within bounds
+        if (total === 0) {
+            this.currentPage.set(1);
+        }
+        else if (this.currentPage() > total) {
+            this.currentPage.set(total);
+        }
+    }
+    // ===== Pagination Methods =====
+    onPageChange(page) {
+        console.log('🔄 DataGrid: onPageChange called with page:', page);
+        const pageNum = typeof page === 'string' ? parseInt(page, 10) : page;
+        console.log('🔄 DataGrid: Parsed page number:', pageNum, 'Total pages:', this.totalPages());
+        if (pageNum >= 1 && pageNum <= this.totalPages()) {
+            // Set page change loading state
+            this.pageChangeLoading.set(true);
+            console.log('🔄 DataGrid: Set page change loading to true');
+            this.currentPage.set(pageNum);
+            if (this.serverSidePagination) {
+                const pageData = { page: pageNum, pageSize: this.pageSize() };
+                console.log('🔄 DataGrid: Emitting pageChange event for server-side pagination:', pageData);
+                // Emit page data object for server-side pagination
+                this.emitEvent('pageChange', pageData);
+                // Don't clear loading state here - let the parent component handle it
+                // The loading state will be cleared when new data arrives via ngOnChanges
+            }
+            else {
+                console.log('🔄 DataGrid: Emitting pageChange event for client-side pagination:', pageNum);
+                // Emit simple page number for client-side pagination
+                this.emitEvent('pageChange', pageNum);
+                // Clear loading state for client-side pagination
+                this.clearPageChangeLoading();
+            }
+        }
+        else {
+            console.log('🔄 DataGrid: Page number out of range, not emitting event');
+        }
+    }
+    onPageSizeChange() {
+        // Set page change loading state
+        this.pageChangeLoading.set(true);
+        this.currentPage.set(1);
+        this.updatePaginationState();
+        if (this.serverSidePagination) {
+            // Emit page data object for server-side pagination
+            this.emitEvent('pageChange', { page: 1, pageSize: this.pageSize() });
+            // Don't clear loading state here - let the parent component handle it
+            // The loading state will be cleared when new data arrives via ngOnChanges
+        }
+        else {
+            // Emit simple page number for client-side pagination
+            this.emitEvent('pageChange', 1);
+            // Clear loading state for client-side pagination
+            this.clearPageChangeLoading();
+        }
+    }
+    updatePageSize(value) {
+        this.pageSize.set(+value);
+        this.onPageSizeChange();
+    }
+    previousPage() {
+        if (this.hasPreviousPage()) {
+            this.onPageChange(this.currentPage() - 1);
+        }
+    }
+    nextPage() {
+        if (this.hasNextPage()) {
+            this.onPageChange(this.currentPage() + 1);
+        }
+    }
+    onJumpToPage() {
+        if (this.jumpToPage >= 1 && this.jumpToPage <= this.totalPages()) {
+            this.onPageChange(this.jumpToPage);
+        }
+    }
+    getEnhancedPageNumbers() {
+        const total = this.totalPages();
+        const current = this.currentPage();
+        const pages = [];
+        if (total <= 7) {
+            for (let i = 1; i <= total; i++) {
+                pages.push(i);
+            }
+        }
+        else {
+            pages.push(1);
+            if (current <= 4) {
+                for (let i = 2; i <= 5; i++) {
+                    pages.push(i);
+                }
+                pages.push('...');
+                pages.push(total);
+            }
+            else if (current >= total - 3) {
+                pages.push('...');
+                for (let i = total - 4; i <= total; i++) {
+                    pages.push(i);
+                }
+            }
+            else {
+                pages.push('...');
+                for (let i = current - 1; i <= current + 1; i++) {
+                    pages.push(i);
+                }
+                pages.push('...');
+                pages.push(total);
+            }
+        }
+        return pages;
+    }
+    // ===== Search Methods =====
+    updateSearchQuery(value) {
+        console.log('updateSearchQuery', value);
+        const searchValue = value;
+        this.searchQuery.set(searchValue);
+        // Clear any existing debounce timer
+        if (this.searchDebounceTimer) {
+            clearTimeout(this.searchDebounceTimer);
+        }
+        // Apply debounce for search
+        const debounceMs = this.mergedConfig().search.debounceMs || 300;
+        this.searchDebounceTimer = setTimeout(() => {
+            // Only emit search event for server-side pagination
+            // Don't trigger any client-side filtering that might cause re-renders
+            if (this.serverSidePagination) {
+                this.currentPage.set(1);
+                this.emitEvent('search', searchValue);
+            }
+            else {
+                this.onSearch();
+            }
+        }, debounceMs);
+    }
+    onSearch() {
+        this.currentPage.set(1);
+        if (this.serverSidePagination) {
+            // For server-side pagination, only emit the search event
+            // Don't apply client-side filters as the server will handle the search
+            this.emitEvent('search', this.searchQuery());
+        }
+        else {
+            // For client-side pagination, apply filters locally
+            this.applyFilters();
+            this.emitEvent('search', this.searchQuery());
+        }
+    }
+    // ===== Action Methods =====
+    onRefresh() {
+        this.isRefreshing.set(true);
+        this.emitEvent('refresh', null);
+        // The parent component should handle the actual refresh and call setRefreshing(false) when done
+        // We don't auto-reset here to allow the parent to control the refresh state
+    }
+    // Method to allow parent components to control the refreshing state
+    setRefreshing(isRefreshing) {
+        this.isRefreshing.set(isRefreshing);
+    }
+    // Method to clear page change loading state when new data is received
+    clearPageChangeLoading() {
+        this.pageChangeLoading.set(false);
+    }
+    // ===== Tree View Helper Methods =====
+    /**
+     * Check if tree view is enabled
+     */
+    isTreeEnabled() {
+        const enabled = this.mergedConfig().tree?.enabled || false;
+        return enabled;
+    }
+    /**
+     * Get tree configuration
+     */
+    getTreeConfig() {
+        return this.mergedConfig().tree;
+    }
+    /**
+     * Check if an item has children
+     */
+    hasChildren(item) {
+        const treeConfig = this.getTreeConfig();
+        if (!treeConfig)
+            return false;
+        const { hasChildrenKey = 'hasChildren', childrenKey = 'children' } = treeConfig;
+        // Check hasChildren property first
+        const hasChildren = this.getNestedValue(item, hasChildrenKey);
+        if (hasChildren !== undefined) {
+            return hasChildren;
+        }
+        // Fallback to checking children array
+        const children = this.getNestedValue(item, childrenKey);
+        return children && children.length > 0;
+    }
+    /**
+     * Get item level in tree
+     */
+    getItemLevel(item) {
+        // Always try to get level from standard 'level' property first (set by transformToTree)
+        let level = this.getNestedValue(item, 'level');
+        // If not found, try tree config level key
+        if (level === undefined || level === null) {
+            const treeConfig = this.getTreeConfig();
+            if (treeConfig) {
+                const { levelKey = 'level' } = treeConfig;
+                level = this.getNestedValue(item, levelKey) || 0;
+            }
+            else {
+                level = 0;
+            }
+        }
+        return level;
+    }
+    /**
+     * Check if item is expanded
+     */
+    isItemExpanded(item) {
+        const treeConfig = this.getTreeConfig();
+        if (!treeConfig)
+            return false;
+        const { expandedKey = 'isExpanded' } = treeConfig;
+        return this.getNestedValue(item, expandedKey) || false;
+    }
+    /**
+     * Get tree indent style
+     */
+    getTreeIndentStyle(item) {
+        const level = this.getItemLevel(item);
+        // Specific padding progression: Level 1=12px, Level 2=22px, Level 3=32px, Level 4=52px
+        const basePadding = 12; // Base cell padding (replaces tw-px-3)
+        let levelPadding = 0;
+        switch (level) {
+            case 0: // Level 1 (root)
+                levelPadding = 0;
+                break;
+            case 1: // Level 2
+                levelPadding = 10;
+                break;
+            case 2: // Level 3
+                levelPadding = 20;
+                break;
+            case 3: // Level 4
+                levelPadding = 40;
+                break;
+            default: // Level 5+
+                levelPadding = 40 + ((level - 3) * 20); // Continue with 20px increments
+                break;
+        }
+        const totalPadding = `${basePadding + levelPadding}px`;
+        return totalPadding;
+    }
+    /**
+     * Get tree level background class for visual distinction
+     */
+    getTreeLevelClass(item) {
+        const level = this.getItemLevel(item);
+        if (level === 0)
+            return 'tree-level-0'; // Root level
+        if (level === 1)
+            return 'tree-level-1'; // First child level  
+        if (level === 2)
+            return 'tree-level-2'; // Second child level
+        return 'tree-level-deep'; // Deep nesting (3+ levels)
+    }
+    // ===== Drag and Drop Helper Methods =====
+    /**
+     * Check if drag and drop is enabled
+     */
+    isDragDropEnabled() {
+        return this.dragDropEnabled || this.mergedConfig().dragDrop?.enabled || false;
+    }
+    /**
+     * Get drag and drop configuration
+     */
+    getDragDropConfig() {
+        return this.mergedConfig().dragDrop;
+    }
+    /**
+     * Handle drag start event
+     */
+    onDragStart(event, item, index) {
+        if (!this.isDragDropEnabled())
+            return;
+        this.isDragging.set(true);
+        // Store the current order IDs when drag starts for comparison
+        this.originalOrderIds = this.displayedData.map(item => this.getItemId(item)).filter(id => id !== null);
+        console.log('🔍 Drag started, current order IDs stored:', this.originalOrderIds);
+        const dragConfig = this.getDragDropConfig();
+        const dragClass = dragConfig?.dragClass || 'tw-opacity-50 tw-bg-blue-50';
+        if (event.dataTransfer) {
+            event.dataTransfer.effectAllowed = 'move';
+            event.dataTransfer.setData('text/plain', JSON.stringify({ item, index }));
+        }
+        // Find the closest tr element and apply drag styles
+        const rowElement = event.target.closest('tr');
+        if (rowElement) {
+            dragClass.split(' ').forEach(cls => rowElement.classList.add(cls));
+            // Add additional visual feedback
+            rowElement.style.transform = 'scale(1.02)';
+            rowElement.style.boxShadow = '0 4px 12px rgba(0, 0, 0, 0.15)';
+            rowElement.style.zIndex = '1000';
+        }
+    }
+    /**
+     * Handle drag over event
+     */
+    onDragOver(event) {
+        if (!this.isDragDropEnabled())
+            return;
+        event.preventDefault();
+        event.dataTransfer.dropEffect = 'move';
+        // Find the row index from the closest tr element
+        const rowElement = event.target.closest('tr');
+        if (rowElement) {
+            const tbody = rowElement.closest('tbody');
+            if (tbody) {
+                const rowIndex = Array.from(tbody.children).indexOf(rowElement);
+                this.isDragOverRow = rowIndex;
+            }
+        }
+    }
+    /**
+     * Handle drag leave event
+     */
+    onDragLeave(event) {
+        console.log('onDragLeave', event);
+        if (!this.isDragDropEnabled())
+            return;
+        // Clear drag over row tracking
+        this.isDragOverRow = null;
+    }
+    /**
+     * Handle drop event
+     */
+    onDrop(event, targetItem, targetIndex) {
+        if (!this.isDragDropEnabled())
+            return;
+        event.preventDefault();
+        // Clear drag over row tracking
+        this.isDragOverRow = null;
+        try {
+            const data = JSON.parse(event.dataTransfer.getData('text/plain'));
+            const sourceItem = data.item;
+            const sourceIndex = data.index;
+            if (sourceIndex !== targetIndex) {
+                const newOrder = this.getNewOrder(sourceIndex, targetIndex);
+                console.log('🔍 Drop completed, updating local order only:', { sourceItem, sourceIndex, targetItem, targetIndex, newOrder });
+                // Update the row order map with new positions (LOCAL ONLY)
+                this.updateRowOrderMap(newOrder);
+                // Update local data for visual reordering (LOCAL ONLY)
+                this.updateLocalDataOrder(newOrder);
+                // Check if any row has changed position
+                const hasActuallyChanged = this.checkIfOrderChanged();
+                this.hasOrderChanged.set(hasActuallyChanged);
+                console.log('🔍 Local order changed:', hasActuallyChanged);
+                // IMPORTANT: DO NOT emit reorder event here - only store locally
+                // External components will be updated only when "Save Order" is clicked
+                console.log('🔍 Order change stored locally - external components not updated until save');
+            }
+            else {
+                console.log('Source and target index are the same, skipping reorder');
+            }
+        }
+        catch (error) {
+            console.error('Error parsing drag data:', error);
+        }
+    }
+    /**
+     * Handle drag end event
+     */
+    onDragEnd(event) {
+        if (!this.isDragDropEnabled())
+            return;
+        this.isDragging.set(false);
+        // Check if order has changed after drag ends
+        const hasActuallyChanged = this.checkIfOrderChanged();
+        this.hasOrderChanged.set(hasActuallyChanged);
+        const dragConfig = this.getDragDropConfig();
+        const dragClass = dragConfig?.dragClass || 'tw-opacity-50 tw-bg-blue-50';
+        // Clear drag over row tracking
+        this.isDragOverRow = null;
+        // Find the closest tr element and remove drag styles
+        const rowElement = event.target.closest('tr');
+        if (rowElement) {
+            dragClass.split(' ').forEach(cls => rowElement.classList.remove(cls));
+            // Remove additional visual feedback
+            rowElement.style.transform = '';
+            rowElement.style.boxShadow = '';
+            rowElement.style.zIndex = '';
+        }
+    }
+    /**
+     * Calculate new order after reordering
+     */
+    getNewOrder(sourceIndex, targetIndex) {
+        const data = [...this.displayedData];
+        const [movedItem] = data.splice(sourceIndex, 1);
+        data.splice(targetIndex, 0, movedItem);
+        return data;
+    }
+    /**
+     * Get the current order number for a specific item
+     */
+    getCurrentOrderNumber(item) {
+        const itemId = this.getItemId(item);
+        if (itemId && this.rowOrderMap.has(itemId)) {
+            return this.rowOrderMap.get(itemId).newPosition;
+        }
+        // Fallback to actual order field value from config
+        const actualOrder = this.getItemOrder(item);
+        if (actualOrder > 0) {
+            return actualOrder;
+        }
+        // Final fallback to index-based calculation
+        const currentIndex = this.displayedData.findIndex(currentItem => {
+            if (item && currentItem && typeof item === 'object' && typeof currentItem === 'object') {
+                const itemId = item['_id'];
+                const currentItemId = currentItem['_id'];
+                return itemId && currentItemId && itemId === currentItemId;
+            }
+            return item === currentItem;
+        });
+        return currentIndex >= 0 ? currentIndex + 1 : 0;
+    }
+    /**
+     * Update the row order map with new positions after reordering
+     */
+    updateRowOrderMap(newOrder) {
+        newOrder.forEach((item, index) => {
+            const itemId = this.getItemId(item);
+            if (itemId && this.rowOrderMap.has(itemId)) {
+                const currentEntry = this.rowOrderMap.get(itemId);
+                // Calculate new order value based on position and original order field
+                const dragDropConfig = this.getDragDropConfig();
+                if (dragDropConfig?.orderField) {
+                    // Use the order field from config to calculate new order values
+                    const baseOrder = Math.min(...this.displayedData.map(item => this.getItemOrder(item)));
+                    const newOrderValue = baseOrder + index;
+                    currentEntry.newPosition = newOrderValue;
+                }
+                else {
+                    // Fallback to index-based position
+                    currentEntry.newPosition = index + 1;
+                }
+                this.rowOrderMap.set(itemId, currentEntry);
+            }
+        });
+        console.log('🔍 Row order map updated with new order values:', Array.from(this.rowOrderMap.entries()));
+    }
+    /**
+     * Check if any row has changed position by comparing old vs new positions
+     */
+    checkIfOrderChanged() {
+        for (const [itemId, orderInfo] of this.rowOrderMap) {
+            if (orderInfo.oldPosition !== orderInfo.newPosition) {
+                console.log('🔍 Order change detected for item:', itemId, orderInfo);
+                return true;
+            }
+        }
+        console.log('🔍 No order change detected');
+        return false;
+    }
+    /**
+     * Reset the row order map to original positions (for reset action)
+     */
+    resetRowOrderMap() {
+        // Get the current full dataset from the config (not cached data)
+        const fullData = this.mergedConfig().data || [];
+        // Completely rebuild the order tracking from current data
+        this.rowOrderMap.clear();
+        this.initialDataOrderIds = [];
+        // Rebuild the order tracking with current data
+        fullData.forEach((item, index) => {
+            const itemId = this.getItemId(item);
+            if (itemId) {
+                const actualOrder = this.getItemOrder(item);
+                this.initialDataOrderIds.push(itemId);
+                this.rowOrderMap.set(itemId, {
+                    oldPosition: actualOrder || (index + 1),
+                    newPosition: actualOrder || (index + 1)
+                });
+            }
+        });
+        // Clear any local reordered data
+        this.localReorderedData = [];
+        this.hasOrderChanged.set(false);
+        console.log('🔍 Row order map completely rebuilt from current data:', this.initialDataOrderIds.length, 'items');
+    }
+    /**
+     * Update the row order map baseline to current positions (for save action)
+     */
+    updateRowOrderMapBaseline() {
+        // Get the current full dataset from the config
+        const fullData = this.mergedConfig().data || [];
+        // Completely rebuild the order tracking from current data
+        this.rowOrderMap.clear();
+        this.initialDataOrderIds = [];
+        // Rebuild the order tracking with current data
+        fullData.forEach((item, index) => {
+            const itemId = this.getItemId(item);
+            if (itemId) {
+                const actualOrder = this.getItemOrder(item);
+                this.initialDataOrderIds.push(itemId);
+                this.rowOrderMap.set(itemId, {
+                    oldPosition: actualOrder || (index + 1),
+                    newPosition: actualOrder || (index + 1)
+                });
+            }
+        });
+        console.log('🔍 Row order map baseline completely rebuilt from current data:', this.initialDataOrderIds.length, 'items');
+    }
+    /**
+     * Get the current order array from the row order map
+     */
+    getCurrentOrderFromMap() {
+        const orderedItems = [];
+        // Get the full dataset from the config (not just displayedData)
+        const fullData = this.mergedConfig().data || [];
+        // Collect all items with their new positions from the full dataset
+        this.rowOrderMap.forEach((orderInfo, itemId) => {
+            const item = fullData.find(dataItem => this.getItemId(dataItem) === itemId);
+            if (item) {
+                orderedItems.push({ item, newPosition: orderInfo.newPosition });
+            }
+        });
+        // Sort by new position and return items in order
+        return orderedItems
+            .sort((a, b) => a.newPosition - b.newPosition)
+            .map(orderedItem => orderedItem.item);
+    }
+    /**
+     * Update local data order for visual reordering (LOCAL ONLY)
+     */
+    updateLocalDataOrder(newOrder) {
+        // Store the reordered data locally for visual display
+        this.localReorderedData = [...newOrder];
+        console.log('🔍 Local data order updated for visual display:', this.localReorderedData.length, 'items');
+    }
+    /**
+     * Check if the current order has changed from the initial order
+     */
+    checkOrderChanged(currentOrder) {
+        if (this.initialDataOrderIds.length !== currentOrder.length) {
+            return true;
+        }
+        // Create arrays of IDs to compare order
+        const currentIds = currentOrder.map(item => this.getItemId(item)).filter(id => id !== null);
+        // Compare the sequences
+        for (let i = 0; i < this.initialDataOrderIds.length; i++) {
+            if (this.initialDataOrderIds[i] !== currentIds[i]) {
+                console.log('🔍 Order changed detected:', {
+                    position: i,
+                    initial: this.initialDataOrderIds[i],
+                    current: currentIds[i]
+                });
+                return true;
+            }
+        }
+        console.log('🔍 No order change detected');
+        return false;
+    }
+    onRowClick(item) {
+        if (this.mergedConfig().onRowClick) {
+            this.emitEvent('rowClick', item);
+        }
+    }
+    onActionClick(item, action) {
+        // Handle tree expand/collapse actions
+        if (action.key === 'toggle-expand' && this.mergedConfig().tree?.enabled) {
+            this.toggleTreeExpand(item);
+        }
+        // Handle order management actions
+        if (action.key === 'reset-order') {
+            this.hasOrderChanged.set(false);
+            // Reset the row order map to current positions (LOCAL ONLY)
+            this.resetRowOrderMap();
+            // Clear local reordered data to revert to original display
+            this.localReorderedData = [];
+            console.log('🔍 Reset clicked, row order map reset locally, visual display reverted');
+        }
+        else if (action.key === 'save-order') {
+            this.hasOrderChanged.set(false);
+            // Update the row order map to current positions as new baseline
+            this.updateRowOrderMapBaseline();
+            // Clear local reordered data as it's now the baseline
+            this.localReorderedData = [];
+            console.log('🔍 Save clicked, row order map updated to new baseline, local data cleared');
+            // NOW emit the reorder event to update external components
+            const currentOrder = this.getCurrentOrderFromMap();
+            if (currentOrder.length > 0) {
+                console.log('🔍 Emitting rowReorder event to update external components:', currentOrder);
+                // Use the expected GridEvent structure for rowReorder
+                this.emitEvent('rowReorder', {
+                    sourceItem: currentOrder[0], // First item as source
+                    sourceIndex: 0, // First position as source
+                    targetItem: currentOrder[currentOrder.length - 1], // Last item as target
+                    targetIndex: currentOrder.length - 1, // Last position as target
+                    newOrder: currentOrder // The complete new order
+                });
+            }
+        }
+        if (this.actionHandlers[action.onClick]) {
+            this.actionHandlers[action.onClick](item, action);
+        }
+        this.emitEvent('action', item, undefined, action);
+    }
+    // ===== Utility Methods =====
+    emitEvent(type, data, column, action) {
+        this.gridEvent.emit({ type, data, column, action });
+    }
+    /**
+     * Get nested value from an object
+     * @param obj - The object to get the nested value from
+     * @param path - The path to the nested value (e.g., 'contact.email')
+     * @returns The nested value or undefined if not found
+     * @example
+     * const obj = { contact: { email: 'test@example.com' } };
+     * const value = getNestedValue(obj, 'contact.email');
+     * // value === 'test@example.com'
+     */
+    getNestedValue(obj, path) {
+        return path.split('.').reduce((current, key) => {
+            return current && typeof current === 'object' ? current[key] : undefined;
+        }, obj);
+    }
+    formatValue(value, column) {
+        if (column.formatter) {
+            if (column.formatter.type === 'custom' && column.formatter.customFunction) {
+                const formatter = this.customFormatters[column.formatter.customFunction];
+                if (formatter) {
+                    return formatter(value, column.formatter.format);
+                }
+            }
+            // Built-in formatters
+            switch (column.formatter.type) {
+                case 'date':
+                    return this.formatDate(value);
+                case 'currency':
+                    return this.formatCurrency(value, column.formatter.format);
+                case 'percentage':
+                    return this.formatPercentage(value);
+                default:
+                    return String(value || '');
+            }
+        }
+        return String(value || '');
+    }
+    formatDate(value) {
+        if (!value)
+            return 'N/A';
+        const date = new Date(value);
+        return isNaN(date.getTime()) ? 'Invalid Date' : date.toLocaleDateString();
+    }
+    formatCurrency(value, currency = 'USD') {
+        if (value === null || value === undefined)
+            return 'N/A';
+        const num = Number(value);
+        return isNaN(num) ? 'N/A' : new Intl.NumberFormat('en-US', {
+            style: 'currency',
+            currency
+        }).format(num);
+    }
+    formatPercentage(value) {
+        if (value === null || value === undefined)
+            return 'N/A';
+        const num = Number(value);
+        return isNaN(num) ? 'N/A' : `${num}%`;
+    }
+    renderCustomCell(value, row, column) {
+        if (column.renderer && this.customRenderers[column.renderer]) {
+            return this.customRenderers[column.renderer](value, row);
+        }
+        return this.formatValue(value, column);
+    }
+    // Enhanced renderer methods for template support
+    isTemplateRenderer(rendererKey) {
+        return !!this.templateRenderers[rendererKey];
+    }
+    isStringRenderer(rendererKey) {
+        return !!this.customRenderers[rendererKey];
+    }
+    getTemplateRenderer(rendererKey) {
+        return this.templateRenderers[rendererKey];
+    }
+    getStringRenderer(rendererKey) {
+        return this.customRenderers[rendererKey] || null;
+    }
+    getTemplateContext(value, row, column) {
+        return {
+            $implicit: value,
+            row,
+            value,
+            column
+        };
+    }
+    getColumnWidthClass(width) {
+        if (!width || width === 'auto')
+            return '';
+        const widthMap = {
+            'xs': 'tw-w-16',
+            'sm': 'tw-w-24',
+            'md': 'tw-w-32',
+            'lg': 'tw-w-48',
+            'xl': 'tw-w-64'
+        };
+        return widthMap[width] || `tw-w-[${width}]`;
+    }
+    getColumnMaxWidthClass(width) {
+        if (!width || width === 'auto')
+            return 'tw-max-w-xs';
+        const maxWidthMap = {
+            'xs': 'tw-max-w-16',
+            'sm': 'tw-max-w-24',
+            'md': 'tw-max-w-32',
+            'lg': 'tw-max-w-48',
+            'xl': 'tw-max-w-64'
+        };
+        return maxWidthMap[width] || `tw-max-w-[${width}]`;
+    }
+    getStatusClass(value, statusConfig) {
+        if (!statusConfig)
+            return '';
+        return value === statusConfig.activeValue ? statusConfig.activeClass : statusConfig.inactiveClass;
+    }
+    getStatusText(value, statusConfig) {
+        if (!statusConfig)
+            return String(value || '');
+        return value === statusConfig.activeValue ? statusConfig.activeLabel : statusConfig.inactiveLabel;
+    }
+    getItemRangeText() {
+        const total = this.totalItems();
+        if (this.serverSidePagination) {
+            // For server-side pagination, calculate based on actual displayed data
+            const displayedCount = this.displayedData.length;
+            const start = (this.currentPage() - 1) * this.pageSize() + 1;
+            const end = start + displayedCount - 1;
+            return `${start}-${end} of ${total}`;
+        }
+        else {
+            // For client-side pagination, use the original logic
+            const start = (this.currentPage() - 1) * this.pageSize() + 1;
+            const end = Math.min(this.currentPage() * this.pageSize(), total);
+            return `${start}-${end} of ${total}`;
+        }
+    }
+    getPageSizeOptions() {
+        return this.mergedConfig().pagination.pageSizeOptions.map(size => ({
+            value: size,
+            label: size.toString()
+        }));
+    }
+    trackByFn(index, item) {
+        const trackBy = this.mergedConfig().trackBy || '_id';
+        return this.getNestedValue(item, trackBy) || index;
+    }
+    getSkeletonArray() {
+        return Array.from({ length: this.loadingConfig.skeletonRows }, (_, i) => i);
+    }
+    // ===== Template Helper Methods =====
+    get displayedData() {
+        // If we have local reordered data (from drag & drop), use that for visual display
+        if (this.localReorderedData.length > 0 && this.hasOrderChanged()) {
+            console.log('🔍 Using local reordered data for display:', this.localReorderedData.length, 'items');
+            return this.localReorderedData;
+        }
+        const data = this.filteredData();
+        // For server-side pagination, the server already provides the correct page of data
+        // For client-side pagination, we need to slice the data
+        if (this.serverSidePagination) {
+            return data;
+        }
+        else {
+            const start = (this.currentPage() - 1) * this.pageSize();
+            const end = start + this.pageSize();
+            return data.slice(start, end);
+        }
+    }
+    get columns() {
+        const baseColumns = this.mergedConfig().columns || [];
+        return baseColumns;
+    }
+    get paginationConfig() {
+        return this.mergedConfig().pagination;
+    }
+    get searchConfig() {
+        return this.mergedConfig().search;
+    }
+    get loadingConfig() {
+        return this.mergedConfig().loading;
+    }
+    get scrollConfig() {
+        return this.mergedConfig().scroll;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: CideEleDataGridComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.7", type: CideEleDataGridComponent, isStandalone: true, selector: "cide-ele-data-grid", inputs: { config: "config", customRenderers: "customRenderers", templateRenderers: "templateRenderers", customFormatters: "customFormatters", actionHandlers: "actionHandlers", serverSidePagination: "serverSidePagination", totalServerItems: "totalServerItems", currentServerPage: "currentServerPage", currentServerPageSize: "currentServerPageSize", dragDropEnabled: "dragDropEnabled" }, outputs: { gridEvent: "gridEvent" }, usesOnChanges: true, ngImport: i0, template: "  <!-- Data Grid Component -->\n  <div class=\"data-grid-container tw-bg-white tw-shadow tw-rounded-lg tw-overflow-visible tw-flex tw-flex-col\" \n       [ngClass]=\"[\n         mergedConfig().tableClass || '',\n         mergedConfig().fullHeight ? 'tw-h-full' : '',\n         isDragDropEnabled() ? 'drag-drop-enabled' : '',\n         isTreeEnabled() ? 'tree-enabled' : ''\n       ]\">\n  \n  <!-- Header Section -->\n  @if (mergedConfig().title || mergedConfig().subtitle) {\n    <div class=\"tw-px-3 tw-py-2 tw-border-b tw-border-gray-200\">\n      @if (mergedConfig().title) {\n        <h3 class=\"tw-text-base tw-font-semibold tw-text-gray-900\">\n          {{ mergedConfig().title }}\n        </h3>\n      }\n      @if (mergedConfig().subtitle) {\n        <p class=\"tw-text-sm tw-text-gray-600 tw-mt-0.5\">\n          {{ mergedConfig().subtitle }}\n        </p>\n      }\n    </div>\n  }\n\n  <!-- Search Section -->\n  @if (searchConfig.enabled) {\n    <div class=\"tw-px-3 tw-py-2 tw-border-b tw-border-gray-200\">\n      <div class=\"tw-flex tw-items-center tw-justify-between\">\n        <!-- Search Input -->\n        <div class=\"tw-max-w-md\">\n          <cide-ele-input [labelHide]=\"true\" [hideHelperAndErrorText]=\"true\" id=\"search-input\" type=\"text\"\n            [ngModel]=\"searchQuery()\"\n            (ngModelChange)=\"updateSearchQuery($event)\"\n            [placeholder]=\"searchConfig.placeholder\"\n            [disabled]=\"loading() || isRefreshing()\"\n            leadingIcon=\"search\"\n            fill=\"outline\">\n          </cide-ele-input>\n        </div>\n        \n        <!-- Drag Order Actions -->\n        @if (isDragDropEnabled() && (isDragging() || hasOrderChanged())) {\n          <div class=\"tw-flex tw-items-center tw-space-x-2\">\n            <button cideEleButton \n                    variant=\"outline\" \n                    size=\"sm\" \n                    (click)=\"onActionClick(null, { key: 'reset-order', label: 'Reset Order', icon: 'undo', variant: 'outline', onClick: 'resetOrder' })\"\n                    class=\"tw-text-blue-700 tw-border-blue-300 hover:tw-bg-blue-100\">\n              <cide-ele-icon size=\"xs\" class=\"tw-w-4 tw-h-4 tw-mr-1\">undo</cide-ele-icon>\n              Reset Order\n            </button>\n            <button cideEleButton \n                    variant=\"primary\" \n                    size=\"sm\" \n                    (click)=\"onActionClick(null, { key: 'save-order', label: 'Save Order', icon: 'save', variant: 'primary', onClick: 'saveOrder' })\"\n                    class=\"tw-bg-blue-600 hover:tw-bg-blue-700 tw-text-white\">\n              <cide-ele-icon size=\"xs\" class=\"tw-w-4 tw-h-4 tw-mr-1\">save</cide-ele-icon>\n              Save Order\n            </button>\n          </div>\n        }\n      </div>\n    </div>\n  }\n\n     <!-- Table Section -->\n   <div class=\"tw-overflow-x-auto tw-relative\"\n        [ngClass]=\"{\n          'tw-flex-1 tw-min-h-0': mergedConfig().fullHeight,\n          'tw-overflow-y-auto': scrollConfig?.enabled,\n          'tw-max-h-full': scrollConfig?.enabled\n        }\"\n        [style.maxHeight]=\"scrollConfig?.enabled ? scrollConfig?.maxHeight : null\"\n        [style.minHeight]=\"scrollConfig?.enabled ? scrollConfig?.minHeight : null\">\n    <table class=\"tw-min-w-full tw-divide-y tw-divide-gray-200 tw-h-full tw-table-fixed\"\n           [class.empty-table]=\"displayedData.length === 0\"\n           [ngClass]=\"{\n             'tw-table-striped': mergedConfig().striped,\n             'tw-border': mergedConfig().bordered,\n             'tw-table-sm': mergedConfig().compact\n           }\"\n           style=\"table-layout: fixed;\">\n      \n      <!-- Table Header -->\n      <thead class=\"tw-bg-gray-50\" \n            [ngClass]=\"[\n              mergedConfig().headerClass || '',\n              scrollConfig?.enabled && scrollConfig?.stickyHeader ? 'tw-sticky tw-top-0 tw-z-10' : ''\n            ]\">\n        <tr>\n          @for (column of columns; track column.key) {\n            <th\n              class=\"tw-px-3 tw-py-2 tw-text-left tw-text-xs tw-font-medium tw-text-gray-500 tw-uppercase tw-tracking-wider tw-truncate\"\n              [ngClass]=\"[\n                getColumnWidthClass(column.width),\n                getColumnMaxWidthClass(column.width),\n                column.align === 'center' ? 'tw-text-center' : '',\n                column.align === 'right' ? 'tw-text-right' : ''\n              ]\"\n              [title]=\"column.header\">\n              {{ column.header }}\n            </th>\n          }\n        </tr>\n      </thead>\n\n      <!-- Table Body -->\n      <tbody class=\"tw-bg-white tw-divide-y tw-divide-gray-200\">\n        @if (loading() || isRefreshing() || pageChangeLoading()) {\n          <!-- Skeleton Loading Rows -->\n          @for (skeletonItem of getSkeletonArray(); track $index) {\n            <tr class=\"tw-animate-pulse tw-border-b tw-border-gray-200\">\n              @for (column of columns; track column.key) {\n                <td class=\"tw-px-3 tw-py-2 tw-whitespace-nowrap\"\n                    [ngClass]=\"[\n                      getColumnWidthClass(column.width),\n                      getColumnMaxWidthClass(column.width)\n                    ]\">\n                  <div class=\"tw-h-2 tw-bg-gray-200 tw-rounded tw-w-3/4\"></div>\n                </td>\n              }\n            </tr>\n          }\n        } @else {\n          @for (item of displayedData; track trackByFn($index, item)) {\n            <tr class=\"tw-group hover:tw-bg-gray-50 tw-border-b-2 tw-border-gray-200\"\n                [ngClass]=\"[\n                  mergedConfig().rowClass || '',\n                  isRefreshing() ? 'tw-opacity-60 tw-pointer-events-none' : '',\n                  isDragDropEnabled() ? 'tw-cursor-move tw-border-2 tw-border-transparent' : '',\n                  !isDragDropEnabled() ? 'tw-transition-colors tw-duration-150' : '',\n                  isTreeEnabled() ? getTreeLevelClass(item) : ''\n                ]\"\n                [style.border-color]=\"isDragOverRow === $index ? '#3b82f6' : 'transparent'\"\n                [style.background-color]=\"isDragOverRow === $index ? '#eff6ff' : ''\"\n                (click)=\"onRowClick(item)\"\n                (keydown.enter)=\"onRowClick(item)\"\n                (keydown.space)=\"onRowClick(item)\"\n                [class.tw-cursor-pointer]=\"mergedConfig().onRowClick && !isDragDropEnabled()\"\n                [tabindex]=\"mergedConfig().onRowClick && !isDragDropEnabled() ? 0 : -1\"\n                [attr.role]=\"mergedConfig().onRowClick && !isDragDropEnabled() ? 'button' : null\"\n                [attr.aria-label]=\"mergedConfig().onRowClick && !isDragDropEnabled() ? 'Select row' : null\"\n                [draggable]=\"isDragDropEnabled()\"\n                (dragstart)=\"onDragStart($event, item, $index)\"\n                (dragover)=\"onDragOver($event)\"\n                (dragleave)=\"onDragLeave($event)\"\n                (drop)=\"onDrop($event, item, $index)\"\n                (dragend)=\"onDragEnd($event)\">\n              \n              @for (column of columns; track column.key) {\n                <td class=\"tw-pr-3 tw-py-1 tw-relative\"\n                    [ngClass]=\"[\n                      getColumnWidthClass(column.width),\n                      getColumnMaxWidthClass(column.width),\n                      mergedConfig().cellClass || '',\n                      column.align === 'center' ? 'tw-text-center' : '',\n                      column.align === 'right' ? 'tw-text-right' : '',\n                      column.truncate !== false ? 'tw-whitespace-nowrap' : 'tw-whitespace-normal'\n                    ]\"\n                    [style.paddingLeft]=\"isTreeEnabled() && $index === 0 ? getTreeIndentStyle(item) : '12px'\"\n                    [style.maxWidth]=\"getColumnMaxWidthClass(column.width) === 'tw-max-w-xs' ? '200px' : getColumnMaxWidthClass(column.width) === 'tw-max-w-sm' ? '300px' : getColumnMaxWidthClass(column.width) === 'tw-max-w-md' ? '400px' : 'none'\"\n                    [style.minWidth]=\"isTreeEnabled() && $index === 0 ? '150px' : '100px'\">\n                  <!-- Tree Expand/Collapse Button (only for first column when tree is enabled) -->\n                  @if (isTreeEnabled() && $index === 0) {\n                    <div class=\"tw-flex tw-items-center tw-space-x-2\">\n                      <!-- Tree Indentation -->\n                      <div class=\"tw-flex tw-items-center\">\n                        @if (hasChildren(item)) {\n                          <button \n                            variant=\"outline\"\n                            size=\"xs\"\n                            type=\"button\"\n                            (click)=\"onActionClick(item, { key: 'toggle-expand', label: 'Toggle', icon: '', variant: 'ghost', onClick: 'toggle-expand' }); $event.stopPropagation()\"\n                            class=\"tw-flex tw-items-center tw-justify-center tw-w-5 tw-h-5 tw-text-gray-500 hover:tw-text-gray-700 tw-rounded\"\n                            [class.tw-transition-colors]=\"!isDragDropEnabled()\"\n                            [title]=\"isItemExpanded(item) ? 'Collapse' : 'Expand'\">\n                            <cide-ele-icon \n                              class=\"tw-w-3 tw-h-3\"\n                              [class.tw-transition-transform]=\"!isDragDropEnabled()\"\n                              [class.tw-rotate-90]=\"isItemExpanded(item)\"\n                              size=\"xs\">\n                              chevron_right\n                            </cide-ele-icon>\n                          </button>\n                        } @else {\n                          <div class=\"tw-w-8 tw-h-5 tw-flex tw-items-center tw-justify-center\">\n                            <!-- <div class=\"tw-w-1 tw-h-1 tw-bg-gray-300 tw-rounded-full\"></div> -->\n                          </div>\n                        }\n                      </div>\n                      \n                      <!-- Cell Content -->\n                      <div class=\"tw-flex-1 tw-w-full\">\n                        @if (column.type === 'text') {\n                          <p class=\"tw-text-sm tw-text-gray-900\"\n                             [class.tw-truncate]=\"column.truncate\"\n                             [title]=\"column.truncate ? (getNestedValue(item, column.valueGetter || column.key) || '').toString() : ''\">\n                            {{ formatValue(getNestedValue(item, column.valueGetter || column.key), column) }}\n                          </p>\n                        } @else if (column.type === 'number') {\n                          <span class=\"tw-text-sm tw-text-gray-900 tw-font-mono\">\n                            {{ formatValue(getNestedValue(item, column.valueGetter || column.key), column) }}\n                          </span>\n                        } @else if (column.type === 'date') {\n                          <span class=\"tw-text-sm tw-text-gray-600\">\n                            {{ formatValue(getNestedValue(item, column.valueGetter || column.key), column) }}\n                          </span>\n                        } @else if (column.type === 'boolean') {\n                          <span class=\"tw-inline-flex tw-items-center tw-px-2 tw-py-0.5 tw-rounded-full tw-text-xs tw-font-medium\"\n                                [ngClass]=\"getNestedValue(item, column.valueGetter || column.key) ? 'tw-bg-green-100 tw-text-green-800' : 'tw-bg-red-100 tw-text-red-800'\">\n                            {{ getNestedValue(item, column.valueGetter || column.key) ? 'Yes' : 'No' }}\n                          </span>\n                        } @else if (column.type === 'status' && column.statusConfig) {\n                          <span class=\"tw-inline-flex tw-items-center tw-px-2 tw-py-0.5 tw-rounded-full tw-text-xs tw-font-medium\"\n                                [ngClass]=\"getStatusClass(getNestedValue(item, column.valueGetter || column.key), column.statusConfig)\">\n                            {{ getStatusText(getNestedValue(item, column.valueGetter || column.key), column.statusConfig) }}\n                          </span>\n                        } @else if (column.type === 'actions' && column.actions) {\n                          <div class=\"tw-flex tw-items-center tw-space-x-2\">\n                            @for (action of column.actions; track action.key) {\n                              <button\n                                cideEleButton\n                                [variant]=\"action.variant || 'ghost'\"\n                                size=\"xs\"\n                                type=\"button\"\n                                (click)=\"onActionClick(item, action); $event.stopPropagation()\"\n                                [title]=\"action.tooltip || action.label\"\n                                [disabled]=\"isRefreshing()\"\n                                class=\"tw-inline-flex tw-items-center tw-px-2 tw-py-2 tw-text-xs tw-font-medium tw-rounded\"\n                                [class.tw-transition-colors]=\"!isDragDropEnabled()\"\n                                [ngClass]=\"{\n                                  'tw-text-gray-700 tw-bg-gray-100 hover:tw-bg-gray-200': action.variant === 'ghost',\n                                  'tw-text-white tw-bg-blue-600 hover:tw-bg-blue-700': action.variant === 'primary',\n                                  'tw-text-blue-700 tw-bg-blue-50 tw-border tw-border-blue-200 hover:tw-bg-blue-100': action.variant === 'outline',\n                                  'tw-text-white tw-bg-red-600 hover:tw-bg-red-700': action.variant === 'danger'\n                                }\">\n                                @if (action.icon) {\n                                  <svg class=\"tw-w-3 tw-h-3 tw-mr-1\" fill=\"currentColor\" viewBox=\"0 0 20 20\">\n                                    <path d=\"M10 12l-5-5h10l-5 5z\"/>\n                                  </svg>\n                                }\n                                {{ action.label }}\n                              </button>\n                            }\n                          </div>\n                        } @else if (column.type === 'custom') {\n                          <!-- Template Renderer -->\n                          @if (column.renderer && isTemplateRenderer(column.renderer)) {\n                            <ng-container \n                              *ngTemplateOutlet=\"getTemplateRenderer(column.renderer)!; \n                                                context: getTemplateContext(getNestedValue(item, column.valueGetter || column.key), item, column)\">\n                            </ng-container>\n                          }\n                          <!-- String Renderer -->\n                          @else if (column.renderer && isStringRenderer(column.renderer)) {\n                            <div [innerHTML]=\"renderCustomCell(getNestedValue(item, column.valueGetter || column.key), item, column)\">\n                            </div>\n                          }\n                          <!-- Default rendering -->\n                          @else {\n                            <div [innerHTML]=\"renderCustomCell(getNestedValue(item, column.valueGetter || column.key), item, column)\">\n                            </div>\n                          }\n                        }\n                      </div>\n                    </div>\n                  } @else {\n                    <!-- Regular cell content (non-tree or non-first column) -->\n                    @if (column.type === 'text') {\n                      <p class=\"tw-text-sm tw-text-gray-900\"\n                         [class.tw-truncate]=\"column.truncate\"\n                         [title]=\"column.truncate ? (getNestedValue(item, column.valueGetter || column.key) || '').toString() : ''\">\n                        {{ formatValue(getNestedValue(item, column.valueGetter || column.key), column) }}\n                      </p>\n                    } @else if (column.type === 'number') {\n                      <span class=\"tw-text-sm tw-text-gray-900 tw-font-mono\">\n                        {{ formatValue(getNestedValue(item, column.valueGetter || column.key), column) }}\n                      </span>\n                    } @else if (column.type === 'date') {\n                      <span class=\"tw-text-sm tw-text-gray-600\">\n                        {{ formatValue(getNestedValue(item, column.valueGetter || column.key), column) }}\n                      </span>\n                    } @else if (column.type === 'boolean') {\n                      <span class=\"tw-inline-flex tw-items-center tw-px-2 tw-py-0.5 tw-rounded-full tw-text-xs tw-font-medium\"\n                            [ngClass]=\"getNestedValue(item, column.valueGetter || column.key) ? 'tw-bg-green-100 tw-text-green-800' : 'tw-bg-red-100 tw-text-red-800'\">\n                        {{ getNestedValue(item, column.valueGetter || column.key) ? 'Yes' : 'No' }}\n                      </span>\n                    } @else if (column.type === 'status' && column.statusConfig) {\n                      <span class=\"tw-inline-flex tw-items-center tw-px-2 tw-py-0.5 tw-rounded-full tw-text-xs tw-font-medium\"\n                            [ngClass]=\"getStatusClass(getNestedValue(item, column.valueGetter || column.key), column.statusConfig)\">\n                        {{ getStatusText(getNestedValue(item, column.valueGetter || column.key), column.statusConfig) }}\n                      </span>\n                    } @else if (column.type === 'actions' && column.actions) {\n                      <div class=\"tw-flex tw-items-center tw-space-x-2\">\n                        @for (action of column.actions; track action.key) {\n                          <button\n                            cideEleButton\n                            [variant]=\"action.variant || 'ghost'\"\n                            size=\"xs\"\n                            type=\"button\"\n                            (click)=\"onActionClick(item, action); $event.stopPropagation()\"\n                            [title]=\"action.tooltip || action.label\"\n                            [disabled]=\"isRefreshing()\"\n                            class=\"tw-inline-flex tw-items-center tw-px-2 tw-py-2 tw-text-xs tw-font-medium tw-rounded\"\n                            [class.tw-transition-colors]=\"!isDragDropEnabled()\"\n                            [ngClass]=\"{\n                              'tw-text-gray-700 tw-bg-gray-100 hover:tw-bg-gray-200': action.variant === 'ghost',\n                              'tw-text-white tw-bg-blue-600 hover:tw-bg-blue-700': action.variant === 'primary',\n                              'tw-text-blue-700 tw-bg-blue-50 tw-border tw-border-blue-200 hover:tw-bg-blue-100': action.variant === 'outline',\n                              'tw-text-white tw-bg-red-600 hover:tw-bg-red-700': action.variant === 'danger'\n                            }\">\n                            @if (action.icon) {\n                              <svg class=\"tw-w-3 tw-h-3 tw-mr-1\" fill=\"currentColor\" viewBox=\"0 0 20 20\">\n                                <path d=\"M10 12l-5-5h10l-5 5z\"/>\n                              </svg>\n                            }\n                            {{ action.label }}\n                          </button>\n                        }\n                      </div>\n                    } @else if (column.type === 'custom') {\n                      <!-- Template Renderer -->\n                      @if (column.renderer && isTemplateRenderer(column.renderer)) {\n                        <ng-container \n                          *ngTemplateOutlet=\"getTemplateRenderer(column.renderer)!; \n                                            context: getTemplateContext(getNestedValue(item, column.valueGetter || column.key), item, column)\">\n                        </ng-container>\n                      }\n                      <!-- String Renderer -->\n                      @else if (column.renderer && isStringRenderer(column.renderer)) {\n                        <div [innerHTML]=\"renderCustomCell(getNestedValue(item, column.valueGetter || column.key), item, column)\">\n                        </div>\n                      }\n                      <!-- Default rendering -->\n                      @else {\n                        <div [innerHTML]=\"renderCustomCell(getNestedValue(item, column.valueGetter || column.key), item, column)\">\n                        </div>\n                      }\n                    }\n                  }\n                </td>\n              }\n            </tr>\n          }\n          \n          <!-- Empty State -->\n          @if (displayedData.length === 0) {\n            <tr class=\"tw-h-full\">\n              <td [attr.colspan]=\"columns.length\" class=\"tw-px-6 tw-py-22 tw-text-center tw-h-full tw-align-middle\">\n                <div class=\"tw-text-gray-500 tw-flex tw-flex-col tw-items-center tw-justify-center tw-min-h-[300px]\">\n                  <svg class=\"tw-mx-auto tw-h-12 tw-w-12 tw-text-gray-400\" fill=\"none\" stroke=\"currentColor\" viewBox=\"0 0 24 24\">\n                    <path stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M9 12h6m-6 4h6m2 5H7a2 2 0 01-2-2V5a2 2 0 012-2h5.586a1 1 0 01.707.293l5.414 5.414a1 1 0 01.293.707V19a2 2 0 01-2 2z\"></path>\n                  </svg>\n                  <h3 class=\"tw-mt-2 tw-text-sm tw-font-medium tw-text-gray-900\">No data found</h3>\n                  <p class=\"tw-mt-1 tw-text-sm tw-text-gray-500\">\n                    @if (searchQuery()) {\n                      No results match your search criteria.\n                    } @else {\n                      There are no items to display.\n                    }\n                  </p>\n                </div>\n              </td>\n            </tr>\n          }\n        }\n      </tbody>\n    </table>\n  </div>\n\n     <!-- Pagination Section -->\n   @if (paginationConfig.enabled && totalItems() > 0) {\n     <div class=\"tw-px-3 tw-py-2 tw-border-t tw-border-gray-200 tw-bg-white tw-relative tw-z-20\"\n          [class.tw-opacity-60]=\"isRefreshing()\">\n      \n      <!-- Results Info and Page Size -->\n      <div class=\"tw-flex tw-flex-col sm:tw-flex-row tw-justify-between tw-items-start sm:tw-items-center tw-space-y-2 sm:tw-space-y-0\">\n        \n        <!-- Results Info -->\n        @if (paginationConfig.showPageInfo) {\n          <div class=\"tw-flex tw-items-center tw-space-x-4\">\n            <p class=\"tw-text-sm tw-text-gray-700\">\n              Showing {{ getItemRangeText() }} results\n            </p>\n            \n                         <!-- Page Size Selector -->\n             <div class=\"tw-flex tw-items-center tw-space-x-2\">\n               <span class=\"tw-text-sm tw-text-gray-700\">Per page:</span>\n               <div class=\"tw-w-20 tw-relative\">\n                 <cide-ele-select\n                   [labelHide]=\"true\"\n                   [ngModel]=\"pageSize()\"\n                   (ngModelChange)=\"updatePageSize($event)\"\n                   [options]=\"getPageSizeOptions()\"\n                   [disabled]=\"isRefreshing()\"\n                   fill=\"outline\"\n                   size=\"sm\"\n                   class=\"tw-z-30\">\n                 </cide-ele-select>\n               </div>\n             </div>\n          </div>\n        }\n\n        <!-- Pagination Controls -->\n        <div class=\"tw-flex tw-items-center tw-space-x-3\">\n          \n          <!-- Previous/Next and Page Numbers -->\n          <div class=\"tw-flex tw-items-center tw-space-x-1\">\n            \n            <!-- First Page -->\n            <button\n              cideEleButton\n              variant=\"ghost\"\n              size=\"sm\"\n              type=\"button\"\n              (click)=\"onPageChange(1)\"\n              [disabled]=\"currentPage() === 1 || isRefreshing()\"\n              class=\"tw-px-3 tw-py-2 tw-text-lg tw-text-gray-500 hover:tw-text-gray-700 hover:tw-bg-gray-100 tw-rounded-md tw-transition-colors disabled:tw-opacity-50 disabled:tw-cursor-not-allowed\">\n              \u00AB\u00AB\n            </button>\n            \n            <!-- Previous Page -->\n            <button\n              cideEleButton\n              variant=\"ghost\"\n              size=\"sm\"\n              type=\"button\"\n              (click)=\"previousPage()\"\n              [disabled]=\"!hasPreviousPage() || isRefreshing()\"\n              class=\"tw-px-3 tw-py-2 tw-text-lg tw-text-gray-500 hover:tw-text-gray-700 hover:tw-bg-gray-100 tw-rounded-md tw-transition-colors disabled:tw-opacity-50 disabled:tw-cursor-not-allowed\">\n              \u2039\n            </button>\n            \n            <!-- Page Numbers -->\n            @for (page of getEnhancedPageNumbers(); track page) {\n              @if (page === '...') {\n                <span class=\"tw-px-2 tw-py-2 tw-text-sm tw-text-gray-500\">...</span>\n              } @else {\n                <button\n                  cideEleButton\n                  [variant]=\"currentPage() === page ? 'primary' : 'outline'\"\n                  size=\"sm\"\n                  type=\"button\"\n                  (click)=\"onPageChange(page)\"\n                  [disabled]=\"isRefreshing()\"\n                  class=\"tw-px-3 tw-py-2 tw-text-sm tw-border tw-rounded-md tw-transition-colors\"\n                  [ngClass]=\"{\n                    'tw-bg-blue-600 tw-text-white tw-border-blue-600': currentPage() === page,\n                    'tw-bg-white tw-text-gray-700 tw-border-gray-300 hover:tw-bg-gray-50': currentPage() !== page\n                  }\">\n                  {{ page }}\n                </button>\n              }\n            }\n            \n            <!-- Next Page -->\n            <button\n              cideEleButton\n              variant=\"ghost\"\n              size=\"sm\"\n              type=\"button\"\n              (click)=\"nextPage()\"\n              [disabled]=\"!hasNextPage() || isRefreshing()\"\n              class=\"tw-px-3 tw-py-2 tw-text-lg tw-text-gray-500 hover:tw-text-gray-700 hover:tw-bg-gray-100 tw-rounded-md tw-transition-colors disabled:tw-opacity-50 disabled:tw-cursor-not-allowed\">\n              \u203A\n            </button>\n            \n            <!-- Last Page -->\n            <button\n              cideEleButton\n              variant=\"ghost\"\n              size=\"sm\"\n              type=\"button\"\n              (click)=\"onPageChange(totalPages())\"\n              [disabled]=\"currentPage() === totalPages() || isRefreshing()\"\n              class=\"tw-px-3 tw-py-2 tw-text-lg tw-text-gray-500 hover:tw-text-gray-700 hover:tw-bg-gray-100 tw-rounded-md tw-transition-colors disabled:tw-opacity-50 disabled:tw-cursor-not-allowed\">\n              \u00BB\u00BB\n            </button>\n            \n          </div>\n\n          <!-- Quick Jump and Refresh -->\n          @if (paginationConfig.showQuickJump || paginationConfig.showRefresh) {\n            <div class=\"tw-flex tw-items-center tw-space-x-2 tw-border-l tw-border-gray-200 tw-pl-3\">\n              \n              <!-- Quick Jump -->\n              @if (paginationConfig.showQuickJump) {\n                                  <div class=\"tw-flex tw-items-center tw-space-x-1\">\n                    <span class=\"tw-text-sm tw-text-gray-700\">Go to:</span>\n                    <div class=\"tw-w-20\">\n                                              <cide-ele-input id=\"jump-to-page-input\" type=\"number\" [labelHide]=\"true\" [hideHelperAndErrorText]=\"true\"\n                          [(ngModel)]=\"jumpToPage\" [min]=\"1\" [max]=\"totalPages()\"\n                          [disabled]=\"isRefreshing()\"\n                          (keydown.enter)=\"onJumpToPage()\">\n                      </cide-ele-input>\n                    </div>\n                  <button\n                    cideEleButton\n                    variant=\"outline\"\n                    size=\"sm\"\n                    type=\"button\"\n                    (click)=\"onJumpToPage()\"\n                    [disabled]=\"isRefreshing()\"\n                    class=\"tw-px-3 tw-py-2 tw-text-sm tw-bg-gray-100 tw-text-gray-700 tw-border tw-border-gray-300 tw-rounded-md hover:tw-bg-gray-200 disabled:tw-opacity-50 disabled:tw-cursor-not-allowed\">\n                    Go\n                  </button>\n                </div>\n              }\n              \n              <!-- Refresh Button -->\n              @if (paginationConfig.showRefresh) {\n                <button\n                  cideEleButton\n                  variant=\"outline\"\n                  size=\"sm\"\n                  type=\"button\"\n                  (click)=\"onRefresh()\"\n                  [disabled]=\"isRefreshing()\"\n                  class=\"!tw-w-10 !tw-h-8 tw-flex tw-items-center tw-justify-center tw-text-gray-600 tw-bg-gray-100 tw-border tw-border-gray-300 tw-rounded-md hover:tw-bg-gray-200 disabled:tw-opacity-50 disabled:tw-cursor-not-allowed\">\n                  @if (isRefreshing()) {\n                    <svg class=\"tw-animate-spin tw-h-4 tw-w-4\" fill=\"none\" viewBox=\"0 0 24 24\">\n                      <circle class=\"tw-opacity-25\" cx=\"12\" cy=\"12\" r=\"10\" stroke=\"currentColor\" stroke-width=\"4\"></circle>\n                      <path class=\"tw-opacity-75\" fill=\"currentColor\" d=\"M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z\"></path>\n                    </svg>\n                  } @else {\n                    <svg class=\"tw-h-4 tw-w-4\" fill=\"none\" stroke=\"currentColor\" viewBox=\"0 0 24 24\">\n                      <path stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M4 4v5h.582m15.356 2A8.001 8.001 0 004.582 9m0 0H9m11 11v-5h-.581m0 0a8.003 8.003 0 01-15.357-2m15.357 2H15\"></path>\n                    </svg>\n                  }\n                </button>\n              }\n            </div>\n          }\n          \n        </div>\n      </div>\n    </div>\n  }\n</div>\n", styles: [".data-grid-container{width:100%;display:flex;flex-direction:column}.data-grid-container.tw-h-full{height:100%;min-height:100%}.data-grid-container .tw-overflow-x-auto{scrollbar-width:thin;scrollbar-color:#d1d5db #f9fafb}.data-grid-container .tw-overflow-x-auto.tw-flex-1{flex:1;min-height:0}.data-grid-container .tw-overflow-x-auto::-webkit-scrollbar{height:6px}.data-grid-container .tw-overflow-x-auto::-webkit-scrollbar-track{background:#f9fafb}.data-grid-container .tw-overflow-x-auto::-webkit-scrollbar-thumb{background:#d1d5db;border-radius:3px}.data-grid-container .tw-overflow-x-auto::-webkit-scrollbar-thumb:hover{background:#9ca3af}.data-grid-container table{min-height:300px}.data-grid-container.tw-h-full table,.data-grid-container.tw-h-full tbody{height:100%}.data-grid-container.tw-table-striped tbody tr:nth-child(2n){background-color:#f9fafb}.data-grid-container.tw-table-sm th,.data-grid-container.tw-table-sm td{padding:.5rem 1rem}.data-grid-container tbody tr:hover{background-color:#f3f4f6}.data-grid-container tbody tr.tw-cursor-pointer:hover{background-color:#e5f3ff}.data-grid-container.loading-overlay{position:relative}.data-grid-container.loading-overlay:after{content:\"\";position:absolute;inset:0;background:#fffc;z-index:10}.data-grid-container .tw-animate-pulse div{animation:pulse 2s cubic-bezier(.4,0,.6,1) infinite}@keyframes pulse{0%,to{opacity:1}50%{opacity:.5}}.data-grid-container .action-buttons{display:flex;gap:.25rem}.data-grid-container .action-buttons button{transition:all .15s ease-in-out}.data-grid-container .action-buttons button:hover:not(:disabled){transform:translateY(-1px);box-shadow:0 2px 4px #0000001a}.data-grid-container .action-buttons button:disabled{cursor:not-allowed;opacity:.5}.data-grid-container .pagination-controls button{transition:all .15s ease-in-out}.data-grid-container .pagination-controls button:hover:not(:disabled){transform:translateY(-1px)}.data-grid-container .pagination-controls button:disabled{cursor:not-allowed}.data-grid-container .pagination-controls button.active{box-shadow:0 2px 4px #3b82f64d}.data-grid-container .pagination-controls input[type=number]{transition:border-color .15s ease-in-out}.data-grid-container .pagination-controls input[type=number]:focus{outline:none;border-color:#3b82f6;box-shadow:0 0 0 3px #3b82f61a}.data-grid-container .status-badge{font-weight:500;letter-spacing:.025em}.data-grid-container .status-badge.active{background-color:#d1fae5;color:#065f46}.data-grid-container .status-badge.inactive{background-color:#fee2e2;color:#991b1b}.data-grid-container .search-input{position:relative}.data-grid-container .search-input input{transition:all .15s ease-in-out}.data-grid-container .search-input input:focus{box-shadow:0 0 0 3px #3b82f61a}.data-grid-container .search-input .search-icon{pointer-events:none}.data-grid-container .empty-state{padding:3rem 1.5rem;text-align:center}.data-grid-container .empty-state svg{margin:0 auto 1rem;opacity:.4}.data-grid-container .empty-state h3{margin-bottom:.5rem}.data-grid-container.tw-h-full tbody tr:only-child td{height:100%;vertical-align:middle}.data-grid-container.tw-h-full table.empty-table{height:100%}.data-grid-container.tw-h-full tbody tr:only-child{height:100%}@media (max-width: 640px){.data-grid-container .tw-px-6{padding-left:1rem;padding-right:1rem}.data-grid-container .pagination-controls{flex-direction:column;gap:1rem}.data-grid-container .pagination-controls .flex{justify-content:center}.data-grid-container .pagination-info{display:none}.data-grid-container .search-actions{flex-direction:column;gap:1rem}}@media (prefers-color-scheme: dark){.data-grid-container.dark-mode{background-color:#1f2937;color:#f9fafb}.data-grid-container.dark-mode table{background-color:#1f2937}.data-grid-container.dark-mode thead{background-color:#374151}.data-grid-container.dark-mode tbody tr{border-color:#374151}.data-grid-container.dark-mode tbody tr:hover{background-color:#374151}.data-grid-container.dark-mode .tw-text-gray-900{color:#f9fafb!important}.data-grid-container.dark-mode .tw-text-gray-600{color:#d1d5db!important}.data-grid-container.dark-mode .tw-text-gray-500{color:#9ca3af!important}}.data-grid-container.drag-drop-enabled tbody tr{transition:all .2s ease}.data-grid-container.drag-drop-enabled tbody tr:hover{background-color:#f3f4f6}.data-grid-container.drag-drop-enabled tbody tr.tw-opacity-50{background-color:#dbeafecc;border:2px dashed #3b82f6;border-radius:4px}.data-grid-container.drag-drop-enabled tbody tr.tw-bg-blue-50{background-color:#eff6ffe6}.data-grid-container.drag-drop-enabled tbody tr[draggable=true]{cursor:move;position:relative}.data-grid-container.drag-drop-enabled tbody tr[draggable=true]:hover{background-color:#f8fafc;box-shadow:0 1px 3px #0000001a}.data-grid-container.drag-drop-enabled tbody tr[draggable=true]:active{cursor:grabbing}.data-grid-container.drag-drop-enabled tbody tr[style*=border-top]{position:relative}.data-grid-container.drag-drop-enabled tbody tr[style*=border-top]:before{content:\"\";position:absolute;top:-2px;left:0;right:0;height:2px;background:linear-gradient(90deg,#3b82f6,#60a5fa);z-index:10}.data-grid-container.tree-enabled tbody tr td:first-child{position:relative}.data-grid-container.tree-enabled tbody tr td:first-child button{transition:all .15s ease}.data-grid-container.tree-enabled tbody tr td:first-child button:hover{background-color:#f3f4f6;border-radius:2px}.data-grid-container.tree-enabled tbody tr td:first-child button svg{transition:transform .2s ease}.data-grid-container.tree-enabled tbody tr[style*=padding-left]{border-left:2px solid transparent}.data-grid-container.tree-enabled tbody tr[style*=padding-left]:hover{border-left-color:#e5e7eb}.tree-level-0{border-bottom:2px solid #e5e7eb!important;background-color:#fff}.tree-level-0:hover{background-color:#f5f5f5!important}.tree-level-0 td:first-child{font-weight:600}.tree-level-1{border-bottom:1px solid #d1d5db!important;background-color:#fafafa}.tree-level-1:hover{background-color:#f1f5f9!important}.tree-level-1 td:first-child{font-weight:500}.tree-level-2{border-bottom:1px solid #d1d5db!important;background-color:#f9fafb}.tree-level-2:hover{background-color:#f3f4f6!important}.tree-level-2 td:first-child{font-weight:400}.tree-level-deep{border-bottom:1px solid #e5e7eb!important;background-color:#fefefe}.tree-level-deep:hover{background-color:#f9fafb!important}.tree-level-deep td:first-child{font-weight:300}table td{box-sizing:border-box;word-wrap:break-word;overflow-wrap:break-word}table td.tw-overflow-hidden{overflow:hidden;text-overflow:ellipsis}table td:first-child{min-width:150px}table td:first-child>div{display:flex;align-items:center;min-width:0}table td:first-child>div .tw-flex{min-width:0}table td .tw-truncate{overflow:hidden;text-overflow:ellipsis;white-space:nowrap;max-width:100%}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i1.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "ngmodule", type: FormsModule }, { kind: "directive", type: i2.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i2.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "component", type: CideInputComponent, selector: "cide-ele-input", inputs: ["fill", "label", "labelHide", "disabled", "clearInput", "labelPlacement", "labelDir", "placeholder", "leadingIcon", "trailingIcon", "helperText", "helperTextCollapse", "hideHelperAndErrorText", "errorText", "maxlength", "minlength", "required", "autocapitalize", "autocomplete", "type", "width", "id", "ngModel", "option", "min", "max", "size"], outputs: ["ngModelChange"] }, { kind: "component", type: CideSelectComponent, selector: "cide-ele-select", inputs: ["label", "labelHide", "placeholder", "helperText", "errorText", "required", "disabled", "id", "ngModel", "size", "fill", "labelPlacement", "labelDir", "leadingIcon", "trailingIcon", "clearInput", "options", "multiple", "searchable", "showSearchInput", "loading"], outputs: ["ngModelChange", "change", "searchChange"] }, { kind: "component", type: CideIconComponent, selector: "cide-ele-icon", inputs: ["size", "type", "toolTip"] }, { kind: "component", type: CideEleButtonComponent, selector: "button[cideEleButton], a[cideEleButton]", inputs: ["label", "variant", "size", "type", "shape", "elevation", "disabled", "id", "loading", "fullWidth", "leftIcon", "rightIcon", "customClass", "tooltip", "ariaLabel", "testId", "routerLink", "routerExtras", "preventDoubleClick", "animated"], outputs: ["btnClick", "doubleClick"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: CideEleDataGridComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'cide-ele-data-grid', standalone: true, imports: [
+                        CommonModule,
+                        FormsModule,
+                        CideInputComponent,
+                        CideSelectComponent,
+                        CideIconComponent,
+                        CideEleButtonComponent
+                    ], template: "  <!-- Data Grid Component -->\n  <div class=\"data-grid-container tw-bg-white tw-shadow tw-rounded-lg tw-overflow-visible tw-flex tw-flex-col\" \n       [ngClass]=\"[\n         mergedConfig().tableClass || '',\n         mergedConfig().fullHeight ? 'tw-h-full' : '',\n         isDragDropEnabled() ? 'drag-drop-enabled' : '',\n         isTreeEnabled() ? 'tree-enabled' : ''\n       ]\">\n  \n  <!-- Header Section -->\n  @if (mergedConfig().title || mergedConfig().subtitle) {\n    <div class=\"tw-px-3 tw-py-2 tw-border-b tw-border-gray-200\">\n      @if (mergedConfig().title) {\n        <h3 class=\"tw-text-base tw-font-semibold tw-text-gray-900\">\n          {{ mergedConfig().title }}\n        </h3>\n      }\n      @if (mergedConfig().subtitle) {\n        <p class=\"tw-text-sm tw-text-gray-600 tw-mt-0.5\">\n          {{ mergedConfig().subtitle }}\n        </p>\n      }\n    </div>\n  }\n\n  <!-- Search Section -->\n  @if (searchConfig.enabled) {\n    <div class=\"tw-px-3 tw-py-2 tw-border-b tw-border-gray-200\">\n      <div class=\"tw-flex tw-items-center tw-justify-between\">\n        <!-- Search Input -->\n        <div class=\"tw-max-w-md\">\n          <cide-ele-input [labelHide]=\"true\" [hideHelperAndErrorText]=\"true\" id=\"search-input\" type=\"text\"\n            [ngModel]=\"searchQuery()\"\n            (ngModelChange)=\"updateSearchQuery($event)\"\n            [placeholder]=\"searchConfig.placeholder\"\n            [disabled]=\"loading() || isRefreshing()\"\n            leadingIcon=\"search\"\n            fill=\"outline\">\n          </cide-ele-input>\n        </div>\n        \n        <!-- Drag Order Actions -->\n        @if (isDragDropEnabled() && (isDragging() || hasOrderChanged())) {\n          <div class=\"tw-flex tw-items-center tw-space-x-2\">\n            <button cideEleButton \n                    variant=\"outline\" \n                    size=\"sm\" \n                    (click)=\"onActionClick(null, { key: 'reset-order', label: 'Reset Order', icon: 'undo', variant: 'outline', onClick: 'resetOrder' })\"\n                    class=\"tw-text-blue-700 tw-border-blue-300 hover:tw-bg-blue-100\">\n              <cide-ele-icon size=\"xs\" class=\"tw-w-4 tw-h-4 tw-mr-1\">undo</cide-ele-icon>\n              Reset Order\n            </button>\n            <button cideEleButton \n                    variant=\"primary\" \n                    size=\"sm\" \n                    (click)=\"onActionClick(null, { key: 'save-order', label: 'Save Order', icon: 'save', variant: 'primary', onClick: 'saveOrder' })\"\n                    class=\"tw-bg-blue-600 hover:tw-bg-blue-700 tw-text-white\">\n              <cide-ele-icon size=\"xs\" class=\"tw-w-4 tw-h-4 tw-mr-1\">save</cide-ele-icon>\n              Save Order\n            </button>\n          </div>\n        }\n      </div>\n    </div>\n  }\n\n     <!-- Table Section -->\n   <div class=\"tw-overflow-x-auto tw-relative\"\n        [ngClass]=\"{\n          'tw-flex-1 tw-min-h-0': mergedConfig().fullHeight,\n          'tw-overflow-y-auto': scrollConfig?.enabled,\n          'tw-max-h-full': scrollConfig?.enabled\n        }\"\n        [style.maxHeight]=\"scrollConfig?.enabled ? scrollConfig?.maxHeight : null\"\n        [style.minHeight]=\"scrollConfig?.enabled ? scrollConfig?.minHeight : null\">\n    <table class=\"tw-min-w-full tw-divide-y tw-divide-gray-200 tw-h-full tw-table-fixed\"\n           [class.empty-table]=\"displayedData.length === 0\"\n           [ngClass]=\"{\n             'tw-table-striped': mergedConfig().striped,\n             'tw-border': mergedConfig().bordered,\n             'tw-table-sm': mergedConfig().compact\n           }\"\n           style=\"table-layout: fixed;\">\n      \n      <!-- Table Header -->\n      <thead class=\"tw-bg-gray-50\" \n            [ngClass]=\"[\n              mergedConfig().headerClass || '',\n              scrollConfig?.enabled && scrollConfig?.stickyHeader ? 'tw-sticky tw-top-0 tw-z-10' : ''\n            ]\">\n        <tr>\n          @for (column of columns; track column.key) {\n            <th\n              class=\"tw-px-3 tw-py-2 tw-text-left tw-text-xs tw-font-medium tw-text-gray-500 tw-uppercase tw-tracking-wider tw-truncate\"\n              [ngClass]=\"[\n                getColumnWidthClass(column.width),\n                getColumnMaxWidthClass(column.width),\n                column.align === 'center' ? 'tw-text-center' : '',\n                column.align === 'right' ? 'tw-text-right' : ''\n              ]\"\n              [title]=\"column.header\">\n              {{ column.header }}\n            </th>\n          }\n        </tr>\n      </thead>\n\n      <!-- Table Body -->\n      <tbody class=\"tw-bg-white tw-divide-y tw-divide-gray-200\">\n        @if (loading() || isRefreshing() || pageChangeLoading()) {\n          <!-- Skeleton Loading Rows -->\n          @for (skeletonItem of getSkeletonArray(); track $index) {\n            <tr class=\"tw-animate-pulse tw-border-b tw-border-gray-200\">\n              @for (column of columns; track column.key) {\n                <td class=\"tw-px-3 tw-py-2 tw-whitespace-nowrap\"\n                    [ngClass]=\"[\n                      getColumnWidthClass(column.width),\n                      getColumnMaxWidthClass(column.width)\n                    ]\">\n                  <div class=\"tw-h-2 tw-bg-gray-200 tw-rounded tw-w-3/4\"></div>\n                </td>\n              }\n            </tr>\n          }\n        } @else {\n          @for (item of displayedData; track trackByFn($index, item)) {\n            <tr class=\"tw-group hover:tw-bg-gray-50 tw-border-b-2 tw-border-gray-200\"\n                [ngClass]=\"[\n                  mergedConfig().rowClass || '',\n                  isRefreshing() ? 'tw-opacity-60 tw-pointer-events-none' : '',\n                  isDragDropEnabled() ? 'tw-cursor-move tw-border-2 tw-border-transparent' : '',\n                  !isDragDropEnabled() ? 'tw-transition-colors tw-duration-150' : '',\n                  isTreeEnabled() ? getTreeLevelClass(item) : ''\n                ]\"\n                [style.border-color]=\"isDragOverRow === $index ? '#3b82f6' : 'transparent'\"\n                [style.background-color]=\"isDragOverRow === $index ? '#eff6ff' : ''\"\n                (click)=\"onRowClick(item)\"\n                (keydown.enter)=\"onRowClick(item)\"\n                (keydown.space)=\"onRowClick(item)\"\n                [class.tw-cursor-pointer]=\"mergedConfig().onRowClick && !isDragDropEnabled()\"\n                [tabindex]=\"mergedConfig().onRowClick && !isDragDropEnabled() ? 0 : -1\"\n                [attr.role]=\"mergedConfig().onRowClick && !isDragDropEnabled() ? 'button' : null\"\n                [attr.aria-label]=\"mergedConfig().onRowClick && !isDragDropEnabled() ? 'Select row' : null\"\n                [draggable]=\"isDragDropEnabled()\"\n                (dragstart)=\"onDragStart($event, item, $index)\"\n                (dragover)=\"onDragOver($event)\"\n                (dragleave)=\"onDragLeave($event)\"\n                (drop)=\"onDrop($event, item, $index)\"\n                (dragend)=\"onDragEnd($event)\">\n              \n              @for (column of columns; track column.key) {\n                <td class=\"tw-pr-3 tw-py-1 tw-relative\"\n                    [ngClass]=\"[\n                      getColumnWidthClass(column.width),\n                      getColumnMaxWidthClass(column.width),\n                      mergedConfig().cellClass || '',\n                      column.align === 'center' ? 'tw-text-center' : '',\n                      column.align === 'right' ? 'tw-text-right' : '',\n                      column.truncate !== false ? 'tw-whitespace-nowrap' : 'tw-whitespace-normal'\n                    ]\"\n                    [style.paddingLeft]=\"isTreeEnabled() && $index === 0 ? getTreeIndentStyle(item) : '12px'\"\n                    [style.maxWidth]=\"getColumnMaxWidthClass(column.width) === 'tw-max-w-xs' ? '200px' : getColumnMaxWidthClass(column.width) === 'tw-max-w-sm' ? '300px' : getColumnMaxWidthClass(column.width) === 'tw-max-w-md' ? '400px' : 'none'\"\n                    [style.minWidth]=\"isTreeEnabled() && $index === 0 ? '150px' : '100px'\">\n                  <!-- Tree Expand/Collapse Button (only for first column when tree is enabled) -->\n                  @if (isTreeEnabled() && $index === 0) {\n                    <div class=\"tw-flex tw-items-center tw-space-x-2\">\n                      <!-- Tree Indentation -->\n                      <div class=\"tw-flex tw-items-center\">\n                        @if (hasChildren(item)) {\n                          <button \n                            variant=\"outline\"\n                            size=\"xs\"\n                            type=\"button\"\n                            (click)=\"onActionClick(item, { key: 'toggle-expand', label: 'Toggle', icon: '', variant: 'ghost', onClick: 'toggle-expand' }); $event.stopPropagation()\"\n                            class=\"tw-flex tw-items-center tw-justify-center tw-w-5 tw-h-5 tw-text-gray-500 hover:tw-text-gray-700 tw-rounded\"\n                            [class.tw-transition-colors]=\"!isDragDropEnabled()\"\n                            [title]=\"isItemExpanded(item) ? 'Collapse' : 'Expand'\">\n                            <cide-ele-icon \n                              class=\"tw-w-3 tw-h-3\"\n                              [class.tw-transition-transform]=\"!isDragDropEnabled()\"\n                              [class.tw-rotate-90]=\"isItemExpanded(item)\"\n                              size=\"xs\">\n                              chevron_right\n                            </cide-ele-icon>\n                          </button>\n                        } @else {\n                          <div class=\"tw-w-8 tw-h-5 tw-flex tw-items-center tw-justify-center\">\n                            <!-- <div class=\"tw-w-1 tw-h-1 tw-bg-gray-300 tw-rounded-full\"></div> -->\n                          </div>\n                        }\n                      </div>\n                      \n                      <!-- Cell Content -->\n                      <div class=\"tw-flex-1 tw-w-full\">\n                        @if (column.type === 'text') {\n                          <p class=\"tw-text-sm tw-text-gray-900\"\n                             [class.tw-truncate]=\"column.truncate\"\n                             [title]=\"column.truncate ? (getNestedValue(item, column.valueGetter || column.key) || '').toString() : ''\">\n                            {{ formatValue(getNestedValue(item, column.valueGetter || column.key), column) }}\n                          </p>\n                        } @else if (column.type === 'number') {\n                          <span class=\"tw-text-sm tw-text-gray-900 tw-font-mono\">\n                            {{ formatValue(getNestedValue(item, column.valueGetter || column.key), column) }}\n                          </span>\n                        } @else if (column.type === 'date') {\n                          <span class=\"tw-text-sm tw-text-gray-600\">\n                            {{ formatValue(getNestedValue(item, column.valueGetter || column.key), column) }}\n                          </span>\n                        } @else if (column.type === 'boolean') {\n                          <span class=\"tw-inline-flex tw-items-center tw-px-2 tw-py-0.5 tw-rounded-full tw-text-xs tw-font-medium\"\n                                [ngClass]=\"getNestedValue(item, column.valueGetter || column.key) ? 'tw-bg-green-100 tw-text-green-800' : 'tw-bg-red-100 tw-text-red-800'\">\n                            {{ getNestedValue(item, column.valueGetter || column.key) ? 'Yes' : 'No' }}\n                          </span>\n                        } @else if (column.type === 'status' && column.statusConfig) {\n                          <span class=\"tw-inline-flex tw-items-center tw-px-2 tw-py-0.5 tw-rounded-full tw-text-xs tw-font-medium\"\n                                [ngClass]=\"getStatusClass(getNestedValue(item, column.valueGetter || column.key), column.statusConfig)\">\n                            {{ getStatusText(getNestedValue(item, column.valueGetter || column.key), column.statusConfig) }}\n                          </span>\n                        } @else if (column.type === 'actions' && column.actions) {\n                          <div class=\"tw-flex tw-items-center tw-space-x-2\">\n                            @for (action of column.actions; track action.key) {\n                              <button\n                                cideEleButton\n                                [variant]=\"action.variant || 'ghost'\"\n                                size=\"xs\"\n                                type=\"button\"\n                                (click)=\"onActionClick(item, action); $event.stopPropagation()\"\n                                [title]=\"action.tooltip || action.label\"\n                                [disabled]=\"isRefreshing()\"\n                                class=\"tw-inline-flex tw-items-center tw-px-2 tw-py-2 tw-text-xs tw-font-medium tw-rounded\"\n                                [class.tw-transition-colors]=\"!isDragDropEnabled()\"\n                                [ngClass]=\"{\n                                  'tw-text-gray-700 tw-bg-gray-100 hover:tw-bg-gray-200': action.variant === 'ghost',\n                                  'tw-text-white tw-bg-blue-600 hover:tw-bg-blue-700': action.variant === 'primary',\n                                  'tw-text-blue-700 tw-bg-blue-50 tw-border tw-border-blue-200 hover:tw-bg-blue-100': action.variant === 'outline',\n                                  'tw-text-white tw-bg-red-600 hover:tw-bg-red-700': action.variant === 'danger'\n                                }\">\n                                @if (action.icon) {\n                                  <svg class=\"tw-w-3 tw-h-3 tw-mr-1\" fill=\"currentColor\" viewBox=\"0 0 20 20\">\n                                    <path d=\"M10 12l-5-5h10l-5 5z\"/>\n                                  </svg>\n                                }\n                                {{ action.label }}\n                              </button>\n                            }\n                          </div>\n                        } @else if (column.type === 'custom') {\n                          <!-- Template Renderer -->\n                          @if (column.renderer && isTemplateRenderer(column.renderer)) {\n                            <ng-container \n                              *ngTemplateOutlet=\"getTemplateRenderer(column.renderer)!; \n                                                context: getTemplateContext(getNestedValue(item, column.valueGetter || column.key), item, column)\">\n                            </ng-container>\n                          }\n                          <!-- String Renderer -->\n                          @else if (column.renderer && isStringRenderer(column.renderer)) {\n                            <div [innerHTML]=\"renderCustomCell(getNestedValue(item, column.valueGetter || column.key), item, column)\">\n                            </div>\n                          }\n                          <!-- Default rendering -->\n                          @else {\n                            <div [innerHTML]=\"renderCustomCell(getNestedValue(item, column.valueGetter || column.key), item, column)\">\n                            </div>\n                          }\n                        }\n                      </div>\n                    </div>\n                  } @else {\n                    <!-- Regular cell content (non-tree or non-first column) -->\n                    @if (column.type === 'text') {\n                      <p class=\"tw-text-sm tw-text-gray-900\"\n                         [class.tw-truncate]=\"column.truncate\"\n                         [title]=\"column.truncate ? (getNestedValue(item, column.valueGetter || column.key) || '').toString() : ''\">\n                        {{ formatValue(getNestedValue(item, column.valueGetter || column.key), column) }}\n                      </p>\n                    } @else if (column.type === 'number') {\n                      <span class=\"tw-text-sm tw-text-gray-900 tw-font-mono\">\n                        {{ formatValue(getNestedValue(item, column.valueGetter || column.key), column) }}\n                      </span>\n                    } @else if (column.type === 'date') {\n                      <span class=\"tw-text-sm tw-text-gray-600\">\n                        {{ formatValue(getNestedValue(item, column.valueGetter || column.key), column) }}\n                      </span>\n                    } @else if (column.type === 'boolean') {\n                      <span class=\"tw-inline-flex tw-items-center tw-px-2 tw-py-0.5 tw-rounded-full tw-text-xs tw-font-medium\"\n                            [ngClass]=\"getNestedValue(item, column.valueGetter || column.key) ? 'tw-bg-green-100 tw-text-green-800' : 'tw-bg-red-100 tw-text-red-800'\">\n                        {{ getNestedValue(item, column.valueGetter || column.key) ? 'Yes' : 'No' }}\n                      </span>\n                    } @else if (column.type === 'status' && column.statusConfig) {\n                      <span class=\"tw-inline-flex tw-items-center tw-px-2 tw-py-0.5 tw-rounded-full tw-text-xs tw-font-medium\"\n                            [ngClass]=\"getStatusClass(getNestedValue(item, column.valueGetter || column.key), column.statusConfig)\">\n                        {{ getStatusText(getNestedValue(item, column.valueGetter || column.key), column.statusConfig) }}\n                      </span>\n                    } @else if (column.type === 'actions' && column.actions) {\n                      <div class=\"tw-flex tw-items-center tw-space-x-2\">\n                        @for (action of column.actions; track action.key) {\n                          <button\n                            cideEleButton\n                            [variant]=\"action.variant || 'ghost'\"\n                            size=\"xs\"\n                            type=\"button\"\n                            (click)=\"onActionClick(item, action); $event.stopPropagation()\"\n                            [title]=\"action.tooltip || action.label\"\n                            [disabled]=\"isRefreshing()\"\n                            class=\"tw-inline-flex tw-items-center tw-px-2 tw-py-2 tw-text-xs tw-font-medium tw-rounded\"\n                            [class.tw-transition-colors]=\"!isDragDropEnabled()\"\n                            [ngClass]=\"{\n                              'tw-text-gray-700 tw-bg-gray-100 hover:tw-bg-gray-200': action.variant === 'ghost',\n                              'tw-text-white tw-bg-blue-600 hover:tw-bg-blue-700': action.variant === 'primary',\n                              'tw-text-blue-700 tw-bg-blue-50 tw-border tw-border-blue-200 hover:tw-bg-blue-100': action.variant === 'outline',\n                              'tw-text-white tw-bg-red-600 hover:tw-bg-red-700': action.variant === 'danger'\n                            }\">\n                            @if (action.icon) {\n                              <svg class=\"tw-w-3 tw-h-3 tw-mr-1\" fill=\"currentColor\" viewBox=\"0 0 20 20\">\n                                <path d=\"M10 12l-5-5h10l-5 5z\"/>\n                              </svg>\n                            }\n                            {{ action.label }}\n                          </button>\n                        }\n                      </div>\n                    } @else if (column.type === 'custom') {\n                      <!-- Template Renderer -->\n                      @if (column.renderer && isTemplateRenderer(column.renderer)) {\n                        <ng-container \n                          *ngTemplateOutlet=\"getTemplateRenderer(column.renderer)!; \n                                            context: getTemplateContext(getNestedValue(item, column.valueGetter || column.key), item, column)\">\n                        </ng-container>\n                      }\n                      <!-- String Renderer -->\n                      @else if (column.renderer && isStringRenderer(column.renderer)) {\n                        <div [innerHTML]=\"renderCustomCell(getNestedValue(item, column.valueGetter || column.key), item, column)\">\n                        </div>\n                      }\n                      <!-- Default rendering -->\n                      @else {\n                        <div [innerHTML]=\"renderCustomCell(getNestedValue(item, column.valueGetter || column.key), item, column)\">\n                        </div>\n                      }\n                    }\n                  }\n                </td>\n              }\n            </tr>\n          }\n          \n          <!-- Empty State -->\n          @if (displayedData.length === 0) {\n            <tr class=\"tw-h-full\">\n              <td [attr.colspan]=\"columns.length\" class=\"tw-px-6 tw-py-22 tw-text-center tw-h-full tw-align-middle\">\n                <div class=\"tw-text-gray-500 tw-flex tw-flex-col tw-items-center tw-justify-center tw-min-h-[300px]\">\n                  <svg class=\"tw-mx-auto tw-h-12 tw-w-12 tw-text-gray-400\" fill=\"none\" stroke=\"currentColor\" viewBox=\"0 0 24 24\">\n                    <path stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M9 12h6m-6 4h6m2 5H7a2 2 0 01-2-2V5a2 2 0 012-2h5.586a1 1 0 01.707.293l5.414 5.414a1 1 0 01.293.707V19a2 2 0 01-2 2z\"></path>\n                  </svg>\n                  <h3 class=\"tw-mt-2 tw-text-sm tw-font-medium tw-text-gray-900\">No data found</h3>\n                  <p class=\"tw-mt-1 tw-text-sm tw-text-gray-500\">\n                    @if (searchQuery()) {\n                      No results match your search criteria.\n                    } @else {\n                      There are no items to display.\n                    }\n                  </p>\n                </div>\n              </td>\n            </tr>\n          }\n        }\n      </tbody>\n    </table>\n  </div>\n\n     <!-- Pagination Section -->\n   @if (paginationConfig.enabled && totalItems() > 0) {\n     <div class=\"tw-px-3 tw-py-2 tw-border-t tw-border-gray-200 tw-bg-white tw-relative tw-z-20\"\n          [class.tw-opacity-60]=\"isRefreshing()\">\n      \n      <!-- Results Info and Page Size -->\n      <div class=\"tw-flex tw-flex-col sm:tw-flex-row tw-justify-between tw-items-start sm:tw-items-center tw-space-y-2 sm:tw-space-y-0\">\n        \n        <!-- Results Info -->\n        @if (paginationConfig.showPageInfo) {\n          <div class=\"tw-flex tw-items-center tw-space-x-4\">\n            <p class=\"tw-text-sm tw-text-gray-700\">\n              Showing {{ getItemRangeText() }} results\n            </p>\n            \n                         <!-- Page Size Selector -->\n             <div class=\"tw-flex tw-items-center tw-space-x-2\">\n               <span class=\"tw-text-sm tw-text-gray-700\">Per page:</span>\n               <div class=\"tw-w-20 tw-relative\">\n                 <cide-ele-select\n                   [labelHide]=\"true\"\n                   [ngModel]=\"pageSize()\"\n                   (ngModelChange)=\"updatePageSize($event)\"\n                   [options]=\"getPageSizeOptions()\"\n                   [disabled]=\"isRefreshing()\"\n                   fill=\"outline\"\n                   size=\"sm\"\n                   class=\"tw-z-30\">\n                 </cide-ele-select>\n               </div>\n             </div>\n          </div>\n        }\n\n        <!-- Pagination Controls -->\n        <div class=\"tw-flex tw-items-center tw-space-x-3\">\n          \n          <!-- Previous/Next and Page Numbers -->\n          <div class=\"tw-flex tw-items-center tw-space-x-1\">\n            \n            <!-- First Page -->\n            <button\n              cideEleButton\n              variant=\"ghost\"\n              size=\"sm\"\n              type=\"button\"\n              (click)=\"onPageChange(1)\"\n              [disabled]=\"currentPage() === 1 || isRefreshing()\"\n              class=\"tw-px-3 tw-py-2 tw-text-lg tw-text-gray-500 hover:tw-text-gray-700 hover:tw-bg-gray-100 tw-rounded-md tw-transition-colors disabled:tw-opacity-50 disabled:tw-cursor-not-allowed\">\n              \u00AB\u00AB\n            </button>\n            \n            <!-- Previous Page -->\n            <button\n              cideEleButton\n              variant=\"ghost\"\n              size=\"sm\"\n              type=\"button\"\n              (click)=\"previousPage()\"\n              [disabled]=\"!hasPreviousPage() || isRefreshing()\"\n              class=\"tw-px-3 tw-py-2 tw-text-lg tw-text-gray-500 hover:tw-text-gray-700 hover:tw-bg-gray-100 tw-rounded-md tw-transition-colors disabled:tw-opacity-50 disabled:tw-cursor-not-allowed\">\n              \u2039\n            </button>\n            \n            <!-- Page Numbers -->\n            @for (page of getEnhancedPageNumbers(); track page) {\n              @if (page === '...') {\n                <span class=\"tw-px-2 tw-py-2 tw-text-sm tw-text-gray-500\">...</span>\n              } @else {\n                <button\n                  cideEleButton\n                  [variant]=\"currentPage() === page ? 'primary' : 'outline'\"\n                  size=\"sm\"\n                  type=\"button\"\n                  (click)=\"onPageChange(page)\"\n                  [disabled]=\"isRefreshing()\"\n                  class=\"tw-px-3 tw-py-2 tw-text-sm tw-border tw-rounded-md tw-transition-colors\"\n                  [ngClass]=\"{\n                    'tw-bg-blue-600 tw-text-white tw-border-blue-600': currentPage() === page,\n                    'tw-bg-white tw-text-gray-700 tw-border-gray-300 hover:tw-bg-gray-50': currentPage() !== page\n                  }\">\n                  {{ page }}\n                </button>\n              }\n            }\n            \n            <!-- Next Page -->\n            <button\n              cideEleButton\n              variant=\"ghost\"\n              size=\"sm\"\n              type=\"button\"\n              (click)=\"nextPage()\"\n              [disabled]=\"!hasNextPage() || isRefreshing()\"\n              class=\"tw-px-3 tw-py-2 tw-text-lg tw-text-gray-500 hover:tw-text-gray-700 hover:tw-bg-gray-100 tw-rounded-md tw-transition-colors disabled:tw-opacity-50 disabled:tw-cursor-not-allowed\">\n              \u203A\n            </button>\n            \n            <!-- Last Page -->\n            <button\n              cideEleButton\n              variant=\"ghost\"\n              size=\"sm\"\n              type=\"button\"\n              (click)=\"onPageChange(totalPages())\"\n              [disabled]=\"currentPage() === totalPages() || isRefreshing()\"\n              class=\"tw-px-3 tw-py-2 tw-text-lg tw-text-gray-500 hover:tw-text-gray-700 hover:tw-bg-gray-100 tw-rounded-md tw-transition-colors disabled:tw-opacity-50 disabled:tw-cursor-not-allowed\">\n              \u00BB\u00BB\n            </button>\n            \n          </div>\n\n          <!-- Quick Jump and Refresh -->\n          @if (paginationConfig.showQuickJump || paginationConfig.showRefresh) {\n            <div class=\"tw-flex tw-items-center tw-space-x-2 tw-border-l tw-border-gray-200 tw-pl-3\">\n              \n              <!-- Quick Jump -->\n              @if (paginationConfig.showQuickJump) {\n                                  <div class=\"tw-flex tw-items-center tw-space-x-1\">\n                    <span class=\"tw-text-sm tw-text-gray-700\">Go to:</span>\n                    <div class=\"tw-w-20\">\n                                              <cide-ele-input id=\"jump-to-page-input\" type=\"number\" [labelHide]=\"true\" [hideHelperAndErrorText]=\"true\"\n                          [(ngModel)]=\"jumpToPage\" [min]=\"1\" [max]=\"totalPages()\"\n                          [disabled]=\"isRefreshing()\"\n                          (keydown.enter)=\"onJumpToPage()\">\n                      </cide-ele-input>\n                    </div>\n                  <button\n                    cideEleButton\n                    variant=\"outline\"\n                    size=\"sm\"\n                    type=\"button\"\n                    (click)=\"onJumpToPage()\"\n                    [disabled]=\"isRefreshing()\"\n                    class=\"tw-px-3 tw-py-2 tw-text-sm tw-bg-gray-100 tw-text-gray-700 tw-border tw-border-gray-300 tw-rounded-md hover:tw-bg-gray-200 disabled:tw-opacity-50 disabled:tw-cursor-not-allowed\">\n                    Go\n                  </button>\n                </div>\n              }\n              \n              <!-- Refresh Button -->\n              @if (paginationConfig.showRefresh) {\n                <button\n                  cideEleButton\n                  variant=\"outline\"\n                  size=\"sm\"\n                  type=\"button\"\n                  (click)=\"onRefresh()\"\n                  [disabled]=\"isRefreshing()\"\n                  class=\"!tw-w-10 !tw-h-8 tw-flex tw-items-center tw-justify-center tw-text-gray-600 tw-bg-gray-100 tw-border tw-border-gray-300 tw-rounded-md hover:tw-bg-gray-200 disabled:tw-opacity-50 disabled:tw-cursor-not-allowed\">\n                  @if (isRefreshing()) {\n                    <svg class=\"tw-animate-spin tw-h-4 tw-w-4\" fill=\"none\" viewBox=\"0 0 24 24\">\n                      <circle class=\"tw-opacity-25\" cx=\"12\" cy=\"12\" r=\"10\" stroke=\"currentColor\" stroke-width=\"4\"></circle>\n                      <path class=\"tw-opacity-75\" fill=\"currentColor\" d=\"M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z\"></path>\n                    </svg>\n                  } @else {\n                    <svg class=\"tw-h-4 tw-w-4\" fill=\"none\" stroke=\"currentColor\" viewBox=\"0 0 24 24\">\n                      <path stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M4 4v5h.582m15.356 2A8.001 8.001 0 004.582 9m0 0H9m11 11v-5h-.581m0 0a8.003 8.003 0 01-15.357-2m15.357 2H15\"></path>\n                    </svg>\n                  }\n                </button>\n              }\n            </div>\n          }\n          \n        </div>\n      </div>\n    </div>\n  }\n</div>\n", styles: [".data-grid-container{width:100%;display:flex;flex-direction:column}.data-grid-container.tw-h-full{height:100%;min-height:100%}.data-grid-container .tw-overflow-x-auto{scrollbar-width:thin;scrollbar-color:#d1d5db #f9fafb}.data-grid-container .tw-overflow-x-auto.tw-flex-1{flex:1;min-height:0}.data-grid-container .tw-overflow-x-auto::-webkit-scrollbar{height:6px}.data-grid-container .tw-overflow-x-auto::-webkit-scrollbar-track{background:#f9fafb}.data-grid-container .tw-overflow-x-auto::-webkit-scrollbar-thumb{background:#d1d5db;border-radius:3px}.data-grid-container .tw-overflow-x-auto::-webkit-scrollbar-thumb:hover{background:#9ca3af}.data-grid-container table{min-height:300px}.data-grid-container.tw-h-full table,.data-grid-container.tw-h-full tbody{height:100%}.data-grid-container.tw-table-striped tbody tr:nth-child(2n){background-color:#f9fafb}.data-grid-container.tw-table-sm th,.data-grid-container.tw-table-sm td{padding:.5rem 1rem}.data-grid-container tbody tr:hover{background-color:#f3f4f6}.data-grid-container tbody tr.tw-cursor-pointer:hover{background-color:#e5f3ff}.data-grid-container.loading-overlay{position:relative}.data-grid-container.loading-overlay:after{content:\"\";position:absolute;inset:0;background:#fffc;z-index:10}.data-grid-container .tw-animate-pulse div{animation:pulse 2s cubic-bezier(.4,0,.6,1) infinite}@keyframes pulse{0%,to{opacity:1}50%{opacity:.5}}.data-grid-container .action-buttons{display:flex;gap:.25rem}.data-grid-container .action-buttons button{transition:all .15s ease-in-out}.data-grid-container .action-buttons button:hover:not(:disabled){transform:translateY(-1px);box-shadow:0 2px 4px #0000001a}.data-grid-container .action-buttons button:disabled{cursor:not-allowed;opacity:.5}.data-grid-container .pagination-controls button{transition:all .15s ease-in-out}.data-grid-container .pagination-controls button:hover:not(:disabled){transform:translateY(-1px)}.data-grid-container .pagination-controls button:disabled{cursor:not-allowed}.data-grid-container .pagination-controls button.active{box-shadow:0 2px 4px #3b82f64d}.data-grid-container .pagination-controls input[type=number]{transition:border-color .15s ease-in-out}.data-grid-container .pagination-controls input[type=number]:focus{outline:none;border-color:#3b82f6;box-shadow:0 0 0 3px #3b82f61a}.data-grid-container .status-badge{font-weight:500;letter-spacing:.025em}.data-grid-container .status-badge.active{background-color:#d1fae5;color:#065f46}.data-grid-container .status-badge.inactive{background-color:#fee2e2;color:#991b1b}.data-grid-container .search-input{position:relative}.data-grid-container .search-input input{transition:all .15s ease-in-out}.data-grid-container .search-input input:focus{box-shadow:0 0 0 3px #3b82f61a}.data-grid-container .search-input .search-icon{pointer-events:none}.data-grid-container .empty-state{padding:3rem 1.5rem;text-align:center}.data-grid-container .empty-state svg{margin:0 auto 1rem;opacity:.4}.data-grid-container .empty-state h3{margin-bottom:.5rem}.data-grid-container.tw-h-full tbody tr:only-child td{height:100%;vertical-align:middle}.data-grid-container.tw-h-full table.empty-table{height:100%}.data-grid-container.tw-h-full tbody tr:only-child{height:100%}@media (max-width: 640px){.data-grid-container .tw-px-6{padding-left:1rem;padding-right:1rem}.data-grid-container .pagination-controls{flex-direction:column;gap:1rem}.data-grid-container .pagination-controls .flex{justify-content:center}.data-grid-container .pagination-info{display:none}.data-grid-container .search-actions{flex-direction:column;gap:1rem}}@media (prefers-color-scheme: dark){.data-grid-container.dark-mode{background-color:#1f2937;color:#f9fafb}.data-grid-container.dark-mode table{background-color:#1f2937}.data-grid-container.dark-mode thead{background-color:#374151}.data-grid-container.dark-mode tbody tr{border-color:#374151}.data-grid-container.dark-mode tbody tr:hover{background-color:#374151}.data-grid-container.dark-mode .tw-text-gray-900{color:#f9fafb!important}.data-grid-container.dark-mode .tw-text-gray-600{color:#d1d5db!important}.data-grid-container.dark-mode .tw-text-gray-500{color:#9ca3af!important}}.data-grid-container.drag-drop-enabled tbody tr{transition:all .2s ease}.data-grid-container.drag-drop-enabled tbody tr:hover{background-color:#f3f4f6}.data-grid-container.drag-drop-enabled tbody tr.tw-opacity-50{background-color:#dbeafecc;border:2px dashed #3b82f6;border-radius:4px}.data-grid-container.drag-drop-enabled tbody tr.tw-bg-blue-50{background-color:#eff6ffe6}.data-grid-container.drag-drop-enabled tbody tr[draggable=true]{cursor:move;position:relative}.data-grid-container.drag-drop-enabled tbody tr[draggable=true]:hover{background-color:#f8fafc;box-shadow:0 1px 3px #0000001a}.data-grid-container.drag-drop-enabled tbody tr[draggable=true]:active{cursor:grabbing}.data-grid-container.drag-drop-enabled tbody tr[style*=border-top]{position:relative}.data-grid-container.drag-drop-enabled tbody tr[style*=border-top]:before{content:\"\";position:absolute;top:-2px;left:0;right:0;height:2px;background:linear-gradient(90deg,#3b82f6,#60a5fa);z-index:10}.data-grid-container.tree-enabled tbody tr td:first-child{position:relative}.data-grid-container.tree-enabled tbody tr td:first-child button{transition:all .15s ease}.data-grid-container.tree-enabled tbody tr td:first-child button:hover{background-color:#f3f4f6;border-radius:2px}.data-grid-container.tree-enabled tbody tr td:first-child button svg{transition:transform .2s ease}.data-grid-container.tree-enabled tbody tr[style*=padding-left]{border-left:2px solid transparent}.data-grid-container.tree-enabled tbody tr[style*=padding-left]:hover{border-left-color:#e5e7eb}.tree-level-0{border-bottom:2px solid #e5e7eb!important;background-color:#fff}.tree-level-0:hover{background-color:#f5f5f5!important}.tree-level-0 td:first-child{font-weight:600}.tree-level-1{border-bottom:1px solid #d1d5db!important;background-color:#fafafa}.tree-level-1:hover{background-color:#f1f5f9!important}.tree-level-1 td:first-child{font-weight:500}.tree-level-2{border-bottom:1px solid #d1d5db!important;background-color:#f9fafb}.tree-level-2:hover{background-color:#f3f4f6!important}.tree-level-2 td:first-child{font-weight:400}.tree-level-deep{border-bottom:1px solid #e5e7eb!important;background-color:#fefefe}.tree-level-deep:hover{background-color:#f9fafb!important}.tree-level-deep td:first-child{font-weight:300}table td{box-sizing:border-box;word-wrap:break-word;overflow-wrap:break-word}table td.tw-overflow-hidden{overflow:hidden;text-overflow:ellipsis}table td:first-child{min-width:150px}table td:first-child>div{display:flex;align-items:center;min-width:0}table td:first-child>div .tw-flex{min-width:0}table td .tw-truncate{overflow:hidden;text-overflow:ellipsis;white-space:nowrap;max-width:100%}\n"] }]
+        }], propDecorators: { config: [{
+                type: Input
+            }], customRenderers: [{
+                type: Input
+            }], templateRenderers: [{
+                type: Input
+            }], customFormatters: [{
+                type: Input
+            }], actionHandlers: [{
+                type: Input
+            }], serverSidePagination: [{
+                type: Input
+            }], totalServerItems: [{
+                type: Input
+            }], currentServerPage: [{
+                type: Input
+            }], currentServerPageSize: [{
+                type: Input
+            }], dragDropEnabled: [{
+                type: Input
+            }], gridEvent: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"data-grid.component.js","sourceRoot":"","sources":["../../../../../../projects/cloud-ide-element/src/lib/components/data-grid/data-grid.component.ts","../../../../../../projects/cloud-ide-element/src/lib/components/data-grid/data-grid.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, Output, EventEmitter, OnInit, OnChanges, OnDestroy, SimpleChanges, SimpleChange, signal, computed, TemplateRef } from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { FormsModule } from '@angular/forms';\nimport { \n  GridConfiguration, \n  GridColumn, \n  GridEvent, \n  GridAction,\n  DEFAULT_GRID_CONFIG,\n  ColumnWidth,\n  StatusConfig\n} from './data-grid.types';\nimport { CideInputComponent } from '../../elements/input/input.component';\nimport { CideSelectComponent } from '../../elements/select/select.component';\nimport { CideIconComponent } from '../../elements/icon/icon.component';\nimport { inputType } from 'cloud-ide-lms-model';\nimport { CideEleButtonComponent } from '../../../public-api';\n\n// Enhanced types for template support\nexport interface TemplateContext<T = Record<string, unknown>> {\n  $implicit: unknown;\n  row: T;\n  value: unknown;\n  column: GridColumn;\n}\n\nexport type TemplateRenderer<T = Record<string, unknown>> = TemplateRef<TemplateContext<T>>;\nexport type StringRenderer<T = Record<string, unknown>> = (value: unknown, row: T) => string;\nexport type Renderer<T = Record<string, unknown>> = StringRenderer<T> | TemplateRenderer<T>;\n\n@Component({\n  selector: 'cide-ele-data-grid',\n  standalone: true,\n  imports: [\n    CommonModule, \n    FormsModule,\n    CideInputComponent,\n    CideSelectComponent,\n    CideIconComponent,\n    CideEleButtonComponent\n  ],\n  templateUrl: './data-grid.component.html',\n  styleUrls: ['./data-grid.component.scss']\n})\nexport class CideEleDataGridComponent<T = Record<string, unknown>> implements OnInit, OnChanges, OnDestroy {\n  @Input() config!: GridConfiguration<T>;\n  @Input() customRenderers: Record<string, StringRenderer<T>> = {};\n  @Input() templateRenderers: Record<string, unknown> = {};\n  @Input() customFormatters: Record<string, (value: unknown, format?: string) => string> = {};\n  @Input() actionHandlers: Record<string, (data: T, action?: GridAction) => void> = {};\n  @Input() serverSidePagination = false;\n  @Input() totalServerItems = 0;\n  @Input() currentServerPage = 1;\n  @Input() currentServerPageSize = 10;\n  @Input() dragDropEnabled = false;\n\n  @Output() gridEvent = new EventEmitter<GridEvent<T>>();\n\n  // Internal state using Angular Signals\n  private internalData = signal<T[]>([]);\n  private filteredData = signal<T[]>([]);\n  \n  // Grid state\n  currentPage = signal(1);\n  pageSize = signal(10);\n  totalItems = signal(0);\n  totalPages = signal(0);\n  searchQuery = signal('');\n  loading = signal(false);\n  isRefreshing = signal(false);\n  pageChangeLoading = signal(false);\n  jumpToPage = 1;\n  isDragOverRow: number | null = null;\n  isDragging = signal(false);\n  hasOrderChanged = signal(false);\n  private originalOrderIds: string[] = []; // Store only IDs for order tracking\n  private initialDataOrderIds: string[] = []; // Store only IDs for initial order\n  private rowOrderMap = new Map<string, { oldPosition: number; newPosition: number }>();\n  private localReorderedData: T[] = []; // Local data for visual reordering\n  private searchDebounceTimer?: ReturnType<typeof setTimeout>;\n  private isDataUpdate = false;\n\n  // Computed properties\n  hasNextPage = computed(() => this.currentPage() < this.totalPages());\n  hasPreviousPage = computed(() => this.currentPage() > 1);\n  \n  // Merged configuration with defaults\n  mergedConfig = signal<GridConfiguration<T>>(this.config);\n\n  ngOnInit() {\n    this.initializeGrid();\n    this.initializeOriginalOrder();\n  }\n\n  ngOnDestroy() {\n    // Clean up search debounce timer\n    if (this.searchDebounceTimer) {\n      clearTimeout(this.searchDebounceTimer);\n    }\n  }\n\n  ngOnChanges(changes: SimpleChanges) {\n    if (changes['config']) {\n      // Store current search query to preserve it during re-initialization\n      const currentSearchQuery = this.searchQuery();\n      \n      this.mergeConfigWithDefaults();\n      \n      // Check if this is a data-only update (same config except data)\n      const isDataOnlyUpdate = this.isDataOnlyUpdate(changes['config']);\n      \n      if (isDataOnlyUpdate && this.serverSidePagination) {\n        console.log('🔄 DataGrid: isDataOnlyUpdate', isDataOnlyUpdate);\n        // For data-only updates, preserve search query and use updateDataOnly\n        this.updateDataOnly(changes['config'].currentValue.data || []);\n        if (currentSearchQuery) {\n          // this.searchQuery.set(currentSearchQuery);\n        }\n      } else {\n        // For full config changes, use initializeGrid\n        this.initializeGrid();\n        \n        // Restore search query after initialization\n        if (currentSearchQuery) {\n          // this.searchQuery.set(currentSearchQuery);\n        }\n      }\n      \n      // Reinitialize original order when data changes\n      this.initializeOriginalOrder();\n      \n      // Also refresh order tracking to ensure it's up to date\n      this.refreshOrderTracking();\n    }\n    \n    if (this.serverSidePagination) {\n      if (changes['totalServerItems']) {\n        // console.log('🔄 DataGrid: totalServerItems changed:', this.totalServerItems);\n        this.totalItems.set(this.totalServerItems);\n        this.updatePaginationState();\n      }\n      \n      if (changes['currentServerPage']) {\n        // console.log('🔄 DataGrid: currentServerPage changed:', this.currentServerPage);\n        this.currentPage.set(this.currentServerPage);\n      }\n      \n      if (changes['currentServerPageSize']) {\n        // console.log('🔄 DataGrid: currentServerPageSize changed:', this.currentServerPageSize);\n        this.pageSize.set(this.currentServerPageSize);\n        this.updatePaginationState();\n      }\n      \n      // Clear page change loading when server-side data is updated\n      if (changes['config'] && this.pageChangeLoading()) {\n        this.clearPageChangeLoading();\n      }\n    }\n  }\n\n  /**\n   * Check if the config change is only a data update\n   */\n  private isDataOnlyUpdate(change: SimpleChange): boolean {\n    if (change.firstChange || !change.previousValue || !change.currentValue) {\n      return false;\n    }\n    \n    const prev = change.previousValue;\n    const curr = change.currentValue;\n    \n    // Check if all properties except 'data' are the same\n    const prevWithoutData = { ...prev };\n    const currWithoutData = { ...curr };\n    delete prevWithoutData.data;\n    delete currWithoutData.data;\n    \n    return JSON.stringify(prevWithoutData) === JSON.stringify(currWithoutData);\n  }\n\n  /**\n   * Update only the data without triggering full grid re-initialization\n   * This prevents the search input and other UI state from being reset\n   */\n  private updateDataOnly(data: T[]) {\n    let processedData = data;\n    \n    // Transform to tree structure if tree config is enabled\n    if (this.mergedConfig().tree?.enabled) {\n      processedData = this.transformToTree(data);\n      console.log('processedData', processedData);\n    }\n    \n    this.internalData.set(processedData);\n    console.log('processedData', processedData);\n    // For server-side pagination, set filtered data directly\n    if (this.serverSidePagination) {\n      console.log('processedData', processedData);\n      this.filteredData.set(processedData);\n    } else {\n      // For client-side pagination, apply filters\n      this.applyFilters();\n    }\n    \n    // Refresh order tracking when data changes\n    this.refreshOrderTracking();\n    \n    this.clearPageChangeLoading();\n  }\n\n  private mergeConfigWithDefaults() {\n    this.mergedConfig.set({\n      ...DEFAULT_GRID_CONFIG,\n      ...this.config,\n      pagination: { ...DEFAULT_GRID_CONFIG.pagination!, ...this.config.pagination },\n      search: { ...DEFAULT_GRID_CONFIG.search!, ...this.config.search },\n      loading: { ...DEFAULT_GRID_CONFIG.loading!, ...this.config.loading },\n      scroll: { ...DEFAULT_GRID_CONFIG.scroll!, ...this.config.scroll }\n    } as GridConfiguration<T>);\n  }\n\n  private initializeGrid() {\n    // Ensure we have valid data\n    let data = this.config?.data || [];\n    \n    // Transform to tree structure if tree config is enabled\n    if (this.mergedConfig().tree?.enabled) {\n      data = this.transformToTree(data);\n    }\n    \n    this.internalData.set(data);\n    \n    // Set pagination values based on mode\n    if (this.serverSidePagination) {\n      this.currentPage.set(this.currentServerPage);\n      this.pageSize.set(this.currentServerPageSize);\n      this.totalItems.set(this.totalServerItems);\n      // For server-side pagination, set filtered data directly without applying filters\n      this.filteredData.set(data);\n    } else {\n      // Client-side pagination\n      const pageSize = this.mergedConfig().pagination?.pageSize || 10;\n      this.pageSize.set(pageSize);\n      this.totalItems.set(data.length);\n      // For client-side pagination, apply filters\n      this.applyFilters();\n    }\n    \n    this.updatePaginationState();\n    \n    // Initialize original order for drag and drop\n    this.initializeOriginalOrder();\n    \n    // Also refresh order tracking to ensure it's up to date\n    this.refreshOrderTracking();\n  }\n\n  /**\n   * Get the unique identifier for an item\n   */\n  private getItemId(item: T): string | null {\n    if (item && typeof item === 'object') {\n      const id = (item as Record<string, unknown>)['_id'];\n      return id ? String(id) : null;\n    }\n    return null;\n  }\n\n  /**\n   * Get the order value for an item from the config\n   */\n  private getItemOrder(item: T): number {\n    const dragDropConfig = this.getDragDropConfig();\n    if (dragDropConfig?.orderField) {\n      const orderValue = this.getNestedValue(item, dragDropConfig.orderField);\n      return typeof orderValue === 'number' ? orderValue : 0;\n    }\n    return 0;\n  }\n\n  /**\n   * Initialize the original order for drag and drop\n   */\n  private initializeOriginalOrder(): void {\n    if (this.isDragDropEnabled()) {\n      // Get the full dataset from the config (not just displayedData)\n      const fullData = this.mergedConfig().data || [];\n      \n      // Completely build the order tracking from current data\n      this.rowOrderMap.clear();\n      this.initialDataOrderIds = [];\n      \n      // Build the order tracking with current data\n      fullData.forEach((item, index) => {\n        const itemId = this.getItemId(item);\n        if (itemId) {\n          const actualOrder = this.getItemOrder(item);\n          this.initialDataOrderIds.push(itemId);\n          this.rowOrderMap.set(itemId, {\n            oldPosition: actualOrder || (index + 1), // Use actual order or fallback to index\n            newPosition: actualOrder || (index + 1)\n          });\n        }\n      });\n      \n      // Clear any existing local reordered data\n      this.localReorderedData = [];\n      \n      console.log('🔍 Initial order tracking built from full dataset:', this.initialDataOrderIds.length, 'items');\n      console.log('🔍 Initial order map created with actual order values:', Array.from(this.rowOrderMap.entries()));\n    }\n  }\n\n  /**\n   * Refresh order tracking with current data (called when data updates)\n   */\n  private refreshOrderTracking(): void {\n    if (this.isDragDropEnabled()) {\n      // Get the current full dataset\n      const fullData = this.mergedConfig().data || [];\n      \n      // Completely rebuild the order tracking from current data\n      this.rowOrderMap.clear();\n      this.initialDataOrderIds = [];\n      \n      // Rebuild the order tracking with current data\n      fullData.forEach((item, index) => {\n        const itemId = this.getItemId(item);\n        if (itemId) {\n          const actualOrder = this.getItemOrder(item);\n          this.initialDataOrderIds.push(itemId);\n          this.rowOrderMap.set(itemId, {\n            oldPosition: actualOrder || (index + 1),\n            newPosition: actualOrder || (index + 1)\n          });\n        }\n      });\n      \n      // Clear any local reordered data since data has changed\n      this.localReorderedData = [];\n      this.hasOrderChanged.set(false);\n      \n      console.log('🔍 Order tracking completely rebuilt with current data:', this.initialDataOrderIds.length, 'items');\n    }\n  }\n\n  // ===== Data Processing =====\n  \n  private applyFilters() {\n    let filtered = [...this.internalData()];\n    \n    // Apply search filter only for client-side pagination\n    // For server-side pagination, search is handled by the server\n    if (!this.serverSidePagination) {\n      const query = this.searchQuery()?.toLowerCase();\n      if (query && this.mergedConfig().search.enabled) {\n        filtered = filtered.filter(item => \n          this.mergedConfig().search.searchableColumns.some(columnKey => {\n            const value = this.getNestedValue(item, columnKey);\n            return String(value || '')?.toLowerCase()?.includes(query);\n          })\n        );\n      }\n    }\n    \n    // Flatten tree structure for display if tree is enabled\n    if (this.mergedConfig().tree?.enabled) {\n      filtered = this.flattenTreeForDisplay(filtered);\n    }\n    \n    this.filteredData.set(filtered);\n    \n    // For server-side pagination, totalItems should always be totalServerItems\n    // For client-side pagination, totalItems should be the filtered data length\n    if (this.serverSidePagination) {\n      this.totalItems.set(this.totalServerItems);\n    } else {\n      this.totalItems.set(filtered.length);\n    }\n    \n    this.updatePaginationState();\n  }\n\n  /**\n   * Transform flat data to tree structure based on foreign key relationships\n   */\n  private transformToTree(data: T[]): T[] {\n    console.log('transformToTree - input data:', data.length, 'items');\n    const treeConfig = this.mergedConfig().tree;\n    if (!treeConfig) return data;\n\n    const { primaryKey, foreignKey, childrenKey = 'children', levelKey = 'level', expandedKey = 'isExpanded', hasChildrenKey = 'hasChildren' } = treeConfig;\n    \n    // Always add level key to each row during processing\n    \n    // Create a map for quick lookup\n    const itemMap = new Map<string, T>();\n    const processedItems = new Set<string>();\n    const rootItems: T[] = [];\n\n    // First pass: create tree items with default properties and level key\n    data.forEach(item => {\n      const treeItem = {\n        ...item,\n        [levelKey]: 0,\n        level: 0,  // Always add 'level' property for consistent access\n        [expandedKey]: false,\n        [hasChildrenKey]: false,\n        [childrenKey]: []\n      } as T;\n      itemMap.set(String(this.getNestedValue(item, primaryKey) || ''), treeItem);\n    });\n\n    // Multi-pass hierarchy building to handle items in any order\n    let remainingItems = [...data];\n    const maxIterations = data.length; // Prevent infinite loops\n    let iteration = 0;\n\n    while (remainingItems.length > 0 && iteration < maxIterations) {\n      const itemsToProcess = [...remainingItems];\n      remainingItems = [];\n      \n      console.log(`Iteration ${iteration + 1}: Processing ${itemsToProcess.length} items`);\n\n      itemsToProcess.forEach(item => {\n        const itemId = String(this.getNestedValue(item, primaryKey) || '');\n        const parentIdValue = this.getNestedValue(item, foreignKey);\n        const parentId = parentIdValue !== null && parentIdValue !== undefined ? String(parentIdValue) : '';\n        const treeItem = itemMap.get(itemId);\n        \n        // Skip if already processed\n        if (processedItems.has(itemId)) {\n          return;\n        }\n\n        if (treeItem && parentId && itemMap.has(parentId)) {\n          // This is a child item - check if parent is processed or is a root\n          const parent = itemMap.get(parentId)!;\n          const parentParentId = this.getNestedValue(parent, foreignKey);\n          const isParentRoot = !parentParentId || parentParentId === null || parentParentId === undefined;\n          \n          if (isParentRoot || processedItems.has(parentId)) {\n            // Parent is processed or is root, we can process this child\n            const parentChildren = this.getNestedValue(parent, childrenKey) as T[] || [];\n            \n            // Avoid adding duplicates\n            const childExists = parentChildren.some(child => \n              String(this.getNestedValue(child, primaryKey) || '') === itemId\n            );\n            \n            if (!childExists) {\n              // Calculate level based on parent - automatically set level key\n              const parentLevel = this.getNestedValue(parent, 'level') as number || 0;\n              const childLevel = parentLevel + 1;\n              \n              // Update child item with correct level\n              const updatedTreeItem = {\n                ...treeItem,\n                [levelKey]: childLevel,\n                level: childLevel  // Always add 'level' property for consistent access\n              } as T;\n              itemMap.set(itemId, updatedTreeItem);\n              \n              // Add updated child to parent's children array\n              parentChildren.push(updatedTreeItem);\n              \n              // Update parent properties\n              const updatedParent = {\n                ...parent,\n                [childrenKey]: parentChildren,\n                [hasChildrenKey]: true\n              } as T;\n              itemMap.set(parentId, updatedParent);\n              \n              processedItems.add(itemId);\n            }\n          } else {\n            // Parent not processed yet, defer this item\n            remainingItems.push(item);\n          }\n        } else if (treeItem) {\n          // This is a root item - automatically set level to 0\n          const updatedRootItem = {\n            ...treeItem,\n            [levelKey]: 0,\n            level: 0  // Always add 'level' property for consistent access\n          } as T;\n          itemMap.set(itemId, updatedRootItem);\n          \n          if (!rootItems.some(rootItem => \n            String(this.getNestedValue(rootItem, primaryKey) || '') === itemId\n          )) {\n            rootItems.push(updatedRootItem);\n            processedItems.add(itemId);\n          }\n        }\n      });\n\n      iteration++;\n    }\n\n    // Handle any remaining unprocessed items as roots (orphaned items)\n    remainingItems.forEach(item => {\n      const itemId = String(this.getNestedValue(item, primaryKey) || '');\n      if (!processedItems.has(itemId)) {\n        const treeItem = itemMap.get(itemId);\n        if (treeItem && !rootItems.includes(treeItem)) {\n          console.log(`Adding orphaned item ${itemId} as root`);\n          rootItems.push(treeItem);\n        }\n      }\n    });\n\n    // Final pass: Update hasChildren property for all items in the tree\n    const updateHasChildren = (items: T[]) => {\n      items.forEach((item, index) => {\n        const itemId = String(this.getNestedValue(item, primaryKey) || '');\n        const children = this.getNestedValue(item, childrenKey) as T[] || [];\n        const hasChildren = children.length > 0;\n        \n        // Update the item with correct hasChildren property\n        const updatedItem = {\n          ...item,\n          [hasChildrenKey]: hasChildren\n        } as T;\n        \n        // Update in the map\n        itemMap.set(itemId, updatedItem);\n        \n        // Update the item in the array\n        items[index] = updatedItem;\n        \n        // Recursively update children\n        if (children.length > 0) {\n          updateHasChildren(children);\n        }\n      });\n    };\n\n    // Get updated root items from the map to ensure we have the latest versions\n    const updatedRootItems = rootItems.map(rootItem => {\n      const rootId = String(this.getNestedValue(rootItem, primaryKey) || '');\n      return itemMap.get(rootId) || rootItem;\n    });\n    \n    // Update all root items and their descendants\n    updateHasChildren(updatedRootItems);\n    \n    console.log('transformToTree - root items:', updatedRootItems.length);\n    console.log('CC - processed items:', processedItems.size);\n    console.log('transformToTree - sample root item with level:', updatedRootItems[0]);\n    return updatedRootItems;\n  }\n\n  /**\n   * Recursively calculate item level in hierarchy for unlimited depth support\n   */\n  private calculateItemLevel(item: T, itemMap: Map<string, T>, primaryKey: string, foreignKey: string, levelKey: string): number {\n    // Check if level is already set correctly\n    const currentLevel = this.getNestedValue(item, levelKey) as number;\n    if (currentLevel !== undefined && currentLevel > 0) {\n      return currentLevel;\n    }\n\n    // Get parent information\n    const itemId = String(this.getNestedValue(item, primaryKey) || '');\n    const parentIdValue = this.getNestedValue(item, foreignKey);\n    const parentId = parentIdValue !== null && parentIdValue !== undefined ? String(parentIdValue) : '';\n    \n    // If no parent, this is a root item (level 0)\n    if (!parentId || !itemMap.has(parentId)) {\n      return 0;\n    }\n    \n    // Recursively calculate parent level and add 1\n    const parent = itemMap.get(parentId)!;\n    const parentLevel = this.calculateItemLevel(parent, itemMap, primaryKey, foreignKey, levelKey);\n    \n    // Update the item's level in the map\n    const updatedItem = {\n      ...item,\n      [levelKey]: parentLevel + 1\n    } as T;\n    itemMap.set(itemId, updatedItem);\n    \n    return parentLevel + 1;\n  }\n\n  /**\n   * Flatten tree structure for display, respecting expansion state with unlimited nesting\n   */\n  private flattenTreeForDisplay(treeItems: T[]): T[] {\n    const result: T[] = [];\n    const treeConfig = this.mergedConfig().tree;\n    if (!treeConfig) return treeItems;\n    \n    const { childrenKey = 'children', expandedKey = 'isExpanded' } = treeConfig;\n    \n    const flatten = (items: T[], currentLevel: number = 0) => {\n      items.forEach(item => {\n        result.push(item);\n        const children = this.getNestedValue(item, childrenKey) as T[] || [];\n        const isExpanded = this.getNestedValue(item, expandedKey) as boolean || false;\n        \n        if (children.length > 0 && isExpanded) {\n          console.log(`Flattening children for item at level ${currentLevel}, children count: ${children.length}`);\n          flatten(children, currentLevel + 1);\n        }\n      });\n    };\n    \n    flatten(treeItems);\n    console.log('flattenTreeForDisplay - result:', result.length, 'items');\n    return result;\n  }\n\n  /**\n   * Toggle expand/collapse state of a tree item with unlimited nesting support\n   */\n  private toggleTreeExpand(item: T): void {\n    const treeConfig = this.mergedConfig().tree;\n    if (!treeConfig) return;\n    \n    const { expandedKey = 'isExpanded', primaryKey } = treeConfig;\n    const currentExpanded = this.getNestedValue(item, expandedKey) as boolean || false;\n    const itemId = String(this.getNestedValue(item, primaryKey) || '');\n    \n    console.log(`toggleTreeExpand - item: ${itemId}, current expanded: ${currentExpanded}`);\n    \n    // Update the expanded state\n    const updatedItem = {\n      ...item,\n      [expandedKey]: !currentExpanded\n    } as T;\n    \n    // Update the item in the tree structure recursively\n    const updateItemInTree = (treeData: T[]): T[] => {\n      return treeData.map(treeItem => {\n        const treeItemId = String(this.getNestedValue(treeItem, primaryKey) || '');\n        \n        if (treeItemId === itemId) {\n          console.log(`Found item to update: ${itemId}, new expanded state: ${!currentExpanded}`);\n          return updatedItem;\n        }\n        \n        // Check children recursively\n        const children = this.getNestedValue(treeItem, 'children') as T[] || [];\n        if (children.length > 0) {\n          const updatedChildren = updateItemInTree(children);\n          return {\n            ...treeItem,\n            children: updatedChildren\n          } as T;\n        }\n        \n        return treeItem;\n      });\n    };\n    \n    // Update the internal data\n    const updatedData = updateItemInTree([...this.internalData()]);\n    this.internalData.set(updatedData);\n    \n    // Re-apply filters to update the display\n    this.applyFilters();\n  }\n\n  private updatePaginationState() {\n    const total = Math.ceil(this.totalItems() / this.pageSize());\n    this.totalPages.set(total);\n    \n    // Ensure current page is within bounds\n    if (total === 0) {\n      this.currentPage.set(1);\n    } else if (this.currentPage() > total) {\n      this.currentPage.set(total);\n    }\n  }\n\n  // ===== Pagination Methods =====\n  \n  onPageChange(page: number | string) {\n    console.log('🔄 DataGrid: onPageChange called with page:', page);\n    const pageNum = typeof page === 'string' ? parseInt(page, 10) : page;\n    console.log('🔄 DataGrid: Parsed page number:', pageNum, 'Total pages:', this.totalPages());\n    \n    if (pageNum >= 1 && pageNum <= this.totalPages()) {\n      // Set page change loading state\n      this.pageChangeLoading.set(true);\n      console.log('🔄 DataGrid: Set page change loading to true');\n      \n      this.currentPage.set(pageNum);\n      \n      if (this.serverSidePagination) {\n        const pageData = { page: pageNum, pageSize: this.pageSize() };\n        console.log('🔄 DataGrid: Emitting pageChange event for server-side pagination:', pageData);\n        // Emit page data object for server-side pagination\n        this.emitEvent('pageChange', pageData as unknown as T);\n        // Don't clear loading state here - let the parent component handle it\n        // The loading state will be cleared when new data arrives via ngOnChanges\n      } else {\n        console.log('🔄 DataGrid: Emitting pageChange event for client-side pagination:', pageNum);\n        // Emit simple page number for client-side pagination\n        this.emitEvent('pageChange', pageNum);\n        // Clear loading state for client-side pagination\n        this.clearPageChangeLoading();\n      }\n    } else {\n      console.log('🔄 DataGrid: Page number out of range, not emitting event');\n    }\n  }\n\n  onPageSizeChange() {\n    // Set page change loading state\n    this.pageChangeLoading.set(true);\n    \n    this.currentPage.set(1);\n    this.updatePaginationState();\n    \n    if (this.serverSidePagination) {\n      // Emit page data object for server-side pagination\n      this.emitEvent('pageChange', { page: 1, pageSize: this.pageSize() } as unknown as T);\n      // Don't clear loading state here - let the parent component handle it\n      // The loading state will be cleared when new data arrives via ngOnChanges\n    } else {\n      // Emit simple page number for client-side pagination\n      this.emitEvent('pageChange', 1);\n      // Clear loading state for client-side pagination\n      this.clearPageChangeLoading();\n    }\n  }\n\n  updatePageSize(value: string | number) {\n    this.pageSize.set(+value);\n    this.onPageSizeChange();\n  }\n\n  previousPage() {\n    if (this.hasPreviousPage()) {\n      this.onPageChange(this.currentPage() - 1);\n    }\n  }\n\n  nextPage() {\n    if (this.hasNextPage()) {\n      this.onPageChange(this.currentPage() + 1);\n    }\n  }\n\n  onJumpToPage() {\n    if (this.jumpToPage >= 1 && this.jumpToPage <= this.totalPages()) {\n      this.onPageChange(this.jumpToPage);\n    }\n  }\n\n  getEnhancedPageNumbers(): (number | string)[] {\n    const total = this.totalPages();\n    const current = this.currentPage();\n    const pages: (number | string)[] = [];\n    \n    if (total <= 7) {\n      for (let i = 1; i <= total; i++) {\n        pages.push(i);\n      }\n    } else {\n      pages.push(1);\n      \n      if (current <= 4) {\n        for (let i = 2; i <= 5; i++) {\n          pages.push(i);\n        }\n        pages.push('...');\n        pages.push(total);\n      } else if (current >= total - 3) {\n        pages.push('...');\n        for (let i = total - 4; i <= total; i++) {\n          pages.push(i);\n        }\n      } else {\n        pages.push('...');\n        for (let i = current - 1; i <= current + 1; i++) {\n          pages.push(i);\n        }\n        pages.push('...');\n        pages.push(total);\n      }\n    }\n    \n    return pages;\n  }\n\n  // ===== Search Methods =====\n  \n  updateSearchQuery(value: inputType) {\n    console.log('updateSearchQuery', value);\n    const searchValue = value as string;\n    this.searchQuery.set(searchValue);\n    \n    // Clear any existing debounce timer\n    if (this.searchDebounceTimer) {\n      clearTimeout(this.searchDebounceTimer);\n    }\n    \n    // Apply debounce for search\n    const debounceMs = this.mergedConfig().search.debounceMs || 300;\n    this.searchDebounceTimer = setTimeout(() => {\n      // Only emit search event for server-side pagination\n      // Don't trigger any client-side filtering that might cause re-renders\n      if (this.serverSidePagination) {\n        this.currentPage.set(1);\n        this.emitEvent('search', searchValue);\n      } else {\n        this.onSearch();\n      }\n    }, debounceMs);\n  }\n  \n  onSearch() {\n    this.currentPage.set(1);\n    \n    if (this.serverSidePagination) {\n      // For server-side pagination, only emit the search event\n      // Don't apply client-side filters as the server will handle the search\n      this.emitEvent('search', this.searchQuery());\n    } else {\n      // For client-side pagination, apply filters locally\n      this.applyFilters();\n      this.emitEvent('search', this.searchQuery());\n    }\n  }\n\n  // ===== Action Methods =====\n  \n  onRefresh() {\n    this.isRefreshing.set(true);\n    this.emitEvent('refresh', null);\n    \n    // The parent component should handle the actual refresh and call setRefreshing(false) when done\n    // We don't auto-reset here to allow the parent to control the refresh state\n  }\n\n  // Method to allow parent components to control the refreshing state\n  setRefreshing(isRefreshing: boolean) {\n    this.isRefreshing.set(isRefreshing);\n  }\n\n  // Method to clear page change loading state when new data is received\n  clearPageChangeLoading() {\n    this.pageChangeLoading.set(false);\n  }\n\n  // ===== Tree View Helper Methods =====\n  \n  /**\n   * Check if tree view is enabled\n   */\n  isTreeEnabled(): boolean {\n    const enabled = this.mergedConfig().tree?.enabled || false;\n    return enabled;\n  }\n\n  /**\n   * Get tree configuration\n   */\n  getTreeConfig() {\n    return this.mergedConfig().tree;\n  }\n\n  /**\n   * Check if an item has children\n   */\n  hasChildren(item: T): boolean {\n    const treeConfig = this.getTreeConfig();\n    if (!treeConfig) return false;\n    \n    const { hasChildrenKey = 'hasChildren', childrenKey = 'children' } = treeConfig;\n    \n    // Check hasChildren property first\n    const hasChildren = this.getNestedValue(item, hasChildrenKey) as boolean;\n    if (hasChildren !== undefined) {\n      return hasChildren;\n    }\n    \n    // Fallback to checking children array\n    const children = this.getNestedValue(item, childrenKey) as T[];\n    return children && children.length > 0;\n  }\n\n  /**\n   * Get item level in tree\n   */\n  getItemLevel(item: T): number {\n    // Always try to get level from standard 'level' property first (set by transformToTree)\n    let level = this.getNestedValue(item, 'level') as number;\n    \n    // If not found, try tree config level key\n    if (level === undefined || level === null) {\n      const treeConfig = this.getTreeConfig();\n      if (treeConfig) {\n        const { levelKey = 'level' } = treeConfig;\n        level = this.getNestedValue(item, levelKey) as number || 0;\n      } else {\n        level = 0;\n      }\n    }\n    \n    return level;\n  }\n\n  /**\n   * Check if item is expanded\n   */\n  isItemExpanded(item: T): boolean {\n    const treeConfig = this.getTreeConfig();\n    if (!treeConfig) return false;\n    \n    const { expandedKey = 'isExpanded' } = treeConfig;\n    return this.getNestedValue(item, expandedKey) as boolean || false;\n  }\n\n  /**\n   * Get tree indent style\n   */\n  getTreeIndentStyle(item: T): string {\n    const level = this.getItemLevel(item);\n    \n    // Specific padding progression: Level 1=12px, Level 2=22px, Level 3=32px, Level 4=52px\n    const basePadding = 12; // Base cell padding (replaces tw-px-3)\n    let levelPadding = 0;\n    \n    switch (level) {\n      case 0: // Level 1 (root)\n        levelPadding = 0;\n        break;\n      case 1: // Level 2\n        levelPadding = 10;\n        break;\n      case 2: // Level 3\n        levelPadding = 20;\n        break;\n      case 3: // Level 4\n        levelPadding = 40;\n        break;\n      default: // Level 5+\n        levelPadding = 40 + ((level - 3) * 20); // Continue with 20px increments\n        break;\n    }\n    \n    const totalPadding = `${basePadding + levelPadding}px`;\n    return totalPadding;\n  }\n\n  /**\n   * Get tree level background class for visual distinction\n   */\n  getTreeLevelClass(item: T): string {\n    const level = this.getItemLevel(item);\n    if (level === 0) return 'tree-level-0'; // Root level\n    if (level === 1) return 'tree-level-1'; // First child level  \n    if (level === 2) return 'tree-level-2'; // Second child level\n    return 'tree-level-deep'; // Deep nesting (3+ levels)\n  }\n\n  // ===== Drag and Drop Helper Methods =====\n  \n  /**\n   * Check if drag and drop is enabled\n   */\n  isDragDropEnabled(): boolean {\n    return this.dragDropEnabled || this.mergedConfig().dragDrop?.enabled || false;\n  }\n\n  /**\n   * Get drag and drop configuration\n   */\n  getDragDropConfig() {\n    return this.mergedConfig().dragDrop;\n  }\n\n  /**\n   * Handle drag start event\n   */\n  onDragStart(event: DragEvent, item: T, index: number): void {\n    if (!this.isDragDropEnabled()) return;\n    \n    this.isDragging.set(true);\n    \n    // Store the current order IDs when drag starts for comparison\n    this.originalOrderIds = this.displayedData.map(item => this.getItemId(item)).filter(id => id !== null) as string[];\n    console.log('🔍 Drag started, current order IDs stored:', this.originalOrderIds);\n    \n    const dragConfig = this.getDragDropConfig();\n    const dragClass = dragConfig?.dragClass || 'tw-opacity-50 tw-bg-blue-50';\n    \n    if (event.dataTransfer) {\n      event.dataTransfer.effectAllowed = 'move';\n      event.dataTransfer.setData('text/plain', JSON.stringify({ item, index }));\n    }\n    \n    // Find the closest tr element and apply drag styles\n    const rowElement = (event.target as HTMLElement).closest('tr');\n    if (rowElement) {\n      dragClass.split(' ').forEach(cls => rowElement.classList.add(cls));\n      // Add additional visual feedback\n      rowElement.style.transform = 'scale(1.02)';\n      rowElement.style.boxShadow = '0 4px 12px rgba(0, 0, 0, 0.15)';\n      rowElement.style.zIndex = '1000';\n    }\n  }\n\n  /**\n   * Handle drag over event\n   */\n  onDragOver(event: DragEvent): void {\n    if (!this.isDragDropEnabled()) return;\n    \n    event.preventDefault();\n    event.dataTransfer!.dropEffect = 'move';\n    \n    // Find the row index from the closest tr element\n    const rowElement = (event.target as HTMLElement).closest('tr');\n    if (rowElement) {\n      const tbody = rowElement.closest('tbody');\n      if (tbody) {\n        const rowIndex = Array.from(tbody.children).indexOf(rowElement);\n        this.isDragOverRow = rowIndex;\n      }\n    }\n  }\n\n  /**\n   * Handle drag leave event\n   */\n  onDragLeave(event: DragEvent): void {\n    console.log('onDragLeave', event);\n    if (!this.isDragDropEnabled()) return;\n    \n    // Clear drag over row tracking\n    this.isDragOverRow = null;\n  }\n\n  /**\n   * Handle drop event\n   */\n  onDrop(event: DragEvent, targetItem: T, targetIndex: number): void {\n    if (!this.isDragDropEnabled()) return;\n    \n    event.preventDefault();\n    \n    // Clear drag over row tracking\n    this.isDragOverRow = null;\n    \n    try {\n      const data = JSON.parse(event.dataTransfer!.getData('text/plain'));\n      const sourceItem = data.item as T;\n      const sourceIndex = data.index as number;\n      \n      if (sourceIndex !== targetIndex) {\n        const newOrder = this.getNewOrder(sourceIndex, targetIndex);\n        console.log('🔍 Drop completed, updating local order only:', { sourceItem, sourceIndex, targetItem, targetIndex, newOrder });\n        \n        // Update the row order map with new positions (LOCAL ONLY)\n        this.updateRowOrderMap(newOrder);\n        \n        // Update local data for visual reordering (LOCAL ONLY)\n        this.updateLocalDataOrder(newOrder);\n        \n        // Check if any row has changed position\n        const hasActuallyChanged = this.checkIfOrderChanged();\n        this.hasOrderChanged.set(hasActuallyChanged);\n        console.log('🔍 Local order changed:', hasActuallyChanged);\n        \n        // IMPORTANT: DO NOT emit reorder event here - only store locally\n        // External components will be updated only when \"Save Order\" is clicked\n        console.log('🔍 Order change stored locally - external components not updated until save');\n      } else {\n        console.log('Source and target index are the same, skipping reorder');\n      }\n    } catch (error) {\n      console.error('Error parsing drag data:', error);\n    }\n  }\n\n  /**\n   * Handle drag end event\n   */\n  onDragEnd(event: DragEvent): void {\n    if (!this.isDragDropEnabled()) return;\n    \n    this.isDragging.set(false);\n    \n    // Check if order has changed after drag ends\n    const hasActuallyChanged = this.checkIfOrderChanged();\n    this.hasOrderChanged.set(hasActuallyChanged);\n    \n    const dragConfig = this.getDragDropConfig();\n    const dragClass = dragConfig?.dragClass || 'tw-opacity-50 tw-bg-blue-50';\n    \n    // Clear drag over row tracking\n    this.isDragOverRow = null;\n    \n    // Find the closest tr element and remove drag styles\n    const rowElement = (event.target as HTMLElement).closest('tr');\n    if (rowElement) {\n      dragClass.split(' ').forEach(cls => rowElement.classList.remove(cls));\n      // Remove additional visual feedback\n      rowElement.style.transform = '';\n      rowElement.style.boxShadow = '';\n      rowElement.style.zIndex = '';\n    }\n  }\n\n  /**\n   * Calculate new order after reordering\n   */\n  private getNewOrder(sourceIndex: number, targetIndex: number): T[] {\n    const data = [...this.displayedData];\n    const [movedItem] = data.splice(sourceIndex, 1);\n    data.splice(targetIndex, 0, movedItem);\n    return data;\n  }\n\n  /**\n   * Get the current order number for a specific item\n   */\n  getCurrentOrderNumber(item: T): number {\n    const itemId = this.getItemId(item);\n    if (itemId && this.rowOrderMap.has(itemId)) {\n      return this.rowOrderMap.get(itemId)!.newPosition;\n    }\n    \n    // Fallback to actual order field value from config\n    const actualOrder = this.getItemOrder(item);\n    if (actualOrder > 0) {\n      return actualOrder;\n    }\n    \n    // Final fallback to index-based calculation\n    const currentIndex = this.displayedData.findIndex(currentItem => {\n      if (item && currentItem && typeof item === 'object' && typeof currentItem === 'object') {\n        const itemId = (item as Record<string, unknown>)['_id'];\n        const currentItemId = (currentItem as Record<string, unknown>)['_id'];\n        return itemId && currentItemId && itemId === currentItemId;\n      }\n      return item === currentItem;\n    });\n    return currentIndex >= 0 ? currentIndex + 1 : 0;\n  }\n\n  /**\n   * Update the row order map with new positions after reordering\n   */\n  private updateRowOrderMap(newOrder: T[]): void {\n    newOrder.forEach((item, index) => {\n      const itemId = this.getItemId(item);\n      if (itemId && this.rowOrderMap.has(itemId)) {\n        const currentEntry = this.rowOrderMap.get(itemId)!;\n        // Calculate new order value based on position and original order field\n        const dragDropConfig = this.getDragDropConfig();\n        if (dragDropConfig?.orderField) {\n          // Use the order field from config to calculate new order values\n          const baseOrder = Math.min(...this.displayedData.map(item => this.getItemOrder(item)));\n          const newOrderValue = baseOrder + index;\n          currentEntry.newPosition = newOrderValue;\n        } else {\n          // Fallback to index-based position\n          currentEntry.newPosition = index + 1;\n        }\n        this.rowOrderMap.set(itemId, currentEntry);\n      }\n    });\n    \n    console.log('🔍 Row order map updated with new order values:', Array.from(this.rowOrderMap.entries()));\n  }\n\n  /**\n   * Check if any row has changed position by comparing old vs new positions\n   */\n  private checkIfOrderChanged(): boolean {\n    for (const [itemId, orderInfo] of this.rowOrderMap) {\n      if (orderInfo.oldPosition !== orderInfo.newPosition) {\n        console.log('🔍 Order change detected for item:', itemId, orderInfo);\n        return true;\n      }\n    }\n    console.log('🔍 No order change detected');\n    return false;\n  }\n\n  /**\n   * Reset the row order map to original positions (for reset action)\n   */\n  private resetRowOrderMap(): void {\n    // Get the current full dataset from the config (not cached data)\n    const fullData = this.mergedConfig().data || [];\n    \n    // Completely rebuild the order tracking from current data\n    this.rowOrderMap.clear();\n    this.initialDataOrderIds = [];\n    \n    // Rebuild the order tracking with current data\n    fullData.forEach((item, index) => {\n      const itemId = this.getItemId(item);\n      if (itemId) {\n        const actualOrder = this.getItemOrder(item);\n        this.initialDataOrderIds.push(itemId);\n        this.rowOrderMap.set(itemId, {\n          oldPosition: actualOrder || (index + 1),\n          newPosition: actualOrder || (index + 1)\n        });\n      }\n    });\n    \n    // Clear any local reordered data\n    this.localReorderedData = [];\n    this.hasOrderChanged.set(false);\n    \n    console.log('🔍 Row order map completely rebuilt from current data:', this.initialDataOrderIds.length, 'items');\n  }\n\n  /**\n   * Update the row order map baseline to current positions (for save action)\n   */\n  private updateRowOrderMapBaseline(): void {\n    // Get the current full dataset from the config\n    const fullData = this.mergedConfig().data || [];\n    \n    // Completely rebuild the order tracking from current data\n    this.rowOrderMap.clear();\n    this.initialDataOrderIds = [];\n    \n    // Rebuild the order tracking with current data\n    fullData.forEach((item, index) => {\n      const itemId = this.getItemId(item);\n      if (itemId) {\n        const actualOrder = this.getItemOrder(item);\n        this.initialDataOrderIds.push(itemId);\n        this.rowOrderMap.set(itemId, {\n          oldPosition: actualOrder || (index + 1),\n          newPosition: actualOrder || (index + 1)\n        });\n      }\n    });\n    \n    console.log('🔍 Row order map baseline completely rebuilt from current data:', this.initialDataOrderIds.length, 'items');\n  }\n\n  /**\n   * Get the current order array from the row order map\n   */\n  private getCurrentOrderFromMap(): T[] {\n    const orderedItems: Array<{ item: T; newPosition: number }> = [];\n    \n    // Get the full dataset from the config (not just displayedData)\n    const fullData = this.mergedConfig().data || [];\n    \n    // Collect all items with their new positions from the full dataset\n    this.rowOrderMap.forEach((orderInfo, itemId) => {\n      const item = fullData.find(dataItem => this.getItemId(dataItem) === itemId);\n      if (item) {\n        orderedItems.push({ item, newPosition: orderInfo.newPosition });\n      }\n    });\n    \n    // Sort by new position and return items in order\n    return orderedItems\n      .sort((a, b) => a.newPosition - b.newPosition)\n      .map(orderedItem => orderedItem.item);\n  }\n\n  /**\n   * Update local data order for visual reordering (LOCAL ONLY)\n   */\n  private updateLocalDataOrder(newOrder: T[]): void {\n    // Store the reordered data locally for visual display\n    this.localReorderedData = [...newOrder];\n    console.log('🔍 Local data order updated for visual display:', this.localReorderedData.length, 'items');\n  }\n\n  /**\n   * Check if the current order has changed from the initial order\n   */\n  private checkOrderChanged(currentOrder: T[]): boolean {\n    if (this.initialDataOrderIds.length !== currentOrder.length) {\n      return true;\n    }\n    \n    // Create arrays of IDs to compare order\n    const currentIds = currentOrder.map(item => this.getItemId(item)).filter(id => id !== null) as string[];\n    \n    // Compare the sequences\n    for (let i = 0; i < this.initialDataOrderIds.length; i++) {\n      if (this.initialDataOrderIds[i] !== currentIds[i]) {\n        console.log('🔍 Order changed detected:', {\n          position: i,\n          initial: this.initialDataOrderIds[i],\n          current: currentIds[i]\n        });\n        return true;\n      }\n    }\n    \n    console.log('🔍 No order change detected');\n    return false;\n  }\n\n  onRowClick(item: T) {\n    if (this.mergedConfig().onRowClick) {\n      this.emitEvent('rowClick', item);\n    }\n  }\n\n  onActionClick(item: T, action: GridAction) {\n    // Handle tree expand/collapse actions\n    if (action.key === 'toggle-expand' && this.mergedConfig().tree?.enabled) {\n      this.toggleTreeExpand(item);\n    }\n    \n    // Handle order management actions\n    if (action.key === 'reset-order') {\n      this.hasOrderChanged.set(false);\n      // Reset the row order map to current positions (LOCAL ONLY)\n      this.resetRowOrderMap();\n      // Clear local reordered data to revert to original display\n      this.localReorderedData = [];\n      console.log('🔍 Reset clicked, row order map reset locally, visual display reverted');\n    } else if (action.key === 'save-order') {\n      this.hasOrderChanged.set(false);\n      // Update the row order map to current positions as new baseline\n      this.updateRowOrderMapBaseline();\n      // Clear local reordered data as it's now the baseline\n      this.localReorderedData = [];\n      console.log('🔍 Save clicked, row order map updated to new baseline, local data cleared');\n      \n      // NOW emit the reorder event to update external components\n      const currentOrder = this.getCurrentOrderFromMap();\n      if (currentOrder.length > 0) {\n        console.log('🔍 Emitting rowReorder event to update external components:', currentOrder);\n        // Use the expected GridEvent structure for rowReorder\n        this.emitEvent('rowReorder', {\n          sourceItem: currentOrder[0], // First item as source\n          sourceIndex: 0, // First position as source\n          targetItem: currentOrder[currentOrder.length - 1], // Last item as target\n          targetIndex: currentOrder.length - 1, // Last position as target\n          newOrder: currentOrder // The complete new order\n        });\n      }\n    }\n    \n    if (this.actionHandlers[action.onClick]) {\n      this.actionHandlers[action.onClick](item, action);\n    }\n    this.emitEvent('action', item, undefined, action);\n  }\n\n  // ===== Utility Methods =====\n  \n  private emitEvent(type: GridEvent<T>['type'], data: GridEvent<T>['data'], column?: GridColumn, action?: GridAction) {\n    this.gridEvent.emit({ type, data, column, action } as GridEvent<T>);\n  }\n\n  /**\n   * Get nested value from an object\n   * @param obj - The object to get the nested value from\n   * @param path - The path to the nested value (e.g., 'contact.email')\n   * @returns The nested value or undefined if not found\n   * @example\n   * const obj = { contact: { email: 'test@example.com' } };\n   * const value = getNestedValue(obj, 'contact.email');\n   * // value === 'test@example.com'\n   */\n  getNestedValue(obj: T, path: string): unknown {\n    return path.split('.').reduce((current: unknown, key: string) => {\n      return current && typeof current === 'object' ? (current as Record<string, unknown>)[key] : undefined;\n    }, obj);\n  }\n\n  formatValue(value: unknown, column: GridColumn): string {\n    if (column.formatter) {\n      if (column.formatter.type === 'custom' && column.formatter.customFunction) {\n        const formatter = this.customFormatters[column.formatter.customFunction];\n        if (formatter) {\n          return formatter(value, column.formatter.format);\n        }\n      }\n      \n      // Built-in formatters\n      switch (column.formatter.type) {\n        case 'date':\n          return this.formatDate(value);\n        case 'currency':\n          return this.formatCurrency(value, column.formatter.format);\n        case 'percentage':\n          return this.formatPercentage(value);\n        default:\n          return String(value || '');\n      }\n    }\n    \n    return String(value || '');\n  }\n\n  private formatDate(value: unknown): string {\n    if (!value) return 'N/A';\n    const date = new Date(value as string);\n    return isNaN(date.getTime()) ? 'Invalid Date' : date.toLocaleDateString();\n  }\n\n  private formatCurrency(value: unknown, currency = 'USD'): string {\n    if (value === null || value === undefined) return 'N/A';\n    const num = Number(value);\n    return isNaN(num) ? 'N/A' : new Intl.NumberFormat('en-US', { \n      style: 'currency', \n      currency \n    }).format(num);\n  }\n\n  private formatPercentage(value: unknown): string {\n    if (value === null || value === undefined) return 'N/A';\n    const num = Number(value);\n    return isNaN(num) ? 'N/A' : `${num}%`;\n  }\n\n  renderCustomCell(value: unknown, row: T, column: GridColumn): string {\n    if (column.renderer && this.customRenderers[column.renderer]) {\n      return this.customRenderers[column.renderer](value, row);\n    }\n    return this.formatValue(value, column);\n  }\n\n  // Enhanced renderer methods for template support\n  isTemplateRenderer(rendererKey: string): boolean {\n    return !!this.templateRenderers[rendererKey];\n  }\n\n  isStringRenderer(rendererKey: string): boolean {\n    return !!this.customRenderers[rendererKey];\n  }\n\n  getTemplateRenderer(rendererKey: string): TemplateRenderer<T> | null {\n    return this.templateRenderers[rendererKey] as TemplateRenderer<T> | null;\n  }\n\n  getStringRenderer(rendererKey: string): StringRenderer<T> | null {\n    return this.customRenderers[rendererKey] || null;\n  }\n\n  getTemplateContext(value: unknown, row: T, column: GridColumn): TemplateContext<T> {\n    return {\n      $implicit: value,\n      row,\n      value,\n      column\n    };\n  }\n\n  getColumnWidthClass(width?: ColumnWidth): string {\n    if (!width || width === 'auto') return '';\n    \n    const widthMap = {\n      'xs': 'tw-w-16',\n      'sm': 'tw-w-24',\n      'md': 'tw-w-32',\n      'lg': 'tw-w-48',\n      'xl': 'tw-w-64'\n    };\n    \n    return widthMap[width as keyof typeof widthMap] || `tw-w-[${width}]`;\n  }\n\n  getColumnMaxWidthClass(width?: ColumnWidth): string {\n    if (!width || width === 'auto') return 'tw-max-w-xs';\n    \n    const maxWidthMap = {\n      'xs': 'tw-max-w-16',\n      'sm': 'tw-max-w-24',\n      'md': 'tw-max-w-32',\n      'lg': 'tw-max-w-48',\n      'xl': 'tw-max-w-64'\n    };\n    \n    return maxWidthMap[width as keyof typeof maxWidthMap] || `tw-max-w-[${width}]`;\n  }\n\n  getStatusClass(value: unknown, statusConfig?: StatusConfig): string {\n    if (!statusConfig) return '';\n    return value === statusConfig.activeValue ? statusConfig.activeClass : statusConfig.inactiveClass;\n  }\n\n  getStatusText(value: unknown, statusConfig?: StatusConfig): string {\n    if (!statusConfig) return String(value || '');\n    return value === statusConfig.activeValue ? statusConfig.activeLabel : statusConfig.inactiveLabel;\n  }\n\n  getItemRangeText(): string {\n    const total = this.totalItems();\n    \n    if (this.serverSidePagination) {\n      // For server-side pagination, calculate based on actual displayed data\n      const displayedCount = this.displayedData.length;\n      const start = (this.currentPage() - 1) * this.pageSize() + 1;\n      const end = start + displayedCount - 1;\n      return `${start}-${end} of ${total}`;\n    } else {\n      // For client-side pagination, use the original logic\n      const start = (this.currentPage() - 1) * this.pageSize() + 1;\n      const end = Math.min(this.currentPage() * this.pageSize(), total);\n      return `${start}-${end} of ${total}`;\n    }\n  }\n\n  getPageSizeOptions() {\n    return this.mergedConfig().pagination.pageSizeOptions.map(size => ({\n      value: size,\n      label: size.toString()\n    }));\n  }\n\n  trackByFn(index: number, item: T): unknown {\n    const trackBy = this.mergedConfig().trackBy || '_id';\n    return this.getNestedValue(item, trackBy) || index;\n  }\n\n  getSkeletonArray(): number[] {\n    return Array.from({ length: this.loadingConfig.skeletonRows }, (_, i) => i);\n  }\n\n  // ===== Template Helper Methods =====\n  \n  get displayedData(): T[] {\n    // If we have local reordered data (from drag & drop), use that for visual display\n    if (this.localReorderedData.length > 0 && this.hasOrderChanged()) {\n      console.log('🔍 Using local reordered data for display:', this.localReorderedData.length, 'items');\n      return this.localReorderedData;\n    }\n    \n    const data = this.filteredData();\n    \n    // For server-side pagination, the server already provides the correct page of data\n    // For client-side pagination, we need to slice the data\n    if (this.serverSidePagination) {\n      return data;\n    } else {\n      const start = (this.currentPage() - 1) * this.pageSize();\n      const end = start + this.pageSize();\n      return data.slice(start, end);\n    }\n  }\n\n  get columns(): GridColumn[] {\n    const baseColumns = this.mergedConfig().columns || [];\n    return baseColumns;\n  }\n\n  get paginationConfig() {\n    return this.mergedConfig().pagination;\n  }\n\n  get searchConfig() {\n    return this.mergedConfig().search;\n  }\n\n  get loadingConfig() {\n    return this.mergedConfig().loading;\n  }\n\n  get scrollConfig() {\n    return this.mergedConfig().scroll;\n  }\n} ","  <!-- Data Grid Component -->\n  <div class=\"data-grid-container tw-bg-white tw-shadow tw-rounded-lg tw-overflow-visible tw-flex tw-flex-col\" \n       [ngClass]=\"[\n         mergedConfig().tableClass || '',\n         mergedConfig().fullHeight ? 'tw-h-full' : '',\n         isDragDropEnabled() ? 'drag-drop-enabled' : '',\n         isTreeEnabled() ? 'tree-enabled' : ''\n       ]\">\n  \n  <!-- Header Section -->\n  @if (mergedConfig().title || mergedConfig().subtitle) {\n    <div class=\"tw-px-3 tw-py-2 tw-border-b tw-border-gray-200\">\n      @if (mergedConfig().title) {\n        <h3 class=\"tw-text-base tw-font-semibold tw-text-gray-900\">\n          {{ mergedConfig().title }}\n        </h3>\n      }\n      @if (mergedConfig().subtitle) {\n        <p class=\"tw-text-sm tw-text-gray-600 tw-mt-0.5\">\n          {{ mergedConfig().subtitle }}\n        </p>\n      }\n    </div>\n  }\n\n  <!-- Search Section -->\n  @if (searchConfig.enabled) {\n    <div class=\"tw-px-3 tw-py-2 tw-border-b tw-border-gray-200\">\n      <div class=\"tw-flex tw-items-center tw-justify-between\">\n        <!-- Search Input -->\n        <div class=\"tw-max-w-md\">\n          <cide-ele-input [labelHide]=\"true\" [hideHelperAndErrorText]=\"true\" id=\"search-input\" type=\"text\"\n            [ngModel]=\"searchQuery()\"\n            (ngModelChange)=\"updateSearchQuery($event)\"\n            [placeholder]=\"searchConfig.placeholder\"\n            [disabled]=\"loading() || isRefreshing()\"\n            leadingIcon=\"search\"\n            fill=\"outline\">\n          </cide-ele-input>\n        </div>\n        \n        <!-- Drag Order Actions -->\n        @if (isDragDropEnabled() && (isDragging() || hasOrderChanged())) {\n          <div class=\"tw-flex tw-items-center tw-space-x-2\">\n            <button cideEleButton \n                    variant=\"outline\" \n                    size=\"sm\" \n                    (click)=\"onActionClick(null, { key: 'reset-order', label: 'Reset Order', icon: 'undo', variant: 'outline', onClick: 'resetOrder' })\"\n                    class=\"tw-text-blue-700 tw-border-blue-300 hover:tw-bg-blue-100\">\n              <cide-ele-icon size=\"xs\" class=\"tw-w-4 tw-h-4 tw-mr-1\">undo</cide-ele-icon>\n              Reset Order\n            </button>\n            <button cideEleButton \n                    variant=\"primary\" \n                    size=\"sm\" \n                    (click)=\"onActionClick(null, { key: 'save-order', label: 'Save Order', icon: 'save', variant: 'primary', onClick: 'saveOrder' })\"\n                    class=\"tw-bg-blue-600 hover:tw-bg-blue-700 tw-text-white\">\n              <cide-ele-icon size=\"xs\" class=\"tw-w-4 tw-h-4 tw-mr-1\">save</cide-ele-icon>\n              Save Order\n            </button>\n          </div>\n        }\n      </div>\n    </div>\n  }\n\n     <!-- Table Section -->\n   <div class=\"tw-overflow-x-auto tw-relative\"\n        [ngClass]=\"{\n          'tw-flex-1 tw-min-h-0': mergedConfig().fullHeight,\n          'tw-overflow-y-auto': scrollConfig?.enabled,\n          'tw-max-h-full': scrollConfig?.enabled\n        }\"\n        [style.maxHeight]=\"scrollConfig?.enabled ? scrollConfig?.maxHeight : null\"\n        [style.minHeight]=\"scrollConfig?.enabled ? scrollConfig?.minHeight : null\">\n    <table class=\"tw-min-w-full tw-divide-y tw-divide-gray-200 tw-h-full tw-table-fixed\"\n           [class.empty-table]=\"displayedData.length === 0\"\n           [ngClass]=\"{\n             'tw-table-striped': mergedConfig().striped,\n             'tw-border': mergedConfig().bordered,\n             'tw-table-sm': mergedConfig().compact\n           }\"\n           style=\"table-layout: fixed;\">\n      \n      <!-- Table Header -->\n      <thead class=\"tw-bg-gray-50\" \n            [ngClass]=\"[\n              mergedConfig().headerClass || '',\n              scrollConfig?.enabled && scrollConfig?.stickyHeader ? 'tw-sticky tw-top-0 tw-z-10' : ''\n            ]\">\n        <tr>\n          @for (column of columns; track column.key) {\n            <th\n              class=\"tw-px-3 tw-py-2 tw-text-left tw-text-xs tw-font-medium tw-text-gray-500 tw-uppercase tw-tracking-wider tw-truncate\"\n              [ngClass]=\"[\n                getColumnWidthClass(column.width),\n                getColumnMaxWidthClass(column.width),\n                column.align === 'center' ? 'tw-text-center' : '',\n                column.align === 'right' ? 'tw-text-right' : ''\n              ]\"\n              [title]=\"column.header\">\n              {{ column.header }}\n            </th>\n          }\n        </tr>\n      </thead>\n\n      <!-- Table Body -->\n      <tbody class=\"tw-bg-white tw-divide-y tw-divide-gray-200\">\n        @if (loading() || isRefreshing() || pageChangeLoading()) {\n          <!-- Skeleton Loading Rows -->\n          @for (skeletonItem of getSkeletonArray(); track $index) {\n            <tr class=\"tw-animate-pulse tw-border-b tw-border-gray-200\">\n              @for (column of columns; track column.key) {\n                <td class=\"tw-px-3 tw-py-2 tw-whitespace-nowrap\"\n                    [ngClass]=\"[\n                      getColumnWidthClass(column.width),\n                      getColumnMaxWidthClass(column.width)\n                    ]\">\n                  <div class=\"tw-h-2 tw-bg-gray-200 tw-rounded tw-w-3/4\"></div>\n                </td>\n              }\n            </tr>\n          }\n        } @else {\n          @for (item of displayedData; track trackByFn($index, item)) {\n            <tr class=\"tw-group hover:tw-bg-gray-50 tw-border-b-2 tw-border-gray-200\"\n                [ngClass]=\"[\n                  mergedConfig().rowClass || '',\n                  isRefreshing() ? 'tw-opacity-60 tw-pointer-events-none' : '',\n                  isDragDropEnabled() ? 'tw-cursor-move tw-border-2 tw-border-transparent' : '',\n                  !isDragDropEnabled() ? 'tw-transition-colors tw-duration-150' : '',\n                  isTreeEnabled() ? getTreeLevelClass(item) : ''\n                ]\"\n                [style.border-color]=\"isDragOverRow === $index ? '#3b82f6' : 'transparent'\"\n                [style.background-color]=\"isDragOverRow === $index ? '#eff6ff' : ''\"\n                (click)=\"onRowClick(item)\"\n                (keydown.enter)=\"onRowClick(item)\"\n                (keydown.space)=\"onRowClick(item)\"\n                [class.tw-cursor-pointer]=\"mergedConfig().onRowClick && !isDragDropEnabled()\"\n                [tabindex]=\"mergedConfig().onRowClick && !isDragDropEnabled() ? 0 : -1\"\n                [attr.role]=\"mergedConfig().onRowClick && !isDragDropEnabled() ? 'button' : null\"\n                [attr.aria-label]=\"mergedConfig().onRowClick && !isDragDropEnabled() ? 'Select row' : null\"\n                [draggable]=\"isDragDropEnabled()\"\n                (dragstart)=\"onDragStart($event, item, $index)\"\n                (dragover)=\"onDragOver($event)\"\n                (dragleave)=\"onDragLeave($event)\"\n                (drop)=\"onDrop($event, item, $index)\"\n                (dragend)=\"onDragEnd($event)\">\n              \n              @for (column of columns; track column.key) {\n                <td class=\"tw-pr-3 tw-py-1 tw-relative\"\n                    [ngClass]=\"[\n                      getColumnWidthClass(column.width),\n                      getColumnMaxWidthClass(column.width),\n                      mergedConfig().cellClass || '',\n                      column.align === 'center' ? 'tw-text-center' : '',\n                      column.align === 'right' ? 'tw-text-right' : '',\n                      column.truncate !== false ? 'tw-whitespace-nowrap' : 'tw-whitespace-normal'\n                    ]\"\n                    [style.paddingLeft]=\"isTreeEnabled() && $index === 0 ? getTreeIndentStyle(item) : '12px'\"\n                    [style.maxWidth]=\"getColumnMaxWidthClass(column.width) === 'tw-max-w-xs' ? '200px' : getColumnMaxWidthClass(column.width) === 'tw-max-w-sm' ? '300px' : getColumnMaxWidthClass(column.width) === 'tw-max-w-md' ? '400px' : 'none'\"\n                    [style.minWidth]=\"isTreeEnabled() && $index === 0 ? '150px' : '100px'\">\n                  <!-- Tree Expand/Collapse Button (only for first column when tree is enabled) -->\n                  @if (isTreeEnabled() && $index === 0) {\n                    <div class=\"tw-flex tw-items-center tw-space-x-2\">\n                      <!-- Tree Indentation -->\n                      <div class=\"tw-flex tw-items-center\">\n                        @if (hasChildren(item)) {\n                          <button \n                            variant=\"outline\"\n                            size=\"xs\"\n                            type=\"button\"\n                            (click)=\"onActionClick(item, { key: 'toggle-expand', label: 'Toggle', icon: '', variant: 'ghost', onClick: 'toggle-expand' }); $event.stopPropagation()\"\n                            class=\"tw-flex tw-items-center tw-justify-center tw-w-5 tw-h-5 tw-text-gray-500 hover:tw-text-gray-700 tw-rounded\"\n                            [class.tw-transition-colors]=\"!isDragDropEnabled()\"\n                            [title]=\"isItemExpanded(item) ? 'Collapse' : 'Expand'\">\n                            <cide-ele-icon \n                              class=\"tw-w-3 tw-h-3\"\n                              [class.tw-transition-transform]=\"!isDragDropEnabled()\"\n                              [class.tw-rotate-90]=\"isItemExpanded(item)\"\n                              size=\"xs\">\n                              chevron_right\n                            </cide-ele-icon>\n                          </button>\n                        } @else {\n                          <div class=\"tw-w-8 tw-h-5 tw-flex tw-items-center tw-justify-center\">\n                            <!-- <div class=\"tw-w-1 tw-h-1 tw-bg-gray-300 tw-rounded-full\"></div> -->\n                          </div>\n                        }\n                      </div>\n                      \n                      <!-- Cell Content -->\n                      <div class=\"tw-flex-1 tw-w-full\">\n                        @if (column.type === 'text') {\n                          <p class=\"tw-text-sm tw-text-gray-900\"\n                             [class.tw-truncate]=\"column.truncate\"\n                             [title]=\"column.truncate ? (getNestedValue(item, column.valueGetter || column.key) || '').toString() : ''\">\n                            {{ formatValue(getNestedValue(item, column.valueGetter || column.key), column) }}\n                          </p>\n                        } @else if (column.type === 'number') {\n                          <span class=\"tw-text-sm tw-text-gray-900 tw-font-mono\">\n                            {{ formatValue(getNestedValue(item, column.valueGetter || column.key), column) }}\n                          </span>\n                        } @else if (column.type === 'date') {\n                          <span class=\"tw-text-sm tw-text-gray-600\">\n                            {{ formatValue(getNestedValue(item, column.valueGetter || column.key), column) }}\n                          </span>\n                        } @else if (column.type === 'boolean') {\n                          <span class=\"tw-inline-flex tw-items-center tw-px-2 tw-py-0.5 tw-rounded-full tw-text-xs tw-font-medium\"\n                                [ngClass]=\"getNestedValue(item, column.valueGetter || column.key) ? 'tw-bg-green-100 tw-text-green-800' : 'tw-bg-red-100 tw-text-red-800'\">\n                            {{ getNestedValue(item, column.valueGetter || column.key) ? 'Yes' : 'No' }}\n                          </span>\n                        } @else if (column.type === 'status' && column.statusConfig) {\n                          <span class=\"tw-inline-flex tw-items-center tw-px-2 tw-py-0.5 tw-rounded-full tw-text-xs tw-font-medium\"\n                                [ngClass]=\"getStatusClass(getNestedValue(item, column.valueGetter || column.key), column.statusConfig)\">\n                            {{ getStatusText(getNestedValue(item, column.valueGetter || column.key), column.statusConfig) }}\n                          </span>\n                        } @else if (column.type === 'actions' && column.actions) {\n                          <div class=\"tw-flex tw-items-center tw-space-x-2\">\n                            @for (action of column.actions; track action.key) {\n                              <button\n                                cideEleButton\n                                [variant]=\"action.variant || 'ghost'\"\n                                size=\"xs\"\n                                type=\"button\"\n                                (click)=\"onActionClick(item, action); $event.stopPropagation()\"\n                                [title]=\"action.tooltip || action.label\"\n                                [disabled]=\"isRefreshing()\"\n                                class=\"tw-inline-flex tw-items-center tw-px-2 tw-py-2 tw-text-xs tw-font-medium tw-rounded\"\n                                [class.tw-transition-colors]=\"!isDragDropEnabled()\"\n                                [ngClass]=\"{\n                                  'tw-text-gray-700 tw-bg-gray-100 hover:tw-bg-gray-200': action.variant === 'ghost',\n                                  'tw-text-white tw-bg-blue-600 hover:tw-bg-blue-700': action.variant === 'primary',\n                                  'tw-text-blue-700 tw-bg-blue-50 tw-border tw-border-blue-200 hover:tw-bg-blue-100': action.variant === 'outline',\n                                  'tw-text-white tw-bg-red-600 hover:tw-bg-red-700': action.variant === 'danger'\n                                }\">\n                                @if (action.icon) {\n                                  <svg class=\"tw-w-3 tw-h-3 tw-mr-1\" fill=\"currentColor\" viewBox=\"0 0 20 20\">\n                                    <path d=\"M10 12l-5-5h10l-5 5z\"/>\n                                  </svg>\n                                }\n                                {{ action.label }}\n                              </button>\n                            }\n                          </div>\n                        } @else if (column.type === 'custom') {\n                          <!-- Template Renderer -->\n                          @if (column.renderer && isTemplateRenderer(column.renderer)) {\n                            <ng-container \n                              *ngTemplateOutlet=\"getTemplateRenderer(column.renderer)!; \n                                                context: getTemplateContext(getNestedValue(item, column.valueGetter || column.key), item, column)\">\n                            </ng-container>\n                          }\n                          <!-- String Renderer -->\n                          @else if (column.renderer && isStringRenderer(column.renderer)) {\n                            <div [innerHTML]=\"renderCustomCell(getNestedValue(item, column.valueGetter || column.key), item, column)\">\n                            </div>\n                          }\n                          <!-- Default rendering -->\n                          @else {\n                            <div [innerHTML]=\"renderCustomCell(getNestedValue(item, column.valueGetter || column.key), item, column)\">\n                            </div>\n                          }\n                        }\n                      </div>\n                    </div>\n                  } @else {\n                    <!-- Regular cell content (non-tree or non-first column) -->\n                    @if (column.type === 'text') {\n                      <p class=\"tw-text-sm tw-text-gray-900\"\n                         [class.tw-truncate]=\"column.truncate\"\n                         [title]=\"column.truncate ? (getNestedValue(item, column.valueGetter || column.key) || '').toString() : ''\">\n                        {{ formatValue(getNestedValue(item, column.valueGetter || column.key), column) }}\n                      </p>\n                    } @else if (column.type === 'number') {\n                      <span class=\"tw-text-sm tw-text-gray-900 tw-font-mono\">\n                        {{ formatValue(getNestedValue(item, column.valueGetter || column.key), column) }}\n                      </span>\n                    } @else if (column.type === 'date') {\n                      <span class=\"tw-text-sm tw-text-gray-600\">\n                        {{ formatValue(getNestedValue(item, column.valueGetter || column.key), column) }}\n                      </span>\n                    } @else if (column.type === 'boolean') {\n                      <span class=\"tw-inline-flex tw-items-center tw-px-2 tw-py-0.5 tw-rounded-full tw-text-xs tw-font-medium\"\n                            [ngClass]=\"getNestedValue(item, column.valueGetter || column.key) ? 'tw-bg-green-100 tw-text-green-800' : 'tw-bg-red-100 tw-text-red-800'\">\n                        {{ getNestedValue(item, column.valueGetter || column.key) ? 'Yes' : 'No' }}\n                      </span>\n                    } @else if (column.type === 'status' && column.statusConfig) {\n                      <span class=\"tw-inline-flex tw-items-center tw-px-2 tw-py-0.5 tw-rounded-full tw-text-xs tw-font-medium\"\n                            [ngClass]=\"getStatusClass(getNestedValue(item, column.valueGetter || column.key), column.statusConfig)\">\n                        {{ getStatusText(getNestedValue(item, column.valueGetter || column.key), column.statusConfig) }}\n                      </span>\n                    } @else if (column.type === 'actions' && column.actions) {\n                      <div class=\"tw-flex tw-items-center tw-space-x-2\">\n                        @for (action of column.actions; track action.key) {\n                          <button\n                            cideEleButton\n                            [variant]=\"action.variant || 'ghost'\"\n                            size=\"xs\"\n                            type=\"button\"\n                            (click)=\"onActionClick(item, action); $event.stopPropagation()\"\n                            [title]=\"action.tooltip || action.label\"\n                            [disabled]=\"isRefreshing()\"\n                            class=\"tw-inline-flex tw-items-center tw-px-2 tw-py-2 tw-text-xs tw-font-medium tw-rounded\"\n                            [class.tw-transition-colors]=\"!isDragDropEnabled()\"\n                            [ngClass]=\"{\n                              'tw-text-gray-700 tw-bg-gray-100 hover:tw-bg-gray-200': action.variant === 'ghost',\n                              'tw-text-white tw-bg-blue-600 hover:tw-bg-blue-700': action.variant === 'primary',\n                              'tw-text-blue-700 tw-bg-blue-50 tw-border tw-border-blue-200 hover:tw-bg-blue-100': action.variant === 'outline',\n                              'tw-text-white tw-bg-red-600 hover:tw-bg-red-700': action.variant === 'danger'\n                            }\">\n                            @if (action.icon) {\n                              <svg class=\"tw-w-3 tw-h-3 tw-mr-1\" fill=\"currentColor\" viewBox=\"0 0 20 20\">\n                                <path d=\"M10 12l-5-5h10l-5 5z\"/>\n                              </svg>\n                            }\n                            {{ action.label }}\n                          </button>\n                        }\n                      </div>\n                    } @else if (column.type === 'custom') {\n                      <!-- Template Renderer -->\n                      @if (column.renderer && isTemplateRenderer(column.renderer)) {\n                        <ng-container \n                          *ngTemplateOutlet=\"getTemplateRenderer(column.renderer)!; \n                                            context: getTemplateContext(getNestedValue(item, column.valueGetter || column.key), item, column)\">\n                        </ng-container>\n                      }\n                      <!-- String Renderer -->\n                      @else if (column.renderer && isStringRenderer(column.renderer)) {\n                        <div [innerHTML]=\"renderCustomCell(getNestedValue(item, column.valueGetter || column.key), item, column)\">\n                        </div>\n                      }\n                      <!-- Default rendering -->\n                      @else {\n                        <div [innerHTML]=\"renderCustomCell(getNestedValue(item, column.valueGetter || column.key), item, column)\">\n                        </div>\n                      }\n                    }\n                  }\n                </td>\n              }\n            </tr>\n          }\n          \n          <!-- Empty State -->\n          @if (displayedData.length === 0) {\n            <tr class=\"tw-h-full\">\n              <td [attr.colspan]=\"columns.length\" class=\"tw-px-6 tw-py-22 tw-text-center tw-h-full tw-align-middle\">\n                <div class=\"tw-text-gray-500 tw-flex tw-flex-col tw-items-center tw-justify-center tw-min-h-[300px]\">\n                  <svg class=\"tw-mx-auto tw-h-12 tw-w-12 tw-text-gray-400\" fill=\"none\" stroke=\"currentColor\" viewBox=\"0 0 24 24\">\n                    <path stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M9 12h6m-6 4h6m2 5H7a2 2 0 01-2-2V5a2 2 0 012-2h5.586a1 1 0 01.707.293l5.414 5.414a1 1 0 01.293.707V19a2 2 0 01-2 2z\"></path>\n                  </svg>\n                  <h3 class=\"tw-mt-2 tw-text-sm tw-font-medium tw-text-gray-900\">No data found</h3>\n                  <p class=\"tw-mt-1 tw-text-sm tw-text-gray-500\">\n                    @if (searchQuery()) {\n                      No results match your search criteria.\n                    } @else {\n                      There are no items to display.\n                    }\n                  </p>\n                </div>\n              </td>\n            </tr>\n          }\n        }\n      </tbody>\n    </table>\n  </div>\n\n     <!-- Pagination Section -->\n   @if (paginationConfig.enabled && totalItems() > 0) {\n     <div class=\"tw-px-3 tw-py-2 tw-border-t tw-border-gray-200 tw-bg-white tw-relative tw-z-20\"\n          [class.tw-opacity-60]=\"isRefreshing()\">\n      \n      <!-- Results Info and Page Size -->\n      <div class=\"tw-flex tw-flex-col sm:tw-flex-row tw-justify-between tw-items-start sm:tw-items-center tw-space-y-2 sm:tw-space-y-0\">\n        \n        <!-- Results Info -->\n        @if (paginationConfig.showPageInfo) {\n          <div class=\"tw-flex tw-items-center tw-space-x-4\">\n            <p class=\"tw-text-sm tw-text-gray-700\">\n              Showing {{ getItemRangeText() }} results\n            </p>\n            \n                         <!-- Page Size Selector -->\n             <div class=\"tw-flex tw-items-center tw-space-x-2\">\n               <span class=\"tw-text-sm tw-text-gray-700\">Per page:</span>\n               <div class=\"tw-w-20 tw-relative\">\n                 <cide-ele-select\n                   [labelHide]=\"true\"\n                   [ngModel]=\"pageSize()\"\n                   (ngModelChange)=\"updatePageSize($event)\"\n                   [options]=\"getPageSizeOptions()\"\n                   [disabled]=\"isRefreshing()\"\n                   fill=\"outline\"\n                   size=\"sm\"\n                   class=\"tw-z-30\">\n                 </cide-ele-select>\n               </div>\n             </div>\n          </div>\n        }\n\n        <!-- Pagination Controls -->\n        <div class=\"tw-flex tw-items-center tw-space-x-3\">\n          \n          <!-- Previous/Next and Page Numbers -->\n          <div class=\"tw-flex tw-items-center tw-space-x-1\">\n            \n            <!-- First Page -->\n            <button\n              cideEleButton\n              variant=\"ghost\"\n              size=\"sm\"\n              type=\"button\"\n              (click)=\"onPageChange(1)\"\n              [disabled]=\"currentPage() === 1 || isRefreshing()\"\n              class=\"tw-px-3 tw-py-2 tw-text-lg tw-text-gray-500 hover:tw-text-gray-700 hover:tw-bg-gray-100 tw-rounded-md tw-transition-colors disabled:tw-opacity-50 disabled:tw-cursor-not-allowed\">\n              ««\n            </button>\n            \n            <!-- Previous Page -->\n            <button\n              cideEleButton\n              variant=\"ghost\"\n              size=\"sm\"\n              type=\"button\"\n              (click)=\"previousPage()\"\n              [disabled]=\"!hasPreviousPage() || isRefreshing()\"\n              class=\"tw-px-3 tw-py-2 tw-text-lg tw-text-gray-500 hover:tw-text-gray-700 hover:tw-bg-gray-100 tw-rounded-md tw-transition-colors disabled:tw-opacity-50 disabled:tw-cursor-not-allowed\">\n              ‹\n            </button>\n            \n            <!-- Page Numbers -->\n            @for (page of getEnhancedPageNumbers(); track page) {\n              @if (page === '...') {\n                <span class=\"tw-px-2 tw-py-2 tw-text-sm tw-text-gray-500\">...</span>\n              } @else {\n                <button\n                  cideEleButton\n                  [variant]=\"currentPage() === page ? 'primary' : 'outline'\"\n                  size=\"sm\"\n                  type=\"button\"\n                  (click)=\"onPageChange(page)\"\n                  [disabled]=\"isRefreshing()\"\n                  class=\"tw-px-3 tw-py-2 tw-text-sm tw-border tw-rounded-md tw-transition-colors\"\n                  [ngClass]=\"{\n                    'tw-bg-blue-600 tw-text-white tw-border-blue-600': currentPage() === page,\n                    'tw-bg-white tw-text-gray-700 tw-border-gray-300 hover:tw-bg-gray-50': currentPage() !== page\n                  }\">\n                  {{ page }}\n                </button>\n              }\n            }\n            \n            <!-- Next Page -->\n            <button\n              cideEleButton\n              variant=\"ghost\"\n              size=\"sm\"\n              type=\"button\"\n              (click)=\"nextPage()\"\n              [disabled]=\"!hasNextPage() || isRefreshing()\"\n              class=\"tw-px-3 tw-py-2 tw-text-lg tw-text-gray-500 hover:tw-text-gray-700 hover:tw-bg-gray-100 tw-rounded-md tw-transition-colors disabled:tw-opacity-50 disabled:tw-cursor-not-allowed\">\n              ›\n            </button>\n            \n            <!-- Last Page -->\n            <button\n              cideEleButton\n              variant=\"ghost\"\n              size=\"sm\"\n              type=\"button\"\n              (click)=\"onPageChange(totalPages())\"\n              [disabled]=\"currentPage() === totalPages() || isRefreshing()\"\n              class=\"tw-px-3 tw-py-2 tw-text-lg tw-text-gray-500 hover:tw-text-gray-700 hover:tw-bg-gray-100 tw-rounded-md tw-transition-colors disabled:tw-opacity-50 disabled:tw-cursor-not-allowed\">\n              »»\n            </button>\n            \n          </div>\n\n          <!-- Quick Jump and Refresh -->\n          @if (paginationConfig.showQuickJump || paginationConfig.showRefresh) {\n            <div class=\"tw-flex tw-items-center tw-space-x-2 tw-border-l tw-border-gray-200 tw-pl-3\">\n              \n              <!-- Quick Jump -->\n              @if (paginationConfig.showQuickJump) {\n                                  <div class=\"tw-flex tw-items-center tw-space-x-1\">\n                    <span class=\"tw-text-sm tw-text-gray-700\">Go to:</span>\n                    <div class=\"tw-w-20\">\n                                              <cide-ele-input id=\"jump-to-page-input\" type=\"number\" [labelHide]=\"true\" [hideHelperAndErrorText]=\"true\"\n                          [(ngModel)]=\"jumpToPage\" [min]=\"1\" [max]=\"totalPages()\"\n                          [disabled]=\"isRefreshing()\"\n                          (keydown.enter)=\"onJumpToPage()\">\n                      </cide-ele-input>\n                    </div>\n                  <button\n                    cideEleButton\n                    variant=\"outline\"\n                    size=\"sm\"\n                    type=\"button\"\n                    (click)=\"onJumpToPage()\"\n                    [disabled]=\"isRefreshing()\"\n                    class=\"tw-px-3 tw-py-2 tw-text-sm tw-bg-gray-100 tw-text-gray-700 tw-border tw-border-gray-300 tw-rounded-md hover:tw-bg-gray-200 disabled:tw-opacity-50 disabled:tw-cursor-not-allowed\">\n                    Go\n                  </button>\n                </div>\n              }\n              \n              <!-- Refresh Button -->\n              @if (paginationConfig.showRefresh) {\n                <button\n                  cideEleButton\n                  variant=\"outline\"\n                  size=\"sm\"\n                  type=\"button\"\n                  (click)=\"onRefresh()\"\n                  [disabled]=\"isRefreshing()\"\n                  class=\"!tw-w-10 !tw-h-8 tw-flex tw-items-center tw-justify-center tw-text-gray-600 tw-bg-gray-100 tw-border tw-border-gray-300 tw-rounded-md hover:tw-bg-gray-200 disabled:tw-opacity-50 disabled:tw-cursor-not-allowed\">\n                  @if (isRefreshing()) {\n                    <svg class=\"tw-animate-spin tw-h-4 tw-w-4\" fill=\"none\" viewBox=\"0 0 24 24\">\n                      <circle class=\"tw-opacity-25\" cx=\"12\" cy=\"12\" r=\"10\" stroke=\"currentColor\" stroke-width=\"4\"></circle>\n                      <path class=\"tw-opacity-75\" fill=\"currentColor\" d=\"M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z\"></path>\n                    </svg>\n                  } @else {\n                    <svg class=\"tw-h-4 tw-w-4\" fill=\"none\" stroke=\"currentColor\" viewBox=\"0 0 24 24\">\n                      <path stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"2\" d=\"M4 4v5h.582m15.356 2A8.001 8.001 0 004.582 9m0 0H9m11 11v-5h-.581m0 0a8.003 8.003 0 01-15.357-2m15.357 2H15\"></path>\n                    </svg>\n                  }\n                </button>\n              }\n            </div>\n          }\n          \n        </div>\n      </div>\n    </div>\n  }\n</div>\n"]}