@mittwald/flow-remote-vue-components 0.0.0-stage → 1.5.0-next.35

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

@@ -0,0 +1,36 @@
+export type ActionStateValue = "isIdle" | "isSucceeded" | "isPending" | "isExecuting" | "isFailed";
+/** How long each state lasts, in ms. */
+export declare const actionStateDurations: {
+    /** An async action counts as pending only after this long. */
+    pending: number;
+    succeeded: number;
+    failed: number;
+};
+/**
+ * What an `Action` shows on its button: executing, pending, then succeeded or
+ * failed for a moment, then idle again.
+ *
+ * A synchronous action shows success only with `showFeedback`, an async one
+ * unless `showFeedback` is `false`. A failure is shown either way.
+ */
+export declare class ActionState {
+    private showFeedback?;
+    state: ActionStateValue;
+    private setPendingTimeout;
+    error: unknown;
+    private isAsync;
+    constructor();
+    updateState(newState: ActionStateValue): void;
+    get isBusy(): boolean;
+    onAsyncStart(): void;
+    onSucceeded(): Promise<void>;
+    onFailed(error?: unknown): Promise<void>;
+    withFeedback(feedback?: boolean): this;
+    private startFailedFeedback;
+    private startSucceededFeedback;
+    private resetAfterDone;
+    private clearPendingTimeout;
+    private onDone;
+    private startPending;
+}
+export default ActionState;

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

@@ -0,0 +1,23 @@
+export { ActionState, actionStateDurations, type ActionStateValue, } from "./action/ActionState";
+export { toArray, type ItemType } from "./lib/array";
+export { ListFilter } from "./list/filter/ListFilter";
+export { ListDateRangeFilter } from "./list/filter/ListDateRangeFilter";
+export { applyDateRangeColumnDef, dateRangeFilterFn, isListDateRange, type ListDateParts, type ListDateRange, } from "./list/filter/dateRange";
+export { ListFilterValue } from "./list/filter/ListFilterValue";
+export type { FilterMatcher, FilterMode, FilterUpdatedCallback, ListFilterShape, } from "./list/filter/types";
+export { getListColumn, type ListModelContext } from "./list/ListModelContext";
+export { ListItem } from "./list/item/ListItem";
+export { ListItemCollection } from "./list/item/ListItemCollection";
+export { ListLoaderState, type ListLoaderStateOptions, } from "./list/loading/ListLoaderState";
+export { getListDataLoaderOptions, type BatchLoadingState, type ListAsyncDataLoader, type ListData, type ListDataLoaderOptions, type ListDataLoaderOptionsSource, type ListDataLoaderResult, type ListPropertyRecord, type QueryableFilter, } from "./list/loading/types";
+export { ListBatchesController, type ListPaginationContext, } from "./list/pagination/ListBatchesController";
+export type { ListBatchesControllerShape, ListLoaderModes, } from "./list/pagination/types";
+export { ListSearch } from "./list/search/ListSearch";
+export type { ListSearchShape, SearchValue } from "./list/search/types";
+export type { ListActiveFiltersSetting, ListSearchSetting, ListSettingKey, ListSettingsDefaults, ListSettingsOperationOptions, ListSettingsPort, ListSortingSetting, } from "./list/settings/types";
+export { ListSorting, mergeHiddenSorting } from "./list/sorting/ListSorting";
+export { ListTable } from "./list/table/ListTable";
+export type { ListSortingShape, SortingDefaultMode, SortingFn, } from "./list/sorting/types";
+export { ListViewMode } from "./list/viewMode/ListViewMode";
+export type { ListViewModeOptions, ListViewModeValue, } from "./list/viewMode/types";
+export { customPropertyPrefix, type CustomPropertyName, type PropertyName, type PropertyValue, type PropertyValueRenderMethod, } from "./list/types";

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

@@ -0,0 +1,4 @@
+/** One value or many, as many. */
+export declare const toArray: <T>(value: T | T[]) => T[];
+/** The element type of an array, or the type itself when it is not one. */
+export type ItemType<T> = T extends (infer TItem)[] ? TItem : T;

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

