@mittwald/flow-react-components 0.1.0-alpha.99 → 0.2.0-alpha.5

package/dist/js/types/components/List/components/Items/components/Item/components/OptionsButton/index.d.ts

@@ -0,0 +1,3 @@
+import { OptionsButton } from './OptionsButton';
+export { OptionsButton } from './OptionsButton';
+export default OptionsButton;

package/dist/js/types/components/List/components/Items/components/Item/components/SkeletonView/SkeletonView.d.ts

@@ -0,0 +1,2 @@
+import { FC } from 'react';
+export declare const SkeletonView: FC;

package/dist/js/types/components/List/components/Items/components/Item/hooks/useGridItemProps.d.ts

@@ -0,0 +1,18 @@
+import { PropsWithChildren, default as React } from 'react';
+interface P extends PropsWithChildren {
+    data: never;
+}
+export declare const useGridItemProps: (props: P) => {
+    gridItemProps: {
+        onAction: (() => void) | undefined;
+        ref?: undefined;
+    };
+    children: React.ReactNode;
+} | {
+    gridItemProps: {
+        ref: React.RefObject<HTMLDivElement | null>;
+        onAction: () => void;
+    };
+    children: React.JSX.Element;
+};
+export {};

package/dist/js/types/components/List/components/Items/components/Item/index.d.ts

@@ -0,0 +1,3 @@
+import { Item } from './Item';
+export { Item } from './Item';
+export default Item;

package/dist/js/types/components/List/components/Items/index.d.ts

@@ -0,0 +1,3 @@
+import { Items } from './Items';
+export { Items } from './Items';
+export default Items;

package/dist/js/types/components/List/components/ListSummary/ListSummary.d.ts

@@ -0,0 +1,6 @@
+import { PropsWithChildren, default as React } from 'react';
+import { FlowComponentProps } from '../../../../lib/componentFactory/flowComponent';
+export interface ListSummaryProps extends FlowComponentProps, PropsWithChildren {
+}
+export declare const ListSummary: React.FunctionComponent<ListSummaryProps & React.RefAttributes<never>>;
+export default ListSummary;

package/dist/js/types/components/List/components/ListSummary/index.d.ts

@@ -0,0 +1,3 @@
+import { ListSummary } from './ListSummary';
+export { ListSummary } from './ListSummary';
+export default ListSummary;

package/dist/js/types/components/List/components/Table/Table.d.ts

@@ -0,0 +1,2 @@
+import { FC } from 'react';
+export declare const Table: FC;

package/dist/js/types/components/List/components/Table/components/TableLoadingView.d.ts

@@ -0,0 +1,3 @@
+import { FC } from 'react';
+import { TableSupportedComponentProps } from '../../../model/table/types';
+export declare const TableLoadingView: FC<TableSupportedComponentProps>;

package/dist/js/types/components/List/components/Table/index.d.ts

@@ -0,0 +1 @@
+export * from './Table';

package/dist/js/types/components/List/hooks/useList.d.ts

@@ -0,0 +1,2 @@
+import { default as List } from '../model/List';
+export declare const useList: <T = never>() => List<T>;

package/dist/js/types/components/List/index.d.ts

@@ -0,0 +1,13 @@
+export * from './List';
+export * from './setupComponents/ListFilter';
+export * from './setupComponents/ListSearch';
+export * from './setupComponents/ListSorting';
+export * from './setupComponents/ListItem';
+export * from './setupComponents/ListLoaderAsync';
+export * from './setupComponents/ListStaticData';
+export * from './components/ListSummary';
+export * from './components/Items/components/Item/components/ListItemView';
+export * from './hooks/useList';
+export * from './typedList';
+export type { DataLoaderOptions, AsyncDataLoader, AsyncResourceFactory, DataLoaderResult, } from './model/loading/types';
+export type { RenderItemFn } from './model/item/types';

package/dist/js/types/components/List/listContext.d.ts

@@ -0,0 +1,6 @@
+import { default as List } from './model/List';
+interface ListContext {
+    list: List<never>;
+}
+export declare const listContext: import('react').Context<ListContext>;
+export {};

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

