@alaarab/ogrid-react 2.1.3 → 2.1.4

package/dist/esm/hooks/useOGrid.js

@@ -1,371 +0,0 @@
-import { useMemo, useCallback, useState, useImperativeHandle, useEffect, useRef, } from 'react';
-import { flattenColumns } from '../utils';
-import { validateColumns, validateRowIds } from '@alaarab/ogrid-core';
-import { useOGridPagination } from './useOGridPagination';
-import { useOGridSorting } from './useOGridSorting';
-import { useOGridFilters } from './useOGridFilters';
-import { useOGridDataFetching } from './useOGridDataFetching';
-import { useLatestRef } from './useLatestRef';
-import { useSideBarState } from './useSideBarState';
-const DEFAULT_PAGE_SIZE = 25;
-const EMPTY_LOADING_OPTIONS = {};
-/**
- * Top-level orchestration hook for OGrid: manages pagination, sorting, filtering, column visibility, and sidebar.
- * Delegates to focused sub-hooks for each concern.
- * @param props - All OGrid props (columns, data, callbacks, feature flags).
- * @param ref - Forwarded ref for imperative API (refresh, export, applyColumnState).
- * @returns Grouped props for DataGridTable, pagination controls, column chooser, layout, and filters.
- */
-export function useOGrid(props, ref) {
-    const { columns: columnsProp, getRowId, data, dataSource, page: controlledPage, pageSize: controlledPageSize, sort: controlledSort, filters: controlledFilters, visibleColumns: controlledVisibleColumns, isLoading: controlledLoading, onPageChange, onPageSizeChange, onSortChange, onFiltersChange, onVisibleColumnsChange, columnOrder, onColumnOrderChange, onColumnResized, onColumnPinned, defaultPageSize = DEFAULT_PAGE_SIZE, defaultSortBy, defaultSortDirection = 'asc', toolbar, toolbarBelow, emptyState, entityLabelPlural = 'items', className, layoutMode = 'fill', suppressHorizontalScroll, editable, cellSelection, onCellValueChanged, onUndo, onRedo, canUndo, canRedo, rowSelection = 'none', selectedRows, onSelectionChange, showRowNumbers, statusBar, pageSizeOptions, sideBar, stickyHeader, fullScreen, onFirstDataRendered, onError, columnChooser: columnChooserProp, columnReorder, virtualScroll, rowHeight, density = 'normal', 'aria-label': ariaLabel, 'aria-labelledby': ariaLabelledBy, } = props;
-    // --- Derived column state ---
-    const columnChooserPlacement = columnChooserProp === false ? 'none'
-        : columnChooserProp === 'sidebar' ? 'sidebar'
-            : 'toolbar';
-    const columns = useMemo(() => flattenColumns(columnsProp), [columnsProp]);
-    const isServerSide = dataSource != null;
-    // --- Runtime validation (dev-only, runs once on mount) ---
-    const rowIdsValidatedRef = useRef(false);
-    useEffect(() => {
-        validateColumns(columns);
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, []); // intentionally empty — run once at mount
-    const defaultSortField = defaultSortBy ?? columns[0]?.columnId ?? '';
-    // --- Internal data state (for imperative setRowData/setLoading API) ---
-    const [internalData, setInternalData] = useState([]);
-    const [internalLoading, setInternalLoading] = useState(false);
-    const displayData = data ?? internalData;
-    const displayLoading = controlledLoading ?? internalLoading;
-    // --- Sub-hooks ---
-    const paginationState = useOGridPagination({
-        controlledPage, controlledPageSize, defaultPageSize,
-        onPageChange, onPageSizeChange,
-    });
-    const sortingState = useOGridSorting({
-        controlledSort, defaultSortField, defaultSortDirection,
-        onSortChange, setPage: paginationState.setPage,
-    });
-    const filtersState = useOGridFilters({
-        controlledFilters, onFiltersChange,
-        setPage: paginationState.setPage,
-        columns, displayData, dataSource,
-    });
-    const dataFetchingState = useOGridDataFetching({
-        isServerSide, dataSource, displayData, columns,
-        stableFilters: filtersState.stableFilters,
-        sort: sortingState.sort,
-        page: paginationState.page,
-        pageSize: paginationState.pageSize,
-        onError, onFirstDataRendered,
-    });
-    // Validate row IDs once on first data render
-    useEffect(() => {
-        const items = dataFetchingState.displayItems;
-        if (!rowIdsValidatedRef.current && items.length > 0) {
-            rowIdsValidatedRef.current = true;
-            validateRowIds(items, getRowId);
-        }
-    }, [dataFetchingState.displayItems, getRowId]);
-    // --- Column visibility ---
-    const [internalVisibleColumns, setInternalVisibleColumns] = useState(() => {
-        const visible = columns
-            .filter((c) => c.defaultVisible !== false)
-            .map((c) => c.columnId);
-        return new Set(visible.length > 0 ? visible : columns.map((c) => c.columnId));
-    });
-    // Re-initialize when columns arrive after starting empty (common pattern: columns
-    // depend on async data, so the initial render passes columns=[] then re-renders
-    // with actual columns once data loads).
-    const prevColumnsLengthRef = useRef(columns.length);
-    useEffect(() => {
-        const prev = prevColumnsLengthRef.current;
-        prevColumnsLengthRef.current = columns.length;
-        if (controlledVisibleColumns !== undefined)
-            return; // controlled — skip
-        if (prev === 0 && columns.length > 0 && internalVisibleColumns.size === 0) {
-            const visible = columns
-                .filter((c) => c.defaultVisible !== false)
-                .map((c) => c.columnId);
-            setInternalVisibleColumns(new Set(visible.length > 0 ? visible : columns.map((c) => c.columnId)));
-        }
-    }, [columns, controlledVisibleColumns, internalVisibleColumns.size]);
-    const visibleColumns = controlledVisibleColumns ?? internalVisibleColumns;
-    const setVisibleColumns = useCallback((cols) => {
-        if (controlledVisibleColumns === undefined)
-            setInternalVisibleColumns(cols);
-        onVisibleColumnsChange?.(cols);
-    }, [controlledVisibleColumns, onVisibleColumnsChange]);
-    const handleVisibilityChange = useCallback((columnKey, isVisible) => {
-        const next = new Set(visibleColumns);
-        if (isVisible)
-            next.add(columnKey);
-        else
-            next.delete(columnKey);
-        setVisibleColumns(next);
-    }, [visibleColumns, setVisibleColumns]);
-    // --- Row selection ---
-    const [internalSelectedRows, setInternalSelectedRows] = useState(new Set());
-    const effectiveSelectedRows = selectedRows ?? internalSelectedRows;
-    const handleSelectionChange = useCallback((event) => {
-        if (selectedRows === undefined) {
-            setInternalSelectedRows(new Set(event.selectedRowIds));
-        }
-        onSelectionChange?.(event);
-    }, [selectedRows, onSelectionChange]);
-    // --- Column resize & pin ---
-    const [columnWidthOverrides, setColumnWidthOverrides] = useState({});
-    const [pinnedOverrides, setPinnedOverrides] = useState({});
-    const handleColumnResized = useCallback((columnId, width) => {
-        setColumnWidthOverrides((prev) => ({ ...prev, [columnId]: width }));
-        onColumnResized?.(columnId, width);
-    }, [onColumnResized]);
-    const handleColumnPinned = useCallback((columnId, pinned) => {
-        setPinnedOverrides((prev) => {
-            if (pinned === null) {
-                const { [columnId]: _, ...rest } = prev;
-                return rest;
-            }
-            return { ...prev, [columnId]: pinned };
-        });
-        onColumnPinned?.(columnId, pinned);
-    }, [onColumnPinned]);
-    // --- Imperative handle (stabilized via refs to avoid invalidation on every state change) ---
-    const visibleColumnsRef = useLatestRef(visibleColumns);
-    const sortRef = useLatestRef(sortingState.sort);
-    const columnOrderRef = useLatestRef(columnOrder);
-    const columnWidthOverridesRef = useLatestRef(columnWidthOverrides);
-    const pinnedOverridesRef = useLatestRef(pinnedOverrides);
-    const filtersRef = useLatestRef(filtersState.filters);
-    const effectiveSelectedRowsRef = useLatestRef(effectiveSelectedRows);
-    const displayItemsRef = useLatestRef(dataFetchingState.displayItems);
-    const getRowIdRef = useLatestRef(getRowId);
-    const columnsRef = useLatestRef(columns);
-    useImperativeHandle(ref, () => ({
-        setRowData: (d) => {
-            if (!isServerSide)
-                setInternalData(d);
-        },
-        setLoading: setInternalLoading,
-        getColumnState: () => ({
-            visibleColumns: Array.from(visibleColumnsRef.current),
-            sort: sortRef.current,
-            columnOrder: columnOrderRef.current ?? undefined,
-            columnWidths: Object.keys(columnWidthOverridesRef.current).length > 0 ? columnWidthOverridesRef.current : undefined,
-            filters: Object.keys(filtersRef.current).length > 0 ? filtersRef.current : undefined,
-            pinnedColumns: Object.keys(pinnedOverridesRef.current).length > 0 ? pinnedOverridesRef.current : undefined,
-        }),
-        applyColumnState: (state) => {
-            if (state.visibleColumns)
-                setVisibleColumns(new Set(state.visibleColumns));
-            if (state.sort)
-                sortingState.setSort(state.sort);
-            if (state.columnOrder && onColumnOrderChange)
-                onColumnOrderChange(state.columnOrder);
-            if (state.columnWidths)
-                setColumnWidthOverrides(state.columnWidths);
-            if (state.filters)
-                filtersState.setFilters(state.filters);
-            if (state.pinnedColumns)
-                setPinnedOverrides(state.pinnedColumns);
-        },
-        setFilterModel: filtersState.setFilters,
-        getSelectedRows: () => Array.from(effectiveSelectedRowsRef.current),
-        setSelectedRows: (rowIds) => {
-            if (selectedRows === undefined)
-                setInternalSelectedRows(new Set(rowIds));
-        },
-        selectAll: () => {
-            const items = displayItemsRef.current;
-            const allIds = new Set(items.map((item) => getRowIdRef.current(item)));
-            if (selectedRows === undefined)
-                setInternalSelectedRows(allIds);
-            onSelectionChange?.({ selectedRowIds: Array.from(allIds), selectedItems: items });
-        },
-        deselectAll: () => {
-            if (selectedRows === undefined)
-                setInternalSelectedRows(new Set());
-            onSelectionChange?.({ selectedRowIds: [], selectedItems: [] });
-        },
-        clearFilters: () => filtersState.setFilters({}),
-        clearSort: () => sortingState.setSort({ field: sortingState.defaultSortField, direction: sortingState.defaultSortDirection }),
-        resetGridState: (options) => {
-            filtersState.setFilters({});
-            sortingState.setSort({ field: sortingState.defaultSortField, direction: sortingState.defaultSortDirection });
-            if (!options?.keepSelection) {
-                if (selectedRows === undefined)
-                    setInternalSelectedRows(new Set());
-                onSelectionChange?.({ selectedRowIds: [], selectedItems: [] });
-            }
-        },
-        getDisplayedRows: () => displayItemsRef.current,
-        refreshData: () => {
-            if (isServerSide)
-                dataFetchingState.refreshData();
-        },
-        getColumnOrder: () => columnOrderRef.current ?? columnsRef.current.map((c) => c.columnId),
-        setColumnOrder: (order) => {
-            onColumnOrderChange?.(order);
-        },
-        scrollToRow: () => {
-            // No-op at orchestration level — DataGridTable components implement
-            // this via useVirtualScroll.scrollToIndex when virtual scrolling is active.
-        },
-    }), [
-        isServerSide, setVisibleColumns, sortingState, filtersState,
-        onColumnOrderChange, selectedRows, onSelectionChange, dataFetchingState,
-        columnOrderRef, columnWidthOverridesRef, columnsRef, displayItemsRef,
-        effectiveSelectedRowsRef, filtersRef, getRowIdRef, pinnedOverridesRef,
-        sortRef, visibleColumnsRef,
-    ]);
-    // --- Status bar ---
-    const statusBarConfig = useMemo(() => {
-        if (!statusBar)
-            return undefined;
-        if (typeof statusBar === 'object')
-            return statusBar;
-        const totalData = !isServerSide ? (data?.length ?? 0) : dataFetchingState.displayTotalCount;
-        const filteredData = dataFetchingState.displayTotalCount;
-        return {
-            totalCount: totalData,
-            filteredCount: filtersState.hasActiveFilters ? filteredData : undefined,
-            selectedCount: effectiveSelectedRows.size,
-            suppressRowCount: true,
-        };
-    }, [statusBar, isServerSide, data, dataFetchingState.displayTotalCount, filtersState.hasActiveFilters, effectiveSelectedRows.size]);
-    // --- Side bar ---
-    const sideBarState = useSideBarState({ config: sideBar });
-    const columnChooserColumns = useMemo(() => columns.map((c) => ({ columnId: c.columnId, name: c.name, required: c.required === true })), [columns]);
-    const filterableColumns = useMemo(() => columns
-        .filter((c) => c.filterable && c.filterable.type)
-        .map((c) => ({
-        columnId: c.columnId,
-        name: c.name,
-        filterField: c.filterable?.filterField ?? c.columnId,
-        filterType: c.filterable?.type,
-    })), [columns]);
-    const sideBarProps = useMemo(() => {
-        if (!sideBarState.isEnabled)
-            return null;
-        return {
-            activePanel: sideBarState.activePanel,
-            onPanelChange: sideBarState.setActivePanel,
-            panels: sideBarState.panels,
-            position: sideBarState.position,
-            columns: columnChooserColumns,
-            visibleColumns,
-            onVisibilityChange: handleVisibilityChange,
-            onSetVisibleColumns: setVisibleColumns,
-            filterableColumns,
-            filters: filtersState.filters,
-            onFilterChange: filtersState.handleFilterChange,
-            filterOptions: filtersState.clientFilterOptions,
-        };
-    }, [
-        sideBarState.isEnabled, sideBarState.activePanel, sideBarState.setActivePanel,
-        sideBarState.panels, sideBarState.position,
-        columnChooserColumns, visibleColumns, handleVisibilityChange, setVisibleColumns,
-        filterableColumns, filtersState.filters, filtersState.handleFilterChange, filtersState.clientFilterOptions,
-    ]);
-    // --- Assembly ---
-    const clearAllFilters = useCallback(() => filtersState.setFilters({}), [filtersState]);
-    const isLoadingResolved = (isServerSide && dataFetchingState.serverLoading) || displayLoading;
-    const dataGridProps = useMemo(() => ({
-        items: dataFetchingState.displayItems,
-        columns: columnsProp,
-        getRowId,
-        sortBy: sortingState.sort.field,
-        sortDirection: sortingState.sort.direction,
-        onColumnSort: sortingState.handleSort,
-        visibleColumns,
-        columnOrder,
-        onColumnOrderChange,
-        onColumnResized: handleColumnResized,
-        onColumnPinned: handleColumnPinned,
-        pinnedColumns: pinnedOverrides,
-        initialColumnWidths: columnWidthOverrides,
-        editable,
-        cellSelection,
-        onCellValueChanged,
-        onUndo,
-        onRedo,
-        canUndo,
-        canRedo,
-        rowSelection,
-        selectedRows: effectiveSelectedRows,
-        onSelectionChange: handleSelectionChange,
-        showRowNumbers,
-        currentPage: paginationState.page,
-        pageSize: paginationState.pageSize,
-        statusBar: statusBarConfig,
-        isLoading: isLoadingResolved,
-        filters: filtersState.filters,
-        onFilterChange: filtersState.handleFilterChange,
-        filterOptions: filtersState.clientFilterOptions,
-        loadingFilterOptions: dataSource?.fetchFilterOptions ? filtersState.loadingFilterOptions : EMPTY_LOADING_OPTIONS,
-        peopleSearch: dataSource?.searchPeople,
-        getUserByEmail: dataSource?.getUserByEmail,
-        layoutMode,
-        suppressHorizontalScroll,
-        stickyHeader: stickyHeader ?? true,
-        columnReorder,
-        virtualScroll,
-        rowHeight,
-        density,
-        'aria-label': ariaLabel,
-        'aria-labelledby': ariaLabelledBy,
-        emptyState: {
-            hasActiveFilters: filtersState.hasActiveFilters,
-            onClearAll: clearAllFilters,
-            message: emptyState?.message,
-            render: emptyState?.render,
-        },
-    }), [
-        dataFetchingState.displayItems, columnsProp, getRowId,
-        sortingState.sort.field, sortingState.sort.direction, sortingState.handleSort,
-        visibleColumns, columnOrder, onColumnOrderChange, handleColumnResized,
-        handleColumnPinned, pinnedOverrides, columnWidthOverrides,
-        editable, cellSelection, onCellValueChanged, onUndo, onRedo, canUndo, canRedo,
-        rowSelection, effectiveSelectedRows, handleSelectionChange, showRowNumbers,
-        paginationState.page, paginationState.pageSize, statusBarConfig,
-        isLoadingResolved, filtersState.filters, filtersState.handleFilterChange,
-        filtersState.clientFilterOptions, dataSource, filtersState.loadingFilterOptions,
-        layoutMode, suppressHorizontalScroll, stickyHeader, columnReorder, virtualScroll,
-        rowHeight, density, ariaLabel, ariaLabelledBy,
-        filtersState.hasActiveFilters, clearAllFilters, emptyState,
-    ]);
-    const pagination = useMemo(() => ({
-        page: paginationState.page,
-        pageSize: paginationState.pageSize,
-        displayTotalCount: dataFetchingState.displayTotalCount,
-        setPage: paginationState.setPage,
-        setPageSize: paginationState.setPageSize,
-        pageSizeOptions,
-        entityLabelPlural,
-    }), [paginationState.page, paginationState.pageSize, dataFetchingState.displayTotalCount, paginationState.setPage, paginationState.setPageSize, pageSizeOptions, entityLabelPlural]);
-    const columnChooser = useMemo(() => ({
-        columns: columnChooserColumns,
-        visibleColumns,
-        onVisibilityChange: handleVisibilityChange,
-        onSetVisibleColumns: setVisibleColumns,
-        placement: columnChooserPlacement,
-    }), [columnChooserColumns, visibleColumns, handleVisibilityChange, setVisibleColumns, columnChooserPlacement]);
-    const layout = useMemo(() => ({
-        toolbar,
-        toolbarBelow,
-        className,
-        emptyState,
-        sideBarProps,
-        fullScreen,
-    }), [toolbar, toolbarBelow, className, emptyState, sideBarProps, fullScreen]);
-    const filtersResult = useMemo(() => ({
-        hasActiveFilters: filtersState.hasActiveFilters,
-        setFilters: filtersState.setFilters,
-    }), [filtersState.hasActiveFilters, filtersState.setFilters]);
-    return {
-        dataGridProps,
-        pagination,
-        columnChooser,
-        layout,
-        filters: filtersResult,
-    };
-}

package/dist/esm/hooks/useOGridDataFetching.js

@@ -1,74 +0,0 @@
-import { useState, useEffect, useRef, useMemo } from 'react';
-import { processClientSideData } from '../utils';
-/**
- * Manages data fetching (server-side) and client-side filtering/sorting/pagination.
- * Fires onFirstDataRendered once when items first appear.
- */
-export function useOGridDataFetching(params) {
-    const { isServerSide, dataSource, displayData, columns, stableFilters, sort, page, pageSize, onError, onFirstDataRendered, } = params;
-    const isClientSide = !isServerSide;
-    // --- Client-side filtering & sorting ---
-    const clientItemsAndTotal = useMemo(() => {
-        if (!isClientSide)
-            return null;
-        const rows = processClientSideData(displayData, columns, stableFilters, sort.field, sort.direction);
-        const total = rows.length;
-        const start = (page - 1) * pageSize;
-        const paged = rows.slice(start, start + pageSize);
-        return { items: paged, totalCount: total };
-    }, [isClientSide, displayData, columns, stableFilters, sort.field, sort.direction, page, pageSize]);
-    // --- Server-side data fetching ---
-    const [serverItems, setServerItems] = useState([]);
-    const [serverTotalCount, setServerTotalCount] = useState(0);
-    const [serverLoading, setServerLoading] = useState(true);
-    const fetchIdRef = useRef(0);
-    const [refreshCounter, setRefreshCounter] = useState(0);
-    useEffect(() => {
-        if (!isServerSide || !dataSource) {
-            if (!isServerSide)
-                setServerLoading(false);
-            return;
-        }
-        const id = ++fetchIdRef.current;
-        setServerLoading(true);
-        dataSource
-            .fetchPage({
-            page, pageSize,
-            sort: { field: sort.field, direction: sort.direction },
-            filters: stableFilters,
-        })
-            .then((res) => {
-            if (id !== fetchIdRef.current)
-                return;
-            setServerItems(res.items);
-            setServerTotalCount(res.totalCount);
-        })
-            .catch((err) => {
-            if (id !== fetchIdRef.current)
-                return;
-            onError?.(err);
-            setServerItems([]);
-            setServerTotalCount(0);
-        })
-            .finally(() => {
-            if (id === fetchIdRef.current)
-                setServerLoading(false);
-        });
-    }, [isServerSide, dataSource, page, pageSize, sort.field, sort.direction, stableFilters, onError, refreshCounter]);
-    const displayItems = isClientSide && clientItemsAndTotal ? clientItemsAndTotal.items : serverItems;
-    const displayTotalCount = isClientSide && clientItemsAndTotal ? clientItemsAndTotal.totalCount : serverTotalCount;
-    // Fire onFirstDataRendered once when the grid first has data
-    const firstDataRenderedRef = useRef(false);
-    useEffect(() => {
-        if (!firstDataRenderedRef.current && displayItems.length > 0) {
-            firstDataRenderedRef.current = true;
-            onFirstDataRendered?.();
-        }
-    }, [displayItems.length, onFirstDataRendered]);
-    return {
-        displayItems,
-        displayTotalCount,
-        serverLoading,
-        refreshData: () => setRefreshCounter((prev) => prev + 1),
-    };
-}

package/dist/esm/hooks/useOGridFilters.js

@@ -1,59 +0,0 @@
-import { useState, useCallback, useMemo } from 'react';
-import { mergeFilter, deriveFilterOptionsFromData, getMultiSelectFilterFields, } from '../utils';
-import { useFilterOptions } from './useFilterOptions';
-import { useShallowEqualMemo } from './useShallowEqualMemo';
-/** Deep-equal check for filter objects (shallow key+value comparison). */
-function filtersEqual(a, b) {
-    const aKeys = Object.keys(a);
-    const bKeys = Object.keys(b);
-    if (aKeys.length !== bKeys.length)
-        return false;
-    for (let i = 0; i < bKeys.length; i++) {
-        if (a[bKeys[i]] !== b[bKeys[i]])
-            return false;
-    }
-    return true;
-}
-const EMPTY_LOADING_OPTIONS = {};
-const EMPTY_DATA_SOURCE = { fetchFilterOptions: undefined };
-/**
- * Manages filter state, filter options (client + server), and stabilized filter reference.
- * Resets to page 1 on filter change.
- */
-export function useOGridFilters(params) {
-    const { controlledFilters, onFiltersChange, setPage, columns, displayData, dataSource } = params;
-    const [internalFilters, setInternalFilters] = useState({});
-    const filters = controlledFilters ?? internalFilters;
-    const setFilters = useCallback((f) => {
-        if (controlledFilters === undefined)
-            setInternalFilters(f);
-        onFiltersChange?.(f);
-        setPage(1);
-    }, [controlledFilters, onFiltersChange, setPage]);
-    const handleFilterChange = useCallback((key, value) => {
-        setFilters(mergeFilter(filters, key, value));
-    }, [filters, setFilters]);
-    // Stabilize filters via shallow comparison so processClientSideData useMemo
-    // doesn't re-run when the filter object reference changes but values are identical.
-    const stableFilters = useShallowEqualMemo(filters, (a, b) => filtersEqual(a, b));
-    const hasActiveFilters = useMemo(() => Object.values(filters).some((v) => v !== undefined), [filters]);
-    // --- Filter options (server or client-derived) ---
-    const multiSelectFilterFields = useMemo(() => getMultiSelectFilterFields(columns), [columns]);
-    const filterOptionsSource = dataSource ?? EMPTY_DATA_SOURCE;
-    const { filterOptions: serverFilterOptions, loadingOptions: loadingFilterOptions } = useFilterOptions(filterOptionsSource, multiSelectFilterFields);
-    const hasServerFilterOptions = dataSource?.fetchFilterOptions != null;
-    const clientFilterOptions = useMemo(() => {
-        if (hasServerFilterOptions)
-            return serverFilterOptions;
-        return deriveFilterOptionsFromData(displayData, columns);
-    }, [hasServerFilterOptions, displayData, columns, serverFilterOptions]);
-    return {
-        filters,
-        setFilters,
-        handleFilterChange,
-        stableFilters,
-        hasActiveFilters,
-        clientFilterOptions,
-        loadingFilterOptions: dataSource?.fetchFilterOptions ? loadingFilterOptions : EMPTY_LOADING_OPTIONS,
-    };
-}

package/dist/esm/hooks/useOGridPagination.js

@@ -1,24 +0,0 @@
-import { useState, useCallback } from 'react';
-/**
- * Manages pagination state with controlled/uncontrolled dual-mode support.
- * Resets to page 1 when page size changes.
- */
-export function useOGridPagination(params) {
-    const { controlledPage, controlledPageSize, defaultPageSize, onPageChange, onPageSizeChange } = params;
-    const [internalPage, setInternalPage] = useState(1);
-    const [internalPageSize, setInternalPageSize] = useState(defaultPageSize);
-    const page = controlledPage ?? internalPage;
-    const pageSize = controlledPageSize ?? internalPageSize;
-    const setPage = useCallback((p) => {
-        if (controlledPage === undefined)
-            setInternalPage(p);
-        onPageChange?.(p);
-    }, [controlledPage, onPageChange]);
-    const setPageSize = useCallback((size) => {
-        if (controlledPageSize === undefined)
-            setInternalPageSize(size);
-        onPageSizeChange?.(size);
-        setPage(1);
-    }, [controlledPageSize, onPageSizeChange, setPage]);
-    return { page, pageSize, setPage, setPageSize };
-}

package/dist/esm/hooks/useOGridSorting.js

@@ -1,24 +0,0 @@
-import { useState, useCallback } from 'react';
-import { computeNextSortState } from '../utils';
-/**
- * Manages sort state with controlled/uncontrolled dual-mode support.
- * Resets to page 1 on sort change.
- */
-export function useOGridSorting(params) {
-    const { controlledSort, defaultSortField, defaultSortDirection, onSortChange, setPage } = params;
-    const [internalSort, setInternalSort] = useState({
-        field: defaultSortField,
-        direction: defaultSortDirection,
-    });
-    const sort = controlledSort ?? internalSort;
-    const setSort = useCallback((s) => {
-        if (controlledSort === undefined)
-            setInternalSort(s);
-        onSortChange?.(s);
-        setPage(1);
-    }, [controlledSort, onSortChange, setPage]);
-    const handleSort = useCallback((columnKey, direction) => {
-        setSort(computeNextSortState(sort, columnKey, direction));
-    }, [sort, setSort]);
-    return { sort, setSort, handleSort, defaultSortField, defaultSortDirection };
-}

package/dist/esm/hooks/usePaginationControls.js

@@ -1,16 +0,0 @@
-import { useMemo } from 'react';
-import { getPaginationViewModel } from '../utils';
-/**
- * Shared pagination controls logic for React UI packages.
- * Computes pagination view model and provides standardized handlers.
- */
-export function usePaginationControls(props) {
-    const { currentPage, pageSize, totalCount, onPageSizeChange, pageSizeOptions, entityLabelPlural } = props;
-    const labelPlural = entityLabelPlural ?? 'items';
-    const vm = useMemo(() => getPaginationViewModel(currentPage, pageSize, totalCount, pageSizeOptions ? { pageSizeOptions } : undefined), [currentPage, pageSize, totalCount, pageSizeOptions]);
-    return {
-        labelPlural,
-        vm,
-        handlePageSizeChange: onPageSizeChange,
-    };
-}

package/dist/esm/hooks/usePeopleFilterState.js

@@ -1,73 +0,0 @@
-/**
- * People filter state sub-hook for column header filters.
- * Manages people search text, suggestions, loading state, input ref, and user select/clear handlers.
- * Includes debounced people search effect.
- */
-import { useState, useCallback, useEffect, useRef } from 'react';
-import { PEOPLE_SEARCH_DEBOUNCE_MS } from '@alaarab/ogrid-core';
-export function usePeopleFilterState(params) {
-    const { onUserChange, peopleSearch, isFilterOpen, filterType } = params;
-    const peopleInputRef = useRef(null);
-    const focusTimeoutRef = useRef(undefined);
-    const peopleSearchTimeoutRef = useRef(undefined);
-    const [peopleSuggestions, setPeopleSuggestions] = useState([]);
-    const [isPeopleLoading, setIsPeopleLoading] = useState(false);
-    const [peopleSearchText, setPeopleSearchText] = useState('');
-    // Sync temp state when popover opens
-    useEffect(() => {
-        if (isFilterOpen) {
-            setPeopleSearchText('');
-            setPeopleSuggestions([]);
-            if (filterType === 'people') {
-                focusTimeoutRef.current = window.setTimeout(() => peopleInputRef.current?.focus(), 50);
-            }
-        }
-        return () => {
-            if (focusTimeoutRef.current)
-                window.clearTimeout(focusTimeoutRef.current);
-        };
-    }, [isFilterOpen, filterType]);
-    // People search with debounce
-    useEffect(() => {
-        if (!peopleSearch || !isFilterOpen || filterType !== 'people')
-            return;
-        if (peopleSearchTimeoutRef.current)
-            window.clearTimeout(peopleSearchTimeoutRef.current);
-        if (!peopleSearchText.trim()) {
-            setPeopleSuggestions([]);
-            return;
-        }
-        setIsPeopleLoading(true);
-        peopleSearchTimeoutRef.current = window.setTimeout(async () => {
-            try {
-                const results = await peopleSearch(peopleSearchText);
-                setPeopleSuggestions(results.slice(0, 10));
-            }
-            catch {
-                setPeopleSuggestions([]);
-            }
-            finally {
-                setIsPeopleLoading(false);
-            }
-        }, PEOPLE_SEARCH_DEBOUNCE_MS);
-        return () => {
-            if (peopleSearchTimeoutRef.current)
-                window.clearTimeout(peopleSearchTimeoutRef.current);
-        };
-    }, [peopleSearchText, peopleSearch, isFilterOpen, filterType]);
-    const handleUserSelect = useCallback((user) => {
-        onUserChange?.(user);
-    }, [onUserChange]);
-    const handleClearUser = useCallback(() => {
-        onUserChange?.(undefined);
-    }, [onUserChange]);
-    return {
-        peopleSuggestions,
-        isPeopleLoading,
-        peopleSearchText,
-        setPeopleSearchText,
-        peopleInputRef,
-        handleUserSelect,
-        handleClearUser,
-    };
-}