@startsimpli/ui 0.1.0 → 0.1.3

package/dist/chunk-27YUQBOE.mjs

@@ -0,0 +1,3954 @@
+import { cn } from './chunk-G4XBXCFH.mjs';
+import * as React5 from 'react';
+import { useState, useMemo, useCallback, useRef, useEffect } from 'react';
+import { useSearchParams, useRouter, usePathname } from 'next/navigation';
+import { Slot } from '@radix-ui/react-slot';
+import { cva } from 'class-variance-authority';
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+import * as LabelPrimitive from '@radix-ui/react-label';
+import * as SelectPrimitive from '@radix-ui/react-select';
+import { ChevronDown, ChevronUp, Check, ChevronRight, Circle, X, Columns3, Loader2, MoreVertical, Download, FileText, FileSpreadsheet, BookmarkPlus, Star, Trash2, Filter, XCircle, MoreHorizontal, ChevronsLeft, ChevronLeft, ChevronsRight, GripVertical, ArrowUp, ArrowDown, ArrowUpDown } from 'lucide-react';
+import * as CheckboxPrimitive from '@radix-ui/react-checkbox';
+import * as DropdownMenuPrimitive from '@radix-ui/react-dropdown-menu';
+import { DragDropContext, Droppable, Draggable } from '@hello-pangea/dnd';
+import * as XLSX from 'xlsx';
+import * as DialogPrimitive from '@radix-ui/react-dialog';
+
+function useTableState({
+  initialData = [],
+  initialPageSize = 25
+}) {
+  const [data, setDataState] = useState(initialData);
+  const [currentPage, setCurrentPage] = useState(1);
+  const [pageSize, setPageSizeState] = useState(initialPageSize);
+  const [searchTerm, setSearchTerm] = useState("");
+  const [debouncedSearchTerm, setDebouncedSearchTerm] = useState("");
+  const [sortBy, setSortBy] = useState(null);
+  const [sortDirection, setSortDirection] = useState("asc");
+  const [loading, setLoadingState] = useState(false);
+  const [loadingRows, setLoadingRowsState] = useState(/* @__PURE__ */ new Set());
+  const [error, setErrorState] = useState(null);
+  const [viewMode, setViewModeState] = useState("table");
+  const totalCount = data.length;
+  const totalPages = Math.max(1, Math.ceil(totalCount / pageSize));
+  const state = useMemo(() => ({
+    data,
+    filteredData: data,
+    // Will be computed by filters hook
+    displayedData: data,
+    // Will be computed by pagination
+    currentPage,
+    pageSize,
+    totalPages,
+    totalCount,
+    selectedIds: /* @__PURE__ */ new Set(),
+    selectAllPages: false,
+    activeFilters: {},
+    sortBy,
+    sortDirection,
+    searchTerm,
+    debouncedSearchTerm,
+    loading,
+    loadingRows,
+    error,
+    viewMode
+  }), [
+    data,
+    currentPage,
+    pageSize,
+    totalPages,
+    totalCount,
+    sortBy,
+    sortDirection,
+    searchTerm,
+    debouncedSearchTerm,
+    loading,
+    loadingRows,
+    error,
+    viewMode
+  ]);
+  const setData = useCallback((newData) => {
+    setDataState(newData);
+  }, []);
+  const setPage = useCallback((page) => {
+    setCurrentPage(page);
+  }, []);
+  const setPageSize = useCallback((size) => {
+    setPageSizeState(size);
+    setCurrentPage(1);
+  }, []);
+  const setLoading = useCallback((isLoading) => {
+    setLoadingState(isLoading);
+  }, []);
+  const setLoadingRows = useCallback((ids) => {
+    setLoadingRowsState(ids);
+  }, []);
+  const setError = useCallback((err) => {
+    setErrorState(err);
+  }, []);
+  const setViewMode = useCallback((mode) => {
+    setViewModeState(mode);
+  }, []);
+  return {
+    state,
+    setData,
+    setPage,
+    setPageSize,
+    setLoading,
+    setLoadingRows,
+    setError,
+    setViewMode
+  };
+}
+function useSelection({
+  currentPageData,
+  totalCount,
+  getRowId,
+  onSelectionChange,
+  onSelectAllPages,
+  externalSelectedIds,
+  externalSelectAllPages
+}) {
+  const [internalSelectedIds, setInternalSelectedIds] = useState(/* @__PURE__ */ new Set());
+  const [internalSelectAllPages, setInternalSelectAllPages] = useState(false);
+  const isControlled = externalSelectedIds !== void 0;
+  const selectedIds = isControlled ? externalSelectedIds : internalSelectedIds;
+  const selectAllPages = externalSelectAllPages ?? internalSelectAllPages;
+  const onSelectionChangeRef = useRef(onSelectionChange);
+  const onSelectAllPagesRef = useRef(onSelectAllPages);
+  useEffect(() => {
+    onSelectionChangeRef.current = onSelectionChange;
+    onSelectAllPagesRef.current = onSelectAllPages;
+  }, [onSelectionChange, onSelectAllPages]);
+  const prevExternalIdsRef = useRef(void 0);
+  useEffect(() => {
+    if (externalSelectedIds !== void 0 && externalSelectedIds !== prevExternalIdsRef.current) {
+      setInternalSelectedIds(new Set(externalSelectedIds));
+      prevExternalIdsRef.current = externalSelectedIds;
+    }
+  }, [externalSelectedIds]);
+  useEffect(() => {
+    if (externalSelectAllPages !== void 0) {
+      setInternalSelectAllPages(externalSelectAllPages);
+    }
+  }, [externalSelectAllPages]);
+  const toggleRow = useCallback((id) => {
+    setInternalSelectedIds((prev) => {
+      const next = new Set(prev);
+      if (next.has(id)) {
+        next.delete(id);
+      } else {
+        next.add(id);
+      }
+      onSelectionChangeRef.current?.(next);
+      return next;
+    });
+    setInternalSelectAllPages((prev) => {
+      if (prev) {
+        onSelectAllPagesRef.current?.(false);
+        return false;
+      }
+      return prev;
+    });
+  }, []);
+  const toggleAll = useCallback(() => {
+    const currentPageIds = currentPageData.map(getRowId);
+    setInternalSelectedIds((prev) => {
+      const allSelected = currentPageIds.every((id) => prev.has(id));
+      let next;
+      if (allSelected) {
+        next = new Set(prev);
+        currentPageIds.forEach((id) => next.delete(id));
+      } else {
+        next = new Set(prev);
+        currentPageIds.forEach((id) => next.add(id));
+      }
+      onSelectionChangeRef.current?.(next);
+      return next;
+    });
+    setInternalSelectAllPages((prev) => {
+      if (prev) {
+        onSelectAllPagesRef.current?.(false);
+        return false;
+      }
+      return prev;
+    });
+  }, [currentPageData, getRowId]);
+  const selectAllPagesToggle = useCallback(() => {
+    setInternalSelectAllPages((prev) => {
+      const next = !prev;
+      onSelectAllPagesRef.current?.(next);
+      if (next) {
+        setInternalSelectedIds(/* @__PURE__ */ new Set());
+        onSelectionChangeRef.current?.(/* @__PURE__ */ new Set());
+      }
+      return next;
+    });
+  }, []);
+  const clearSelection = useCallback(() => {
+    setInternalSelectedIds(/* @__PURE__ */ new Set());
+    setInternalSelectAllPages(false);
+    onSelectionChangeRef.current?.(/* @__PURE__ */ new Set());
+    onSelectAllPagesRef.current?.(false);
+  }, []);
+  const getSelectedCount = useCallback(() => {
+    if (selectAllPages) {
+      return totalCount;
+    }
+    return selectedIds.size;
+  }, [selectAllPages, selectedIds, totalCount]);
+  return {
+    selectedIds,
+    selectAllPages,
+    toggleRow,
+    toggleAll,
+    selectAllPagesToggle,
+    clearSelection,
+    getSelectedCount
+  };
+}
+function usePagination({
+  totalCount,
+  initialPageSize = 25,
+  initialPage = 1,
+  serverSide = false,
+  onPageChange
+}) {
+  const [currentPage, setCurrentPage] = useState(initialPage);
+  const [pageSize, setPageSize] = useState(initialPageSize);
+  const totalPages = useMemo(() => {
+    return Math.max(1, Math.ceil(totalCount / pageSize));
+  }, [totalCount, pageSize]);
+  const canGoNext = useMemo(() => {
+    return currentPage < totalPages;
+  }, [currentPage, totalPages]);
+  const canGoPrevious = useMemo(() => {
+    return currentPage > 1;
+  }, [currentPage]);
+  const goToPage = useCallback((page) => {
+    const validPage = Math.max(1, Math.min(page, totalPages));
+    setCurrentPage(validPage);
+    onPageChange?.(validPage);
+  }, [totalPages, onPageChange]);
+  const goToFirstPage = useCallback(() => {
+    goToPage(1);
+  }, [goToPage]);
+  const goToLastPage = useCallback(() => {
+    goToPage(totalPages);
+  }, [goToPage, totalPages]);
+  const goToNextPage = useCallback(() => {
+    if (canGoNext) {
+      goToPage(currentPage + 1);
+    }
+  }, [canGoNext, currentPage, goToPage]);
+  const goToPreviousPage = useCallback(() => {
+    if (canGoPrevious) {
+      goToPage(currentPage - 1);
+    }
+  }, [canGoPrevious, currentPage, goToPage]);
+  const getPageNumbers = useCallback(() => {
+    const maxVisible = 7;
+    if (totalPages <= maxVisible) {
+      return Array.from({ length: totalPages }, (_, i) => i + 1);
+    }
+    const pages = [];
+    pages.push(1);
+    if (currentPage > 3) {
+      pages.push("...");
+    }
+    const start = Math.max(2, currentPage - 1);
+    const end = Math.min(totalPages - 1, currentPage + 1);
+    for (let i = start; i <= end; i++) {
+      if (!pages.includes(i)) {
+        pages.push(i);
+      }
+    }
+    if (currentPage < totalPages - 2) {
+      pages.push("...");
+    }
+    if (!pages.includes(totalPages)) {
+      pages.push(totalPages);
+    }
+    return pages;
+  }, [currentPage, totalPages]);
+  const getDisplayRange = useCallback(() => {
+    const start = (currentPage - 1) * pageSize + 1;
+    const end = Math.min(currentPage * pageSize, totalCount);
+    return { start, end };
+  }, [currentPage, pageSize, totalCount]);
+  return {
+    currentPage,
+    pageSize,
+    totalPages,
+    totalCount,
+    canGoNext,
+    canGoPrevious,
+    goToPage,
+    goToFirstPage,
+    goToLastPage,
+    goToNextPage,
+    goToPreviousPage,
+    getPageNumbers,
+    getDisplayRange
+  };
+}
+function useFilters({
+  initialFilters = {},
+  onChange
+}) {
+  const [filters, setFilters] = useState(initialFilters);
+  const setFilter = useCallback((key, value) => {
+    setFilters((prev) => {
+      const next = { ...prev, [key]: value };
+      onChange?.(next);
+      return next;
+    });
+  }, [onChange]);
+  const clearFilter = useCallback((key) => {
+    setFilters((prev) => {
+      const next = { ...prev };
+      delete next[key];
+      onChange?.(next);
+      return next;
+    });
+  }, [onChange]);
+  const clearAllFilters = useCallback(() => {
+    setFilters({});
+    onChange?.({});
+  }, [onChange]);
+  const hasActiveFilters = useCallback(() => {
+    return Object.keys(filters).length > 0;
+  }, [filters]);
+  const getActiveFilterCount = useCallback(() => {
+    return Object.keys(filters).length;
+  }, [filters]);
+  return {
+    filters,
+    setFilter,
+    clearFilter,
+    clearAllFilters,
+    hasActiveFilters,
+    getActiveFilterCount
+  };
+}
+var DEFAULT_BREAKPOINTS = {
+  mobile: 768,
+  tablet: 1024,
+  desktop: 1280
+};
+function useResponsive(breakpoints = DEFAULT_BREAKPOINTS) {
+  const [viewMode, setViewMode] = useState("desktop");
+  const [windowWidth, setWindowWidth] = useState(0);
+  useEffect(() => {
+    const handleResize = () => {
+      const width = window.innerWidth;
+      setWindowWidth(width);
+      if (width < breakpoints.mobile) {
+        setViewMode("mobile");
+      } else if (width < breakpoints.tablet) {
+        setViewMode("tablet");
+      } else {
+        setViewMode("desktop");
+      }
+    };
+    handleResize();
+    window.addEventListener("resize", handleResize);
+    return () => window.removeEventListener("resize", handleResize);
+  }, [breakpoints]);
+  return {
+    viewMode,
+    windowWidth,
+    isMobile: viewMode === "mobile",
+    isTablet: viewMode === "tablet",
+    isDesktop: viewMode === "desktop",
+    isMobileOrTablet: viewMode === "mobile" || viewMode === "tablet"
+  };
+}
+function useColumnVisibility({
+  defaultVisibility = {},
+  persistKey,
+  onVisibilityChange
+} = {}) {
+  const [columnVisibility, setColumnVisibility] = useState(() => {
+    if (persistKey && typeof window !== "undefined") {
+      const stored = localStorage.getItem(`column-visibility-${persistKey}`);
+      if (stored) {
+        try {
+          return JSON.parse(stored);
+        } catch {
+          return defaultVisibility;
+        }
+      }
+    }
+    return defaultVisibility;
+  });
+  useEffect(() => {
+    if (persistKey && typeof window !== "undefined") {
+      localStorage.setItem(`column-visibility-${persistKey}`, JSON.stringify(columnVisibility));
+    }
+    onVisibilityChange?.(columnVisibility);
+  }, [columnVisibility, persistKey, onVisibilityChange]);
+  const toggleColumn = useCallback((columnId) => {
+    setColumnVisibility((prev) => ({
+      ...prev,
+      [columnId]: !(prev[columnId] ?? true)
+    }));
+  }, []);
+  const showColumn = useCallback((columnId) => {
+    setColumnVisibility((prev) => ({
+      ...prev,
+      [columnId]: true
+    }));
+  }, []);
+  const hideColumn = useCallback((columnId) => {
+    setColumnVisibility((prev) => ({
+      ...prev,
+      [columnId]: false
+    }));
+  }, []);
+  const showAllColumns = useCallback(() => {
+    setColumnVisibility({});
+  }, []);
+  const hideAllColumns = useCallback((exceptColumns = []) => {
+    setColumnVisibility((prev) => {
+      const newVisibility = {};
+      Object.keys(prev).forEach((key) => {
+        newVisibility[key] = exceptColumns.includes(key);
+      });
+      return newVisibility;
+    });
+  }, []);
+  const resetVisibility = useCallback(() => {
+    setColumnVisibility(defaultVisibility);
+  }, [defaultVisibility]);
+  const isColumnVisible = useCallback((columnId) => {
+    return columnVisibility[columnId] ?? true;
+  }, [columnVisibility]);
+  return {
+    columnVisibility,
+    setColumnVisibility,
+    toggleColumn,
+    showColumn,
+    hideColumn,
+    showAllColumns,
+    hideAllColumns,
+    resetVisibility,
+    isColumnVisible
+  };
+}
+function useTablePreferences({
+  tableId,
+  enabled = true,
+  defaultColumnVisibility = {},
+  defaultPageSize = 25,
+  debounceMs = 500,
+  apiFetch = fetch
+  // Default to native fetch if not provided
+}) {
+  const [preferences, setPreferences] = useState(null);
+  const [isLoading, setIsLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const saveTimeoutRef = useRef(null);
+  const pendingUpdatesRef = useRef({});
+  useEffect(() => {
+    if (!enabled) {
+      setIsLoading(false);
+      return;
+    }
+    const loadPreferences = async () => {
+      try {
+        const response = await apiFetch(`/api/v1/table-preferences/?tableId=${encodeURIComponent(tableId)}`);
+        if (!response.ok) {
+          throw new Error("Failed to load table preferences");
+        }
+        const data = await response.json();
+        if (data) {
+          setPreferences(data);
+        } else {
+          setPreferences({
+            columnVisibility: defaultColumnVisibility,
+            columnOrder: null,
+            defaultSortColumn: null,
+            defaultSortDirection: null,
+            pageSize: defaultPageSize
+          });
+        }
+      } catch (err) {
+        console.error("Error loading table preferences:", err);
+        setError(err instanceof Error ? err : new Error("Unknown error"));
+        setPreferences({
+          columnVisibility: defaultColumnVisibility,
+          columnOrder: null,
+          defaultSortColumn: null,
+          defaultSortDirection: null,
+          pageSize: defaultPageSize
+        });
+      } finally {
+        setIsLoading(false);
+      }
+    };
+    loadPreferences();
+  }, [tableId, enabled, defaultPageSize]);
+  const savePreferences = useCallback(async (updates) => {
+    pendingUpdatesRef.current = { ...pendingUpdatesRef.current, ...updates };
+    if (saveTimeoutRef.current) {
+      clearTimeout(saveTimeoutRef.current);
+    }
+    saveTimeoutRef.current = setTimeout(async () => {
+      const updatesToSave = { ...pendingUpdatesRef.current };
+      pendingUpdatesRef.current = {};
+      try {
+        const response = await apiFetch("/api/v1/table-preferences/", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            tableId,
+            ...updatesToSave
+          })
+        });
+        if (!response.ok) {
+          throw new Error("Failed to save table preferences");
+        }
+      } catch (err) {
+        console.error("Error saving table preferences:", err);
+      }
+    }, debounceMs);
+  }, [tableId, debounceMs]);
+  useEffect(() => {
+    return () => {
+      if (saveTimeoutRef.current) {
+        clearTimeout(saveTimeoutRef.current);
+      }
+    };
+  }, []);
+  const updateColumnVisibility = useCallback((visibility) => {
+    setPreferences((prev) => prev ? { ...prev, columnVisibility: visibility } : null);
+    savePreferences({ columnVisibility: visibility });
+  }, [savePreferences]);
+  const updateColumnOrder = useCallback((order) => {
+    setPreferences((prev) => prev ? { ...prev, columnOrder: order } : null);
+    savePreferences({ columnOrder: order });
+  }, [savePreferences]);
+  const updateSortPreference = useCallback((sort) => {
+    setPreferences((prev) => prev ? {
+      ...prev,
+      defaultSortColumn: sort.sortBy,
+      defaultSortDirection: sort.sortDirection
+    } : null);
+    savePreferences({
+      defaultSortColumn: sort.sortBy,
+      defaultSortDirection: sort.sortDirection
+    });
+  }, [savePreferences]);
+  const updatePageSize = useCallback((size) => {
+    setPreferences((prev) => prev ? { ...prev, pageSize: size } : null);
+    savePreferences({ pageSize: size });
+  }, [savePreferences]);
+  const resetPreferences = useCallback(async () => {
+    try {
+      const response = await apiFetch(`/api/v1/table-preferences/?tableId=${encodeURIComponent(tableId)}`, {
+        method: "DELETE"
+      });
+      if (!response.ok) {
+        throw new Error("Failed to reset table preferences");
+      }
+      setPreferences({
+        columnVisibility: defaultColumnVisibility,
+        columnOrder: null,
+        defaultSortColumn: null,
+        defaultSortDirection: null,
+        pageSize: defaultPageSize
+      });
+    } catch (err) {
+      console.error("Error resetting table preferences:", err);
+      throw err;
+    }
+  }, [tableId, defaultColumnVisibility, defaultPageSize]);
+  return {
+    preferences,
+    isLoading,
+    error,
+    updateColumnVisibility,
+    updateColumnOrder,
+    updateSortPreference,
+    updatePageSize,
+    resetPreferences
+  };
+}
+function useTableKeyboard({
+  data,
+  getRowId,
+  selectedIds,
+  onToggleRow,
+  onToggleAll,
+  onRowClick,
+  onDelete,
+  tableRef,
+  enabled = true
+}) {
+  const [focusedRowIndex, setFocusedRowIndexState] = useState(-1);
+  const focusedRowIndexRef = useRef(-1);
+  const setFocusedRowIndex = useCallback((index) => {
+    focusedRowIndexRef.current = index;
+    setFocusedRowIndexState(index);
+  }, []);
+  const handleKeyDown = useCallback((event) => {
+    if (!enabled || data.length === 0) return;
+    const { key, ctrlKey, metaKey, shiftKey } = event;
+    const isModifierPressed = ctrlKey || metaKey;
+    if (key === "a" && isModifierPressed && onToggleAll) {
+      event.preventDefault();
+      onToggleAll();
+      return;
+    }
+    if (key === "Delete" && onDelete && selectedIds && selectedIds.size > 0) {
+      event.preventDefault();
+      onDelete(selectedIds);
+      return;
+    }
+    if (key === "ArrowDown") {
+      event.preventDefault();
+      const nextIndex = Math.min(focusedRowIndexRef.current + 1, data.length - 1);
+      setFocusedRowIndex(nextIndex);
+      if (tableRef.current) {
+        const rowElement = tableRef.current.querySelector(
+          `[data-row-index="${nextIndex}"]`
+        );
+        if (rowElement && typeof rowElement.focus === "function") {
+          rowElement.focus();
+        }
+      }
+      return;
+    }
+    if (key === "ArrowUp") {
+      event.preventDefault();
+      const prevIndex = Math.max(focusedRowIndexRef.current - 1, 0);
+      setFocusedRowIndex(prevIndex);
+      if (tableRef.current) {
+        const rowElement = tableRef.current.querySelector(
+          `[data-row-index="${prevIndex}"]`
+        );
+        if (rowElement) {
+          rowElement.focus();
+        }
+      }
+      return;
+    }
+    if (key === "Enter" && focusedRowIndexRef.current >= 0 && onRowClick) {
+      event.preventDefault();
+      const row = data[focusedRowIndexRef.current];
+      if (row) {
+        onRowClick(row);
+      }
+      return;
+    }
+    if (key === " " && focusedRowIndexRef.current >= 0 && onToggleRow) {
+      event.preventDefault();
+      const row = data[focusedRowIndexRef.current];
+      if (row) {
+        const rowId = getRowId(row);
+        onToggleRow(rowId);
+      }
+      return;
+    }
+    if (key === "Home") {
+      event.preventDefault();
+      setFocusedRowIndex(0);
+      if (tableRef.current) {
+        const rowElement = tableRef.current.querySelector(
+          '[data-row-index="0"]'
+        );
+        if (rowElement) {
+          rowElement.focus();
+        }
+      }
+      return;
+    }
+    if (key === "End") {
+      event.preventDefault();
+      const lastIndex = data.length - 1;
+      setFocusedRowIndex(lastIndex);
+      if (tableRef.current) {
+        const rowElement = tableRef.current.querySelector(
+          `[data-row-index="${lastIndex}"]`
+        );
+        if (rowElement) {
+          rowElement.focus();
+        }
+      }
+      return;
+    }
+  }, [
+    enabled,
+    data,
+    getRowId,
+    selectedIds,
+    onToggleRow,
+    onToggleAll,
+    onRowClick,
+    onDelete,
+    tableRef,
+    setFocusedRowIndex
+  ]);
+  useEffect(() => {
+    if (!enabled || !tableRef.current) return;
+    const handleKeyboardEvent = (event) => {
+      const syntheticEvent = {
+        key: event.key,
+        ctrlKey: event.ctrlKey,
+        metaKey: event.metaKey,
+        shiftKey: event.shiftKey,
+        preventDefault: () => event.preventDefault(),
+        stopPropagation: () => event.stopPropagation()
+      };
+      handleKeyDown(syntheticEvent);
+    };
+    const tableElement = tableRef.current;
+    tableElement.addEventListener("keydown", handleKeyboardEvent);
+    return () => {
+      tableElement.removeEventListener("keydown", handleKeyboardEvent);
+    };
+  }, [enabled, tableRef, handleKeyDown]);
+  return {
+    focusedRowIndex,
+    setFocusedRowIndex,
+    handleKeyDown
+  };
+}
+function useTableURL({
+  tableId,
+  persistToUrl,
+  debounceMs = 300
+}) {
+  const searchParams = useSearchParams();
+  const router = useRouter();
+  const pathname = usePathname();
+  const debounceTimerRef = useRef(null);
+  const isApplyingURLRef = useRef(false);
+  const getParamKey = useCallback((key) => {
+    return `${tableId}_${key}`;
+  }, [tableId]);
+  const getURLState = useCallback(() => {
+    if (!persistToUrl) {
+      return {
+        sortBy: null,
+        sortDirection: "asc",
+        filters: {},
+        page: 1,
+        search: ""
+      };
+    }
+    const sortBy = searchParams.get(getParamKey("sortBy"));
+    const sortDirection = searchParams.get(getParamKey("sortDir"));
+    const page = parseInt(searchParams.get(getParamKey("page")) || "1", 10);
+    const search = searchParams.get(getParamKey("search")) || "";
+    const filters = {};
+    const filterPrefix = getParamKey("filter_");
+    searchParams.forEach((value, key) => {
+      if (key.startsWith(filterPrefix)) {
+        const filterKey = key.substring(filterPrefix.length);
+        try {
+          filters[filterKey] = JSON.parse(value);
+        } catch {
+          filters[filterKey] = value;
+        }
+      }
+    });
+    return {
+      sortBy: sortBy || null,
+      sortDirection: sortDirection || "asc",
+      filters,
+      page: isNaN(page) || page < 1 ? 1 : page,
+      search
+    };
+  }, [searchParams, persistToUrl, getParamKey]);
+  const updateURL = useCallback((updates) => {
+    if (!persistToUrl) return;
+    if (debounceTimerRef.current) {
+      clearTimeout(debounceTimerRef.current);
+    }
+    debounceTimerRef.current = setTimeout(() => {
+      const newParams = new URLSearchParams(searchParams.toString());
+      Object.entries(updates).forEach(([key, value]) => {
+        if (value === null || value === "") {
+          newParams.delete(key);
+        } else {
+          newParams.set(key, value);
+        }
+      });
+      const newParamsString = newParams.toString();
+      const currentParamsString = searchParams.toString();
+      if (newParamsString !== currentParamsString) {
+        isApplyingURLRef.current = true;
+        const newURL = newParamsString ? `${pathname}?${newParamsString}` : pathname;
+        router.replace(newURL, { scroll: false });
+        setTimeout(() => {
+          isApplyingURLRef.current = false;
+        }, 50);
+      }
+    }, debounceMs);
+  }, [persistToUrl, searchParams, pathname, router, debounceMs]);
+  const setSortToURL = useCallback((sort) => {
+    if (!persistToUrl) return;
+    updateURL({
+      [getParamKey("sortBy")]: sort.sortBy,
+      [getParamKey("sortDir")]: sort.sortBy ? sort.sortDirection : null,
+      // Reset to page 1 when sorting changes
+      [getParamKey("page")]: "1"
+    });
+  }, [persistToUrl, updateURL, getParamKey]);
+  const setFiltersToURL = useCallback((filters) => {
+    if (!persistToUrl) return;
+    const updates = {};
+    const filterPrefix = getParamKey("filter_");
+    searchParams.forEach((_, key) => {
+      if (key.startsWith(filterPrefix)) {
+        updates[key] = null;
+      }
+    });
+    Object.entries(filters).forEach(([key, value]) => {
+      const paramKey = `${filterPrefix}${key}`;
+      if (value === void 0 || value === null || value === "") {
+        updates[paramKey] = null;
+      } else if (typeof value === "object") {
+        updates[paramKey] = JSON.stringify(value);
+      } else {
+        updates[paramKey] = String(value);
+      }
+    });
+    updates[getParamKey("page")] = "1";
+    updateURL(updates);
+  }, [persistToUrl, updateURL, getParamKey, searchParams]);
+  const setPageToURL = useCallback((page) => {
+    if (!persistToUrl) return;
+    updateURL({
+      [getParamKey("page")]: page > 1 ? String(page) : null
+      // Remove param if page 1
+    });
+  }, [persistToUrl, updateURL, getParamKey]);
+  const setSearchToURL = useCallback((search) => {
+    if (!persistToUrl) return;
+    updateURL({
+      [getParamKey("search")]: search || null,
+      // Reset to page 1 when search changes
+      [getParamKey("page")]: "1"
+    });
+  }, [persistToUrl, updateURL, getParamKey]);
+  const clearURLState = useCallback(() => {
+    if (!persistToUrl) return;
+    const newParams = new URLSearchParams(searchParams.toString());
+    const keysToDelete = [];
+    newParams.forEach((_, key) => {
+      if (key.startsWith(`${tableId}_`)) {
+        keysToDelete.push(key);
+      }
+    });
+    keysToDelete.forEach((key) => newParams.delete(key));
+    const newURL = newParams.toString() ? `${pathname}?${newParams.toString()}` : pathname;
+    router.replace(newURL, { scroll: false });
+  }, [persistToUrl, searchParams, pathname, router, tableId]);
+  const hasURLState = useCallback(() => {
+    if (!persistToUrl) return false;
+    let hasState = false;
+    searchParams.forEach((_, key) => {
+      if (key.startsWith(`${tableId}_`)) {
+        hasState = true;
+      }
+    });
+    return hasState;
+  }, [persistToUrl, searchParams, tableId]);
+  useEffect(() => {
+    return () => {
+      if (debounceTimerRef.current) {
+        clearTimeout(debounceTimerRef.current);
+      }
+    };
+  }, []);
+  return {
+    getURLState,
+    setSortToURL,
+    setFiltersToURL,
+    setPageToURL,
+    setSearchToURL,
+    clearURLState,
+    hasURLState
+  };
+}
+function useColumnReorder({
+  columns,
+  initialOrder = null,
+  enabled = true,
+  onOrderChange
+}) {
+  const defaultOrder = useMemo(() => columns.map((c) => c.id), [columns]);
+  const [columnOrder, setColumnOrder] = useState(() => {
+    if (initialOrder && initialOrder.length > 0) {
+      const validOrder = initialOrder.filter((id) => columns.some((c) => c.id === id));
+      const newColumns = columns.filter((c) => !initialOrder.includes(c.id)).map((c) => c.id);
+      return [...validOrder, ...newColumns];
+    }
+    return defaultOrder;
+  });
+  const orderedColumns = useMemo(() => {
+    if (!enabled) return columns;
+    const columnMap = new Map(columns.map((c) => [c.id, c]));
+    const ordered = [];
+    for (const id of columnOrder) {
+      const column = columnMap.get(id);
+      if (column) {
+        ordered.push(column);
+      }
+    }
+    for (const column of columns) {
+      if (!columnOrder.includes(column.id)) {
+        ordered.push(column);
+      }
+    }
+    return ordered;
+  }, [columns, columnOrder, enabled]);
+  const handleDragEnd = useCallback((result) => {
+    if (!result.destination) return;
+    if (result.source.index === result.destination.index) return;
+    const newOrder = Array.from(columnOrder);
+    const [removed] = newOrder.splice(result.source.index, 1);
+    newOrder.splice(result.destination.index, 0, removed);
+    setColumnOrder(newOrder);
+    onOrderChange?.(newOrder);
+  }, [columnOrder, onOrderChange]);
+  const resetOrder = useCallback(() => {
+    setColumnOrder(defaultOrder);
+    onOrderChange?.(defaultOrder);
+  }, [defaultOrder, onOrderChange]);
+  return {
+    orderedColumns,
+    columnOrder,
+    handleDragEnd,
+    resetOrder
+  };
+}
+function useColumnResize({
+  enabled = true,
+  initialWidths = null,
+  minWidth = 50,
+  onWidthChange
+} = {}) {
+  const [columnWidths, setColumnWidths] = useState(() => initialWidths ?? {});
+  const [resizingColumn, setResizingColumn] = useState(null);
+  const resizeRef = useRef(null);
+  const minWidthRef = useRef(minWidth);
+  const onWidthChangeRef = useRef(onWidthChange);
+  useEffect(() => {
+    minWidthRef.current = minWidth;
+    onWidthChangeRef.current = onWidthChange;
+  }, [minWidth, onWidthChange]);
+  const getColumnWidth = useCallback((columnId, defaultWidth) => {
+    if (!enabled) return defaultWidth;
+    return columnWidths[columnId] ?? defaultWidth;
+  }, [enabled, columnWidths]);
+  const startResize = useCallback((columnId, startX, startWidth) => {
+    if (!enabled) return;
+    resizeRef.current = { columnId, startX, startWidth };
+    setResizingColumn(columnId);
+  }, [enabled]);
+  const handlePointerMove = useCallback((e) => {
+    if (!resizeRef.current) return;
+    const { columnId, startX, startWidth } = resizeRef.current;
+    const diff = e.clientX - startX;
+    const newWidth = Math.max(minWidthRef.current, startWidth + diff);
+    setColumnWidths((prev) => ({ ...prev, [columnId]: newWidth }));
+  }, []);
+  const handlePointerUp = useCallback(() => {
+    if (!resizeRef.current) return;
+    resizeRef.current = null;
+    setResizingColumn(null);
+    setColumnWidths((current) => {
+      onWidthChangeRef.current?.(current);
+      return current;
+    });
+  }, []);
+  useEffect(() => {
+    if (resizingColumn) {
+      document.addEventListener("pointermove", handlePointerMove);
+      document.addEventListener("pointerup", handlePointerUp);
+      document.addEventListener("mousemove", handlePointerMove);
+      document.addEventListener("mouseup", handlePointerUp);
+      document.body.style.cursor = "col-resize";
+      document.body.style.userSelect = "none";
+      return () => {
+        document.removeEventListener("pointermove", handlePointerMove);
+        document.removeEventListener("pointerup", handlePointerUp);
+        document.removeEventListener("mousemove", handlePointerMove);
+        document.removeEventListener("mouseup", handlePointerUp);
+        document.body.style.cursor = "";
+        document.body.style.userSelect = "";
+      };
+    }
+  }, [resizingColumn, handlePointerMove, handlePointerUp]);
+  const resetWidths = useCallback(() => {
+    setColumnWidths({});
+    onWidthChange?.({});
+  }, [onWidthChange]);
+  return {
+    columnWidths,
+    getColumnWidth,
+    startResize,
+    resetWidths,
+    isResizing: resizingColumn !== null,
+    resizingColumn
+  };
+}
+var buttonVariants = cva(
+  "inline-flex items-center justify-center whitespace-nowrap rounded-md text-sm font-medium transition-colors focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring disabled:pointer-events-none disabled:opacity-50",
+  {
+    variants: {
+      variant: {
+        default: "bg-primary text-primary-foreground shadow hover:bg-primary/90",
+        destructive: "bg-destructive text-destructive-foreground shadow-sm hover:bg-destructive/90",
+        outline: "border border-input bg-background shadow-sm hover:bg-accent hover:text-accent-foreground",
+        secondary: "bg-secondary text-secondary-foreground shadow-sm hover:bg-secondary/80",
+        ghost: "hover:bg-accent hover:text-accent-foreground",
+        link: "text-primary underline-offset-4 hover:underline"
+      },
+      size: {
+        default: "h-9 px-4 py-2",
+        sm: "h-8 rounded-md px-3 text-xs",
+        lg: "h-10 rounded-md px-8",
+        icon: "h-9 w-9"
+      }
+    },
+    defaultVariants: {
+      variant: "default",
+      size: "default"
+    }
+  }
+);
+var Button = React5.forwardRef(
+  ({ className, variant, size, asChild = false, ...props }, ref) => {
+    const Comp = asChild ? Slot : "button";
+    return /* @__PURE__ */ jsx(
+      Comp,
+      {
+        className: cn(buttonVariants({ variant, size, className })),
+        ref,
+        ...props
+      }
+    );
+  }
+);
+Button.displayName = "Button";
+var badgeVariants = cva(
+  "inline-flex items-center rounded-md border px-2.5 py-0.5 text-xs font-semibold transition-colors focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2",
+  {
+    variants: {
+      variant: {
+        default: "border-transparent bg-primary text-primary-foreground shadow hover:bg-primary/80",
+        secondary: "border-transparent bg-secondary text-secondary-foreground hover:bg-secondary/80",
+        destructive: "border-transparent bg-destructive text-destructive-foreground shadow hover:bg-destructive/80",
+        outline: "text-foreground"
+      }
+    },
+    defaultVariants: {
+      variant: "default"
+    }
+  }
+);
+function Badge({ className, variant, ...props }) {
+  return /* @__PURE__ */ jsx("div", { className: cn(badgeVariants({ variant }), className), ...props });
+}
+var Input = React5.forwardRef(
+  ({ className, type, ...props }, ref) => {
+    return /* @__PURE__ */ jsx(
+      "input",
+      {
+        type,
+        className: cn(
+          "flex h-9 w-full rounded-md border border-input bg-transparent px-3 py-1 text-sm shadow-sm transition-colors file:border-0 file:bg-transparent file:text-sm file:font-medium placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring disabled:cursor-not-allowed disabled:opacity-50",
+          className
+        ),
+        ref,
+        ...props
+      }
+    );
+  }
+);
+Input.displayName = "Input";
+var labelVariants = cva(
+  "text-sm font-medium leading-none peer-disabled:cursor-not-allowed peer-disabled:opacity-70"
+);
+var Label = React5.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(
+  LabelPrimitive.Root,
+  {
+    ref,
+    className: cn(labelVariants(), className),
+    ...props
+  }
+));
+Label.displayName = LabelPrimitive.Root.displayName;
+var Select = SelectPrimitive.Root;
+var SelectGroup = SelectPrimitive.Group;
+var SelectValue = SelectPrimitive.Value;
+var SelectTrigger = React5.forwardRef(({ className, children, ...props }, ref) => /* @__PURE__ */ jsxs(
+  SelectPrimitive.Trigger,
+  {
+    ref,
+    className: cn(
+      "flex h-10 w-full items-center justify-between rounded-md border border-input bg-background px-3 py-2 text-sm ring-offset-background placeholder:text-muted-foreground focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50 [&>span]:line-clamp-1",
+      className
+    ),
+    ...props,
+    children: [
+      children,
+      /* @__PURE__ */ jsx(SelectPrimitive.Icon, { asChild: true, children: /* @__PURE__ */ jsx(ChevronDown, { className: "h-4 w-4 opacity-50" }) })
+    ]
+  }
+));
+SelectTrigger.displayName = SelectPrimitive.Trigger.displayName;
+var SelectScrollUpButton = React5.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(
+  SelectPrimitive.ScrollUpButton,
+  {
+    ref,
+    className: cn(
+      "flex cursor-default items-center justify-center py-1",
+      className
+    ),
+    ...props,
+    children: /* @__PURE__ */ jsx(ChevronUp, { className: "h-4 w-4" })
+  }
+));
+SelectScrollUpButton.displayName = SelectPrimitive.ScrollUpButton.displayName;
+var SelectScrollDownButton = React5.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(
+  SelectPrimitive.ScrollDownButton,
+  {
+    ref,
+    className: cn(
+      "flex cursor-default items-center justify-center py-1",
+      className
+    ),
+    ...props,
+    children: /* @__PURE__ */ jsx(ChevronDown, { className: "h-4 w-4" })
+  }
+));
+SelectScrollDownButton.displayName = SelectPrimitive.ScrollDownButton.displayName;
+var SelectContent = React5.forwardRef(({ className, children, position = "popper", ...props }, ref) => /* @__PURE__ */ jsx(SelectPrimitive.Portal, { children: /* @__PURE__ */ jsxs(
+  SelectPrimitive.Content,
+  {
+    ref,
+    className: cn(
+      "relative z-50 max-h-96 min-w-[8rem] overflow-hidden rounded-md border bg-popover text-popover-foreground shadow-md data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2",
+      position === "popper" && "data-[side=bottom]:translate-y-1 data-[side=left]:-translate-x-1 data-[side=right]:translate-x-1 data-[side=top]:-translate-y-1",
+      className
+    ),
+    position,
+    ...props,
+    children: [
+      /* @__PURE__ */ jsx(SelectScrollUpButton, {}),
+      /* @__PURE__ */ jsx(
+        SelectPrimitive.Viewport,
+        {
+          className: cn(
+            "p-1",
+            position === "popper" && "h-[var(--radix-select-trigger-height)] w-full min-w-[var(--radix-select-trigger-width)]"
+          ),
+          children
+        }
+      ),
+      /* @__PURE__ */ jsx(SelectScrollDownButton, {})
+    ]
+  }
+) }));
+SelectContent.displayName = SelectPrimitive.Content.displayName;
+var SelectLabel = React5.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(
+  SelectPrimitive.Label,
+  {
+    ref,
+    className: cn("py-1.5 pl-8 pr-2 text-sm font-semibold", className),
+    ...props
+  }
+));
+SelectLabel.displayName = SelectPrimitive.Label.displayName;
+var SelectItem = React5.forwardRef(({ className, children, ...props }, ref) => /* @__PURE__ */ jsxs(
+  SelectPrimitive.Item,
+  {
+    ref,
+    className: cn(
+      "relative flex w-full cursor-default select-none items-center rounded-sm py-1.5 pl-8 pr-2 text-sm outline-none focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50",
+      className
+    ),
+    ...props,
+    children: [
+      /* @__PURE__ */ jsx("span", { className: "absolute left-2 flex h-3.5 w-3.5 items-center justify-center", children: /* @__PURE__ */ jsx(SelectPrimitive.ItemIndicator, { children: /* @__PURE__ */ jsx(Check, { className: "h-4 w-4" }) }) }),
+      /* @__PURE__ */ jsx(SelectPrimitive.ItemText, { children })
+    ]
+  }
+));
+SelectItem.displayName = SelectPrimitive.Item.displayName;
+var SelectSeparator = React5.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(
+  SelectPrimitive.Separator,
+  {
+    ref,
+    className: cn("-mx-1 my-1 h-px bg-muted", className),
+    ...props
+  }
+));
+SelectSeparator.displayName = SelectPrimitive.Separator.displayName;
+function TableFilters({ config, filters, className, defaultExpanded = false }) {
+  const [isExpanded, setIsExpanded] = useState(defaultExpanded);
+  const [expandedSections, setExpandedSections] = useState(/* @__PURE__ */ new Set());
+  const toggleSection = (sectionId) => {
+    setExpandedSections((prev) => {
+      const next = new Set(prev);
+      if (next.has(sectionId)) {
+        next.delete(sectionId);
+      } else {
+        next.add(sectionId);
+      }
+      return next;
+    });
+  };
+  const renderChipsFilter = (section) => {
+    if (section.type !== "chips" || !section.filters) return null;
+    return /* @__PURE__ */ jsx("div", { className: "flex flex-wrap items-center gap-3", children: section.filters.map((filter) => {
+      if (!filter.options) return null;
+      return /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2", children: [
+        /* @__PURE__ */ jsxs(Label, { className: "text-sm text-muted-foreground whitespace-nowrap", children: [
+          filter.label,
+          ":"
+        ] }),
+        /* @__PURE__ */ jsx("div", { className: "flex gap-1", children: filter.options.map((option) => {
+          const isActive = filters.filters[filter.id] === option;
+          return /* @__PURE__ */ jsx(
+            Button,
+            {
+              variant: isActive ? "default" : "outline",
+              size: "sm",
+              onClick: () => {
+                if (isActive) {
+                  filters.clearFilter(filter.id);
+                } else {
+                  filters.setFilter(filter.id, option);
+                }
+              },
+              className: "h-7 px-2 text-xs",
+              children: option
+            },
+            option
+          );
+        }) })
+      ] }, filter.id);
+    }) });
+  };
+  const renderBucketsFilter = (section) => {
+    if (section.type !== "buckets" || !section.buckets) return null;
+    const currentValue = filters.filters[section.id] || "all";
+    return /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-1.5", children: [
+      /* @__PURE__ */ jsxs(Label, { htmlFor: section.id, className: "text-xs text-muted-foreground whitespace-nowrap", children: [
+        section.label,
+        ":"
+      ] }),
+      /* @__PURE__ */ jsxs(Select, { value: currentValue, onValueChange: (value) => filters.setFilter(section.id, value), children: [
+        /* @__PURE__ */ jsx(SelectTrigger, { id: section.id, className: "w-32 h-8 text-xs", children: /* @__PURE__ */ jsx(SelectValue, { placeholder: "Select range" }) }),
+        /* @__PURE__ */ jsx(SelectContent, { children: section.buckets.map((bucket, idx) => /* @__PURE__ */ jsx(SelectItem, { value: bucket.label.toLowerCase().replace(/\s+/g, "-"), children: bucket.label }, idx)) })
+      ] })
+    ] });
+  };
+  const renderDropdownFilter = (filter) => {
+    if (!filter.options) return null;
+    const currentValue = filters.filters[filter.id] || "all";
+    const filteredOptions = filter.options.filter((option) => option.toLowerCase() !== "all");
+    return /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-1.5", children: [
+      /* @__PURE__ */ jsxs(Label, { htmlFor: filter.id, className: "text-xs text-muted-foreground whitespace-nowrap", children: [
+        filter.label,
+        ":"
+      ] }),
+      /* @__PURE__ */ jsxs(Select, { value: currentValue, onValueChange: (value) => filters.setFilter(filter.id, value), children: [
+        /* @__PURE__ */ jsx(SelectTrigger, { id: filter.id, className: "w-28 h-8 text-xs", children: /* @__PURE__ */ jsx(SelectValue, { placeholder: "All" }) }),
+        /* @__PURE__ */ jsxs(SelectContent, { children: [
+          /* @__PURE__ */ jsx(SelectItem, { value: "all", children: "All" }),
+          filteredOptions.map((option) => /* @__PURE__ */ jsx(SelectItem, { value: option, children: option === "null" ? "Not Set" : option }, option))
+        ] })
+      ] })
+    ] }, filter.id);
+  };
+  const renderSearchFilter = (filter) => {
+    const currentValue = filters.filters[filter.id] || "";
+    return /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-1.5", children: [
+      /* @__PURE__ */ jsxs(Label, { htmlFor: filter.id, className: "text-xs text-muted-foreground whitespace-nowrap", children: [
+        filter.label,
+        ":"
+      ] }),
+      /* @__PURE__ */ jsx(
+        Input,
+        {
+          id: filter.id,
+          type: "text",
+          placeholder: filter.label,
+          value: currentValue,
+          onChange: (e) => filters.setFilter(filter.id, e.target.value),
+          className: "w-32 h-8 text-xs"
+        }
+      )
+    ] }, filter.id);
+  };
+  const renderCollapsibleSection = (section) => {
+    if (section.type !== "collapsible" || !section.filters) return null;
+    const isExpanded2 = expandedSections.has(section.id);
+    return /* @__PURE__ */ jsxs("div", { className: "border rounded-lg p-3", children: [
+      /* @__PURE__ */ jsxs(
+        Button,
+        {
+          variant: "ghost",
+          size: "sm",
+          onClick: () => toggleSection(section.id),
+          className: "w-full justify-between -ml-2",
+          children: [
+            /* @__PURE__ */ jsx("span", { className: "font-medium", children: section.label }),
+            isExpanded2 ? /* @__PURE__ */ jsx(ChevronUp, { className: "h-4 w-4" }) : /* @__PURE__ */ jsx(ChevronDown, { className: "h-4 w-4" })
+          ]
+        }
+      ),
+      isExpanded2 && /* @__PURE__ */ jsx("div", { className: "mt-3 space-y-3", children: section.filters.map((filter) => {
+        if (filter.type === "dropdown") {
+          return renderDropdownFilter(filter);
+        }
+        if (filter.type === "search") {
+          return renderSearchFilter(filter);
+        }
+        return null;
+      }) })
+    ] }, section.id);
+  };
+  const renderCustomFilter = useCallback((section) => {
+    if (section.type !== "custom" || !section.customFilter) return null;
+    const currentValue = filters.filters[section.id] ?? section.customFilter.defaultValue;
+    const onChange = (value) => {
+      if (value === section.customFilter?.defaultValue || value === void 0 || value === null) {
+        filters.clearFilter(section.id);
+      } else {
+        filters.setFilter(section.id, value);
+      }
+    };
+    return /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-1.5", children: [
+      section.label && /* @__PURE__ */ jsxs(Label, { className: "text-xs text-muted-foreground whitespace-nowrap", children: [
+        section.label,
+        ":"
+      ] }),
+      section.customFilter.render(currentValue, onChange)
+    ] }, section.id);
+  }, [filters]);
+  const hasActiveFilters = filters.hasActiveFilters();
+  const activeFilterCount = filters.getActiveFilterCount();
+  return /* @__PURE__ */ jsxs("div", { className: cn("rounded-lg border bg-muted/30", className), children: [
+    /* @__PURE__ */ jsxs(
+      "button",
+      {
+        type: "button",
+        onClick: () => setIsExpanded(!isExpanded),
+        className: "w-full flex items-center justify-between px-3 py-2 hover:bg-muted/50 transition-colors",
+        children: [
+          /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2", children: [
+            /* @__PURE__ */ jsx(Filter, { className: "h-4 w-4 text-muted-foreground" }),
+            /* @__PURE__ */ jsx("span", { className: "text-sm font-medium", children: "Filters" }),
+            hasActiveFilters && /* @__PURE__ */ jsx(Badge, { variant: "secondary", className: "text-xs", children: activeFilterCount })
+          ] }),
+          /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2", children: [
+            hasActiveFilters && /* @__PURE__ */ jsxs(
+              Button,
+              {
+                variant: "ghost",
+                size: "sm",
+                onClick: (e) => {
+                  e.stopPropagation();
+                  filters.clearAllFilters();
+                },
+                className: "gap-1 h-6 px-2 text-xs",
+                children: [
+                  /* @__PURE__ */ jsx(XCircle, { className: "h-3 w-3" }),
+                  "Clear"
+                ]
+              }
+            ),
+            isExpanded ? /* @__PURE__ */ jsx(ChevronUp, { className: "h-4 w-4 text-muted-foreground" }) : /* @__PURE__ */ jsx(ChevronDown, { className: "h-4 w-4 text-muted-foreground" })
+          ] })
+        ]
+      }
+    ),
+    isExpanded && /* @__PURE__ */ jsx("div", { className: "px-3 pb-3 pt-1", children: /* @__PURE__ */ jsx("div", { className: "flex flex-wrap items-center gap-x-4 gap-y-2", children: config.sections.map((section) => {
+      if (section.type === "chips") {
+        return /* @__PURE__ */ jsx("div", { children: renderChipsFilter(section) }, section.id);
+      }
+      if (section.type === "buckets") {
+        return /* @__PURE__ */ jsx("div", { children: renderBucketsFilter(section) }, section.id);
+      }
+      if (section.type === "collapsible") {
+        return renderCollapsibleSection(section);
+      }
+      if (section.type === "dropdown" && section.filters) {
+        return section.filters.map((filter) => /* @__PURE__ */ jsx("div", { children: renderDropdownFilter(filter) }, filter.id));
+      }
+      if (section.type === "search" && section.filters) {
+        return section.filters.map((filter) => /* @__PURE__ */ jsx("div", { children: renderSearchFilter(filter) }, filter.id));
+      }
+      if (section.type === "custom") {
+        return /* @__PURE__ */ jsx("div", { children: renderCustomFilter(section) }, section.id);
+      }
+      return null;
+    }) }) })
+  ] });
+}
+function BulkActionBar({
+  selectedCount,
+  selectAllPages,
+  totalCount,
+  bulkActions,
+  onClearSelection,
+  onExecuteAction,
+  className
+}) {
+  const isVisible = selectedCount > 0;
+  const getVariantClassName = (variant) => {
+    switch (variant) {
+      case "gradient-purple":
+        return "bg-gradient-to-r from-purple-600 to-blue-600 text-white hover:from-purple-700 hover:to-blue-700";
+      case "gradient-green":
+        return "bg-gradient-to-r from-green-600 to-teal-600 text-white hover:from-green-700 hover:to-teal-700";
+      case "gradient-indigo":
+        return "bg-gradient-to-r from-indigo-600 to-purple-600 text-white hover:from-indigo-700 hover:to-purple-700";
+      case "gradient-orange":
+        return "bg-gradient-to-r from-orange-600 to-red-600 text-white hover:from-orange-700 hover:to-red-700";
+      case "gradient-blue":
+        return "bg-gradient-to-r from-blue-600 to-indigo-600 text-white hover:from-blue-700 hover:to-indigo-700";
+      default:
+        return "";
+    }
+  };
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      className: cn(
+        "transition-all duration-200 ease-in-out overflow-hidden",
+        isVisible ? "opacity-100 max-h-20" : "opacity-0 max-h-0 pointer-events-none",
+        className
+      ),
+      "aria-hidden": !isVisible,
+      children: /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2 p-3 bg-muted/50 rounded-lg border", children: [
+        /* @__PURE__ */ jsx("div", { className: "flex items-center gap-2 text-sm font-medium", children: selectAllPages ? /* @__PURE__ */ jsxs("span", { className: "text-blue-600", children: [
+          "All ",
+          /* @__PURE__ */ jsx("span", { className: "font-semibold", children: totalCount }),
+          " items selected"
+        ] }) : /* @__PURE__ */ jsx("span", { children: `${selectedCount} ${selectedCount === 1 ? "item" : "items"} selected` }) }),
+        /* @__PURE__ */ jsx("div", { className: "h-6 w-px bg-border mx-1" }),
+        /* @__PURE__ */ jsx("div", { className: "flex items-center gap-2 flex-1", children: bulkActions.map((action) => {
+          const Icon2 = action.icon;
+          const isDisabled = action.disabled?.(/* @__PURE__ */ new Set()) || false;
+          const exceedsMaxSelection = !!(action.maxSelection && selectedCount > action.maxSelection);
+          return /* @__PURE__ */ jsxs(
+            Button,
+            {
+              size: "sm",
+              variant: action.variant === "default" ? "default" : "default",
+              className: cn(
+                getVariantClassName(action.variant),
+                "gap-2"
+              ),
+              onClick: () => onExecuteAction(action),
+              disabled: isDisabled || exceedsMaxSelection,
+              title: exceedsMaxSelection ? `Maximum ${action.maxSelection} items can be selected for this action` : action.label,
+              children: [
+                /* @__PURE__ */ jsx(Icon2, { className: "h-4 w-4" }),
+                action.label,
+                selectAllPages && totalCount > 0 && ` (${totalCount})`
+              ]
+            },
+            action.id
+          );
+        }) }),
+        /* @__PURE__ */ jsxs(
+          Button,
+          {
+            variant: "outline",
+            size: "sm",
+            onClick: onClearSelection,
+            className: "gap-2",
+            children: [
+              /* @__PURE__ */ jsx(X, { className: "h-4 w-4" }),
+              "Clear"
+            ]
+          }
+        )
+      ] })
+    }
+  );
+}
+var Table = React5.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx("div", { className: "relative w-full overflow-auto", children: /* @__PURE__ */ jsx(
+  "table",
+  {
+    ref,
+    className: cn("w-full caption-bottom text-sm", className),
+    ...props
+  }
+) }));
+Table.displayName = "Table";
+var TableHeader = React5.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx("thead", { ref, className: cn("[&_tr]:border-b", className), ...props }));
+TableHeader.displayName = "TableHeader";
+var TableBody = React5.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(
+  "tbody",
+  {
+    ref,
+    className: cn("[&_tr:last-child]:border-0", className),
+    ...props
+  }
+));
+TableBody.displayName = "TableBody";
+var TableFooter = React5.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(
+  "tfoot",
+  {
+    ref,
+    className: cn(
+      "border-t bg-muted/50 font-medium [&>tr]:last:border-b-0",
+      className
+    ),
+    ...props
+  }
+));
+TableFooter.displayName = "TableFooter";
+var TableRow = React5.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(
+  "tr",
+  {
+    ref,
+    className: cn(
+      "border-b transition-colors hover:bg-muted/50 data-[state=selected]:bg-muted",
+      className
+    ),
+    ...props
+  }
+));
+TableRow.displayName = "TableRow";
+var TableHead = React5.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(
+  "th",
+  {
+    ref,
+    className: cn(
+      "h-12 px-4 text-left align-middle font-medium text-muted-foreground [&:has([role=checkbox])]:pr-0",
+      className
+    ),
+    ...props
+  }
+));
+TableHead.displayName = "TableHead";
+var TableCell = React5.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(
+  "td",
+  {
+    ref,
+    className: cn("p-4 align-middle [&:has([role=checkbox])]:pr-0", className),
+    ...props
+  }
+));
+TableCell.displayName = "TableCell";
+var TableCaption = React5.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(
+  "caption",
+  {
+    ref,
+    className: cn("mt-4 text-sm text-muted-foreground", className),
+    ...props
+  }
+));
+TableCaption.displayName = "TableCaption";
+var Checkbox = React5.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(
+  CheckboxPrimitive.Root,
+  {
+    ref,
+    className: cn(
+      "peer h-4 w-4 shrink-0 rounded-sm border border-primary ring-offset-background focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50 data-[state=checked]:bg-primary data-[state=checked]:text-primary-foreground",
+      className
+    ),
+    ...props,
+    children: /* @__PURE__ */ jsx(
+      CheckboxPrimitive.Indicator,
+      {
+        className: cn("flex items-center justify-center text-current"),
+        children: /* @__PURE__ */ jsx(Check, { className: "h-4 w-4" })
+      }
+    )
+  }
+));
+Checkbox.displayName = CheckboxPrimitive.Root.displayName;
+var DropdownMenu = DropdownMenuPrimitive.Root;
+var DropdownMenuTrigger = DropdownMenuPrimitive.Trigger;
+var DropdownMenuGroup = DropdownMenuPrimitive.Group;
+var DropdownMenuPortal = DropdownMenuPrimitive.Portal;
+var DropdownMenuSub = DropdownMenuPrimitive.Sub;
+var DropdownMenuRadioGroup = DropdownMenuPrimitive.RadioGroup;
+var DropdownMenuSubTrigger = React5.forwardRef(({ className, inset, children, ...props }, ref) => /* @__PURE__ */ jsxs(
+  DropdownMenuPrimitive.SubTrigger,
+  {
+    ref,
+    className: cn(
+      "flex cursor-default select-none items-center rounded-sm px-2 py-1.5 text-sm outline-none focus:bg-accent data-[state=open]:bg-accent",
+      inset && "pl-8",
+      className
+    ),
+    ...props,
+    children: [
+      children,
+      /* @__PURE__ */ jsx(ChevronRight, { className: "ml-auto h-4 w-4" })
+    ]
+  }
+));
+DropdownMenuSubTrigger.displayName = DropdownMenuPrimitive.SubTrigger.displayName;
+var DropdownMenuSubContent = React5.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(
+  DropdownMenuPrimitive.SubContent,
+  {
+    ref,
+    className: cn(
+      "z-50 min-w-[8rem] overflow-hidden rounded-md border bg-popover p-1 text-popover-foreground shadow-lg data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2",
+      className
+    ),
+    ...props
+  }
+));
+DropdownMenuSubContent.displayName = DropdownMenuPrimitive.SubContent.displayName;
+var DropdownMenuContent = React5.forwardRef(({ className, sideOffset = 4, ...props }, ref) => /* @__PURE__ */ jsx(DropdownMenuPrimitive.Portal, { children: /* @__PURE__ */ jsx(
+  DropdownMenuPrimitive.Content,
+  {
+    ref,
+    sideOffset,
+    className: cn(
+      "z-50 min-w-[8rem] overflow-hidden rounded-md border bg-popover p-1 text-popover-foreground shadow-md data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2",
+      className
+    ),
+    ...props
+  }
+) }));
+DropdownMenuContent.displayName = DropdownMenuPrimitive.Content.displayName;
+var DropdownMenuItem = React5.forwardRef(({ className, inset, ...props }, ref) => /* @__PURE__ */ jsx(
+  DropdownMenuPrimitive.Item,
+  {
+    ref,
+    className: cn(
+      "relative flex cursor-default select-none items-center rounded-sm px-2 py-1.5 text-sm outline-none transition-colors focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50",
+      inset && "pl-8",
+      className
+    ),
+    ...props
+  }
+));
+DropdownMenuItem.displayName = DropdownMenuPrimitive.Item.displayName;
+var DropdownMenuCheckboxItem = React5.forwardRef(({ className, children, checked, ...props }, ref) => /* @__PURE__ */ jsxs(
+  DropdownMenuPrimitive.CheckboxItem,
+  {
+    ref,
+    className: cn(
+      "relative flex cursor-default select-none items-center rounded-sm py-1.5 pl-8 pr-2 text-sm outline-none transition-colors focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50",
+      className
+    ),
+    checked,
+    ...props,
+    children: [
+      /* @__PURE__ */ jsx("span", { className: "absolute left-2 flex h-3.5 w-3.5 items-center justify-center", children: /* @__PURE__ */ jsx(DropdownMenuPrimitive.ItemIndicator, { children: /* @__PURE__ */ jsx(Check, { className: "h-4 w-4" }) }) }),
+      children
+    ]
+  }
+));
+DropdownMenuCheckboxItem.displayName = DropdownMenuPrimitive.CheckboxItem.displayName;
+var DropdownMenuRadioItem = React5.forwardRef(({ className, children, ...props }, ref) => /* @__PURE__ */ jsxs(
+  DropdownMenuPrimitive.RadioItem,
+  {
+    ref,
+    className: cn(
+      "relative flex cursor-default select-none items-center rounded-sm py-1.5 pl-8 pr-2 text-sm outline-none transition-colors focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50",
+      className
+    ),
+    ...props,
+    children: [
+      /* @__PURE__ */ jsx("span", { className: "absolute left-2 flex h-3.5 w-3.5 items-center justify-center", children: /* @__PURE__ */ jsx(DropdownMenuPrimitive.ItemIndicator, { children: /* @__PURE__ */ jsx(Circle, { className: "h-2 w-2 fill-current" }) }) }),
+      children
+    ]
+  }
+));
+DropdownMenuRadioItem.displayName = DropdownMenuPrimitive.RadioItem.displayName;
+var DropdownMenuLabel = React5.forwardRef(({ className, inset, ...props }, ref) => /* @__PURE__ */ jsx(
+  DropdownMenuPrimitive.Label,
+  {
+    ref,
+    className: cn(
+      "px-2 py-1.5 text-sm font-semibold",
+      inset && "pl-8",
+      className
+    ),
+    ...props
+  }
+));
+DropdownMenuLabel.displayName = DropdownMenuPrimitive.Label.displayName;
+var DropdownMenuSeparator = React5.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(
+  DropdownMenuPrimitive.Separator,
+  {
+    ref,
+    className: cn("-mx-1 my-1 h-px bg-muted", className),
+    ...props
+  }
+));
+DropdownMenuSeparator.displayName = DropdownMenuPrimitive.Separator.displayName;
+var DropdownMenuShortcut = ({
+  className,
+  ...props
+}) => {
+  return /* @__PURE__ */ jsx(
+    "span",
+    {
+      className: cn("ml-auto text-xs tracking-widest opacity-60", className),
+      ...props
+    }
+  );
+};
+DropdownMenuShortcut.displayName = "DropdownMenuShortcut";
+function InlineEditCell({
+  value: initialValue,
+  columnId,
+  rowId,
+  editType = "text",
+  editOptions = [],
+  onSave,
+  onCancel,
+  validate
+}) {
+  const [value, setValue] = useState(initialValue ?? "");
+  const [error, setError] = useState(null);
+  const [isSaving, setIsSaving] = useState(false);
+  const inputRef = useRef(null);
+  useEffect(() => {
+    if (inputRef.current) {
+      inputRef.current.focus();
+      inputRef.current.select();
+    }
+  }, []);
+  const handleSave = useCallback(async () => {
+    if (validate) {
+      const validationError = validate(value);
+      if (validationError) {
+        setError(validationError);
+        return;
+      }
+    }
+    setIsSaving(true);
+    setError(null);
+    try {
+      await onSave(value);
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Failed to save");
+      setIsSaving(false);
+    }
+  }, [value, validate, onSave]);
+  const handleKeyDown = useCallback((e) => {
+    if (e.key === "Enter" && !e.shiftKey) {
+      e.preventDefault();
+      handleSave();
+    } else if (e.key === "Escape") {
+      e.preventDefault();
+      onCancel();
+    }
+  }, [handleSave, onCancel]);
+  if (editType === "select") {
+    return /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-1", children: [
+      /* @__PURE__ */ jsxs(
+        Select,
+        {
+          value: String(value),
+          onValueChange: (newValue) => {
+            setValue(newValue);
+            onSave(newValue);
+          },
+          children: [
+            /* @__PURE__ */ jsx(SelectTrigger, { className: "h-8 w-full", children: /* @__PURE__ */ jsx(SelectValue, {}) }),
+            /* @__PURE__ */ jsx(SelectContent, { children: editOptions.map((option) => /* @__PURE__ */ jsx(SelectItem, { value: option, children: option }, option)) })
+          ]
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        "button",
+        {
+          onClick: onCancel,
+          className: "p-1 hover:bg-muted rounded",
+          disabled: isSaving,
+          children: /* @__PURE__ */ jsx(X, { className: "h-4 w-4 text-muted-foreground" })
+        }
+      )
+    ] });
+  }
+  return /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-1", children: [
+    /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-1", children: [
+      /* @__PURE__ */ jsx(
+        Input,
+        {
+          ref: inputRef,
+          type: editType === "number" ? "number" : editType === "date" ? "date" : "text",
+          value,
+          onChange: (e) => {
+            setValue(e.target.value);
+            setError(null);
+          },
+          onKeyDown: handleKeyDown,
+          className: cn(
+            "h-8 w-full",
+            error && "border-red-500 focus-visible:ring-red-500"
+          ),
+          disabled: isSaving
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        "button",
+        {
+          onClick: handleSave,
+          className: "p-1 hover:bg-green-100 rounded",
+          disabled: isSaving,
+          children: isSaving ? /* @__PURE__ */ jsx(Loader2, { className: "h-4 w-4 animate-spin text-muted-foreground" }) : /* @__PURE__ */ jsx(Check, { className: "h-4 w-4 text-green-600" })
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        "button",
+        {
+          onClick: onCancel,
+          className: "p-1 hover:bg-red-100 rounded",
+          disabled: isSaving,
+          children: /* @__PURE__ */ jsx(X, { className: "h-4 w-4 text-red-600" })
+        }
+      )
+    ] }),
+    error && /* @__PURE__ */ jsx("span", { className: "text-xs text-red-500", children: error })
+  ] });
+}
+function DataTableCore({
+  data,
+  columns,
+  getRowId,
+  selectionEnabled,
+  selectedIds = /* @__PURE__ */ new Set(),
+  onToggleRow,
+  onToggleAll,
+  allRowsSelected,
+  renderSelectionCell,
+  sortingEnabled,
+  sortBy,
+  sortDirection,
+  onSort,
+  columnReorderEnabled,
+  onColumnDragEnd,
+  columnResizeEnabled,
+  columnWidths = {},
+  onColumnResizeStart,
+  isResizing,
+  inlineEditEnabled,
+  onCellEdit,
+  rowActions,
+  onRowClick,
+  loadingRows = /* @__PURE__ */ new Set(),
+  className
+}) {
+  const [editingCell, setEditingCell] = useState(null);
+  const [isDraggingColumn, setIsDraggingColumn] = useState(false);
+  const handleDragStart = useCallback((_) => {
+    setIsDraggingColumn(true);
+  }, []);
+  const handleDragEnd = useCallback((result) => {
+    setIsDraggingColumn(false);
+    onColumnDragEnd?.(result);
+  }, [onColumnDragEnd]);
+  const getEffectiveWidth = (column) => {
+    if (columnResizeEnabled && columnWidths[column.id]) {
+      return columnWidths[column.id];
+    }
+    return column.width;
+  };
+  const handleResizeMouseDown = useCallback((columnId, e) => {
+    e.stopPropagation();
+    e.preventDefault();
+    const th = e.target.closest("th");
+    if (th && onColumnResizeStart) {
+      onColumnResizeStart(columnId, e.clientX, th.offsetWidth);
+    }
+  }, [onColumnResizeStart]);
+  const renderResizeHandle = (columnId) => {
+    if (!columnResizeEnabled) return null;
+    return /* @__PURE__ */ jsx(
+      "div",
+      {
+        "data-resize-handle": "true",
+        className: "absolute right-0 top-0 h-full w-5 cursor-col-resize z-50 flex items-center justify-center group/resize pointer-events-auto",
+        style: { marginRight: "-10px" },
+        onMouseDown: (e) => handleResizeMouseDown(columnId, e),
+        onPointerDown: (e) => handleResizeMouseDown(columnId, e),
+        onDragStart: (e) => e.preventDefault(),
+        children: /* @__PURE__ */ jsx("div", { className: "w-[3px] h-full bg-transparent group-hover/resize:bg-primary transition-colors rounded-full" })
+      }
+    );
+  };
+  const renderCellContent = (column, row) => {
+    if (column.cell) {
+      return column.cell(row);
+    }
+    if (column.accessorFn) {
+      return column.accessorFn(row);
+    }
+    if (column.accessorKey) {
+      const value = row[column.accessorKey];
+      return value !== null && value !== void 0 ? String(value) : "-";
+    }
+    return "-";
+  };
+  const SortIndicator = ({ columnId }) => {
+    const isSorted = sortBy === columnId;
+    const direction = isSorted ? sortDirection : null;
+    if (direction === "asc") {
+      return /* @__PURE__ */ jsx(ArrowUp, { className: "ml-2 h-4 w-4" });
+    } else if (direction === "desc") {
+      return /* @__PURE__ */ jsx(ArrowDown, { className: "ml-2 h-4 w-4" });
+    }
+    return /* @__PURE__ */ jsx(ArrowUpDown, { className: "ml-2 h-4 w-4 opacity-50" });
+  };
+  const handleSortClick = useCallback((columnId) => {
+    if (isDraggingColumn) return;
+    onSort?.(columnId);
+  }, [isDraggingColumn, onSort]);
+  const renderHeader = (column, inDragContext = false) => {
+    if (typeof column.header === "function") {
+      return column.header({});
+    }
+    if (inDragContext) {
+      return /* @__PURE__ */ jsx("span", { children: column.header });
+    }
+    if (sortingEnabled && column.sortable !== false) {
+      return /* @__PURE__ */ jsxs(
+        Button,
+        {
+          variant: "ghost",
+          onClick: () => handleSortClick(column.id),
+          className: "-ml-4 h-8 hover:bg-transparent",
+          children: [
+            column.header,
+            /* @__PURE__ */ jsx(SortIndicator, { columnId: column.id })
+          ]
+        }
+      );
+    }
+    return column.header;
+  };
+  const renderColumnHeaders = () => {
+    if (columnReorderEnabled && onColumnDragEnd) {
+      return /* @__PURE__ */ jsx(DragDropContext, { onDragStart: handleDragStart, onDragEnd: handleDragEnd, children: /* @__PURE__ */ jsx(TableHeader, { children: /* @__PURE__ */ jsx(Droppable, { droppableId: "columns", direction: "horizontal", children: (provided) => /* @__PURE__ */ jsxs(
+        TableRow,
+        {
+          ref: provided.innerRef,
+          ...provided.droppableProps,
+          children: [
+            selectionEnabled && /* @__PURE__ */ jsx(TableHead, { className: "w-12", children: /* @__PURE__ */ jsx(
+              Checkbox,
+              {
+                checked: allRowsSelected,
+                onCheckedChange: onToggleAll,
+                "aria-label": "Select all"
+              }
+            ) }),
+            columns.map((column, index) => /* @__PURE__ */ jsx(Draggable, { draggableId: column.id, index, children: (provided2, snapshot) => /* @__PURE__ */ jsxs(
+              TableHead,
+              {
+                ref: provided2.innerRef,
+                ...provided2.draggableProps,
+                style: {
+                  ...provided2.draggableProps.style,
+                  width: getEffectiveWidth(column),
+                  minWidth: column.minWidth,
+                  maxWidth: column.maxWidth
+                },
+                className: cn(
+                  "relative group overflow-visible",
+                  snapshot.isDragging && "bg-primary/10 shadow-lg ring-2 ring-primary/20 z-50",
+                  columnResizeEnabled && "select-none"
+                ),
+                children: [
+                  /* @__PURE__ */ jsxs(
+                    "div",
+                    {
+                      ...provided2.dragHandleProps,
+                      className: cn(
+                        "flex items-center gap-2 cursor-grab active:cursor-grabbing",
+                        "hover:bg-muted/50 rounded px-1 -mx-1 py-1 transition-colors",
+                        columnResizeEnabled && "pr-4"
+                      ),
+                      children: [
+                        /* @__PURE__ */ jsx(GripVertical, { className: "h-4 w-4 text-muted-foreground flex-shrink-0" }),
+                        /* @__PURE__ */ jsxs(
+                          "div",
+                          {
+                            className: "flex-1 flex items-center",
+                            onClick: (e) => {
+                              if (!snapshot.isDragging && sortingEnabled && column.sortable !== false) {
+                                e.stopPropagation();
+                                handleSortClick(column.id);
+                              }
+                            },
+                            children: [
+                              renderHeader(column, true),
+                              sortingEnabled && column.sortable !== false && /* @__PURE__ */ jsx(SortIndicator, { columnId: column.id })
+                            ]
+                          }
+                        )
+                      ]
+                    }
+                  ),
+                  renderResizeHandle(column.id)
+                ]
+              }
+            ) }, column.id)),
+            provided.placeholder,
+            rowActions && rowActions.length > 0 && /* @__PURE__ */ jsx(TableHead, { className: "w-12", children: /* @__PURE__ */ jsx("span", { className: "sr-only", children: "Actions" }) })
+          ]
+        }
+      ) }) }) });
+    }
+    return /* @__PURE__ */ jsx(TableHeader, { children: /* @__PURE__ */ jsxs(TableRow, { children: [
+      selectionEnabled && /* @__PURE__ */ jsx(TableHead, { className: "w-12", children: /* @__PURE__ */ jsx(
+        Checkbox,
+        {
+          checked: allRowsSelected,
+          onCheckedChange: onToggleAll,
+          "aria-label": "Select all"
+        }
+      ) }),
+      columns.map((column) => /* @__PURE__ */ jsxs(
+        TableHead,
+        {
+          className: cn("relative group overflow-visible", columnResizeEnabled && "select-none"),
+          style: {
+            width: getEffectiveWidth(column),
+            minWidth: column.minWidth,
+            maxWidth: column.maxWidth
+          },
+          children: [
+            renderHeader(column),
+            renderResizeHandle(column.id)
+          ]
+        },
+        column.id
+      )),
+      rowActions && rowActions.length > 0 && /* @__PURE__ */ jsx(TableHead, { className: "w-12", children: /* @__PURE__ */ jsx("span", { className: "sr-only", children: "Actions" }) })
+    ] }) });
+  };
+  return /* @__PURE__ */ jsx("div", { className: cn("rounded-md border", className), children: /* @__PURE__ */ jsxs(Table, { children: [
+    renderColumnHeaders(),
+    /* @__PURE__ */ jsx(TableBody, { children: data.length === 0 ? /* @__PURE__ */ jsx(TableRow, { children: /* @__PURE__ */ jsx(
+      TableCell,
+      {
+        colSpan: columns.length + (selectionEnabled ? 1 : 0) + (rowActions ? 1 : 0),
+        className: "h-24 text-center",
+        children: "No results found."
+      }
+    ) }) : data.map((row, rowIndex) => {
+      const rowId = getRowId(row);
+      const isSelected = selectedIds.has(rowId);
+      const isLoading = loadingRows.has(rowId);
+      return /* @__PURE__ */ jsxs(
+        TableRow,
+        {
+          "data-row-index": rowIndex,
+          "data-state": isSelected && "selected",
+          onClick: () => onRowClick?.(row),
+          tabIndex: 0,
+          className: cn(
+            onRowClick && "cursor-pointer hover:bg-muted/50",
+            isLoading && "opacity-50"
+          ),
+          children: [
+            selectionEnabled && /* @__PURE__ */ jsx(TableCell, { onClick: (e) => e.stopPropagation(), children: /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-1", children: [
+              /* @__PURE__ */ jsx(
+                Checkbox,
+                {
+                  checked: isSelected,
+                  onCheckedChange: () => onToggleRow?.(rowId),
+                  "aria-label": "Select row"
+                }
+              ),
+              renderSelectionCell?.(row)
+            ] }) }),
+            columns.map((column) => {
+              const isEditing = editingCell?.rowId === rowId && editingCell?.columnId === column.id;
+              const canEdit = inlineEditEnabled && column.editable && onCellEdit;
+              const getCellValue = () => {
+                if (column.accessorFn) return column.accessorFn(row);
+                if (column.accessorKey) {
+                  const keys = column.accessorKey.split(".");
+                  return keys.reduce((obj, key) => obj?.[key], row);
+                }
+                return void 0;
+              };
+              return /* @__PURE__ */ jsx(
+                TableCell,
+                {
+                  style: {
+                    width: getEffectiveWidth(column),
+                    minWidth: column.minWidth,
+                    maxWidth: column.maxWidth
+                  },
+                  className: cn(
+                    canEdit && !isEditing && "cursor-pointer hover:bg-muted/50"
+                  ),
+                  onClick: (e) => {
+                    if (canEdit && !isEditing) {
+                      e.stopPropagation();
+                      setEditingCell({ rowId, columnId: column.id });
+                    }
+                  },
+                  children: isEditing ? /* @__PURE__ */ jsx(
+                    InlineEditCell,
+                    {
+                      value: getCellValue(),
+                      columnId: column.id,
+                      rowId,
+                      editType: column.editType,
+                      editOptions: column.editOptions,
+                      validate: column.validate ? (v) => column.validate(v, row) : void 0,
+                      onSave: async (value) => {
+                        await onCellEdit(rowId, column.id, value, row);
+                        setEditingCell(null);
+                      },
+                      onCancel: () => setEditingCell(null)
+                    }
+                  ) : /* @__PURE__ */ jsxs(Fragment, { children: [
+                    isLoading && /* @__PURE__ */ jsx(Loader2, { className: "h-4 w-4 animate-spin inline-block mr-2" }),
+                    renderCellContent(column, row)
+                  ] })
+                },
+                column.id
+              );
+            }),
+            rowActions && rowActions.length > 0 && /* @__PURE__ */ jsx(TableCell, { onClick: (e) => e.stopPropagation(), children: /* @__PURE__ */ jsxs(DropdownMenu, { children: [
+              /* @__PURE__ */ jsx(DropdownMenuTrigger, { asChild: true, children: /* @__PURE__ */ jsxs(Button, { variant: "ghost", className: "h-8 w-8 p-0", children: [
+                /* @__PURE__ */ jsx("span", { className: "sr-only", children: "Open menu" }),
+                /* @__PURE__ */ jsx(MoreHorizontal, { className: "h-4 w-4" })
+              ] }) }),
+              /* @__PURE__ */ jsxs(DropdownMenuContent, { align: "end", children: [
+                /* @__PURE__ */ jsx(DropdownMenuLabel, { children: "Actions" }),
+                rowActions.map((action, idx) => {
+                  const isDisabled = action.disabled?.(row) || false;
+                  return /* @__PURE__ */ jsxs(
+                    DropdownMenuItem,
+                    {
+                      onClick: () => !isDisabled && action.onClick(row),
+                      disabled: isDisabled,
+                      className: cn(action.destructive && "text-red-600"),
+                      children: [
+                        action.icon && /* @__PURE__ */ jsx(action.icon, { className: "mr-2 h-4 w-4" }),
+                        action.label
+                      ]
+                    },
+                    action.id
+                  );
+                })
+              ] })
+            ] }) })
+          ]
+        },
+        rowId
+      );
+    }) })
+  ] }) });
+}
+function TablePagination({
+  pagination,
+  showSelectAllPrompt,
+  onSelectAllPages,
+  totalFilteredCount,
+  className
+}) {
+  const {
+    currentPage,
+    totalPages,
+    totalCount,
+    canGoNext,
+    canGoPrevious,
+    goToPage,
+    goToFirstPage,
+    goToLastPage,
+    goToNextPage,
+    goToPreviousPage,
+    getPageNumbers,
+    getDisplayRange
+  } = pagination;
+  const { start, end } = getDisplayRange();
+  const pageNumbers = getPageNumbers();
+  return /* @__PURE__ */ jsxs("div", { className, children: [
+    /* @__PURE__ */ jsxs("div", { className: "flex flex-col sm:flex-row sm:items-center sm:justify-between gap-4", children: [
+      /* @__PURE__ */ jsxs("div", { className: "text-sm text-muted-foreground", children: [
+        "Showing ",
+        /* @__PURE__ */ jsxs("span", { className: "font-medium", children: [
+          start,
+          "-",
+          end
+        ] }),
+        " of",
+        " ",
+        /* @__PURE__ */ jsx("span", { className: "font-medium", children: totalCount }),
+        totalFilteredCount && totalFilteredCount !== totalCount && /* @__PURE__ */ jsx("span", { children: " filtered items" })
+      ] }),
+      totalPages > 1 && /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2", children: [
+        /* @__PURE__ */ jsxs("span", { className: "text-sm text-muted-foreground hidden sm:inline", children: [
+          "Page ",
+          currentPage,
+          " of ",
+          totalPages
+        ] }),
+        /* @__PURE__ */ jsxs("div", { className: "flex gap-1", children: [
+          /* @__PURE__ */ jsx(
+            Button,
+            {
+              variant: "outline",
+              size: "sm",
+              onClick: goToFirstPage,
+              disabled: !canGoPrevious,
+              className: "h-8 w-8 p-0",
+              title: "First page",
+              children: /* @__PURE__ */ jsx(ChevronsLeft, { className: "h-4 w-4" })
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            Button,
+            {
+              variant: "outline",
+              size: "sm",
+              onClick: goToPreviousPage,
+              disabled: !canGoPrevious,
+              className: "h-8 w-8 p-0",
+              title: "Previous page",
+              children: /* @__PURE__ */ jsx(ChevronLeft, { className: "h-4 w-4" })
+            }
+          ),
+          pageNumbers.map((pageNum, idx) => {
+            if (pageNum === "...") {
+              return /* @__PURE__ */ jsx(
+                "span",
+                {
+                  className: "flex items-center px-2 text-muted-foreground",
+                  children: "\u2022\u2022\u2022"
+                },
+                `ellipsis-${idx}`
+              );
+            }
+            const page = pageNum;
+            return /* @__PURE__ */ jsx(
+              Button,
+              {
+                variant: page === currentPage ? "default" : "outline",
+                size: "sm",
+                onClick: () => goToPage(page),
+                className: "h-8 w-8 p-0",
+                children: page
+              },
+              page
+            );
+          }),
+          /* @__PURE__ */ jsx(
+            Button,
+            {
+              variant: "outline",
+              size: "sm",
+              onClick: goToNextPage,
+              disabled: !canGoNext,
+              className: "h-8 w-8 p-0",
+              title: "Next page",
+              children: /* @__PURE__ */ jsx(ChevronRight, { className: "h-4 w-4" })
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            Button,
+            {
+              variant: "outline",
+              size: "sm",
+              onClick: goToLastPage,
+              disabled: !canGoNext,
+              className: "h-8 w-8 p-0",
+              title: "Last page",
+              children: /* @__PURE__ */ jsx(ChevronsRight, { className: "h-4 w-4" })
+            }
+          )
+        ] })
+      ] })
+    ] }),
+    showSelectAllPrompt && onSelectAllPages && totalFilteredCount && totalFilteredCount > end && /* @__PURE__ */ jsxs("div", { className: "mt-3 flex items-center justify-center p-3 bg-blue-50 border border-blue-200 rounded-lg", children: [
+      /* @__PURE__ */ jsxs("span", { className: "text-sm text-blue-900 mr-2", children: [
+        "Select all ",
+        /* @__PURE__ */ jsx("span", { className: "font-semibold", children: totalFilteredCount }),
+        " items?"
+      ] }),
+      /* @__PURE__ */ jsxs(
+        Button,
+        {
+          size: "sm",
+          variant: "link",
+          onClick: onSelectAllPages,
+          className: "text-blue-700 hover:text-blue-900 font-semibold p-0 h-auto",
+          children: [
+            "Select all ",
+            totalFilteredCount,
+            " items"
+          ]
+        }
+      )
+    ] })
+  ] });
+}
+function getColumnValue(row, column) {
+  if (column.accessorFn) {
+    return column.accessorFn(row);
+  }
+  if (column.accessorKey) {
+    const keys = column.accessorKey.split(".");
+    let value = row;
+    for (const key of keys) {
+      value = value?.[key];
+    }
+    return value;
+  }
+  return "";
+}
+function formatValueForExport(value) {
+  if (value == null) {
+    return "";
+  }
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+  if (typeof value === "object") {
+    return JSON.stringify(value);
+  }
+  if (typeof value === "boolean") {
+    return value ? "Yes" : "No";
+  }
+  return String(value);
+}
+function getColumnHeader(column) {
+  if (typeof column.header === "string") {
+    return column.header;
+  }
+  return column.id;
+}
+function prepareExportData(data, columns, includeHeaders = true) {
+  const rows = [];
+  if (includeHeaders) {
+    rows.push(columns.map(getColumnHeader));
+  }
+  for (const row of data) {
+    const rowData = [];
+    for (const column of columns) {
+      const value = getColumnValue(row, column);
+      rowData.push(formatValueForExport(value));
+    }
+    rows.push(rowData);
+  }
+  return rows;
+}
+function arrayToCSV(data) {
+  return data.map(
+    (row) => row.map((cell) => {
+      const needsQuotes = /[,"\n\r]/.test(cell);
+      if (needsQuotes) {
+        return `"${cell.replace(/"/g, '""')}"`;
+      }
+      return cell;
+    }).join(",")
+  ).join("\n");
+}
+function downloadFile(content, filename, mimeType) {
+  const blob = content instanceof Blob ? content : new Blob([content], { type: mimeType });
+  const url = URL.createObjectURL(blob);
+  const link = document.createElement("a");
+  link.href = url;
+  link.download = filename;
+  document.body.appendChild(link);
+  link.click();
+  document.body.removeChild(link);
+  URL.revokeObjectURL(url);
+}
+function exportToCSV(data, columns, filename, includeHeaders = true) {
+  if (!data || data.length === 0) {
+    throw new Error("No data to export");
+  }
+  if (!columns || columns.length === 0) {
+    throw new Error("No columns specified for export");
+  }
+  const exportData2 = prepareExportData(data, columns, includeHeaders);
+  const csv = arrayToCSV(exportData2);
+  downloadFile(csv, `${filename}.csv`, "text/csv;charset=utf-8;");
+}
+function exportToExcel(data, columns, filename, includeHeaders = true) {
+  if (!data || data.length === 0) {
+    throw new Error("No data to export");
+  }
+  if (!columns || columns.length === 0) {
+    throw new Error("No columns specified for export");
+  }
+  const exportData2 = prepareExportData(data, columns, includeHeaders);
+  const ws = XLSX.utils.aoa_to_sheet(exportData2);
+  const wb = XLSX.utils.book_new();
+  XLSX.utils.book_append_sheet(wb, ws, "Data");
+  const columnWidths = columns.map((column, idx) => {
+    const header = getColumnHeader(column);
+    const maxWidth = exportData2.reduce((max, row) => {
+      const cellValue = row[idx] || "";
+      return Math.max(max, cellValue.length);
+    }, header.length);
+    return { wch: Math.min(maxWidth + 2, 50) };
+  });
+  ws["!cols"] = columnWidths;
+  const excelBuffer = XLSX.write(wb, { bookType: "xlsx", type: "array" });
+  const blob = new Blob([excelBuffer], {
+    type: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+  });
+  downloadFile(blob, `${filename}.xlsx`, blob.type);
+}
+function exportData(data, columns, options) {
+  const { format, filename, includeHeaders = true } = options;
+  switch (format) {
+    case "csv":
+      exportToCSV(data, columns, filename, includeHeaders);
+      break;
+    case "excel":
+      exportToExcel(data, columns, filename, includeHeaders);
+      break;
+    default:
+      throw new Error(`Unsupported export format: ${format}`);
+  }
+}
+function generateExportFilename(baseFilename) {
+  const now = /* @__PURE__ */ new Date();
+  const timestamp = now.toISOString().replace(/[:.]/g, "-").slice(0, -5);
+  return `${baseFilename}_${timestamp}`;
+}
+function ExportButton({
+  data,
+  filteredData,
+  selectedData,
+  columns,
+  baseFilename = "export",
+  disabled = false,
+  className,
+  showProgress = true,
+  onExportStart,
+  onExportComplete,
+  onExportError
+}) {
+  const [isExporting, setIsExporting] = useState(false);
+  const [progress, setProgress] = useState(0);
+  const hasFilteredData = filteredData && filteredData.length > 0 && filteredData.length < data.length;
+  const hasSelectedData = selectedData && selectedData.length > 0;
+  const handleExport = useCallback(
+    async (format, scope) => {
+      setIsExporting(true);
+      setProgress(0);
+      try {
+        onExportStart?.(format, scope);
+        let dataToExport;
+        let scopeLabel;
+        switch (scope) {
+          case "selected":
+            if (!selectedData || selectedData.length === 0) {
+              throw new Error("No rows selected");
+            }
+            dataToExport = selectedData;
+            scopeLabel = "selected";
+            break;
+          case "filtered":
+            if (!filteredData || filteredData.length === 0) {
+              throw new Error("No filtered data available");
+            }
+            dataToExport = filteredData;
+            scopeLabel = "filtered";
+            break;
+          case "all":
+          default:
+            dataToExport = data;
+            scopeLabel = "all";
+            break;
+        }
+        if (showProgress && dataToExport.length > 100) {
+          setProgress(25);
+          await new Promise((resolve) => setTimeout(resolve, 100));
+          setProgress(50);
+        }
+        const filename = `${baseFilename}_${scopeLabel}_${generateExportFilename("")}`.replace(
+          /__/g,
+          "_"
+        );
+        if (format === "csv") {
+          exportToCSV(dataToExport, columns, filename);
+        } else {
+          exportToExcel(dataToExport, columns, filename);
+        }
+        if (showProgress) {
+          setProgress(100);
+        }
+        onExportComplete?.(format, scope, dataToExport.length);
+      } catch (error) {
+        console.error("Export failed:", error);
+        const errorObj = error instanceof Error ? error : new Error("Export failed");
+        onExportError?.(errorObj);
+      } finally {
+        if (showProgress) {
+          setTimeout(() => {
+            setIsExporting(false);
+            setProgress(0);
+          }, 500);
+        } else {
+          setIsExporting(false);
+          setProgress(0);
+        }
+      }
+    },
+    [
+      data,
+      filteredData,
+      selectedData,
+      columns,
+      baseFilename,
+      showProgress,
+      onExportStart,
+      onExportComplete,
+      onExportError
+    ]
+  );
+  const isDisabled = disabled || isExporting || data.length === 0;
+  return /* @__PURE__ */ jsxs(DropdownMenu, { children: [
+    /* @__PURE__ */ jsx(DropdownMenuTrigger, { asChild: true, children: /* @__PURE__ */ jsx(
+      Button,
+      {
+        variant: "outline",
+        size: "sm",
+        disabled: isDisabled,
+        className,
+        "aria-label": "Export data",
+        children: isExporting ? /* @__PURE__ */ jsxs(Fragment, { children: [
+          /* @__PURE__ */ jsx(Loader2, { className: "mr-2 h-4 w-4 animate-spin" }),
+          "Exporting",
+          showProgress && progress > 0 ? ` ${progress}%` : "..."
+        ] }) : /* @__PURE__ */ jsxs(Fragment, { children: [
+          /* @__PURE__ */ jsx(Download, { className: "mr-2 h-4 w-4" }),
+          "Export"
+        ] })
+      }
+    ) }),
+    /* @__PURE__ */ jsxs(DropdownMenuContent, { align: "end", className: "w-56", children: [
+      /* @__PURE__ */ jsx("div", { className: "px-2 py-1.5 text-xs font-semibold text-muted-foreground", children: "CSV Format" }),
+      /* @__PURE__ */ jsxs(
+        DropdownMenuItem,
+        {
+          onClick: () => handleExport("csv", "all"),
+          disabled: isExporting || data.length === 0,
+          children: [
+            /* @__PURE__ */ jsx(FileText, { className: "mr-2 h-4 w-4" }),
+            "Export All (",
+            data.length,
+            " rows)"
+          ]
+        }
+      ),
+      hasFilteredData && /* @__PURE__ */ jsxs(
+        DropdownMenuItem,
+        {
+          onClick: () => handleExport("csv", "filtered"),
+          disabled: isExporting,
+          children: [
+            /* @__PURE__ */ jsx(FileText, { className: "mr-2 h-4 w-4" }),
+            "Export Filtered (",
+            filteredData?.length || 0,
+            " rows)"
+          ]
+        }
+      ),
+      hasSelectedData && /* @__PURE__ */ jsxs(
+        DropdownMenuItem,
+        {
+          onClick: () => handleExport("csv", "selected"),
+          disabled: isExporting,
+          children: [
+            /* @__PURE__ */ jsx(FileText, { className: "mr-2 h-4 w-4" }),
+            "Export Selected (",
+            selectedData?.length || 0,
+            " rows)"
+          ]
+        }
+      ),
+      /* @__PURE__ */ jsx(DropdownMenuSeparator, {}),
+      /* @__PURE__ */ jsx("div", { className: "px-2 py-1.5 text-xs font-semibold text-muted-foreground", children: "Excel Format" }),
+      /* @__PURE__ */ jsxs(
+        DropdownMenuItem,
+        {
+          onClick: () => handleExport("excel", "all"),
+          disabled: isExporting || data.length === 0,
+          children: [
+            /* @__PURE__ */ jsx(FileSpreadsheet, { className: "mr-2 h-4 w-4" }),
+            "Export All (",
+            data.length,
+            " rows)"
+          ]
+        }
+      ),
+      hasFilteredData && /* @__PURE__ */ jsxs(
+        DropdownMenuItem,
+        {
+          onClick: () => handleExport("excel", "filtered"),
+          disabled: isExporting,
+          children: [
+            /* @__PURE__ */ jsx(FileSpreadsheet, { className: "mr-2 h-4 w-4" }),
+            "Export Filtered (",
+            filteredData?.length || 0,
+            " rows)"
+          ]
+        }
+      ),
+      hasSelectedData && /* @__PURE__ */ jsxs(
+        DropdownMenuItem,
+        {
+          onClick: () => handleExport("excel", "selected"),
+          disabled: isExporting,
+          children: [
+            /* @__PURE__ */ jsx(FileSpreadsheet, { className: "mr-2 h-4 w-4" }),
+            "Export Selected (",
+            selectedData?.length || 0,
+            " rows)"
+          ]
+        }
+      )
+    ] })
+  ] });
+}
+var Dialog = DialogPrimitive.Root;
+var DialogTrigger = DialogPrimitive.Trigger;
+var DialogPortal = DialogPrimitive.Portal;
+var DialogClose = DialogPrimitive.Close;
+var DialogOverlay = React5.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(
+  DialogPrimitive.Overlay,
+  {
+    ref,
+    className: cn(
+      "fixed inset-0 z-50 bg-background/80 backdrop-blur-sm data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0",
+      className
+    ),
+    ...props
+  }
+));
+DialogOverlay.displayName = DialogPrimitive.Overlay.displayName;
+var DialogContent = React5.forwardRef(({ className, children, ...props }, ref) => /* @__PURE__ */ jsxs(DialogPortal, { children: [
+  /* @__PURE__ */ jsx(DialogOverlay, {}),
+  /* @__PURE__ */ jsxs(
+    DialogPrimitive.Content,
+    {
+      ref,
+      className: cn(
+        "fixed left-[50%] top-[50%] z-50 grid w-full max-w-lg translate-x-[-50%] translate-y-[-50%] gap-4 border bg-background p-4 sm:p-6 shadow-lg duration-200 data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[state=closed]:slide-out-to-left-1/2 data-[state=closed]:slide-out-to-top-[48%] data-[state=open]:slide-in-from-left-1/2 data-[state=open]:slide-in-from-top-[48%] sm:rounded-lg max-h-[95vh] max-sm:max-h-[90vh] max-sm:m-4 max-sm:w-[calc(100%-2rem)] overflow-hidden",
+        className
+      ),
+      ...props,
+      children: [
+        children,
+        /* @__PURE__ */ jsxs(DialogPrimitive.Close, { className: "absolute right-3 top-3 sm:right-4 sm:top-4 rounded-sm opacity-70 ring-offset-background transition-opacity hover:opacity-100 focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2 disabled:pointer-events-none data-[state=open]:bg-accent data-[state=open]:text-muted-foreground min-h-[44px] min-w-[44px] flex items-center justify-center", children: [
+          /* @__PURE__ */ jsx(X, { className: "h-4 w-4" }),
+          /* @__PURE__ */ jsx("span", { className: "sr-only", children: "Close" })
+        ] })
+      ]
+    }
+  )
+] }));
+DialogContent.displayName = DialogPrimitive.Content.displayName;
+var DialogHeader = ({
+  className,
+  ...props
+}) => /* @__PURE__ */ jsx(
+  "div",
+  {
+    className: cn(
+      "flex flex-col space-y-1.5 text-center sm:text-left",
+      className
+    ),
+    ...props
+  }
+);
+DialogHeader.displayName = "DialogHeader";
+var DialogFooter = ({
+  className,
+  ...props
+}) => /* @__PURE__ */ jsx(
+  "div",
+  {
+    className: cn(
+      "flex flex-col-reverse sm:flex-row sm:justify-end sm:space-x-2 space-y-2 space-y-reverse sm:space-y-0",
+      className
+    ),
+    ...props
+  }
+);
+DialogFooter.displayName = "DialogFooter";
+var DialogTitle = React5.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(
+  DialogPrimitive.Title,
+  {
+    ref,
+    className: cn(
+      "text-lg font-semibold leading-none tracking-tight",
+      className
+    ),
+    ...props
+  }
+));
+DialogTitle.displayName = DialogPrimitive.Title.displayName;
+var DialogDescription = React5.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(
+  DialogPrimitive.Description,
+  {
+    ref,
+    className: cn("text-sm text-muted-foreground", className),
+    ...props
+  }
+));
+DialogDescription.displayName = DialogPrimitive.Description.displayName;
+function SavedViewsDropdown({
+  views,
+  currentViewId,
+  onSaveView,
+  onUpdateView,
+  onDeleteView,
+  onLoadView,
+  getCurrentViewState
+}) {
+  const [isOpen, setIsOpen] = useState(false);
+  const [isSaveDialogOpen, setIsSaveDialogOpen] = useState(false);
+  const [viewName, setViewName] = useState("");
+  const [isDefault, setIsDefault] = useState(false);
+  const [isSaving, setIsSaving] = useState(false);
+  const [deleteConfirmId, setDeleteConfirmId] = useState(null);
+  const currentView = views.find((v) => v.id === currentViewId);
+  const handleSaveView = async () => {
+    if (!viewName.trim()) return;
+    setIsSaving(true);
+    try {
+      const viewState = getCurrentViewState();
+      await onSaveView({
+        name: viewName.trim(),
+        isDefault,
+        ...viewState
+      });
+      setIsSaveDialogOpen(false);
+      setViewName("");
+      setIsDefault(false);
+    } catch (error) {
+      console.error("Failed to save view:", error);
+    } finally {
+      setIsSaving(false);
+    }
+  };
+  const handleDeleteView = async (viewId) => {
+    if (!onDeleteView) return;
+    try {
+      await onDeleteView(viewId);
+      setDeleteConfirmId(null);
+    } catch (error) {
+      console.error("Failed to delete view:", error);
+    }
+  };
+  const handleSetDefault = async (viewId) => {
+    if (!onUpdateView) return;
+    try {
+      for (const view of views) {
+        if (view.isDefault && view.id !== viewId) {
+          await onUpdateView(view.id, { isDefault: false });
+        }
+      }
+      await onUpdateView(viewId, { isDefault: true });
+    } catch (error) {
+      console.error("Failed to set default view:", error);
+    }
+  };
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsxs(DropdownMenu, { open: isOpen, onOpenChange: setIsOpen, children: [
+      /* @__PURE__ */ jsx(DropdownMenuTrigger, { asChild: true, children: /* @__PURE__ */ jsxs(Button, { variant: "outline", size: "sm", children: [
+        /* @__PURE__ */ jsx(BookmarkPlus, { className: "mr-2 h-4 w-4" }),
+        currentView ? currentView.name : "Views",
+        /* @__PURE__ */ jsx(ChevronDown, { className: "ml-2 h-4 w-4" })
+      ] }) }),
+      /* @__PURE__ */ jsxs(DropdownMenuContent, { align: "end", className: "w-56", children: [
+        /* @__PURE__ */ jsx(DropdownMenuLabel, { children: "Saved Views" }),
+        /* @__PURE__ */ jsx(DropdownMenuSeparator, {}),
+        views.length === 0 ? /* @__PURE__ */ jsx(DropdownMenuItem, { disabled: true, children: "No saved views" }) : views.map((view) => /* @__PURE__ */ jsxs(
+          DropdownMenuItem,
+          {
+            className: "flex items-center justify-between cursor-pointer",
+            onSelect: (e) => {
+              e.preventDefault();
+              if (deleteConfirmId === view.id) return;
+              onLoadView(view.id);
+              setIsOpen(false);
+            },
+            children: [
+              /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2", children: [
+                currentViewId === view.id && /* @__PURE__ */ jsx(Check, { className: "h-4 w-4 text-primary" }),
+                currentViewId !== view.id && /* @__PURE__ */ jsx("div", { className: "w-4" }),
+                /* @__PURE__ */ jsx("span", { children: view.name }),
+                view.isDefault && /* @__PURE__ */ jsx(Star, { className: "h-3 w-3 text-yellow-500 fill-yellow-500" })
+              ] }),
+              /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-1", children: [
+                onUpdateView && !view.isDefault && /* @__PURE__ */ jsx(
+                  "button",
+                  {
+                    onClick: (e) => {
+                      e.stopPropagation();
+                      handleSetDefault(view.id);
+                    },
+                    className: "p-1 hover:bg-muted rounded opacity-50 hover:opacity-100",
+                    title: "Set as default",
+                    children: /* @__PURE__ */ jsx(Star, { className: "h-3 w-3" })
+                  }
+                ),
+                onDeleteView && /* @__PURE__ */ jsx(
+                  "button",
+                  {
+                    onClick: (e) => {
+                      e.stopPropagation();
+                      if (deleteConfirmId === view.id) {
+                        handleDeleteView(view.id);
+                      } else {
+                        setDeleteConfirmId(view.id);
+                        setTimeout(() => setDeleteConfirmId(null), 3e3);
+                      }
+                    },
+                    className: cn(
+                      "p-1 hover:bg-muted rounded",
+                      deleteConfirmId === view.id ? "text-red-600 hover:text-red-700" : "opacity-50 hover:opacity-100"
+                    ),
+                    title: deleteConfirmId === view.id ? "Click again to confirm" : "Delete view",
+                    children: /* @__PURE__ */ jsx(Trash2, { className: "h-3 w-3" })
+                  }
+                )
+              ] })
+            ]
+          },
+          view.id
+        )),
+        /* @__PURE__ */ jsx(DropdownMenuSeparator, {}),
+        /* @__PURE__ */ jsxs(
+          DropdownMenuItem,
+          {
+            onSelect: (e) => {
+              e.preventDefault();
+              setIsSaveDialogOpen(true);
+              setIsOpen(false);
+            },
+            children: [
+              /* @__PURE__ */ jsx(BookmarkPlus, { className: "mr-2 h-4 w-4" }),
+              "Save Current View"
+            ]
+          }
+        )
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx(Dialog, { open: isSaveDialogOpen, onOpenChange: setIsSaveDialogOpen, children: /* @__PURE__ */ jsxs(DialogContent, { className: "sm:max-w-[425px]", children: [
+      /* @__PURE__ */ jsxs(DialogHeader, { children: [
+        /* @__PURE__ */ jsx(DialogTitle, { children: "Save View" }),
+        /* @__PURE__ */ jsx(DialogDescription, { children: "Save your current table configuration as a named view." })
+      ] }),
+      /* @__PURE__ */ jsxs("div", { className: "grid gap-4 py-4", children: [
+        /* @__PURE__ */ jsxs("div", { className: "grid gap-2", children: [
+          /* @__PURE__ */ jsx(Label, { htmlFor: "view-name", children: "View Name" }),
+          /* @__PURE__ */ jsx(
+            Input,
+            {
+              id: "view-name",
+              value: viewName,
+              onChange: (e) => setViewName(e.target.value),
+              placeholder: "My Custom View",
+              onKeyDown: (e) => {
+                if (e.key === "Enter") handleSaveView();
+              }
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2", children: [
+          /* @__PURE__ */ jsx(
+            Checkbox,
+            {
+              id: "is-default",
+              checked: isDefault,
+              onCheckedChange: (checked) => setIsDefault(checked === true)
+            }
+          ),
+          /* @__PURE__ */ jsx(Label, { htmlFor: "is-default", className: "cursor-pointer", children: "Set as default view" })
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxs(DialogFooter, { children: [
+        /* @__PURE__ */ jsx(
+          Button,
+          {
+            variant: "outline",
+            onClick: () => setIsSaveDialogOpen(false),
+            disabled: isSaving,
+            children: "Cancel"
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          Button,
+          {
+            onClick: handleSaveView,
+            disabled: !viewName.trim() || isSaving,
+            children: isSaving ? "Saving..." : "Save View"
+          }
+        )
+      ] })
+    ] }) })
+  ] });
+}
+function StandardTableToolbar({
+  searchEnabled,
+  searchPlaceholder = "Search...",
+  searchValue = "",
+  onSearchChange,
+  searchInputRef,
+  searchAutoFocus,
+  columnVisibilityEnabled,
+  hideableColumns = [],
+  columnVisibility = {},
+  onToggleColumnVisibility,
+  exportEnabled,
+  exportProps,
+  exportData: exportData2 = [],
+  exportColumns = [],
+  savedViewsEnabled,
+  savedViews = [],
+  currentViewId,
+  savedViewsProps,
+  className
+}) {
+  const hasRightSideButtons = exportEnabled || columnVisibilityEnabled || savedViewsEnabled;
+  return /* @__PURE__ */ jsxs("div", { className: cn("flex items-center justify-between gap-4", className), children: [
+    /* @__PURE__ */ jsx("div", { className: "flex items-center gap-3 flex-1", children: searchEnabled ? /* @__PURE__ */ jsx(
+      Input,
+      {
+        type: "text",
+        placeholder: searchPlaceholder,
+        value: searchValue,
+        onChange: (e) => onSearchChange?.(e.target.value),
+        ref: searchInputRef,
+        autoFocus: searchAutoFocus,
+        className: "max-w-xl w-full"
+      }
+    ) : /* @__PURE__ */ jsx("div", {}) }),
+    hasRightSideButtons && /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2", children: [
+      exportEnabled && exportProps && /* @__PURE__ */ jsx(
+        ExportButton,
+        {
+          data: exportData2,
+          columns: exportColumns,
+          ...exportProps
+        }
+      ),
+      columnVisibilityEnabled && hideableColumns.length > 0 && /* @__PURE__ */ jsxs(DropdownMenu, { children: [
+        /* @__PURE__ */ jsx(DropdownMenuTrigger, { asChild: true, children: /* @__PURE__ */ jsxs(Button, { variant: "outline", size: "sm", children: [
+          /* @__PURE__ */ jsx(Columns3, { className: "mr-2 h-4 w-4" }),
+          "Columns",
+          /* @__PURE__ */ jsx(ChevronDown, { className: "ml-2 h-4 w-4" })
+        ] }) }),
+        /* @__PURE__ */ jsx(DropdownMenuContent, { align: "end", className: "w-48", children: hideableColumns.map((column) => /* @__PURE__ */ jsx(
+          DropdownMenuCheckboxItem,
+          {
+            checked: columnVisibility[column.id] !== false,
+            onCheckedChange: () => onToggleColumnVisibility?.(column.id),
+            children: typeof column.header === "string" ? column.header : column.id
+          },
+          column.id
+        )) })
+      ] }),
+      savedViewsEnabled && savedViewsProps && /* @__PURE__ */ jsx(
+        SavedViewsDropdown,
+        {
+          views: savedViews,
+          currentViewId,
+          ...savedViewsProps
+        }
+      )
+    ] })
+  ] });
+}
+function UnifiedTable({
+  data,
+  columns,
+  tableId,
+  getRowId,
+  pagination: paginationConfig,
+  selection: selectionConfig,
+  filters: filtersConfig,
+  bulkActions = [],
+  rowActions = [],
+  search: searchConfig,
+  sorting: sortingConfig,
+  columnVisibility: columnVisibilityConfig,
+  columnReorder: columnReorderConfig,
+  columnResize: columnResizeConfig,
+  inlineEdit: inlineEditConfig,
+  savedViews: savedViewsConfig,
+  urlPersistence: urlPersistenceConfig,
+  export: exportConfig,
+  onRowClick,
+  mobileConfig,
+  loading = false,
+  loadingRows = /* @__PURE__ */ new Set(),
+  className,
+  emptyState,
+  errorState
+}) {
+  const searchInputRef = useRef(null);
+  const shouldRestoreFocusRef = useRef(false);
+  const tableRef = useRef(null);
+  const urlState = useTableURL({
+    tableId,
+    persistToUrl: urlPersistenceConfig?.enabled ?? false,
+    debounceMs: urlPersistenceConfig?.debounceMs ?? 300
+  });
+  const initialURLState = useMemo(() => {
+    if (!urlPersistenceConfig?.enabled) return null;
+    return urlState.getURLState();
+  }, []);
+  const [columnVisibility, setColumnVisibility] = useState(() => {
+    if (columnVisibilityConfig?.persistKey && typeof window !== "undefined") {
+      try {
+        const stored = localStorage.getItem(`table-columns-${columnVisibilityConfig.persistKey}`);
+        if (stored) {
+          return JSON.parse(stored);
+        }
+      } catch {
+      }
+    }
+    const initial = {};
+    columns.forEach((col) => {
+      if (columnVisibilityConfig?.defaultVisible) {
+        initial[col.id] = columnVisibilityConfig.defaultVisible.includes(col.id);
+      } else {
+        initial[col.id] = true;
+      }
+    });
+    return initial;
+  });
+  const [localSort, setLocalSort] = useState(() => {
+    if (initialURLState) {
+      return {
+        sortBy: initialURLState.sortBy,
+        sortDirection: initialURLState.sortDirection
+      };
+    }
+    return { sortBy: null, sortDirection: "asc" };
+  });
+  useEffect(() => {
+    if (columnVisibilityConfig?.persistKey && typeof window !== "undefined") {
+      try {
+        localStorage.setItem(
+          `table-columns-${columnVisibilityConfig.persistKey}`,
+          JSON.stringify(columnVisibility)
+        );
+      } catch {
+      }
+    }
+  }, [columnVisibility, columnVisibilityConfig?.persistKey]);
+  const toggleColumnVisibility = useCallback((columnId) => {
+    if (columnVisibilityConfig?.alwaysVisible?.includes(columnId)) {
+      return;
+    }
+    setColumnVisibility((prev) => ({
+      ...prev,
+      [columnId]: !prev[columnId]
+    }));
+  }, [columnVisibilityConfig?.alwaysVisible]);
+  const visibleColumns = useMemo(() => {
+    if (!columnVisibilityConfig?.enabled) {
+      return columns;
+    }
+    return columns.filter((col) => columnVisibility[col.id] !== false);
+  }, [columns, columnVisibility, columnVisibilityConfig?.enabled]);
+  const hideableColumns = useMemo(() => {
+    return columns.filter((col) => {
+      if (col.hideable === false) return false;
+      if (columnVisibilityConfig?.alwaysVisible?.includes(col.id)) return false;
+      return true;
+    });
+  }, [columns, columnVisibilityConfig?.alwaysVisible]);
+  const columnReorder = useColumnReorder({
+    columns: visibleColumns,
+    initialOrder: columnReorderConfig?.initialOrder,
+    enabled: columnReorderConfig?.enabled ?? false,
+    onOrderChange: columnReorderConfig?.onOrderChange
+  });
+  const displayColumns = columnReorderConfig?.enabled ? columnReorder.orderedColumns : visibleColumns;
+  const columnResize = useColumnResize({
+    enabled: columnResizeConfig?.enabled ?? false,
+    initialWidths: columnResizeConfig?.initialWidths,
+    minWidth: columnResizeConfig?.minWidth ?? 50,
+    onWidthChange: columnResizeConfig?.onWidthChange
+  });
+  const sortingEnabled = sortingConfig?.enabled ?? true;
+  const currentSortBy = sortingConfig?.value?.sortBy ?? localSort.sortBy;
+  const currentSortDirection = sortingConfig?.value?.sortDirection ?? localSort.sortDirection;
+  const handleSort = useCallback((columnId) => {
+    const newDirection = currentSortBy === columnId && currentSortDirection === "asc" ? "desc" : "asc";
+    const newSort = { sortBy: columnId, sortDirection: newDirection };
+    if (sortingConfig?.onChange) {
+      sortingConfig.onChange(newSort);
+    } else {
+      setLocalSort(newSort);
+    }
+    urlState.setSortToURL(newSort);
+  }, [currentSortBy, currentSortDirection, sortingConfig, urlState]);
+  const safeData = useMemo(() => Array.isArray(data) ? data : [], [data]);
+  const sortedData = useMemo(() => {
+    if (sortingConfig?.serverSide || !currentSortBy) {
+      return safeData;
+    }
+    const column = columns.find((c) => c.id === currentSortBy);
+    if (!column) return safeData;
+    return [...safeData].sort((a, b) => {
+      let valueA;
+      let valueB;
+      if (column.sortingFn) {
+        return currentSortDirection === "asc" ? column.sortingFn(a, b) : column.sortingFn(b, a);
+      }
+      if (column.accessorFn) {
+        valueA = column.accessorFn(a);
+        valueB = column.accessorFn(b);
+      } else if (column.accessorKey) {
+        const keys = column.accessorKey.split(".");
+        valueA = keys.reduce((obj, key) => obj?.[key], a);
+        valueB = keys.reduce((obj, key) => obj?.[key], b);
+      } else {
+        return 0;
+      }
+      if (valueA == null && valueB == null) return 0;
+      if (valueA == null) return currentSortDirection === "asc" ? 1 : -1;
+      if (valueB == null) return currentSortDirection === "asc" ? -1 : 1;
+      if (typeof valueA === "string" && typeof valueB === "string") {
+        const comparison2 = valueA.localeCompare(valueB, void 0, { sensitivity: "base" });
+        return currentSortDirection === "asc" ? comparison2 : -comparison2;
+      }
+      if (typeof valueA === "number" && typeof valueB === "number") {
+        return currentSortDirection === "asc" ? valueA - valueB : valueB - valueA;
+      }
+      const comparison = String(valueA).localeCompare(String(valueB));
+      return currentSortDirection === "asc" ? comparison : -comparison;
+    });
+  }, [safeData, columns, currentSortBy, currentSortDirection, sortingConfig?.serverSide]);
+  const pagination = usePagination({
+    totalCount: paginationConfig?.totalCount || sortedData.length,
+    initialPageSize: paginationConfig?.pageSize || 25,
+    initialPage: paginationConfig?.currentPage || (initialURLState?.page ?? 1),
+    serverSide: paginationConfig?.serverSide || false,
+    onPageChange: paginationConfig?.onPageChange
+  });
+  const selection = useSelection({
+    currentPageData: sortedData,
+    totalCount: paginationConfig?.totalCount || sortedData.length,
+    getRowId,
+    onSelectionChange: selectionConfig?.onSelectionChange,
+    onSelectAllPages: selectionConfig?.onSelectAllPages,
+    // External controlled state
+    externalSelectedIds: selectionConfig?.selectedIds,
+    externalSelectAllPages: selectionConfig?.selectAllPages
+  });
+  const filters = useFilters({
+    initialFilters: filtersConfig?.value || (initialURLState?.filters ?? {}),
+    onChange: filtersConfig?.onChange
+  });
+  const getCurrentViewState = useCallback(() => {
+    return {
+      columnVisibility: columnVisibilityConfig?.enabled ? columnVisibility : void 0,
+      columnOrder: columnReorderConfig?.enabled ? columnReorder.columnOrder : void 0,
+      sortBy: currentSortBy,
+      sortDirection: currentSortDirection,
+      filters: filtersConfig?.enabled ? filters.filters : void 0,
+      pageSize: paginationConfig?.pageSize
+    };
+  }, [
+    columnVisibility,
+    columnVisibilityConfig?.enabled,
+    columnReorder.columnOrder,
+    columnReorderConfig?.enabled,
+    currentSortBy,
+    currentSortDirection,
+    filters.filters,
+    filtersConfig?.enabled,
+    paginationConfig?.pageSize
+  ]);
+  useTableKeyboard({
+    data: sortedData,
+    getRowId,
+    selectedIds: selection.selectedIds,
+    onToggleRow: selection.toggleRow,
+    onToggleAll: selection.toggleAll,
+    onRowClick,
+    onDelete: bulkActions.find((action) => action.id === "delete")?.onClick ? (ids) => {
+      const deleteAction = bulkActions.find((action) => action.id === "delete");
+      if (deleteAction) {
+        deleteAction.onClick(ids);
+      }
+    } : void 0,
+    tableRef,
+    enabled: true
+  });
+  useEffect(() => {
+    if (!searchConfig?.enabled || !searchConfig.preserveFocus) return;
+    if (!shouldRestoreFocusRef.current) return;
+    if (searchInputRef.current) {
+      searchInputRef.current.focus();
+      const len = searchConfig.value?.length ?? 0;
+      try {
+        searchInputRef.current.setSelectionRange(len, len);
+      } catch {
+      }
+    }
+    shouldRestoreFocusRef.current = false;
+  }, [searchConfig?.enabled, searchConfig?.preserveFocus, searchConfig?.value]);
+  useEffect(() => {
+    if (!urlPersistenceConfig?.enabled) return;
+    if (!paginationConfig?.enabled) return;
+    urlState.setPageToURL(pagination.currentPage);
+  }, [pagination.currentPage, urlPersistenceConfig?.enabled, paginationConfig?.enabled, urlState]);
+  useEffect(() => {
+    if (!urlPersistenceConfig?.enabled) return;
+    if (!filtersConfig?.enabled) return;
+    urlState.setFiltersToURL(filters.filters);
+  }, [filters.filters, urlPersistenceConfig?.enabled, filtersConfig?.enabled, urlState]);
+  useEffect(() => {
+    if (!urlPersistenceConfig?.enabled) return;
+    if (!searchConfig?.enabled) return;
+    if (!initialURLState?.search) return;
+    if (!searchConfig.value && initialURLState.search) {
+      searchConfig.onChange(initialURLState.search);
+    }
+  }, []);
+  const allRowsSelected = useMemo(() => {
+    if (sortedData.length === 0) return false;
+    return sortedData.every((row) => selection.selectedIds.has(getRowId(row)));
+  }, [sortedData, selection.selectedIds, getRowId]);
+  const selectedDataForExport = useMemo(() => {
+    if (!selectionConfig?.enabled || selection.selectedIds.size === 0) {
+      return void 0;
+    }
+    return sortedData.filter((row) => selection.selectedIds.has(getRowId(row)));
+  }, [sortedData, selection.selectedIds, getRowId, selectionConfig?.enabled]);
+  const handleExecuteBulkAction = async (action) => {
+    const selectedIds = selection.selectAllPages ? new Set(sortedData.map(getRowId)) : selection.selectedIds;
+    if (action.confirmMessage) {
+      const message = action.confirmMessage.replace("{count}", selectedIds.size.toString());
+      if (!confirm(message)) {
+        return;
+      }
+    }
+    if (action.maxSelection && selectedIds.size > action.maxSelection) {
+      alert(`Maximum ${action.maxSelection} items can be selected for this action`);
+      return;
+    }
+    try {
+      await action.onClick(selectedIds);
+      selection.clearSelection();
+    } catch (error) {
+      console.error("Bulk action failed:", error);
+    }
+  };
+  if (loading && sortedData.length === 0) {
+    return /* @__PURE__ */ jsx("div", { className: cn("flex items-center justify-center p-12", className), children: /* @__PURE__ */ jsx(Loader2, { className: "h-8 w-8 animate-spin text-muted-foreground" }) });
+  }
+  if (!loading && sortedData.length === 0 && emptyState) {
+    return /* @__PURE__ */ jsx("div", { className, children: emptyState });
+  }
+  return /* @__PURE__ */ jsxs("div", { ref: tableRef, className: cn("space-y-4", className), tabIndex: 0, children: [
+    /* @__PURE__ */ jsx(
+      StandardTableToolbar,
+      {
+        searchEnabled: searchConfig?.enabled,
+        searchPlaceholder: searchConfig?.placeholder,
+        searchValue: searchConfig?.value,
+        onSearchChange: (value) => {
+          if (searchConfig) {
+            shouldRestoreFocusRef.current = true;
+            searchConfig.onChange(value);
+            urlState.setSearchToURL(value);
+          }
+        },
+        searchInputRef,
+        searchAutoFocus: searchConfig?.autoFocus,
+        columnVisibilityEnabled: columnVisibilityConfig?.enabled,
+        hideableColumns,
+        columnVisibility,
+        onToggleColumnVisibility: toggleColumnVisibility,
+        exportEnabled: exportConfig?.enabled,
+        exportData: sortedData,
+        exportColumns: displayColumns,
+        exportProps: exportConfig?.enabled ? {
+          filteredData: sortedData.length < safeData.length ? sortedData : void 0,
+          selectedData: selectedDataForExport,
+          baseFilename: exportConfig.baseFilename,
+          showProgress: exportConfig.showProgress,
+          onExportStart: exportConfig.onExportStart,
+          onExportComplete: exportConfig.onExportComplete,
+          onExportError: exportConfig.onExportError
+        } : void 0,
+        savedViewsEnabled: savedViewsConfig?.enabled,
+        savedViews: savedViewsConfig?.views,
+        currentViewId: savedViewsConfig?.currentViewId,
+        savedViewsProps: savedViewsConfig?.enabled ? {
+          onSaveView: savedViewsConfig.onSaveView,
+          onUpdateView: savedViewsConfig.onUpdateView,
+          onDeleteView: savedViewsConfig.onDeleteView,
+          onLoadView: savedViewsConfig.onLoadView || (() => {
+          }),
+          getCurrentViewState
+        } : void 0
+      }
+    ),
+    filtersConfig?.enabled && filtersConfig.config && /* @__PURE__ */ jsx(TableFilters, { config: filtersConfig.config, filters }),
+    selectionConfig?.enabled && bulkActions.length > 0 && /* @__PURE__ */ jsx(
+      BulkActionBar,
+      {
+        selectedCount: selection.getSelectedCount(),
+        selectAllPages: selection.selectAllPages,
+        totalCount: paginationConfig?.totalCount || sortedData.length,
+        bulkActions,
+        onClearSelection: selection.clearSelection,
+        onExecuteAction: handleExecuteBulkAction
+      }
+    ),
+    selectionConfig?.enabled && selection.getSelectedCount() > 0 && bulkActions.length === 0 && /* @__PURE__ */ jsxs("div", { className: "flex items-center justify-between text-sm text-muted-foreground", children: [
+      /* @__PURE__ */ jsx("div", { children: selection.selectAllPages ? /* @__PURE__ */ jsxs("span", { className: "font-medium text-blue-600", children: [
+        "All ",
+        paginationConfig?.totalCount || sortedData.length,
+        " items selected"
+      ] }) : /* @__PURE__ */ jsxs("span", { children: [
+        selection.getSelectedCount(),
+        " item",
+        selection.getSelectedCount() === 1 ? "" : "s",
+        " selected",
+        allRowsSelected ? " on this page" : ""
+      ] }) }),
+      !selection.selectAllPages && allRowsSelected && paginationConfig && (paginationConfig.totalCount || 0) > sortedData.length && /* @__PURE__ */ jsxs(
+        "button",
+        {
+          onClick: selection.selectAllPagesToggle,
+          className: "text-blue-600 hover:text-blue-800 font-medium",
+          children: [
+            "Select all ",
+            paginationConfig.totalCount,
+            " items"
+          ]
+        }
+      )
+    ] }),
+    selectionConfig?.enabled && bulkActions.length > 0 && !selection.selectAllPages && allRowsSelected && paginationConfig && (paginationConfig.totalCount || 0) > sortedData.length && /* @__PURE__ */ jsx("div", { className: "flex items-center justify-center p-2 bg-blue-50 border border-blue-200 rounded-lg", children: /* @__PURE__ */ jsxs(
+      "button",
+      {
+        onClick: selection.selectAllPagesToggle,
+        className: "text-blue-600 hover:text-blue-800 font-medium text-sm",
+        children: [
+          "Select all ",
+          paginationConfig.totalCount,
+          " items across all pages"
+        ]
+      }
+    ) }),
+    /* @__PURE__ */ jsx(
+      DataTableCore,
+      {
+        data: sortedData,
+        columns: displayColumns,
+        getRowId,
+        selectionEnabled: selectionConfig?.enabled,
+        selectedIds: selection.selectedIds,
+        onToggleRow: selection.toggleRow,
+        onToggleAll: selection.toggleAll,
+        allRowsSelected,
+        renderSelectionCell: selectionConfig?.renderSelectionCell,
+        sortingEnabled,
+        sortBy: currentSortBy,
+        sortDirection: currentSortDirection,
+        onSort: handleSort,
+        columnReorderEnabled: columnReorderConfig?.enabled,
+        onColumnDragEnd: columnReorder.handleDragEnd,
+        columnResizeEnabled: columnResizeConfig?.enabled,
+        columnWidths: columnResize.columnWidths,
+        onColumnResizeStart: columnResize.startResize,
+        isResizing: columnResize.isResizing,
+        inlineEditEnabled: inlineEditConfig?.enabled,
+        onCellEdit: inlineEditConfig?.onSave,
+        rowActions,
+        onRowClick,
+        loadingRows
+      }
+    ),
+    paginationConfig?.enabled && /* @__PURE__ */ jsx(
+      TablePagination,
+      {
+        pagination,
+        totalFilteredCount: paginationConfig.totalCount
+      }
+    )
+  ] });
+}
+var Card = React5.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(
+  "div",
+  {
+    ref,
+    className: cn(
+      "rounded-xl border bg-card text-card-foreground shadow",
+      className
+    ),
+    ...props
+  }
+));
+Card.displayName = "Card";
+var CardHeader = React5.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx("div", { ref, className: cn("flex flex-col space-y-1.5 p-6", className), ...props }));
+CardHeader.displayName = "CardHeader";
+var CardTitle = React5.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(
+  "h3",
+  {
+    ref,
+    className: cn("font-semibold leading-none tracking-tight", className),
+    ...props
+  }
+));
+CardTitle.displayName = "CardTitle";
+var CardDescription = React5.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(
+  "p",
+  {
+    ref,
+    className: cn("text-sm text-muted-foreground", className),
+    ...props
+  }
+));
+CardDescription.displayName = "CardDescription";
+var CardContent = React5.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx("div", { ref, className: cn("p-6 pt-0", className), ...props }));
+CardContent.displayName = "CardContent";
+var CardFooter = React5.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx("div", { ref, className: cn("flex items-center p-6 pt-0", className), ...props }));
+CardFooter.displayName = "CardFooter";
+function CardActions({
+  actions,
+  row,
+  className,
+  maxVisibleActions = 2
+}) {
+  const [isExecuting, setIsExecuting] = useState(null);
+  const visibleActions = actions.filter((action) => {
+    return !(action.hidden && action.hidden(row));
+  });
+  if (visibleActions.length === 0) {
+    return null;
+  }
+  const handleActionClick = async (action) => {
+    if (action.disabled && action.disabled(row)) {
+      return;
+    }
+    setIsExecuting(action.id);
+    try {
+      await action.onClick(row);
+    } finally {
+      setIsExecuting(null);
+    }
+  };
+  const primaryActions = visibleActions.slice(0, maxVisibleActions);
+  const overflowActions = visibleActions.slice(maxVisibleActions);
+  return /* @__PURE__ */ jsxs("div", { className: cn("flex items-center gap-1", className), children: [
+    primaryActions.map((action) => {
+      const Icon2 = action.icon;
+      const isDisabled = action.disabled ? action.disabled(row) : false;
+      const isLoading = isExecuting === action.id;
+      return /* @__PURE__ */ jsxs(
+        Button,
+        {
+          variant: action.variant || "ghost",
+          size: "sm",
+          className: cn(
+            "h-9 min-w-[44px]",
+            Icon2 && !action.label && "w-9 p-0",
+            action.className
+          ),
+          onClick: (e) => {
+            e.stopPropagation();
+            handleActionClick(action);
+          },
+          disabled: isDisabled || isLoading,
+          children: [
+            Icon2 && /* @__PURE__ */ jsx(Icon2, { className: cn(
+              "h-4 w-4",
+              action.label && "mr-1.5"
+            ) }),
+            action.label && /* @__PURE__ */ jsx("span", { className: "text-xs font-medium", children: action.label })
+          ]
+        },
+        action.id
+      );
+    }),
+    overflowActions.length > 0 && /* @__PURE__ */ jsxs(DropdownMenu, { children: [
+      /* @__PURE__ */ jsx(DropdownMenuTrigger, { asChild: true, children: /* @__PURE__ */ jsxs(
+        Button,
+        {
+          variant: "ghost",
+          size: "sm",
+          className: "h-9 w-9 p-0",
+          onClick: (e) => e.stopPropagation(),
+          children: [
+            /* @__PURE__ */ jsx(MoreVertical, { className: "h-4 w-4" }),
+            /* @__PURE__ */ jsx("span", { className: "sr-only", children: "More actions" })
+          ]
+        }
+      ) }),
+      /* @__PURE__ */ jsx(DropdownMenuContent, { align: "end", className: "w-48", children: overflowActions.map((action, index) => {
+        const Icon2 = action.icon;
+        const isDisabled = action.disabled ? action.disabled(row) : false;
+        const isLoading = isExecuting === action.id;
+        return /* @__PURE__ */ jsxs(
+          DropdownMenuItem,
+          {
+            onClick: (e) => {
+              e.stopPropagation();
+              handleActionClick(action);
+            },
+            disabled: isDisabled || isLoading,
+            className: cn(
+              action.variant === "destructive" && "text-destructive focus:text-destructive",
+              action.className
+            ),
+            children: [
+              Icon2 && /* @__PURE__ */ jsx(Icon2, { className: "mr-2 h-4 w-4" }),
+              /* @__PURE__ */ jsx("span", { children: action.label || "Action" })
+            ]
+          },
+          action.id
+        );
+      }) })
+    ] })
+  ] });
+}
+function getNestedValue(obj, path) {
+  if (!path || !obj) return obj;
+  const keys = path.split(".");
+  let value = obj;
+  for (const key of keys) {
+    if (value === null || value === void 0) return void 0;
+    value = value[key];
+  }
+  return value;
+}
+function renderField(field, row) {
+  const value = getNestedValue(row, field.key);
+  if (field.render) {
+    return field.render(value, row);
+  }
+  if (value === null || value === void 0) {
+    return /* @__PURE__ */ jsx("span", { className: "text-muted-foreground", children: "-" });
+  }
+  if (typeof value === "boolean") {
+    return /* @__PURE__ */ jsx("span", { children: value ? "Yes" : "No" });
+  }
+  return /* @__PURE__ */ jsx("span", { children: String(value) });
+}
+function Card2({
+  row,
+  config,
+  rowId,
+  isLoading = false,
+  className
+}) {
+  const {
+    titleKey,
+    titleRender,
+    subtitleKey,
+    subtitleRender,
+    imageKey,
+    imageRender,
+    primaryFields,
+    secondaryFields,
+    actions,
+    renderCustomContent,
+    renderCustomHeader,
+    renderCustomFooter,
+    showSelection,
+    onSelectionChange,
+    isSelected,
+    onClick,
+    headerClassName,
+    contentClassName,
+    footerClassName
+  } = config;
+  const handleClick = () => {
+    if (onClick && !isLoading) {
+      onClick(row);
+    }
+  };
+  const handleSelectionChange = (checked) => {
+    if (onSelectionChange && rowId) {
+      onSelectionChange(rowId, checked);
+    }
+  };
+  const selected = isSelected ? isSelected(row) : false;
+  return /* @__PURE__ */ jsxs(
+    Card,
+    {
+      className: cn(
+        "relative transition-all duration-200",
+        onClick && !isLoading && "cursor-pointer hover:shadow-md hover:border-primary/50",
+        selected && "ring-2 ring-primary border-primary",
+        isLoading && "opacity-60 pointer-events-none",
+        className,
+        config.className
+      ),
+      onClick: handleClick,
+      children: [
+        isLoading && /* @__PURE__ */ jsx("div", { className: "absolute inset-0 flex items-center justify-center bg-background/50 rounded-lg z-10", children: /* @__PURE__ */ jsx(Loader2, { className: "h-6 w-6 animate-spin text-primary" }) }),
+        /* @__PURE__ */ jsx(CardHeader, { className: cn("pb-3", headerClassName), children: renderCustomHeader ? renderCustomHeader(row) : /* @__PURE__ */ jsxs("div", { className: "flex items-start gap-3", children: [
+          showSelection && /* @__PURE__ */ jsx(
+            "div",
+            {
+              className: "flex items-center pt-1",
+              onClick: (e) => e.stopPropagation(),
+              children: /* @__PURE__ */ jsx(
+                Checkbox,
+                {
+                  checked: selected,
+                  onCheckedChange: handleSelectionChange,
+                  "aria-label": "Select row",
+                  className: "h-5 w-5"
+                }
+              )
+            }
+          ),
+          (imageKey || imageRender) && /* @__PURE__ */ jsx("div", { className: "flex-shrink-0", children: imageRender ? imageRender(row) : /* @__PURE__ */ jsx("div", { className: "h-12 w-12 rounded-full bg-gradient-to-br from-primary/20 to-primary/10 flex items-center justify-center", children: /* @__PURE__ */ jsx("span", { className: "text-lg font-semibold text-primary", children: String(getNestedValue(row, titleKey) || "?").charAt(0).toUpperCase() }) }) }),
+          /* @__PURE__ */ jsx("div", { className: "flex-1 min-w-0", children: /* @__PURE__ */ jsxs("div", { className: "flex items-start justify-between gap-2", children: [
+            /* @__PURE__ */ jsxs("div", { className: "flex-1 min-w-0", children: [
+              /* @__PURE__ */ jsx("h3", { className: "font-semibold text-base leading-tight truncate", children: titleRender ? titleRender(row) : getNestedValue(row, titleKey) }),
+              subtitleKey && /* @__PURE__ */ jsx("p", { className: "text-sm text-muted-foreground mt-1 truncate", children: subtitleRender ? subtitleRender(row) : getNestedValue(row, subtitleKey) })
+            ] }),
+            actions && actions.length > 0 && /* @__PURE__ */ jsx("div", { onClick: (e) => e.stopPropagation(), children: /* @__PURE__ */ jsx(
+              CardActions,
+              {
+                actions,
+                row,
+                maxVisibleActions: 2
+              }
+            ) })
+          ] }) })
+        ] }) }),
+        /* @__PURE__ */ jsx(CardContent, { className: cn("pt-0 space-y-4", contentClassName), children: renderCustomContent ? renderCustomContent(row) : /* @__PURE__ */ jsxs(Fragment, { children: [
+          primaryFields && primaryFields.length > 0 && /* @__PURE__ */ jsx("div", { className: "space-y-3", children: primaryFields.map((field) => /* @__PURE__ */ jsxs(
+            "div",
+            {
+              className: cn(
+                "flex justify-between items-center gap-2",
+                field.className
+              ),
+              children: [
+                /* @__PURE__ */ jsxs("span", { className: "text-sm font-medium text-muted-foreground flex-shrink-0", children: [
+                  field.label || field.key.replace(/([A-Z])/g, " $1").replace(/^./, (str) => str.toUpperCase()),
+                  ":"
+                ] }),
+                /* @__PURE__ */ jsx("div", { className: "text-sm font-medium text-right truncate", children: renderField(field, row) })
+              ]
+            },
+            field.key
+          )) }),
+          secondaryFields && secondaryFields.length > 0 && /* @__PURE__ */ jsx("div", { className: "border-t pt-3", children: /* @__PURE__ */ jsx("div", { className: "grid grid-cols-2 gap-3", children: secondaryFields.map((field) => /* @__PURE__ */ jsxs(
+            "div",
+            {
+              className: cn("space-y-1", field.className),
+              children: [
+                /* @__PURE__ */ jsx("div", { className: "text-xs font-medium text-muted-foreground uppercase tracking-wide", children: field.label || field.key.replace(/([A-Z])/g, " $1").replace(/^./, (str) => str.toUpperCase()) }),
+                /* @__PURE__ */ jsx("div", { className: "text-sm font-semibold truncate", children: renderField(field, row) })
+              ]
+            },
+            field.key
+          )) }) })
+        ] }) }),
+        renderCustomFooter && /* @__PURE__ */ jsx(CardFooter, { className: cn("pt-0", footerClassName), children: renderCustomFooter(row) })
+      ]
+    }
+  );
+}
+
+// src/components/unified-table/components/MobileView/types.ts
+var MOBILE_BREAKPOINT = 768;
+function MobileView({
+  data,
+  config,
+  getRowId,
+  loading = false,
+  loadingRows,
+  emptyState,
+  className
+}) {
+  const [isMobile, setIsMobile] = useState(false);
+  useEffect(() => {
+    const checkMobile = () => {
+      setIsMobile(window.innerWidth < MOBILE_BREAKPOINT);
+    };
+    checkMobile();
+    window.addEventListener("resize", checkMobile);
+    return () => window.removeEventListener("resize", checkMobile);
+  }, []);
+  if (data.length === 0 && !loading) {
+    return /* @__PURE__ */ jsx("div", { className: cn("flex items-center justify-center py-12", className), children: emptyState || /* @__PURE__ */ jsx("div", { className: "text-center", children: /* @__PURE__ */ jsx("p", { className: "text-muted-foreground text-sm", children: "No data to display" }) }) });
+  }
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      className: cn(
+        "space-y-4",
+        isMobile && "space-y-3",
+        className
+      ),
+      children: data.map((row, index) => {
+        const rowId = getRowId ? getRowId(row) : String(index);
+        const isRowLoading = loadingRows?.has(rowId) || false;
+        return /* @__PURE__ */ jsx(
+          Card2,
+          {
+            row,
+            config,
+            rowId,
+            isLoading: isRowLoading
+          },
+          rowId
+        );
+      })
+    }
+  );
+}
+
+// src/components/unified-table/utils/renderers.ts
+function createCellRenderer(render) {
+  return render;
+}
+function getNestedValue2(obj, path) {
+  if (!path || !obj) return obj;
+  const keys = path.split(".");
+  let value = obj;
+  for (const key of keys) {
+    if (value === null || value === void 0) return void 0;
+    value = value[key];
+  }
+  return value;
+}
+var commonRenderers = {
+  text: createCellRenderer((value) => String(value || "-")),
+  number: createCellRenderer((value) => {
+    if (value === null || value === void 0) return "-";
+    return new Intl.NumberFormat().format(Number(value));
+  }),
+  currency: createCellRenderer((value, row, options) => {
+    if (value === null || value === void 0) return "-";
+    return new Intl.NumberFormat(options?.locale || "en-US", {
+      style: "currency",
+      currency: options?.currency || "USD"
+    }).format(Number(value));
+  }),
+  percentage: createCellRenderer((value) => {
+    if (value === null || value === void 0) return "-";
+    return `${Number(value).toFixed(2)}%`;
+  }),
+  date: createCellRenderer((value) => {
+    if (!value) return "-";
+    const date = new Date(value);
+    return date.toLocaleDateString();
+  }),
+  datetime: createCellRenderer((value) => {
+    if (!value) return "-";
+    const date = new Date(value);
+    return date.toLocaleString();
+  }),
+  boolean: createCellRenderer((value) => {
+    if (value === null || value === void 0) return "-";
+    return value ? "Yes" : "No";
+  }),
+  badge: createCellRenderer((value, row, options) => {
+    if (!value) return null;
+    return value;
+  }),
+  truncate: createCellRenderer((value, row, options) => {
+    if (!value) return "-";
+    const str = String(value);
+    const maxLength = options?.maxLength || 50;
+    if (str.length <= maxLength) return str;
+    return `${str.substring(0, maxLength)}...`;
+  }),
+  array: createCellRenderer((value, row, options) => {
+    if (!Array.isArray(value) || value.length === 0) return "-";
+    const maxItems = options?.maxItems || value.length;
+    const items = value.slice(0, maxItems);
+    const separator = options?.separator || ", ";
+    const display = items.join(separator);
+    if (value.length > maxItems) {
+      return `${display} +${value.length - maxItems} more`;
+    }
+    return display;
+  })
+};
+function combineRenderers(...renderers) {
+  return (value, row) => {
+    for (const renderer of renderers) {
+      const result = renderer(value, row);
+      if (result !== null && result !== void 0) {
+        return result;
+      }
+    }
+    return value;
+  };
+}
+
+// src/components/unified-table/utils/themes.ts
+var defaultTheme = {
+  name: "default",
+  container: "w-full",
+  header: "bg-muted/50",
+  headerCell: "px-4 py-3 text-left text-sm font-medium text-muted-foreground",
+  body: "",
+  row: "border-b transition-colors",
+  rowHover: "hover:bg-muted/50",
+  rowSelected: "bg-primary/10 border-primary",
+  cell: "px-4 py-3 text-sm",
+  pagination: "flex items-center justify-between px-4 py-3 border-t",
+  emptyState: "flex items-center justify-center py-12 text-muted-foreground",
+  mobileCard: "rounded-lg border bg-card shadow-sm",
+  mobileCardHeader: "p-4 pb-2",
+  mobileCardContent: "p-4 pt-2"
+};
+var compactTheme = {
+  ...defaultTheme,
+  name: "compact",
+  headerCell: "px-2 py-2 text-left text-xs font-medium text-muted-foreground",
+  cell: "px-2 py-2 text-xs",
+  pagination: "flex items-center justify-between px-2 py-2 border-t",
+  mobileCardHeader: "p-3 pb-1",
+  mobileCardContent: "p-3 pt-1"
+};
+var spaciousTheme = {
+  ...defaultTheme,
+  name: "spacious",
+  headerCell: "px-6 py-4 text-left text-sm font-medium text-muted-foreground",
+  cell: "px-6 py-4 text-sm",
+  pagination: "flex items-center justify-between px-6 py-4 border-t",
+  mobileCardHeader: "p-6 pb-3",
+  mobileCardContent: "p-6 pt-3"
+};
+var minimalTheme = {
+  ...defaultTheme,
+  name: "minimal",
+  header: "",
+  headerCell: "px-4 py-3 text-left text-sm font-semibold",
+  row: "border-b border-border/50",
+  rowHover: "hover:bg-muted/30",
+  mobileCard: "rounded-lg border border-border/50 bg-card"
+};
+var themes = {
+  default: defaultTheme,
+  compact: compactTheme,
+  spacious: spaciousTheme,
+  minimal: minimalTheme
+};
+function getTheme(themeName = "default") {
+  return themes[themeName] || defaultTheme;
+}
+function createCustomTheme(baseTheme = "default", overrides) {
+  return {
+    ...themes[baseTheme],
+    ...overrides,
+    name: overrides.name || `custom-${baseTheme}`
+  };
+}
+
+// src/components/unified-table/utils/validation.ts
+function validateMobileCardConfig(config) {
+  const errors = [];
+  const warnings = [];
+  if (!config.titleKey && !config.titleRender) {
+    errors.push("Mobile card config must have either titleKey or titleRender");
+  }
+  if (!config.primaryFields || config.primaryFields.length === 0) {
+    warnings.push("Mobile card config has no primary fields defined");
+  }
+  if (config.primaryFields) {
+    config.primaryFields.forEach((field, index) => {
+      if (!field.key && !field.render) {
+        errors.push(`Primary field at index ${index} must have either key or render function`);
+      }
+    });
+  }
+  if (config.secondaryFields) {
+    config.secondaryFields.forEach((field, index) => {
+      if (!field.key && !field.render) {
+        errors.push(`Secondary field at index ${index} must have either key or render function`);
+      }
+    });
+  }
+  if (config.actions) {
+    config.actions.forEach((action, index) => {
+      if (!action.id) {
+        errors.push(`Action at index ${index} must have an id`);
+      }
+      if (!action.onClick) {
+        errors.push(`Action '${action.id || index}' must have an onClick handler`);
+      }
+      if (!action.label && !action.icon) {
+        warnings.push(`Action '${action.id || index}' should have either a label or icon`);
+      }
+    });
+  }
+  if (config.showSelection && !config.onSelectionChange) {
+    warnings.push("showSelection is enabled but onSelectionChange handler is not provided");
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings
+  };
+}
+function validateColumnConfig(columns) {
+  const errors = [];
+  const warnings = [];
+  if (!columns || columns.length === 0) {
+    errors.push("At least one column must be defined");
+    return { valid: false, errors, warnings };
+  }
+  const columnIds = /* @__PURE__ */ new Set();
+  columns.forEach((column, index) => {
+    if (!column.id && !column.accessorKey) {
+      errors.push(`Column at index ${index} must have either id or accessorKey`);
+    }
+    const columnId = column.id || column.accessorKey;
+    if (columnIds.has(columnId)) {
+      errors.push(`Duplicate column id: '${columnId}'`);
+    }
+    columnIds.add(columnId);
+    if (!column.header && !column.hideHeader) {
+      warnings.push(`Column '${columnId}' has no header defined`);
+    }
+    if (!column.cell && !column.accessorKey && !column.accessorFn) {
+      warnings.push(`Column '${columnId}' has no way to access data (missing cell, accessorKey, or accessorFn)`);
+    }
+  });
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings
+  };
+}
+function logValidationResults(configName, result, throwOnError = false) {
+  if (result.errors.length > 0) {
+    console.error(`[${configName}] Validation Errors:`, result.errors);
+    if (throwOnError) {
+      throw new Error(`${configName} validation failed: ${result.errors.join(", ")}`);
+    }
+  }
+  if (result.warnings.length > 0) {
+    console.warn(`[${configName}] Validation Warnings:`, result.warnings);
+  }
+  if (result.valid && result.warnings.length === 0) {
+    console.log(`[${configName}] Configuration is valid`);
+  }
+}
+
+export { Badge, Button, Card, Card2, CardActions, CardContent, CardDescription, CardFooter, CardHeader, CardTitle, Checkbox, Dialog, DialogClose, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogOverlay, DialogPortal, DialogTitle, DialogTrigger, DropdownMenu, DropdownMenuCheckboxItem, DropdownMenuContent, DropdownMenuGroup, DropdownMenuItem, DropdownMenuLabel, DropdownMenuPortal, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuTrigger, Input, Label, MOBILE_BREAKPOINT, MobileView, Select, SelectContent, SelectGroup, SelectItem, SelectLabel, SelectScrollDownButton, SelectScrollUpButton, SelectSeparator, SelectTrigger, SelectValue, StandardTableToolbar, Table, TableBody, TableCaption, TableCell, TableFooter, TableHead, TableHeader, TableRow, UnifiedTable, badgeVariants, buttonVariants, combineRenderers, commonRenderers, compactTheme, createCellRenderer, createCustomTheme, defaultTheme, exportData, exportToCSV, exportToExcel, generateExportFilename, getNestedValue2 as getNestedValue, getTheme, logValidationResults, minimalTheme, spaciousTheme, themes, useColumnReorder, useColumnResize, useColumnVisibility, useFilters, usePagination, useResponsive, useSelection, useTableKeyboard, useTablePreferences, useTableState, useTableURL, validateColumnConfig, validateMobileCardConfig };
+//# sourceMappingURL=chunk-27YUQBOE.mjs.map
+//# sourceMappingURL=chunk-27YUQBOE.mjs.map