@@ -0,0 +1,47 @@
+import { ItemCollection } from './item/ItemCollection';
+import { BatchesController } from './pagination/BatchesController';
+import { Filter } from './filter/Filter';
+import { Sorting } from './sorting/Sorting';
+import { default as ReactTable } from './ReactTable';
+import { GetItemId, ItemActionFn, ListShape, ListSupportedComponentProps, ListViewMode } from './types';
+import { IncrementalLoader } from './loading/IncrementalLoader';
+import { Search } from './search/Search';
+import { ItemView } from './item/ItemView';
+import { Table } from './table/Table';
+import { default as z } from 'zod';
+export declare class List<T> {
+    readonly filters: Filter<T, never, never>[];
+    readonly itemView?: ItemView<T>;
+    readonly table?: Table<T>;
+    readonly search?: Search<T>;
+    readonly sorting: Sorting<T>[];
+    readonly items: ItemCollection<T>;
+    readonly reactTable: ReactTable<T>;
+    readonly batches: BatchesController<T>;
+    readonly loader: IncrementalLoader<T>;
+    readonly onAction?: ItemActionFn<T>;
+    readonly accordion: boolean;
+    readonly getItemId?: GetItemId<T>;
+    readonly componentProps: ListSupportedComponentProps;
+    viewMode: ListViewMode;
+    readonly setViewMode: (viewMode: ListViewMode) => void;
+    private readonly settingsStore?;
+    readonly supportsSettingsStorage: boolean;
+    readonly settingStorageKey?: string;
+    private readonly viewModeStorageKey?;
+    private readonly filterSettingsStorageKey?;
+    static readonly viewModeSettingsStorageSchema: z.ZodOptional<z.ZodEnum<["list", "table"]>>;
+    constructor(shape: ListShape<T>);
+    get isFiltered(): boolean;
+    get visibleSorting(): Sorting<T>[];
+    static useNew<T>(shape: ListShape<T>): List<T>;
+    storeFilterDefaultSettings(): void;
+    getStoredFilterDefaultSettings(): Record<string, string[]> | undefined;
+    getStoredViewModeDefaultSetting(): "table" | "list" | undefined;
+    getSorting(id: string): Sorting<T>;
+    clearSorting(): void;
+    resetFilters(): void;
+    clearFilters(): void;
+    useIsEmpty(): boolean;
+}
+export default List;

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

@@ -0,0 +1,19 @@
+import { Column, ColumnSort, Table, TableOptions } from '@tanstack/react-table';
+import { default as List } from './List';
+import { OnListChanged, PropertyName } from './types';
+import { SearchValue } from './search/types';
+import { Dispatch, SetStateAction } from 'react';
+export declare class ReactTable<T> {
+    readonly list: List<T>;
+    readonly table: Table<T>;
+    readonly sortingState: ColumnSort[];
+    readonly updateSortingState: Dispatch<SetStateAction<ColumnSort[]>>;
+    private constructor();
+    static useNew<T>(list: List<T>, onChange?: OnListChanged<T>, tableOptions?: Partial<TableOptions<T>>): ReactTable<T>;
+    private useReactTable;
+    private handleSortingStateUpdate;
+    get searchString(): SearchValue;
+    getTableColumn(property: PropertyName<T>): Column<T>;
+    private getTableColumnDefs;
+}
+export default ReactTable;

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

@@ -0,0 +1,45 @@
+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 { FilterValue } from './FilterValue';
+import { default as z } from 'zod';
+export declare class Filter<T, TProp extends PropertyName<T>, TMatchValue> {
+    static readonly settingsStorageSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>>;
+    private _values?;
+    private _valuesFromTableState?;
+    readonly list: List<T>;
+    readonly property: PropertyName<T>;
+    readonly mode: FilterMode;
+    readonly matcher: FilterMatcher<T, never, never>;
+    readonly renderItem: PropertyValueRenderMethod<TMatchValue>;
+    readonly name?: string;
+    private onFilterUpdateCallbacks;
+    private readonly defaultSelectedValues?;
+    constructor(list: List<T>, shape: FilterShape<T, TProp, TMatchValue>);
+    private getStoredSelectedIds;
+    updateInitialState(initialState: InitialTableState): void;
+    updateTableColumnDef(def: ColumnDef<T>): void;
+    private getReactTableFilterFn;
+    private checkFilterMatches;
+    protected getTableColumnFilter(): ColumnFilter | undefined;
+    private getTableColumn;
+    getValue(): unknown;
+    private getValuesFromTableState;
+    private checkIfValueIsUnknown;
+    deleteUnknownFilterValues(): void;
+    get values(): FilterValue[];
+    findValueById(id: string): FilterValue | undefined;
+    private get valuesFromTableState();
+    getArrayValue(): FilterValue[];
+    isValueActive(value: FilterValue): boolean;
+    isActive(): boolean;
+    deactivateValue(value: FilterValue): void;
+    hasChanged(): boolean;
+    private getInitialValues;
+    private getInitialFilterValues;
+    resetValues(): void;
+    clear(): void;
+    toggleValue(newValue: FilterValue): void;
+    onFilterUpdated(cb: () => unknown): void;
+}

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

