@mittwald/flow-react-components 1.5.0-next.47 → 1.5.0-next.49

package/dist/types/_bundled/flow-components-base/list/sorting/ListSorting.d.ts

@@ -0,0 +1,40 @@
+import { type ListModelContext } from "../ListModelContext";
+import type { PropertyName } from "../types";
+import type { ListSortingShape, SortingDefaultMode, SortingFn } from "./types";
+import type { Column, ColumnDef, ColumnSort, SortDirection } from "@tanstack/table-core";
+/**
+ * One way a list can be sorted — a property, a direction, and whether it is on.
+ *
+ * Framework-free: the state lives in the TanStack table and the preference in
+ * the settings store, and this only translates between them. Which is why it
+ * could move here whole, unlike the loader, which had to leave its fetching
+ * behind.
+ */
+export declare class ListSorting<T> {
+    readonly context: ListModelContext<T>;
+    readonly property: PropertyName<T>;
+    readonly name?: string;
+    readonly directionName?: string;
+    readonly direction: SortDirection;
+    readonly initialEnabled: SortingDefaultMode;
+    readonly customSortingFn?: SortingFn<T>;
+    readonly autosave: boolean;
+    constructor(context: ListModelContext<T>, shape: ListSortingShape<T>);
+    private getInitialEnabled;
+    updateTableColumnDef(def: ColumnDef<T>): void;
+    getReactTableColumnSort(): ColumnSort;
+    isSorted(): boolean;
+    getTableColumn(): Column<T>;
+    enable(): void;
+    clear(): void;
+    get id(): string;
+}
+export default ListSorting;
+/**
+ * The next sorting state, with every hidden sorting still in it.
+ *
+ * A hidden sorting is not a user choice — it is how the list is ordered when
+ * nothing else says otherwise, so a click on a visible sorting must not drop
+ * it. The table's own updater knows nothing about that distinction.
+ */
+export declare const mergeHiddenSorting: <T>(sortings: ListSorting<T>[], next: ColumnSort[]) => ColumnSort[];

package/dist/types/_bundled/flow-components-base/list/sorting/types.d.ts

@@ -0,0 +1,14 @@
+import type { PropertyName } from "../types";
+import type { SortDirection, SortingFn as TableSortingFn } from "@tanstack/table-core";
+/** `"hidden"` keeps a sorting out of the UI but leaves it usable in code. */
+export type SortingDefaultMode = boolean | "hidden";
+export type SortingFn<T> = TableSortingFn<T>;
+export interface ListSortingShape<T> {
+    property: PropertyName<T>;
+    name?: string;
+    directionName?: string;
+    direction?: SortDirection;
+    defaultEnabled?: SortingDefaultMode;
+    customSortingFn?: SortingFn<T>;
+    autosave?: boolean;
+}

package/dist/types/_bundled/flow-components-base/list/table/ListTable.d.ts

@@ -0,0 +1,34 @@
+import type { RowData, Table, TableOptions, TableState, Updater } from "@tanstack/table-core";
+/**
+ * A TanStack table whose state is MobX.
+ *
+ * `useReactTable` is `createTable` plus a `useState` for the table's own state
+ * and a `setOptions` on every render that folds that state back in. Only the
+ * `useState` is React, and `@tanstack/vue-table` reimplements the same twenty
+ * lines against Vue's reactivity — so the state lives here instead and each
+ * binding brings its subscription.
+ *
+ * Options still arrive from the binding on every render, because that is where
+ * they come from: the loaded data, the column definitions the list's filters
+ * and sortings produce, a controlled piece of state. `setOptions` is therefore
+ * called by the binding, and re-applied here whenever the state changes.
+ */
+export declare class ListTable<T extends RowData> {
+    readonly table: Table<T>;
+    state: TableState;
+    /**
+     * Bumped whenever the state _or_ the options changed.
+     *
+     * The row models are derived from both, and the options are plain data that
+     * arrives from the binding — so a binding observing only `state` keeps
+     * rendering the previous rows after new data was handed in. It is the one
+     * signal that says "ask the table again".
+     */
+    revision: number;
+    private options;
+    constructor(options: TableOptions<T>);
+    setState(updater: Updater<TableState>): void;
+    /** Called by the binding on every render, with that render's options. */
+    setOptions(options: TableOptions<T>): void;
+    private applyOptions;
+}