@@ -0,0 +1,30 @@
+import type { ListSettingsDefaults, ListSettingsPort } from "./settings/types";
+import type { PropertyName } from "./types";
+import type { Column, Table } from "@tanstack/table-core";
+/**
+ * What a shared list model may reach for.
+ *
+ * The narrow replacement for the `List` back-reference the model classes used
+ * to carry: a `List` is a React object — its constructor calls hooks — while
+ * what sorting and searching actually need is the TanStack table and the
+ * persistence. A binding's own list satisfies this shape and keeps passing
+ * itself.
+ *
+ * `dataTable`, not `table`: Flow's `List` already calls its own view model
+ * `table`, and the TanStack instance is a different thing — the rows, the
+ * sorting state and the global filter. It is a getter on purpose, because the
+ * model is built before the table is and reading it eagerly reads `undefined`.
+ */
+export interface ListModelContext<T> {
+    readonly dataTable: Table<T>;
+    readonly settings?: ListSettingsPort;
+    readonly settingsDefaults?: ListSettingsDefaults;
+}
+/**
+ * The table's column for a property.
+ *
+ * Throws rather than returning `undefined`: a sorting or a filter names a
+ * column the list declared, so a miss is a wiring mistake, and the alternative
+ * is a control that silently does nothing.
+ */
+export declare const getListColumn: <T>(table: Table<T>, property: PropertyName<T>) => Column<T>;

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

@@ -0,0 +1,18 @@
+import { ListFilter } from "./ListFilter";
+import { type ListDateRange } from "./dateRange";
+import type { PropertyName } from "../types";
+import type { ColumnDef } from "@tanstack/table-core";
+/**
+ * A filter over a span of days rather than over a set of values.
+ *
+ * Everything except the control that picks the range: the table column, the
+ * comparison and the stored value are the same in every binding, and what a
+ * calendar looks like is not. A binding subclasses this to add its own calendar
+ * options.
+ */
+export declare class ListDateRangeFilter<T = never, TProp extends PropertyName<T> = never, TRendered = unknown> extends ListFilter<T, TProp, never, TRendered> {
+    updateTableColumnDef(def: ColumnDef<T>): void;
+    getValue(): ListDateRange | null;
+    setValue(range: ListDateRange | null): void;
+}
+export default ListDateRangeFilter;

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