@@ -0,0 +1,13 @@
+import { Filter } from './Filter';
+export declare class FilterValue {
+    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;
+}

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

@@ -0,0 +1,13 @@
+import { PropertyName, PropertyValue, PropertyValueRenderMethod } from '../types';
+import { ItemType } from '../../../../lib/types/array';
+export type FilterMode = "all" | "some" | "one";
+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>[];
+}

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

@@ -0,0 +1,9 @@
+import { ItemCollection } from './ItemCollection';
+import { Row } from '@tanstack/react-table';
+export declare class Item<T> {
+    readonly id: string;
+    readonly data: T;
+    readonly collection: ItemCollection<T>;
+    constructor(collection: ItemCollection<T>, id: string, data: T);
+    static fromRow<T>(collection: ItemCollection<T>, row: Row<T>): Item<T>;
+}

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

@@ -0,0 +1,7 @@
+import { default as List } from '../List';
+import { Item } from './Item';
+export declare class ItemCollection<T> {
+    readonly list: List<T>;
+    constructor(list: List<T>);
+    get entries(): Item<T>[];
+}

package/dist/js/types/components/List/model/item/ItemView.d.ts

@@ -0,0 +1,21 @@
+import { ReactElement, ReactNode } from 'react';
+import { RenderItemFn } from './types';
+import { default as List } from '../List';
+export interface ItemViewShape<T> {
+    textValue?: (data: T) => string;
+    href?: (data: T) => string;
+    defaultExpanded?: (data: T) => boolean;
+    renderFn?: RenderItemFn<T>;
+    fallback?: ReactElement;
+}
+export declare class ItemView<T> {
+    readonly list: List<T>;
+    readonly textValue?: (data: T) => string;
+    readonly href?: (data: T) => string;
+    readonly defaultExpanded?: (data: T) => boolean;
+    readonly fallback?: ReactElement;
+    private readonly renderFn?;
+    constructor(list: List<T>, shape?: ItemViewShape<T>);
+    render(data: T): ReactNode;
+    private static fallbackRenderItemFn;
+}

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

@@ -0,0 +1,3 @@
+import { ReactNode } from 'react';
+import { default as List } from '../List';
+export type RenderItemFn<T> = (data: T, list: List<T>) => ReactNode;

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

@@ -0,0 +1,26 @@
+import { default as List } from '../List';
+import { IncrementalLoaderShape } from './types';
+import { IncrementalLoaderState } from './IncrementalLoaderState';
+import { PropertyName } from '../types';
+export declare class IncrementalLoader<T> {
+    private readonly list;
+    private readonly dataSource;
+    readonly manualSorting: boolean;
+    readonly manualFiltering: boolean;
+    readonly manualPagination: boolean;
+    readonly loaderState: IncrementalLoaderState<T>;
+    readonly staticDataProperties: PropertyName<T>[];
+    private constructor();
+    static useNew<T>(list: List<T>, shape?: IncrementalLoaderShape<T>): IncrementalLoader<T>;
+    private initStaticDataProperties;
+    private reset;
+    useIsLoading(): boolean;
+    useIsInitiallyLoading(): boolean;
+    useData(): T[];
+    getLoaderInvocationHooks(): (() => void)[];
+    private useLoadBatch;
+    private useObserveBatchLoadingState;
+    private useObserveBatchData;
+    private getDataLoaderOptions;
+    private getBatchDataAsyncResource;
+}

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

@@ -0,0 +1,21 @@
+import { AsyncResource } from '@mittwald/react-use-promise';
+import { ListData } from './types';
+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;
+    private constructor();
+    static useNew<T>(): IncrementalLoaderState<T>;
+    reset(): void;
+    setDataBatch(index: number, data: ListData<T>): void;
+    setBatchLoadingState(index: number, state: AsyncResourceLoadingState): void;
+    get mergedData(): T[];
+    useMergedData(): T[];
+    get isLoading(): boolean;
+    useIsLoading(): boolean;
+    isBatchLoaded(batchIndex: number): boolean;
+}
+export {};

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