package/dist/types/_bundled/flow-components-base/list/types.d.ts

@@ -0,0 +1,18 @@
+import type { ItemType } from "../lib/array";
+import type { DeepKeys, DeepValue } from "@tanstack/table-core";
+export declare const customPropertyPrefix: "$";
+/**
+ * A column that is not a property of the item — a computed one, or one a filter
+ * invents. Prefixed so it cannot collide with a real key.
+ */
+export type CustomPropertyName = `${typeof customPropertyPrefix}${string}`;
+export type PropertyName<T> = DeepKeys<T> | CustomPropertyName;
+export type PropertyValue<T, TProp> = TProp extends CustomPropertyName ? T : DeepValue<T, TProp>;
+/**
+ * How a filter turns one of its values into something to show.
+ *
+ * The return type is the binding's: React's `Filter` narrows it to `ReactNode`,
+ * which is why the class carries it as a type parameter instead of deciding it
+ * here.
+ */
+export type PropertyValueRenderMethod<TMatcherValue, TRendered = unknown> = (prop: NonNullable<ItemType<TMatcherValue>>) => TRendered;

package/dist/types/_bundled/flow-components-base/list/viewMode/ListViewMode.d.ts

@@ -0,0 +1,25 @@
+import type { ListViewModeOptions, ListViewModeValue } from "./types";
+/**
+ * Which layout the list is in, and its persistence.
+ *
+ * The value is a MobX observable rather than a binding's own state, so that the
+ * rule it obeys — a stored mode wins over the default, and a change is written
+ * back — is one implementation. A binding brings the subscription:
+ * `useSelector` in React, `watchMobxValue` in Vue.
+ */
+export declare class ListViewMode {
+    value: ListViewModeValue;
+    private storage;
+    constructor(options?: ListViewModeOptions);
+    get autosave(): boolean;
+    /**
+     * Where a change is written, for a binding whose list can change it without a
+     * new model — React rebuilds the list every render, the view mode lives on.
+     * The value itself is read only once, at construction.
+     */
+    updateStorage(storage: Pick<ListViewModeOptions, "autosave" | "settings">): void;
+    get isTiles(): boolean;
+    get isTable(): boolean;
+    get isList(): boolean;
+    set(viewMode: ListViewModeValue): void;
+}

package/dist/types/_bundled/flow-components-base/list/viewMode/types.d.ts

@@ -0,0 +1,10 @@
+import type { ListSettingsPort } from "../settings/types";
+/** How the list lays its items out. */
+export type ListViewModeValue = "table" | "list" | "tiles";
+export interface ListViewModeOptions {
+    /** The mode to start in. A persisted mode takes precedence. */
+    defaultValue?: ListViewModeValue;
+    /** @default true */
+    autosave?: boolean;
+    settings?: ListSettingsPort;
+}

package/dist/types/components/Action/models/ActionState.d.ts

@@ -1,29 +1,16 @@
-export type ActionStateValue = "isIdle" | "isSucceeded" | "isPending" | "isExecuting" | "isFailed";
+import { ActionState as ActionStateBase } from '../../../_bundled/flow-components-base/index';
+export type { ActionStateValue } from '../../../_bundled/flow-components-base/index';
 export declare const duration: {
     pending: number;
     succeeded: number;
     failed: number;
 };
