Filament Header Filters

https://github.com/leek/filament-header-filters
Admin
Inline header filters for Filament tables. Attach any BaseFilter to a column header — select...
Tokens:23,301
Snippets:174
Trust Score:9.6
License:MIT
Update:3 weeks ago
Show doc for...
Tokens:
Raw
### Install leek/filament-header-filters with Composer

Source: https://github.com/leek/filament-header-filters/blob/main/README.md

Install the package via Composer.

```bash
composer require leek/filament-header-filters
```

--------------------------------

### Verify table readiness before getTable()

Source: https://github.com/leek/filament-header-filters/blob/main/_autodocs/api-reference/has-header-filters-trait.md

Advanced example for controlling registration timing. Use this guard to verify the table is ready before calling $this->getTable() in your own page code.

```php
if ($this->hasInitializedTableForHeaderFilters()) {
    // table is hydrated — safe to call $this->getTable()
}
```

--------------------------------

### Comment example for configurePackage invocation

Source: https://github.com/leek/filament-header-filters/blob/main/_autodocs/api-reference/service-provider.md

Shows a comment block indicating that the method is invoked automatically during provider resolution and that views become available as 'filament-header-filters::<name>'.

```php
// Invoked automatically during provider resolution.
// The package's views become available as:
//   filament-header-filters::<name>
```

--------------------------------

### Call RegisterMacros::register() in packageBooted

Source: https://github.com/leek/filament-header-filters/blob/main/_autodocs/api-reference/register-macros.md

Example of calling RegisterMacros::register() from the service provider's packageBooted method.

```php
public function packageBooted(): void
{
    RegisterMacros::register();
    // ...
}
```

--------------------------------

### Example of setFilterColumnName usage

Source: https://github.com/leek/filament-header-filters/blob/main/_autodocs/api-reference/header-filter-registry.md

Demonstrates how BaseFilter::columnName() works internally: sets the column name and retrieves it.

```php
$filter = SelectFilter::make('status');

HeaderFilterRegistry::setFilterColumnName($filter, 'status');
echo HeaderFilterRegistry::getFilterColumnName($filter); // "status"
```

--------------------------------

### Safe retrieval example using hasColumnFilter and getColumnFilter

Source: https://github.com/leek/filament-header-filters/blob/main/_autodocs/api-reference/header-filter-registry.md

Shows how to safely retrieve a filter after checking it exists, ensuring the returned filter is non-null.

```php
if (HeaderFilterRegistry::hasColumnFilter($column)) {
    $filter = HeaderFilterRegistry::getColumnFilter($column); // non-null
}
```

--------------------------------

### Run test suite with composer test

Source: https://github.com/leek/filament-header-filters/blob/main/README.md

Runs the test suite for this Filament plugin. Ensure Composer is installed and dependencies are set up before running.

```bash
composer test

```

--------------------------------

### Example usage of setColumnFilter

Source: https://github.com/leek/filament-header-filters/blob/main/_autodocs/api-reference/header-filter-registry.md

Shows how to bind a column to a filter and later detach it by passing null, mimicking what Column::headerFilter() does internally.

```php
$column = $table->getColumn('status');

HeaderFilterRegistry::setColumnFilter($column, SelectFilter::make('status'));

// later, to detach:
HeaderFilterRegistry::setColumnFilter($column, null);
```

--------------------------------

### register(selector, selectRootSelector = null)

Source: https://github.com/leek/filament-header-filters/blob/main/_autodocs/api-reference/views-and-assets.md

Registers CSS selectors for badge containers and optional select root, starts observers, and schedules an initial pass.

```APIDOC
## register(selector, selectRootSelector = null)

### Description
Registers CSS selectors for badge containers and optional select root, starts observers (rAF scheduler, MutationObserver, ResizeObserver), and schedules an initial pass.

### Method
register

### Parameters
- **selector** (string) - Required - CSS selector matching badge containers (elements observed for responsive overflow)
- **selectRootSelector** (string | null) - Optional - Default: null - CSS selector matching the Alpine select root (`.fi-select-input`) used to locate the `select` data object

### Returns
No return value (undefined)

### Example
```js
const overflow = window.FilamentResponsiveBadgeOverflow;
overflow.register('.fi-ta-header-filter .fi-select-input-value-badges-ctn', '.fi-ta-header-filter .fi-select-input');
```
```

--------------------------------

### Attach dropdown filter to TextColumn

Source: https://github.com/leek/filament-header-filters/blob/main/_autodocs/api-reference/register-macros.md

Example of attaching a select filter to a text column.

```php
use App\Enums\OrderStatus;
use Filament\Tables\Columns\TextColumn;
use Filament\Tables\Filters\SelectFilter;

TextColumn::make('status')
    ->badge()
    ->headerFilter(
        SelectFilter::make('status')
            ->options(OrderStatus::class)
            ->native(false)
    );
```

--------------------------------

### Multi-field custom filter with null-default handling

Source: https://github.com/leek/filament-header-filters/blob/main/_autodocs/api-reference/register-macros.md

Example of a multi-field filter with range inputs and a query that safely handles null defaults.

```php
use Filament\Forms\Components\TextInput;
use Filament\Tables\Columns\TextColumn;
use Filament\Tables\Filters\Filter;
use Illuminate\Database\Eloquent\Builder;

TextColumn::make('total_price')
    ->headerFilter(
        Filter::make('total_price_range')
            ->columns(2)
            ->schema([
                TextInput::make('min')->numeric()->placeholder('Min'),
                TextInput::make('max')->numeric()->placeholder('Max'),
            ])
            ->query(fn (Builder $query, array $data): Builder => $query
                ->when($data['min'] ?? null, fn (Builder $q, $v): Builder => $q->where('total_price', '>=', $v))
                ->when($data['max'] ?? null, fn (Builder $q, $v): Builder => $q->where('total_price', '<=', $v))
            )
    );
```

--------------------------------

### Guard usage example for isTableRegistered and markTableRegistered

Source: https://github.com/leek/filament-header-filters/blob/main/_autodocs/api-reference/header-filter-registry.md

Shows the per-instance guard used by the trait: checks if the table is already registered, returns early if so, otherwise pushes filters and marks the table as registered.

