@mittwald/flow-react-components 0.1.0-alpha.21 → 0.1.0-alpha.211

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

@@ -0,0 +1,35 @@
+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 { 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';
+
+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 componentProps: ListSupportedComponentProps;
+    viewMode: ListViewMode;
+    constructor(shape: ListShape<T>);
+    static useNew<T>(shape: ListShape<T>): List<T>;
+    get isFiltered(): boolean;
+    get visibleSorting(): Sorting<T>[];
+    getSorting(id: string): Sorting<T>;
+    clearSorting(): void;
+    clearFilters(): void;
+    useIsEmpty(): boolean;
+    setViewMode(to: ListViewMode): void;
+}
+export default List;

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

@@ -0,0 +1,20 @@
+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/types/components/List/model/filter/Filter.d.ts

@@ -0,0 +1,36 @@
+import { ColumnDef, ColumnFilter } 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';
+
+export declare class Filter<T, TProp extends PropertyName<T>, TMatchValue> {
+    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;
+    constructor(list: List<T>, shape: FilterShape<T, TProp, TMatchValue>);
+    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[];
+    private get valuesFromTableState();
+    getArrayValue(): FilterValue[];
+    isValueActive(value: FilterValue): boolean;
+    isActive(): boolean;
+    deactivateValue(value: FilterValue): void;
+    clearValues(): void;
+    toggleValue(newValue: FilterValue): void;
+    onFilterUpdated(cb: () => unknown): void;
+}

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

@@ -0,0 +1,13 @@
+import { Filter } from './Filter';
+
+export declare class FilterValue {
+    private readonly filter;
+    readonly value: unknown;
+    constructor(filter: Filter<any, any, any>, value: unknown);
+    equals(otherValue: FilterValue): boolean;
+    get id(): string;
+    get isActive(): boolean;
+    render(): import('react').ReactNode;
+    toggle(): void;
+    deactivate(): void;
+}

package/dist/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?: TMatcherValue[];
+    name?: string;
+}

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

@@ -0,0 +1,10 @@
+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/types/components/List/model/item/ItemCollection.d.ts

@@ -0,0 +1,8 @@
+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/types/components/List/model/item/ItemView.d.ts

@@ -0,0 +1,20 @@
+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;
+    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 fallback?: ReactElement;
+    private readonly renderFn?;
+    constructor(list: List<T>, shape?: ItemViewShape<T>);
+    render(data: T): ReactNode;
+    private static fallbackRenderItemFn;
+}

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

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

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

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

package/dist/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;
+}
+export {};

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

@@ -0,0 +1,48 @@
+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>>;
+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/types/components/List/model/pagination/BatchesController.d.ts

@@ -0,0 +1,16 @@
+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/types/components/List/model/pagination/types.d.ts

@@ -0,0 +1,3 @@
+export interface BatchesControllerShape {
+    batchSize?: number;
+}

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

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

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

@@ -0,0 +1,15 @@
+import { ComponentType } from 'react';
+import { SearchFieldProps } from '../../../SearchField';
+
+type SupportedSearchFieldProps = Pick<SearchFieldProps, "className" | "autoFocus">;
+interface SearchFieldRenderProps extends SupportedSearchFieldProps {
+    onChange: (value: SearchValue) => unknown;
+    value: SearchValue;
+}
+export type SearchFieldRenderComponent = ComponentType<SearchFieldRenderProps>;
+export type SearchValue = string | undefined;
+export interface SearchShape<IgnoredT> {
+    render?: SearchFieldRenderComponent;
+    textFieldProps: SupportedSearchFieldProps;
+}
+export {};

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

@@ -0,0 +1,20 @@
+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/types/components/List/model/sorting/types.d.ts

@@ -0,0 +1,10 @@
+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/types/components/List/model/table/Table.d.ts

@@ -0,0 +1,12 @@
+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/types/components/List/model/table/TableBody.d.ts

@@ -0,0 +1,10 @@
+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/types/components/List/model/table/TableCell.d.ts

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

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

@@ -0,0 +1,8 @@
+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/types/components/List/model/table/TableHeader.d.ts

@@ -0,0 +1,10 @@
+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/types/components/List/model/table/TableRow.d.ts

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

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

