"use client" import * as React from "react" import type { ColumnDef } from "./types" import type { ActiveFilter, FilterOperator } from "../../lib/table-properties-types" import { augmentColumnsWithCompanionFilters, resolveColumnFilter } from "../../lib/column-filter" let _filterId = 0 function nextFilterId() { return `f-${++_filterId}` } /** Search, active filters, connectors and the filter drawer/bar state for useTableState. */ export function useFilterState>( columns: ColumnDef[], syncedSearchFromUrl?: string, ) { const [search, setSearch] = React.useState(() => syncedSearchFromUrl !== undefined ? syncedSearchFromUrl.trim() : "", ) const [searchOpen, setSearchOpen] = React.useState(() => syncedSearchFromUrl !== undefined && Boolean(syncedSearchFromUrl.trim()), ) const searchRef = React.useRef(null) const [activeFilters, setActiveFilters] = React.useState([]) const [filterConnectors, setFilterConnectors] = React.useState>({}) const [openFilterId, setOpenFilterId] = React.useState(null) const [filterBarVisible, setFilterBarVisible] = React.useState(true) const [drawerExpandedFilters, setDrawerExpandedFilters] = React.useState>(new Set()) // Follow the URL's search when it changes. Adjusted during render (not in an // effect) so the table never paints one frame with the old query. const [prevSyncedSearch, setPrevSyncedSearch] = React.useState(syncedSearchFromUrl) if (syncedSearchFromUrl !== prevSyncedSearch) { setPrevSyncedSearch(syncedSearchFromUrl) if (syncedSearchFromUrl !== undefined) { const next = syncedSearchFromUrl.trim() setSearch(next) setSearchOpen(next.length > 0) } } const toggleConnector = React.useCallback((leftId: string) => { setFilterConnectors(prev => ({ ...prev, [leftId]: prev[leftId] === "or" ? "and" : "or" })) }, [setFilterConnectors]) function getConnector(leftId: string): "and" | "or" { return filterConnectors[leftId] ?? "and" } const filterColumns = React.useMemo( () => augmentColumnsWithCompanionFilters(columns), [columns], ) const buildEmptyFilter = React.useCallback((fieldKey: string): ActiveFilter | null => { const col = filterColumns.find(c => c.key === fieldKey) const f = col ? resolveColumnFilter(col) : null if (!f) return null const firstOperator: FilterOperator = (() => { if (f.type === "select" || f.type === "date" || f.type === "date-range") { const pick = f.operators?.find(o => o === "is" || o === "is_not") return pick ?? "is" } return f.operators?.[0] ?? "contains" })() return { id: nextFilterId(), fieldKey, operator: firstOperator, values: [] } }, [filterColumns]) const addFilter = React.useCallback((fieldKey: string, fromDrawer = false) => { const newFilter = buildEmptyFilter(fieldKey) if (!newFilter) return setActiveFilters(prev => [...prev, newFilter]) if (fromDrawer) { setDrawerExpandedFilters(() => new Set([newFilter.id])) // Keep toolbar pills hidden until a value is chosen — avoids mounting every // FilterPill (heavy) on each drawer "Add filter" click. } else { setOpenFilterId(newFilter.id) setFilterBarVisible(true) } }, [buildEmptyFilter, setActiveFilters, setDrawerExpandedFilters, setOpenFilterId, setFilterBarVisible]) const updateFilter = React.useCallback((id: string, patch: Partial) => { let shouldShowFilterBar = false setActiveFilters(prev => { const next = prev.map(f => { if (f.id !== id) return f const merged = { ...f, ...patch } const col = filterColumns.find(c => c.key === merged.fieldKey) const filterDef = col ? resolveColumnFilter(col) : null if (merged.values.length > 0) { shouldShowFilterBar = filterDef?.type === "text" ? (merged.values[0] ?? "").trim().length > 0 : filterDef?.type === "range" ? merged.values.length >= 2 : filterDef?.type === "date-range" ? Boolean(merged.values[0] || merged.values[1]) : true } return merged }) return next }) if (shouldShowFilterBar) setFilterBarVisible(true) }, [filterColumns, setActiveFilters, setFilterBarVisible]) const removeFilter = React.useCallback((id: string) => { // The connector map is keyed by the filter on its left, so a removed // filter has to hand its connector to that neighbour before its own entry // goes. The two updates are queued side by side rather than nesting the // connector one inside the filter updater: an updater that queues another // update is not pure, and React can replay it. const idx = activeFilters.findIndex(f => f.id === id) const remaining = activeFilters.length - 1 setActiveFilters(prev => prev.filter(f => f.id !== id)) setFilterConnectors(prev => { const next = { ...prev } if (idx > 0 && remaining > 0) { const leftId = activeFilters[idx - 1].id next[leftId] = prev[id] ?? prev[leftId] ?? "and" } delete next[id] return next }) setOpenFilterId(prev => prev === id ? null : prev) }, [activeFilters, setActiveFilters, setFilterConnectors, setOpenFilterId]) return { search, setSearch, searchOpen, setSearchOpen, searchRef, activeFilters, setActiveFilters, filterConnectors, setFilterConnectors, openFilterId, setOpenFilterId, filterBarVisible, setFilterBarVisible, drawerExpandedFilters, setDrawerExpandedFilters, toggleConnector, getConnector, filterColumns, buildEmptyFilter, addFilter, updateFilter, removeFilter } }