```php
$table = $this->getTable();

if (HeaderFilterRegistry::isTableRegistered($table)) {
    return; // already pushed filters for this instance
}

// ... push filters, seed state ...
HeaderFilterRegistry::markTableRegistered($table);
```

--------------------------------

### Custom Livewire table page using HasHeaderFilters

Source: https://github.com/leek/filament-header-filters/blob/main/_autodocs/api-reference/has-header-filters-trait.md

Example of a Livewire component that uses InteractsWithTable and HasHeaderFilters traits. The table method defines a column with a header filter, and registration happens automatically.

```php
use Filament\Tables\Concerns\InteractsWithTable;
use Filament\Tables\Table;
use Leek\FilamentHeaderFilters\Concerns\HasHeaderFilters;

class OrderBrowser extends Component implements HasTable
{
    use InteractsWithTable;
    use HasHeaderFilters;

    public function table(Table $table): Table
    {
        return $table
            ->columns([
                TextColumn::make('status')
                    ->headerFilter(SelectFilter::make('status')->options(OrderStatus::class)),
            ]);
    }
}
```

--------------------------------

### Use Table::getHeaderFilters() to inspect and order header filters

Source: https://github.com/leek/filament-header-filters/blob/main/_autodocs/api-reference/register-macros.md

Example of using `getHeaderFilters()` to inspect what will render and apply custom ordering. It iterates over the returned filter array, logging each filter's name and its associated column name.

```php
$headerFilters = $table->getHeaderFilters(); // e.g. ['status' => SelectFilter, 'created_at' => Filter]

foreach ($headerFilters as $name => $filter) {
    logger("$name is a header filter on column {$filter->getColumnName()}");
}
```

--------------------------------

### Column::headerFilter(?BaseFilter $filter): Column

Source: https://github.com/leek/filament-header-filters/blob/main/_autodocs/api-reference/register-macros.md

Macro installed on `Filament\Tables\Columns\Column` that attaches a filter to a column, or detaches it when `null` is passed.

```APIDOC
## Column::headerFilter(?BaseFilter $filter): Column

### Description
Attaches a filter to a column, or detaches it when `null` is passed. Stores the column→filter binding in `HeaderFilterRegistry` and, when the filter is non-null, also records the column's name on the filter (making `BaseFilter::isHeaderFilter()` return `true` for it). Passing `null` unbinds any existing header filter and does *not* touch the previous filter's column name.

### Method
`Column::headerFilter(?BaseFilter $filter): Column`

### Parameters
- `$filter` (`?Filament\Tables\Filters\BaseFilter`) - Required - The filter to attach to the column, or `null` to detach/clear.

### Returns
`Column` — `$this`, so it chains fluently from column definitions.

### Example — dropdown filter
```php
use App\Enums\OrderStatus;
use Filament\Tables\Columns\TextColumn;
use Filament\Tables\Filters\SelectFilter;

TextColumn::make('status')
    ->badge()
    ->headerFilter(
        SelectFilter::make('status')
            ->options(OrderStatus::class)
            ->native(false)
    );
```

### Example — multi-field custom filter with error-free null-default handling
```php
use Filament\Forms\Components\TextInput;
use Filament\Tables\Columns\TextColumn;
use Filament\Tables\Filters\Filter;
use Illuminate\Database\Eloquent\Builder;

TextColumn::make('total_price')
    ->headerFilter(
        Filter::make('total_price_range')
            ->columns(2)
            ->schema([
                TextInput::make('min')->numeric()->placeholder('Min'),
                TextInput::make('max')->numeric()->placeholder('Max'),
            ])
            ->query(fn (Builder $query, array $data): Builder => $query
                ->when($data['min'] ?? null, fn (Builder $q, $v): Builder => $q->where('total_price', '>=', $v))
                ->when($data['max'] ?? null, fn (Builder $q, $v): Builder => $q->where('total_price', '<=', $v))
            )
    );
```
```

--------------------------------

### Automatic registration comment example

Source: https://github.com/leek/filament-header-filters/blob/main/_autodocs/api-reference/has-header-filters-trait.md

A comment block indicating that no direct calls are needed because the method runs automatically during registration, and explaining the reliance on CSS-hide for the removeTableFilter functionality.

```php
// No direct calls needed. The indicator badge ✕ (removeTableFilter) relies on
// this CSS-hide: state is cleared, row is hidden, but Filament can still reset
// the underlying fields because the group was never schema-hidden.
```

--------------------------------

### BaseFilter::columnName(?string $name): BaseFilter

Source: https://github.com/leek/filament-header-filters/blob/main/_autodocs/api-reference/register-macros.md

Macro installed on BaseFilter to set the owning column's name for the filter.

```APIDOC
## BaseFilter::columnName(?string $name): BaseFilter

### Description
Sets the owning column's name for this filter, or clears it if null. Returns $this for chaining.

### Method
Macro

### Endpoint
BaseFilter::columnName(?string $name)

### Parameters
- **$name** (?string) - Required - The owning column's name, or null to clear.

### Returns
- **BaseFilter** - $this for chaining.

### Behavior
Records the filter→column-name association in the registry. null clears it, which also makes isHeaderFilter() return false again. This is invoked automatically on each header filter during trait registration.

### Example
```php
$filter = SelectFilter::make('status');
$filter->columnName('status');

echo $filter->getColumnName(); // "status"
echo $filter->isHeaderFilter() ? 'yes' : 'no'; // "yes"
```
```

--------------------------------

### Column::getHeaderFilter() macro registration and usage

Source: https://github.com/leek/filament-header-filters/blob/main/_autodocs/api-reference/register-macros.md

Registers a macro that returns the filter bound to a column, or null if none. The example shows how to use it; the returned filter is guaranteed non-null when hasHeaderFilter() returns true.

```php
Column::macro('getHeaderFilter', function (): ?BaseFilter {
    /** @var Column $this */
    return HeaderFilterRegistry::getColumnFilter($this);
});
```

```php
$filter = $column->getHeaderFilter();

if ($filter !== null) {
    // e.g. $filter->getName(), $filter->getColumnName()
}
```

--------------------------------