@@ -0,0 +1,104 @@
+import { type ListModelContext } from "../ListModelContext";
+import type { ListSettingsOperationOptions } from "../settings/types";
+import type { PropertyName, PropertyValueRenderMethod } from "../types";
+import { ListFilterValue } from "./ListFilterValue";
+import type { FilterMatcher, FilterMode, ListFilterShape } from "./types";
+import type { Column, ColumnDef, ColumnFilter, InitialTableState } from "@tanstack/table-core";
+/** What `storeFilters` needs of a filter, and nothing more. */
+interface StorableFilter {
+    readonly storageKey: string;
+    getArrayValue(): {
+        id: string;
+    }[];
+}
+/**
+ * One filter of a list: its values, which of them are on, and how that is
+ * persisted.
+ *
+ * Framework-free apart from one thing, which is why `TRendered` exists: a
+ * filter value has to be _shown_, and what "shown" is belongs to the binding.
+ * React's `Filter` fills it with `ReactNode`; the default is `unknown`, so the
+ * core can be read without deciding.
+ *
+ * The selected values live in the TanStack table's column filter, not here.
+ * This translates: ids to values, values to a predicate, a toggle to a new
+ * column filter.
+ */
+export declare class ListFilter<T = never, TProp extends PropertyName<T> = never, TMatchValue = never, TRendered = unknown> {
+    private _values?;
+    private valuesFromTableState?;
+    readonly context: ListModelContext<T>;
+    readonly property: TProp;
+    readonly mode: FilterMode;
+    readonly matcher: FilterMatcher<T, never, never>;
+    readonly renderItem: PropertyValueRenderMethod<TMatchValue, TRendered>;
+    readonly name?: string;
+    readonly autosave: boolean;
+    readonly manualSave: boolean;
+    private readonly onFilterChangeCallbacks;
+    private readonly defaultSelectedValues?;
+    readonly priority: "primary" | "secondary";
+    readonly storageKey: string;
+    constructor(context: ListModelContext<T>, shape: ListFilterShape<T, TProp, TMatchValue, TRendered>);
+    updateInitialState(initialState: InitialTableState): void;
+    private getInitialSelectedIds;
+    private getStoredSelectedIds;
+    private getStoredSelectedValues;
+    /**
+     * Writes every filter's selection in one go — they share a settings key.
+     *
+     * Takes the two members it reads rather than a `ListFilter<any, …>`: a
+     * `Table<never>` is not assignable to a `Table<any>` (a row model sits in a
+     * contravariant position deep inside), so a list of concrete filters would
+     * not go in.
+     */
+    static storeFilters<T>(context: ListModelContext<T>, filters: StorableFilter[], options: ListSettingsOperationOptions): void;
+    updateTableColumnDef(def: ColumnDef<T>): void;
+    private getTableFilterFn;
+    private checkFilterMatches;
+    protected getTableColumnFilter(): ColumnFilter | undefined;
+    protected getTableColumn(): Column<T>;
+    getValue(): unknown;
+    private getValuesFromTableState;
+    private checkIfValueIsUnknown;
+    /**
+     * Drops a selection the data no longer offers — a stored filter value whose
+     * item is gone would otherwise filter everything away with no way to undo
+     * it.
+     */
+    deleteUnknownFilterValues(): void;
+    /**
+     * The values the filter offers — the ones it was given, or the ones the data
+     * has.
+     *
+     * Follows the table, not a snapshot. A binding that keeps one filter instance
+     * for the list's lifetime would otherwise hold the answer from before the
+     * first batch arrived: an async loader gives the header an empty menu and
+     * never fills it. The values are cached per faceted-values map, which
+     * TanStack replaces when the data changes.
+     */
+    get values(): ListFilterValue<TRendered>[];
+    getArrayValue(): ListFilterValue<TRendered>[];
+    isValueActive(value: ListFilterValue<TRendered>): boolean;
+    isActive(): boolean;
+    deactivateValue(value: ListFilterValue<TRendered>): void;
+    private callOnChangedHandlers;
+    hasChanges(): boolean;
+    isStoringAvailable(): boolean;
+    resetValues(): void;
+    clear(): void;
+    toggleValue(newValue: ListFilterValue<TRendered>): void;
+    /**
+     * Whether the filter offers "Select all" — a `some` filter with enough
+     * values.
+     */
+    get isSelectAllAvailable(): boolean;
+    isEveryValueActive(): boolean;
+    selectAll(): void;
+    /** Makes exactly these values active — what a multiple-selection menu reports. */
+    setActiveValueIds(ids: Iterable<unknown>): void;
+    deselectAll(): void;
+    private setArrayValue;
+    onFilterUpdated(cb: () => unknown): void;
+}
+export default ListFilter;

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

@@ -0,0 +1,21 @@
+import type { ListFilter } from "./ListFilter";
+/**
+ * One selectable value of a filter, and the identity it is stored under.
+ *
+ * The id is content-addressed — the property plus a hash of the value — so a
+ * selection survives a reload without the values having to keep their order or
+ * their index.
+ */
+export declare class ListFilterValue<TRendered = unknown> {
+    readonly filter: ListFilter<unknown, string, unknown, TRendered>;
+    readonly value: unknown;
+    readonly id: string;
+    private constructor();
+    static create<TRendered>(filter: ListFilter<any, any, any, TRendered>, value: unknown): ListFilterValue<TRendered>;
+    equals(otherValue: ListFilterValue<TRendered>): boolean;
+    get isActive(): boolean;
+    render(): TRendered;
+    toggle(): void;
+    deactivate(): void;
+}
+export default ListFilterValue;

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

@@ -0,0 +1,23 @@
+import type { ColumnDef, Row } from "@tanstack/table-core";
+/** A calendar date, in whichever shape it reached the filter. */
+export interface ListDateParts {
+    readonly year: number;
+    readonly month: number;
+    readonly day: number;
+}
+export interface ListDateRange {
+    readonly start?: ListDateParts;
+    readonly end?: ListDateParts;
+}
+/** A range needs both ends present to be one, even if either may be unset. */
+export declare const isListDateRange: (value: unknown) => value is ListDateRange;
+/**
+ * Whether a row's date falls inside the selected range.
+ *
+ * A value that is not a date keeps its row: a filter the data cannot answer
+ * should not empty the list. That includes a string luxon cannot parse — the
+ * invalid `DateTime` compares as `NaN`, and neither end excludes it.
+ */
+export declare const dateRangeFilterFn: <T>(row: Row<T>, columnId: string, range?: ListDateRange) => boolean;
+/** Turns the column into one a date range filters. */
+export declare const applyDateRangeColumnDef: <T>(def: ColumnDef<T>) => void;

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

