@undevy-org/tablewright 0.1.0

package/dist/es/hooks/useTableOrchestration.js

@@ -0,0 +1,452 @@
+import { useState, useEffect, useMemo, useRef, useCallback } from "react";
+import { useStore } from "zustand";
+import { useColumnResize } from "../components/data-table/hooks/use-column-resize.js";
+import { getVisiblePageNumbers } from "../components/data-table/hooks/use-table-pagination.js";
+import { computeColumnGaps } from "../lib/column-gaps.js";
+import { computeColumnStats } from "../lib/filter-stats.js";
+import { createTableOrchestrationStore, defaultValueForFilter } from "./table-orchestration-store.js";
+const EMPTY_ID_SET = /* @__PURE__ */ new Set();
+function useTableOrchestration(config) {
+  const {
+    rows,
+    filterConfigs,
+    columnMeta,
+    toggleableColumnIds,
+    rowsPerPageOptions,
+    viewPresets,
+    defaultViewKey,
+    columnGroups,
+    initialColumnVisibility,
+    initialColumnWidths,
+    columnPriorities,
+    wideBreakpoint = 1280,
+    compactBreakpoint = 768
+  } = config;
+  const { getRowId, filterRow, getSortValue, getSearchText } = config;
+  const [store] = useState(
+    () => createTableOrchestrationStore({
+      defaultViewKey,
+      initialColumnVisibility,
+      initialRowsPerPage: rowsPerPageOptions[0]
+    })
+  );
+  const searchInput = useStore(store, (s) => s.searchInput);
+  const searchQuery = useStore(store, (s) => s.searchQuery);
+  const columnFilters = useStore(store, (s) => s.columnFilters);
+  const newestFilterColumnId = useStore(store, (s) => s.newestFilterColumnId);
+  const requestOpenFilterId = useStore(store, (s) => s.requestOpenFilterId);
+  const currentSort = useStore(store, (s) => s.currentSort);
+  const columnVisibility = useStore(store, (s) => s.columnVisibility);
+  const page = useStore(store, (s) => s.page);
+  const rowsPerPage = useStore(store, (s) => s.rowsPerPage);
+  const density = useStore(store, (s) => s.density);
+  const isRefreshing = useStore(store, (s) => s.isRefreshing);
+  const selectedIds = useStore(store, (s) => s.selectedIds);
+  const activeView = useStore(store, (s) => s.activeView);
+  const columnsMenuOpen = useStore(store, (s) => s.columnsMenuOpen);
+  const selectedRowId = useStore(store, (s) => s.selectedRowId);
+  const hasPriorities = Boolean(columnPriorities && Object.keys(columnPriorities).length > 0);
+  const [isWide, setIsWide] = useState(true);
+  const [isCompact, setIsCompact] = useState(false);
+  useEffect(() => {
+    if (!hasPriorities || typeof window === "undefined") return;
+    const mql = window.matchMedia(`(min-width: ${wideBreakpoint}px)`);
+    const onChange = (e) => setIsWide(e.matches);
+    setIsWide(mql.matches);
+    mql.addEventListener("change", onChange);
+    return () => mql.removeEventListener("change", onChange);
+  }, [hasPriorities, wideBreakpoint]);
+  useEffect(() => {
+    if (typeof window === "undefined") return;
+    const mql = window.matchMedia(`(max-width: ${compactBreakpoint - 1}px)`);
+    const onChange = (e) => setIsCompact(e.matches);
+    setIsCompact(mql.matches);
+    mql.addEventListener("change", onChange);
+    return () => mql.removeEventListener("change", onChange);
+  }, [compactBreakpoint]);
+  const responsiveHiddenColumnIds = useMemo(() => {
+    if (isWide || !columnPriorities) return EMPTY_ID_SET;
+    const hidden = /* @__PURE__ */ new Set();
+    for (const [id, priority] of Object.entries(columnPriorities)) {
+      if (priority === 3) hidden.add(id);
+    }
+    return hidden;
+  }, [isWide, columnPriorities]);
+  const selectedIdsRef = useRef(selectedIds);
+  const headerCheckStateRef = useRef(false);
+  const sortState = useMemo(() => {
+    if (!currentSort) return {};
+    return { [currentSort.columnId]: currentSort.direction };
+  }, [currentSort]);
+  const { widths, onPointerDown, setWidths } = useColumnResize(columnMeta, initialColumnWidths);
+  const activePreset = useMemo(() => {
+    if (activeView === "custom") {
+      return {
+        key: "custom",
+        label: "Custom",
+        filters: [],
+        sort: null,
+        columnVisibility: {}
+      };
+    }
+    return viewPresets.find((v) => v.key === activeView) ?? viewPresets[0];
+  }, [activeView, viewPresets]);
+  const allColumnFilterStats = useMemo(() => {
+    const result = {};
+    for (const [columnId, cfg] of Object.entries(filterConfigs)) {
+      if (cfg.type === "compound" && cfg.subFilters) {
+        for (const sub of cfg.subFilters) {
+          const s = computeColumnStats(rows, sub.field, {
+            type: sub.type,
+            label: sub.label,
+            options: sub.options
+          });
+          if (s) result[`${columnId}:${sub.key}`] = s;
+        }
+      } else {
+        const s = computeColumnStats(rows, cfg.fieldName ?? columnId, cfg);
+        if (s) result[columnId] = s;
+      }
+    }
+    return result;
+  }, [rows, filterConfigs]);
+  const filteredRows = useMemo(() => {
+    const search = searchQuery.trim().toLowerCase();
+    const filtered = rows.filter((row) => {
+      if (activePreset.customFilter && !activePreset.customFilter(row)) return false;
+      if (search.length > 0 && !getSearchText(row).includes(search)) return false;
+      return columnFilters.every((filter) => filterRow(row, filter));
+    });
+    if (!currentSort) return filtered;
+    const { columnId, direction } = currentSort;
+    return [...filtered].sort((a, b) => {
+      const aVal = getSortValue(a, columnId);
+      const bVal = getSortValue(b, columnId);
+      if (aVal < bVal) return direction === "asc" ? -1 : 1;
+      if (aVal > bVal) return direction === "asc" ? 1 : -1;
+      return 0;
+    });
+  }, [
+    rows,
+    searchQuery,
+    columnFilters,
+    currentSort,
+    activePreset,
+    getSearchText,
+    filterRow,
+    getSortValue
+  ]);
+  const filteredColumnFilterStats = useMemo(() => {
+    if (columnFilters.length === 0 && searchQuery.trim().length === 0) return null;
+    const result = {};
+    for (const [columnId, cfg] of Object.entries(filterConfigs)) {
+      if (cfg.type === "compound" && cfg.subFilters) {
+        for (const sub of cfg.subFilters) {
+          const s = computeColumnStats(filteredRows, sub.field, {
+            type: sub.type,
+            label: sub.label,
+            options: sub.options
+          });
+          if (s) result[`${columnId}:${sub.key}`] = s;
+        }
+      } else {
+        const s = computeColumnStats(filteredRows, columnId, cfg);
+        if (s) result[columnId] = s;
+      }
+    }
+    return result;
+  }, [filteredRows, filterConfigs, columnFilters, searchQuery]);
+  const columnFilterStats = useMemo(() => {
+    const result = {};
+    for (const [columnId, cfg] of Object.entries(filterConfigs)) {
+      if (cfg.type === "compound" && cfg.subFilters) {
+        for (const sub of cfg.subFilters) {
+          const key = `${columnId}:${sub.key}`;
+          const all = allColumnFilterStats[key];
+          if (!all) continue;
+          result[key] = { all, filtered: filteredColumnFilterStats?.[key] ?? null };
+        }
+      } else {
+        const all = allColumnFilterStats[columnId];
+        if (!all) continue;
+        result[columnId] = { all, filtered: filteredColumnFilterStats?.[columnId] ?? null };
+      }
+    }
+    return result;
+  }, [allColumnFilterStats, filteredColumnFilterStats, filterConfigs]);
+  const totalPages = Math.max(1, Math.ceil(filteredRows.length / rowsPerPage));
+  const safePage = Math.min(page, totalPages);
+  const pageNumbers = useMemo(
+    () => getVisiblePageNumbers(safePage, totalPages),
+    [safePage, totalPages]
+  );
+  const paginatedRows = useMemo(() => {
+    const start = (safePage - 1) * rowsPerPage;
+    return filteredRows.slice(start, start + rowsPerPage);
+  }, [filteredRows, rowsPerPage, safePage]);
+  const pageIds = useMemo(() => new Set(paginatedRows.map(getRowId)), [paginatedRows, getRowId]);
+  const selectedOnPage = useMemo(
+    () => [...selectedIds].filter((id) => pageIds.has(id)).length,
+    [selectedIds, pageIds]
+  );
+  const allOnPageSelected = pageIds.size > 0 && selectedOnPage === pageIds.size;
+  const headerCheckState = allOnPageSelected ? true : selectedOnPage > 0 ? "indeterminate" : false;
+  const columnGaps = useMemo(
+    () => columnGroups ? computeColumnGaps(toggleableColumnIds, columnVisibility) : [],
+    [columnGroups, toggleableColumnIds, columnVisibility]
+  );
+  const extendedColumnMeta = useMemo(() => {
+    if (columnGaps.length === 0) return columnMeta;
+    const meta = { ...columnMeta };
+    for (const gap of columnGaps) {
+      meta[`__gap_after_${gap.afterColumnId ?? "start"}`] = { minW: 32 };
+    }
+    return meta;
+  }, [columnGaps, columnMeta]);
+  const extendedWidths = useMemo(() => {
+    if (columnGaps.length === 0) return widths;
+    const merged = { ...widths };
+    for (const gap of columnGaps) {
+      merged[`__gap_after_${gap.afterColumnId ?? "start"}`] = 32;
+    }
+    return merged;
+  }, [widths, columnGaps]);
+  const hiddenColumnsCount = useMemo(() => {
+    return toggleableColumnIds.filter((id) => columnVisibility[id] === false).length;
+  }, [toggleableColumnIds, columnVisibility]);
+  const activeCustomFilterChip = activePreset.customFilterChip ?? null;
+  selectedIdsRef.current = selectedIds;
+  headerCheckStateRef.current = headerCheckState;
+  if (page !== safePage) {
+    store.getState().setPage(safePage);
+  }
+  if (selectedRowId && !filteredRows.some((row) => getRowId(row) === selectedRowId)) {
+    store.getState().setSelectedRowId(null);
+  }
+  const filteredIdSet = useMemo(
+    () => new Set(filteredRows.map(getRowId)),
+    [filteredRows, getRowId]
+  );
+  const prunedSelectedIds = useMemo(() => {
+    const pruned = new Set([...selectedIds].filter((id) => filteredIdSet.has(id)));
+    return pruned.size === selectedIds.size ? selectedIds : pruned;
+  }, [selectedIds, filteredIdSet]);
+  if (prunedSelectedIds !== selectedIds) {
+    store.getState().setSelectedIds(prunedSelectedIds);
+  }
+  const handleSearchSubmit = useCallback(
+    (e) => {
+      e.preventDefault();
+      store.getState().submitSearch();
+    },
+    [store]
+  );
+  const handleHeaderSort = useCallback(
+    (columnId, direction) => {
+      store.getState().toggleSort(columnId, direction);
+    },
+    [store]
+  );
+  const handleViewChange = useCallback(
+    (key) => {
+      if (key === "custom") return;
+      const preset = viewPresets.find((v) => v.key === key);
+      if (!preset) return;
+      store.getState().applyPreset({
+        key,
+        filters: preset.filters,
+        sort: preset.sort,
+        columnVisibility: preset.columnVisibility
+      });
+    },
+    [viewPresets, store]
+  );
+  const handleAddColumnFilter = useCallback(
+    (columnId) => {
+      const cfg = filterConfigs[columnId];
+      if (!cfg) return;
+      store.getState().addColumnFilter(columnId, defaultValueForFilter(cfg));
+    },
+    [filterConfigs, store]
+  );
+  const handleOpenExistingFilter = useCallback(
+    (columnId) => store.getState().setRequestOpenFilterId(columnId),
+    [store]
+  );
+  const handleRequestOpenHandled = useCallback(
+    () => store.getState().setRequestOpenFilterId(null),
+    [store]
+  );
+  const handleRemoveColumnFilter = useCallback(
+    (columnId) => store.getState().removeColumnFilter(columnId),
+    [store]
+  );
+  const handleChangeColumnFilter = useCallback(
+    (columnId, value) => store.getState().changeColumnFilter(columnId, value),
+    [store]
+  );
+  const handleSetColumnFilter = useCallback(
+    (columnId, value) => store.getState().setColumnFilter(columnId, value),
+    [store]
+  );
+  const handleHeaderFilterClick = useCallback(
+    (columnId) => {
+      const state = store.getState();
+      const isActive = state.columnFilters.some((f) => f.columnId === columnId);
+      if (!isActive) {
+        const cfg = filterConfigs[columnId];
+        if (cfg) state.addColumnFilter(columnId, defaultValueForFilter(cfg));
+      }
+      state.setRequestOpenFilterId(columnId);
+    },
+    [filterConfigs, store]
+  );
+  const handleHideColumn = useCallback(
+    (columnId) => store.getState().hideColumn(columnId),
+    [store]
+  );
+  const handleResetColumns = useCallback(() => {
+    store.getState().resetColumns();
+    setWidths(() => {
+      const w = {};
+      for (const [id, m] of Object.entries(columnMeta)) w[id] = m.minW;
+      return w;
+    });
+  }, [store, setWidths, columnMeta]);
+  const handleRemoveSort = useCallback(() => store.getState().removeSort(), [store]);
+  const handleRemoveCustomFilter = useCallback(() => {
+    store.getState().goCustom();
+    store.getState().setPage(1);
+  }, [store]);
+  const handleClearAll = useCallback(
+    () => store.getState().clearAll(defaultViewKey),
+    [defaultViewKey, store]
+  );
+  const handleRefresh = useCallback(() => store.getState().startRefresh(), [store]);
+  const handleToggleRowSelection = useCallback(
+    (id) => store.getState().toggleRowSelection(id),
+    [store]
+  );
+  const handleToggleHeaderCheck = useCallback(() => {
+    const ids = paginatedRows.map(getRowId);
+    store.getState().toggleHeaderCheck(ids, allOnPageSelected);
+  }, [paginatedRows, allOnPageSelected, getRowId, store]);
+  const handleExpandRow = useCallback(
+    (row, e) => {
+      e.stopPropagation();
+      const id = getRowId(row);
+      store.getState().toggleSelectedRowId(id);
+    },
+    [getRowId, store]
+  );
+  const handleExpandGap = useCallback(
+    (hiddenIds) => store.getState().showColumns(hiddenIds),
+    [store]
+  );
+  const handlePageChange = useCallback((p) => store.getState().setPage(p), [store]);
+  const handleRowsPerPageChange = useCallback(
+    (value) => store.getState().setRowsPerPage(value),
+    [store]
+  );
+  const setSearchInput = useCallback((v) => store.getState().setSearchInput(v), [store]);
+  const setColumnVisibility = useCallback(
+    (next) => store.getState().setColumnVisibility(next),
+    [store]
+  );
+  const setDensity = useCallback(
+    (v) => store.getState().setDensity(v),
+    [store]
+  );
+  const setSelectedIds = useCallback(
+    (next) => store.getState().setSelectedIds(next),
+    [store]
+  );
+  const setColumnsMenuOpen = useCallback(
+    (v) => store.getState().setColumnsMenuOpen(v),
+    [store]
+  );
+  const setSelectedRowId = useCallback(
+    (v) => store.getState().setSelectedRowId(v),
+    [store]
+  );
+  const getSelectedIds = useCallback(() => selectedIdsRef.current, []);
+  const getHeaderCheckState = useCallback(() => headerCheckStateRef.current, []);
+  return {
+    // State
+    searchInput,
+    setSearchInput,
+    searchQuery,
+    columnFilters,
+    newestFilterColumnId,
+    requestOpenFilterId,
+    currentSort,
+    columnVisibility,
+    setColumnVisibility,
+    page,
+    rowsPerPage,
+    density,
+    setDensity,
+    isRefreshing,
+    selectedIds,
+    setSelectedIds,
+    activeView,
+    columnsMenuOpen,
+    setColumnsMenuOpen,
+    selectedRowId,
+    setSelectedRowId,
+    // Derived
+    sortState,
+    activePreset,
+    filteredRows,
+    paginatedRows,
+    totalPages,
+    safePage,
+    pageNumbers,
+    columnFilterStats,
+    columnGaps,
+    extendedColumnMeta,
+    extendedWidths,
+    activeCustomFilterChip,
+    hiddenColumnsCount,
+    responsiveHiddenColumnIds,
+    isCompact,
+    // Selection
+    pageIds,
+    allOnPageSelected,
+    headerCheckState,
+    // Ref-stable getters
+    getSelectedIds,
+    getHeaderCheckState,
+    // Callbacks
+    handleSearchSubmit,
+    handleHeaderSort,
+    handleViewChange,
+    handleAddColumnFilter,
+    handleOpenExistingFilter,
+    handleRequestOpenHandled,
+    handleRemoveColumnFilter,
+    handleChangeColumnFilter,
+    handleSetColumnFilter,
+    handleHeaderFilterClick,
+    handleHideColumn,
+    handleResetColumns,
+    handleRemoveSort,
+    handleRemoveCustomFilter,
+    handleClearAll,
+    handleRefresh,
+    handleToggleRowSelection,
+    handleToggleHeaderCheck,
+    handleExpandRow,
+    handleExpandGap,
+    handlePageChange,
+    handleRowsPerPageChange,
+    // Column resize
+    widths,
+    onPointerDown,
+    // Escape hatch
+    store
+  };
+}
+export {
+  useTableOrchestration
+};