### BaseFilter::getColumnName() macro registration and usage

Source: https://github.com/leek/filament-header-filters/blob/main/_autodocs/api-reference/register-macros.md

Registers the getColumnName macro on BaseFilter. The macro returns the column name from HeaderFilterRegistry, or null if not set. The example shows checking the returned column name against a specific value.

```php
BaseFilter::macro('getColumnName', function (): ?string {
    /** @var BaseFilter $this */
    return HeaderFilterRegistry::getFilterColumnName($this);
});
```

```php
$columnName = $filter->getColumnName();

if ($columnName !== null && $columnName === 'status') {
    // filter drives the status column
}
```

--------------------------------

### Hide panel filter button with FiltersLayout::Hidden and headerFilter

Source: https://github.com/leek/filament-header-filters/blob/main/_autodocs/api-reference/register-macros.md

Hides the panel filter button when only header filters exist by using `FiltersLayout::Hidden` on the table and attaching a header filter to a column. This example demonstrates a typical table definition returning a Table instance with hidden filters layout.

```php
use Filament\Tables\Enums\FiltersLayout;

public function table(Table $table): Table
{
    return $table
        ->filtersLayout(FiltersLayout::Hidden)
        ->columns([
            TextColumn::make('status')->headerFilter(/* ... */),
        ]);
}
```

--------------------------------

### Column::hasHeaderFilter() macro registration and usage

Source: https://github.com/leek/filament-header-filters/blob/main/_autodocs/api-reference/register-macros.md

Registers a macro that returns true if a header filter is bound to the column. The example shows a typical usage in a registration loop or table view where getHeaderFilter() is guaranteed non-null after the check.

```php
Column::macro('hasHeaderFilter', function (): bool {
    /** @var Column $this */
    return HeaderFilterRegistry::hasColumnFilter($this);
});
```

```php
foreach ($table->getColumns() as $column) {
    if (! $column->hasHeaderFilter()) {
        continue;
    }
    // $column->getHeaderFilter() is guaranteed non-null here
}
```

--------------------------------

### BaseFilter::isHeaderFilter() macro registration and usage

Source: https://github.com/leek/filament-header-filters/blob/main/_autodocs/api-reference/register-macros.md

Registers the isHeaderFilter macro on BaseFilter. The macro returns true when the filter has a non-empty column name recorded :) and is used to distinguish header filters from regular panel filters. The example shows iterating over filters and using isHeaderFilter to conditionally hide them in the panel form.

```php
BaseFilter::macro('isHeaderFilter', function (): bool {
    /** @var BaseFilter $this */
    return filled(HeaderFilterRegistry::getFilterColumnName($this));
});
```

```php
foreach ($filters as $filterName => $group) {
    $filter = $table->getFilter($filterName);

    if ($filter instanceof BaseFilter && $filter->isHeaderFilter()) {
        // CSS-hide this group in the panel filters form
    }
}
```

--------------------------------

### BaseFilter::columnName() macro registration and usage

Source: https://github.com/leek/filament-header-filters/blob/main/_autodocs/api-reference/register-macros.md

Registers a macro that sets the owning column name for a filter, returning $this for chaining. Passing null clears the association and makes isHeaderFilter() return false. The example shows setting the column name and verifying the result.

```php
BaseFilter::macro('columnName', function (?string $name): BaseFilter {
    /** @var BaseFilter $this */
    HeaderFilterRegistry::setFilterColumnName($this, $name);

    return $this;
});
```

```php
$filter = SelectFilter::make('status');
$filter->columnName('status');

echo $filter->getColumnName(); // "status"
echo $filter->isHeaderFilter() ? 'yes' : 'no'; // "yes"
```

--------------------------------

### prependFilamentTableView() method implementation

Source: https://github.com/leek/filament-header-filters/blob/main/_autodocs/api-reference/service-provider.md

Protected method that waits for the 'view' resolver and prepends the package's resources/views/vendor/filament-tables directory to the 'filament-tables' view namespace. The is_dir() check ensures the override is safe if resources are removed. Returns void and never throws.

```php
protected function prependFilamentTableView(): void
{
    $this->callAfterResolving('view', function ($view, Application $app): void {
        $viewsPath = __DIR__.'/../resources/views/vendor/filament-tables';

        if (is_dir($viewsPath)) {
            $view->prependNamespace('filament-tables', $viewsPath);
        }
    });
}
```

--------------------------------

### packageBooted() method

Source: https://github.com/leek/filament-header-filters/blob/main/_autodocs/api-reference/service-provider.md

Registers macros, registers the JS asset 'filament-header-filters.js' with FilamentAsset, and prepends the patched table view. The asset is available via FilamentAsset::getScriptSrc('filament-header-filters', 'leek/filament-header-filters').

```php
public function packageBooted(): void
{
    RegisterMacros::register();

    FilamentAsset::register(
        assets: [
            Js::make('filament-header-filters', __DIR__.'/../resources/js/filament-header-filters.js'),
        ],
        package: 'leek/filament-header-filters',
    );

    $this->prependFilamentTableView();
}
```

--------------------------------

### Rebuild assets with npm run build

Source: https://github.com/leek/filament-header-filters/blob/main/README.md

Rebuild app assets after adding the stylesheet.

```bash
npm run build
```

--------------------------------

### Event: filament-responsive-badge-overflow:ready

Source: https://github.com/leek/filament-header-filters/blob/main/_autodocs/api-reference/views-and-assets.md

Fired on window when the module is ready, providing the module object in detail.overflow for registering additional containers.

```APIDOC
## Event: filament-responsive-badge-overflow:ready

### Description
Fired on window when the module is ready, providing the module object in `detail.overflow` for registering additional containers.

### Event Type
CustomEvent

### Detail Fields
- **detail.overflow** (object) - The module object `{ register, schedule }` namespace, handy for registering extra containers from your own script.

### Example
```html
<script>
    document.addEventListener('filament-responsive-badge-overflow:ready', (event) => {
        event.detail.overflow.register('.my-custom-badge-container');
    });
</script>
```
```

--------------------------------

### renderingHasHeaderFilters() implementation

Source: https://github.com/leek/filament-header-filters/blob/main/_autodocs/api-reference/has-header-filters-trait.md