@@ -0,0 +1,18 @@
+import type { ItemType } from "../../lib/array";
+import type { PropertyName, PropertyValue, PropertyValueRenderMethod } from "../types";
+export type FilterMode = "all" | "some" | "one" | "dateRange";
+export type FilterMatcher<T, P, TMatcherValue> = (filterBy: NonNullable<ItemType<TMatcherValue>>, filterFrom: PropertyValue<T, P>) => boolean;
+export type FilterUpdatedCallback = (values: unknown[]) => unknown;
+export interface ListFilterShape<T, TProp extends PropertyName<T>, TMatcherValue, TRendered = unknown> {
+    property: TProp;
+    renderItem?: PropertyValueRenderMethod<TMatcherValue, TRendered>;
+    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;
+}

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

@@ -0,0 +1,10 @@
+import type { ListItemCollection } from "./ListItemCollection";
+import type { Row } from "@tanstack/table-core";
+/** One row of the list, as the views see it: an id and the data behind it. */
+export declare class ListItem<T> {
+    readonly id: string;
+    readonly data: T;
+    readonly collection: ListItemCollection<T>;
+    constructor(collection: ListItemCollection<T>, id: string, data: T);
+    static fromRow<T>(collection: ListItemCollection<T>, row: Row<T>): ListItem<T>;
+}

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

@@ -0,0 +1,14 @@
+import type { ListModelContext } from "../ListModelContext";
+import { ListItem } from "./ListItem";
+/**
+ * The items the list currently shows.
+ *
+ * Read from the table's row model on every access rather than kept: the rows
+ * are what sorting, filtering and paging produce, so a stored copy would be a
+ * second answer to the same question.
+ */
+export declare class ListItemCollection<T> {
+    readonly context: ListModelContext<T>;
+    constructor(context: ListModelContext<T>);
+    get entries(): ListItem<T>[];
+}

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

@@ -0,0 +1,44 @@
+import type { BatchLoadingState, ListData } from "./types";
+export interface ListLoaderStateOptions<T> {
+    /**
+     * Identifies an item, so the same one loaded in two batches appears once.
+     * Without it the batches are concatenated as they arrive.
+     */
+    getItemId?: (item: T) => string;
+}
+/**
+ * What a list has loaded so far, and how far each batch has got.
+ *
+ * MobX, and nothing else — no hook, no framework. A binding reads it through
+ * its own reactivity: React with `useSelector`, Vue with `watchMobxValue`. That
+ * split is the point: the batching, the deduplication and the "still loading"
+ * rules are one implementation, and only the subscription is written twice.
+ *
+ * What is _not_ here is the loading itself. Fetching a batch is
+ * `usePromise`/Suspense in React and something else in Vue, so it stays with
+ * the binding, and only its outcome is reported here.
+ */
+export declare class ListLoaderState<T> {
+    dataBatches: ListData<T>[];
+    batchLoadingStates: BatchLoadingState[];
+    metadata?: unknown;
+    isInitiallyLoading: boolean;
+    /**
+     * The last non-empty result, kept outside MobX on purpose: it exists so a
+     * reset can keep rendering the previous data instead of flashing empty, and
+     * observing it would make that very reset re-render.
+     */
+    prevDataBatches: ListData<T>[];
+    private readonly getItemId?;
+    constructor(options?: ListLoaderStateOptions<T>);
+    reset(): void;
+    setDataBatch(index: number, data: ListData<T>): void;
+    setBatchLoadingState(index: number, state: BatchLoadingState): void;
+    setMetadata(metadata?: unknown): void;
+    setIsInitiallyLoading(isInitiallyLoading: boolean): void;
+    get mergedData(): T[];
+    get isLoading(): boolean;
+    get isLoadingMore(): boolean;
+    isBatchLoaded(batchIndex: number): boolean;
+}
+export default ListLoaderState;

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