package/dist/es/index.js

@@ -0,0 +1,199 @@
+import { Badge, badgeVariants } from "./components/ui/badge.js";
+import { Button, buttonVariants } from "./components/ui/button.js";
+import { Checkbox } from "./components/ui/checkbox.js";
+import { Dialog, DialogClose, DialogContent, DialogDescription, DialogHeader, DialogOverlay, DialogPortal, DialogTitle, DialogTrigger } from "./components/ui/dialog.js";
+import { DropdownMenu, DropdownMenuCheckboxItem, DropdownMenuContent, DropdownMenuGroup, DropdownMenuItem, DropdownMenuPortal, DropdownMenuTrigger } from "./components/ui/dropdown-menu.js";
+import { Input } from "./components/ui/input.js";
+import { Popover, PopoverAnchor, PopoverContent, PopoverTrigger } from "./components/ui/popover.js";
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "./components/ui/select.js";
+import { Tabs, TabsContent, TabsList, TabsTrigger } from "./components/ui/tabs.js";
+import { Combobox, Command, CommandEmpty, CommandGroup, CommandInput, CommandItem, CommandList } from "./components/ui/combobox.js";
+import { ButtonFooter } from "./components/ui/button-footer.js";
+import { ThemeSwitch } from "./components/ui/theme-switch.js";
+import { SegmentedControl } from "./components/ui/segmented-control.js";
+import { CopyButton } from "./components/data-table/CopyButton.js";
+import { CopyableText } from "./components/data-table/CopyableText.js";
+import { DataTableShell } from "./components/data-table/DataTableShell.js";
+import { DrawerActionGroup } from "./components/data-table/DrawerActionGroup.js";
+import { DrawerEntityCard } from "./components/data-table/DrawerEntityCard.js";
+import { DrawerField } from "./components/data-table/DrawerField.js";
+import { DrawerFlagGrid, DrawerFlagItem } from "./components/data-table/DrawerFlagItem.js";
+import { DrawerSection } from "./components/data-table/DrawerSection.js";
+import { DrawerShell } from "./components/data-table/DrawerShell.js";
+import { DrawerSummaryCard } from "./components/data-table/DrawerSummaryCard.js";
+import { useDrawerExpanded } from "./context/drawer-expand-context.js";
+import { DRAWER_SIZE } from "./constants/drawer.js";
+import { EmptyState } from "./components/data-table/EmptyState.js";
+import { FilterChip } from "./components/data-table/FilterChip.js";
+import { ViewChip } from "./components/data-table/ViewChip.js";
+import { FilterPopoverFooter } from "./components/data-table/FilterPopoverFooter.js";
+import * as FilterToolbar from "./components/data-table/FilterToolbar.js";
+import { RowActionsMenu } from "./components/data-table/RowActionsMenu.js";
+import { RowControlCell, RowControlHeader } from "./components/data-table/RowControlCell.js";
+import { SortableHeader } from "./components/data-table/SortableHeader.js";
+import { TableFooter } from "./components/data-table/TableFooter.js";
+import { TableLayout } from "./components/data-table/TableLayout.js";
+import { useColumnResize } from "./components/data-table/hooks/use-column-resize.js";
+import { getVisiblePageNumbers } from "./components/data-table/hooks/use-table-pagination.js";
+import { useRowDrag } from "./components/data-table/hooks/use-row-drag.js";
+import { useTableSort } from "./components/data-table/hooks/use-table-sort.js";
+import { AppShell } from "./components/layout/AppShell.js";
+import { Sidebar } from "./components/layout/Sidebar.js";
+import { TopBar } from "./components/layout/TopBar.js";
+import { SidebarUser } from "./components/layout/SidebarUser.js";
+import { SidebarAccountMenu } from "./components/layout/SidebarAccountMenu.js";
+import { useAppShell } from "./components/layout/app-shell-context.js";
+import { ReportSummaryCard } from "./components/dashboard/ReportSummaryCard.js";
+import { useScrollActivity } from "./hooks/use-scroll-activity.js";
+import { cn } from "./lib/utils.js";
+import { STYLE_SCOPE } from "./lib/style-scope.js";
+import { PortalContainerContext, usePortalContainer } from "./context/portal-container-context.js";
+import { GAP_CELL_ATTR, GAP_HEADER_ATTR, GapCell, GapIndicator } from "./components/data-table/GapIndicator.js";
+import { TimestampCell } from "./components/data-table/TimestampCell.js";
+import { ExpiryTimestampCell } from "./components/data-table/ExpiryTimestampCell.js";
+import { ColumnHeaderMenu } from "./components/data-table/ColumnHeaderMenu.js";
+import { TwoPanelMenuBase } from "./components/data-table/TwoPanelMenu.js";
+import { FlatColumnToggle } from "./components/data-table/FlatColumnToggle.js";
+import { GroupedColumnToggle } from "./components/data-table/GroupedColumnToggle.js";
+import { ColumnFilterPopover } from "./components/data-table/ColumnFilterPopover.js";
+import { CompoundFilterPopover } from "./components/data-table/CompoundFilterPopover.js";
+import { AppliedStateChips } from "./components/data-table/AppliedStateChips.js";
+import { FilterFormPanel } from "./components/data-table/FilterFormPanel.js";
+import { FilterFormToggle, useFilterFormOpen } from "./components/data-table/FilterFormToggle.js";
+import { applyManagedChanges, clearManagedFilters, hasActiveManagedFilters } from "./components/data-table/managed-filters.js";
+import { useTableOrchestration } from "./hooks/useTableOrchestration.js";
+import { createTableOrchestrationStore, defaultValueForFilter } from "./hooks/table-orchestration-store.js";
+import { useRowDragOverride } from "./hooks/useRowDragOverride.js";
+import { computeColumnGaps } from "./lib/column-gaps.js";
+import { computeColumnStats } from "./lib/filter-stats.js";
+import { formatEnumLabel } from "./lib/format-enum.js";
+import { displayTimeZone, formatDateParts, formatLiveTimestamp, parsePossibleTimestamp } from "./lib/format-timestamp.js";
+import { MonoIdCell } from "./components/data-table/cells/MonoIdCell.js";
+import { CurrencyAmountCell } from "./components/data-table/cells/CurrencyAmountCell.js";
+import { DualLineCell } from "./components/data-table/cells/DualLineCell.js";
+import { AmountCell } from "./components/data-table/cells/AmountCell.js";
+import { ConfirmedAmountCell } from "./components/data-table/cells/ConfirmedAmountCell.js";
+import { EnumBadgeCell } from "./components/data-table/cells/EnumBadgeCell.js";
+export {
+  AmountCell,
+  AppShell,
+  AppliedStateChips,
+  Badge,
+  Button,
+  ButtonFooter,
+  Checkbox,
+  ColumnFilterPopover,
+  ColumnHeaderMenu,
+  Combobox,
+  Command,
+  CommandEmpty,
+  CommandGroup,
+  CommandInput,
+  CommandItem,
+  CommandList,
+  CompoundFilterPopover,
+  ConfirmedAmountCell,
+  CopyButton,
+  CopyableText,
+  CurrencyAmountCell,
+  DRAWER_SIZE,
+  DataTableShell,
+  Dialog,
+  DialogClose,
+  DialogContent,
+  DialogDescription,
+  DialogHeader,
+  DialogOverlay,
+  DialogPortal,
+  DialogTitle,
+  DialogTrigger,
+  DrawerActionGroup,
+  DrawerEntityCard,
+  DrawerField,
+  DrawerFlagGrid,
+  DrawerFlagItem,
+  DrawerSection,
+  DrawerShell,
+  DrawerSummaryCard,
+  DropdownMenu,
+  DropdownMenuCheckboxItem,
+  DropdownMenuContent,
+  DropdownMenuGroup,
+  DropdownMenuItem,
+  DropdownMenuPortal,
+  DropdownMenuTrigger,
+  DualLineCell,
+  EmptyState,
+  EnumBadgeCell,
+  ExpiryTimestampCell,
+  FilterChip,
+  FilterFormPanel,
+  FilterFormToggle,
+  FilterPopoverFooter,
+  FilterToolbar,
+  FlatColumnToggle,
+  GAP_CELL_ATTR,
+  GAP_HEADER_ATTR,
+  GapCell,
+  GapIndicator,
+  GroupedColumnToggle,
+  Input,
+  MonoIdCell,
+  Popover,
+  PopoverAnchor,
+  PopoverContent,
+  PopoverTrigger,
+  PortalContainerContext,
+  ReportSummaryCard,
+  RowActionsMenu,
+  RowControlCell,
+  RowControlHeader,
+  STYLE_SCOPE,
+  SegmentedControl,
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+  Sidebar,
+  SidebarAccountMenu,
+  SidebarUser,
+  SortableHeader,
+  TableFooter,
+  TableLayout,
+  Tabs,
+  TabsContent,
+  TabsList,
+  TabsTrigger,
+  ThemeSwitch,
+  TimestampCell,
+  TopBar,
+  TwoPanelMenuBase,
+  ViewChip,
+  applyManagedChanges,
+  badgeVariants,
+  buttonVariants,
+  clearManagedFilters,
+  cn,
+  computeColumnGaps,
+  computeColumnStats,
+  createTableOrchestrationStore,
+  defaultValueForFilter,
+  displayTimeZone,
+  formatDateParts,
+  formatEnumLabel,
+  formatLiveTimestamp,
+  getVisiblePageNumbers,
+  hasActiveManagedFilters,
+  parsePossibleTimestamp,
+  useAppShell,
+  useColumnResize,
+  useDrawerExpanded,
+  useFilterFormOpen,
+  usePortalContainer,
+  useRowDrag,
+  useRowDragOverride,
+  useScrollActivity,
+  useTableOrchestration,
+  useTableSort
+};

package/dist/es/lib/column-gaps.js

@@ -0,0 +1,23 @@
+function computeColumnGaps(orderedColumnIds, columnVisibility) {
+  const gaps = [];
+  let lastVisibleId = null;
+  let pendingHidden = [];
+  for (const columnId of orderedColumnIds) {
+    if (columnVisibility[columnId] === false) {
+      pendingHidden.push(columnId);
+    } else {
+      if (pendingHidden.length > 0) {
+        gaps.push({ afterColumnId: lastVisibleId, hiddenIds: pendingHidden });
+        pendingHidden = [];
+      }
+      lastVisibleId = columnId;
+    }
+  }
+  if (pendingHidden.length > 0) {
+    gaps.push({ afterColumnId: lastVisibleId, hiddenIds: pendingHidden });
+  }
+  return gaps;
+}
+export {
+  computeColumnGaps
+};