Livewire lifecycle hook invoked on every render. Re-runs registration defensively; the per-Table-instance registration guard makes this a cheap no-op after the first pass.

```php
public function renderingHasHeaderFilters(): void
{
    $this->registerTableHeaderFilters();
}
```

--------------------------------

### Initialize and register FilamentResponsiveBadgeOverflow

Source: https://github.com/leek/filament-header-filters/blob/main/_autodocs/api-reference/views-and-assets.md

Initializes the module on window.FilamentResponsiveBadgeOverflow, registers the default header-filter select containers, and dispatches a ready event with the module object in detail.overflow.

```javascript
window[namespace] = window[namespace] || createResponsiveBadgeOverflow();
window[namespace].register(
    '.fi-ta-header-filter .fi-select-input-value-badges-ctn',
    '.fi-ta-header-filter .fi-select-input',
);
window.dispatchEvent(new CustomEvent('filament-responsive-badge-overflow:ready', {
    detail: { overflow: window[namespace] },
}));
```

--------------------------------

### configurePackage(Package $package) method

Source: https://github.com/leek/filament-header-filters/blob/main/_autodocs/api-reference/service-provider.md

Configures the package with name 'filament-header-filters' and registers its blade view namespace. No configuration file is shipped. This method is invoked by the framework and never called directly by consumers.

```php
public function configurePackage(Package $package): void
{
    $package
        ->name(static::$name)
        ->hasViews('filament-header-filters');
}
```

--------------------------------

### Run npm run dev for Vite

Source: https://github.com/leek/filament-header-filters/blob/main/README.md

Run the Vite development server (restart or keep running) when working locally.

```bash
npm run dev
```

--------------------------------

### Public static property $name

Source: https://github.com/leek/filament-header-filters/blob/main/_autodocs/api-reference/service-provider.md

The package name used for configuration and scoping.

```php
public static string $name = 'filament-header-filters';
```

--------------------------------

### bootedHasHeaderFilters() implementation

Source: https://github.com/leek/filament-header-filters/blob/main/_autodocs/api-reference/has-header-filters-trait.md

Livewire lifecycle hook called once per component boot. Registers header filters before the first render. Never throws on its own.

```php
public function bootedHasHeaderFilters(): void
{
    $this->registerTableHeaderFilters();
}
```

--------------------------------

### Import RegisterMacros

Source: https://github.com/leek/filament-header-filters/blob/main/_autodocs/api-reference/register-macros.md

Import the RegisterMacros class to call its static methods.

```php
use Leek\FilamentHeaderFilters\Macros\RegisterMacros;
```

--------------------------------

### Table::hasHeaderFilters(): bool

Source: https://github.com/leek/filament-header-filters/blob/main/_autodocs/api-reference/register-macros.md

Documentation for the Table::hasHeaderFilters() macro.

```APIDOC
## Macro: Table::hasHeaderFilters(): bool

### Description
Returns `true` when at least one visible, non-hidden column carries a header filter. Useful for conditionally showing UI elements based on the presence of header filters.

### Method
Macro

### Endpoint
Table::hasHeaderFilters()

### Parameters
None

### Returns
- **bool** - `true` if there is at least one header filter, `false` otherwise.

### Example
```php
$isColumnSearchVisible = $isSearchableByColumn() || ((method_exists($table, 'hasHeaderFilters') || (method_exists($table, 'hasMacro') && $table->hasMacro('hasHeaderFilters'))) && $table->hasHeaderFilters());
```
```

--------------------------------

### Register additional select containers

Source: https://github.com/leek/filament-header-filters/blob/main/_autodocs/api-reference/views-and-assets.md

Registers additional select containers by listening for the ready event and calling register with a custom selector.

```html
<script>
    document.addEventListener('filament-responsive-badge-overflow:ready', (event) => {
        event.detail.overflow.register('.my-custom-badge-container');
    });
</script>
```

--------------------------------

### RegisterMacros::register()

Source: https://github.com/leek/filament-header-filters/blob/main/_autodocs/api-reference/register-macros.md

Registers all package macros by invoking the internal registration methods. Called once per package boot; never throws.

```php
public static function register(): void
{
    self::registerColumnMacros();
    self::registerFilterMacros();
    self::registerTableMacros();
}
```

--------------------------------

### Import HeaderFilterRegistry class

Source: https://github.com/leek/filament-header-filters/blob/main/_autodocs/api-reference/header-filter-registry.md

Imports the HeaderFilterRegistry class for use in PHP code.

```php
use Leek\FilamentHeaderFilters\Support\HeaderFilterRegistry;
```

--------------------------------

### Publish views command

Source: https://github.com/leek/filament-header-filters/blob/main/_autodocs/api-reference/service-provider.md

Artisan command to publish the package's views using the standard package-tools tag 'filament-header-filters-views'. There is no config publication tag.

```bash
php artisan vendor:publish --tag=filament-header-filters-views
```

--------------------------------

### Table::getHeaderFilters(): array

Source: https://github.com/leek/filament-header-filters/blob/main/_autodocs/api-reference/register-macros.md

Documentation for the Table::getHeaderFilters() macro.

```APIDOC
## Macro: Table::getHeaderFilters(): array

### Description
Returns an associative array of header filters from visible columns that have a header filter and are not hidden. Filters that are not visible are skipped, and if two columns share the same filter name, the last one wins.

### Method
Macro

### Endpoint
Table::getHeaderFilters()

### Parameters
None

### Returns
- **array** - An associative array `array<string, BaseFilter>` keyed by `BaseFilter::getName()`.

### Example
```php
$headerFilters = $table->getHeaderFilters(); // e.g. ['status' => SelectFilter, 'created_at' => Filter]

foreach ($headerFilters as $name => $filter) {
    logger("$name is a header filter on column {$filter->getColumnName()}");
}
```
```

--------------------------------

### Test seedHeaderFilterState via trait alias

Source: https://github.com/leek/filament-header-filters/blob/main/_autodocs/api-reference/has-header-filters-trait.md

Shows how to test seedHeaderFilterState by exposing it via trait alias, as done in tests/RegistryTest.php. Demonstrates the resulting tableFilters state for a Select component.