@@ -0,0 +1,69 @@
+import type { FilterMode } from "../filter/types";
+import type { ListLoaderModes } from "../pagination/types";
+import type { SearchValue } from "../search/types";
+import type { ListSorting } from "../sorting/ListSorting";
+import type { PropertyName } from "../types";
+/** One batch of list data, as a loader hands it over. */
+export type ListData<T> = readonly T[];
+/**
+ * How far one batch has got.
+ *
+ * The same four values `@mittwald/react-use-promise` uses, spelled out rather
+ * than imported: that package is React's, and this one is the half both
+ * bindings share.
+ */
+export type BatchLoadingState = "void" | "loading" | "loaded" | "error";
+/** A value per property of `T`, e.g. a direction or a filter's selection. */
+export type ListPropertyRecord<T, TValue> = Partial<Record<PropertyName<T>, TValue>>;
+interface ListDataLoaderPaginationOptions {
+    offset: number;
+    limit: number;
+}
+/**
+ * What a list asks its data source for.
+ *
+ * The consumer-facing contract of every dynamic loader, and the reason it is
+ * here rather than with a binding: a Vue app and a React app write the same
+ * loader function. Each field is filled only where the source said it does that
+ * job itself — see `ListLoaderModes`.
+ */
+export interface ListDataLoaderOptions<T> {
+    sorting?: ListPropertyRecord<T, "asc" | "desc">;
+    filtering?: ListPropertyRecord<T, {
+        mode: FilterMode;
+        values: unknown[];
+    }>;
+    searchString?: SearchValue;
+    pagination?: ListDataLoaderPaginationOptions;
+}
+export interface ListDataLoaderResult<T> {
+    data: ListData<T>;
+    itemTotalCount?: number;
+    metadata?: unknown;
+}
+export type ListAsyncDataLoader<T> = (options: ListDataLoaderOptions<T>) => Promise<ListDataLoaderResult<T>>;
+/** What building the loader options needs of a filter, and nothing more. */
+export interface QueryableFilter<T> {
+    readonly property: PropertyName<T>;
+    readonly mode: FilterMode;
+    getValue(): unknown;
+    getArrayValue(): {
+        value: unknown;
+    }[];
+}
+export interface ListDataLoaderOptionsSource<T> {
+    readonly batchSize: number;
+    readonly modes: ListLoaderModes;
+    readonly sorting: ListSorting<T>[];
+    readonly filters: QueryableFilter<T>[];
+    readonly searchString: SearchValue;
+}
+/**
+ * The query for one batch.
+ *
+ * Every branch is the same question — "does the source do this itself?" — and
+ * getting it wrong is silent: a source that paginates but is sent no pagination
+ * returns its first page forever.
+ */
+export declare const getListDataLoaderOptions: <T>(source: ListDataLoaderOptionsSource<T>, batchIndex: number) => ListDataLoaderOptions<T>;
+export {};

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

@@ -0,0 +1,32 @@
+import type { ListModelContext } from "../ListModelContext";
+import type { ListBatchesControllerShape, ListLoaderModes } from "./types";
+/**
+ * The context a batches controller needs: the table, plus who does the paging.
+ *
+ * Declared here rather than folded into `ListModelContext`, so a model that
+ * only sorts or filters is not made to carry a loader it never asks anything.
+ */
+export interface ListPaginationContext<T> extends ListModelContext<T> {
+    readonly loader: ListLoaderModes;
+}
+/**
+ * How much of the list is shown, in batches of `batchSize`.
+ *
+ * Resetting on a changed filter or search is **not** wired here: the filters
+ * and the search belong to the list that assembles them, and it is the list
+ * that calls `reset()`. Keeping the wiring out also keeps the variance trap out
+ * — a list of concrete filters is not assignable to a list of generic ones.
+ */
+export declare class ListBatchesController<T> {
+    readonly batchSize: number;
+    private readonly context;
+    constructor(context: ListPaginationContext<T>, shape?: ListBatchesControllerShape);
+    private get dataTable();
+    getBatchIndex(): number;
+    hasNextBatch(): boolean;
+    getTotalItemsCount(): number;
+    getVisibleItemsCount(): number;
+    updateItemTotalCount(value: number): void;
+    reset(): void;
+    nextBatch(): void;
+}

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