@@ -0,0 +1,35 @@
+import { PropsWithChildren, ReactNode } from 'react';
+import { TableBodyProps, TableCellProps, TableColumnProps, TableHeaderProps, TableProps, TableRowProps } from '../../../Table';
+import { ItemActionFn } from '../types';
+
+/** Cell */
+export type RenderCellFn<T> = (data: T) => ReactNode;
+export type TableCellSupportedComponentProps = Omit<TableCellProps, "children">;
+export interface TableCellShape<T> extends TableCellSupportedComponentProps {
+    renderFn?: RenderCellFn<T>;
+}
+/** Row */
+export type TableRowSupportedComponentProps = Omit<TableRowProps, "onAction" | "children">;
+export interface TableRowShape<T> extends TableRowSupportedComponentProps, PropsWithChildren {
+    cells?: TableCellShape<T>[];
+    onAction?: ItemActionFn<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/types/components/List/model/types.d.ts

@@ -0,0 +1,36 @@
+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';
+
+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 {
+    "aria-labelledby"?: string;
+    "aria-label"?: string;
+}
+export interface ListShape<T> extends ListSupportedComponentProps {
+    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>;
+    onChange?: OnListChanged<T>;
+}
+export type PropertyRecord<T, TValue> = Partial<Record<PropertyName<T>, TValue>>;
+export type ListViewMode = "table" | "list";
+export type ItemActionFn<T> = (data: T) => void;

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

@@ -0,0 +1,10 @@
+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/types/components/List/setupComponents/ListItem.d.ts

@@ -0,0 +1,10 @@
+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/types/components/List/setupComponents/ListLoaderAsync.d.ts

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

package/dist/types/components/List/setupComponents/ListLoaderAsyncResource.d.ts

@@ -0,0 +1,9 @@
+import { AsyncResourceFactoryDataLoaderShape } from '../model/loading/types';
+import { ComponentType } from 'react';
+
+type Props<T> = Omit<AsyncResourceFactoryDataLoaderShape<T>, "asyncResourceFactory"> & {
+    children: AsyncResourceFactoryDataLoaderShape<T>["asyncResourceFactory"];
+};
+export declare const ListLoaderAsyncResource: <T>(ignoredProps: Props<T>) => null;
+export declare const TypedListLoaderAsyncResource: <T>() => ComponentType<Props<T>>;
+export {};

package/dist/types/components/List/setupComponents/ListSearch.d.ts

@@ -0,0 +1,9 @@
+import { SearchFieldRenderComponent, SearchShape } from '../model/search/types';
+import { ComponentType } from 'react';
+
+type Props<T> = Omit<SearchShape<T>, "render" | "textFieldProps"> & {
+    children?: SearchFieldRenderComponent;
+} & SearchShape<T>["textFieldProps"];
+export declare function ListSearch<T = never>(ignoredProps: Props<T>): null;
+export declare const TypedListSearch: <T>() => ComponentType<Props<T>>;
+export {};

package/dist/types/components/List/setupComponents/ListSorting.d.ts

@@ -0,0 +1,7 @@
+import { SortingShape } from '../model/sorting/types';
+import { ComponentType } from 'react';
+
+type Props<T> = SortingShape<T>;
+export declare const ListSorting: <T>(ignoredProps: Props<T>) => null;
+export declare const TypedListSorting: <T>() => ComponentType<Props<T>>;
+export {};

package/dist/types/components/List/setupComponents/ListStaticData.d.ts

@@ -0,0 +1,8 @@
+import { ComponentType } from 'react';
+
+type Props<T> = {} & {
+    data: readonly T[];
+};
+export declare const ListStaticData: <T>(ignoredProps: Props<T>) => null;
+export declare const TypedListStaticData: <T>() => ComponentType<Props<T>>;
+export {};

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

@@ -0,0 +1,7 @@
+import { ComponentType } from 'react';
+import { TableShape } from '../model/table/types';
+
+type Props<T> = Omit<TableShape<T>, "header" | "body">;
+export declare const Table: <T>(ignoredProps: Props<T>) => null;
+export declare const TypedTable: <T>() => ComponentType<Props<T>>;
+export {};

package/dist/types/components/List/setupComponents/TableBody.d.ts

@@ -0,0 +1,7 @@
+import { ComponentType } from 'react';
+import { TableBodyShape } from '../model/table/types';
+
+type Props<IgnoredT> = TableBodyShape<IgnoredT>;
+export declare const TableBody: <T>(ignoredProps: Props<T>) => null;
+export declare const TypedTableBody: <T>() => ComponentType<Props<T>>;
+export {};

package/dist/types/components/List/setupComponents/TableCell.d.ts

@@ -0,0 +1,9 @@
+import { ComponentType } from 'react';
+import { RenderCellFn, TableCellShape } from '../model/table/types';
+
+type Props<T> = Omit<TableCellShape<T>, "renderFn"> & {
+    children: RenderCellFn<T>;
+};
+export declare const TableCell: <T>(ignoredProps: Props<T>) => null;
+export declare const TypedTableCell: <T>() => ComponentType<Props<T>>;
+export {};

package/dist/types/components/List/setupComponents/TableColumn.d.ts

@@ -0,0 +1,7 @@
+import { ComponentType } from 'react';
+import { TableColumnShape } from '../model/table/types';
+
+type Props<IgnoredT> = TableColumnShape;
+export declare const TableColumn: <T>(ignoredProps: Props<T>) => null;
+export declare const TypedTableColumn: <T>() => ComponentType<Props<T>>;
+export {};

package/dist/types/components/List/setupComponents/TableHeader.d.ts

@@ -0,0 +1,7 @@
+import { ComponentType } from 'react';
+import { TableHeaderShape } from '../model/table/types';
+
+type Props<IgnoredT> = TableHeaderShape;
+export declare const TableHeader: <T>(ignoredProps: Props<T>) => null;
+export declare const TypedTableHeader: <T>() => ComponentType<Props<T>>;
+export {};

package/dist/types/components/List/setupComponents/TableRow.d.ts

@@ -0,0 +1,7 @@
+import { ComponentType } from 'react';
+import { TableRowShape } from '../model/table/types';
+
+type Props<T> = Omit<TableRowShape<T>, "cells">;
+export declare const TableRow: <T>(ignoredProps: Props<T>) => null;
+export declare const TypedTableRow: <T>() => ComponentType<Props<T>>;
+export {};

package/dist/types/components/List/stories/Default.stories.d.ts

@@ -0,0 +1,7 @@
+import { Meta, StoryObj } from '@storybook/react';
+import { default as List } from '../List';
+
+declare const meta: Meta<typeof List>;
+export default meta;
+type Story = StoryObj<typeof List>;
+export declare const Default: Story;