```php
use Filament\Forms\Components\Select;
use Filament\Tables\Filters\BaseFilter;
use Leek\FilamentHeaderFilters\Concerns\HasHeaderFilters;

$component = new class
{
    use HasHeaderFilters {
        seedHeaderFilterState as public;
    }

    public ?array $tableFilters = [];
};

$component->seedHeaderFilterState([
    (new class('role') extends BaseFilter
    {
        public function getSchemaComponents(): array
        {
            return [
                Select::make('value')->options(['analyst' => 'Analyst']),
            ];
        }
    }),
]);
// $component->tableFilters['role']['value'] now equals the Select's default state
```

--------------------------------

### schedule()

Source: https://github.com/leek/filament-header-filters/blob/main/_autodocs/api-reference/views-and-assets.md

Triggers a rAF-queued re-measure and re-render of every registered container. Called automatically on morph.updated and livewire:navigated.

```APIDOC
## schedule()

### Description
Triggers a rAF-queued re-measure and re-render of every registered container. Called automatically on `morph.updated` (via `Livewire.hook('morph.updated', schedule)`) and `livewire:navigated`.

### Method
schedule

### Parameters
None

### Returns
No return value (undefined)

### Example
```js
const overflow = window.FilamentResponsiveBadgeOverflow;
overflow.schedule();
```
```

--------------------------------

### composer.json auto-discovery configuration

Source: https://github.com/leek/filament-header-filters/blob/main/_autodocs/api-reference/service-provider.md

Configures Laravel to auto-discover the package's service provider via the extra.laravel.providers entry.

```json
"extra": {
    "laravel": {
        "providers": [
            "Leek\\FilamentHeaderFilters\\FilamentHeaderFiltersServiceProvider"
        ]
    }
}
```

--------------------------------

### Dropdown header filter with SelectFilter

Source: https://github.com/leek/filament-header-filters/blob/main/README.md

Apply a SelectFilter for exact-match column filtering; default placeholder is "All".

```php
use App\Enums\OrderStatus;
use Filament\Tables\Columns\TextColumn;
use Filament\Tables\Filters\SelectFilter;

TextColumn::make('status')
    ->badge()
    ->headerFilter(
        SelectFilter::make('status')
            ->options(OrderStatus::class)
            ->native(false)
    )
```

--------------------------------

### Seed header filter state with seedHeaderFilterState()

Source: https://github.com/leek/filament-header-filters/blob/main/_autodocs/api-reference/has-header-filters-trait.md

Seeds filter state from header filters. For each filter, initializes $this->tableFilters[$filterName] with field defaults and resets stale array values for single Select fields.

```php
/**
 * @param  array<BaseFilter>  $headerFilters
 */
protected function seedHeaderFilterState(array $headerFilters): void
{
    $this->tableFilters ??= [];

    foreach ($headerFilters as $filter) {
        $filterName = $filter->getName();
        $state = $this->tableFilters[$filterName] ?? [];

        if (! is_array($state)) {
            $state = [];
        }

        foreach ($filter->getSchemaComponents() as $component) {
            if (! $component instanceof Field) {
                continue;
            }

            $fieldName = $component->getName();

            if (! array_key_exists($fieldName, $state)) {
                $state[$fieldName] = $component->getDefaultState();
            }

            if ($component instanceof Select && (! $component->isMultiple()) && is_array($state[$fieldName])) {
                $state[$fieldName] = null;
            }
        }

        $this->tableFilters[$filterName] = $state;
    }
}
```

--------------------------------

### registerTableHeaderFilters() implementation

Source: https://github.com/leek/filament-header-filters/blob/main/_autodocs/api-reference/has-header-filters-trait.md

Protected method that iterates table columns, collects those with header filters, sets column names, pushes filters to the table, caches forms, seeds state, and marks the table as registered. Registration is tracked per Table instance to handle resetTable().

```php
protected function registerTableHeaderFilters(): void
{
    if (! $this->hasInitializedTableForHeaderFilters()) {
        return;
    }

    $table = $this->getTable();

    // Registration is tracked per Table instance, not via a once-per-request flag:
    // resetTable() rebuilds the table from scratch (a new instance) and drops the
    // filters pushed below, so a flag would leave them selected but un-applied.
    if (HeaderFilterRegistry::isTableRegistered($table)) {
        return;
    }

    $headerFilters = [];

    foreach ($table->getColumns() as $column) {
        if (! $column->hasHeaderFilter()) {
            continue;
        }

        $filter = $column->getHeaderFilter();

        $filter->columnName($column->getName());

        $headerFilters[] = $filter;
    }

    if (empty($headerFilters)) {
        HeaderFilterRegistry::markTableRegistered($table);

        return;
    }

    $table->pushFilters($headerFilters);

    $this->hideHeaderFilterGroupsFromPanelForm($table);

    $this->cacheSchema(
        'tableFiltersForm',
        $this->getTableFiltersForm(...),
    );

    $this->cacheSchema(
        'tableHeaderFiltersForm',
        $this->getTableHeaderFiltersForm(...),
    );

    $this->seedHeaderFilterState($headerFilters);

    HeaderFilterRegistry::markTableRegistered($table);
}
```

--------------------------------

### Import package CSS into panel theme

Source: https://github.com/leek/filament-header-filters/blob/main/_autodocs/api-reference/service-provider.md

CSS imports to add to the panel theme built with ->viteTheme(...). The stylesheet is not auto-registered; consumers must import it manually as shown.

```css
@import '../../../../vendor/filament/filament/resources/css/theme.css';
@import '../../../../vendor/leek/filament-header-filters/resources/css/filament-header-filters.css';
```

--------------------------------

### Service provider class definition

Source: https://github.com/leek/filament-header-filters/blob/main/_autodocs/api-reference/service-provider.md

Defines the FilamentHeaderFiltersServiceProvider class extending PackageServiceProvider, with a static $name property.

```php
use Leek\FilamentHeaderFilters\FilamentHeaderFiltersServiceProvider;

class FilamentHeaderFiltersServiceProvider extends PackageServiceProvider
{
    public static string $name = 'filament-header-filters';
    // ...
}
```