@@ -0,0 +1,17 @@
+/**
+ * Which of the table's jobs the data source does itself.
+ *
+ * A list either hands TanStack all the rows and lets it paginate, filter and
+ * sort them, or it asks a server for one page at a time. Every count and every
+ * "is there more" answer differs between the two, which is why the batches
+ * controller needs them — and why it takes only these three, not the loader
+ * that computes them.
+ */
+export interface ListLoaderModes {
+    readonly manualPagination: boolean;
+    readonly manualFiltering: boolean;
+    readonly manualSorting: boolean;
+}
+export interface ListBatchesControllerShape {
+    batchSize?: number;
+}

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

@@ -0,0 +1,27 @@
+import type { ListModelContext } from "../ListModelContext";
+import type { ListSearchShape, SearchValue } from "./types";
+import type { InitialTableState } from "@tanstack/table-core";
+/**
+ * The list's search term: where it starts, where it is kept, who to tell.
+ *
+ * The term itself lives in the table's global filter — this owns the initial
+ * value, the persistence and the notification, none of which is a framework's
+ * business. What a binding adds on top is how the field is _rendered_.
+ */
+export declare class ListSearch<T> {
+    readonly context: ListModelContext<T>;
+    private readonly onUpdateCallbacks;
+    private readonly initialValue?;
+    private readonly defaultValue?;
+    private readonly autosave;
+    constructor(context: ListModelContext<T>, shape: ListSearchShape);
+    get value(): SearchValue;
+    get isSet(): boolean;
+    private callOnUpdateCallbacks;
+    private getInitialValue;
+    updateInitialState(initialState: InitialTableState): void;
+    setValue(value: SearchValue): void;
+    clear(): void;
+    onUpdated(cb: () => unknown): void;
+}
+export default ListSearch;

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

@@ -0,0 +1,5 @@
+export type SearchValue = string | undefined;
+export interface ListSearchShape {
+    defaultValue?: string;
+    autosave?: boolean;
+}

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

@@ -0,0 +1,52 @@
+import type { ListViewModeValue } from "../viewMode/types";
+export interface ListSettingsOperationOptions {
+    autosave?: boolean;
+    manualSave?: boolean;
+}
+export interface ListSortingSetting {
+    property: string | number;
+    direction: "asc" | "desc";
+}
+export interface ListSearchSetting {
+    value?: string;
+}
+/** Which values of each filter are on, keyed by the filter's storage key. */
+export type ListActiveFiltersSetting = Partial<Record<string, string[]>>;
+export type ListSettingKey = "sorting" | "search" | "activeFilters" | "viewMode";
+/**
+ * The part of the list's persistence the shared model touches.
+ *
+ * A port, not the store: persisting is `SettingsProvider` in React — async
+ * resources, hierarchical MobX stores, Suspense-aware writes — and none of that
+ * belongs here. `ListSettingsStore` satisfies this shape as it stands.
+ *
+ * Spelled out per key rather than as one generic method over a value map: a
+ * generic whose return type indexes that map resolves to the _intersection_ of
+ * every value when TypeScript checks a real store against it, and nothing can
+ * satisfy `ListSortingSetting & ListSearchSetting`.
+ */
+export interface ListSettingsPort {
+    get(key: "activeFilters", options: ListSettingsOperationOptions): ListActiveFiltersSetting | undefined;
+    get(key: "sorting", options: ListSettingsOperationOptions): ListSortingSetting | undefined;
+    get(key: "search", options: ListSettingsOperationOptions): ListSearchSetting | undefined;
+    get(key: "viewMode", options: ListSettingsOperationOptions): ListViewModeValue | undefined;
+    store(key: "activeFilters", value: ListActiveFiltersSetting | undefined, options: ListSettingsOperationOptions): void;
+    store(key: "sorting", value: ListSortingSetting | undefined, options: ListSettingsOperationOptions): void;
+    store(key: "search", value: ListSearchSetting | undefined, options: ListSettingsOperationOptions): void;
+    store(key: "viewMode", value: ListViewModeValue | undefined, options: ListSettingsOperationOptions): void;
+}
+export interface ListSettingsDefaults {
+    filters?: {
+        autosave?: boolean;
+        manualSave?: boolean;
+    };
+    sorting?: {
+        autosave?: boolean;
+    };
+    viewMode?: {
+        autosave?: boolean;
+    };
+    search?: {
+        autosave?: boolean;
+    };
+}

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;
+}