@@ -0,0 +1,47 @@
+import { PropertyRecord } from '../types';
+import { FilterMode } from '../filter/types';
+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;
+}
+export type AsyncDataLoader<T> = (options: DataLoaderOptions<T>) => Promise<DataLoaderResult<T>>;
+export type AsyncResourceFactory<T> = (options?: DataLoaderOptions<T>) => AsyncResource<DataLoaderResult<T>>;
+interface DynamicLoaderShape {
+    manualSorting?: boolean;
+    manualFiltering?: boolean;
+    manualPagination?: boolean;
+}
+export interface StaticDataLoaderShape<T> {
+    staticData: ListData<T>;
+}
+export type AsyncResourceFactoryDataLoaderShape<T> = {
+    asyncResourceFactory: AsyncResourceFactory<T>;
+} & DynamicLoaderShape;
+export type AsyncDataLoaderShape<T> = {
+    asyncLoader: AsyncDataLoader<T>;
+    dependencies?: DependencyList;
+} & DynamicLoaderShape;
+export type DataSource<T> = StaticDataLoaderShape<T> | AsyncResourceFactoryDataLoaderShape<T> | AsyncDataLoaderShape<T>;
+export interface IncrementalLoaderShape<T> {
+    source?: DataSource<T>;
+}
+export {};

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

@@ -0,0 +1,15 @@
+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;
+}

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

@@ -0,0 +1,18 @@
+import { default as List } from '../List';
+import { SearchShape, SearchValue } from './types';
+import { InitialTableState } from '@tanstack/react-table';
+export declare class Search<T> {
+    readonly list: List<T>;
+    readonly textFieldProps: SearchShape<T>["textFieldProps"];
+    private onUpdateCallbacks;
+    private readonly defaultValue?;
+    readonly autoSubmit?: boolean;
+    constructor(list: List<T>, searchShape: SearchShape<T>);
+    get value(): SearchValue;
+    get isSet(): boolean;
+    private callOnUpdateCallbacks;
+    updateInitialState(initialState: InitialTableState): void;
+    setValue(value: SearchValue): void;
+    clear(): void;
+    onUpdated(cb: () => unknown): void;
+}

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

@@ -0,0 +1,9 @@
+import { SearchFieldProps } from '../../../SearchField';
+type SupportedSearchFieldProps = Pick<SearchFieldProps, "className" | "autoFocus">;
+export type SearchValue = string | undefined;
+export interface SearchShape<IgnoredT> {
+    textFieldProps: SupportedSearchFieldProps;
+    defaultValue?: string;
+    autoSubmit?: boolean;
+}
+export {};

package/dist/js/types/components/List/model/sorting/Sorting.d.ts

@@ -0,0 +1,19 @@
+import { Column, ColumnDef, ColumnSort, SortDirection } from '@tanstack/react-table';
+import { default as List } from '../List';
+import { SortingDefaultMode, SortingShape } from './types';
+import { PropertyName } from '../types';
+export declare class Sorting<T> {
+    readonly list: List<T>;
+    readonly property: PropertyName<T>;
+    readonly name?: string;
+    readonly direction: SortDirection;
+    readonly defaultEnabled: SortingDefaultMode;
+    constructor(list: List<T>, shape: SortingShape<T>);
+    updateTableColumnDef(def: ColumnDef<T>): void;
+    getReactTableColumnSort(): ColumnSort;
+    isSorted(): boolean;
+    getTableColumn(): Column<T>;
+    enable(): void;
+    clear(): void;
+    get id(): string;
+}

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

@@ -0,0 +1,9 @@
+import { SortDirection } from '@tanstack/react-table';
+import { PropertyName } from '../types';
+export type SortingDefaultMode = boolean | "hidden";
+export interface SortingShape<T> {
+    property: PropertyName<T>;
+    name?: string;
+    direction?: SortDirection;
+    defaultEnabled?: SortingDefaultMode;
+}

package/dist/js/types/components/List/model/table/Table.d.ts