--------------------------------

### Date range header filter with DatePickers

Source: https://github.com/leek/filament-header-filters/blob/main/README.md

Create a date range filter using two DatePicker fields and a query that filters on the date column.

```php
use Filament\Forms\Components\DatePicker;
use Filament\Tables\Columns\TextColumn;
use Filament\Tables\Filters\Filter;
use Illuminate\Database\Eloquent\Builder;

TextColumn::make('created_at')
    ->label('Order date')
    ->date()
    ->headerFilter(
        Filter::make('order_date_range')
            ->columns(2)
            ->schema([
                DatePicker::make('from')->placeholder('From')->native(false),
                DatePicker::make('until')->placeholder('Until')->native(false),
            ])
            ->query(fn (Builder $query, array $data): Builder => $query
                ->when($data['from'] ?? null, fn (Builder $q, $v): Builder => $q->whereDate('created_at', '>=', $v))
                ->when($data['until'] ?? null, fn (Builder $q, $v): Builder => $q->whereDate('created_at', '<=', $v))
            )
    )
```

--------------------------------

### Min/max range header filter with TextInputs

Source: https://github.com/leek/filament-header-filters/blob/main/README.md

Create a min/max range filter using a custom Filter with two TextInput fields and a query that applies >= and <= conditions.

```php
use Filament\Forms\Components\TextInput;
use Filament\Tables\Columns\TextColumn;
use Filament\Tables\Filters\Filter;
use Illuminate\Database\Eloquent\Builder;

TextColumn::make('total_price')
    ->headerFilter(
        Filter::make('total_price_range')
            ->columns(2)
            ->schema([
                TextInput::make('min')->numeric()->placeholder('Min'),
                TextInput::make('max')->numeric()->placeholder('Max'),
            ])
            ->query(fn (Builder $query, array $data): Builder => $query
                ->when($data['min'] ?? null, fn (Builder $q, $v): Builder => $q->where('total_price', '>=', $v))
                ->when($data['max'] ?? null, fn (Builder $q, $v): Builder => $q->where('total_price', '<=', $v))
            )
    )
```

--------------------------------

### getTableHeaderFiltersForm() implementation

Source: https://github.com/leek/filament-header-filters/blob/main/_autodocs/api-reference/has-header-filters-trait.md

Builds a Filament Schema for header filters. It returns a cached schema if caching is enabled and a cached version exists. Otherwise, it creates a Group for each header filter, hiding labels on fields, and returns a live schema at state path 'tableFilters' with the table's model.

```php
public function getTableHeaderFiltersForm(): Schema
{
    if ((! $this->isCachingSchemas) && $this->hasCachedSchema('tableHeaderFiltersForm')) {
        return $this->getSchema('tableHeaderFiltersForm');
    }

    $table = $this->getTable();

    $groups = [];

    foreach ($table->getHeaderFilters() as $filterName => $filter) {
        $components = $filter->getSchemaComponents();

        foreach ($components as $component) {
            if ($component instanceof Field) {
                $component->hiddenLabel();
            }
        }

        $groups[] = Group::make()
            ->schema($components)
            ->statePath($filterName)
            ->key($filterName)
            ->columns($filter->getColumns())
            ->dense();
    }

    return $this->makeSchema()
        ->model($table->getModel())
        ->schema($groups)
        ->statePath('tableFilters')
        ->live();
}
```

--------------------------------

### RegisterMacros::register()

Source: https://github.com/leek/filament-header-filters/blob/main/_autodocs/api-reference/register-macros.md

Registers all package macros onto Filament classes. It is invoked automatically by the service provider.

```APIDOC
## RegisterMacros::register()

### Description
Registers all package macros onto Filament classes. It is invoked automatically by the service provider via `RegisterMacros::register()`.

### Method
`RegisterMacros::register()`

### Signature
```php
public static function register(): void
```

### Parameters
None.

### Returns
`void`

### Throws
Never. Idempotent with respect to Filament's macro system; called once per package boot.

### Example
```php
public function packageBooted(): void
{
    RegisterMacros::register();
    // ...
}
```
```

--------------------------------

### Verifying registered asset with FilamentAsset::getScriptSrc

Source: https://github.com/leek/filament-header-filters/blob/main/_autodocs/api-reference/service-provider.md

Shows how to retrieve the script source URL for the registered asset, as done in the test suite. The $src resolves to '/js/filament-header-filters.js' on the panel's asset route.

```php
use Filament\Support\Facades\FilamentAsset;

$src = FilamentAsset::getScriptSrc('filament-header-filters', 'leek/filament-header-filters');
// $src resolves to /js/filament-header-filters.js on the panel's asset route
```

--------------------------------

### Use HasHeaderFilters in a ListRecords page

Source: https://github.com/leek/filament-header-filters/blob/main/_autodocs/api-reference/has-header-filters-trait.md

Add the trait to a Filament resource list page to enable header filters. The component must use InteractsWithTable.

```php
use Filament\Resources\Pages\ListRecords;
use Leek\FilamentHeaderFilters\Concerns\HasHeaderFilters;

class ListOrders extends ListRecords
{
    use HasHeaderFilters;
}
```

--------------------------------

### Public object shape of FilamentResponsiveBadgeOverflow

Source: https://github.com/leek/filament-header-filters/blob/main/_autodocs/api-reference/views-and-assets.md

Public object shape of the module: register(selector, selectRootSelector = null) and schedule().

```javascript
{
    register(selector, selectRootSelector = null),
    schedule(),
}
```

--------------------------------

### HasHeaderFilters trait docblock annotations

Source: https://github.com/leek/filament-header-filters/blob/main/_autodocs/api-reference/has-header-filters-trait.md

Shows the magic property and mixin annotations declared in the trait's docblock.

```php
/**
 * @property-read Schema $tableHeaderFiltersForm
 *
 * @mixin InteractsWithTable
 */
trait HasHeaderFilters
```

--------------------------------

### markTableRegistered(Table $table): void

Source: https://github.com/leek/filament-header-filters/blob/main/_autodocs/api-reference/header-filter-registry.md

Marks a Table instance as registered in a WeakMap to prevent duplicate registration. A rebuilt table instance will be treated as unregistered.

