nuxt-ui-tools 0.1.2 → 1.0.0

package/dist/runtime/table/constants/grid.js

@@ -1,8 +1,8 @@
 export const GRID_DEFAULTS = {
-  mode: "flow",
   columns: 1,
-  itemSpan: 1,
   estimatedRowHeight: 272,
-  skeletonRows: 6,
-  overscan: 3
+  itemSpan: 1,
+  mode: "flow",
+  overscan: 3,
+  skeletonRows: 6
 };

package/dist/runtime/table/constants/query-state.d.ts

@@ -1,5 +1,10 @@
-import type { TableFilterOperator, TableQueryStateFilterKind } from '../types/query-state.js';
-export declare const DEFAULT_FILTER_OPERATOR: Record<TableQueryStateFilterKind, TableFilterOperator>;
+export declare const DEFAULT_FILTER_OPERATOR: {
+    boolean: "is";
+    date: "is";
+    number: "is";
+    option: "isAnyOf";
+    text: "contains";
+};
 export declare const PAGINATION_DEFAULTS: {
     defaultSize: {
         grid: number;
@@ -12,14 +17,14 @@ export declare const PAGINATION_DEFAULTS: {
 };
 /** Default TanStack Query options applied to all table queries. */
 export declare const QUERY_DEFAULTS: {
+    refetchOnWindowFocus: boolean;
     /** How long fetched data is considered fresh (ms). Prevents refetches on remount/focus. */
     staleTime: {
-        /** Main data query */
-        data: number;
         /** Context / page-context side queries */
         context: number;
+        /** Main data query */
+        data: number;
         /** Filter option queries (facets, remote options) */
         filterOptions: number;
     };
-    refetchOnWindowFocus: boolean;
 };

package/dist/runtime/table/constants/query-state.js

@@ -1,9 +1,9 @@
 export const DEFAULT_FILTER_OPERATOR = {
-  text: "contains",
-  option: "isAnyOf",
   boolean: "is",
+  date: "is",
   number: "is",
-  date: "is"
+  option: "isAnyOf",
+  text: "contains"
 };
 export const PAGINATION_DEFAULTS = {
   defaultSize: { grid: 10, table: 50 },
@@ -13,14 +13,14 @@ export const PAGINATION_DEFAULTS = {
   }
 };
 export const QUERY_DEFAULTS = {
+  refetchOnWindowFocus: false,
   /** How long fetched data is considered fresh (ms). Prevents refetches on remount/focus. */
   staleTime: {
-    /** Main data query */
-    data: 3e4,
     /** Context / page-context side queries */
     context: 6e4,
+    /** Main data query */
+    data: 3e4,
     /** Filter option queries (facets, remote options) */
     filterOptions: 3e4
-  },
-  refetchOnWindowFocus: false
+  }
 };

package/dist/runtime/table/schema/index.js

@@ -2,15 +2,16 @@ import { resolveColumns, resolveUiFilters } from "../builders/index.js";
 export function defineTableSchema(schema) {
   return {
     ...schema,
+    filters: schema.filters ? {
+      ...schema.filters,
+      ui: resolveUiFilters(schema.filters.ui)
+    } : void 0,
     table: schema.table ? {
       ...schema.table,
+      // SAFETY: the schema's inferred row/context contracts are preserved by the final schema return contract.
       columns: resolveColumns(
         schema.table.columns
       )
-    } : void 0,
-    filters: schema.filters ? {
-      ...schema.filters,
-      ui: resolveUiFilters(schema.filters.ui)
     } : void 0
   };
 }

package/dist/runtime/table/types/actions.d.ts

@@ -1,8 +1,13 @@
 import type { DropdownMenuItem } from '@nuxt/ui/components/DropdownMenu.vue';
 import type { TableSourceRequestContext } from './source.js';
+import type { TableApi } from './table-api.js';
 import type { GenericObject, MaybePromise, TableLayout, TableRowRenderParams, TableTextValue } from './utils.js';
 export interface TableActionContext<TRow extends GenericObject = GenericObject, TContext extends GenericObject = GenericObject, TPageContext extends GenericObject = GenericObject> {
     selectedRows: TRow[];
+    /** `selection` targets the checked rows; `all` targets every row matching the current query. */
+    scope: 'selection' | 'all';
+    /** Total rows matching the current query when known. */
+    matchingCount: number | null;
     context: TContext;
     pageContext: TPageContext;
     request: TableSourceRequestContext<TRow, TContext>;
@@ -18,6 +23,26 @@ export interface TableToolbarAction<TRow extends GenericObject = GenericObject,
 export interface TableBulkAction<TRow extends GenericObject = GenericObject, TContext extends GenericObject = GenericObject, TPageContext extends GenericObject = GenericObject> extends TableToolbarAction<TRow, TContext, TPageContext> {
     requiresSelection?: boolean;
 }
+/** Runtime state exposed for a configured toolbar or bulk action. */
+export interface TableActionState {
+    visible: boolean;
+    disabled: boolean;
+    loading: boolean;
+    running: boolean;
+}
+/**
+ * Headless action data for custom table toolbars.
+ *
+ * The action definition remains available alongside resolved state so a custom
+ * renderer can keep package behavior while owning the actual button markup.
+ */
+export interface TableActionSlotProps<TRow extends GenericObject = GenericObject, TContext extends GenericObject = GenericObject, TPageContext extends GenericObject = GenericObject> {
+    definition: TableBulkAction<TRow, TContext, TPageContext> | TableToolbarAction<TRow, TContext, TPageContext>;
+    state: TableActionState;
+    running: boolean;
+    selection: TableApi['selection'];
+    execute: () => Promise<void>;
+}
 export interface TableRowActionContext<TRow extends GenericObject = GenericObject, TContext extends GenericObject = GenericObject, TPageContext extends GenericObject = GenericObject> extends TableRowRenderParams<TRow, TContext, TPageContext> {
     layout: TableLayout;
 }

package/dist/runtime/table/types/columns.d.ts

@@ -1,8 +1,34 @@
-import type { GenericObject, RenderableType, TableColumnAlign, TableColumnPinned, TableKnownFieldPath, TableFieldValue, TableRowRenderParams, TableSortKey, TableTextValue } from './utils.js';
+import type { GenericObject, RenderableType, TableColumnAlign, TableColumnPinned, TableKnownFieldPath, TableFieldValue, TableRowRenderParams, TableSortKey, TableTextValue, TableRuntimeRecord } from './utils.js';
+export type TableColumnSkeleton = 'text' | 'avatar' | 'dot' | 'check' | 'badge' | 'number' | 'none';
+export type TableSummaryKind = 'sum' | 'avg' | 'count' | 'min' | 'max';
+export type TableSummaryScope = 'page' | 'filtered' | 'selection';
+export type TableSummaryValue = string | number | boolean | Date | null | undefined;
+export type TableSummaryRequest = object | null | undefined;
+export interface TableSummaryContext<TRow extends GenericObject = GenericObject> {
+    rows: TRow[];
+    scope: TableSummaryScope;
+    columnKey: string;
+    request: TableSummaryRequest;
+}
+export interface TableColumnSummaryConfig<TRow extends GenericObject = GenericObject> {
+    /** Derived aggregate computed from the rows in scope. */
+    kind?: TableSummaryKind;
+    /** Custom (possibly async) resolver; wins over `kind`. */
+    resolve?: (context: TableSummaryContext<TRow>) => TableSummaryValue | Promise<TableSummaryValue>;
+    /** Formats the resolved value for display. */
+    format?: (value: TableSummaryValue, context: TableSummaryContext<TRow>) => string | number;
+    /** Renders the cell content; receives the loading state. */
+    render?: (params: {
+        value: TableSummaryValue;
+        loading: boolean;
+        scope: TableSummaryScope;
+    }) => RenderableType;
+}
+export type TableColumnSummary<TRow extends GenericObject = GenericObject> = TableSummaryKind | TableColumnSummaryConfig<TRow> | ((context: TableSummaryContext<TRow>) => TableSummaryValue | Promise<TableSummaryValue>);
 export interface TableColumnCellDataAttributes {
     [key: `data-${string}`]: string | number | boolean | undefined;
 }
-export type TableColumnCellProps = Record<string, unknown> & TableColumnCellDataAttributes;
+export type TableColumnCellProps = TableRuntimeRecord & TableColumnCellDataAttributes;
 interface TableColumnBase<TRow extends GenericObject = GenericObject, TContext extends GenericObject = GenericObject, TPageContext extends GenericObject = GenericObject, TKey extends string = string, TParams extends TableRowRenderParams<TRow, TContext, TPageContext> = TableRowRenderParams<TRow, TContext, TPageContext>> {
     key: TKey;
     label?: TableTextValue | (() => RenderableType);
@@ -14,11 +40,17 @@ interface TableColumnBase<TRow extends GenericObject = GenericObject, TContext e
     pinned?: TableColumnPinned;
     align?: TableColumnAlign;
     labelAlign?: TableColumnAlign;
-    ellipsis?: boolean | Record<string, unknown>;
+    ellipsis?: boolean | TableRuntimeRecord;
     resizable?: boolean;
     condition?: () => boolean;
     enabled?: boolean;
     required?: boolean;
+    /** Footer aggregate for this column. */
+    summary?: TableColumnSummary<TRow>;
+    /** Placeholder shape rendered while the first page loads. */
+    skeleton?: TableColumnSkeleton;
+    /** Maximum wrapped lines before clamping; defaults to 3, `ellipsis: true` forces one line. */
+    lines?: number;
     visible?: boolean | ((context: TContext) => boolean);
     cellProps?: (params: TParams) => TableColumnCellProps;
     colSpan?: (params: TParams) => number;
@@ -31,7 +63,7 @@ interface TableColumnBase<TRow extends GenericObject = GenericObject, TContext e
 export type TableFieldRenderParams<TRow extends GenericObject = GenericObject, TContext extends GenericObject = GenericObject, TPageContext extends GenericObject = GenericObject, TField extends TableKnownFieldPath<TRow> = TableKnownFieldPath<TRow>> = TableRowRenderParams<TRow, TContext, TPageContext> & {
     value: TableFieldValue<TRow, TField>;
 };
-interface TableFieldColumnBase<TRow extends GenericObject = GenericObject, TContext extends GenericObject = GenericObject, TPageContext extends GenericObject = GenericObject, TField extends TableKnownFieldPath<TRow> = TableKnownFieldPath<TRow>> extends TableColumnBase<TRow, TContext, TPageContext, Extract<TField, string>, TableFieldRenderParams<TRow, TContext, TPageContext, TField>> {
+interface TableFieldColumnBase<TRow extends GenericObject = GenericObject, TContext extends GenericObject = GenericObject, TPageContext extends GenericObject = GenericObject, TField extends TableKnownFieldPath<TRow> = TableKnownFieldPath<TRow>> extends TableColumnBase<TRow, TContext, TPageContext, TField, TableFieldRenderParams<TRow, TContext, TPageContext, TField>> {
     kind: 'field';
     field: TField;
     render?: (params: TableFieldRenderParams<TRow, TContext, TPageContext, TField>) => RenderableType;
@@ -54,7 +86,7 @@ export type TableFieldColumnOptions<TRow extends GenericObject = GenericObject,
 export type TableCompositeColumnOptions<TRow extends GenericObject = GenericObject, TContext extends GenericObject = GenericObject, TPageContext extends GenericObject = GenericObject, TKey extends string = string, TSortKey extends string = TableSortKey<TRow>> = Omit<TableCompositeColumn<TRow, TContext, TPageContext, TKey, TSortKey>, 'key' | 'kind'>;
 export type TableDisplayColumnOptions<TRow extends GenericObject = GenericObject, TContext extends GenericObject = GenericObject, TPageContext extends GenericObject = GenericObject, TKey extends string = string> = Omit<TableDisplayColumn<TRow, TContext, TPageContext, TKey>, 'key' | 'kind'>;
 export interface TableColumnBuilder<TRow extends GenericObject = GenericObject, TContext extends GenericObject = GenericObject, TPageContext extends GenericObject = GenericObject, TSortKey extends string = TableSortKey<TRow>> {
-    field<TField extends TableKnownFieldPath<TRow>>(field: TField, options?: TableFieldColumnOptions<TRow, TContext, TPageContext, TField>): TableFieldColumn<TRow, TContext, TPageContext, TField>;
+    field<TField extends TableKnownFieldPath<TRow> & string>(field: TField, options?: TableFieldColumnOptions<TRow, TContext, TPageContext, TField>): TableFieldColumn<TRow, TContext, TPageContext, TField>;
     composite<TKey extends string>(key: TKey, options: TableCompositeColumnOptions<TRow, TContext, TPageContext, TKey, TSortKey>): TableCompositeColumn<TRow, TContext, TPageContext, TKey, TSortKey>;
     display<TKey extends string>(key: TKey, options: TableDisplayColumnOptions<TRow, TContext, TPageContext, TKey>): TableDisplayColumn<TRow, TContext, TPageContext, TKey>;
 }

package/dist/runtime/table/types/context.d.ts

@@ -21,6 +21,6 @@ type ContextItemRecord<TItem> = TItem extends {
     } ? TQuery extends {
         queryFn?: (...args: never[]) => Promise<infer TValue> | (infer TValue);
     } ? Awaited<TValue> : TQuery extends TableQueryDefinition<infer TValue> ? Awaited<TValue> : never : never;
-} : {};
+} : NonNullable<unknown>;
 export type TableContextDataFromItems<TItems extends unknown[]> = Prettify<UnionToIntersection<ContextItemRecord<TItems[number]>>>;
 export {};

package/dist/runtime/table/types/data-list.d.ts

@@ -1,6 +1,19 @@
+import type { BadgeProps } from '@nuxt/ui/components/Badge.vue';
+import type { ButtonProps } from '@nuxt/ui/components/Button.vue';
+import type { CheckboxProps } from '@nuxt/ui/components/Checkbox.vue';
+import type { InputProps } from '@nuxt/ui/components/Input.vue';
+import type { PaginationProps } from '@nuxt/ui/components/Pagination.vue';
+import type { SelectProps } from '@nuxt/ui/components/Select.vue';
+import type { TableLayout } from './utils.js';
 export type DataListDensity = 'compact' | 'default' | 'comfortable';
-export type DataListControlSize = 'xs' | 'sm' | 'md' | 'lg';
+export type DataListControlSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+/** Controls whether a granular content part owns its table boundary. */
+export type DataListContentSurface = 'plain' | 'contained';
+/** Selects the width contract for table popover content. */
+export type DataListPopoverSizing = 'fit' | 'trigger' | 'independent';
 export type DataListContentFit = 'content' | 'height' | 'fill';
+export type DataListFilterPanelMode = 'drawer' | 'panel';
+export type DataListFilterPanelCommitMode = 'live' | 'submit';
 /** A Tailwind class override for a named DataList UI slot. */
 export type DataListUiClass = string;
 /** UI slots rendered by the built-in DataList recipe. */
@@ -29,6 +42,7 @@ export interface DataListSearchUi {
 /** Shared UI slots rendered by a progressive filter editor popover. */
 export interface DataListFilterEditorUi {
     popoverContent?: DataListUiClass;
+    editorHeader?: DataListUiClass;
     operatorContent?: DataListUiClass;
     operatorItem?: DataListUiClass;
     operatorLabel?: DataListUiClass;
@@ -62,6 +76,10 @@ export interface DataListFilterEditorUi {
 export interface DataListFilterTagsUi extends DataListFilterEditorUi {
     root?: DataListUiClass;
     trigger?: DataListUiClass;
+    activeTrigger?: DataListUiClass;
+    activeRoot?: DataListUiClass;
+    sheetTrigger?: DataListUiClass;
+    sheetContent?: DataListUiClass;
     label?: DataListUiClass;
     value?: DataListUiClass;
     dismiss?: DataListUiClass;
@@ -71,6 +89,7 @@ export interface DataListFilterTagsUi extends DataListFilterEditorUi {
 /** UI slots rendered by the progressive add-filter picker. */
 export interface DataListAddFilterUi extends DataListFilterEditorUi {
     trigger?: DataListUiClass;
+    title?: DataListUiClass;
     panel?: DataListUiClass;
     optionTrailingIcon?: DataListUiClass;
 }
@@ -86,13 +105,40 @@ export interface DataListFilterPanelUi {
     body?: DataListUiClass;
     footer?: DataListUiClass;
     title?: DataListUiClass;
+    results?: DataListUiClass;
     description?: DataListUiClass;
     close?: DataListUiClass;
     fields?: DataListUiClass;
+    section?: DataListUiClass;
+    sectionTitle?: DataListUiClass;
+    field?: DataListUiClass;
+    fieldLabel?: DataListUiClass;
+    fieldMeta?: DataListUiClass;
+    chips?: DataListUiClass;
+    chip?: DataListUiClass;
+    chipActive?: DataListUiClass;
+    matching?: DataListUiClass;
     footerActions?: DataListUiClass;
     clear?: DataListUiClass;
     apply?: DataListUiClass;
 }
+/** Component props exposed by the filter slideover. */
+export interface DataListFilterPanelProps {
+    trigger?: DataListButtonProps;
+    /** Active-filter badge inside the trigger; `false` hides it. */
+    count?: DataListBadgeProps | false;
+    close?: DataListButtonProps;
+    clear?: DataListButtonProps;
+    apply?: DataListButtonProps;
+    /** Renders option filters as inline chips up to this many options; `false` always uses the picker. Defaults to 8. */
+    chips?: number | false;
+}
+export interface DataListFilterPanelConfig extends DataListPartConfig<DataListFilterPanelUi, DataListFilterPanelProps> {
+    /** Renders the filter fields inline instead of inside a slideover. */
+    mode?: DataListFilterPanelMode;
+    /** Applies each field change immediately or waits for the Apply command. */
+    commitMode?: DataListFilterPanelCommitMode;
+}
 /** UI slots rendered by the clear-filters control. */
 export interface DataListClearFiltersUi {
     [slot: string]: DataListUiClass | undefined;
@@ -116,6 +162,9 @@ export interface DataListRefreshUi {
 /** UI slots rendered by the column picker. */
 export interface DataListColumnPanelUi {
     trigger?: DataListUiClass;
+    count?: DataListUiClass;
+    title?: DataListUiClass;
+    close?: DataListUiClass;
     popoverContent?: DataListUiClass;
     panel?: DataListUiClass;
     searchHeader?: DataListUiClass;
@@ -164,6 +213,11 @@ export interface DataListContentUi {
     errorDescription?: DataListUiClass;
     retry?: DataListUiClass;
 }
+/** Render the content boundary here or leave it to the surrounding composition. */
+export interface DataListContentOptions {
+    /** Use `contained` for an assembled boundary, or `plain` for consumer-owned composition. */
+    surface?: DataListContentSurface;
+}
 /** UI slots rendered by the table mode. Nuxt UI table slots are forwarded unchanged. */
 export interface DataListTableUi {
     wrapper?: DataListUiClass;
@@ -227,13 +281,119 @@ export interface DataListInfiniteLoaderUi {
     loadMore?: DataListUiClass;
     end?: DataListUiClass;
 }
-export interface DataListPartConfig<TUi> {
+/** Nuxt UI props forwarded to one control rendered by a DataList part. */
+export type DataListControlProps<TProps> = Partial<Omit<TProps, 'ui'>>;
+export type DataListButtonProps = DataListControlProps<ButtonProps>;
+export type DataListBadgeProps = DataListControlProps<BadgeProps>;
+export type DataListInputProps = DataListControlProps<InputProps>;
+export type DataListCheckboxProps = DataListControlProps<CheckboxProps>;
+export type DataListPaginationControlProps = DataListControlProps<PaginationProps>;
+export type DataListSelectControlProps = DataListControlProps<SelectProps>;
+/** Component props exposed by the search input. */
+export interface DataListSearchProps {
+    input?: DataListInputProps;
+}
+/** Component props exposed by filter tags and their adjacent actions. */
+export interface DataListFilterTagsProps {
+    /** Renders the filter kind icon before the label; defaults to true. */
+    icon?: boolean;
+    /** Dormant tag: the filter is configured but has no value yet. */
+    trigger?: DataListButtonProps;
+    /** Active tag segments once the filter holds a value. */
+    activeTrigger?: DataListButtonProps;
+    operatorTrigger?: DataListButtonProps;
+    value?: DataListButtonProps;
+    dismiss?: DataListButtonProps;
+    previewBadge?: DataListBadgeProps;
+    /** Checkboxes inside option editors. */
+    optionCheckbox?: DataListCheckboxProps;
+    /** Renders a label + clear header above option editors; defaults to true. */
+    editorHeader?: boolean;
+    addTrigger?: DataListButtonProps;
+    clearTrigger?: DataListButtonProps;
+    /** Mobile bottom-sheet trigger. */
+    sheetTrigger?: DataListButtonProps;
+}
+/** Component props exposed by the add-filter picker. */
+export interface DataListAddFilterProps {
+    trigger?: DataListButtonProps;
+    /** Shows the filter search box; a number enables it above that many filters. Defaults to 8. */
+    search?: boolean | number;
+    /** Shows the picker title; defaults to true. */
+    title?: boolean;
+    /** Row icon: a plus sign (default) or the filter kind icon. */
+    icon?: 'plus' | 'kind';
+}
+/** Component props exposed by the column picker trigger. */
+export interface DataListColumnPanelProps {
+    /** Shows the column search box; a number enables it above that many columns. Defaults to 30. */
+    search?: boolean | number;
+    checkbox?: DataListCheckboxProps;
+    trigger?: DataListButtonProps;
+    /** Visible-column count badge inside the trigger; `false` hides it. */
+    count?: DataListBadgeProps | false;
+    reset?: DataListButtonProps;
+}
+/** Component props exposed by the sort menu trigger. */
+export interface DataListSortMenuProps {
+    trigger?: DataListButtonProps;
+    /** Mobile bottom-sheet trigger (icon-only by default). */
+    sheetTrigger?: DataListButtonProps;
+}
+/** Component props exposed by the layout switcher. */
+export interface DataListLayoutSwitchProps {
+    trigger?: DataListButtonProps;
+    activeTrigger?: DataListButtonProps;
+    /** Icons per layout; defaults to list and box icons. */
+    icons?: Partial<Record<TableLayout, string>>;
+}
+/** Component props exposed by the table renderer controls. */
+export interface DataListTableProps {
+    checkbox?: DataListCheckboxProps;
+    rowActions?: DataListButtonProps;
+    /** Empty state copy; `description: false` hides the second line. */
+    empty?: {
+        icon?: string;
+        title?: string;
+        description?: string | false;
+    };
+}
+/** Component props exposed by offset pagination. */
+export interface DataListPaginationProps {
+    pagination?: DataListPaginationControlProps;
+    pageSize?: DataListSelectControlProps;
+    /** Renders the first/last page buttons; defaults to true. */
+    firstLast?: boolean;
+}
+/** Component props exposed by the floating selection bar. */
+export interface DataListSelectionActionsProps {
+    action?: DataListButtonProps;
+    overflow?: DataListButtonProps;
+    dismiss?: DataListButtonProps;
+    scope?: DataListButtonProps;
+}
+/** Component props exposed by the refresh control. */
+export interface DataListRefreshProps {
+    button?: DataListButtonProps;
+}
+/** Component props exposed by the clear-filters control. */
+export interface DataListClearFiltersProps {
+    button?: DataListButtonProps;
+}
+/** Component props exposed by the cursor loader. */
+export interface DataListInfiniteLoaderProps {
+    loadMore?: DataListButtonProps;
+    retry?: DataListButtonProps;
+}
+export interface DataListPartConfig<TUi, TProps = Record<string, never>> {
     /** Overrides the control size derived from the DataList density. */
     size?: DataListControlSize;
     /** Named class slots for this granular component. */
     ui?: TUi;
+    /** Nuxt UI component props (variant, color, size…) for the controls this part renders. */
+    props?: TProps;
 }
-export interface DataListSearchConfig extends DataListPartConfig<DataListSearchUi> {
+export interface DataListSearchConfig extends DataListPartConfig<DataListSearchUi, DataListSearchProps> {
     /** CSS width for the search input; it remains capped to its container. */
     width?: string;
 }
@@ -254,26 +414,40 @@ export interface DataListUiConfig {
         ui?: DataListDefaultUi;
     };
     search?: DataListSearchConfig;
-    filterTags?: DataListPartConfig<DataListFilterTagsUi>;
-    addFilter?: DataListPartConfig<DataListAddFilterUi>;
-    filterPanel?: DataListPartConfig<DataListFilterPanelUi>;
-    clearFilters?: DataListPartConfig<DataListClearFiltersUi>;
-    resultCount?: {
-        ui?: DataListResultCountUi;
-    };
-    refresh?: DataListPartConfig<DataListRefreshUi>;
-    columnPanel?: DataListPartConfig<DataListColumnPanelUi>;
-    sortMenu?: DataListPartConfig<DataListSortMenuUi>;
-    layoutSwitch?: DataListPartConfig<DataListLayoutSwitchUi>;
-    content?: {
-        ui?: DataListContentUi;
-    };
-    table?: {
-        ui?: DataListTableUi;
-    };
-    grid?: {
-        ui?: DataListGridUi;
-    };
-    pagination?: DataListPartConfig<DataListPaginationUi>;
-    infiniteLoader?: DataListPartConfig<DataListInfiniteLoaderUi>;
+    filterTags?: DataListPartConfig<DataListFilterTagsUi, DataListFilterTagsProps>;
+    addFilter?: DataListPartConfig<DataListAddFilterUi, DataListAddFilterProps>;
+    filterPanel?: DataListFilterPanelConfig;
+    clearFilters?: DataListPartConfig<DataListClearFiltersUi, DataListClearFiltersProps>;
+    resultCount?: DataListPartConfig<DataListResultCountUi>;
+    refresh?: DataListPartConfig<DataListRefreshUi, DataListRefreshProps>;
+    columnPanel?: DataListPartConfig<DataListColumnPanelUi, DataListColumnPanelProps>;
+    sortMenu?: DataListPartConfig<DataListSortMenuUi, DataListSortMenuProps>;
+    layoutSwitch?: DataListPartConfig<DataListLayoutSwitchUi, DataListLayoutSwitchProps>;
+    content?: DataListPartConfig<DataListContentUi>;
+    table?: DataListTableConfig;
+    grid?: DataListGridConfig;
+    pagination?: DataListPartConfig<DataListPaginationUi, DataListPaginationProps>;
+    infiniteLoader?: DataListPartConfig<DataListInfiniteLoaderUi, DataListInfiniteLoaderProps>;
+    selectionActions?: DataListPartConfig<DataListSelectionActionsUi, DataListSelectionActionsProps>;
+    /** Overrides merged on top of this config while the viewport is below the `md` breakpoint. */
+    mobile?: Omit<DataListUiConfig, 'mobile'>;
+}
+export interface DataListGridConfig extends DataListPartConfig<DataListGridUi> {
+    /** Gap between cards in px; defaults to 16. */
+    gap?: number;
+}
+export interface DataListTableConfig extends DataListPartConfig<DataListTableUi, DataListTableProps> {
+    /** Horizontal padding of the first and last cells, in px; defaults to the cell padding. */
+    gutter?: number;
+}
+/** UI slots rendered by the floating selection bar. */
+export interface DataListSelectionActionsUi {
+    root?: DataListUiClass;
+    bar?: DataListUiClass;
+    count?: DataListUiClass;
+    scope?: DataListUiClass;
+    actions?: DataListUiClass;
+    action?: DataListUiClass;
+    overflow?: DataListUiClass;
+    dismiss?: DataListUiClass;
 }

package/dist/runtime/table/types/filters.d.ts

@@ -1,6 +1,7 @@
 import type { TableFilterOperator, TableQueryStateFilterRule, TableQueryStateFilterValue } from './query-state.js';
 import type { TableFacetExecutionResult, TableFacetRequestDescriptor, TableFacetsContext, TableQueryDefinition } from './source.js';
 import type { GenericObject, RenderableType, TableFieldPath, TableKnownFieldPath, TableTextValue } from './utils.js';
+export { type TableFilterOperator } from './query-state.js';
 export interface TableSearchFilter<TRow extends GenericObject = GenericObject> {
     fields: TableFieldPath<TRow>[];
     placeholder?: TableTextValue;
@@ -19,7 +20,8 @@ export type TableFilterDisplayLocationValue = TableFilterDisplayLocation | strin
 export interface TableFilterBehaviorCommon<TOperator extends TableFilterOperator = TableFilterOperator> {
     /**
      * Effective filter value when the URL has no override for this definition.
-     * The default stays active but is omitted from the URL; clearing the filter restores it.
+     * The default drives queries but is omitted from the URL and does not count as active UI state.
+     * Clearing an override restores this value.
      */
     defaultValue?: TableQueryStateFilterValue;
     operators?: TOperator[];
@@ -487,20 +489,23 @@ export interface TableFilterOptionValueEntry<TValue = TableFilterPrimitiveValue>
     label: TableTextValue;
     value: TValue;
     icon?: string;
+    /** CSS color rendered as a dot before the label in tags and editors. */
+    color?: string;
     count?: number;
-    children?: ReadonlyArray<TableFilterOptionEntry<TValue>>;
+    children?: readonly TableFilterOptionEntry<TValue>[];
 }
 export interface TableFilterOptionGroupEntry<TValue = TableFilterPrimitiveValue> {
     label: TableTextValue;
     value?: undefined;
     icon?: string;
+    color?: string;
     count?: number;
-    children: ReadonlyArray<TableFilterOptionEntry<TValue>>;
+    children: readonly TableFilterOptionEntry<TValue>[];
 }
 export type TableFilterOptionEntry<TValue = TableFilterPrimitiveValue> = TableFilterOptionValueEntry<TValue> | TableFilterOptionGroupEntry<TValue>;
 export type TableOptionEntryForPresentation<TValue = TableFilterPrimitiveValue, TPresentation extends TableOptionFilterPresentation = TableOptionFilterPresentation> = TPresentation extends 'tree' ? TableFilterOptionEntry<TValue> : TableFilterOptionValueEntry<TValue>;
 export interface TableFilterOptionQueryResultForPresentation<TValue = TableFilterPrimitiveValue, TPresentation extends TableOptionFilterPresentation = TableOptionFilterPresentation> {
-    options: ReadonlyArray<TableOptionEntryForPresentation<TValue, TPresentation>>;
+    options: readonly TableOptionEntryForPresentation<TValue, TPresentation>[];
     nextCursor?: string | null;
     total?: number;
 }
@@ -509,15 +514,17 @@ export interface TableResolvedFilterOptionEntry<TValue = TableFilterPrimitiveVal
     label: string;
     value?: TValue;
     icon?: string;
+    color?: string;
     count?: number;
     selected: boolean;
-    children: Array<TableResolvedFilterOptionEntry<TValue>>;
+    children: TableResolvedFilterOptionEntry<TValue>[];
 }
 export interface TableVisibleFilterOptionEntry<TValue = TableFilterPrimitiveValue> {
     id: string;
     label: string;
     value?: TValue;
     icon?: string;
+    color?: string;
     count?: number;
     selected: boolean;
     depth: number;
@@ -547,7 +554,7 @@ export type TableFilterFacetSpec<TRow extends GenericObject = GenericObject, TCo
 export interface TableStaticFilterRule<TRow extends GenericObject = GenericObject, TContext extends GenericObject = GenericObject, TKey extends string = TableKnownFieldPath<TRow>> {
     key: TKey;
     operator: TableFilterOperator;
-    value: unknown | ((context: TContext) => unknown);
+    value: TableQueryStateFilterValue | ((context: TContext) => TableQueryStateFilterValue);
 }
 export interface TableResolvedFilterCondition<TKey extends string = string, TValue = unknown> {
     type: 'condition';
@@ -588,7 +595,7 @@ export interface TableTextFilterDefinition<TRow extends GenericObject = GenericO
 export interface TableOptionFilterDefinition<TRow extends GenericObject = GenericObject, TContext extends GenericObject = GenericObject, TKey extends string = TableKnownFieldPath<TRow>, TValue = TableFilterPrimitiveValue, TPresentation extends TableOptionFilterPresentation = TableOptionFilterPresentation> extends TableFilterDefinitionBase<TRow, TContext, TKey, TValue[], TableOptionFilterOperator> {
     kind: 'option';
     source?: {
-        options?: ReadonlyArray<TableOptionEntryForPresentation<TValue, TPresentation>>;
+        options?: readonly TableOptionEntryForPresentation<TValue, TPresentation>[];
         query?: (context: TableFilterOptionQueryContext) => TableQueryDefinition<TableOptionEntryForPresentation<TValue, TPresentation>[] | TableFilterOptionQueryResultForPresentation<TValue, TPresentation>>;
         facet?: TableFilterFacetSpec<TRow, TContext, TKey>;
         sort?: 'alpha' | 'count';
@@ -619,7 +626,6 @@ export interface TableDateFilterDefinition<TRow extends GenericObject = GenericO
     preview?: TableDateFilterPreviewConfig;
 }
 export type TableUiFilterDefinition<TRow extends GenericObject = GenericObject, TContext extends GenericObject = GenericObject, TKey extends string = TableKnownFieldPath<TRow>> = TableTextFilterDefinition<TRow, TContext, TKey> | TableOptionFilterDefinition<TRow, TContext, TKey, TableFilterPrimitiveValue, TableOptionFilterPresentation> | TableBooleanFilterDefinition<TRow, TContext, TKey> | TableNumberFilterDefinition<TRow, TContext, TKey> | TableDateFilterDefinition<TRow, TContext, TKey>;
-export type { TableFilterOperator };
 export type TableTextFilterOptions<TRow extends GenericObject = GenericObject, TContext extends GenericObject = GenericObject, TKey extends string = TableKnownFieldPath<TRow>> = Omit<TableTextFilterDefinition<TRow, TContext, TKey>, 'key' | 'kind'>;
 export type TableOptionFilterOptions<TRow extends GenericObject = GenericObject, TContext extends GenericObject = GenericObject, TKey extends string = TableKnownFieldPath<TRow>, TValue = TableFilterPrimitiveValue, TPresentation extends TableOptionFilterPresentation = TableOptionFilterPresentation> = Omit<TableOptionFilterDefinition<TRow, TContext, TKey, TValue, TPresentation>, 'key' | 'kind'>;
 export type TableBooleanFilterOptions<TRow extends GenericObject = GenericObject, TContext extends GenericObject = GenericObject, TKey extends string = TableKnownFieldPath<TRow>> = Omit<TableBooleanFilterDefinition<TRow, TContext, TKey>, 'key' | 'kind'>;