@@ -0,0 +1,11 @@
+import { TableShape, TableSupportedComponentProps } from './types';
+import { default as List } from '../List';
+import { TableHeader } from './TableHeader';
+import { TableBody } from './TableBody';
+export declare class Table<T> {
+    readonly list: List<T>;
+    readonly header: TableHeader<T>;
+    readonly body: TableBody<T>;
+    readonly componentProps: TableSupportedComponentProps;
+    constructor(list: List<T>, shape?: TableShape<T>);
+}

package/dist/js/types/components/List/model/table/TableBody.d.ts

@@ -0,0 +1,9 @@
+import { Table } from './Table';
+import { TableBodyShape, TableBodySupportedComponentProps } from './types';
+import { TableRow } from './TableRow';
+export declare class TableBody<T> {
+    readonly table: Table<T>;
+    readonly componentProps: TableBodySupportedComponentProps;
+    readonly row: TableRow<T>;
+    constructor(table: Table<T>, shape?: TableBodyShape<T>);
+}

package/dist/js/types/components/List/model/table/TableCell.d.ts

@@ -0,0 +1,9 @@
+import { TableCellShape, TableCellSupportedComponentProps } from './types';
+import { TableRow } from './TableRow';
+import { RenderItemFn } from '../..';
+export declare class TableCell<T> {
+    readonly row: TableRow<T>;
+    readonly renderFn?: RenderItemFn<T>;
+    readonly componentProps: TableCellSupportedComponentProps;
+    constructor(row: TableRow<T>, shape?: TableCellShape<T>);
+}

package/dist/js/types/components/List/model/table/TableColumn.d.ts

@@ -0,0 +1,7 @@
+import { TableColumnShape, TableColumnSupportedComponentProps } from './types';
+import { TableHeader } from './TableHeader';
+export declare class TableColumn<T> {
+    readonly tableHeader: TableHeader<T>;
+    readonly componentProps: TableColumnSupportedComponentProps;
+    constructor(tableHeader: TableHeader<T>, shape?: TableColumnShape);
+}

package/dist/js/types/components/List/model/table/TableHeader.d.ts

@@ -0,0 +1,9 @@
+import { Table } from './Table';
+import { TableHeaderShape, TableHeaderSupportedComponentProps } from './types';
+import { TableColumn } from './TableColumn';
+export declare class TableHeader<T> {
+    readonly table: Table<T>;
+    readonly componentProps: TableHeaderSupportedComponentProps;
+    readonly columns: TableColumn<T>[];
+    constructor(table: Table<T>, shape?: TableHeaderShape);
+}

package/dist/js/types/components/List/model/table/TableRow.d.ts

@@ -0,0 +1,9 @@
+import { TableRowShape, TableRowSupportedComponentProps } from './types';
+import { TableCell } from './TableCell';
+import { TableBody } from './TableBody';
+export declare class TableRow<T> {
+    readonly tableBody: TableBody<T>;
+    readonly cells: TableCell<T>[];
+    readonly componentProps: TableRowSupportedComponentProps;
+    constructor(tableBody: TableBody<T>, shape?: TableRowShape<T>);
+}

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

@@ -0,0 +1,32 @@
+import { PropsWithChildren } from 'react';
+import { TableBodyProps, TableCellProps, TableColumnProps, TableHeaderProps, TableProps, TableRowProps } from '../../../Table';
+import { RenderItemFn } from '../..';
+/** Cell */
+export type TableCellSupportedComponentProps = Omit<TableCellProps, "children">;
+export interface TableCellShape<T> extends TableCellSupportedComponentProps {
+    renderFn?: RenderItemFn<T>;
+}
+/** Row */
+export type TableRowSupportedComponentProps = Omit<TableRowProps, "onAction" | "children">;
+export interface TableRowShape<T> extends TableRowSupportedComponentProps, PropsWithChildren {
+    cells?: TableCellShape<T>[];
+}
+/** Column */
+export type TableColumnSupportedComponentProps = TableColumnProps;
+export type TableColumnShape = TableColumnSupportedComponentProps;
+/** Header */
+export type TableHeaderSupportedComponentProps = Omit<TableHeaderProps, "columns">;
+export interface TableHeaderShape extends TableHeaderSupportedComponentProps {
+    columns?: TableColumnShape[];
+}
+/** Body */
+export type TableBodySupportedComponentProps = TableBodyProps;
+export interface TableBodyShape<T> extends TableBodySupportedComponentProps {
+    row?: TableRowShape<T>;
+}
+/** Table */
+export type TableSupportedComponentProps = TableProps;
+export interface TableShape<T> extends TableSupportedComponentProps {
+    header?: TableHeaderShape;
+    body?: TableBodyShape<T>;
+}

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

