{
  "$schema": "https://ui.shadcn.com/schema/registry-item.json",
  "name": "data-table-filter",
  "title": "Data Table Filter",
  "description": "Linear-style filter bar (text, option, multi-option, number, date and async options) that reads and writes the data table query.",
  "dependencies": [
    "date-fns",
    "react-day-picker",
    "lucide-react"
  ],
  "registryDependencies": [
    "https://dentil.dev/r/data-table.json?via=data-table-filter",
    "button",
    "calendar",
    "checkbox",
    "command",
    "input",
    "popover",
    "separator",
    "slider",
    "tabs"
  ],
  "files": [
    {
      "path": "components/dentil/data-table/filters.tsx",
      "content": "'use client';\n\nimport { useCallback, useEffect, useRef, useState } from 'react';\n\nimport { DataTableFilter, parseToFilters, parseToQuery, useDataTableFilters } from './filter';\nimport type { ColumnConfig, FiltersState } from './filter/core/types';\nimport { PAGE_KEYS, type TableQuery } from './types';\n\n/**\n * Server-side filter bar. Reads its state from `query` and writes filter values back into it, keeping\n * non-filter keys (tab, sort) and resetting the page (`offset`, `after`, `before`). Pass it as the table's `toolbar`.\n */\nexport function DataTableFilters<TData>({\n  data,\n  filterColumns,\n  query,\n  setQuery,\n}: {\n  data: TData[];\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  filterColumns: ReadonlyArray<ColumnConfig<TData, any, any, any>>;\n  query: TableQuery;\n  setQuery: (query: TableQuery) => void;\n}) {\n  const [filterState, setFilterState] = useState<FiltersState>(() => parseToFilters({ query, filterColumns }));\n\n  // Re-derive the filters when the query changes from outside (tabs, URL state, a reset). Done during render\n  // rather than in an effect so the UI never shows a frame of stale filters.\n  const [synced, setSynced] = useState({ query, filterColumns });\n  if (synced.query !== query || synced.filterColumns !== filterColumns) {\n    setSynced({ query, filterColumns });\n    setFilterState(parseToFilters({ query, filterColumns }));\n  }\n\n  // Keep the latest values in refs so `onFiltersChange` can stay referentially\n  // stable. If it changed identity each render, the downstream `actions` (memoised\n  // on the change handler) would too, which reset the filter inputs' debounce\n  // timers and dropped keystrokes while typing. The refs are written in an effect\n  // (after commit) to keep render pure; the handler only reads them from events.\n  const filterStateRef = useRef(filterState);\n  const queryRef = useRef(query);\n  const setQueryRef = useRef(setQuery);\n  const filterColumnsRef = useRef(filterColumns);\n  useEffect(() => {\n    filterStateRef.current = filterState;\n    queryRef.current = query;\n    setQueryRef.current = setQuery;\n    filterColumnsRef.current = filterColumns;\n  });\n\n  const handleFiltersChange = useCallback((newFilters: FiltersState | ((prev: FiltersState) => FiltersState)) => {\n    const nextFilters = typeof newFilters === 'function' ? newFilters(filterStateRef.current) : newFilters;\n    setFilterState(nextFilters);\n\n    const filterIds = new Set(filterColumnsRef.current.map((column) => column.id));\n    const preserved = Object.fromEntries(\n      Object.entries(queryRef.current).filter(([key]) => !filterIds.has(key) && !PAGE_KEYS.includes(key))\n    );\n    const newQuery = { ...preserved, ...parseToQuery(nextFilters, filterColumnsRef.current) };\n\n    if (JSON.stringify(newQuery) !== JSON.stringify(queryRef.current)) {\n      setQueryRef.current(newQuery);\n    }\n  }, []);\n\n  const { columns, filters, actions, strategy } = useDataTableFilters({\n    strategy: 'server',\n    data,\n    columnsConfig: filterColumns,\n    filters: filterState,\n    onFiltersChange: handleFiltersChange,\n  });\n\n  return <DataTableFilter filters={filters} columns={columns} actions={actions} strategy={strategy} />;\n}\n",
      "type": "registry:component",
      "target": "components/dentil/data-table/filters.tsx"
    },
    {
      "path": "components/dentil/data-table/filter/LICENSE.md",
      "content": "# The MIT License (MIT)\n\nThe files in this folder are adapted from bazza/ui (https://github.com/bazzalabs/ui).\n\nCopyright © 2025 Kian Bazarjani\n\nPermission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n",
      "type": "registry:file",
      "target": "components/dentil/data-table/filter/LICENSE.md"
    },
    {
      "path": "components/dentil/data-table/filter/components/active-filters.tsx",
      "content": "import { X } from 'lucide-react';\nimport { useEffect, useRef, useState } from 'react';\n\nimport { Button } from '@/components/ui/button';\nimport { Separator } from '@/components/ui/separator';\n\nimport type {\n  Column,\n  ColumnDataType,\n  DataTableFilterActions,\n  FilterModel,\n  FilterStrategy,\n  FiltersState,\n} from '../core/types';\nimport { getColumn } from '../lib/helpers';\nimport type { Locale } from '../lib/i18n';\nimport { FilterOperator } from './filter-operator';\nimport { FilterSubject } from './filter-subject';\nimport { FilterValue } from './filter-value';\n\ninterface ActiveFiltersProps<TData> {\n  columns: Column<TData>[];\n  filters: FiltersState;\n  actions: DataTableFilterActions;\n  strategy: FilterStrategy;\n  locale?: Locale;\n}\n\nexport function ActiveFilters<TData>({\n  columns,\n  filters,\n  actions,\n  strategy,\n  locale = 'en',\n}: ActiveFiltersProps<TData>) {\n  return (\n    <>\n      {filters.map((filter) => {\n        const id = filter.columnId;\n\n        const column = getColumn(columns, id);\n\n        // Skip if no filter value\n        if (!filter.values) return null;\n\n        return (\n          <ActiveFilter\n            key={`active-filter-${filter.columnId}`}\n            filter={filter}\n            column={column}\n            actions={actions}\n            strategy={strategy}\n            locale={locale}\n          />\n        );\n      })}\n    </>\n  );\n}\n\ninterface ActiveFilterProps<TData, TType extends ColumnDataType> {\n  filter: FilterModel<TType>;\n  column: Column<TData, TType>;\n  actions: DataTableFilterActions;\n  strategy: FilterStrategy;\n  locale?: Locale;\n}\n\n// Generic render function for a filter with type-safe value\nfunction ActiveFilter<TData, TType extends ColumnDataType>({\n  filter,\n  column,\n  actions,\n  strategy,\n  locale = 'en',\n}: ActiveFilterProps<TData, TType>) {\n  return (\n    <div className=\"bg-background flex h-7 items-center rounded-2xl border text-xs\">\n      <FilterSubject column={column} />\n      <Separator orientation=\"vertical\" />\n      <FilterOperator filter={filter} column={column} actions={actions} locale={locale} />\n      <Separator orientation=\"vertical\" />\n      <FilterValue filter={filter} column={column} actions={actions} strategy={strategy} locale={locale} />\n      <Separator orientation=\"vertical\" />\n      <Button\n        variant=\"ghost\"\n        className=\"h-full w-7 rounded-none rounded-r-2xl text-xs\"\n        onClick={() => actions.removeFilter(filter.columnId)}>\n        <X className=\"size-4 -translate-x-0.5\" />\n      </Button>\n    </div>\n  );\n}\n\nexport function ActiveFiltersMobileContainer({ children }: { children: React.ReactNode }) {\n  const scrollContainerRef = useRef<HTMLDivElement>(null);\n  const [showLeftBlur, setShowLeftBlur] = useState(false);\n  const [showRightBlur, setShowRightBlur] = useState(true);\n\n  // Check if there's content to scroll and update blur states\n  const checkScroll = () => {\n    if (scrollContainerRef.current) {\n      const { scrollLeft, scrollWidth, clientWidth } = scrollContainerRef.current;\n\n      // Show left blur if scrolled to the right\n      setShowLeftBlur(scrollLeft > 0);\n\n      // Show right blur if there's more content to scroll to the right\n      // Add a small buffer (1px) to account for rounding errors\n      setShowRightBlur(scrollLeft + clientWidth < scrollWidth - 1);\n    }\n  };\n\n  // Log blur states for debugging\n  // useEffect(() => {\n  //   console.log('left:', showLeftBlur, '  right:', showRightBlur)\n  // }, [showLeftBlur, showRightBlur])\n\n  // Set up ResizeObserver to monitor container size\n  // biome-ignore lint/correctness/useExhaustiveDependencies: <explanation>\n  useEffect(() => {\n    if (scrollContainerRef.current) {\n      const resizeObserver = new ResizeObserver(() => {\n        checkScroll();\n      });\n      resizeObserver.observe(scrollContainerRef.current);\n      return () => {\n        resizeObserver.disconnect();\n      };\n    }\n  }, []);\n\n  // Update blur states when children change\n  // biome-ignore lint/correctness/useExhaustiveDependencies: <explanation>\n  useEffect(() => {\n    checkScroll();\n  }, [children]);\n\n  return (\n    <div className=\"relative w-full overflow-x-hidden\">\n      {/* Left blur effect */}\n      {showLeftBlur && (\n        <div className=\"from-background animate-in fade-in-0 pointer-events-none absolute top-0 bottom-0 left-0 z-10 w-16 bg-gradient-to-r to-transparent\" />\n      )}\n\n      {/* Scrollable container */}\n      <div ref={scrollContainerRef} className=\"no-scrollbar flex gap-2 overflow-x-scroll\" onScroll={checkScroll}>\n        {children}\n      </div>\n\n      {/* Right blur effect */}\n      {showRightBlur && (\n        <div className=\"from-background animate-in fade-in-0 pointer-events-none absolute top-0 right-0 bottom-0 z-10 w-16 bg-gradient-to-l to-transparent\" />\n      )}\n    </div>\n  );\n}\n",
      "type": "registry:component",
      "target": "components/dentil/data-table/filter/components/active-filters.tsx"
    },
    {
      "path": "components/dentil/data-table/filter/components/data-table-filter.tsx",
      "content": "'use client';\n\nimport { useMediaQuery } from '../../hooks';\nimport type { Column, DataTableFilterActions, FilterStrategy, FiltersState } from '../core/types';\nimport type { Locale } from '../lib/i18n';\nimport { ActiveFilters, ActiveFiltersMobileContainer } from './active-filters';\nimport { FilterActions } from './filter-actions';\nimport { FilterSelector } from './filter-selector';\n\ninterface DataTableFilterProps<TData> {\n  columns: Column<TData>[];\n  filters: FiltersState;\n  actions: DataTableFilterActions;\n  strategy: FilterStrategy;\n  locale?: Locale;\n}\n\nexport function DataTableFilter<TData>({\n  columns,\n  filters,\n  actions,\n  strategy,\n  locale = 'en',\n}: DataTableFilterProps<TData>) {\n  const isMobile = useMediaQuery('(max-width: 767px)');\n  if (isMobile) {\n    return (\n      <div className=\"flex w-full items-start justify-between gap-2\">\n        <div className=\"flex gap-1\">\n          <FilterSelector columns={columns} filters={filters} actions={actions} strategy={strategy} locale={locale} />\n          <FilterActions hasFilters={filters.length > 0} actions={actions} locale={locale} />\n        </div>\n        <ActiveFiltersMobileContainer>\n          <ActiveFilters columns={columns} filters={filters} actions={actions} strategy={strategy} locale={locale} />\n        </ActiveFiltersMobileContainer>\n      </div>\n    );\n  }\n\n  return (\n    <div className=\"flex w-full items-start justify-between gap-2\">\n      <div className=\"flex w-full flex-1 gap-2 md:flex-wrap\">\n        <FilterSelector columns={columns} filters={filters} actions={actions} strategy={strategy} locale={locale} />\n        <ActiveFilters columns={columns} filters={filters} actions={actions} strategy={strategy} locale={locale} />\n      </div>\n      <FilterActions hasFilters={filters.length > 0} actions={actions} locale={locale} />\n    </div>\n  );\n}\n",
      "type": "registry:component",
      "target": "components/dentil/data-table/filter/components/data-table-filter.tsx"
    },
    {
      "path": "components/dentil/data-table/filter/components/filter-actions.tsx",
      "content": "import { FilterXIcon } from 'lucide-react';\nimport { memo } from 'react';\n\nimport { Button } from '@/components/ui/button';\nimport { cn } from '@/lib/utils';\n\nimport type { DataTableFilterActions } from '../core/types';\nimport { type Locale, t } from '../lib/i18n';\n\ninterface FilterActionsProps {\n  hasFilters: boolean;\n  actions?: DataTableFilterActions;\n  locale?: Locale;\n}\n\nexport const FilterActions = memo(__FilterActions);\nfunction __FilterActions({ hasFilters, actions, locale = 'en' }: FilterActionsProps) {\n  return (\n    <Button\n      className={cn('h-7 !px-2', !hasFilters && 'hidden')}\n      size=\"sm\"\n      variant=\"destructive\"\n      onClick={actions?.removeAllFilters}>\n      <FilterXIcon className=\"size-3\" />\n      <span className=\"hidden text-xs md:block\">{t('clear', locale)}</span>\n    </Button>\n  );\n}\n",
      "type": "registry:component",
      "target": "components/dentil/data-table/filter/components/filter-actions.tsx"
    },
    {
      "path": "components/dentil/data-table/filter/components/filter-operator.tsx",
      "content": "import { useState } from 'react';\n\nimport { Button } from '@/components/ui/button';\nimport { Command, CommandEmpty, CommandGroup, CommandInput, CommandItem, CommandList } from '@/components/ui/command';\nimport { Popover, PopoverContent, PopoverTrigger } from '@/components/ui/popover';\n\nimport {\n  dateFilterOperators,\n  filterTypeOperatorDetails,\n  multiOptionFilterOperators,\n  numberFilterOperators,\n  optionFilterOperators,\n  textFilterOperators,\n} from '../core/operators';\nimport type { Column, ColumnDataType, DataTableFilterActions, FilterModel, FilterOperators } from '../core/types';\nimport { type Locale, t } from '../lib/i18n';\n\ninterface FilterOperatorProps<TData, TType extends ColumnDataType> {\n  column: Column<TData, TType>;\n  filter: FilterModel<TType>;\n  actions: DataTableFilterActions;\n  locale?: Locale;\n}\n\n// Renders the filter operator display and menu for a given column filter\n// The filter operator display is the label and icon for the filter operator\n// The filter operator menu is the dropdown menu for the filter operator\nexport function FilterOperator<TData, TType extends ColumnDataType>({\n  column,\n  filter,\n  actions,\n  locale = 'en',\n}: FilterOperatorProps<TData, TType>) {\n  const [open, setOpen] = useState<boolean>(false);\n\n  const close = () => setOpen(false);\n\n  return (\n    <Popover open={open} onOpenChange={setOpen}>\n      <PopoverTrigger asChild>\n        <Button variant=\"ghost\" className=\"m-0 h-full w-fit rounded-none p-0 px-2 text-xs whitespace-nowrap\">\n          <FilterOperatorDisplay filter={filter} columnType={column.type} locale={locale} />\n        </Button>\n      </PopoverTrigger>\n      <PopoverContent align=\"start\" className=\"w-fit p-0\">\n        <Command loop>\n          <CommandInput placeholder={t('search', locale)} />\n          <CommandEmpty>{t('noresults', locale)}</CommandEmpty>\n          <CommandList className=\"max-h-fit\">\n            <FilterOperatorController\n              filter={filter}\n              column={column}\n              actions={actions}\n              closeController={close}\n              locale={locale}\n            />\n          </CommandList>\n        </Command>\n      </PopoverContent>\n    </Popover>\n  );\n}\n\ninterface FilterOperatorDisplayProps<TType extends ColumnDataType> {\n  filter: FilterModel<TType>;\n  columnType: TType;\n  locale?: Locale;\n}\n\nfunction FilterOperatorDisplay<TType extends ColumnDataType>({\n  filter,\n  columnType,\n  locale = 'en',\n}: FilterOperatorDisplayProps<TType>) {\n  const operator = filterTypeOperatorDetails[columnType][filter.operator];\n  const label = t(operator.key, locale);\n\n  return <span className=\"text-muted-foreground\">{label}</span>;\n}\n\ninterface FilterOperatorControllerProps<TData, TType extends ColumnDataType> {\n  filter: FilterModel<TType>;\n  column: Column<TData, TType>;\n  actions: DataTableFilterActions;\n  closeController: () => void;\n  locale?: Locale;\n}\n\n/*\n *\n * TODO: Reduce into a single component. Each data type does not need it's own controller.\n *\n */\nfunction FilterOperatorController<TData, TType extends ColumnDataType>({\n  filter,\n  column,\n  actions,\n  closeController,\n  locale = 'en',\n}: FilterOperatorControllerProps<TData, TType>) {\n  switch (column.type) {\n    case 'option':\n      return (\n        <FilterOperatorOptionController\n          filter={filter as FilterModel<'option'>}\n          column={column as Column<TData, 'option'>}\n          actions={actions}\n          closeController={closeController}\n          locale={locale}\n        />\n      );\n    case 'multiOption':\n      return (\n        <FilterOperatorMultiOptionController\n          filter={filter as FilterModel<'multiOption'>}\n          column={column as Column<TData, 'multiOption'>}\n          actions={actions}\n          closeController={closeController}\n          locale={locale}\n        />\n      );\n    case 'date':\n      return (\n        <FilterOperatorDateController\n          filter={filter as FilterModel<'date'>}\n          column={column as Column<TData, 'date'>}\n          actions={actions}\n          closeController={closeController}\n          locale={locale}\n        />\n      );\n    case 'text':\n      return (\n        <FilterOperatorTextController\n          filter={filter as FilterModel<'text'>}\n          column={column as Column<TData, 'text'>}\n          actions={actions}\n          closeController={closeController}\n          locale={locale}\n        />\n      );\n    case 'number':\n      return (\n        <FilterOperatorNumberController\n          filter={filter as FilterModel<'number'>}\n          column={column as Column<TData, 'number'>}\n          actions={actions}\n          closeController={closeController}\n          locale={locale}\n        />\n      );\n    default:\n      return null;\n  }\n}\n\nfunction FilterOperatorOptionController<TData>({\n  filter,\n  column,\n  actions,\n  closeController,\n  locale = 'en',\n}: FilterOperatorControllerProps<TData, 'option'>) {\n  const filterDetails = optionFilterOperators[filter.operator];\n\n  const relatedFilters = Object.values(optionFilterOperators).filter((o) => o.target === filterDetails.target);\n\n  const changeOperator = (value: string) => {\n    actions?.setFilterOperator(column.id, value as FilterOperators['option']);\n    closeController();\n  };\n\n  return (\n    <CommandGroup heading={t('operators', locale)}>\n      {relatedFilters.map((r) => {\n        return (\n          <CommandItem onSelect={changeOperator} value={r.value} key={r.value}>\n            {t(r.key, locale)}\n          </CommandItem>\n        );\n      })}\n    </CommandGroup>\n  );\n}\n\nfunction FilterOperatorMultiOptionController<TData>({\n  filter,\n  column,\n  actions,\n  closeController,\n  locale = 'en',\n}: FilterOperatorControllerProps<TData, 'multiOption'>) {\n  const filterDetails = multiOptionFilterOperators[filter.operator];\n\n  const relatedFilters = Object.values(multiOptionFilterOperators).filter((o) => o.target === filterDetails.target);\n\n  const changeOperator = (value: string) => {\n    actions?.setFilterOperator(column.id, value as FilterOperators['multiOption']);\n    closeController();\n  };\n\n  return (\n    <CommandGroup heading={t('operators', locale)}>\n      {relatedFilters.map((r) => {\n        return (\n          <CommandItem onSelect={changeOperator} value={r.value} key={r.value}>\n            {t(r.key, locale)}\n          </CommandItem>\n        );\n      })}\n    </CommandGroup>\n  );\n}\n\nfunction FilterOperatorDateController<TData>({\n  filter,\n  column,\n  actions,\n  closeController,\n  locale = 'en',\n}: FilterOperatorControllerProps<TData, 'date'>) {\n  const filterDetails = dateFilterOperators[filter.operator];\n\n  const relatedFilters = Object.values(dateFilterOperators).filter((o) => o.target === filterDetails.target);\n\n  const changeOperator = (value: string) => {\n    actions?.setFilterOperator(column.id, value as FilterOperators['date']);\n    closeController();\n  };\n\n  return (\n    <CommandGroup>\n      {relatedFilters.map((r) => {\n        return (\n          <CommandItem onSelect={changeOperator} value={r.value} key={r.value}>\n            {t(r.key, locale)}\n          </CommandItem>\n        );\n      })}\n    </CommandGroup>\n  );\n}\n\nfunction FilterOperatorTextController<TData>({\n  filter,\n  column,\n  actions,\n  closeController,\n  locale = 'en',\n}: FilterOperatorControllerProps<TData, 'text'>) {\n  const filterDetails = textFilterOperators[filter.operator];\n\n  const relatedFilters = Object.values(textFilterOperators).filter((o) => o.target === filterDetails.target);\n\n  const changeOperator = (value: string) => {\n    actions?.setFilterOperator(column.id, value as FilterOperators['text']);\n    closeController();\n  };\n\n  return (\n    <CommandGroup heading={t('operators', locale)}>\n      {relatedFilters.map((r) => {\n        return (\n          <CommandItem onSelect={changeOperator} value={r.value} key={r.value}>\n            {t(r.key, locale)}\n          </CommandItem>\n        );\n      })}\n    </CommandGroup>\n  );\n}\n\nfunction FilterOperatorNumberController<TData>({\n  filter,\n  column,\n  actions,\n  closeController,\n  locale = 'en',\n}: FilterOperatorControllerProps<TData, 'number'>) {\n  const filterDetails = numberFilterOperators[filter.operator];\n\n  const relatedFilters = Object.values(numberFilterOperators).filter((o) => o.target === filterDetails.target);\n\n  const changeOperator = (value: string) => {\n    actions?.setFilterOperator(column.id, value as FilterOperators['number']);\n    closeController();\n  };\n\n  return (\n    <div>\n      <CommandGroup heading={t('operators', locale)}>\n        {relatedFilters.map((r) => (\n          <CommandItem onSelect={() => changeOperator(r.value)} value={r.value} key={r.value}>\n            {t(r.key, locale)}\n          </CommandItem>\n        ))}\n      </CommandGroup>\n    </div>\n  );\n}\n",
      "type": "registry:component",
      "target": "components/dentil/data-table/filter/components/filter-operator.tsx"
    },
    {
      "path": "components/dentil/data-table/filter/components/filter-selector.tsx",
      "content": "import { ArrowRightIcon, ChevronRightIcon, ListFilter } from 'lucide-react';\nimport { isValidElement, memo, useCallback, useEffect, useMemo, useRef, useState } from 'react';\nimport React from 'react';\n\nimport { Button } from '@/components/ui/button';\nimport { Checkbox } from '@/components/ui/checkbox';\nimport { Command, CommandEmpty, CommandGroup, CommandInput, CommandItem, CommandList } from '@/components/ui/command';\nimport { Popover, PopoverContent, PopoverTrigger } from '@/components/ui/popover';\nimport { cn } from '@/lib/utils';\n\nimport type { Column, ColumnDataType, DataTableFilterActions, FilterStrategy, FiltersState } from '../core/types';\nimport { isAnyOf } from '../lib/array';\nimport { getColumn } from '../lib/helpers';\nimport { type Locale, t } from '../lib/i18n';\nimport { FilterValueController } from './filter-value';\n\ninterface FilterSelectorProps<TData> {\n  filters: FiltersState;\n  columns: Column<TData>[];\n  actions: DataTableFilterActions;\n  strategy: FilterStrategy;\n  locale?: Locale;\n}\n\nexport const FilterSelector = memo(FilterSelectorInner) as typeof FilterSelectorInner;\n\nfunction FilterSelectorInner<TData>({\n  filters,\n  columns,\n  actions,\n  strategy,\n  locale = 'en',\n}: FilterSelectorProps<TData>) {\n  const [open, setOpen] = useState(false);\n  const [value, setValue] = useState('');\n  const [property, setProperty] = useState<string | undefined>(undefined);\n  const inputRef = useRef<HTMLInputElement>(null);\n\n  const column = property ? getColumn(columns, property) : undefined;\n  const filter = property ? filters.find((f) => f.columnId === property) : undefined;\n\n  const hasFilters = filters.length > 0;\n\n  useEffect(() => {\n    if (property && inputRef) {\n      inputRef.current?.focus();\n      setValue('');\n    }\n  }, [property]);\n\n  useEffect(() => {\n    if (!open) {\n      const id = setTimeout(() => setValue(''), 150);\n      return () => clearTimeout(id);\n    }\n  }, [open]);\n\n  // biome-ignore lint/correctness/useExhaustiveDependencies: need filters to be updated\n  const content = useMemo(\n    () =>\n      property && column ? (\n        <FilterValueController\n          filter={filter!}\n          column={column as Column<TData, ColumnDataType>}\n          actions={actions}\n          strategy={strategy}\n          locale={locale}\n        />\n      ) : (\n        <Command\n          loop\n          filter={(value, search, keywords) => {\n            const extendValue = `${value} ${keywords?.join(' ')}`;\n            return extendValue.toLowerCase().includes(search.toLowerCase()) ? 1 : 0;\n          }}>\n          <CommandInput value={value} onValueChange={setValue} ref={inputRef} placeholder={t('search', locale)} />\n          <CommandEmpty>{t('noresults', locale)}</CommandEmpty>\n          <CommandList className=\"max-h-fit\">\n            <CommandGroup>\n              {columns.map((column) => (\n                <FilterableColumn key={column.id} column={column} setProperty={setProperty} />\n              ))}\n              <QuickSearchFilters\n                search={value}\n                filters={filters}\n                columns={columns}\n                actions={actions}\n                strategy={strategy}\n                locale={locale}\n              />\n            </CommandGroup>\n          </CommandList>\n        </Command>\n      ),\n    [property, column, filter, filters, columns, actions, value]\n  );\n\n  return (\n    <Popover\n      open={open}\n      onOpenChange={async (value) => {\n        setOpen(value);\n        if (!value) setTimeout(() => setProperty(undefined), 100);\n      }}>\n      <PopoverTrigger asChild>\n        <Button\n          variant=\"outline\"\n          size=\"sm\"\n          aria-label={t('filter', locale)}\n          className={cn('h-7 w-fit rounded-full !px-2', hasFilters && 'w-fit !px-2')}>\n          <ListFilter className=\"size-3\" />\n          {!hasFilters && <span className=\"text-xs\">{t('filter', locale)}</span>}\n        </Button>\n      </PopoverTrigger>\n      <PopoverContent\n        align=\"start\"\n        side=\"bottom\"\n        className=\"w-fit p-0\">\n        {content}\n      </PopoverContent>\n    </Popover>\n  );\n}\n\nfunction FilterableColumn<TData, TType extends ColumnDataType, TVal>({\n  column,\n  setProperty,\n}: {\n  column: Column<TData, TType, TVal>;\n  setProperty: (value: string) => void;\n}) {\n  const itemRef = useRef<HTMLDivElement>(null);\n\n  const prefetch = useCallback(() => {\n    column.prefetchOptions();\n    column.prefetchValues();\n    column.prefetchFacetedUniqueValues();\n    column.prefetchFacetedMinMaxValues();\n  }, [column]);\n\n  useEffect(() => {\n    const target = itemRef.current;\n\n    if (!target) return;\n\n    // Set up MutationObserver\n    const observer = new MutationObserver((mutations) => {\n      for (const mutation of mutations) {\n        if (mutation.type === 'attributes') {\n          const isSelected = target.getAttribute('data-selected') === 'true';\n          if (isSelected) prefetch();\n        }\n      }\n    });\n\n    // Set up observer\n    observer.observe(target, {\n      attributes: true,\n      attributeFilter: ['data-selected'],\n    });\n\n    // Cleanup on unmount\n    return () => observer.disconnect();\n  }, [prefetch]);\n\n  return (\n    <CommandItem\n      ref={itemRef}\n      value={column.id}\n      keywords={[column.displayName]}\n      onSelect={() => setProperty(column.id)}\n      className=\"group\"\n      onMouseEnter={prefetch}>\n      <div className=\"flex w-full items-center justify-between\">\n        <div className=\"inline-flex items-center gap-1.5\">\n          {<column.icon strokeWidth={2.25} className=\"size-4\" />}\n          <span>{column.displayName}</span>\n        </div>\n        <ArrowRightIcon className=\"size-4 opacity-0 group-aria-selected:opacity-100\" />\n      </div>\n    </CommandItem>\n  );\n}\n\ninterface QuickSearchFiltersProps<TData> {\n  search?: string;\n  filters: FiltersState;\n  columns: Column<TData>[];\n  actions: DataTableFilterActions;\n  strategy: FilterStrategy;\n  locale?: Locale;\n}\n\nconst QuickSearchFilters = memo(QuickSearchFiltersInner) as typeof QuickSearchFiltersInner;\n\nfunction QuickSearchFiltersInner<TData>({ search, filters, columns, actions }: QuickSearchFiltersProps<TData>) {\n  const cols = useMemo(\n    () => columns.filter((c) => isAnyOf<ColumnDataType>(c.type, ['option', 'multiOption'])),\n    [columns]\n  );\n\n  if (!search || search.trim().length < 2) return null;\n\n  return (\n    <>\n      {cols.map((column) => {\n        const filter = filters.find((f) => f.columnId === column.id);\n        const options = column.getOptions();\n        const optionsCount = column.getFacetedUniqueValues();\n\n        function handleOptionSelect(value: string, check: boolean) {\n          if (check) actions.addFilterValue(column, [value]);\n          else actions.removeFilterValue(column, [value]);\n        }\n\n        return (\n          <React.Fragment key={column.id}>\n            {options.map((v) => {\n              const checked = Boolean(filter?.values.includes(v.value));\n              const count = optionsCount?.get(v.value) ?? 0;\n\n              return (\n                <CommandItem\n                  key={v.value}\n                  value={v.value}\n                  keywords={[v.label, v.value]}\n                  onSelect={() => {\n                    handleOptionSelect(v.value, !checked);\n                  }}\n                  className=\"group\">\n                  <div className=\"group flex items-center gap-1.5\">\n                    <Checkbox\n                      checked={checked}\n                      className=\"dark:border-ring mr-1 opacity-0 group-data-[selected=true]:opacity-100 data-checked:opacity-100 data-[state=checked]:opacity-100\"\n                    />\n                    <div className=\"flex w-4 items-center justify-center\">\n                      {v.icon && (isValidElement(v.icon) ? v.icon : <v.icon className=\"text-primary size-4\" />)}\n                    </div>\n                    <div className=\"flex items-center gap-0.5\">\n                      <span className=\"text-muted-foreground\">{column.displayName}</span>\n                      <ChevronRightIcon className=\"text-muted-foreground/75 size-3.5\" />\n                      <span>\n                        {v.label}\n                        <sup\n                          className={cn(\n                            !optionsCount && 'hidden',\n                            'text-muted-foreground ml-0.5 tracking-tight tabular-nums',\n                            count === 0 && 'slashed-zero'\n                          )}>\n                          {count < 100 ? count : '100+'}\n                        </sup>\n                      </span>\n                    </div>\n                  </div>\n                </CommandItem>\n              );\n            })}\n          </React.Fragment>\n        );\n      })}\n    </>\n  );\n}\n",
      "type": "registry:component",
      "target": "components/dentil/data-table/filter/components/filter-selector.tsx"
    },
    {
      "path": "components/dentil/data-table/filter/components/filter-subject.tsx",
      "content": "import type { Column, ColumnDataType } from '../core/types';\n\ninterface FilterSubjectProps<TData, TType extends ColumnDataType> {\n  column: Column<TData, TType>;\n}\n\nexport function FilterSubject<TData, TType extends ColumnDataType>({ column }: FilterSubjectProps<TData, TType>) {\n  const hasIcon = !!column.icon;\n  return (\n    <span className=\"flex items-center gap-1 px-2 text-xs whitespace-nowrap select-none\">\n      {hasIcon && <column.icon className=\"size-3\" />}\n      <span>{column.displayName}</span>\n    </span>\n  );\n}\n",
      "type": "registry:component",
      "target": "components/dentil/data-table/filter/components/filter-subject.tsx"
    },
    {
      "path": "components/dentil/data-table/filter/components/filter-value.tsx",
      "content": "import { isEqual } from 'date-fns';\nimport { format } from 'date-fns';\nimport { Check, Ellipsis, Loader2 } from 'lucide-react';\nimport {\n  cloneElement,\n  isValidElement,\n  memo,\n  useCallback,\n  useEffect,\n  useMemo,\n  useRef,\n  useState,\n  type KeyboardEvent,\n} from 'react';\nimport type { DateRange } from 'react-day-picker';\n\nimport { Button } from '@/components/ui/button';\nimport { Calendar } from '@/components/ui/calendar';\nimport { Checkbox } from '@/components/ui/checkbox';\nimport {\n  Command,\n  CommandEmpty,\n  CommandGroup,\n  CommandInput,\n  CommandItem,\n  CommandList,\n  CommandSeparator,\n} from '@/components/ui/command';\nimport { Popover, PopoverContent, PopoverTrigger } from '@/components/ui/popover';\nimport { Slider } from '@/components/ui/slider';\nimport { Tabs, TabsContent, TabsList, TabsTrigger } from '@/components/ui/tabs';\nimport { cn } from '@/lib/utils';\n\nimport { numberFilterOperators } from '../core/operators';\nimport type {\n  Column,\n  ColumnDataType,\n  ColumnOption,\n  ColumnOptionExtended,\n  DataTableFilterActions,\n  FilterModel,\n  FilterStrategy,\n} from '../core/types';\nimport { useDebounceCallback } from '../hooks/use-debounce-callback';\nimport { take } from '../lib/array';\nimport { createNumberRange } from '../lib/helpers';\nimport { type Locale, t } from '../lib/i18n';\nimport { DebouncedInput } from '../ui/debounced-input';\n\n/** Cache of display labels for async option filters (columnId:valueId -> label), set when user selects in the filter. */\nconst asyncOptionLabelCache = new Map<string, string>();\n\nfunction getAsyncOptionLabel(columnId: string, valueId: string): string | undefined {\n  return asyncOptionLabelCache.get(`${columnId}:${valueId}`);\n}\n\nfunction setAsyncOptionLabel(columnId: string, valueId: string, label: string): void {\n  asyncOptionLabelCache.set(`${columnId}:${valueId}`, label);\n}\n\nfunction AsyncOptionLabel({\n  columnId,\n  value,\n  resolveLabel,\n}: {\n  columnId: string;\n  value: string;\n  resolveLabel?: (value: string) => Promise<string | undefined>;\n}) {\n  const cached = getAsyncOptionLabel(columnId, value);\n  const [resolved, setResolved] = useState<{ value: string; label: string } | null>(null);\n\n  useEffect(() => {\n    if (cached || !resolveLabel) return;\n    let cancelled = false;\n    resolveLabel(value)\n      .then((label) => {\n        if (cancelled || !label) return;\n        setAsyncOptionLabel(columnId, value, label);\n        setResolved({ value, label });\n      })\n      .catch(() => {});\n    return () => {\n      cancelled = true;\n    };\n  }, [cached, resolveLabel, columnId, value]);\n\n  const label = cached ?? (resolved?.value === value ? resolved.label : undefined);\n  return <span className=\"inline-flex min-w-0 truncate\">{label ?? value}</span>;\n}\n\ninterface FilterValueProps<TData, TType extends ColumnDataType> {\n  filter: FilterModel<TType>;\n  column: Column<TData, TType>;\n  actions: DataTableFilterActions;\n  strategy: FilterStrategy;\n  locale?: Locale;\n}\n\nexport const FilterValue = memo(__FilterValue) as typeof __FilterValue;\n\nfunction __FilterValue<TData, TType extends ColumnDataType>({\n  filter,\n  column,\n  actions,\n  strategy,\n  locale,\n}: FilterValueProps<TData, TType>) {\n  return (\n    <Popover>\n      <PopoverTrigger asChild>\n        <Button variant=\"ghost\" className=\"m-0 h-full w-fit rounded-none p-0 px-2 text-xs whitespace-nowrap\">\n          <FilterValueDisplay filter={filter} column={column} actions={actions} locale={locale} />\n        </Button>\n      </PopoverTrigger>\n      <PopoverContent align=\"start\" side=\"bottom\" sideOffset={4} className=\"w-fit p-0\">\n        <FilterValueController filter={filter} column={column} actions={actions} strategy={strategy} locale={locale} />\n      </PopoverContent>\n    </Popover>\n  );\n}\n\ninterface FilterValueDisplayProps<TData, TType extends ColumnDataType> {\n  filter: FilterModel<TType>;\n  column: Column<TData, TType>;\n  actions: DataTableFilterActions;\n  locale?: Locale;\n}\n\nfunction FilterValueDisplay<TData, TType extends ColumnDataType>({\n  filter,\n  column,\n  actions,\n  locale = 'en',\n}: FilterValueDisplayProps<TData, TType>) {\n  switch (column.type) {\n    case 'option':\n      return (\n        <FilterValueOptionDisplay\n          filter={filter as FilterModel<'option'>}\n          column={column as Column<TData, 'option'>}\n          actions={actions}\n          locale={locale}\n        />\n      );\n    case 'multiOption':\n      return (\n        <FilterValueMultiOptionDisplay\n          filter={filter as FilterModel<'multiOption'>}\n          column={column as Column<TData, 'multiOption'>}\n          actions={actions}\n          locale={locale}\n        />\n      );\n    case 'date':\n      return (\n        <FilterValueDateDisplay\n          filter={filter as FilterModel<'date'>}\n          column={column as Column<TData, 'date'>}\n          actions={actions}\n          locale={locale}\n        />\n      );\n    case 'text':\n      return (\n        <FilterValueTextDisplay\n          filter={filter as FilterModel<'text'>}\n          column={column as Column<TData, 'text'>}\n          actions={actions}\n          locale={locale}\n        />\n      );\n    case 'number':\n      return (\n        <FilterValueNumberDisplay\n          filter={filter as FilterModel<'number'>}\n          column={column as Column<TData, 'number'>}\n          actions={actions}\n          locale={locale}\n        />\n      );\n    default:\n      return null;\n  }\n}\n\nfunction FilterValueOptionDisplay<TData>({ filter, column }: FilterValueDisplayProps<TData, 'option'>) {\n  const options = useMemo(() => column.getOptions(), [column]);\n  const selected = options.filter((o) => filter?.values.includes(o.value));\n\n  // We display the selected options based on how many are selected\n  //\n  // If there is only one option selected, we display its icon and label\n  //\n  // If there are multiple options selected, we display:\n  // 1) up to 3 icons of the selected options\n  // 2) the number of selected options\n  if (selected.length === 1) {\n    const selectedOption = selected[0];\n    if (!selectedOption) return null;\n    const { label, icon: Icon } = selectedOption;\n    const hasIcon = !!Icon;\n    return (\n      <span className=\"inline-flex items-center gap-1\">\n        {hasIcon && (isValidElement(Icon) ? Icon : <Icon className=\"text-primary size-3\" />)}\n        <span>{label}</span>\n      </span>\n    );\n  }\n\n  if (selected.length === 0 && filter.values.length === 1 && filter.values[0]) {\n    const rawValue = filter.values[0];\n    if (column.asyncOptions) {\n      return <AsyncOptionLabel columnId={column.id} value={rawValue} resolveLabel={column.asyncOptions.resolveLabel} />;\n    }\n    return <span>{rawValue}</span>;\n  }\n\n  const name = column.displayName.toLowerCase();\n  // TODO: Better pluralization for different languages\n  const pluralName = name.endsWith('s') ? `${name}es` : `${name}s`;\n\n  const hasOptionIcons = !options?.some((o) => !o.icon);\n\n  return (\n    <div className=\"inline-flex items-center gap-0.5\">\n      {hasOptionIcons &&\n        take(selected, 3).map(({ value, icon }) => {\n          const Icon = icon!;\n          return isValidElement(Icon) ? Icon : <Icon key={value} className=\"size-3\" />;\n        })}\n      <span className={cn(hasOptionIcons && 'ml-1.5')}>\n        {selected.length} {pluralName}\n      </span>\n    </div>\n  );\n}\n\nfunction FilterValueMultiOptionDisplay<TData>({ filter, column }: FilterValueDisplayProps<TData, 'multiOption'>) {\n  const options = useMemo(() => column.getOptions(), [column]);\n  const selected = options.filter((o) => filter.values.includes(o.value));\n\n  if (selected.length === 1) {\n    const selectedOption = selected[0];\n    if (!selectedOption) return null;\n    const { label, icon: Icon } = selectedOption;\n    const hasIcon = !!Icon;\n    return (\n      <span className=\"inline-flex items-center gap-1.5\">\n        {hasIcon && (isValidElement(Icon) ? Icon : <Icon className=\"text-primary size-3\" />)}\n\n        <span>{label}</span>\n      </span>\n    );\n  }\n\n  const name = column.displayName.toLowerCase();\n\n  const hasOptionIcons = !options?.some((o) => !o.icon);\n\n  return (\n    <div className=\"inline-flex items-center gap-1.5\">\n      {hasOptionIcons && (\n        <div key=\"icons\" className=\"inline-flex items-center gap-0.5\">\n          {take(selected, 3).map(({ value, icon }) => {\n            const Icon = icon!;\n            return isValidElement(Icon) ? cloneElement(Icon, { key: value }) : <Icon key={value} className=\"size-3\" />;\n          })}\n        </div>\n      )}\n      <span>\n        {selected.length} {name}\n      </span>\n    </div>\n  );\n}\n\nfunction formatDateRange(start: Date, end: Date) {\n  const sameMonth = start.getMonth() === end.getMonth();\n  const sameYear = start.getFullYear() === end.getFullYear();\n\n  if (sameMonth && sameYear) {\n    return `${format(start, 'MMM d')} - ${format(end, 'd, yyyy')}`;\n  }\n\n  if (sameYear) {\n    return `${format(start, 'MMM d')} - ${format(end, 'MMM d, yyyy')}`;\n  }\n\n  return `${format(start, 'MMM d, yyyy')} - ${format(end, 'MMM d, yyyy')}`;\n}\n\nfunction FilterValueDateDisplay<TData>({ filter }: FilterValueDisplayProps<TData, 'date'>) {\n  if (!filter) return null;\n  if (filter.values.length === 0) return <Ellipsis className=\"size-4\" />;\n  if (filter.values.length === 1) {\n    const value = filter.values[0];\n    if (!value) return <Ellipsis className=\"size-4\" />;\n\n    const formattedDateStr = format(value, 'MMM d, yyyy');\n\n    return <span>{formattedDateStr}</span>;\n  }\n\n  const startDate = filter.values[0];\n  const endDate = filter.values[1];\n  if (!startDate || !endDate) return <Ellipsis className=\"size-4\" />;\n\n  const formattedRangeStr = formatDateRange(startDate, endDate);\n\n  return <span>{formattedRangeStr}</span>;\n}\n\nfunction FilterValueTextDisplay<TData>({ filter }: FilterValueDisplayProps<TData, 'text'>) {\n  if (!filter) return null;\n  if (filter.values.length === 0 || !filter.values[0] || filter.values[0].trim() === '')\n    return <Ellipsis className=\"size-4\" />;\n\n  const value = filter.values[0];\n\n  return <span>{value}</span>;\n}\n\nfunction formatScaledNumber(value: number | undefined, scale?: number): string {\n  if (value === undefined) return '';\n  if (typeof scale === 'number' && scale > 1) {\n    const decimals = Math.log10(scale);\n    if (Number.isInteger(decimals) && decimals > 0 && decimals <= 4) {\n      return value.toFixed(decimals);\n    }\n  }\n  return String(value);\n}\n\nfunction FilterValueNumberDisplay<TData>({ filter, column, locale = 'en' }: FilterValueDisplayProps<TData, 'number'>) {\n  if (!filter || !filter.values || filter.values.length === 0) return null;\n\n  if (filter.operator === 'is between' || filter.operator === 'is not between') {\n    const minValue = filter.values[0];\n    const maxValue = filter.values[1];\n\n    return (\n      <span className=\"tracking-tight tabular-nums\">\n        {formatScaledNumber(minValue, column.scale)} {t('and', locale)} {formatScaledNumber(maxValue, column.scale)}\n      </span>\n    );\n  }\n\n  const value = filter.values[0];\n  return <span className=\"tracking-tight tabular-nums\">{formatScaledNumber(value, column.scale)}</span>;\n}\n\n/****** Property Filter Value Controller ******/\n\ninterface FilterValueControllerProps<TData, TType extends ColumnDataType> {\n  filter: FilterModel<TType>;\n  column: Column<TData, TType>;\n  actions: DataTableFilterActions;\n  strategy: FilterStrategy;\n  locale?: Locale;\n}\n\nexport const FilterValueController = memo(__FilterValueController) as typeof __FilterValueController;\n\nfunction __FilterValueController<TData, TType extends ColumnDataType>({\n  filter,\n  column,\n  actions,\n  strategy,\n  locale = 'en',\n}: FilterValueControllerProps<TData, TType>) {\n  switch (column.type) {\n    case 'option':\n      return (\n        <FilterValueOptionController\n          filter={filter as FilterModel<'option'>}\n          column={column as Column<TData, 'option'>}\n          actions={actions}\n          strategy={strategy}\n          locale={locale}\n        />\n      );\n    case 'multiOption':\n      return (\n        <FilterValueMultiOptionController\n          filter={filter as FilterModel<'multiOption'>}\n          column={column as Column<TData, 'multiOption'>}\n          actions={actions}\n          strategy={strategy}\n          locale={locale}\n        />\n      );\n    case 'date':\n      return (\n        <FilterValueDateController\n          filter={filter as FilterModel<'date'>}\n          column={column as Column<TData, 'date'>}\n          actions={actions}\n          strategy={strategy}\n          locale={locale}\n        />\n      );\n    case 'text':\n      return (\n        <FilterValueTextController\n          filter={filter as FilterModel<'text'>}\n          column={column as Column<TData, 'text'>}\n          actions={actions}\n          strategy={strategy}\n          locale={locale}\n        />\n      );\n    case 'number':\n      return (\n        <FilterValueNumberController\n          filter={filter as FilterModel<'number'>}\n          column={column as Column<TData, 'number'>}\n          actions={actions}\n          strategy={strategy}\n          locale={locale}\n        />\n      );\n    default:\n      return null;\n  }\n}\n\ninterface OptionItemProps {\n  option: ColumnOptionExtended & { initialSelected: boolean };\n  onToggle: (value: string, checked: boolean) => void;\n}\n\n// Memoized option item to prevent re-renders unless its own props change\nconst OptionItem = memo(function OptionItem({ option, onToggle }: OptionItemProps) {\n  const { value, label, icon: Icon, selected } = option;\n  const handleSelect = useCallback(() => {\n    onToggle(value, !selected);\n  }, [onToggle, value, selected]);\n\n  return (\n    <CommandItem key={value} onSelect={handleSelect} className=\"group flex items-center justify-between gap-1.5\">\n      <div className=\"flex items-center gap-1.5\">\n        <Checkbox\n          checked={selected}\n          className=\"dark:border-ring mr-1 opacity-0 group-data-[selected=true]:opacity-100 data-checked:opacity-100 data-[state=checked]:opacity-100\"\n        />\n        {Icon && (isValidElement(Icon) ? Icon : <Icon className=\"text-primary size-3\" />)}\n        <span>{label}</span>\n      </div>\n    </CommandItem>\n  );\n});\n\nfunction FilterValueOptionAsyncController<TData>({\n  filter,\n  column,\n  actions,\n  locale = 'en',\n}: FilterValueControllerProps<TData, 'option'>) {\n  const { fetchOptions, debounceMs = 300 } = column.asyncOptions!;\n  const [search, setSearch] = useState('');\n  const [options, setOptions] = useState<ColumnOption[]>([]);\n  const [loading, setLoading] = useState(true);\n  const [error, setError] = useState<string | null>(null);\n  const latestRequest = useRef(0);\n  const selectedValues = filter?.values ?? [];\n\n  const load = useCallback(\n    async (term: string) => {\n      const request = ++latestRequest.current;\n      setLoading(true);\n      setError(null);\n      try {\n        const result = await fetchOptions(term);\n        // Ignore responses that arrive after a newer search has started.\n        if (request === latestRequest.current) setOptions(result);\n      } catch (err) {\n        if (request === latestRequest.current) setError(err instanceof Error ? err.message : 'Failed to load options');\n      } finally {\n        if (request === latestRequest.current) setLoading(false);\n      }\n    },\n    [fetchOptions]\n  );\n\n  const debouncedLoad = useDebounceCallback(load, debounceMs);\n\n  useEffect(() => {\n    void load('');\n  }, [load]);\n\n  const handleSelect = (option: ColumnOption) => {\n    setAsyncOptionLabel(column.id, option.value, option.label);\n    const isSelected = selectedValues.includes(option.value);\n    if (column.allowMultiple) {\n      if (isSelected) actions.removeFilterValue(column, [option.value]);\n      else actions.addFilterValue(column, [option.value]);\n    } else {\n      actions.setFilterValue(column, isSelected ? [] : [option.value]);\n    }\n  };\n\n  return (\n    <Command shouldFilter={false} className=\"w-[280px]\">\n      <CommandInput\n        autoFocus\n        placeholder={t('search', locale)}\n        value={search}\n        onValueChange={(value) => {\n          setSearch(value);\n          debouncedLoad(value);\n        }}\n      />\n      <CommandList>\n        {error ? (\n          <div className=\"text-destructive p-4 text-center text-sm\">{error}</div>\n        ) : loading && options.length === 0 ? (\n          <div className=\"flex justify-center p-4\">\n            <Loader2 className=\"text-muted-foreground size-4 animate-spin\" />\n          </div>\n        ) : (\n          <CommandEmpty>{t('noresults', locale)}</CommandEmpty>\n        )}\n        <CommandGroup>\n          {options.map((option) => {\n            const Icon = option.icon;\n            const selected = selectedValues.includes(option.value);\n            return (\n              <CommandItem\n                key={option.value}\n                value={option.value}\n                onSelect={() => handleSelect(option)}\n                className=\"flex items-center gap-1.5\">\n                {Icon && (isValidElement(Icon) ? Icon : <Icon className=\"text-primary size-3\" />)}\n                <span className=\"truncate\">{option.label}</span>\n                <Check className={cn('ml-auto size-3', selected ? 'opacity-100' : 'opacity-0')} />\n              </CommandItem>\n            );\n          })}\n        </CommandGroup>\n      </CommandList>\n    </Command>\n  );\n}\n\nfunction FilterValueOptionSyncController<TData>({\n  filter,\n  column,\n  actions,\n  locale = 'en',\n}: FilterValueControllerProps<TData, 'option'>) {\n  // Compute initial options once per mount\n  const initialOptions = useMemo(() => {\n    const counts = column.getFacetedUniqueValues();\n    return column.getOptions().map((o) => ({\n      ...o,\n      selected: filter?.values.includes(o.value),\n      initialSelected: filter?.values.includes(o.value),\n      count: counts?.get(o.value) ?? 0,\n    }));\n  }, []);\n\n  const [options, setOptions] = useState(initialOptions);\n\n  // Update selected state when filter values change\n  useEffect(() => {\n    setOptions((prev) => prev.map((o) => ({ ...o, selected: filter?.values.includes(o.value) })));\n  }, [filter?.values]);\n\n  const handleToggle = useCallback(\n    (value: string, checked: boolean) => {\n      if (checked) {\n        // Check if multiple selection is allowed for this column\n        if (column.allowMultiple) {\n          actions.addFilterValue(column, [value]);\n        } else {\n          // Single selection: replace the current value\n          actions.setFilterValue(column, [value]);\n        }\n      } else {\n        actions.removeFilterValue(column, [value]);\n      }\n    },\n    [actions, column]\n  );\n\n  // Derive groups based on `initialSelected` only\n  const { selectedOptions, unselectedOptions } = useMemo(() => {\n    const sel: typeof options = [];\n    const unsel: typeof options = [];\n    for (const o of options) {\n      if (o.initialSelected) sel.push(o);\n      else unsel.push(o);\n    }\n    return { selectedOptions: sel, unselectedOptions: unsel };\n  }, [options]);\n\n  return (\n    <Command loop>\n      <CommandInput autoFocus placeholder={t('search', locale)} />\n      <CommandEmpty>{t('noresults', locale)}</CommandEmpty>\n      <CommandList className=\"max-h-fit\">\n        <CommandGroup className={cn(selectedOptions.length === 0 && 'hidden')}>\n          {selectedOptions.map((option) => (\n            <OptionItem key={option.value} option={option} onToggle={handleToggle} />\n          ))}\n        </CommandGroup>\n        <CommandSeparator />\n        <CommandGroup className={cn(unselectedOptions.length === 0 && 'hidden')}>\n          {unselectedOptions.map((option) => (\n            <OptionItem key={option.value} option={option} onToggle={handleToggle} />\n          ))}\n        </CommandGroup>\n      </CommandList>\n    </Command>\n  );\n}\n\nfunction FilterValueOptionController<TData>(props: FilterValueControllerProps<TData, 'option'>) {\n  if (props.column.asyncOptions) return <FilterValueOptionAsyncController {...props} />;\n  return <FilterValueOptionSyncController {...props} />;\n}\n\nfunction FilterValueMultiOptionController<TData>({\n  filter,\n  column,\n  actions,\n  locale = 'en',\n}: FilterValueControllerProps<TData, 'multiOption'>) {\n  // Compute initial options once per mount\n  const initialOptions = useMemo(() => {\n    const counts = column.getFacetedUniqueValues();\n    return column.getOptions().map((o) => {\n      const selected = filter?.values.includes(o.value);\n      return {\n        ...o,\n        selected,\n        initialSelected: selected,\n        count: counts?.get(o.value) ?? 0,\n      };\n    });\n  }, []);\n\n  const [options, setOptions] = useState(initialOptions);\n\n  // Update selected state when filter values change\n  useEffect(() => {\n    setOptions((prev) => prev.map((o) => ({ ...o, selected: filter?.values.includes(o.value) })));\n  }, [filter?.values]);\n\n  const handleToggle = useCallback(\n    (value: string, checked: boolean) => {\n      if (checked) actions.addFilterValue(column, [value]);\n      else actions.removeFilterValue(column, [value]);\n    },\n    [actions, column]\n  );\n\n  // Derive groups based on `initialSelected` only\n  const { selectedOptions, unselectedOptions } = useMemo(() => {\n    const sel: typeof options = [];\n    const unsel: typeof options = [];\n    for (const o of options) {\n      if (o.initialSelected) sel.push(o);\n      else unsel.push(o);\n    }\n    return { selectedOptions: sel, unselectedOptions: unsel };\n  }, [options]);\n\n  return (\n    <Command loop>\n      <CommandInput autoFocus placeholder={t('search', locale)} />\n      <CommandEmpty>{t('noresults', locale)}</CommandEmpty>\n      <CommandList>\n        <CommandGroup className={cn(selectedOptions.length === 0 && 'hidden')}>\n          {selectedOptions.map((option) => (\n            <OptionItem key={option.value} option={option} onToggle={handleToggle} />\n          ))}\n        </CommandGroup>\n        <CommandSeparator />\n        <CommandGroup className={cn(unselectedOptions.length === 0 && 'hidden')}>\n          {unselectedOptions.map((option) => (\n            <OptionItem key={option.value} option={option} onToggle={handleToggle} />\n          ))}\n        </CommandGroup>\n      </CommandList>\n    </Command>\n  );\n}\n\nfunction FilterValueDateController<TData>({ filter, column, actions }: FilterValueControllerProps<TData, 'date'>) {\n  const [date, setDate] = useState<DateRange | undefined>({\n    from: filter?.values[0] ?? new Date(),\n    to: filter?.values[1] ?? undefined,\n  });\n\n  function changeDateRange(value: DateRange | undefined) {\n    const start = value?.from;\n    const end = start && value && value.to && !isEqual(start, value.to) ? value.to : undefined;\n\n    setDate({ from: start, to: end });\n\n    const isRange = start && end;\n    const newValues = isRange ? [start, end] : start ? [start] : [];\n\n    actions.setFilterValue(column, newValues);\n  }\n\n  return (\n    <Command>\n      <CommandList className=\"max-h-fit\">\n        <CommandGroup>\n          <div>\n            <Calendar\n              autoFocus\n              mode=\"range\"\n              defaultMonth={date?.from}\n              selected={date}\n              onSelect={changeDateRange}\n              numberOfMonths={1}\n            />\n          </div>\n        </CommandGroup>\n      </CommandList>\n    </Command>\n  );\n}\n\nfunction FilterValueTextController<TData>({\n  filter,\n  column,\n  actions,\n  locale = 'en',\n}: FilterValueControllerProps<TData, 'text'>) {\n  const changeText = (value: string | number) => {\n    actions.setFilterValue(column, [String(value)]);\n  };\n\n  return (\n    <Command>\n      <CommandList className=\"max-h-fit\">\n        <CommandGroup>\n          <CommandItem>\n            <DebouncedInput\n              placeholder={t('search', locale)}\n              autoFocus\n              value={filter?.values[0] ?? ''}\n              onChange={changeText}\n            />\n          </CommandItem>\n        </CommandGroup>\n      </CommandList>\n    </Command>\n  );\n}\n\nfunction FilterValueNumberController<TData>({\n  filter,\n  column,\n  actions,\n  locale = 'en',\n}: FilterValueControllerProps<TData, 'number'>) {\n  const minMax = useMemo(() => column.getFacetedMinMaxValues(), [column]);\n  const [sliderMin, sliderMax] = [minMax ? minMax[0] : 0, minMax ? minMax[1] : 0];\n  const step = typeof column.scale === 'number' && column.scale > 1 ? 1 / column.scale : 1;\n\n  // Local state for values\n  const [values, setValues] = useState(filter?.values ?? [0, 0]);\n\n  // Sync with parent filter changes\n  useEffect(() => {\n    if (filter?.values && filter.values.length === values.length && filter.values.every((v, i) => v === values[i])) {\n      setValues(filter.values);\n    }\n  }, [filter?.values, values]);\n\n  const isNumberRange =\n    // filter && values.length === 2\n    filter && numberFilterOperators[filter.operator].target === 'multiple';\n\n  // Only the slider goes through these. The inputs are already debounced by DebouncedInput.\n  const setFilterOperatorDebounced = useDebounceCallback(actions.setFilterOperator, 300);\n  const setFilterValueDebounced = useDebounceCallback(actions.setFilterValue, 300);\n\n  const parseNumberInput = (raw: string | number) => {\n    const next = Number(raw);\n    return Number.isFinite(next) ? next : 0;\n  };\n\n  const applySingle = (raw: string | number) => {\n    setFilterValueDebounced.cancel();\n    const newValues = [parseNumberInput(raw)];\n    setValues(newValues);\n    actions.setFilterValue(column, newValues);\n  };\n\n  const applyRangeBound = (index: 0 | 1, raw: string | number) => {\n    setFilterValueDebounced.cancel();\n    const parsed = parseNumberInput(raw);\n    const newValues = createNumberRange(index === 0 ? [parsed, values[1] ?? 0] : [values[0] ?? 0, parsed]);\n    setValues(newValues);\n    actions.setFilterValue(column, newValues);\n  };\n\n  // Radix sliders pass `number[]`; Base UI sliders pass `number | readonly number[]`.\n  const changeNumber = (next: number | readonly number[]) => {\n    const value = Array.isArray(next) ? [...next] : [next as number];\n    setValues(value);\n    setFilterValueDebounced(column as any, value);\n  };\n\n  const onEnter = (apply: (raw: string) => void) => (event: KeyboardEvent<HTMLInputElement>) => {\n    if (event.key !== 'Enter') return;\n    event.preventDefault();\n    event.stopPropagation();\n    apply(event.currentTarget.value);\n  };\n\n  const changeType = useCallback(\n    (type: 'single' | 'range') => {\n      let newValues: number[] = [];\n      if (type === 'single') {\n        const firstValue = values[0] ?? 0;\n        newValues = [firstValue]; // Keep the first value for single mode\n      } else if (!minMax) {\n        const firstValue = values[0] ?? 0;\n        const secondValue = values[1] ?? 0;\n        newValues = createNumberRange([firstValue, secondValue]);\n      } else {\n        const value = values[0] ?? 0;\n        newValues =\n          value - minMax[0] < minMax[1] - value\n            ? createNumberRange([value, minMax[1]])\n            : createNumberRange([minMax[0], value]);\n      }\n\n      const newOperator = type === 'single' ? 'is' : 'is between';\n\n      // Update local state\n      setValues(newValues);\n\n      // Cancel in-flight debounced calls to prevent flicker/race conditions\n      setFilterOperatorDebounced.cancel();\n      setFilterValueDebounced.cancel();\n\n      // Update global filter state atomically\n      actions.setFilterOperator(column.id, newOperator);\n      actions.setFilterValue(column, newValues);\n    },\n    [values, column, actions, minMax]\n  );\n\n  return (\n    <Command>\n      <CommandList className=\"w-[300px] p-2\">\n        <CommandGroup>\n          <div className=\"flex w-full flex-col\">\n            <Tabs value={isNumberRange ? 'range' : 'single'} onValueChange={(v) => changeType(v as 'single' | 'range')}>\n              <TabsList className=\"w-full *:text-xs\">\n                <TabsTrigger value=\"single\">{t('single', locale)}</TabsTrigger>\n                <TabsTrigger value=\"range\">{t('range', locale)}</TabsTrigger>\n              </TabsList>\n              <TabsContent value=\"single\" className=\"mt-4 flex flex-col gap-4\">\n                {minMax && (\n                  <Slider\n                    value={[values[0] ?? 0]}\n                    onValueChange={changeNumber}\n                    min={sliderMin}\n                    max={sliderMax}\n                    step={step}\n                    aria-orientation=\"horizontal\"\n                  />\n                )}\n                <div className=\"flex items-center gap-2\">\n                  <span className=\"text-xs font-medium\">{t('value', locale)}</span>\n                  <DebouncedInput\n                    id=\"single\"\n                    type=\"number\"\n                    step={step}\n                    value={(values[0] ?? 0).toString()} // Use values[0] directly\n                    onChange={applySingle}\n                    onKeyDown={onEnter(applySingle)}\n                  />\n                </div>\n              </TabsContent>\n              <TabsContent value=\"range\" className=\"mt-4 flex flex-col gap-4\">\n                {minMax && (\n                  <Slider\n                    value={values} // Use values directly\n                    onValueChange={changeNumber}\n                    min={sliderMin}\n                    max={sliderMax}\n                    step={step}\n                    aria-orientation=\"horizontal\"\n                  />\n                )}\n                <div className=\"grid grid-cols-2 gap-4\">\n                  <div className=\"flex items-center gap-2\">\n                    <span className=\"text-xs font-medium\">{t('min', locale)}</span>\n                    <DebouncedInput\n                      type=\"number\"\n                      step={step}\n                      value={values[0] ?? 0}\n                      onChange={(v) => applyRangeBound(0, v)}\n                      onKeyDown={onEnter((raw) => applyRangeBound(0, raw))}\n                    />\n                  </div>\n                  <div className=\"flex items-center gap-2\">\n                    <span className=\"text-xs font-medium\">{t('max', locale)}</span>\n                    <DebouncedInput\n                      type=\"number\"\n                      step={step}\n                      value={values[1] ?? 0}\n                      onChange={(v) => applyRangeBound(1, v)}\n                      onKeyDown={onEnter((raw) => applyRangeBound(1, raw))}\n                    />\n                  </div>\n                </div>\n              </TabsContent>\n            </Tabs>\n          </div>\n        </CommandGroup>\n      </CommandList>\n    </Command>\n  );\n}\n",
      "type": "registry:component",
      "target": "components/dentil/data-table/filter/components/filter-value.tsx"
    },
    {
      "path": "components/dentil/data-table/filter/core/filters.ts",
      "content": "import { isAnyOf, uniq } from '../lib/array';\nimport { isColumnOptionArray } from '../lib/helpers';\nimport { memo } from '../lib/memo';\nimport type {\n  AsyncOptionConfig,\n  Column,\n  ColumnConfig,\n  ColumnDataType,\n  ColumnOption,\n  ElementType,\n  FilterStrategy,\n  Nullable,\n  TAccessorFn,\n  TOrderFn,\n  TTransformOptionFn,\n} from './types';\n\nclass ColumnConfigBuilder<\n  TData,\n  TType extends ColumnDataType = any,\n  TVal = unknown,\n  TId extends string = string, // Add TId generic\n> {\n  private config: Partial<ColumnConfig<TData, TType, TVal, TId>>;\n\n  constructor(type: TType) {\n    this.config = { type } as Partial<ColumnConfig<TData, TType, TVal, TId>>;\n  }\n\n  private clone(): ColumnConfigBuilder<TData, TType, TVal, TId> {\n    const newInstance = new ColumnConfigBuilder<TData, TType, TVal, TId>(this.config.type as TType);\n    newInstance.config = { ...this.config };\n    return newInstance;\n  }\n\n  id<TNewId extends string>(value: TNewId): ColumnConfigBuilder<TData, TType, TVal, TNewId> {\n    const newInstance = this.clone() as any; // We'll refine this\n    newInstance.config.id = value;\n    return newInstance as ColumnConfigBuilder<TData, TType, TVal, TNewId>;\n  }\n\n  accessor<TNewVal>(accessor: TAccessorFn<TData, TNewVal>): ColumnConfigBuilder<TData, TType, TNewVal, TId> {\n    const newInstance = this.clone() as any;\n    newInstance.config.accessor = accessor;\n    return newInstance as ColumnConfigBuilder<TData, TType, TNewVal, TId>;\n  }\n\n  displayName(value: string): ColumnConfigBuilder<TData, TType, TVal, TId> {\n    const newInstance = this.clone();\n    newInstance.config.displayName = value;\n    return newInstance;\n  }\n\n  icon(value: any): ColumnConfigBuilder<TData, TType, TVal, TId> {\n    const newInstance = this.clone();\n    newInstance.config.icon = value;\n    return newInstance;\n  }\n\n  min(value: number): ColumnConfigBuilder<TData, TType extends 'number' ? TType : never, TVal, TId> {\n    if (this.config.type !== 'number') {\n      throw new Error('min() is only applicable to number columns');\n    }\n    const newInstance = this.clone() as any;\n    newInstance.config.min = value;\n    return newInstance;\n  }\n\n  max(value: number): ColumnConfigBuilder<TData, TType extends 'number' ? TType : never, TVal, TId> {\n    if (this.config.type !== 'number') {\n      throw new Error('max() is only applicable to number columns');\n    }\n    const newInstance = this.clone() as any;\n    newInstance.config.max = value;\n    return newInstance;\n  }\n\n  scale(value: number): ColumnConfigBuilder<TData, TType extends 'number' ? TType : never, TVal, TId> {\n    if (this.config.type !== 'number') {\n      throw new Error('scale() is only applicable to number columns');\n    }\n    if (!Number.isFinite(value) || value <= 0) {\n      throw new Error('scale() must be a positive finite number');\n    }\n    const newInstance = this.clone() as any;\n    newInstance.config.scale = value;\n    return newInstance;\n  }\n\n  options(\n    value: ColumnOption[]\n  ): ColumnConfigBuilder<TData, TType extends 'option' | 'multiOption' ? TType : never, TVal, TId> {\n    if (!isAnyOf(this.config.type, ['option', 'multiOption'])) {\n      throw new Error('options() is only applicable to option or multiOption columns');\n    }\n    const newInstance = this.clone() as any;\n    newInstance.config.options = value;\n    return newInstance;\n  }\n\n  asyncOptions(\n    value: AsyncOptionConfig\n  ): ColumnConfigBuilder<TData, TType extends 'option' | 'multiOption' ? TType : never, TVal, TId> {\n    if (!isAnyOf(this.config.type, ['option', 'multiOption'])) {\n      throw new Error('asyncOptions() is only applicable to option or multiOption columns');\n    }\n    const newInstance = this.clone() as any;\n    newInstance.config.asyncOptions = value;\n    return newInstance;\n  }\n\n  allowMultiple(value: boolean = true): ColumnConfigBuilder<TData, TType extends 'option' ? TType : never, TVal, TId> {\n    if (this.config.type !== 'option') {\n      throw new Error('allowMultiple() is only applicable to option columns');\n    }\n    const newInstance = this.clone() as any;\n    newInstance.config.allowMultiple = value;\n    return newInstance;\n  }\n\n  transformOptionFn(\n    fn: TTransformOptionFn<TVal>\n  ): ColumnConfigBuilder<TData, TType extends 'option' | 'multiOption' ? TType : never, TVal, TId> {\n    if (!isAnyOf(this.config.type, ['option', 'multiOption'])) {\n      throw new Error('transformOptionFn() is only applicable to option or multiOption columns');\n    }\n    const newInstance = this.clone() as any;\n    newInstance.config.transformOptionFn = fn;\n    return newInstance;\n  }\n\n  orderFn(\n    fn: TOrderFn<TVal>\n  ): ColumnConfigBuilder<TData, TType extends 'option' | 'multiOption' ? TType : never, TVal, TId> {\n    if (!isAnyOf(this.config.type, ['option', 'multiOption'])) {\n      throw new Error('orderFn() is only applicable to option or multiOption columns');\n    }\n    const newInstance = this.clone() as any;\n    newInstance.config.orderFn = fn;\n    return newInstance;\n  }\n\n  build(): ColumnConfig<TData, TType, TVal, TId> {\n    if (!this.config.id) throw new Error('id is required');\n    if (!this.config.accessor) throw new Error('accessor is required');\n    if (!this.config.displayName) throw new Error('displayName is required');\n    if (!this.config.icon) throw new Error('icon is required');\n    return this.config as ColumnConfig<TData, TType, TVal, TId>;\n  }\n}\n\n// Update the helper interface\ninterface FluentColumnConfigHelper<TData> {\n  text: () => ColumnConfigBuilder<TData, 'text', string>;\n  number: () => ColumnConfigBuilder<TData, 'number', number>;\n  date: () => ColumnConfigBuilder<TData, 'date', Date>;\n  option: () => ColumnConfigBuilder<TData, 'option', string>;\n  multiOption: () => ColumnConfigBuilder<TData, 'multiOption', string[]>;\n}\n\n// Factory function remains mostly the same\nexport function createColumnConfigHelper<TData>(): FluentColumnConfigHelper<TData> {\n  return {\n    text: () => new ColumnConfigBuilder<TData, 'text', string>('text'),\n    number: () => new ColumnConfigBuilder<TData, 'number', number>('number'),\n    date: () => new ColumnConfigBuilder<TData, 'date', Date>('date'),\n    option: () => new ColumnConfigBuilder<TData, 'option', string>('option'),\n    multiOption: () => new ColumnConfigBuilder<TData, 'multiOption', string[]>('multiOption'),\n  };\n}\n\nfunction getColumnOptions<TData, TType extends ColumnDataType, TVal>(\n  column: ColumnConfig<TData, TType, TVal>,\n  data: TData[],\n  strategy: FilterStrategy\n): ColumnOption[] {\n  if (!isAnyOf(column.type, ['option', 'multiOption'])) {\n    console.warn('Column options can only be retrieved for option and multiOption columns');\n    return [];\n  }\n\n  if (strategy === 'server' && !column.options && !column.asyncOptions) {\n    throw new Error('column options are required for server-side filtering');\n  }\n\n  if (column.options) {\n    return column.options;\n  }\n\n  if (column.asyncOptions && strategy === 'server') {\n    return [];\n  }\n\n  const filtered = data.flatMap(column.accessor).filter((v): v is NonNullable<TVal> => v !== undefined && v !== null);\n\n  let models = uniq(filtered);\n\n  if (column.orderFn) {\n    models = models.sort((m1, m2) =>\n      column.orderFn!(m1 as ElementType<NonNullable<TVal>>, m2 as ElementType<NonNullable<TVal>>)\n    );\n  }\n\n  if (column.transformOptionFn) {\n    // Memoize transformOptionFn calls\n    const memoizedTransform = memo(\n      () => [models],\n      (deps) => {\n        const modelsArray = deps[0];\n        if (!modelsArray) return [];\n        return modelsArray.map((m) => column.transformOptionFn!(m as ElementType<NonNullable<TVal>>));\n      },\n      { key: `transform-${column.id}` }\n    );\n    return memoizedTransform();\n  }\n\n  if (column.asyncOptions) {\n    return [];\n  }\n\n  if (isColumnOptionArray(models)) return models;\n\n  throw new Error(\n    `[data-table-filter] [${column.id}] Either provide static options, a transformOptionFn, or ensure the column data conforms to ColumnOption type`\n  );\n}\n\nfunction getColumnValues<TData, TType extends ColumnDataType, TVal>(\n  column: ColumnConfig<TData, TType, TVal>,\n  data: TData[]\n) {\n  // Memoize accessor calls\n  const memoizedAccessor = memo(\n    () => [data],\n    (deps) => {\n      const dataArray = deps[0];\n      if (!dataArray) return [];\n      return dataArray\n        .flatMap(column.accessor)\n        .filter((v): v is NonNullable<TVal> => v !== undefined && v !== null) as ElementType<NonNullable<TVal>>[];\n    },\n    { key: `accessor-${column.id}` }\n  );\n\n  const raw = memoizedAccessor();\n\n  if (!isAnyOf(column.type, ['option', 'multiOption'])) {\n    return raw;\n  }\n\n  if (column.options) {\n    return raw\n      .map((v) => column.options?.find((o) => o.value === v)?.value)\n      .filter((v) => v !== undefined && v !== null);\n  }\n\n  if (column.transformOptionFn) {\n    const memoizedTransform = memo(\n      () => [raw],\n      (deps) => {\n        const rawArray = deps[0];\n        if (!rawArray) return [];\n        return rawArray.map((v) => column.transformOptionFn!(v) as ElementType<NonNullable<TVal>>);\n      },\n      { key: `transform-values-${column.id}` }\n    );\n    return memoizedTransform();\n  }\n\n  if (isColumnOptionArray(raw)) {\n    return raw;\n  }\n\n  throw new Error(\n    `[data-table-filter] [${column.id}] Either provide static options, a transformOptionFn, or ensure the column data conforms to ColumnOption type`\n  );\n}\n\nfunction getFacetedUniqueValues<TData, TType extends ColumnDataType, TVal>(\n  column: ColumnConfig<TData, TType, TVal>,\n  values: string[] | ColumnOption[],\n  strategy: FilterStrategy\n): Map<string, number> | undefined {\n  if (!isAnyOf(column.type, ['option', 'multiOption'])) {\n    console.warn('Faceted unique values can only be retrieved for option and multiOption columns');\n    return new Map<string, number>();\n  }\n\n  if (strategy === 'server') {\n    return column.facetedOptions;\n  }\n\n  const acc = new Map<string, number>();\n\n  if (isColumnOptionArray(values)) {\n    for (const option of values) {\n      const curr = acc.get(option.value) ?? 0;\n      acc.set(option.value, curr + 1);\n    }\n  } else {\n    for (const option of values) {\n      const curr = acc.get(option as string) ?? 0;\n      acc.set(option as string, curr + 1);\n    }\n  }\n\n  return acc;\n}\n\nfunction getFacetedMinMaxValues<TData, TType extends ColumnDataType, TVal>(\n  column: ColumnConfig<TData, TType, TVal>,\n  data: TData[],\n  strategy: FilterStrategy\n): [number, number] | undefined {\n  if (column.type !== 'number') return undefined; // Only applicable to number columns\n\n  if (typeof column.min === 'number' && typeof column.max === 'number') {\n    return [column.min, column.max];\n  }\n\n  if (strategy === 'server') {\n    return undefined;\n  }\n\n  const values = data\n    .flatMap((row) => column.accessor(row) as Nullable<number>)\n    .filter((v): v is number => typeof v === 'number' && !Number.isNaN(v));\n\n  if (values.length === 0) {\n    return [0, 0]; // Fallback to config or reasonable defaults\n  }\n\n  const min = Math.min(...values);\n  const max = Math.max(...values);\n\n  return [min, max];\n}\n\nexport function createColumns<TData>(\n  data: TData[],\n  columnConfigs: ReadonlyArray<ColumnConfig<TData, any, any, any>>,\n  strategy: FilterStrategy\n): Column<TData>[] {\n  return columnConfigs.map((columnConfig) => {\n    const getOptions: () => ColumnOption[] = memo(\n      () => [data, strategy, columnConfig.options],\n      ([data, strategy]) => getColumnOptions(columnConfig, data as any, strategy as any),\n      { key: `options-${columnConfig.id}` }\n    );\n\n    const getValues: () => ElementType<NonNullable<any>>[] = memo(\n      () => [data, strategy],\n      () => (strategy === 'client' ? getColumnValues(columnConfig, data) : []),\n      { key: `values-${columnConfig.id}` }\n    );\n\n    const getUniqueValues: () => Map<string, number> | undefined = memo(\n      () => [getValues(), strategy],\n      ([values, strategy]) => getFacetedUniqueValues(columnConfig, values as any, strategy as any),\n      { key: `faceted-${columnConfig.id}` }\n    );\n\n    const getMinMaxValues: () => [number, number] | undefined = memo(\n      () => [data, strategy],\n      () => getFacetedMinMaxValues(columnConfig, data, strategy),\n      { key: `minmax-${columnConfig.id}` }\n    );\n\n    // Create the Column instance\n    const column: Column<TData> = {\n      ...columnConfig,\n      getOptions,\n      getValues,\n      getFacetedUniqueValues: getUniqueValues,\n      getFacetedMinMaxValues: getMinMaxValues,\n      // Prefetch methods will be added below\n      prefetchOptions: async () => {}, // Placeholder, defined below\n      prefetchValues: async () => {},\n      prefetchFacetedUniqueValues: async () => {},\n      prefetchFacetedMinMaxValues: async () => {},\n      _prefetchedOptionsCache: null, // Initialize private cache\n      _prefetchedValuesCache: null,\n      _prefetchedFacetedUniqueValuesCache: null,\n      _prefetchedFacetedMinMaxValuesCache: null,\n    };\n\n    if (strategy === 'client') {\n      // Define prefetch methods with access to the column instance\n      column.prefetchOptions = async (): Promise<void> => {\n        if (!column._prefetchedOptionsCache) {\n          await new Promise((resolve) =>\n            setTimeout(() => {\n              const options = getOptions();\n              column._prefetchedOptionsCache = options;\n              // console.log(`Prefetched options for ${columnConfig.id}`)\n              resolve(undefined);\n            }, 0)\n          );\n        }\n      };\n\n      column.prefetchValues = async (): Promise<void> => {\n        if (!column._prefetchedValuesCache) {\n          await new Promise((resolve) =>\n            setTimeout(() => {\n              const values = getValues();\n              column._prefetchedValuesCache = values;\n              // console.log(`Prefetched values for ${columnConfig.id}`)\n              resolve(undefined);\n            }, 0)\n          );\n        }\n      };\n\n      column.prefetchFacetedUniqueValues = async (): Promise<void> => {\n        if (!column._prefetchedFacetedUniqueValuesCache) {\n          await new Promise((resolve) =>\n            setTimeout(() => {\n              const facetedMap = getUniqueValues();\n              column._prefetchedFacetedUniqueValuesCache = facetedMap ?? null;\n              // console.log(\n              //   `Prefetched faceted unique values for ${columnConfig.id}`,\n              // )\n              resolve(undefined);\n            }, 0)\n          );\n        }\n      };\n\n      column.prefetchFacetedMinMaxValues = async (): Promise<void> => {\n        if (!column._prefetchedFacetedMinMaxValuesCache) {\n          await new Promise((resolve) =>\n            setTimeout(() => {\n              const value = getMinMaxValues();\n              column._prefetchedFacetedMinMaxValuesCache = value ?? null;\n              // console.log(\n              //   `Prefetched faceted min/max values for ${columnConfig.id}`,\n              // )\n              resolve(undefined);\n            }, 0)\n          );\n        }\n      };\n    }\n\n    return column;\n  });\n}\n",
      "type": "registry:lib",
      "target": "components/dentil/data-table/filter/core/filters.ts"
    },
    {
      "path": "components/dentil/data-table/filter/core/operators.ts",
      "content": "import type {\n  ColumnDataType,\n  FilterDetails,\n  FilterOperatorTarget,\n  FilterOperators,\n  FilterTypeOperatorDetails,\n  FilterValues,\n} from './types';\n\nexport const DEFAULT_OPERATORS: Record<\n  ColumnDataType,\n  Record<FilterOperatorTarget, FilterOperators[ColumnDataType]>\n> = {\n  text: {\n    single: 'contains',\n    multiple: 'contains',\n  },\n  number: {\n    single: 'is',\n    multiple: 'is between',\n  },\n  date: {\n    single: 'is',\n    multiple: 'is between',\n  },\n  option: {\n    single: 'is',\n    multiple: 'is any of',\n  },\n  multiOption: {\n    single: 'include',\n    multiple: 'include any of',\n  },\n};\n\n/* Details for all the filter operators for option data type */\nexport const optionFilterOperators = {\n  is: {\n    key: 'filters.option.is',\n    value: 'is',\n    target: 'single',\n    singularOf: 'is any of',\n    relativeOf: 'is any of',\n    isNegated: false,\n    negation: 'is none of',\n  },\n  'is any of': {\n    key: 'filters.option.isAnyOf',\n    value: 'is any of',\n    target: 'multiple',\n    pluralOf: 'is',\n    relativeOf: 'is none of',\n    isNegated: false,\n    negation: 'is none of',\n  },\n  'is none of': {\n    key: 'filters.option.isNoneOf',\n    value: 'is none of',\n    target: 'multiple',\n    relativeOf: 'is any of',\n    isNegated: true,\n    negationOf: 'is any of',\n  },\n} as const satisfies FilterDetails<'option'>;\n\n/* Details for all the filter operators for multi-option data type */\nexport const multiOptionFilterOperators = {\n  include: {\n    key: 'filters.multiOption.include',\n    value: 'include',\n    target: 'single',\n    singularOf: 'include any of',\n    relativeOf: 'exclude',\n    isNegated: false,\n    negation: 'exclude',\n  },\n  exclude: {\n    key: 'filters.multiOption.exclude',\n    value: 'exclude',\n    target: 'single',\n    singularOf: 'exclude if any of',\n    relativeOf: 'include',\n    isNegated: true,\n    negationOf: 'include',\n  },\n  'include any of': {\n    key: 'filters.multiOption.includeAnyOf',\n    value: 'include any of',\n    target: 'multiple',\n    pluralOf: 'include',\n    relativeOf: ['exclude if all', 'include all of', 'exclude if any of'],\n    isNegated: false,\n    negation: 'exclude if all',\n  },\n  'exclude if all': {\n    key: 'filters.multiOption.excludeIfAll',\n    value: 'exclude if all',\n    target: 'multiple',\n    pluralOf: 'exclude',\n    relativeOf: ['include any of', 'include all of', 'exclude if any of'],\n    isNegated: true,\n    negationOf: 'include any of',\n  },\n  'include all of': {\n    key: 'filters.multiOption.includeAllOf',\n    value: 'include all of',\n    target: 'multiple',\n    pluralOf: 'include',\n    relativeOf: ['include any of', 'exclude if all', 'exclude if any of'],\n    isNegated: false,\n    negation: 'exclude if any of',\n  },\n  'exclude if any of': {\n    key: 'filters.multiOption.excludeIfAnyOf',\n    value: 'exclude if any of',\n    target: 'multiple',\n    pluralOf: 'exclude',\n    relativeOf: ['include any of', 'exclude if all', 'include all of'],\n    isNegated: true,\n    negationOf: 'include all of',\n  },\n} as const satisfies FilterDetails<'multiOption'>;\n\n/* Details for all the filter operators for date data type */\nexport const dateFilterOperators = {\n  is: {\n    key: 'filters.date.is',\n    value: 'is',\n    target: 'single',\n    singularOf: 'is between',\n    relativeOf: 'is after',\n    isNegated: false,\n    negation: 'is before',\n  },\n  'is not': {\n    key: 'filters.date.isNot',\n    value: 'is not',\n    target: 'single',\n    singularOf: 'is not between',\n    relativeOf: ['is', 'is before', 'is on or after', 'is after', 'is on or before'],\n    isNegated: true,\n    negationOf: 'is',\n  },\n  'is before': {\n    key: 'filters.date.isBefore',\n    value: 'is before',\n    target: 'single',\n    singularOf: 'is between',\n    relativeOf: ['is', 'is not', 'is on or after', 'is after', 'is on or before'],\n    isNegated: false,\n    negation: 'is on or after',\n  },\n  'is on or after': {\n    key: 'filters.date.isOnOrAfter',\n    value: 'is on or after',\n    target: 'single',\n    singularOf: 'is between',\n    relativeOf: ['is', 'is not', 'is before', 'is after', 'is on or before'],\n    isNegated: false,\n    negation: 'is before',\n  },\n  'is after': {\n    key: 'filters.date.isAfter',\n    value: 'is after',\n    target: 'single',\n    singularOf: 'is between',\n    relativeOf: ['is', 'is not', 'is before', 'is on or after', 'is on or before'],\n    isNegated: false,\n    negation: 'is on or before',\n  },\n  'is on or before': {\n    key: 'filters.date.isOnOrBefore',\n    value: 'is on or before',\n    target: 'single',\n    singularOf: 'is between',\n    relativeOf: ['is', 'is not', 'is after', 'is on or after', 'is before'],\n    isNegated: false,\n    negation: 'is after',\n  },\n  'is between': {\n    key: 'filters.date.isBetween',\n    value: 'is between',\n    target: 'multiple',\n    pluralOf: 'is',\n    relativeOf: 'is not between',\n    isNegated: false,\n    negation: 'is not between',\n  },\n  'is not between': {\n    key: 'filters.date.isNotBetween',\n    value: 'is not between',\n    target: 'multiple',\n    pluralOf: 'is not',\n    relativeOf: 'is between',\n    isNegated: true,\n    negationOf: 'is between',\n  },\n} as const satisfies FilterDetails<'date'>;\n\n/* Details for all the filter operators for text data type */\nexport const textFilterOperators = {\n  contains: {\n    key: 'filters.text.contains',\n    value: 'contains',\n    target: 'single',\n    relativeOf: 'does not contain',\n    isNegated: false,\n    negation: 'does not contain',\n  },\n  'does not contain': {\n    key: 'filters.text.doesNotContain',\n    value: 'does not contain',\n    target: 'single',\n    relativeOf: 'contains',\n    isNegated: true,\n    negationOf: 'contains',\n  },\n} as const satisfies FilterDetails<'text'>;\n\n/* Details for all the filter operators for number data type */\nexport const numberFilterOperators = {\n  is: {\n    key: 'filters.number.is',\n    value: 'is',\n    target: 'single',\n    singularOf: 'is between',\n    relativeOf: [\n      'is not',\n      'is greater than',\n      'is less than or equal to',\n      'is less than',\n      'is greater than or equal to',\n    ],\n    isNegated: false,\n    negation: 'is not',\n  },\n  'is not': {\n    key: 'filters.number.isNot',\n    value: 'is not',\n    target: 'single',\n    singularOf: 'is not between',\n    relativeOf: ['is', 'is greater than', 'is less than or equal to', 'is less than', 'is greater than or equal to'],\n    isNegated: true,\n    negationOf: 'is',\n  },\n  'is greater than': {\n    key: 'filters.number.greaterThan',\n    value: 'is greater than',\n    target: 'single',\n    singularOf: 'is between',\n    relativeOf: ['is', 'is not', 'is less than or equal to', 'is less than', 'is greater than or equal to'],\n    isNegated: false,\n    negation: 'is less than or equal to',\n  },\n  'is greater than or equal to': {\n    key: 'filters.number.greaterThanOrEqual',\n    value: 'is greater than or equal to',\n    target: 'single',\n    singularOf: 'is between',\n    relativeOf: ['is', 'is not', 'is greater than', 'is less than or equal to', 'is less than'],\n    isNegated: false,\n    negation: 'is less than or equal to',\n  },\n  'is less than': {\n    key: 'filters.number.lessThan',\n    value: 'is less than',\n    target: 'single',\n    singularOf: 'is between',\n    relativeOf: ['is', 'is not', 'is greater than', 'is less than or equal to', 'is greater than or equal to'],\n    isNegated: false,\n    negation: 'is greater than',\n  },\n  'is less than or equal to': {\n    key: 'filters.number.lessThanOrEqual',\n    value: 'is less than or equal to',\n    target: 'single',\n    singularOf: 'is between',\n    relativeOf: ['is', 'is not', 'is greater than', 'is less than', 'is greater than or equal to'],\n    isNegated: false,\n    negation: 'is greater than or equal to',\n  },\n  'is between': {\n    key: 'filters.number.isBetween',\n    value: 'is between',\n    target: 'multiple',\n    pluralOf: 'is',\n    relativeOf: 'is not between',\n    isNegated: false,\n    negation: 'is not between',\n  },\n  'is not between': {\n    key: 'filters.number.isNotBetween',\n    value: 'is not between',\n    target: 'multiple',\n    pluralOf: 'is not',\n    relativeOf: 'is between',\n    isNegated: true,\n    negationOf: 'is between',\n  },\n} as const satisfies FilterDetails<'number'>;\n\nexport const filterTypeOperatorDetails: FilterTypeOperatorDetails = {\n  text: textFilterOperators,\n  number: numberFilterOperators,\n  date: dateFilterOperators,\n  option: optionFilterOperators,\n  multiOption: multiOptionFilterOperators,\n};\n\n/*\n *\n * Determines the new operator for a filter based on the current operator, old and new filter values.\n *\n * This handles cases where the filter values have transitioned from a single value to multiple values (or vice versa),\n * and the current operator needs to be transitioned to its plural form (or singular form).\n *\n * For example, if the current operator is 'is', and the new filter values have a length of 2, the\n * new operator would be 'is any of'.\n *\n */\n/*\n * Gets the available operators for an option column based on allowMultiple setting\n */\nexport function getOptionFilterOperators(allowMultiple: boolean = true) {\n  if (allowMultiple) {\n    return optionFilterOperators;\n  }\n\n  // Return only single-value operators when multiple selection is disabled\n  const { is } = optionFilterOperators;\n  return { is } as const;\n}\n\nexport function determineNewOperator<TType extends ColumnDataType>(\n  type: TType,\n  oldVals: FilterValues<TType>,\n  nextVals: FilterValues<TType>,\n  currentOperator: FilterOperators[TType],\n  allowMultiple?: boolean\n): FilterOperators[TType] {\n  const a = Array.isArray(oldVals) && Array.isArray(oldVals[0]) ? oldVals[0].length : oldVals.length;\n  const b = Array.isArray(nextVals) && Array.isArray(nextVals[0]) ? nextVals[0].length : nextVals.length;\n\n  // For option type with allowMultiple=false, don't transition to multiple operators\n  if (type === 'option' && allowMultiple === false) {\n    return currentOperator;\n  }\n\n  // If filter size has not transitioned from single to multiple (or vice versa)\n  // or is unchanged, return the current operator.\n  if (a === b || (a >= 2 && b >= 2) || (a <= 1 && b <= 1)) return currentOperator;\n\n  const opDetails = filterTypeOperatorDetails[type][currentOperator];\n\n  // Handle transition from single to multiple filter values.\n  if (a < b && b >= 2) return opDetails.singularOf ?? currentOperator;\n  // Handle transition from multiple to single filter values.\n  if (a > b && b <= 1) return opDetails.pluralOf ?? currentOperator;\n  return currentOperator;\n}\n",
      "type": "registry:lib",
      "target": "components/dentil/data-table/filter/core/operators.ts"
    },
    {
      "path": "components/dentil/data-table/filter/core/types.ts",
      "content": "/* eslint-disable @typescript-eslint/no-unused-vars */\nimport type { LucideIcon } from 'lucide-react';\n\n/*\n * # GENERAL NOTES:\n *\n * ## GENERICS:\n *\n * TData is the shape of a single row in your data table.\n * TVal is the shape of the underlying value for a column.\n * TType is the type (kind) of the column.\n *\n */\n\nexport type ElementType<T> = T extends (infer U)[] ? U : T;\n\nexport type Nullable<T> = T | null | undefined;\n\n/*\n * The model of a column option.\n * Used for representing underlying column values of type `option` or `multiOption`.\n */\nexport interface ColumnOption {\n  /* The label to display for the option. */\n  label: string;\n  /* The internal value of the option. */\n  value: string;\n  /* An optional icon to display next to the label. */\n  icon?: React.ReactElement | React.ElementType;\n}\n\nexport interface ColumnOptionExtended extends ColumnOption {\n  selected?: boolean;\n  count?: number;\n}\n\n/*\n * Options loaded on demand as the user types, for option columns with too many values to list up front\n * (e.g. customers or team members).\n */\nexport type AsyncOptionConfig = {\n  /* Return the options matching `search` (an empty string on open). */\n  fetchOptions: (search: string) => Promise<ColumnOption[]>;\n  /* Delay before searching after the user stops typing. Defaults to 300ms. */\n  debounceMs?: number;\n  /* Look up the label for a value that wasn't picked in this session (e.g. restored from the URL). */\n  resolveLabel?: (value: string) => Promise<string | undefined>;\n};\n\n/*\n * Represents the data type (kind) of a column.\n */\nexport type ColumnDataType =\n  /* The column value is a string that should be searchable. */\n  | 'text'\n  | 'number'\n  | 'date'\n  /* The column value can be a single value from a list of options. */\n  | 'option'\n  /* The column value can be zero or more values from a list of options. */\n  | 'multiOption';\n\n/*\n * Represents the data type (kind) of option and multi-option columns.\n */\nexport type OptionBasedColumnDataType = Extract<ColumnDataType, 'option' | 'multiOption'>;\n\n/*\n * Maps a ColumnDataType to it's primitive type (i.e. string, number, etc.).\n */\nexport type ColumnDataNativeMap = {\n  text: string;\n  number: number;\n  date: Date;\n  option: string;\n  multiOption: string[];\n};\n\n/*\n * Represents the value of a column filter.\n * Contigent on the filtered column's data type.\n */\nexport type FilterValues<T extends ColumnDataType> = Array<ElementType<ColumnDataNativeMap[T]>>;\n\n/*\n * An accessor function for a column's data.\n * Uses the original row data as an argument.\n */\nexport type TAccessorFn<TData, TVal = unknown> = (data: TData) => TVal;\n\n/*\n * Used by `option` and `multiOption` columns.\n * Transforms the underlying column value into a valid ColumnOption.\n */\nexport type TTransformOptionFn<TVal = unknown> = (value: ElementType<NonNullable<TVal>>) => ColumnOption;\n\n/*\n * Used by `option` and `multiOption` columns.\n * A custom ordering function when sorting a column's options.\n */\nexport type TOrderFn<TVal = unknown> = (a: ElementType<NonNullable<TVal>>, b: ElementType<NonNullable<TVal>>) => number;\n\n/*\n * The configuration for a column.\n */\nexport type ColumnConfig<TData, TType extends ColumnDataType = any, TVal = unknown, TId extends string = string> = {\n  id: TId;\n  accessor: TAccessorFn<TData, TVal>;\n  displayName: string;\n  icon: LucideIcon;\n  type: TType;\n  options?: TType extends OptionBasedColumnDataType ? ColumnOption[] : never;\n  facetedOptions?: TType extends OptionBasedColumnDataType ? Map<string, number> : never;\n  allowMultiple?: TType extends 'option' ? boolean : never;\n  min?: TType extends 'number' ? number : never;\n  max?: TType extends 'number' ? number : never;\n  /* Multiply UI values by this when sending to the API (e.g. 100 for pounds → pence). */\n  scale?: TType extends 'number' ? number : never;\n  transformOptionFn?: TType extends OptionBasedColumnDataType ? TTransformOptionFn<TVal> : never;\n  orderFn?: TType extends OptionBasedColumnDataType ? TOrderFn<TVal> : never;\n  asyncOptions?: TType extends OptionBasedColumnDataType ? AsyncOptionConfig : never;\n};\n\nexport type OptionColumnId<T> = T extends ColumnConfig<any, 'option' | 'multiOption', any, infer TId> ? TId : never;\n\nexport type OptionColumnIds<T extends ReadonlyArray<ColumnConfig<any, any, any, any>>> = {\n  [K in keyof T]: OptionColumnId<T[K]>;\n}[number];\n\nexport type NumberColumnId<T> = T extends ColumnConfig<any, 'number', any, infer TId> ? TId : never;\n\nexport type NumberColumnIds<T extends ReadonlyArray<ColumnConfig<any, any, any, any>>> = {\n  [K in keyof T]: NumberColumnId<T[K]>;\n}[number];\n\n/*\n * Describes a helper function for creating column configurations.\n */\nexport type ColumnConfigHelper<TData> = {\n  accessor: <TAccessor extends TAccessorFn<TData>, TType extends ColumnDataType, TVal extends ReturnType<TAccessor>>(\n    accessor: TAccessor,\n    config?: Omit<ColumnConfig<TData, TType, TVal>, 'accessor'>\n  ) => ColumnConfig<TData, TType, unknown>;\n};\n\nexport type DataTableFilterConfig<TData> = {\n  data: TData[];\n  columns: ColumnConfig<TData>[];\n};\n\nexport type ColumnProperties<_TData, TVal> = {\n  getOptions: () => ColumnOption[];\n  getValues: () => ElementType<NonNullable<TVal>>[];\n  getFacetedUniqueValues: () => Map<string, number> | undefined;\n  getFacetedMinMaxValues: () => [number, number] | undefined;\n  prefetchOptions: () => Promise<void>; // Prefetch options\n  prefetchValues: () => Promise<void>; // Prefetch values\n  prefetchFacetedUniqueValues: () => Promise<void>; // Prefetch faceted unique values\n  prefetchFacetedMinMaxValues: () => Promise<void>; // Prefetch faceted min/max values\n};\n\nexport type ColumnPrivateProperties<_TData, TVal> = {\n  _prefetchedOptionsCache: ColumnOption[] | null;\n  _prefetchedValuesCache: ElementType<NonNullable<TVal>>[] | null;\n  _prefetchedFacetedUniqueValuesCache: Map<string, number> | null;\n  _prefetchedFacetedMinMaxValuesCache: [number, number] | null;\n};\n\nexport type Column<TData, TType extends ColumnDataType = any, TVal = unknown> = ColumnConfig<TData, TType, TVal> &\n  ColumnProperties<TData, TVal> &\n  ColumnPrivateProperties<TData, TVal>;\n\n/*\n * Describes the available actions on column filters.\n * Includes both column-specific and global actions, ultimately acting on the column filters.\n */\nexport interface DataTableFilterActions {\n  addFilterValue: <TData, TType extends OptionBasedColumnDataType>(\n    column: Column<TData, TType>,\n    values: FilterModel<TType>['values']\n  ) => void;\n\n  removeFilterValue: <TData, TType extends OptionBasedColumnDataType>(\n    column: Column<TData, TType>,\n    value: FilterModel<TType>['values']\n  ) => void;\n\n  setFilterValue: <TData, TType extends ColumnDataType>(\n    column: Column<TData, TType>,\n    values: FilterModel<TType>['values']\n  ) => void;\n\n  setFilterOperator: <TType extends ColumnDataType>(columnId: string, operator: FilterModel<TType>['operator']) => void;\n\n  removeFilter: (columnId: string) => void;\n\n  removeAllFilters: () => void;\n}\n\nexport type FilterStrategy = 'client' | 'server';\n\n/* Operators for text data */\nexport type TextFilterOperator = 'contains' | 'does not contain';\n\n/* Operators for number data */\nexport type NumberFilterOperator =\n  | 'is'\n  | 'is not'\n  | 'is less than'\n  | 'is greater than or equal to'\n  | 'is greater than'\n  | 'is less than or equal to'\n  | 'is between'\n  | 'is not between';\n\n/* Operators for date data */\nexport type DateFilterOperator =\n  'is' | 'is not' | 'is before' | 'is on or after' | 'is after' | 'is on or before' | 'is between' | 'is not between';\n\n/* Operators for option data */\nexport type OptionFilterOperator = 'is' | 'is any of' | 'is none of';\n\n/* Operators for multi-option data */\nexport type MultiOptionFilterOperator =\n  'include' | 'exclude' | 'include any of' | 'include all of' | 'exclude if any of' | 'exclude if all';\n\n/* Maps filter operators to their respective data types */\nexport type FilterOperators = {\n  text: TextFilterOperator;\n  number: NumberFilterOperator;\n  date: DateFilterOperator;\n  option: OptionFilterOperator;\n  multiOption: MultiOptionFilterOperator;\n};\n\n/*\n *\n * FilterValue is a type that represents a filter value for a specific column.\n *\n * It consists of:\n * - Operator: The operator to be used for the filter.\n * - Values: An array of values to be used for the filter.\n *\n */\nexport type FilterModel<TType extends ColumnDataType = any> = {\n  columnId: string;\n  type: TType;\n  operator: FilterOperators[TType];\n  values: FilterValues<TType>;\n};\n\nexport type FiltersState = Array<FilterModel>;\n\n/*\n * FilterDetails is a type that represents the details of all the filter operators for a specific column data type.\n */\nexport type FilterDetails<T extends ColumnDataType> = {\n  [key in FilterOperators[T]]: FilterOperatorDetails<key, T>;\n};\n\nexport type FilterOperatorTarget = 'single' | 'multiple';\n\nexport type FilterOperatorDetailsBase<OperatorValue, T extends ColumnDataType> = {\n  /* The i18n key for the operator. */\n  key: string;\n  /* The operator value. Usually the string representation of the operator. */\n  value: OperatorValue;\n  /* How much data the operator applies to. */\n  target: FilterOperatorTarget;\n  /* The plural form of the operator, if applicable. */\n  singularOf?: FilterOperators[T];\n  /* The singular form of the operator, if applicable. */\n  pluralOf?: FilterOperators[T];\n  /* All related operators. Normally, all the operators which share the same target. */\n  relativeOf: FilterOperators[T] | Array<FilterOperators[T]>;\n  /* Whether the operator is negated. */\n  isNegated: boolean;\n  /* If the operator is not negated, this provides the negated equivalent. */\n  negation?: FilterOperators[T];\n  /* If the operator is negated, this provides the positive equivalent. */\n  negationOf?: FilterOperators[T];\n};\n\n/*\n *\n * FilterOperatorDetails is a type that provides details about a filter operator for a specific column data type.\n * It extends FilterOperatorDetailsBase with additional logic and contraints on the defined properties.\n *\n */\nexport type FilterOperatorDetails<OperatorValue, T extends ColumnDataType> = FilterOperatorDetailsBase<\n  OperatorValue,\n  T\n> &\n  (\n    | { singularOf?: never; pluralOf?: never }\n    | { target: 'single'; singularOf: FilterOperators[T]; pluralOf?: never }\n    | { target: 'multiple'; singularOf?: never; pluralOf: FilterOperators[T] }\n  ) &\n  (\n    | { isNegated: false; negation: FilterOperators[T]; negationOf?: never }\n    | { isNegated: true; negation?: never; negationOf: FilterOperators[T] }\n  );\n\n/* Maps column data types to their respective filter operator details */\nexport type FilterTypeOperatorDetails = {\n  [key in ColumnDataType]: FilterDetails<key>;\n};\n",
      "type": "registry:lib",
      "target": "components/dentil/data-table/filter/core/types.ts"
    },
    {
      "path": "components/dentil/data-table/filter/hooks/use-data-table-filters.tsx",
      "content": "'use client';\n\nimport type React from 'react';\nimport { useMemo, useState } from 'react';\nimport { createColumns } from '../core/filters';\nimport { DEFAULT_OPERATORS, determineNewOperator } from '../core/operators';\nimport type {\n  ColumnConfig,\n  ColumnDataType,\n  ColumnOption,\n  DataTableFilterActions,\n  FilterModel,\n  FilterStrategy,\n  FiltersState,\n  NumberColumnIds,\n  OptionBasedColumnDataType,\n  OptionColumnIds,\n} from '../core/types';\nimport { uniq } from '../lib/array';\nimport { addUniq, removeUniq } from '../lib/array';\nimport {\n  createDateFilterValue,\n  createNumberFilterValue,\n  isColumnOptionArray,\n  isColumnOptionMap,\n  isMinMaxTuple,\n} from '../lib/helpers';\n\nexport interface DataTableFiltersOptions<\n  TData,\n  TColumns extends ReadonlyArray<ColumnConfig<TData, any, any, any>>,\n  TStrategy extends FilterStrategy,\n> {\n  strategy: TStrategy;\n  data: TData[];\n  columnsConfig: TColumns;\n  defaultFilters?: FiltersState;\n  filters?: FiltersState;\n  onFiltersChange?: React.Dispatch<React.SetStateAction<FiltersState>>;\n  options?: Partial<Record<OptionColumnIds<TColumns>, ColumnOption[] | undefined>>;\n  faceted?: Partial<\n    | Record<OptionColumnIds<TColumns>, Map<string, number> | undefined>\n    | Record<NumberColumnIds<TColumns>, [number, number] | undefined>\n  >;\n}\n\nexport function useDataTableFilters<\n  TData,\n  TColumns extends ReadonlyArray<ColumnConfig<TData, any, any, any>>,\n  TStrategy extends FilterStrategy,\n>({\n  strategy,\n  data,\n  columnsConfig,\n  defaultFilters,\n  filters: externalFilters,\n  onFiltersChange,\n  options,\n  faceted,\n}: DataTableFiltersOptions<TData, TColumns, TStrategy>) {\n  const [internalFilters, setInternalFilters] = useState<FiltersState>(defaultFilters ?? []);\n\n  if ((externalFilters && !onFiltersChange) || (!externalFilters && onFiltersChange)) {\n    throw new Error('If using controlled state, you must specify both filters and onFiltersChange.');\n  }\n\n  const filters = externalFilters ?? internalFilters;\n  const setFilters = onFiltersChange ?? setInternalFilters;\n\n  // Convert ColumnConfig to Column, applying options and faceted options if provided\n  const columns = useMemo(() => {\n    const enhancedConfigs = columnsConfig.map((config) => {\n      let final = config;\n\n      // Set options, if exists\n      if (options && (config.type === 'option' || config.type === 'multiOption')) {\n        const optionsInput = options[config.id as OptionColumnIds<TColumns>];\n        if (!optionsInput || !isColumnOptionArray(optionsInput)) return config;\n\n        final = { ...final, options: optionsInput };\n      }\n\n      // Set faceted options, if exists\n      if (faceted && (config.type === 'option' || config.type === 'multiOption')) {\n        const facetedOptionsInput = faceted[config.id as OptionColumnIds<TColumns>];\n        if (!facetedOptionsInput || !isColumnOptionMap(facetedOptionsInput)) return config;\n\n        final = { ...final, facetedOptions: facetedOptionsInput };\n      }\n\n      // Set faceted min/max values, if exists\n      if (config.type === 'number' && faceted) {\n        const minMaxTuple = faceted[config.id as NumberColumnIds<TColumns>];\n        if (!minMaxTuple || !isMinMaxTuple(minMaxTuple)) return config;\n\n        final = {\n          ...final,\n          min: minMaxTuple[0],\n          max: minMaxTuple[1],\n        };\n      }\n\n      return final;\n    });\n\n    return createColumns(data, enhancedConfigs, strategy);\n  }, [data, columnsConfig, options, faceted, strategy]);\n\n  const actions: DataTableFilterActions = useMemo(\n    () => ({\n      addFilterValue<TData, TType extends OptionBasedColumnDataType>(\n        column: ColumnConfig<TData, TType>,\n        values: FilterModel<TType>['values']\n      ) {\n        if (column.type === 'option') {\n          setFilters((prev) => {\n            const filter = prev.find((f) => f.columnId === column.id);\n            const isColumnFiltered = filter && filter.values.length > 0;\n            if (!isColumnFiltered) {\n              return [\n                ...prev,\n                {\n                  columnId: column.id,\n                  type: column.type,\n                  operator:\n                    values.length > 1 ? DEFAULT_OPERATORS[column.type].multiple : DEFAULT_OPERATORS[column.type].single,\n                  values,\n                },\n              ];\n            }\n            const oldValues = filter.values;\n            const newValues = addUniq(filter.values, values);\n            const newOperator = determineNewOperator('option', oldValues, newValues, filter.operator);\n            return prev.map((f) =>\n              f.columnId === column.id\n                ? {\n                    columnId: column.id,\n                    type: column.type,\n                    operator: newOperator,\n                    values: newValues,\n                  }\n                : f\n            );\n          });\n          return;\n        }\n        if (column.type === 'multiOption') {\n          setFilters((prev) => {\n            const filter = prev.find((f) => f.columnId === column.id);\n            const isColumnFiltered = filter && filter.values.length > 0;\n            if (!isColumnFiltered) {\n              return [\n                ...prev,\n                {\n                  columnId: column.id,\n                  type: column.type,\n                  operator:\n                    values.length > 1 ? DEFAULT_OPERATORS[column.type].multiple : DEFAULT_OPERATORS[column.type].single,\n                  values,\n                },\n              ];\n            }\n            const oldValues = filter.values;\n            const newValues = addUniq(filter.values, values);\n            const newOperator = determineNewOperator('multiOption', oldValues, newValues, filter.operator);\n            if (newValues.length === 0) {\n              return prev.filter((f) => f.columnId !== column.id);\n            }\n            return prev.map((f) =>\n              f.columnId === column.id\n                ? {\n                    columnId: column.id,\n                    type: column.type,\n                    operator: newOperator,\n                    values: newValues,\n                  }\n                : f\n            );\n          });\n          return;\n        }\n        throw new Error('[data-table-filter] addFilterValue() is only supported for option columns');\n      },\n      removeFilterValue<TData, TType extends OptionBasedColumnDataType>(\n        column: ColumnConfig<TData, TType>,\n        value: FilterModel<TType>['values']\n      ) {\n        if (column.type === 'option') {\n          setFilters((prev) => {\n            const filter = prev.find((f) => f.columnId === column.id);\n            const isColumnFiltered = filter && filter.values.length > 0;\n            if (!isColumnFiltered) {\n              return [...prev];\n            }\n            const newValues = removeUniq(filter.values, value);\n            const oldValues = filter.values;\n            const newOperator = determineNewOperator('option', oldValues, newValues, filter.operator);\n            if (newValues.length === 0) {\n              return prev.filter((f) => f.columnId !== column.id);\n            }\n            return prev.map((f) =>\n              f.columnId === column.id\n                ? {\n                    columnId: column.id,\n                    type: column.type,\n                    operator: newOperator,\n                    values: newValues,\n                  }\n                : f\n            );\n          });\n          return;\n        }\n        if (column.type === 'multiOption') {\n          setFilters((prev) => {\n            const filter = prev.find((f) => f.columnId === column.id);\n            const isColumnFiltered = filter && filter.values.length > 0;\n            if (!isColumnFiltered) {\n              return [...prev];\n            }\n            const newValues = removeUniq(filter.values, value);\n            const oldValues = filter.values;\n            const newOperator = determineNewOperator('multiOption', oldValues, newValues, filter.operator);\n            if (newValues.length === 0) {\n              return prev.filter((f) => f.columnId !== column.id);\n            }\n            return prev.map((f) =>\n              f.columnId === column.id\n                ? {\n                    columnId: column.id,\n                    type: column.type,\n                    operator: newOperator,\n                    values: newValues,\n                  }\n                : f\n            );\n          });\n          return;\n        }\n        throw new Error('[data-table-filter] removeFilterValue() is only supported for option columns');\n      },\n      setFilterValue<TData, TType extends ColumnDataType>(\n        column: ColumnConfig<TData, TType>,\n        values: FilterModel<TType>['values']\n      ) {\n        setFilters((prev) => {\n          const filter = prev.find((f) => f.columnId === column.id);\n          const isColumnFiltered = filter && filter.values.length > 0;\n          const newValues =\n            column.type === 'number'\n              ? createNumberFilterValue(values as number[])\n              : column.type === 'date'\n                ? createDateFilterValue(values as [Date, Date] | [Date] | [] | undefined)\n                : uniq(values);\n          if (newValues.length === 0) return prev;\n          if (!isColumnFiltered) {\n            return [\n              ...prev,\n              {\n                columnId: column.id,\n                type: column.type,\n                operator:\n                  values.length > 1 ? DEFAULT_OPERATORS[column.type].multiple : DEFAULT_OPERATORS[column.type].single,\n                values: newValues,\n              },\n            ];\n          }\n          const oldValues = filter.values;\n          const newOperator = determineNewOperator(column.type, oldValues, newValues, filter.operator);\n          const newFilter = {\n            columnId: column.id,\n            type: column.type,\n            operator: newOperator,\n            values: newValues as any,\n          } satisfies FilterModel<TType>;\n          return prev.map((f) => (f.columnId === column.id ? newFilter : f));\n        });\n      },\n      setFilterOperator<TType extends ColumnDataType>(columnId: string, operator: FilterModel<TType>['operator']) {\n        setFilters((prev) => prev.map((f) => (f.columnId === columnId ? { ...f, operator } : f)));\n      },\n      removeFilter(columnId: string) {\n        setFilters((prev) => prev.filter((f) => f.columnId !== columnId));\n      },\n      removeAllFilters() {\n        setFilters([]);\n      },\n    }),\n    [setFilters]\n  );\n\n  return { columns, filters, actions, strategy }; // columns is Column<TData>[]\n}\n",
      "type": "registry:component",
      "target": "components/dentil/data-table/filter/hooks/use-data-table-filters.tsx"
    },
    {
      "path": "components/dentil/data-table/filter/hooks/use-debounce-callback.tsx",
      "content": "import { useEffect, useMemo, useRef } from 'react';\nimport { debounce } from '../lib/debounce';\nimport { useUnmount } from './use-unmount';\n\ntype DebounceOptions = {\n  leading?: boolean;\n  trailing?: boolean;\n  maxWait?: number;\n};\n\ntype ControlFunctions = {\n  cancel: () => void;\n  flush: () => void;\n  isPending: () => boolean;\n};\n\nexport type DebouncedState<T extends (...args: any) => ReturnType<T>> = ((\n  ...args: Parameters<T>\n) => ReturnType<T> | undefined) &\n  ControlFunctions;\n\nexport function useDebounceCallback<T extends (...args: any) => ReturnType<T>>(\n  func: T,\n  delay = 500,\n  options?: DebounceOptions\n): DebouncedState<T> {\n  const debouncedFunc = useRef<ReturnType<typeof debounce>>(null);\n\n  useUnmount(() => {\n    if (debouncedFunc.current) {\n      debouncedFunc.current.cancel();\n    }\n  });\n\n  const debounced = useMemo(() => {\n    const debouncedFuncInstance = debounce(func, delay, options);\n\n    const wrappedFunc: DebouncedState<T> = (...args: Parameters<T>) => {\n      return debouncedFuncInstance(...args);\n    };\n\n    wrappedFunc.cancel = () => {\n      debouncedFuncInstance.cancel();\n    };\n\n    wrappedFunc.isPending = () => {\n      return !!debouncedFunc.current;\n    };\n\n    wrappedFunc.flush = () => {\n      return debouncedFuncInstance.flush();\n    };\n\n    return wrappedFunc;\n  }, [func, delay, options]);\n\n  // Update the debounced function ref whenever func, wait, or options change.\n  // Cancel the previous instance first so its pending timer/closure is released.\n  useEffect(() => {\n    debouncedFunc.current?.cancel();\n    debouncedFunc.current = debounce(func, delay, options);\n  }, [func, delay, options]);\n\n  return debounced;\n}\n",
      "type": "registry:component",
      "target": "components/dentil/data-table/filter/hooks/use-debounce-callback.tsx"
    },
    {
      "path": "components/dentil/data-table/filter/hooks/use-unmount.tsx",
      "content": "import { useEffect, useRef } from 'react';\n\nexport function useUnmount(func: () => void) {\n  const funcRef = useRef(func);\n\n  funcRef.current = func;\n\n  useEffect(\n    () => () => {\n      funcRef.current();\n    },\n    []\n  );\n}\n",
      "type": "registry:component",
      "target": "components/dentil/data-table/filter/hooks/use-unmount.tsx"
    },
    {
      "path": "components/dentil/data-table/filter/index.tsx",
      "content": "// Adapted from bazza/ui data-table-filter (MIT, see LICENSE.md): https://github.com/bazzalabs/ui\nexport { useDataTableFilters } from './hooks/use-data-table-filters';\nexport { DataTableFilter } from './components/data-table-filter';\nexport { createColumnConfigHelper } from './core/filters';\nexport { parseToQuery, parseToFilters } from './parser';\nexport type { ColumnConfig, ColumnOption, FiltersState, FilterModel, AsyncOptionConfig } from './core/types';\n",
      "type": "registry:component",
      "target": "components/dentil/data-table/filter/index.tsx"
    },
    {
      "path": "components/dentil/data-table/filter/lib/array.ts",
      "content": "export function intersection<T>(a: T[], b: T[]): T[] {\n  return a.filter((x) => b.includes(x));\n}\n\n/**\n * Computes a stable hash string for any value using deep inspection.\n * This function recursively builds a string for primitives, arrays, and objects.\n * It uses a cache (WeakMap) to avoid rehashing the same object twice, which is\n * particularly beneficial if an object appears in multiple places.\n */\nfunction deepHash(value: any, cache = new WeakMap<object, string>()): string {\n  // Handle primitives and null/undefined.\n  if (value === null) return 'null';\n  if (value === undefined) return 'undefined';\n  const type = typeof value;\n  if (type === 'number' || type === 'boolean' || type === 'string') {\n    return `${type}:${value.toString()}`;\n  }\n  if (type === 'function') {\n    // Note: using toString for functions.\n    return `function:${value.toString()}`;\n  }\n\n  // For objects and arrays, use caching to avoid repeated work.\n  if (type === 'object') {\n    // If we've seen this object before, return the cached hash.\n    if (cache.has(value)) {\n      return cache.get(value)!;\n    }\n    let hash: string;\n    if (Array.isArray(value)) {\n      // Compute hash for each element in order.\n      hash = `array:[${value.map((v) => deepHash(v, cache)).join(',')}]`;\n    } else {\n      // For objects, sort keys to ensure the representation is stable.\n      const keys = Object.keys(value).sort();\n      const props = keys.map((k) => `${k}:${deepHash(value[k], cache)}`).join(',');\n      hash = `object:{${props}}`;\n    }\n    cache.set(value, hash);\n    return hash;\n  }\n\n  // Fallback if no case matched.\n  return `${type}:${value.toString()}`;\n}\n\n/**\n * Performs deep equality check for any two values.\n * This recursively checks primitives, arrays, and plain objects.\n */\nfunction deepEqual(a: any, b: any): boolean {\n  // Check strict equality first.\n  if (a === b) return true;\n  // If types differ, they're not equal.\n  if (typeof a !== typeof b) return false;\n  if (a === null || b === null || a === undefined || b === undefined) return false;\n\n  // Check arrays.\n  if (Array.isArray(a)) {\n    if (!Array.isArray(b) || a.length !== b.length) return false;\n    for (let i = 0; i < a.length; i++) {\n      if (!deepEqual(a[i], b[i])) return false;\n    }\n    return true;\n  }\n\n  // Check objects.\n  if (typeof a === 'object') {\n    if (typeof b !== 'object') return false;\n    const aKeys = Object.keys(a).sort();\n    const bKeys = Object.keys(b).sort();\n    if (aKeys.length !== bKeys.length) return false;\n    for (let i = 0; i < aKeys.length; i++) {\n      const aKey = aKeys[i];\n      const bKey = bKeys[i];\n      if (!aKey || !bKey || aKey !== bKey) return false;\n      if (!deepEqual(a[aKey], b[bKey])) return false;\n    }\n    return true;\n  }\n\n  // For any other types (should be primitives by now), use strict equality.\n  return false;\n}\n\n/**\n * Returns a new array containing only the unique values from the input array.\n * Uniqueness is determined by deep equality.\n *\n * @param arr - The array of values to be filtered.\n * @returns A new array with duplicates removed.\n */\nexport function uniq<T>(arr: T[]): T[] {\n  // Use a Map where key is the deep hash and value is an array of items sharing the same hash.\n  const seen = new Map<string, T[]>();\n  const result: T[] = [];\n\n  for (const item of arr) {\n    const hash = deepHash(item);\n    if (seen.has(hash)) {\n      // There is a potential duplicate; check the stored items with the same hash.\n      const itemsWithHash = seen.get(hash)!;\n      let duplicateFound = false;\n      for (const existing of itemsWithHash) {\n        if (deepEqual(existing, item)) {\n          duplicateFound = true;\n          break;\n        }\n      }\n      if (!duplicateFound) {\n        itemsWithHash.push(item);\n        result.push(item);\n      }\n    } else {\n      // First time this hash appears.\n      seen.set(hash, [item]);\n      result.push(item);\n    }\n  }\n\n  return result;\n}\n\nexport function take<T>(a: T[], n: number): T[] {\n  return a.slice(0, n);\n}\n\nexport function addUniq<T>(arr: T[], values: T[]): T[] {\n  return uniq([...arr, ...values]);\n}\n\nexport function removeUniq<T>(arr: T[], values: T[]): T[] {\n  return arr.filter((v) => !values.includes(v));\n}\n\nexport function isAnyOf<T>(value: T, values: T[]): boolean {\n  return values.includes(value);\n}\n",
      "type": "registry:lib",
      "target": "components/dentil/data-table/filter/lib/array.ts"
    },
    {
      "path": "components/dentil/data-table/filter/lib/debounce.ts",
      "content": "/* eslint-disable @typescript-eslint/no-this-alias */\ntype ControlFunctions = {\n  cancel: () => void;\n  flush: () => void;\n  isPending: () => boolean;\n};\n\ntype DebounceOptions = {\n  leading?: boolean;\n  trailing?: boolean;\n  maxWait?: number;\n};\n\nexport function debounce<T extends (...args: any[]) => any>(\n  func: T,\n  wait: number,\n  options: DebounceOptions = {}\n): ((...args: Parameters<T>) => ReturnType<T> | undefined) & ControlFunctions {\n  const { leading = false, trailing = true, maxWait } = options;\n  let timeout: ReturnType<typeof setTimeout> | null = null;\n  let lastArgs: Parameters<T> | null = null;\n  let lastThis: any;\n  let result: ReturnType<T> | undefined;\n  let lastCallTime: number | null = null;\n  let lastInvokeTime = 0;\n\n  const maxWaitTime = maxWait !== undefined ? Math.max(wait, maxWait) : null;\n\n  function invokeFunc(time: number): ReturnType<T> | undefined {\n    if (lastArgs === null) return undefined;\n    const args = lastArgs;\n    const thisArg = lastThis;\n    lastArgs = null;\n    lastThis = null;\n    lastInvokeTime = time;\n    result = func.apply(thisArg, args);\n    return result;\n  }\n\n  function shouldInvoke(time: number): boolean {\n    if (lastCallTime === null) return false;\n    const timeSinceLastCall = time - lastCallTime;\n    const timeSinceLastInvoke = time - lastInvokeTime;\n    return (\n      lastCallTime === null ||\n      timeSinceLastCall >= wait ||\n      timeSinceLastCall < 0 ||\n      (maxWaitTime !== null && timeSinceLastInvoke >= maxWaitTime)\n    );\n  }\n\n  function startTimer(pendingFunc: () => void, waitTime: number): ReturnType<typeof setTimeout> {\n    return setTimeout(pendingFunc, waitTime);\n  }\n\n  function remainingWait(time: number): number {\n    if (lastCallTime === null) return wait;\n    const timeSinceLastCall = time - lastCallTime;\n    const timeSinceLastInvoke = time - lastInvokeTime;\n    const timeWaiting = wait - timeSinceLastCall;\n    return maxWaitTime !== null ? Math.min(timeWaiting, maxWaitTime - timeSinceLastInvoke) : timeWaiting;\n  }\n\n  function timerExpired() {\n    const time = Date.now();\n    if (shouldInvoke(time)) {\n      return trailingEdge(time);\n    }\n    timeout = startTimer(timerExpired, remainingWait(time));\n  }\n\n  function leadingEdge(time: number): ReturnType<T> | undefined {\n    lastInvokeTime = time;\n    timeout = startTimer(timerExpired, wait);\n    return leading ? invokeFunc(time) : undefined;\n  }\n\n  function trailingEdge(time: number): ReturnType<T> | undefined {\n    timeout = null;\n    if (trailing && lastArgs) {\n      return invokeFunc(time);\n    }\n    lastArgs = null;\n    lastThis = null;\n    return result;\n  }\n\n  function debounced(this: any, ...args: Parameters<T>): ReturnType<T> | undefined {\n    const time = Date.now();\n    const isInvoking = shouldInvoke(time);\n\n    lastArgs = args;\n    lastThis = this;\n    lastCallTime = time;\n\n    if (isInvoking) {\n      if (timeout === null) {\n        return leadingEdge(lastCallTime);\n      }\n      if (maxWaitTime !== null) {\n        timeout = startTimer(timerExpired, wait);\n        return invokeFunc(lastCallTime);\n      }\n    }\n    if (timeout === null) {\n      timeout = startTimer(timerExpired, wait);\n    }\n    return result;\n  }\n\n  debounced.cancel = () => {\n    if (timeout !== null) {\n      clearTimeout(timeout);\n    }\n    lastInvokeTime = 0;\n    lastArgs = null;\n    lastThis = null;\n    lastCallTime = null;\n    timeout = null;\n  };\n\n  debounced.flush = () => {\n    return timeout === null ? result : trailingEdge(Date.now());\n  };\n\n  debounced.isPending = () => {\n    return timeout !== null;\n  };\n\n  return debounced;\n}\n",
      "type": "registry:lib",
      "target": "components/dentil/data-table/filter/lib/debounce.ts"
    },
    {
      "path": "components/dentil/data-table/filter/lib/helpers.ts",
      "content": "import { isBefore } from 'date-fns';\n\nimport type { Column, ColumnOption } from '../core/types';\n\nexport function getColumn<TData>(columns: Column<TData>[], id: string) {\n  const column = columns.find((c) => c.id === id);\n\n  if (!column) {\n    throw new Error(`Column with id ${id} not found`);\n  }\n\n  return column;\n}\n\nexport function createNumberFilterValue(values: number[] | undefined): number[] {\n  if (!values || values.length === 0) return [];\n  if (values.length === 1) {\n    const firstValue = values[0];\n    return firstValue !== undefined ? [firstValue] : [];\n  }\n  if (values.length === 2) return createNumberRange(values);\n  const firstValue = values[0];\n  const secondValue = values[1];\n  return [firstValue ?? 0, secondValue ?? 0];\n}\n\nexport function createDateFilterValue(values: [Date, Date] | [Date] | [] | undefined) {\n  if (!values || values.length === 0) return [];\n  if (values.length === 1) return [values[0]];\n  if (values.length === 2) return createDateRange(values);\n  throw new Error('Cannot create date filter value from more than 2 values');\n}\n\nfunction createDateRange(values: [Date, Date]) {\n  const [a, b] = values;\n  const [min, max] = isBefore(a, b) ? [a, b] : [b, a];\n\n  return [min, max];\n}\n\nexport function createNumberRange(values: number[] | undefined) {\n  if (!values || values.length === 0) return [0, 0];\n\n  if (values.length === 1) {\n    const firstValue = values[0];\n    const a = firstValue ?? 0;\n    return [a, a]; // For single value, return same value for both min and max\n  }\n\n  const firstValue = values[0];\n  const secondValue = values[1];\n  const a = firstValue ?? 0;\n  const b = secondValue ?? 0;\n\n  const [min, max] = a < b ? [a, b] : [b, a];\n\n  return [min, max];\n}\n\nfunction isColumnOption(value: unknown): value is ColumnOption {\n  return typeof value === 'object' && value !== null && 'value' in value && 'label' in value;\n}\n\nexport function isColumnOptionArray(value: unknown): value is ColumnOption[] {\n  return Array.isArray(value) && value.every(isColumnOption);\n}\n\nexport function isColumnOptionMap(value: unknown): value is Map<string, number> {\n  if (!(value instanceof Map)) {\n    return false;\n  }\n  for (const key of value.keys()) {\n    if (typeof key !== 'string') {\n      return false;\n    }\n  }\n  for (const val of value.values()) {\n    if (typeof val !== 'number') {\n      return false;\n    }\n  }\n  return true;\n}\n\nexport function isMinMaxTuple(value: unknown): value is [number, number] {\n  return Array.isArray(value) && value.length === 2 && typeof value[0] === 'number' && typeof value[1] === 'number';\n}\n",
      "type": "registry:lib",
      "target": "components/dentil/data-table/filter/lib/helpers.ts"
    },
    {
      "path": "components/dentil/data-table/filter/lib/i18n.ts",
      "content": "import { en } from '../locales/en';\n\nexport type Locale = 'en';\n\ntype Translations = Record<string, string>;\n\nconst translations: Record<Locale, Translations> = {\n  en,\n};\n\nexport function t(key: string, locale: Locale): string {\n  return translations[locale][key] ?? key;\n}\n",
      "type": "registry:lib",
      "target": "components/dentil/data-table/filter/lib/i18n.ts"
    },
    {
      "path": "components/dentil/data-table/filter/lib/memo.ts",
      "content": "/* eslint-disable @typescript-eslint/no-unused-vars */\nexport function memo<TDeps extends readonly any[], TResult>(\n  getDeps: () => TDeps,\n  compute: (deps: TDeps) => TResult,\n  _options: { key: string }\n): () => TResult {\n  let prevDeps: TDeps | undefined;\n  let cachedResult: TResult | undefined;\n\n  return () => {\n    // console.log(`[memo] Calling memoized function: ${_options.key}`)\n\n    const deps = getDeps();\n\n    // If no previous deps or deps have changed, recompute\n    if (!prevDeps || !shallowEqual(prevDeps, deps)) {\n      // console.log(`[memo] Cache MISS - ${_options.key}`)\n      cachedResult = compute(deps);\n      prevDeps = deps;\n    } else {\n      // console.log(`[memo] Cache HIT - ${_options.key}`)\n    }\n\n    return cachedResult!;\n  };\n}\n\nfunction shallowEqual<T>(arr1: readonly T[], arr2: readonly T[]): boolean {\n  if (arr1 === arr2) return true;\n  if (arr1.length !== arr2.length) return false;\n\n  for (let i = 0; i < arr1.length; i++) {\n    if (arr1[i] !== arr2[i]) return false;\n  }\n  return true;\n}\n",
      "type": "registry:lib",
      "target": "components/dentil/data-table/filter/lib/memo.ts"
    },
    {
      "path": "components/dentil/data-table/filter/locales/en.ts",
      "content": "export const en = {\n  clear: 'Clear',\n  search: 'Search...',\n  noresults: 'No results.',\n  operators: 'Operators',\n  filter: 'Filter',\n  and: 'and',\n  single: 'Single',\n  range: 'Range',\n  value: 'Value',\n  min: 'Min',\n  max: 'Max',\n  'filters.option.is': 'is',\n  'filters.option.isNot': 'is not',\n  'filters.option.isAnyOf': 'is any of',\n  'filters.option.isNoneOf': 'is none of',\n  'filters.multiOption.include': 'includes',\n  'filters.multiOption.exclude': 'excludes',\n  'filters.multiOption.includeAnyOf': 'includes any of',\n  'filters.multiOption.excludeAllOf': 'excludes all of',\n  'filters.multiOption.includeAllOf': 'includes all of',\n  'filters.multiOption.excludeIfAnyOf': 'excludes if any of',\n  'filters.multiOption.excludeIfAll': 'excludes if all of',\n  'filters.date.is': 'is',\n  'filters.date.isNot': 'is not',\n  'filters.date.isBefore': 'is before',\n  'filters.date.isOnOrAfter': 'is on or after',\n  'filters.date.isAfter': 'is after',\n  'filters.date.isOnOrBefore': 'is on or before',\n  'filters.date.isBetween': 'is between',\n  'filters.date.isNotBetween': 'is not between',\n  'filters.text.contains': 'contains',\n  'filters.text.doesNotContain': 'does not contain',\n  'filters.number.is': 'is',\n  'filters.number.isNot': 'is not',\n  'filters.number.greaterThan': 'greater than',\n  'filters.number.greaterThanOrEqual': 'greater than or equal',\n  'filters.number.lessThan': 'less than',\n  'filters.number.lessThanOrEqual': 'less than or equal',\n  'filters.number.isBetween': 'is between',\n  'filters.number.isNotBetween': 'is not between',\n};\n",
      "type": "registry:lib",
      "target": "components/dentil/data-table/filter/locales/en.ts"
    },
    {
      "path": "components/dentil/data-table/filter/parser.ts",
      "content": "import type { TableQuery } from '../types';\n\nimport type { ColumnConfig, FilterModel, FiltersState, NumberFilterOperator } from './core/types';\n\ntype NumberRangeQuery = {\n  gt?: number;\n  lt?: number;\n  gte?: number;\n  lte?: number;\n  ne?: number;\n  nbt?: { gte?: number; lte?: number };\n};\n\nfunction isFiniteNumber(value: unknown): value is number {\n  return typeof value === 'number' && Number.isFinite(value);\n}\n\nfunction toFiniteNumber(value: unknown): number | undefined {\n  if (isFiniteNumber(value)) return value;\n  if (typeof value === 'string' && value.trim() !== '') {\n    const parsed = Number(value);\n    if (Number.isFinite(parsed)) return parsed;\n  }\n  return undefined;\n}\n\nfunction coerceQueryValue(value: unknown): unknown {\n  if (typeof value !== 'string') return value;\n  const trimmed = value.trim();\n  if ((trimmed.startsWith('{') && trimmed.endsWith('}')) || (trimmed.startsWith('[') && trimmed.endsWith(']'))) {\n    try {\n      return JSON.parse(trimmed);\n    } catch {\n      return value;\n    }\n  }\n  return value;\n}\n\nfunction getNumberScale(column?: ColumnConfig<unknown, 'number'> | ColumnConfig<any, any, any, any>): number {\n  if (!column || column.type !== 'number') return 1;\n  const scale = column.scale;\n  return typeof scale === 'number' && Number.isFinite(scale) && scale > 0 ? scale : 1;\n}\n\nfunction scaleToQuery(value: number, scale: number): number {\n  return scale === 1 ? value : Math.round(value * scale);\n}\n\nfunction scaleFromQuery(value: number, scale: number): number {\n  return scale === 1 ? value : value / scale;\n}\n\nfunction parseNumberToQuery(filter: FilterModel<'number'>, scale: number): TableQuery[string] | undefined {\n  const values = filter.values.filter(isFiniteNumber).map((value) => scaleToQuery(value, scale));\n  if (values.length === 0) return undefined;\n\n  const value = values[0]!;\n  const max = values[1];\n\n  switch (filter.operator) {\n    case 'is':\n      return value;\n    case 'is not':\n      return { ne: value };\n    case 'is less than':\n      return { lt: value };\n    case 'is greater than':\n      return { gt: value };\n    case 'is greater than or equal to':\n      return { gte: value };\n    case 'is less than or equal to':\n      return { lte: value };\n    case 'is between':\n      return max === undefined ? { gte: value } : { gte: value, lte: max };\n    case 'is not between':\n      return max === undefined ? { nbt: { gte: value } } : { nbt: { gte: value, lte: max } };\n    default:\n      return value;\n  }\n}\n\nfunction parseNumberFromQuery(\n  value: unknown,\n  scale: number\n): { operator: NumberFilterOperator; values: number[] } | null {\n  const coerced = coerceQueryValue(value);\n  const fromQuery = (raw: unknown) => {\n    const parsed = toFiniteNumber(raw);\n    return parsed === undefined ? undefined : scaleFromQuery(parsed, scale);\n  };\n\n  if (isFiniteNumber(coerced) || typeof coerced === 'string') {\n    const parsed = fromQuery(coerced);\n    if (parsed === undefined) return null;\n    return { operator: 'is', values: [parsed] };\n  }\n\n  if (!coerced || typeof coerced !== 'object' || Array.isArray(coerced)) {\n    return null;\n  }\n\n  const range = coerced as NumberRangeQuery;\n  const nbtGte = fromQuery(range.nbt?.gte);\n  const nbtLte = fromQuery(range.nbt?.lte);\n  if (nbtGte !== undefined || nbtLte !== undefined) {\n    return { operator: 'is not between', values: [nbtGte ?? nbtLte ?? 0, nbtLte ?? nbtGte ?? 0] };\n  }\n\n  const gt = fromQuery(range.gt);\n  const lt = fromQuery(range.lt);\n  const gte = fromQuery(range.gte);\n  const lte = fromQuery(range.lte);\n  const ne = fromQuery(range.ne);\n\n  // The dashboard only writes inclusive pairs (`gte`+`lte`) or a single bound.\n  // If a URL has both ends (including mixed exclusive/inclusive), keep both so\n  // reload does not drop one side.\n  const lower = gte ?? gt;\n  const upper = lte ?? lt;\n  if (lower !== undefined && upper !== undefined) {\n    return { operator: 'is between', values: [lower, upper] };\n  }\n  if (gt !== undefined) return { operator: 'is greater than', values: [gt] };\n  if (lt !== undefined) return { operator: 'is less than', values: [lt] };\n  if (gte !== undefined) return { operator: 'is greater than or equal to', values: [gte] };\n  if (lte !== undefined) return { operator: 'is less than or equal to', values: [lte] };\n  if (ne !== undefined) return { operator: 'is not', values: [ne] };\n\n  return null;\n}\n\nexport function parseToQuery(\n  filters: FiltersState,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  filterColumns?: ReadonlyArray<ColumnConfig<any, any, any, any>>\n): TableQuery {\n  return filters.reduce<TableQuery>((acc, filter) => {\n    if (filter.type === 'option') {\n      acc[filter.columnId] = filter.values.length === 1 ? filter.values[0] : filter.values;\n    } else if (filter.type === 'text') {\n      acc[filter.columnId] = filter.values?.[0];\n    } else if (filter.type === 'number') {\n      const column = filterColumns?.find((item) => item.id === filter.columnId);\n      const parsed = parseNumberToQuery(filter as FilterModel<'number'>, getNumberScale(column));\n      if (parsed !== undefined) {\n        acc[filter.columnId] = parsed;\n      }\n    }\n    return acc;\n  }, {});\n}\n\nexport function parseToFilters<TData>({\n  query,\n  filterColumns,\n}: {\n  query: TableQuery;\n  filterColumns: ReadonlyArray<ColumnConfig<TData, any, any, any>>;\n}): FiltersState {\n  return Object.entries(query)\n    .map(([columnId, value]) => {\n      const column = filterColumns.find((column) => column.id === columnId);\n      if (!column) {\n        return null;\n      }\n\n      if (column.type === 'number') {\n        const parsed = parseNumberFromQuery(value, getNumberScale(column));\n        if (!parsed) return null;\n        return {\n          columnId,\n          operator: parsed.operator,\n          type: column.type,\n          values: parsed.values,\n        };\n      }\n\n      return {\n        columnId,\n        operator: column.type === 'text' ? 'contains' : 'is',\n        type: column.type,\n        values: Array.isArray(value) ? value : [value],\n      };\n    })\n    .filter((filter): filter is NonNullable<typeof filter> => filter !== null);\n}\n",
      "type": "registry:lib",
      "target": "components/dentil/data-table/filter/parser.ts"
    },
    {
      "path": "components/dentil/data-table/filter/ui/debounced-input.tsx",
      "content": "'use client';\n\nimport { useEffect, useRef, useState } from 'react';\n\nimport { Input } from '@/components/ui/input';\n\ntype Pending = { value: string | number; timer: ReturnType<typeof setTimeout> };\n\nexport function DebouncedInput({\n  value: initialValue,\n  onChange,\n  debounceMs = 300, // This is the wait time, not the function\n  ...props\n}: {\n  value: string | number;\n  onChange: (value: string | number) => void;\n  debounceMs?: number;\n} & Omit<React.InputHTMLAttributes<HTMLInputElement>, 'onChange'>) {\n  const [value, setValue] = useState(initialValue);\n\n  // Sync with initialValue when it changes\n  useEffect(() => {\n    setValue(initialValue);\n  }, [initialValue]);\n\n  // Callers pass a new `onChange` on every render. Holding it in a ref keeps the pending call alive across parent\n  // re-renders (such as new table data arriving), which would otherwise cancel it and drop the last keystrokes.\n  const onChangeRef = useRef(onChange);\n  useEffect(() => {\n    onChangeRef.current = onChange;\n  });\n\n  const pendingRef = useRef<Pending | null>(null);\n\n  const flush = () => {\n    const pending = pendingRef.current;\n    if (!pending) return;\n    clearTimeout(pending.timer);\n    pendingRef.current = null;\n    onChangeRef.current(pending.value);\n  };\n\n  // Apply a pending value on unmount, so closing the popover straight after typing doesn't lose it.\n  useEffect(() => {\n    const pending = pendingRef;\n    const latestOnChange = onChangeRef;\n    return () => {\n      if (!pending.current) return;\n      clearTimeout(pending.current.timer);\n      latestOnChange.current(pending.current.value);\n      pending.current = null;\n    };\n  }, []);\n\n  const updateValueAndDebounce = (e: React.ChangeEvent<HTMLInputElement>) => {\n    const newValue = e.target.value;\n    setValue(newValue);\n    if (pendingRef.current) clearTimeout(pendingRef.current.timer);\n    pendingRef.current = { value: newValue, timer: setTimeout(flush, debounceMs) };\n  };\n\n  return <Input {...props} value={value} onChange={updateValueAndDebounce} />;\n}\n",
      "type": "registry:component",
      "target": "components/dentil/data-table/filter/ui/debounced-input.tsx"
    }
  ],
  "type": "registry:block"
}
