@coveord/plasma-mantine/dist/esm/components/Table/use-persisted-column-visibility.js

A Plasma flavoured Mantine theme

import { useCallback, useMemo } from 'react';
import { getStorageItem, setStorageItem } from '../../utils/local-storage.js';
const storagePath = (tableId)=>[
        'table',
        tableId,
        'columnVisibility'
    ];
const capVisibleColumns = (visibility, max)=>{
    let visibleCount = 0;
    const result = {};
    for (const [key, isVisible] of Object.entries(visibility)){
        const shouldShow = isVisible && visibleCount < max;
        result[key] = shouldShow;
        if (shouldShow) {
            visibleCount++;
        }
    }
    return result;
};
const sanitizeFromStorage = (raw, validColumnIds)=>{
    const result = {};
    if (typeof raw !== 'object' || raw === null || Array.isArray(raw)) {
        return result;
    }
    for (const [key, value] of Object.entries(raw)){
        if (validColumnIds.has(key) && typeof value === 'boolean') {
            result[key] = value;
        }
    }
    return result;
};
/**
 * Hook that persists column visibility preferences to localStorage.
 *
 * @param defaultVisibleColumns - The default visibility map. Its keys define the set of valid column IDs.
 * Must be a stable reference (e.g. via `useRef`) to avoid re-reading localStorage on every render.
 * @param maxSelectableColumns - Maximum number of columns that can be visible at the same time.
 * @param tableId - Unique identifier for the table. When omitted, no persistence occurs.
 */ export const usePersistedColumnVisibility = (defaultVisibleColumns, maxSelectableColumns, tableId)=>{
    const path = tableId ? storagePath(tableId) : null;
    const validIds = useMemo(()=>new Set(Object.keys(defaultVisibleColumns)), [
        defaultVisibleColumns
    ]);
    const hasValidIds = validIds.size > 0;
    const initialColumnVisibility = useMemo(()=>{
        if (!path || !hasValidIds) {
            return defaultVisibleColumns;
        }
        const stored = getStorageItem([
            ...path
        ]);
        if (stored !== null) {
            const sanitized = sanitizeFromStorage(stored, validIds);
            if (Object.keys(sanitized).length > 0) {
                return capVisibleColumns({
                    ...defaultVisibleColumns,
                    ...sanitized
                }, maxSelectableColumns);
            }
        }
        return capVisibleColumns(defaultVisibleColumns, maxSelectableColumns);
    }, [
        path,
        validIds,
        defaultVisibleColumns,
        maxSelectableColumns
    ]);
    const persistColumnVisibility = useCallback((visibility)=>{
        if (!path || !hasValidIds) {
            return;
        }
        setStorageItem([
            ...path
        ], visibility);
    }, [
        path,
        hasValidIds
    ]);
    return {
        initialColumnVisibility,
        persistColumnVisibility
    };
};

//# sourceMappingURL=use-persisted-column-visibility.js.map