```php
public static function markTableRegistered(Table $table): void
{
    self::$registeredTables ??= new WeakMap;

    self::$registeredTables[$table] = true;
}
```

--------------------------------

### WeakMap property declarations for HeaderFilterRegistry

Source: https://github.com/leek/filament-header-filters/blob/main/_autodocs/api-reference/header-filter-registry.md

Declares the three static WeakMap properties used to store column-to-filter bindings, filter-to-column-name bindings, and registered tables. These are lazily instantiated on first write.

```php
/** @var WeakMap<Column, BaseFilter>|null */
protected static ?WeakMap $columnFilters = null;

/** @var WeakMap<BaseFilter, string>|null */
protected static ?WeakMap $filterColumnNames = null;

/** @var WeakMap<Table, true>|null */
protected static ?WeakMap $registeredTables = null;
```

--------------------------------

### Check table initialization with hasInitializedTableForHeaderFilters()

Source: https://github.com/leek/filament-header-filters/blob/main/_autodocs/api-reference/has-header-filters-trait.md

Returns true when the $table property (provided by InteractsWithTable) has been set, false before the table is initialized. This guard is called internally by registerTableHeaderFilters() and never throws.

```php
protected function hasInitializedTableForHeaderFilters(): bool
{
    return isset($this->table);
}
```

--------------------------------

### setColumnFilter method implementation

Source: https://github.com/leek/filament-header-filters/blob/main/_autodocs/api-reference/header-filter-registry.md

Binds a column to a filter or unbinds it by passing null. Uses a WeakMap to store the association, removing the key entirely when unbinding.

```php
public static function setColumnFilter(Column $column, ?BaseFilter $filter): void
{
    self::$columnFilters ??= new WeakMap;

    if ($filter === null) {
        unset(self::$columnFilters[$column]);

        return;
    }

    self::$columnFilters[$column] = $filter;
}
```

--------------------------------

### isTableRegistered(Table $table): bool

Source: https://github.com/leek/filament-header-filters/blob/main/_autodocs/api-reference/header-filter-registry.md

Checks whether a specific Table instance has already been registered. Returns true only for the exact same instance.

```php
public static function isTableRegistered(Table $table): bool
{
    return isset(self::$registeredTables[$table]);
}
```

--------------------------------

### isTableRegistered(Table $table): bool

Source: https://github.com/leek/filament-header-filters/blob/main/_autodocs/api-reference/header-filter-registry.md

Checks whether a specific Table instance has already been registered. Returns true if the exact instance is in the registry.

```APIDOC
## isTableRegistered(Table $table): bool

### Description
Checks whether a specific Table instance has already been registered. Returns true if the exact instance is in the registry.

### Method
Static method

### Signature
`public static function isTableRegistered(Table $table): bool`

### Parameters
- `$table` (Filament\Tables\Table) - Required - The table to test.

### Returns
`bool` — `true` when this exact `Table` instance has already been registered.

### Example — the guard used by the trait (per-instance, not per-request):
```php
$table = $this->getTable();

if (HeaderFilterRegistry::isTableRegistered($table)) {
    return; // already pushed filters for this instance
}

// ... push filters, seed state ...
HeaderFilterRegistry::markTableRegistered($table);
```

### Source
`src/Support/HeaderFilterRegistry.php:71-73`
```

--------------------------------

### markTableRegistered(Table $table): void

Source: https://github.com/leek/filament-header-filters/blob/main/_autodocs/api-reference/header-filter-registry.md

Marks a Table instance as registered so that registerTableHeaderFilters() does not run twice for the same instance. Uses a WeakMap keyed by object identity, so a rebuilt table is always treated as unregistered.

```APIDOC
## markTableRegistered(Table $table): void

### Description
Marks a Table instance as registered so that registerTableHeaderFilters() does not run twice for the same instance. Uses a WeakMap keyed by object identity, so a rebuilt table is always treated as unregistered.

### Method
Static method

### Signature
`public static function markTableRegistered(Table $table): void`

### Parameters
- `$table` (Filament\Tables\Table) - Required - The table to mark as registered.

### Returns
`void`

### Behavior
Marks a `Table` instance so `registerTableHeaderFilters()` does not run twice for the same instance. Because the marker lives in a `WeakMap` keyed by object identity, a rebuilt table (fresh `resetTable()` instance) always reads as unregistered.

### Source
`src/Support/HeaderFilterRegistry.php:64-69`
```

--------------------------------

### getColumnFilter method implementation

Source: https://github.com/leek/filament-header-filters/blob/main/_autodocs/api-reference/header-filter-registry.md

Returns the filter bound to the given column, or null if none. Uses a static array lookup.

```php
public static function getColumnFilter(Column $column): ?BaseFilter
{
    return self::$columnFilters[$column] ?? null;
}
```

--------------------------------

### Register Table::getHeaderFilters() macro

Source: https://github.com/leek/filament-header-filters/blob/main/_autodocs/api-reference/register-macros.md

Registered by `registerTableMacros()` at `src/Macros/RegisterMacros.php:67-90` on `Filament\Tables\Table`. Returns an associative array `array<string, BaseFilter>` keyed by `BaseFilter::getName()`, skipping columns without a header filter, hidden columns, and non-visible filters. A filter shared by two columns under the same name collapses to the last one encountered.

```php
Table::macro('getHeaderFilters', function (): array {
    /** @var Table $this */
    $headerFilters = [];

    foreach ($this->getColumns() as $column) {
        if (! $column->hasHeaderFilter()) {
            continue;
        }

        if ($column->isHidden()) {
            continue;
        }

        $filter = $column->getHeaderFilter();

        if (! $filter->isVisible()) {
            continue;
        }

        $headerFilters[$filter->getName()] = $filter;
    }

    return $headerFilters;
});
```

--------------------------------

### Register Table::hasHeaderFilters() macro

Source: https://github.com/leek/filament-header-filters/blob/main/_autodocs/api-reference/register-macros.md

Registered at `src/Macros/RegisterMacros.php:92-96` on `Filament\Tables\Table`. Returns `true` when at least one visible, non-hidden column carries a header filter; otherwise returns `false`.