@@ -0,0 +1,42 @@
+import { DeepKeys, DeepValue } from '@tanstack/react-table';
+import { SortingShape } from './sorting/types';
+import { BatchesControllerShape } from './pagination/types';
+import { FilterShape } from './filter/types';
+import { IncrementalLoaderShape } from './loading/types';
+import { SearchShape } from './search/types';
+import { ItemViewShape } from './item/ItemView';
+import { ReactNode } from 'react';
+import { ItemType } from '../../../lib/types/array';
+import { default as List } from './List';
+import { TableShape } from './table/types';
+import { MultipleSelection, SelectionBehavior } from '@react-types/shared';
+export declare const customPropertyPrefix: "$";
+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>;
+export type PropertyValueRenderMethod<TMatcherValue> = (prop: NonNullable<ItemType<TMatcherValue>>) => ReactNode;
+export type OnListChanged<T> = (list: List<T>) => void;
+export interface ListSupportedComponentProps extends MultipleSelection {
+    "aria-labelledby"?: string;
+    "aria-label"?: string;
+    selectionBehavior?: SelectionBehavior;
+}
+export interface ListShape<T> extends ListSupportedComponentProps {
+    settingStorageKey?: string;
+    loader?: IncrementalLoaderShape<T>;
+    filters?: FilterShape<T, never, never>[];
+    itemView?: ItemViewShape<T>;
+    search?: SearchShape<T>;
+    sorting?: SortingShape<T>[];
+    batchesController?: BatchesControllerShape;
+    table?: TableShape<T>;
+    onAction?: ItemActionFn<T>;
+    accordion?: boolean;
+    getItemId?: GetItemId<T>;
+    onChange?: OnListChanged<T>;
+    defaultViewMode?: ListViewMode;
+}
+export type PropertyRecord<T, TValue> = Partial<Record<PropertyName<T>, TValue>>;
+export type ListViewMode = "table" | "list";
+export type ItemActionFn<T> = (data: T) => void;
+export type GetItemId<T> = (data: T) => string;

package/dist/js/types/components/List/setupComponents/ListFilter.d.ts

@@ -0,0 +1,9 @@
+import { FilterShape } from '../model/filter/types';
+import { ReactNode } from 'react';
+import { PropertyName, PropertyValue, PropertyValueRenderMethod } from '../model/types';
+type Props<T, TProp extends PropertyName<T>, TMatcherValue> = Omit<FilterShape<T, TProp, TMatcherValue>, "type" | "renderItem"> & {
+    children?: PropertyValueRenderMethod<TMatcherValue>;
+};
+export declare const ListFilter: <T, const TProp extends PropertyName<T> = PropertyName<T>, TMatcherValue = PropertyValue<T, TProp>>(ignoredProps: Props<T, TProp, TMatcherValue>) => null;
+export declare const TypedListFilter: <T>() => <const TProp extends PropertyName<T>, TMatcherValue = PropertyValue<T, TProp>>(props: Props<T, TProp, TMatcherValue>) => ReactNode;
+export {};

package/dist/js/types/components/List/setupComponents/ListItem.d.ts

@@ -0,0 +1,9 @@
+import { ComponentType } from 'react';
+import { RenderItemFn } from '../model/item/types';
+import { ItemViewShape } from '../model/item/ItemView';
+type Props<T> = Omit<ItemViewShape<T>, "renderFn"> & {
+    children: RenderItemFn<T>;
+};
+export declare const ListItem: <T>(ignoredProps: Props<T>) => null;
+export declare const TypedListItem: <T>() => ComponentType<Props<T>>;
+export {};

package/dist/js/types/components/List/setupComponents/ListLoaderAsync.d.ts

@@ -0,0 +1,8 @@
+import { AsyncDataLoaderShape } from '../model/loading/types';
+import { ComponentType } from 'react';
+type Props<T> = Omit<AsyncDataLoaderShape<T>, "asyncLoader"> & {
+    children: AsyncDataLoaderShape<T>["asyncLoader"];
+};
+export declare const ListLoaderAsync: <T>(ignoredProps: Props<T>) => null;
+export declare const TypedListLoaderAsync: <T>() => ComponentType<Props<T>>;
+export {};