-export declare class ActionState {
-    private showFeedback?;
-    state: ActionStateValue;
-    private setPendingTimeout;
-    error: unknown;
-    private isAsync;
-    constructor();
+/**
+ * The state machine is `@mittwald/flow-components-base`'s, shared with every
+ * remote binding; this adds the hooks.
+ */
+export declare class ActionState extends ActionStateBase {
     static useNew(): ActionState;
-    updateState(newState: ActionStateValue): void;
-    useValue(): ActionStateValue;
+    useValue(): ActionStateBase["state"];
     useIsBusy(): boolean;
-    get isBusy(): boolean;
-    onAsyncStart(): void;
-    onSucceeded(): Promise<void>;
-    onFailed(error?: unknown): Promise<void>;
-    withFeedback(feedback?: boolean): ActionState;
-    private startFailedFeedback;
-    private startSucceededFeedback;
-    private resetAfterDone;
-    private clearPendingTimeout;
-    private onDone;
-    private startPending;
 }

package/dist/types/components/List/components/Header/lib.d.ts

@@ -1,2 +1 @@
-import { ListViewMode } from '../../model/types';
-export declare const useAvailableViewModes: () => ListViewMode[];
+export declare const useAvailableViewModes: () => import('../../../../_bundled/flow-components-base/index').ListViewModeValue[];

package/dist/types/components/List/model/List.d.ts

@@ -12,7 +12,9 @@ import { ReactNode } from 'react';
 import { ListSettingsStore } from './ListSettingsStore';
 import { ListViewMode } from './ListViewMode';
 import { DateRangeFilter } from './filter/DateRangeFilter';
-export declare class List<T = unknown, TMeta = unknown> {
+import { ListModelContext, ListSettingsPort } from '../../../_bundled/flow-components-base/index';
+import { Table as ReactTableInstance } from '@tanstack/table-core';
+export declare class List<T = unknown, TMeta = unknown> implements ListModelContext<T> {
     readonly filters: (Filter<T, never, never> | DateRangeFilter<T, never>)[];
     readonly itemView?: ItemView<T>;
     readonly table?: Table<T>;
@@ -35,6 +37,9 @@ export declare class List<T = unknown, TMeta = unknown> {
     readonly emptySearchResultView?: ReactNode;
     readonly settingsStorageDefaults?: ListSettingsStorageDefaults;
     constructor(shape: ListShape<T, TMeta>);
+    get dataTable(): ReactTableInstance<T>;
+    get settings(): ListSettingsPort | undefined;
+    get settingsDefaults(): ListSettingsStorageDefaults | undefined;
     getEmptyViewType(): EmptyViewType;
     get hasActiveFilters(): boolean;
     get visibleSorting(): Sorting<T>[];

package/dist/types/components/List/model/ListSettingsStore.d.ts

@@ -1,11 +1,9 @@
+import { ListSettingsOperationOptions } from '../../../_bundled/flow-components-base/index';
 import { SettingsStore } from '../../SettingsProvider/models/SettingsStore';
 import { ListSettingsStorageShape } from './types';
 import { default as List } from './List';
 import { default as z } from 'zod';
-export interface ListSettingsStoreOperationOptions {
-    autosave?: boolean;
-    manualSave?: boolean;
-}
+export type ListSettingsStoreOperationOptions = ListSettingsOperationOptions;
 declare const supportedSettings: {
     readonly activeFilters: {
         readonly supports: {

package/dist/types/components/List/model/ListViewMode.d.ts

@@ -1,18 +1,25 @@
+import { ListViewMode as ListViewModeState } from '../../../_bundled/flow-components-base/index';
 import { ListViewMode as RawListViewMode } from './types';
 import { List } from './List';
 interface Options {
     defaultViewMode?: RawListViewMode;
     autosave?: boolean;
 }
-export declare class ListViewMode<T = unknown> {
-    readonly list: List<T>;
-    readonly autosave: boolean;
-    private readonly state;
-    constructor(list: List<T>, options?: Options);
-    get value(): RawListViewMode;
-    get isTiles(): boolean;
-    get isTable(): boolean;
-    get isList(): boolean;
-    set(viewMode: RawListViewMode): void;
+/**
+ * React's view of the list's layout mode.
+ *
+ * The mode itself — the stored value winning over the default, the write-back —
+ * is `ListViewMode` in `@mittwald/flow-components-base`. What is left here is
+ * the subscription, and the fact that the model outlives a render: a view mode
+ * rebuilt every render would forget what the user picked. The list, its
+ * settings store and `autosave` are taken from the current render, as they were
+ * when this class was rebuilt with the list.
+ */
+export declare class ListViewMode<T = unknown> extends ListViewModeState {
+    private currentList;
+    private constructor();
+    get list(): List<T>;
+    private static storageOf;
+    static useNew<T>(list: List<T>, options?: Options): ListViewMode<T>;
 }
 export {};

package/dist/types/components/List/model/ReactTable.d.ts

@@ -1,4 +1,4 @@
-import { Column, ColumnSort, Table, TableOptions } from '@tanstack/react-table';
+import { Column, ColumnSort, Table, TableOptions } from '@tanstack/table-core';
 import { default as List } from './List';
 import { OnListChanged, PropertyName } from './types';
 import { SearchValue } from './search/types';

package/dist/types/components/List/model/filter/DateRangeFilter.d.ts

@@ -1,15 +1,27 @@
-import { ColumnDef } from '@tanstack/react-table';
-import { default as List } from '../List';
-import { Filter } from './Filter';
+import { ListDateRangeFilter, ListModelContext } from '../../../../_bundled/flow-components-base/index';
 import { FilterShape } from './types';
 import { PropertyName } from '../types';
-import { DateRange, RangeValue } from 'react-aria-components';
-import { DateValue } from '@internationalized/date';
 import { RangeCalendarProps } from '../../../Calendar';
-export declare class DateRangeFilter<T = never, TProp extends PropertyName<T> = never> extends Filter<T, TProp> {
+import { DateValue } from '@internationalized/date';
+import { DateRange, RangeValue } from 'react-aria-components';
+import { ReactNode } from 'react';
+import { List } from '../List';
+import { FilterValue } from './FilterValue';
+/**
+ * React's date-range filter.
+ *
+ * The column, the comparison and the stored value are `ListDateRangeFilter` in
+ * `@mittwald/flow-components-base`, so the Vue binding filters the same dates
+ * the same way. What is left here is the calendar's own options, which are
+ * Flow's `RangeCalendar` props.
+ */
+export declare class DateRangeFilter<T = never, TProp extends PropertyName<T> = never> extends ListDateRangeFilter<T, TProp, ReactNode> {
     readonly dateRangeOptions?: RangeCalendarProps;
-    constructor(list: List<T>, shape: FilterShape<T, TProp, never>);
-    updateTableColumnDef(def: ColumnDef<T>): void;
+    constructor(context: ListModelContext<T>, shape: FilterShape<T, TProp, never>);
     getValue(): DateRange | null;
-    setValue(range: RangeValue<DateValue>): void;
+    setValue(range: RangeValue<DateValue> | null): void;
+    /** The list this filter belongs to — `context`, typed as React's `List`. */
+    get list(): List<T>;
+    get values(): FilterValue[];
+    getArrayValue(): FilterValue[];
 }

package/dist/types/components/List/model/filter/Filter.d.ts

@@ -1,56 +1,22 @@
-import { ColumnDef, ColumnFilter, InitialTableState } from '@tanstack/react-table';
-import { default as List } from '../List';
-import { FilterMatcher, FilterMode, FilterShape } from './types';
-import { PropertyName, PropertyValueRenderMethod } from '../types';
+import { FilterShape } from './types';
+import { PropertyName } from '../types';
+import { ListModelContext, ListFilter } from '../../../../_bundled/flow-components-base/index';
+import { ReactNode } from 'react';
+import { List } from '../List';
 import { FilterValue } from './FilterValue';
-import { ListSettingsStoreOperationOptions } from '../ListSettingsStore';
-export declare class Filter<T = never, TProp extends PropertyName<T> = never, TMatchValue = never> {
-    private _values?;
-    private _valuesFromTableState?;
-    readonly list: List<T>;
-    readonly property: TProp;
-    readonly mode: FilterMode;
-    readonly matcher: FilterMatcher<T, never, never>;
-    readonly renderItem: PropertyValueRenderMethod<TMatchValue>;
-    readonly name?: string;
-    readonly autosave: boolean;
-    readonly manualSave: boolean;
-    private onFilterChangeCallbacks;
-    private readonly defaultSelectedValues?;
-    readonly priority: "primary" | "secondary";
-    readonly storageKey: string;
-    constructor(list: List<T>, shape: FilterShape<T, TProp, TMatchValue>);
-    updateInitialState(initialState: InitialTableState): void;
-    private getInitialSelectedIds;
-    private getStoredSelectedIds;
-    private getStoredSelectedValues;
-    static storeFilters<T>(list: List<T>, options: ListSettingsStoreOperationOptions): void;
-    updateTableColumnDef(def: ColumnDef<T>): void;
-    private getReactTableFilterFn;
-    private checkFilterMatches;
-    protected getTableColumnFilter(): ColumnFilter | undefined;
-    private getTableColumn;
-    getValue(): unknown;
-    private getValuesFromTableState;
-    private checkIfValueIsUnknown;
-    deleteUnknownFilterValues(): void;
+/**
+ * React's filter: the shared one, with `renderItem` narrowed.
+ *
+ * Everything a filter does — values, selection, persistence, the predicate the
+ * table runs — is `ListFilter` in `@mittwald/flow-components-base`. The one
+ * thing that is not shareable is what a filter value _looks_ like, so the core
+ * carries the rendered type as a parameter and this fills it with `ReactNode`.
+ */
+export declare class Filter<T = never, TProp extends PropertyName<T> = never, TMatchValue = never> extends ListFilter<T, TProp, TMatchValue, ReactNode> {
+    constructor(context: ListModelContext<T>, shape: FilterShape<T, TProp, TMatchValue>);
+    /** The list this filter belongs to — `context`, typed as React's `List`. */
+    get list(): List<T>;
     get values(): FilterValue[];
-    private get valuesFromTableState();
     getArrayValue(): FilterValue[];
-    isValueActive(value: FilterValue): boolean;
-    isActive(): boolean;
-    deactivateValue(value: FilterValue): void;
-    private callOnChangedHandlers;
-    hasChanges(): boolean;
-    isStoringAvailable(): boolean;
-    resetValues(): void;
-    clear(): void;
-    toggleValue(newValue: FilterValue): void;
-    get isSelectAllAvailable(): boolean;
-    isEveryValueActive(): boolean;
-    selectAll(): void;
-    setActiveValueIds(ids: Iterable<unknown>): void;
-    deselectAll(): void;
-    private setArrayValue;
-    onFilterUpdated(cb: () => unknown): void;
 }
+export default Filter;

package/dist/types/components/List/model/filter/FilterValue.d.ts

@@ -1,13 +1,12 @@
 import { Filter } from './Filter';
-export declare class FilterValue {
+import { ListFilterValue } from '../../../../_bundled/flow-components-base/index';
+import { ReactNode } from 'react';
+/**
+ * Framework-free apart from what it renders to, which the core takes as a type
+ * parameter — so React's is that class with `ReactNode` filled in, and its
+ * filter typed as React's, the one that carries `list`.
+ */
+export type FilterValue = ListFilterValue<ReactNode> & {
     readonly filter: Filter<unknown, string, unknown>;
-    readonly value: unknown;
-    readonly id: string;
-    private constructor();
-    static create(filter: Filter<any, any, any>, value: unknown): FilterValue;
-    equals(otherValue: FilterValue): boolean;
-    get isActive(): boolean;
-    render(): import('react').ReactNode;
-    toggle(): void;
-    deactivate(): void;
-}
+};
+export declare const FilterValue: typeof ListFilterValue;

package/dist/types/components/List/model/filter/types.d.ts

@@ -1,22 +1,10 @@
-import { PropertyName, PropertyValue, PropertyValueRenderMethod } from '../types';
-import { ItemType } from '../../../../lib/types/array';
-import { RangeCalendarProps } from '../../../Calendar';
 import { DateRangeFilter } from './DateRangeFilter';
-export type FilterMode = "all" | "some" | "one" | "dateRange";
-export type FilterMatcher<T, P, TMatcherValue> = (filterBy: NonNullable<ItemType<TMatcherValue>>, filterFrom: PropertyValue<T, P>) => boolean;
-export interface FilterShape<T, TProp extends PropertyName<T>, TMatcherValue> {
-    property: TProp;
-    renderItem?: PropertyValueRenderMethod<TMatcherValue>;
-    mode?: FilterMode;
-    matcher?: FilterMatcher<T, TProp, TMatcherValue>;
-    values?: readonly TMatcherValue[];
-    name?: string;
-    defaultSelected?: readonly NonNullable<TMatcherValue>[];
-    onChange?: FilterUpdatedCallback;
-    priority?: "primary" | "secondary";
-    autosave?: boolean;
-    manualSave?: boolean;
+import { PropertyName } from '../types';
+import { RangeCalendarProps } from '../../../Calendar';
+import { ListFilterShape } from '../../../../_bundled/flow-components-base/index';
+import { ReactNode } from 'react';
+export type { FilterMatcher, FilterMode, FilterUpdatedCallback, } from '../../../../_bundled/flow-components-base/index';
+export interface FilterShape<T, TProp extends PropertyName<T>, TMatcherValue> extends ListFilterShape<T, TProp, TMatcherValue, ReactNode> {
     dateRangeOptions?: RangeCalendarProps;
 }
-export type FilterUpdatedCallback = (values: unknown[]) => unknown;
 export type AnyDateRangeFilter = DateRangeFilter | DateRangeFilter<any, any>;

package/dist/types/components/List/model/item/Item.d.ts

@@ -1,9 +1,10 @@
+import { ListItem } from '../../../../_bundled/flow-components-base/index';
 import { ItemCollection } from './ItemCollection';
-import { Row } from '@tanstack/react-table';
-export declare class Item<T> {
-    readonly id: string;
-    readonly data: T;
+/**
+ * `ListItem` from `@mittwald/flow-components-base`, with its collection typed
+ * as React's — the one that carries `list`.
+ */
+export type Item<T> = ListItem<T> & {
     readonly collection: ItemCollection<T>;
-    constructor(collection: ItemCollection<T>, id: string, data: T);
-    static fromRow<T>(collection: ItemCollection<T>, row: Row<T>): Item<T>;
-}
+};
+export declare const Item: typeof ListItem;

package/dist/types/components/List/model/item/ItemCollection.d.ts

@@ -1,7 +1,12 @@
-import { default as List } from '../List';
+import { ListItemCollection } from '../../../../_bundled/flow-components-base/index';
 import { Item } from './Item';
-export declare class ItemCollection<T> {
-    readonly list: List<T>;
-    constructor(list: List<T>);
+import { List } from '../List';
+/**
+ * React's item collection: `ListItemCollection` from
+ * `@mittwald/flow-components-base`, plus `list` — see `Sorting` for why.
+ */
+export declare class ItemCollection<T> extends ListItemCollection<T> {
+    get list(): List<T>;
     get entries(): Item<T>[];
 }
+export default ItemCollection;

package/dist/types/components/List/model/loading/IncrementalLoaderState.d.ts

@@ -1,30 +1,20 @@
-import { ListData } from './types';
-import { AsyncResource } from '@mittwald/react-use-promise';
 import { default as List } from '../List';
-type AsyncResourceLoadingState = AsyncResource["state"]["value"];
-type DataBatches<T> = ListData<T>[];
-type BatchesLoadingState = AsyncResourceLoadingState[];
-export declare class IncrementalLoaderState<T> {
-    dataBatches: DataBatches<T>;
-    prevDataBatches: DataBatches<T>;
-    batchLoadingStates: BatchesLoadingState;
-    metadata?: unknown;
+import { ListLoaderState } from '../../../../_bundled/flow-components-base/index';
+/**
+ * React's view of the list's loading state.
+ *
+ * Everything the state _is_ — the batches, the deduplication, what counts as
+ * loading — lives in `ListLoaderState` in `@mittwald/flow-components-base`, so
+ * the Vue binding runs the same rules rather than a second implementation of
+ * them. What is left here is the subscription: MobX is framework-agnostic,
+ * reading it in a component is not.
+ */
+export declare class IncrementalLoaderState<T> extends ListLoaderState<T> {
     readonly list: List<T>;
-    isInitiallyLoading: boolean;
     private constructor();
     static useNew<T>(list: List<T>): IncrementalLoaderState<T>;
-    reset(): void;
-    setDataBatch(index: number, data: ListData<T>): void;
-    setBatchLoadingState(index: number, state: AsyncResourceLoadingState): void;
-    setMetadata(metadata?: unknown): void;
-    setIsInitiallyLoading(isInitiallyLoading: boolean): void;
-    get mergedData(): T[];
     useMergedData(): T[];
-    get isLoading(): boolean;
     useIsLoading(): boolean;
-    get isLoadingMore(): boolean;
     useIsLoadingMore(): boolean;
     useIsInitiallyLoading(): boolean;
-    isBatchLoaded(batchIndex: number): boolean;
 }
-export {};

package/dist/types/components/List/model/loading/types.d.ts

@@ -1,31 +1,11 @@
-import { PropertyRecord } from '../types';
-import { FilterMode } from '../filter/types';
+import { ListAsyncDataLoader, ListData, ListDataLoaderOptions, ListDataLoaderResult } from '../../../../_bundled/flow-components-base/index';
 import { AsyncResource } from '@mittwald/react-use-promise';
-import { SearchValue } from '../search/types';
 import { DependencyList } from 'react';
-type DataLoaderSortOptions<T> = PropertyRecord<T, "asc" | "desc">;
-type DataLoaderFilterOptions<T> = PropertyRecord<T, {
-    mode: FilterMode;
-    values: unknown[];
-}>;
-interface DataLoaderPaginationOptions {
-    offset: number;
-    limit: number;
-}
-export interface DataLoaderOptions<T> {
-    sorting?: DataLoaderSortOptions<T>;
-    filtering?: DataLoaderFilterOptions<T>;
-    searchString?: SearchValue;
-    pagination?: DataLoaderPaginationOptions;
-}
-export type ListData<T> = readonly T[];
-export interface DataLoaderResult<T> {
-    data: ListData<T>;
-    itemTotalCount?: number;
-    metadata?: unknown;
-}
+export type DataLoaderOptions<T> = ListDataLoaderOptions<T>;
+export type DataLoaderResult<T> = ListDataLoaderResult<T>;
+export type { ListData };
 export type HooksDataLoader<T> = (options: DataLoaderOptions<T>) => DataLoaderResult<T>;
-export type AsyncDataLoader<T> = (options: DataLoaderOptions<T>) => Promise<DataLoaderResult<T>>;
+export type AsyncDataLoader<T> = ListAsyncDataLoader<T>;
 export type AsyncResourceFactory<T> = (options?: DataLoaderOptions<T>) => AsyncResource<DataLoaderResult<T>>;
 interface DynamicLoaderShape {
     manualSorting?: boolean;
@@ -64,4 +44,3 @@ export interface LoaderInvocationHook {
     useLoadBatch: () => void;
     useRenderSuspense: () => void;
 }
-export {};

package/dist/types/components/List/model/pagination/BatchesController.d.ts

@@ -1,15 +1 @@
-import { default as List } from '../List';
-import { BatchesControllerShape } from './types';
-export declare class BatchesController<T> {
-    readonly batchSize: number;
-    private readonly list;
-    constructor(list: List<T>, shape?: BatchesControllerShape);
-    private get reactTable();
-    getBatchIndex(): number;
-    hasNextBatch(): boolean;
-    getTotalItemsCount(): number;
-    getVisibleItemsCount(): number;
-    updateItemTotalCount(value: number): void;
-    reset(): void;
-    nextBatch(): void;
-}
+export { ListBatchesController as BatchesController } from '../../../../_bundled/flow-components-base/index';

package/dist/types/components/List/model/pagination/types.d.ts

@@ -1,3 +1 @@
-export interface BatchesControllerShape {
-    batchSize?: number;
-}
+export type { ListBatchesControllerShape as BatchesControllerShape } from '../../../../_bundled/flow-components-base/index';

package/dist/types/components/List/model/search/Search.d.ts

@@ -1,21 +1,18 @@
-import { default as List } from '../List';
-import { SearchFieldRenderComponent, SearchShape, SearchValue } from './types';
-import { InitialTableState } from '@tanstack/react-table';
-export declare class Search<T> {
-    readonly list: List<T>;
-    readonly render?: SearchFieldRenderComponent;
+import { SearchShape } from './types';
+import { ListModelContext, ListSearch } from '../../../../_bundled/flow-components-base/index';
+import { List } from '../List';
+/**
+ * React's search: the shared one plus how the field is rendered.
+ *
+ * The term, its initial value and its persistence are `ListSearch` in
+ * `@mittwald/flow-components-base`. `render` and `textFieldProps` stay here — a
+ * component type and Flow's `SearchField` props are React, and a binding brings
+ * its own.
+ */
+export declare class Search<T> extends ListSearch<T> {
+    readonly render?: SearchShape<T>["render"];
     readonly textFieldProps: SearchShape<T>["textFieldProps"];
-    private onUpdateCallbacks;
-    private readonly initialValue?;
-    private readonly defaultValue?;
-    private readonly autosave;
-    constructor(list: List<T>, searchShape: SearchShape<T>);
-    get value(): SearchValue;
-    get isSet(): boolean;
-    private callOnUpdateCallbacks;
-    private getInitialValue;
-    updateInitialState(initialState: InitialTableState): void;
-    setValue(value: SearchValue): void;
-    clear(): void;
-    onUpdated(cb: () => unknown): void;
+    constructor(context: ListModelContext<T>, shape: SearchShape<T>);
+    /** The list this search belongs to — `context`, typed as React's `List`. */
+    get list(): List<T>;
 }