Skip to content

An open source design system that's fully customizable and agent ready

TypeScript

fix(Table): filtering nits — empty state, icon spacing, inline clear (#1134)

Cindy Zhange543afe7ee26
diff --git a/apps/storybook/stories/TableFiltering.stories.tsx b/apps/storybook/stories/TableFiltering.stories.tsx
index 8f07627f5e..02baf6768c 100644
--- a/apps/storybook/stories/TableFiltering.stories.tsx
+++ b/apps/storybook/stories/TableFiltering.stories.tsx
@@ -3,19 +3,16 @@ import type {Meta, StoryObj} from '@storybook/react';
import {
XDSTable,
useXDSTableFiltering,
+ useXDSTableFilterState,
useXDSTableSelection,
useXDSTableSelectionState,
useXDSTableSortable,
useXDSTableColumnResize,
toSearchFilters,
} from '@xds/core/Table';
-import type {
- XDSTableColumn,
- XDSTableFilterState,
- XDSTableFilterValue,
- XDSTableSortState,
-} from '@xds/core/Table';
+import type {XDSTableColumn, XDSTableSortState} from '@xds/core/Table';
import {usePowerSearchConfig} from '@xds/core/PowerSearch';
+import {XDSEmptyState} from '@xds/core/EmptyState';
import type {PowerSearchFilter} from '@xds/core/PowerSearch';
interface Employee extends Record<string, unknown> {
@@ -98,19 +95,23 @@ const fieldDefs = [
{key: 'level', type: 'number', label: 'Level'},
] as const;
-function useFilterState() {
- const [filters, setFilters] = useState<XDSTableFilterState>({});
- const onFilterChange = (key: string, value: XDSTableFilterValue | null) => {
- setFilters(prev => {
- const next = {...prev};
- if (value == null) delete next[key];
- else next[key] = value;
- return next;
- });
- };
- return {filters, onFilterChange};
+function applySorting<T extends Record<string, unknown>>(
+ data: T[],
+ sort: XDSTableSortState,
+): T[] {
+ if (sort.length === 0) return data;
+ return [...data].sort((a, b) => {
+ for (const {sortKey, direction} of sort) {
+ const aVal = a[sortKey];
+ const bVal = b[sortKey];
+ const cmp = String(aVal).localeCompare(String(bVal), undefined, {
+ numeric: true,
+ });
+ if (cmp !== 0) return direction === 'ascending' ? cmp : -cmp;
+ }
+ return 0;
+ });
}
-
const meta: Meta = {
title: 'Core/XDSTable/Filtering',
tags: ['autodocs'],
@@ -122,7 +123,7 @@ type Story = StoryObj;
export const TextFilter: Story = {
render: () => {
const {config, applyFilters} = usePowerSearchConfig(fieldDefs);
- const {filters, onFilterChange} = useFilterState();
+ const {filters, onFilterChange} = useXDSTableFilterState();
const columns: XDSTableColumn<Employee>[] = [
{key: 'name', header: 'Name', filter: 'name'},
{key: 'email', header: 'Email', filter: 'email'},
@@ -157,7 +158,7 @@ export const TextFilter: Story = {
export const SelectorFilter: Story = {
render: () => {
const {config, applyFilters} = usePowerSearchConfig(fieldDefs);
- const {filters, onFilterChange} = useFilterState();
+ const {filters, onFilterChange} = useXDSTableFilterState();
const columns: XDSTableColumn<Employee>[] = [
{key: 'name', header: 'Name'},
{key: 'role', header: 'Role', filter: 'role'},
@@ -192,7 +193,7 @@ export const SelectorFilter: Story = {
export const MultiSelectorFilter: Story = {
render: () => {
const {config, applyFilters} = usePowerSearchConfig(fieldDefs);
- const {filters, onFilterChange} = useFilterState();
+ const {filters, onFilterChange} = useXDSTableFilterState();
const columns: XDSTableColumn<Employee>[] = [
{key: 'name', header: 'Name'},
{key: 'role', header: 'Role'},
@@ -228,7 +229,7 @@ export const MultiSelectorFilter: Story = {
export const NumberFilter: Story = {
render: () => {
const {config, applyFilters} = usePowerSearchConfig(fieldDefs);
- const {filters, onFilterChange} = useFilterState();
+ const {filters, onFilterChange} = useXDSTableFilterState();
const columns: XDSTableColumn<Employee>[] = [
{key: 'name', header: 'Name'},
{key: 'role', header: 'Role'},
@@ -264,7 +265,7 @@ export const NumberFilter: Story = {
export const InlineVariant: Story = {
render: () => {
const {config, applyFilters} = usePowerSearchConfig(fieldDefs);
- const {filters, onFilterChange} = useFilterState();
+ const {filters, onFilterChange} = useXDSTableFilterState();
const columns: XDSTableColumn<Employee>[] = [
{key: 'name', header: 'Name', filter: 'name'},
{key: 'role', header: 'Role', filter: 'role'},
@@ -300,7 +301,7 @@ export const InlineVariant: Story = {
export const WithSelection: Story = {
render: () => {
const {config, applyFilters} = usePowerSearchConfig(fieldDefs);
- const {filters, onFilterChange} = useFilterState();
+ const {filters, onFilterChange} = useXDSTableFilterState();
const [selectedKeys, setSelectedKeys] = useState(new Set<string>());
const columns: XDSTableColumn<Employee>[] = [
{key: 'name', header: 'Name', filter: 'name'},
@@ -313,17 +314,17 @@ export const WithSelection: Story = {
onFilterChange,
searchConfig: config,
});
+ const data = applyFilters(
+ toSearchFilters(filters, columns, config) as PowerSearchFilter[],
+ employees,
+ );
const {selectionConfig} = useXDSTableSelectionState({
- data: employees,
+ data,
idKey: 'id',
selectedKeys,
setSelectedKeys,
});
const selectionPlugin = useXDSTableSelection<Employee>(selectionConfig);
- const data = applyFilters(
- toSearchFilters(filters, columns, config) as PowerSearchFilter[],
- employees,
- );
return (
<div style={{maxWidth: 800}}>
<p style={{marginBottom: 8, fontSize: 14, color: '#666'}}>
@@ -344,7 +345,7 @@ export const WithSelection: Story = {
export const WithSorting: Story = {
render: () => {
const {config, applyFilters} = usePowerSearchConfig(fieldDefs);
- const {filters, onFilterChange} = useFilterState();
+ const {filters, onFilterChange} = useXDSTableFilterState();
const [sort, setSort] = useState<XDSTableSortState>([]);
const columns: XDSTableColumn<Employee>[] = [
{key: 'name', header: 'Name', sortable: true, filter: 'name'},
@@ -361,10 +362,11 @@ export const WithSorting: Story = {
sort,
onSortChange: setSort,
});
- const data = applyFilters(
+ const filtered = applyFilters(
toSearchFilters(filters, columns, config) as PowerSearchFilter[],
employees,
);
+ const data = applySorting(filtered, sort);
return (
<div style={{maxWidth: 800}}>
<p style={{marginBottom: 8, fontSize: 14, color: '#666'}}>
@@ -384,7 +386,7 @@ export const WithSorting: Story = {
export const WithResize: Story = {
render: () => {
const {config, applyFilters} = usePowerSearchConfig(fieldDefs);
- const {filters, onFilterChange} = useFilterState();
+ const {filters, onFilterChange} = useXDSTableFilterState();
const [columnWidths, setColumnWidths] = useState<Record<string, number>>(
{},
);
@@ -430,7 +432,7 @@ export const WithResize: Story = {
export const WithAllPlugins: Story = {
render: () => {
const {config, applyFilters} = usePowerSearchConfig(fieldDefs);
- const {filters, onFilterChange} = useFilterState();
+ const {filters, onFilterChange} = useXDSTableFilterState();
const [sort, setSort] = useState<XDSTableSortState>([]);
const [columnWidths, setColumnWidths] = useState<Record<string, number>>(
{},
@@ -457,17 +459,18 @@ export const WithAllPlugins: Story = {
setColumnWidths(prev => ({...prev, ...updates})),
columns,
});
+ const filtered = applyFilters(
+ toSearchFilters(filters, columns, config) as PowerSearchFilter[],
+ employees,
+ );
+ const data = applySorting(filtered, sort);
const {selectionConfig} = useXDSTableSelectionState({
- data: employees,
+ data,
idKey: 'id',
selectedKeys,
setSelectedKeys,
});
const selectionPlugin = useXDSTableSelection<Employee>(selectionConfig);
- const data = applyFilters(
- toSearchFilters(filters, columns, config) as PowerSearchFilter[],
- employees,
- );
return (
<div style={{maxWidth: 900}}>
<p style={{marginBottom: 8, fontSize: 14, color: '#666'}}>
@@ -489,3 +492,83 @@ export const WithAllPlugins: Story = {
);
},
};
+
+export const InlineWithClear: Story = {
+ render: () => {
+ const {config, applyFilters} = usePowerSearchConfig(fieldDefs);
+ const {filters, onFilterChange} = useXDSTableFilterState();
+ const columns: XDSTableColumn<Employee>[] = [
+ {key: 'name', header: 'Name', filter: 'name'},
+ {key: 'role', header: 'Role', filter: 'role'},
+ {key: 'level', header: 'Level', filter: 'level'},
+ {key: 'department', header: 'Department'},
+ ];
+ const filterPlugin = useXDSTableFiltering<Employee>({
+ filters,
+ onFilterChange,
+ variant: 'inline',
+ searchConfig: config,
+ });
+ const data = applyFilters(
+ toSearchFilters(filters, columns, config) as PowerSearchFilter[],
+ employees,
+ );
+ return (
+ <div style={{maxWidth: 800}}>
+ <p style={{marginBottom: 8, fontSize: 14, color: '#666'}}>
+ Inline variant with clear buttons. Type to filter, then click ✕ to
+ clear. Showing {data.length}/{employees.length} rows.
+ </p>
+ <XDSTable
+ data={data}
+ columns={columns}
+ idKey="id"
+ plugins={{filter: filterPlugin}}
+ />
+ </div>
+ );
+ },
+};
+
+export const EmptyState: Story = {
+ render: () => {
+ const {config, applyFilters} = usePowerSearchConfig(fieldDefs);
+ const {filters, onFilterChange} = useXDSTableFilterState();
+ const columns: XDSTableColumn<Employee>[] = [
+ {key: 'name', header: 'Name', filter: 'name'},
+ {key: 'role', header: 'Role', filter: 'role'},
+ {key: 'level', header: 'Level', filter: 'level'},
+ {key: 'department', header: 'Department'},
+ ];
+ const filterPlugin = useXDSTableFiltering<Employee>({
+ filters,
+ onFilterChange,
+ variant: 'inline',
+ searchConfig: config,
+ });
+ const data = applyFilters(
+ toSearchFilters(filters, columns, config) as PowerSearchFilter[],
+ employees,
+ );
+ return (
+ <div style={{maxWidth: 800}}>
+ <p style={{marginBottom: 8, fontSize: 14, color: '#666'}}>
+ Try filtering to get zero results — empty state appears.
+ </p>
+ <XDSTable
+ data={data}
+ columns={columns}
+ idKey="id"
+ plugins={{filter: filterPlugin}}
+ emptyState={
+ <XDSEmptyState
+ title="No results"
+ description="Try adjusting your filters to find what you're looking for."
+ size="compact"
+ />
+ }
+ />
+ </div>
+ );
+ },
+};
diff --git a/packages/core/src/Button/XDSButton.tsx b/packages/core/src/Button/XDSButton.tsx
index d33d34ef3e..418a05ac15 100644
--- a/packages/core/src/Button/XDSButton.tsx
+++ b/packages/core/src/Button/XDSButton.tsx
@@ -92,7 +92,8 @@ const styles = stylex.create({
iconOnly: {
'--button-icon-only-aspect': '1 / 1',
aspectRatio: 'var(--button-icon-only-aspect)',
- paddingInline: spacingVars['--spacing-2'],
+ paddingInline: 0,
+ paddingBlock: 0,
},
endContentWrapper: {
display: 'inline-flex',
@@ -540,8 +541,7 @@ export function XDSButton({
{...stylex.props(styles.contentWrapper)}
aria-hidden={isLoadingState || undefined}>
{icon && (
- <span
- {...stylex.props(styles.iconWrapper, iconSizeStyles[size])}>
+ <span {...stylex.props(styles.iconWrapper, iconSizeStyles[size])}>
{icon}
</span>
)}
diff --git a/packages/core/src/Table/XDSBaseTable.tsx b/packages/core/src/Table/XDSBaseTable.tsx
index 70300b1438..0ce61c889c 100644
--- a/packages/core/src/Table/XDSBaseTable.tsx
+++ b/packages/core/src/Table/XDSBaseTable.tsx
@@ -36,6 +36,7 @@ import {XDSTableRow} from './XDSTableRow';
import {XDSTableCell} from './XDSTableCell';
import {XDSTableHeaderCell} from './XDSTableHeaderCell';
import {xdsClassName, mergeProps} from '../utils';
+import {XDSEmptyState} from '../EmptyState';
const styles = stylex.create({
table: {
@@ -52,7 +53,7 @@ const styles = stylex.create({
headerLabelRow: {
display: 'inline-flex',
alignItems: 'center',
- gap: spacingVars['--spacing-0-5'],
+ gap: spacingVars['--spacing-1'],
minWidth: 0,
},
});
@@ -242,6 +243,7 @@ function XDSBaseTableInner<T extends Record<string, unknown>>({
components,
children,
tableProps: userTableProps,
+ emptyState,
ref,
}: XDSBaseTableProps<T> & {ref?: Ref<HTMLTableElement>}): ReactElement {
// Use stable empty array when no plugins provided
@@ -399,28 +401,36 @@ function XDSBaseTableInner<T extends Record<string, unknown>>({
<tbody>
{children
? children
- : hasData &&
- data.map((item, rowIndex) => {
- const rowKey =
- idKey == null
- ? rowIndex
- : typeof idKey === 'function'
- ? idKey(item)
- : String(item[idKey]);
-
- return (
- <MemoizedTableRow<T>
- key={rowKey}
- item={item}
- rowIndex={rowIndex}
- rowKey={rowKey}
- columns={resolvedColumns}
- plugins={plugins}
- RowComponent={RowComponent}
- CellComponent={CellComponent}
- />
- );
- })}
+ : hasData
+ ? data.map((item, rowIndex) => {
+ const rowKey =
+ idKey == null
+ ? rowIndex
+ : typeof idKey === 'function'
+ ? idKey(item)
+ : String(item[idKey]);
+
+ return (
+ <MemoizedTableRow<T>
+ key={rowKey}
+ item={item}
+ rowIndex={rowIndex}
+ rowKey={rowKey}
+ columns={resolvedColumns}
+ plugins={plugins}
+ RowComponent={RowComponent}
+ CellComponent={CellComponent}
+ />
+ );
+ })
+ : data != null &&
+ emptyState !== false && (
+ <tr>
+ <td colSpan={resolvedColumns.length}>
+ {emptyState ?? <XDSEmptyState title="No data" isCompact />}
+ </td>
+ </tr>
+ )}
</tbody>
</table>
);
diff --git a/packages/core/src/Table/XDSTable.test.tsx b/packages/core/src/Table/XDSTable.test.tsx
index ec0a4d902d..27bcfc9c4e 100644
--- a/packages/core/src/Table/XDSTable.test.tsx
+++ b/packages/core/src/Table/XDSTable.test.tsx
@@ -262,8 +262,9 @@ describe('XDSBaseTable', () => {
it('renders empty table when data is empty array', () => {
render(<XDSBaseTable data={[]} columns={columns} />);
expect(screen.getByRole('table')).toBeInTheDocument();
- // Header row only, no data rows
- expect(screen.getAllByRole('row')).toHaveLength(1);
+ // Header row + empty state row
+ expect(screen.getAllByRole('row')).toHaveLength(2);
+ expect(screen.getByText('No data')).toBeInTheDocument();
});
it('does not render colgroup', () => {
@@ -910,3 +911,93 @@ describe('XDSTableCell', () => {
expect(screen.getByTestId('rowspan-cell')).toHaveAttribute('rowspan', '2');
});
});
+
+describe('emptyState', () => {
+ it('renders default empty state when data is empty', () => {
+ render(
+ <XDSTable
+ data={[]}
+ columns={[
+ {key: 'name', header: 'Name'},
+ {key: 'age', header: 'Age'},
+ ]}
+ />,
+ );
+ expect(screen.getByText('No data')).toBeInTheDocument();
+ });
+
+ it('renders custom empty state when provided', () => {
+ render(
+ <XDSTable
+ data={[]}
+ columns={[
+ {key: 'name', header: 'Name'},
+ {key: 'age', header: 'Age'},
+ ]}
+ emptyState={<div data-testid="empty">No results found</div>}
+ />,
+ );
+ expect(screen.getByTestId('empty')).toBeInTheDocument();
+ expect(screen.getByText('No results found')).toBeInTheDocument();
+ });
+
+ it('does not render empty state when data has rows', () => {
+ render(
+ <XDSTable
+ data={[{name: 'Alice', age: 30}]}
+ columns={[
+ {key: 'name', header: 'Name'},
+ {key: 'age', header: 'Age'},
+ ]}
+ />,
+ );
+ expect(screen.queryByText('No data')).not.toBeInTheDocument();
+ expect(screen.getByText('Alice')).toBeInTheDocument();
+ });
+
+ it('does not render empty state when data is undefined', () => {
+ render(<XDSTable columns={[{key: 'name', header: 'Name'}]} />);
+ expect(screen.queryByText('No data')).not.toBeInTheDocument();
+ });
+
+ it('disables empty state with false', () => {
+ render(
+ <XDSTable
+ data={[]}
+ columns={[{key: 'name', header: 'Name'}]}
+ emptyState={false}
+ />,
+ );
+ expect(screen.queryByText('No data')).not.toBeInTheDocument();
+ });
+
+ it('empty state row spans all columns', () => {
+ render(
+ <XDSTable
+ data={[]}
+ columns={[
+ {key: 'name', header: 'Name'},
+ {key: 'age', header: 'Age'},
+ {key: 'role', header: 'Role'},
+ ]}
+ emptyState={<div data-testid="empty">Nothing here</div>}
+ />,
+ );
+ const td = screen.getByTestId('empty').closest('td');
+ expect(td).toHaveAttribute('colspan', '3');
+ });
+
+ it('still renders headers even when data is empty', () => {
+ render(
+ <XDSTable
+ data={[]}
+ columns={[
+ {key: 'name', header: 'Name'},
+ {key: 'age', header: 'Age'},
+ ]}
+ />,
+ );
+ expect(screen.getByText('Name')).toBeInTheDocument();
+ expect(screen.getByText('Age')).toBeInTheDocument();
+ });
+});
diff --git a/packages/core/src/Table/XDSTableCell.tsx b/packages/core/src/Table/XDSTableCell.tsx
index 4cfd351fa3..f835d994f8 100644
--- a/packages/core/src/Table/XDSTableCell.tsx
+++ b/packages/core/src/Table/XDSTableCell.tsx
@@ -68,7 +68,12 @@ const densityStyles = stylex.create({
const dividerRowStyles = stylex.create({
cell: {
- borderBottomWidth: borderVars['--border-width'],
+ borderBottomWidth: {
+ default: borderVars['--border-width'],
+ // Skip border on cells in the last body row to avoid a
+ // redundant line at the bottom of the table.
+ [stylex.when.ancestor(':last-child')]: '0',
+ },
borderBottomStyle: 'solid',
borderBottomColor: colorVars['--color-border'],
},
diff --git a/packages/core/src/Table/index.ts b/packages/core/src/Table/index.ts
index 01ea0a96ec..4fbe1b24b7 100644
--- a/packages/core/src/Table/index.ts
+++ b/packages/core/src/Table/index.ts
@@ -21,7 +21,11 @@ export {useXDSTableSortable} from './plugins/sortable';
export {useXDSTablePagination} from './plugins/pagination';
export {useXDSTableColumnSettings} from './plugins/columnSettings';
export {useXDSTableColumnResize} from './plugins/columnResize';
-export {useXDSTableFiltering, toSearchFilters} from './plugins/filtering';
+export {
+ useXDSTableFiltering,
+ useXDSTableFilterState,
+ toSearchFilters,
+} from './plugins/filtering';
export {useXDSBaseTablePlugins} from './useXDSBaseTablePlugins';
export {
proportional,
diff --git a/packages/core/src/Table/plugins/filtering/index.ts b/packages/core/src/Table/plugins/filtering/index.ts
index 45c7a7f2ef..32c97d5492 100644
--- a/packages/core/src/Table/plugins/filtering/index.ts
+++ b/packages/core/src/Table/plugins/filtering/index.ts
@@ -1,4 +1,6 @@
export {useXDSTableFiltering, toSearchFilters} from './useXDSTableFiltering';
+export {useXDSTableFilterState} from './useXDSTableFilterState';
+export type {UseXDSTableFilterStateResult} from './useXDSTableFilterState';
export type {
UseXDSTableFilteringConfig,
XDSTableFilterState,
diff --git a/packages/core/src/Table/plugins/filtering/useXDSTableFilterState.tsx b/packages/core/src/Table/plugins/filtering/useXDSTableFilterState.tsx
new file mode 100644
index 0000000000..ad44b84e30
--- /dev/null
+++ b/packages/core/src/Table/plugins/filtering/useXDSTableFilterState.tsx
@@ -0,0 +1,76 @@
+'use client';
+
+/**
+ * @file useXDSTableFilterState.tsx
+ * @input React, filter types
+ * @output Exports useXDSTableFilterState hook for managing filter state
+ * @position Filter state helper; manages the filter state object.
+ * Pairs with useXDSTableFiltering for the UI plugin.
+ *
+ * SYNC: When modified, update these files to stay in sync:
+ * - /packages/core/src/Table/plugins/filtering/index.ts (exports)
+ * - /packages/core/src/Table/Table.doc.mjs (filtering documentation)
+ */
+
+import {useState, useCallback} from 'react';
+import type {
+ XDSTableFilterState,
+ XDSTableFilterValue,
+} from './useXDSTableFiltering';
+
+export interface UseXDSTableFilterStateResult {
+ /** Current filter state — pass to useXDSTableFiltering. */
+ filters: XDSTableFilterState;
+ /** Filter change handler — pass to useXDSTableFiltering. */
+ onFilterChange: (key: string, value: XDSTableFilterValue | null) => void;
+ /** Reset all filters to empty. */
+ clearAll: () => void;
+}
+
+/**
+ * useXDSTableFilterState — manages the filter state object.
+ *
+ * A convenience hook that bundles `useState<XDSTableFilterState>` with a
+ * correctly-typed `onFilterChange` handler. Eliminates the boilerplate of
+ * writing the state update logic in every consumer.
+ *
+ * The returned `filters` and `onFilterChange` are passed directly to
+ * `useXDSTableFiltering`.
+ *
+ * @example
+ * ```
+ * const {filters, onFilterChange} = useXDSTableFilterState();
+ *
+ * const filterPlugin = useXDSTableFiltering({
+ * filters,
+ * onFilterChange,
+ * variant: 'inline',
+ * searchConfig: config,
+ * });
+ * ```
+ */
+export function useXDSTableFilterState(
+ initialState?: XDSTableFilterState,
+): UseXDSTableFilterStateResult {
+ const [filters, setFilters] = useState<XDSTableFilterState>(
+ initialState ?? {},
+ );
+
+ const onFilterChange = useCallback(
+ (key: string, value: XDSTableFilterValue | null) => {
+ setFilters(prev => {
+ const next = {...prev};
+ if (value == null) delete next[key];
+ else next[key] = value;
+ return next;
+ });
+ },
+ [],
+ );
+
+ const clearAll = useCallback(() => {
+ setFilters({});
+ }, []);
+
+ return {filters, onFilterChange, clearAll};
+}
diff --git a/packages/core/src/Table/plugins/filtering/useXDSTableFiltering.test.tsx b/packages/core/src/Table/plugins/filtering/useXDSTableFiltering.test.tsx
index dec4577bbf..1622f65d0e 100644
--- a/packages/core/src/Table/plugins/filtering/useXDSTableFiltering.test.tsx
+++ b/packages/core/src/Table/plugins/filtering/useXDSTableFiltering.test.tsx
@@ -191,7 +191,7 @@ describe('useXDSTableFiltering', () => {
it('renders text input for string field', () => {
render(<FilterTable variant="inline" />);
- const textInputs = screen.getAllByPlaceholderText('Filter...');
+ const textInputs = screen.getAllByPlaceholderText(/^Filter /);
expect(textInputs.length).toBeGreaterThanOrEqual(1);
});
@@ -206,7 +206,7 @@ describe('useXDSTableFiltering', () => {
it('updates text filter on type', async () => {
const user = userEvent.setup();
render(<FilterTable variant="inline" />);
- const textInputs = screen.getAllByPlaceholderText('Filter...');
+ const textInputs = screen.getAllByPlaceholderText(/^Filter /);
await user.type(textInputs[0], 'Alice');
expect(textInputs[0]).toHaveValue('Alice');
});
@@ -222,7 +222,7 @@ describe('useXDSTableFiltering', () => {
},
];
render(<FilterTable columns={columns} variant="inline" />);
- const textInputs = screen.getAllByPlaceholderText('Filter...');
+ const textInputs = screen.getAllByPlaceholderText(/^Filter /);
expect(textInputs.length).toBeGreaterThanOrEqual(1);
});
diff --git a/packages/core/src/Table/plugins/filtering/useXDSTableFiltering.tsx b/packages/core/src/Table/plugins/filtering/useXDSTableFiltering.tsx
index 2645ce6b0b..7697401d1c 100644
--- a/packages/core/src/Table/plugins/filtering/useXDSTableFiltering.tsx
+++ b/packages/core/src/Table/plugins/filtering/useXDSTableFiltering.tsx
@@ -39,6 +39,7 @@ import type {
XDSTableColumn,
HeaderCellRenderProps,
} from '../../types';
+import {proportional} from '../../columnUtils';
import type {
PowerSearchConfig,
PowerSearchField,
@@ -105,14 +106,14 @@ export interface XDSTableFilterOption {
/** Text filter — free-form text input. */
export interface XDSTableFilterTypeText {
type: 'text';
- /** Placeholder text for the input. @default 'Filter...' */
+ /** Placeholder text for the input. @default 'Filter <column header>' */
placeholder?: string;
}
/** Number filter — numeric input for exact match. */
export interface XDSTableFilterTypeNumber {
type: 'number';
- /** Placeholder text. @default 'Filter...' */
+ /** Placeholder text. @default 'Filter <column header>' */
placeholder?: string;
/** Minimum allowed value */
min?: number;
@@ -162,7 +163,7 @@ export interface XDSTableFilterTypeMultiSelector {
/** Date filter — date picker input (ISO date string). */
export interface XDSTableFilterTypeDate {
type: 'date';
- /** Placeholder text. @default 'Filter...' */
+ /** Placeholder text. @default 'Filter <column header>' */
placeholder?: string;
/** Minimum allowed date (ISO string) */
min?: string;
@@ -173,7 +174,7 @@ export interface XDSTableFilterTypeDate {
/** Time filter — time picker input (ISO time string). */
export interface XDSTableFilterTypeTime {
type: 'time';
- /** Placeholder text. @default 'Filter...' */
+ /** Placeholder text. @default 'Filter <column header>' */
placeholder?: string;
/** Minimum allowed time */
min?: string;
@@ -527,7 +528,6 @@ const filterStyles = stylex.create({
afterPopover: {
display: 'flex',
alignItems: 'center',
- gap: spacingVars['--spacing-1'],
flexShrink: 0,
},
afterInline: {
@@ -537,6 +537,15 @@ const filterStyles = stylex.create({
marginTop: spacingVars['--spacing-1'],
minWidth: 0,
},
+ inlineClearRow: {
+ display: 'flex',
+ alignItems: 'center',
+ gap: spacingVars['--spacing-0-5'],
+ },
+ inlineClearGrow: {
+ flex: 1,
+ minWidth: 0,
+ },
triggerButton: {
background: 'none',
border: 'none',
@@ -544,7 +553,7 @@ const filterStyles = stylex.create({
display: 'inline-flex',
alignItems: 'center',
justifyContent: 'center',
- padding: spacingVars['--spacing-1'],
+ padding: 0,
borderRadius: radiusVars['--radius-element'],
flexShrink: 0,
// Minimum 44px touch target on coarse pointer devices (iOS guideline).
@@ -564,15 +573,16 @@ const filterStyles = stylex.create({
opacity: 1,
},
popoverContent: {
- padding: spacingVars['--spacing-2'],
width: '240px',
},
popoverActions: {
display: 'flex',
- justifyContent: 'flex-end',
gap: spacingVars['--spacing-2'],
marginTop: spacingVars['--spacing-2'],
},
+ popoverActionsSpacer: {
+ flex: 1,
+ },
numberRangeRow: {
display: 'flex',
gap: spacingVars['--spacing-2'],
@@ -615,7 +625,7 @@ function TextFilterControl({
.getConfig()
.onFilterChange(columnKey, newValue === '' ? null : newValue);
}}
- placeholder={filterConfig.placeholder ?? 'Filter...'}
+ placeholder={filterConfig.placeholder ?? `Filter ${header}`}
size={size}
/>
);
@@ -645,7 +655,7 @@ function NumberFilterControl({
onChange={(newValue: number) => {
store.getConfig().onFilterChange(columnKey, newValue);
}}
- placeholder={filterConfig.placeholder ?? 'Filter...'}
+ placeholder={filterConfig.placeholder ?? `Filter ${header}`}
min={filterConfig.min ?? null}
max={filterConfig.max ?? null}
step={filterConfig.step ?? null}
@@ -1069,15 +1079,16 @@ function PopoverFilterTrigger({
columnKey={columnKey}
header={header}
filterConfig={filterConfig}
- size="sm"
+ size="md"
/>
<div {...stylex.props(filterStyles.popoverActions)}>
<XDSButton
- label="Clear"
- variant="secondary"
+ label="Reset"
+ variant="ghost"
size="sm"
onClick={handleClear}
/>
+ <div {...stylex.props(filterStyles.popoverActionsSpacer)} />
<XDSButton
label="Apply"
variant="primary"
@@ -1165,21 +1176,43 @@ function InlineFilterSlot({
filterConfig: XDSTableFilterType | undefined;
}) {
const variant = useContext(FilterVariantContext);
- const size = variant === 'inline-compact' ? 'sm' : 'md';
+ const store = useContext(FilterStoreContext);
+ const size = 'sm';
const placeholderStyle =
variant === 'inline-compact'
? filterStyles.placeholderCompact
: filterStyles.placeholder;
+ const config = store?.getConfig();
+ const value = config?.filters[columnKey];
+ const hasValue = value != null && value !== '';
+
+ const handleClear = useCallback(() => {
+ store?.getConfig().onFilterChange(columnKey, null);
+ }, [store, columnKey]);
+
return (
<div {...stylex.props(filterStyles.afterInline)}>
{filterConfig != null ? (
- <FilterControl
- columnKey={columnKey}
- header={header}
- filterConfig={filterConfig}
- size={size}
- />
+ <div {...stylex.props(filterStyles.inlineClearRow)}>
+ <div {...stylex.props(filterStyles.inlineClearGrow)}>
+ <FilterControl
+ columnKey={columnKey}
+ header={header}
+ filterConfig={filterConfig}
+ size={size}
+ />
+ </div>
+ {hasValue && (
+ <XDSButton
+ variant="ghost"
+ size="sm"
+ icon={<XDSIcon icon="close" size="xsm" />}
+ label="Clear"
+ onClick={handleClear}
+ />
+ )}
+ </div>
) : (
<div aria-hidden="true" {...stylex.props(placeholderStyle)} />
)}
@@ -1253,6 +1286,20 @@ export function useXDSTableFiltering<T extends Record<string, unknown>>(
return useMemo(
(): TablePlugin<T> => ({
+ // For inline variants, upgrade columns with filters and no explicit width
+ // to proportional(1) so they get a default minWidth from the width resolver.
+ // Without this, inline filter inputs can collapse to unusable sizes.
+ transformColumns:
+ variant === 'inline' || variant === 'inline-compact'
+ ? (columns: XDSTableColumn<T>[]) =>
+ columns.map(col => {
+ if (col.filter != null && col.width == null) {
+ return {...col, width: proportional(1)};
+ }
+ return col;
+ })
+ : undefined,
+
transformTableContext(children: ReactNode) {
return (
<FilterStoreContext.Provider value={store}>
diff --git a/packages/core/src/Table/plugins/selection/useXDSTableSelectionState.test.tsx b/packages/core/src/Table/plugins/selection/useXDSTableSelectionState.test.tsx
index 091979a551..d32e449249 100644
--- a/packages/core/src/Table/plugins/selection/useXDSTableSelectionState.test.tsx
+++ b/packages/core/src/Table/plugins/selection/useXDSTableSelectionState.test.tsx
@@ -225,3 +225,174 @@ describe('useXDSTableSelectionState', () => {
expect(rows[3]).not.toHaveAttribute('aria-selected');
});
});
+
+// =============================================================================
+// Filtering + Selection Interaction Tests
+// =============================================================================
+
+/**
+ * Simulates the pattern where consumers pass filtered data to
+ * useXDSTableSelectionState, scoping select-all to visible rows.
+ * Selections made on filtered views persist when the filter changes.
+ */
+function FilteredSelectionTable({
+ initialFilter = '',
+}: {
+ initialFilter?: string;
+}) {
+ const [selectedKeys, setSelectedKeys] = useState<Set<string>>(new Set());
+ const [filter, setFilter] = useState(initialFilter);
+
+ // Simulate filtering — only show items whose name includes the filter
+ const filteredData = filter
+ ? testData.filter(item =>
+ item.name.toLowerCase().includes(filter.toLowerCase()),
+ )
+ : testData;
+
+ const {selectionConfig} = useXDSTableSelectionState<TestItem>({
+ data: filteredData,
+ idKey: 'id',
+ selectedKeys,
+ setSelectedKeys,
+ });
+
+ const plugin = useXDSTableSelection<TestItem>(selectionConfig);
+
+ return (
+ <div>
+ <input
+ data-testid="filter-input"
+ value={filter}
+ onChange={e => setFilter(e.target.value)}
+ />
+ <span data-testid="selected-count">{selectedKeys.size}</span>
+ <span data-testid="selected-keys">
+ {[...selectedKeys].sort().join(',')}
+ </span>
+ <XDSTable
+ data={filteredData}
+ columns={columns}
+ idKey="id"
+ plugins={{selection: plugin}}
+ />
+ </div>
+ );
+}
+
+describe('useXDSTableSelectionState with filtered data', () => {
+ it('select-all only selects visible (filtered) rows', async () => {
+ const user = userEvent.setup();
+ // Filter to only show Alice and Charlie (names containing "li")
+ render(<FilteredSelectionTable initialFilter="li" />);
+
+ // Should show 2 rows (Alice, Charlie)
+ const rows = screen.getAllByRole('row');
+ // header + 2 body rows = 3
+ expect(rows).toHaveLength(3);
+
+ await user.click(screen.getByLabelText('Select all rows'));
+
+ // Only Alice (1) and Charlie (3) should be selected
+ expect(screen.getByTestId('selected-count')).toHaveTextContent('2');
+ expect(screen.getByTestId('selected-keys')).toHaveTextContent('1,3');
+ });
+
+ it('selections persist when filter changes', async () => {
+ const user = userEvent.setup();
+ render(<FilteredSelectionTable />);
+
+ // Select Bob (row index 2 in unfiltered view)
+ const checkboxes = screen.getAllByLabelText('Select row');
+ await user.click(checkboxes[1]); // Bob
+
+ expect(screen.getByTestId('selected-keys')).toHaveTextContent('2');
+
+ // Now filter to only "Ali" — Bob disappears but stays selected
+ const input = screen.getByTestId('filter-input');
+ await user.clear(input);
+ await user.type(input, 'Ali');
+
+ // Bob is no longer visible
+ const rows = screen.getAllByRole('row');
+ expect(rows).toHaveLength(2); // header + Alice
+
+ // But selectedKeys still includes Bob
+ expect(screen.getByTestId('selected-count')).toHaveTextContent('1');
+ expect(screen.getByTestId('selected-keys')).toHaveTextContent('2');
+ });
+
+ it('select-all in filtered view preserves selections from other views', async () => {
+ const user = userEvent.setup();
+ render(<FilteredSelectionTable />);
+
+ // Select Bob individually
+ const checkboxes = screen.getAllByLabelText('Select row');
+ await user.click(checkboxes[1]); // Bob (id: 2)
+
+ expect(screen.getByTestId('selected-keys')).toHaveTextContent('2');
+
+ // Filter to "Ali" — shows only Alice
+ const input = screen.getByTestId('filter-input');
+ await user.clear(input);
+ await user.type(input, 'Ali');
+
+ // Select all in filtered view (just Alice)
+ await user.click(screen.getByLabelText('Select all rows'));
+
+ // Both Bob (from before) and Alice (from select-all) should be selected
+ expect(screen.getByTestId('selected-count')).toHaveTextContent('2');
+ expect(screen.getByTestId('selected-keys')).toHaveTextContent('1,2');
+ });
+
+ it('deselect-all in filtered view only deselects visible rows', async () => {
+ const user = userEvent.setup();
+ render(<FilteredSelectionTable />);
+
+ // Select all (unfiltered) — selects all 4
+ await user.click(screen.getByLabelText('Select all rows'));
+ expect(screen.getByTestId('selected-count')).toHaveTextContent('4');
+
+ // Filter to "Ali" — shows only Alice
+ const input = screen.getByTestId('filter-input');
+ await user.clear(input);
+ await user.type(input, 'Ali');
+
+ // Deselect all in filtered view — only deselects Alice
+ await user.click(screen.getByLabelText('Select all rows'));
+
+ // Bob, Charlie, Diana still selected (not visible, so frozen)
+ expect(screen.getByTestId('selected-count')).toHaveTextContent('3');
+ expect(screen.getByTestId('selected-keys')).toHaveTextContent('2,3,4');
+ });
+
+ it('clearing filter restores selections from all views', async () => {
+ const user = userEvent.setup();
+ render(<FilteredSelectionTable />);
+
+ // Select Alice individually
+ const checkboxes = screen.getAllByLabelText('Select row');
+ await user.click(checkboxes[0]); // Alice (id: 1)
+
+ // Filter to "Bob" and select Bob
+ const input = screen.getByTestId('filter-input');
+ await user.clear(input);
+ await user.type(input, 'Bob');
+ const filteredCheckboxes = screen.getAllByLabelText('Select row');
+ await user.click(filteredCheckboxes[0]); // Bob (id: 2)
+
+ // Clear filter
+ await user.clear(input);
+
+ // Both Alice and Bob should be selected
+ expect(screen.getByTestId('selected-count')).toHaveTextContent('2');
+ expect(screen.getByTestId('selected-keys')).toHaveTextContent('1,2');
+
+ // And they should appear selected in the table
+ const rows = screen.getAllByRole('row');
+ expect(rows[1]).toHaveAttribute('aria-selected', 'true'); // Alice
+ expect(rows[2]).toHaveAttribute('aria-selected', 'true'); // Bob
+ expect(rows[3]).not.toHaveAttribute('aria-selected'); // Charlie
+ expect(rows[4]).not.toHaveAttribute('aria-selected'); // Diana
+ });
+});
diff --git a/packages/core/src/Table/plugins/selection/useXDSTableSelectionState.tsx b/packages/core/src/Table/plugins/selection/useXDSTableSelectionState.tsx
index fa72b8be64..5db7483db4 100644
--- a/packages/core/src/Table/plugins/selection/useXDSTableSelectionState.tsx
+++ b/packages/core/src/Table/plugins/selection/useXDSTableSelectionState.tsx
@@ -26,7 +26,11 @@ import type {UseXDSTableSelectionConfig} from './useXDSTableSelection';
export interface UseXDSTableSelectionStateConfig<
T extends Record<string, unknown>,
> {
- /** The full data array rendered in the table. */
+ /**
+ * The data array currently rendered in the table.
+ * Pass the **filtered/visible** data, not the full dataset — select-all
+ * operates on this array, so passing unfiltered data would select hidden rows.
+ */
data: T[];
/**
* Key extractor — returns a unique string ID for each item.
diff --git a/packages/core/src/Table/plugins/sortable/useXDSTableSortable.tsx b/packages/core/src/Table/plugins/sortable/useXDSTableSortable.tsx
index bc7e04be30..de7bb01dee 100644
--- a/packages/core/src/Table/plugins/sortable/useXDSTableSortable.tsx
+++ b/packages/core/src/Table/plugins/sortable/useXDSTableSortable.tsx
@@ -97,7 +97,7 @@ export interface UseXDSTableSortableConfig<TSortKey extends string = string> {
* When true, clicking a sorted column cycles: asc → desc → unsorted.
* When false, clicking cycles: asc → desc → asc.
*
- * @default false
+ * @default true
*/
allowUnsortedState?: boolean;
@@ -139,12 +139,10 @@ const sortStyles = stylex.create({
},
iconWrapperUnsorted: {
display: 'inline-flex',
- opacity: 0,
- [stylex.when.ancestor(':hover')]: {
- opacity: 1,
- },
- [stylex.when.ancestor(':focus-within')]: {
- opacity: 1,
+ opacity: {
+ default: 0.35,
+ ':is(th:hover *)': 1,
+ ':focus-visible': 1,
},
},
iconWrapperActive: {
@@ -241,7 +239,7 @@ function SortHeaderButton<T extends Record<string, unknown>>({
const handleClick = (e: React.MouseEvent | React.KeyboardEvent) => {
const cfg = configRef.current;
const isShift = e.shiftKey && cfg.isMultiSortEnabled;
- const allowUnsorted = cfg.allowUnsortedState ?? false;
+ const allowUnsorted = cfg.allowUnsortedState ?? true;
if (isShift) {
// Multi-sort: toggle in place or append
diff --git a/packages/core/src/Table/types.ts b/packages/core/src/Table/types.ts
index 1e4b50098f..df7d497458 100644
--- a/packages/core/src/Table/types.ts
+++ b/packages/core/src/Table/types.ts
@@ -330,4 +330,24 @@ export interface XDSBaseTableProps<T extends Record<string, unknown>> {
children?: ReactNode;
/** Additional HTML attributes for the `<table>` element */
tableProps?: HTMLAttributes<HTMLTableElement>;
+ /**
+ * Content displayed when `data` is an empty array.
+ * Rendered as a full-width row spanning all columns.
+ *
+ * - **Omit or `undefined`** — renders a default compact "No data" empty state
+ * - **`ReactNode`** — renders your custom content (e.g. `<XDSEmptyState>`)
+ * - **`false`** — disables the empty state entirely (renders empty `<tbody>`)
+ *
+ * @default <XDSEmptyState title="No data" isCompact />
+ *
+ * @example
+ * ```
+ * <XDSTable
+ * data={filteredUsers}
+ * columns={columns}
+ * emptyState={<XDSEmptyState title="No results" description="Try adjusting your filters." />}
+ * />
+ * ```
+ */
+ emptyState?: ReactNode | false;
}