```php
Table::macro('hasHeaderFilters', function (): bool {
    /** @var Table $this */
    return count($this->getHeaderFilters()) > 0;
});
```

--------------------------------

### setFilterColumnName method implementation

Source: https://github.com/leek/filament-header-filters/blob/main/_autodocs/api-reference/header-filter-registry.md

Records the owning column name for a filter, or clears it when null is passed. Uses a WeakMap to avoid memory leaks.

```php
public static function setFilterColumnName(BaseFilter $filter, ?string $name): void
{
    self::$filterColumnNames ??= new WeakMap;

    if ($name === null) {
        unset(self::$filterColumnNames[$filter]);

        return;
    }

    self::$filterColumnNames[$filter] = $name;
}
```

--------------------------------

### Column::getHeaderFilter(): ?BaseFilter

Source: https://github.com/leek/filament-header-filters/blob/main/_autodocs/api-reference/register-macros.md

Macro registered on Column to retrieve the header filter bound to the column.

```APIDOC
## Column::getHeaderFilter(): ?BaseFilter

### Description
Retrieves the header filter bound to this column, or null if none.

### Method
Macro

### Endpoint
Column::getHeaderFilter()

### Parameters
None

### Returns
- **?Filament\Tables\Filters\BaseFilter** - The filter bound to this column, or null if none.

### Example
```php
$filter = $column->getHeaderFilter();

if ($filter !== null) {
    // e.g. $filter->getName(), $filter->getColumnName()
}
```
```

--------------------------------

### getTableHeaderFiltersForm(): Schema

Source: https://github.com/leek/filament-header-filters/blob/main/_autodocs/api-reference/has-header-filters-trait.md

Returns the header filters form schema for the table. The schema is built from the table's header filters, each represented as a Group component with state path, key, columns, and dense layout. Fields are hidden-labeled. The schema is live and backed by the table's model.

```APIDOC
## getTableHeaderFiltersForm(): Schema

### Description
Returns the header filters form schema for the table. The schema is built from the table's header filters, each represented as a Group component with state path, key, columns, and dense layout. Fields are hidden-labeled. The schema is live and backed by the table's model.

### Method
GET

### Endpoint
`getTableHeaderFiltersForm()`

### Parameters
None

### Returns
- **Type**: `Filament\Schemas\Schema`
- **Description**: A schema at state path `tableFilters`, backed by the table's model, `->live()`, containing one `Filament\Schemas\Components\Group` per header filter. Each group is bound to the filter's name via `->statePath($filterName)`, keyed with `->key($filterName)`, laid out with `->columns($filter->getColumns())` and `->dense()`. Every `Filament\Forms\Components\Field` inside gets `->hiddenLabel()` — the column header acts as the label.

### Throws
Nothing on its own; the cached variant is returned when schema caching is enabled on the component.

### Example — overriding the header filters form in a page
```php
use Filament\Schemas\Schema;

public function getTableHeaderFiltersForm(): Schema
{
    $schema = parent::getTableHeaderFiltersForm();

    // Wrap every header filter group with extra attributes or alter the schema
    // before returning — the Blade component renders it per column cell.

    return $schema;
}
```

### Example — rendering the form for a single filter (what the view partial does)
```blade
{{ $this->getTableHeaderFiltersForm()->getComponent($filterName)?->getChildSchema() }}
```
```

--------------------------------

### hideHeaderFilterGroupsFromPanelForm method implementation

Source: https://github.com/leek/filament-header-filters/blob/main/_autodocs/api-reference/has-header-filters-trait.md

Registers a filtersFormSchema callback that iterates over filter groups, identifies header filters, and applies extra attributes to hide them via CSS while keeping them accessible for state operations. The method returns void and never throws.

```php
protected function hideHeaderFilterGroupsFromPanelForm(Table $table): void
{
    $table->filtersFormSchema(static function (array $filters) use ($table): array {
        foreach ($filters as $filterName => $group) {
            $filter = $table->getFilter($filterName);

            if ($filter instanceof BaseFilter && $filter->isHeaderFilter()) {
                // CSS-hide instead of schema-hide: a schema-hidden group is
                // skipped by getComponentByStatePath(), which turns Filament's
                // removeTableFilter() into a no-op — the filter indicator's
                // remove button could never clear a header filter's state.
                // The class lets the stylesheet hide the group's grid wrapper
                // without matching on the style attribute (see the CSS note).
                $group->extraAttributes(['class' => 'fi-ta-header-filter-panel-group', 'style' => 'display: none'], merge: true)->dense();
            }
        }

        return array_values($filters);
    });
}
```

--------------------------------

### Rendering the form for a single filter (Blade)

Source: https://github.com/leek/filament-header-filters/blob/main/_autodocs/api-reference/has-header-filters-trait.md

Blade snippet used by the view partial to render the schema for a single header filter. It retrieves the component by filter name and outputs its child schema.

```blade
{{ $this->getTableHeaderFiltersForm()->getComponent($filterName)?->getChildSchema() }}
```

--------------------------------

### hasColumnFilter method implementation

Source: https://github.com/leek/filament-header-filters/blob/main/_autodocs/api-reference/header-filter-registry.md

Checks if a non-null filter is bound to the given column. Returns true when isset() is true.

```php
public static function hasColumnFilter(Column $column): bool
{
    return isset(self::$columnFilters[$column]);
}
```

--------------------------------

### getColumnFilter(Column $column): ?BaseFilter

Source: https://github.com/leek/filament-header-filters/blob/main/_autodocs/api-reference/header-filter-registry.md

Retrieves the filter bound to a given column, or null if none exists.

```APIDOC
## getColumnFilter(Column $column): ?BaseFilter

### Description
Returns the filter bound to the given column, or `null` if no filter is bound.

### Method
`HeaderFilterRegistry::getColumnFilter`

### Parameters
- `$column` (Filament\Tables\Columns\Column) - Required - The column to look up.

### Returns
`?Filament\Tables\Filters\BaseFilter` - The bound filter, or `null` when the column has none.

### Example
```php
$filter = HeaderFilterRegistry::getColumnFilter($column);
```
```
Tokens:
Raw