1 |
|
2 |
|
3 |
|
4 |
|
5 |
|
6 |
|
7 |
|
8 |
|
9 |
|
10 |
|
11 |
|
12 |
|
13 |
|
14 |
|
15 |
|
16 |
|
17 |
|
18 |
|
19 | import {
|
20 | ChangeEvent,
|
21 | ComponentType,
|
22 | CSSProperties,
|
23 | DependencyList,
|
24 | EffectCallback,
|
25 | MouseEvent,
|
26 | ReactElement,
|
27 | ReactFragment,
|
28 | ReactNode,
|
29 | } from 'react';
|
30 |
|
31 | export {};
|
32 |
|
33 |
|
34 |
|
35 |
|
36 |
|
37 |
|
38 |
|
39 |
|
40 |
|
41 |
|
42 |
|
43 | export interface TableOptions<D extends object> extends UseTableOptions<D> {}
|
44 |
|
45 | export interface TableInstance<D extends object = {}>
|
46 | extends Omit<TableOptions<D>, 'columns' | 'pageCount'>,
|
47 | UseTableInstanceProps<D> {}
|
48 |
|
49 | export interface TableState<D extends object = {}> {
|
50 | hiddenColumns?: Array<IdType<D>> | undefined;
|
51 | }
|
52 |
|
53 | export interface Hooks<D extends object = {}> extends UseTableHooks<D> {}
|
54 |
|
55 | export interface Cell<D extends object = {}, V = any> extends UseTableCellProps<D, V> {}
|
56 |
|
57 | export interface ColumnInterface<D extends object = {}> extends UseTableColumnOptions<D> {}
|
58 |
|
59 | export interface ColumnInterfaceBasedOnValue<D extends object = {}, V = any> {
|
60 | Cell?: Renderer<CellProps<D, V>> | undefined;
|
61 | }
|
62 |
|
63 | export interface ColumnGroupInterface<D extends object> {
|
64 | columns: Array<Column<D>>;
|
65 | }
|
66 |
|
67 | export type ColumnGroup<D extends object = {}> =
|
68 | & ColumnInterface<D>
|
69 | & ColumnGroupInterface<D>
|
70 | & (
|
71 | | { Header: string; }
|
72 | | ({ id: IdType<D>; } & {
|
73 | Header: Renderer<HeaderProps<D>>;
|
74 | })
|
75 | )
|
76 |
|
77 | & { accessor?: Accessor<D> | undefined; };
|
78 |
|
79 | type ValueOf<T> = T[keyof T];
|
80 |
|
81 |
|
82 | export type ColumnWithStrictAccessor<D extends object = {}> =
|
83 | & ColumnInterface<D>
|
84 | & ValueOf<{
|
85 | [K in keyof D]: {
|
86 | accessor: K;
|
87 | } & ColumnInterfaceBasedOnValue<D, D[K]>;
|
88 | }>;
|
89 |
|
90 | export type ColumnWithLooseAccessor<D extends object = {}> =
|
91 | & ColumnInterface<D>
|
92 | & ColumnInterfaceBasedOnValue<D>
|
93 | & (
|
94 | | { Header: string }
|
95 | | { id: IdType<D> }
|
96 | | { accessor: keyof D extends never ? IdType<D> : never }
|
97 | )
|
98 | & { accessor?: (keyof D extends never ? IdType<D> | Accessor<D> : Accessor<D>) | undefined; };
|
99 |
|
100 | export type Column<D extends object = {}> =
|
101 | | ColumnGroup<D>
|
102 | | ColumnWithLooseAccessor<D>
|
103 | | ColumnWithStrictAccessor<D>;
|
104 |
|
105 | export interface ColumnInstance<D extends object = {}>
|
106 | extends Omit<ColumnInterface<D>, 'id'>,
|
107 | ColumnInterfaceBasedOnValue<D>,
|
108 | UseTableColumnProps<D> {}
|
109 |
|
110 | export interface HeaderGroup<D extends object = {}> extends ColumnInstance<D>, UseTableHeaderGroupProps<D> {}
|
111 |
|
112 | export interface Row<D extends object = {}> extends UseTableRowProps<D> {}
|
113 |
|
114 | export interface TableCommonProps {
|
115 | style?: CSSProperties | undefined;
|
116 | className?: string | undefined;
|
117 | role?: string | undefined;
|
118 | }
|
119 |
|
120 | export interface TableProps extends TableCommonProps {}
|
121 |
|
122 | export interface TableBodyProps extends TableCommonProps {}
|
123 |
|
124 | export interface TableKeyedProps extends TableCommonProps {
|
125 | key: React.Key;
|
126 | }
|
127 |
|
128 | export interface TableHeaderGroupProps extends TableKeyedProps {}
|
129 |
|
130 | export interface TableFooterGroupProps extends TableKeyedProps {}
|
131 |
|
132 | export interface TableHeaderProps extends TableKeyedProps {}
|
133 |
|
134 | export interface TableFooterProps extends TableKeyedProps {}
|
135 |
|
136 | export interface TableRowProps extends TableKeyedProps {}
|
137 |
|
138 | export interface TableCellProps extends TableKeyedProps {}
|
139 |
|
140 | export interface TableToggleCommonProps extends TableCommonProps {
|
141 | onChange?: ((e: ChangeEvent) => void) | undefined;
|
142 | checked?: boolean | undefined;
|
143 | title?: string | undefined;
|
144 | indeterminate?: boolean | undefined;
|
145 | }
|
146 |
|
147 | export interface MetaBase<D extends object> {
|
148 | instance: TableInstance<D>;
|
149 | userProps: any;
|
150 | }
|
151 |
|
152 | // inspired by ExtendState in https://github.com/reduxjs/redux/blob/master/src/types/store.ts
|
153 | export type Meta<D extends object, Extension = never, M = MetaBase<D>> = [Extension] extends [never]
|
154 | ? M
|
155 | : M & Extension;
|
156 |
|
157 | //#region useTable
|
158 | export function useTable<D extends object = {}>(
|
159 | options: TableOptions<D>,
|
160 | ...plugins: Array<PluginHook<D>>
|
161 | ): TableInstance<D>;
|
162 |
|
163 | /**
|
164 | * NOTE: To use custom options, use "Interface Merging" to add the custom options
|
165 | */
|
166 | export type UseTableOptions<D extends object> = {
|
167 | columns: ReadonlyArray<Column<D>>;
|
168 | data: readonly D[];
|
169 | } & Partial<{
|
170 | initialState: Partial<TableState<D>>;
|
171 | stateReducer: (newState: TableState<D>, action: ActionType, previousState: TableState<D>, instance?: TableInstance<D>) => TableState<D>;
|
172 | useControlledState: (state: TableState<D>, meta: Meta<D>) => TableState<D>;
|
173 | defaultColumn: Partial<Column<D>>;
|
174 | getSubRows: (originalRow: D, relativeIndex: number) => D[];
|
175 | getRowId: (originalRow: D, relativeIndex: number, parent?: Row<D>) => string;
|
176 | autoResetHiddenColumns: boolean;
|
177 | }>;
|
178 |
|
179 | export type PropGetter<D extends object, Props, T extends object = never, P = Partial<Props>> =
|
180 | | ((props: P, meta: Meta<D, T>) => P | P[])
|
181 | | P
|
182 | | P[];
|
183 |
|
184 | export type TablePropGetter<D extends object> = PropGetter<D, TableProps>;
|
185 |
|
186 | export type TableBodyPropGetter<D extends object> = PropGetter<D, TableBodyProps>;
|
187 |
|
188 | export type HeaderPropGetter<D extends object> = PropGetter<D, TableHeaderProps, { column: HeaderGroup<D> }>;
|
189 |
|
190 | export type FooterGroupPropGetter<D extends object> = PropGetter<D, TableFooterGroupProps, { column: HeaderGroup<D> }>;
|
191 |
|
192 | export type HeaderGroupPropGetter<D extends object> = PropGetter<D, TableHeaderGroupProps, { column: HeaderGroup<D> }>;
|
193 |
|
194 | export type FooterPropGetter<D extends object> = PropGetter<D, TableFooterProps, { column: HeaderGroup<D> }>;
|
195 |
|
196 | export type RowPropGetter<D extends object> = PropGetter<D, TableRowProps, { row: Row<D> }>;
|
197 |
|
198 | export type CellPropGetter<D extends object> = PropGetter<D, TableCellProps, { cell: Cell<D> }>;
|
199 |
|
200 | export interface ReducerTableState<D extends object> extends TableState<D>, Record<string, any> {}
|
201 |
|
202 | export interface UseTableHooks<D extends object> extends Record<string, any> {
|
203 | useOptions: Array<(options: TableOptions<D>, args: TableOptions<D>) => TableOptions<D>>;
|
204 | stateReducers: Array<
|
205 | (
|
206 | newState: TableState<D>,
|
207 | action: ActionType,
|
208 | previousState?: TableState<D>,
|
209 | instance?: TableInstance<D>,
|
210 | ) => ReducerTableState<D> | undefined
|
211 | >;
|
212 | columns: Array<(columns: Array<Column<D>>, meta: Meta<D>) => Array<Column<D>>>;
|
213 | columnsDeps: Array<(deps: any[], meta: Meta<D>) => any[]>;
|
214 | allColumns: Array<(allColumns: Array<ColumnInstance<D>>, meta: Meta<D>) => Array<Column<D>>>;
|
215 | allColumnsDeps: Array<(deps: any[], meta: Meta<D>) => any[]>;
|
216 | visibleColumns: Array<(allColumns: Array<ColumnInstance<D>>, meta: Meta<D>) => Array<Column<D>>>;
|
217 | visibleColumnsDeps: Array<(deps: any[], meta: Meta<D>) => any[]>;
|
218 | headerGroups: Array<(allColumns: Array<HeaderGroup<D>>, meta: Meta<D>) => Array<HeaderGroup<D>>>;
|
219 | headerGroupsDeps: Array<(deps: any[], meta: Meta<D>) => any[]>;
|
220 | useInstanceBeforeDimensions: Array<(instance: TableInstance<D>) => void>;
|
221 | useInstance: Array<(instance: TableInstance<D>) => void>;
|
222 | prepareRow: Array<(row: Row<D>, meta: Meta<D>) => void>;
|
223 | useControlledState: Array<(state: TableState<D>, meta: Meta<D>) => TableState<D>>;
|
224 |
|
225 | getTableProps: Array<TablePropGetter<D>>;
|
226 | getTableBodyProps: Array<TableBodyPropGetter<D>>;
|
227 | getHeaderGroupProps: Array<HeaderGroupPropGetter<D>>;
|
228 | getFooterGroupProps: Array<FooterGroupPropGetter<D>>;
|
229 | getHeaderProps: Array<HeaderPropGetter<D>>;
|
230 | getFooterProps: Array<FooterPropGetter<D>>;
|
231 | getRowProps: Array<RowPropGetter<D>>;
|
232 | getCellProps: Array<CellPropGetter<D>>;
|
233 | useFinalInstance: Array<(instance: TableInstance<D>) => void>;
|
234 | }
|
235 |
|
236 | export interface UseTableColumnOptions<D extends object> {
|
237 | id?: IdType<D> | undefined;
|
238 | Header?: Renderer<HeaderProps<D>> | undefined;
|
239 | Footer?: Renderer<FooterProps<D>> | undefined;
|
240 | width?: number | string | undefined;
|
241 | minWidth?: number | undefined;
|
242 | maxWidth?: number | undefined;
|
243 | }
|
244 |
|
245 | type UpdateHiddenColumns<D extends object> = (oldHidden: Array<IdType<D>>) => Array<IdType<D>>;
|
246 |
|
247 | export interface TableToggleHideAllColumnProps extends TableToggleCommonProps {}
|
248 |
|
249 | export interface UseTableInstanceProps<D extends object> {
|
250 | state: TableState<D>;
|
251 | plugins: Array<PluginHook<D>>;
|
252 | dispatch: TableDispatch;
|
253 | columns: Array<ColumnInstance<D>>;
|
254 | allColumns: Array<ColumnInstance<D>>;
|
255 | visibleColumns: Array<ColumnInstance<D>>;
|
256 | headerGroups: Array<HeaderGroup<D>>;
|
257 | footerGroups: Array<HeaderGroup<D>>;
|
258 | headers: Array<ColumnInstance<D>>;
|
259 | flatHeaders: Array<ColumnInstance<D>>;
|
260 | rows: Array<Row<D>>;
|
261 | rowsById: Record<string, Row<D>>;
|
262 | getTableProps: (propGetter?: TablePropGetter<D>) => TableProps;
|
263 | getTableBodyProps: (propGetter?: TableBodyPropGetter<D>) => TableBodyProps;
|
264 | prepareRow: (row: Row<D>) => void;
|
265 | flatRows: Array<Row<D>>;
|
266 | totalColumnsWidth: number;
|
267 | allColumnsHidden: boolean;
|
268 | toggleHideColumn: (columnId: IdType<D>, value?: boolean) => void;
|
269 | setHiddenColumns: (param: Array<IdType<D>> | UpdateHiddenColumns<D>) => void;
|
270 | toggleHideAllColumns: (value?: boolean) => void;
|
271 | getToggleHideAllColumnsProps: (props?: Partial<TableToggleHideAllColumnProps>) => TableToggleHideAllColumnProps;
|
272 | getHooks: () => Hooks<D>;
|
273 | }
|
274 |
|
275 | export interface UseTableHeaderGroupProps<D extends object> {
|
276 | headers: Array<HeaderGroup<D>>;
|
277 | getHeaderGroupProps: (propGetter?: HeaderGroupPropGetter<D>) => TableHeaderProps;
|
278 | getFooterGroupProps: (propGetter?: FooterGroupPropGetter<D>) => TableFooterProps;
|
279 | totalHeaderCount: number;
|
280 | }
|
281 |
|
282 | export interface UseTableColumnProps<D extends object> {
|
283 | id: IdType<D>;
|
284 | columns?: Array<ColumnInstance<D>> | undefined;
|
285 | isVisible: boolean;
|
286 | render: (type: 'Header' | 'Footer' | string, props?: object) => ReactNode;
|
287 | totalLeft: number;
|
288 | totalWidth: number;
|
289 | getHeaderProps: (propGetter?: HeaderPropGetter<D>) => TableHeaderProps;
|
290 | getFooterProps: (propGetter?: FooterPropGetter<D>) => TableFooterProps;
|
291 | toggleHidden: (value?: boolean) => void;
|
292 | parent?: ColumnInstance<D> | undefined;
|
293 | getToggleHiddenProps: (userProps?: any) => any;
|
294 | depth: number;
|
295 | placeholderOf?: ColumnInstance | undefined;
|
296 | }
|
297 |
|
298 | export interface UseTableRowProps<D extends object> {
|
299 | cells: Array<Cell<D>>;
|
300 | allCells: Array<Cell<D>>;
|
301 | values: Record<IdType<D>, CellValue>;
|
302 | getRowProps: (propGetter?: RowPropGetter<D>) => TableRowProps;
|
303 | index: number;
|
304 | original: D;
|
305 | id: string;
|
306 | subRows: Array<Row<D>>;
|
307 | }
|
308 |
|
309 | export interface UseTableCellProps<D extends object, V = any> {
|
310 | column: ColumnInstance<D>;
|
311 | row: Row<D>;
|
312 | value: CellValue<V>;
|
313 | getCellProps: (propGetter?: CellPropGetter<D>) => TableCellProps;
|
314 | render: (type: 'Cell' | string, userProps?: object) => ReactNode;
|
315 | }
|
316 |
|
317 | export type HeaderProps<D extends object> = TableInstance<D> & {
|
318 | column: ColumnInstance<D>;
|
319 | };
|
320 |
|
321 | export type FooterProps<D extends object> = TableInstance<D> & {
|
322 | column: ColumnInstance<D>;
|
323 | };
|
324 |
|
325 | export type CellProps<D extends object, V = any> = TableInstance<D> & {
|
326 | column: ColumnInstance<D>;
|
327 | row: Row<D>;
|
328 | cell: Cell<D, V>;
|
329 | value: CellValue<V>;
|
330 | };
|
331 |
|
332 | export type Accessor<D extends object> = (
|
333 | originalRow: D,
|
334 | index: number,
|
335 | sub: {
|
336 | subRows: D[];
|
337 | depth: number;
|
338 | data: D[];
|
339 | },
|
340 | ) => CellValue;
|
341 |
|
342 |
|
343 |
|
344 |
|
345 |
|
346 |
|
347 | export function useAbsoluteLayout<D extends object = {}>(hooks: Hooks<D>): void;
|
348 |
|
349 | export namespace useAbsoluteLayout {
|
350 | const pluginName = 'useAbsoluteLayout';
|
351 | }
|
352 |
|
353 |
|
354 |
|
355 | export function useBlockLayout<D extends object = {}>(hooks: Hooks<D>): void;
|
356 |
|
357 | export namespace useBlockLayout {
|
358 | const pluginName = 'useBlockLayout';
|
359 | }
|
360 |
|
361 |
|
362 |
|
363 | export function useColumnOrder<D extends object = {}>(hooks: Hooks<D>): void;
|
364 |
|
365 | export namespace useColumnOrder {
|
366 | const pluginName = 'useColumnOrder';
|
367 | }
|
368 |
|
369 | export interface UseColumnOrderState<D extends object> {
|
370 | columnOrder: Array<IdType<D>>;
|
371 | }
|
372 |
|
373 | export interface UseColumnOrderInstanceProps<D extends object> {
|
374 | setColumnOrder: (updater: ((columnOrder: Array<IdType<D>>) => Array<IdType<D>>) | Array<IdType<D>>) => void;
|
375 | }
|
376 |
|
377 |
|
378 |
|
379 |
|
380 | export function useExpanded<D extends object = {}>(hooks: Hooks<D>): void;
|
381 |
|
382 | export namespace useExpanded {
|
383 | const pluginName = 'useExpanded';
|
384 | }
|
385 |
|
386 | export interface TableExpandedToggleProps extends TableKeyedProps {}
|
387 |
|
388 | export type UseExpandedOptions<D extends object> = Partial<{
|
389 | manualExpandedKey: IdType<D>;
|
390 | paginateExpandedRows: boolean;
|
391 | expandSubRows: boolean;
|
392 | autoResetExpanded?: boolean | undefined;
|
393 | }>;
|
394 |
|
395 | export interface UseExpandedHooks<D extends object> {
|
396 | getToggleRowsExpandedProps: Array<PropGetter<D, TableCommonProps>>;
|
397 | getToggleAllRowsExpandedProps: Array<PropGetter<D, TableCommonProps>>;
|
398 | }
|
399 |
|
400 | export interface UseExpandedState<D extends object> {
|
401 | expanded: Record<IdType<D>, boolean>;
|
402 | }
|
403 |
|
404 | export interface UseExpandedInstanceProps<D extends object> {
|
405 | preExpandedRows: Array<Row<D>>;
|
406 | expandedRows: Array<Row<D>>;
|
407 | rows: Array<Row<D>>;
|
408 | expandedDepth: number;
|
409 | isAllRowsExpanded: boolean;
|
410 | toggleRowExpanded: (id: Array<IdType<D>>, value?: boolean) => void;
|
411 | toggleAllRowsExpanded: (value?: boolean) => void;
|
412 | }
|
413 |
|
414 | export interface UseExpandedRowProps<D extends object> {
|
415 | isExpanded: boolean;
|
416 | canExpand: boolean;
|
417 | subRows: Array<Row<D>>;
|
418 | toggleRowExpanded: (value?: boolean) => void;
|
419 | getToggleRowExpandedProps: (props?: Partial<TableExpandedToggleProps>) => TableExpandedToggleProps;
|
420 | depth: number;
|
421 | }
|
422 |
|
423 |
|
424 |
|
425 |
|
426 | export function useFilters<D extends object = {}>(hooks: Hooks<D>): void;
|
427 |
|
428 | export namespace useFilters {
|
429 | const pluginName = 'useFilters';
|
430 | }
|
431 |
|
432 | export type UseFiltersOptions<D extends object> = Partial<{
|
433 | manualFilters: boolean;
|
434 | disableFilters: boolean;
|
435 | defaultCanFilter: boolean;
|
436 | filterTypes: FilterTypes<D>;
|
437 | autoResetFilters?: boolean | undefined;
|
438 | }>;
|
439 |
|
440 | export interface UseFiltersState<D extends object> {
|
441 | filters: Filters<D>;
|
442 | }
|
443 |
|
444 | export type UseFiltersColumnOptions<D extends object> = Partial<{
|
445 | Filter: Renderer<FilterProps<D>>;
|
446 | disableFilters: boolean;
|
447 | defaultCanFilter: boolean;
|
448 | filter: FilterType<D> | DefaultFilterTypes | string;
|
449 | }>;
|
450 |
|
451 | export interface UseFiltersInstanceProps<D extends object> {
|
452 | preFilteredRows: Array<Row<D>>;
|
453 | preFilteredFlatRows: Array<Row<D>>;
|
454 | preFilteredRowsById: Record<string, Row<D>>;
|
455 | filteredRows: Array<Row<D>>;
|
456 | filteredFlatRows: Array<Row<D>>;
|
457 | filteredRowsById: Record<string, Row<D>>;
|
458 | rows: Array<Row<D>>;
|
459 | flatRows: Array<Row<D>>;
|
460 | rowsById: Record<string, Row<D>>;
|
461 | setFilter: (columnId: IdType<D>, updater: ((filterValue: FilterValue) => FilterValue) | FilterValue) => void;
|
462 | setAllFilters: (updater: Filters<D> | ((filters: Filters<D>) => Filters<D>)) => void;
|
463 | }
|
464 |
|
465 | export interface UseFiltersColumnProps<D extends object> {
|
466 | canFilter: boolean;
|
467 | setFilter: (updater: ((filterValue: FilterValue) => FilterValue) | FilterValue) => void;
|
468 | filterValue: FilterValue;
|
469 | preFilteredRows: Array<Row<D>>;
|
470 | filteredRows: Array<Row<D>>;
|
471 | }
|
472 |
|
473 | export type FilterProps<D extends object> = HeaderProps<D>;
|
474 | export type FilterValue = any;
|
475 | export type Filters<D extends object> = Array<{ id: IdType<D>; value: FilterValue }>;
|
476 | export type FilterTypes<D extends object> = Record<string, FilterType<D>>;
|
477 |
|
478 | export type DefaultFilterTypes =
|
479 | | 'text'
|
480 | | 'exactText'
|
481 | | 'exactTextCase'
|
482 | | 'includes'
|
483 | | 'includesAll'
|
484 | | 'exact'
|
485 | | 'equals'
|
486 | | 'between';
|
487 |
|
488 | export interface FilterType<D extends object> {
|
489 | (rows: Array<Row<D>>, columnIds: Array<IdType<D>>, filterValue: FilterValue): Array<Row<D>>;
|
490 |
|
491 | autoRemove?: ((filterValue: FilterValue) => boolean) | undefined;
|
492 | }
|
493 |
|
494 | //#endregion
|
495 |
|
496 | //#region useFlexLayout
|
497 | export function useFlexLayout<D extends object = {}>(hooks: Hooks<D>): void;
|
498 |
|
499 | export namespace useFlexLayout {
|
500 | const pluginName = 'useFlexLayout';
|
501 | }
|
502 | //#endregion
|
503 |
|
504 | //#region useGridLayout
|
505 | export function useGridLayout<D extends object = {}>(hooks: Hooks<D>): void;
|
506 |
|
507 | export namespace useGridLayout {
|
508 | const pluginName = 'useGridLayout';
|
509 | }
|
510 | //#endregion
|
511 |
|
512 | //#region useGlobalFilter
|
513 | export function useGlobalFilter<D extends object = {}>(hooks: Hooks<D>): void;
|
514 |
|
515 | export namespace useGlobalFilter {
|
516 | const pluginName = 'useGlobalFilter';
|
517 | }
|
518 |
|
519 | export type UseGlobalFiltersOptions<D extends object> = Partial<{
|
520 | globalFilter: ((rows: Array<Row<D>>, columnIds: Array<IdType<D>>, filterValue: any) => Array<Row<D>>) | string;
|
521 | manualGlobalFilter: boolean;
|
522 | filterTypes: FilterTypes<D>;
|
523 | autoResetGlobalFilter?: boolean | undefined;
|
524 | disableGlobalFilter?: boolean | undefined;
|
525 | }>;
|
526 |
|
527 | export interface UseGlobalFiltersState<D extends object> {
|
528 | globalFilter: any;
|
529 | }
|
530 |
|
531 | export type UseGlobalFiltersColumnOptions<D extends object> = Partial<{
|
532 | disableGlobalFilter?: boolean | undefined;
|
533 | }>;
|
534 |
|
535 | export interface UseGlobalFiltersInstanceProps<D extends object> {
|
536 | preGlobalFilteredRows: Array<Row<D>>;
|
537 | preGlobalFilteredFlatRows: Array<Row<D>>;
|
538 | preGlobalFilteredRowsById: Record<string, Row<D>>;
|
539 | globalFilteredRows: Array<Row<D>>;
|
540 | globalFilteredFlatRows: Array<Row<D>>;
|
541 | globalFilteredRowsById: Record<string, Row<D>>;
|
542 | rows: Array<Row<D>>;
|
543 | flatRows: Array<Row<D>>;
|
544 | rowsById: Record<string, Row<D>>;
|
545 | setGlobalFilter: (filterValue: FilterValue) => void;
|
546 | }
|
547 |
|
548 |
|
549 |
|
550 |
|
551 | export function useGroupBy<D extends object = {}>(hooks: Hooks<D>): void;
|
552 |
|
553 | export namespace useGroupBy {
|
554 | const pluginName = 'useGroupBy';
|
555 | }
|
556 |
|
557 | export interface TableGroupByToggleProps {
|
558 | title?: string | undefined;
|
559 | style?: CSSProperties | undefined;
|
560 | onClick?: ((e: MouseEvent) => void) | undefined;
|
561 | }
|
562 |
|
563 | export type UseGroupByOptions<D extends object> = Partial<{
|
564 | manualGroupBy: boolean;
|
565 | disableGroupBy: boolean;
|
566 | defaultCanGroupBy: boolean;
|
567 | aggregations: Record<string, AggregatorFn<D>>;
|
568 | groupByFn: (rows: Array<Row<D>>, columnId: IdType<D>) => Record<string, Array<Row<D>>>;
|
569 | autoResetGroupBy?: boolean | undefined;
|
570 | }>;
|
571 |
|
572 | export interface UseGroupByHooks<D extends object> {
|
573 | getGroupByToggleProps: Array<HeaderGroupPropGetter<D>>;
|
574 | }
|
575 |
|
576 | export interface UseGroupByState<D extends object> {
|
577 | groupBy: Array<IdType<D>>;
|
578 | }
|
579 |
|
580 | export type UseGroupByColumnOptions<D extends object> = Partial<{
|
581 | aggregate: Aggregator<D>;
|
582 | Aggregated: Renderer<CellProps<D>>;
|
583 | disableGroupBy: boolean;
|
584 | defaultCanGroupBy: boolean;
|
585 | }>;
|
586 |
|
587 | export interface UseGroupByInstanceProps<D extends object> {
|
588 | preGroupedRows: Array<Row<D>>;
|
589 | preGroupedFlatRows: Array<Row<D>>;
|
590 | preGroupedRowsById: Record<string, Row<D>>;
|
591 | groupedRows: Array<Row<D>>;
|
592 | groupedFlatRows: Array<Row<D>>;
|
593 | groupedRowsById: Record<string, Row<D>>;
|
594 | onlyGroupedFlatRows: Array<Row<D>>;
|
595 | onlyGroupedRowsById: Record<string, Row<D>>;
|
596 | nonGroupedFlatRows: Array<Row<D>>;
|
597 | nonGroupedRowsById: Record<string, Row<D>>;
|
598 | rows: Array<Row<D>>;
|
599 | flatRows: Array<Row<D>>;
|
600 | rowsById: Record<string, Row<D>>;
|
601 | toggleGroupBy: (columnId: IdType<D>, value?: boolean) => void;
|
602 | }
|
603 |
|
604 | export interface UseGroupByColumnProps<D extends object> {
|
605 | canGroupBy: boolean;
|
606 | isGrouped: boolean;
|
607 | groupedIndex: number;
|
608 | toggleGroupBy: () => void;
|
609 | getGroupByToggleProps: (props?: Partial<TableGroupByToggleProps>) => TableGroupByToggleProps;
|
610 | }
|
611 |
|
612 | export interface UseGroupByRowProps<D extends object> {
|
613 | isGrouped: boolean;
|
614 | groupByID: IdType<D>;
|
615 | groupByVal: string;
|
616 | values: Record<IdType<D>, AggregatedValue>;
|
617 | subRows: Array<Row<D>>;
|
618 | leafRows: Array<Row<D>>;
|
619 | depth: number;
|
620 | id: string;
|
621 | index: number;
|
622 | }
|
623 |
|
624 | export interface UseGroupByCellProps<D extends object> {
|
625 | isGrouped: boolean;
|
626 | isPlaceholder: boolean;
|
627 | isAggregated: boolean;
|
628 | }
|
629 |
|
630 | export type DefaultAggregators = 'sum' | 'average' | 'median' | 'uniqueCount' | 'count';
|
631 |
|
632 | export type AggregatorFn<D extends object> = (
|
633 | columnValues: CellValue[],
|
634 | rows: Array<Row<D>>,
|
635 | isAggregated: boolean,
|
636 | ) => AggregatedValue;
|
637 | export type Aggregator<D extends object> = AggregatorFn<D> | DefaultAggregators | string;
|
638 | export type AggregatedValue = any;
|
639 |
|
640 |
|
641 |
|
642 | export function usePagination<D extends object = {}>(hooks: Hooks<D>): void;
|
643 |
|
644 | export namespace usePagination {
|
645 | const pluginName = 'usePagination';
|
646 | }
|
647 |
|
648 | export type UsePaginationOptions<D extends object> = Partial<{
|
649 | pageCount: number;
|
650 | manualPagination: boolean;
|
651 | autoResetPage?: boolean | undefined;
|
652 | paginateExpandedRows: boolean;
|
653 | }>;
|
654 |
|
655 | export interface UsePaginationState<D extends object> {
|
656 | pageSize: number;
|
657 | pageIndex: number;
|
658 | }
|
659 |
|
660 | export interface UsePaginationInstanceProps<D extends object> {
|
661 | page: Array<Row<D>>;
|
662 | pageCount: number;
|
663 | pageOptions: number[];
|
664 | canPreviousPage: boolean;
|
665 | canNextPage: boolean;
|
666 | gotoPage: (updater: ((pageIndex: number) => number) | number) => void;
|
667 | previousPage: () => void;
|
668 | nextPage: () => void;
|
669 | setPageSize: (pageSize: number) => void;
|
670 | }
|
671 |
|
672 |
|
673 |
|
674 |
|
675 | export function useResizeColumns<D extends object = {}>(hooks: Hooks<D>): void;
|
676 |
|
677 | export namespace useResizeColumns {
|
678 | const pluginName = 'useResizeColumns';
|
679 | }
|
680 |
|
681 | export interface UseResizeColumnsOptions<D extends object> {
|
682 | disableResizing?: boolean | undefined;
|
683 | autoResetResize?: boolean | undefined;
|
684 | }
|
685 |
|
686 | export interface UseResizeColumnsState<D extends object> {
|
687 | columnResizing: {
|
688 | startX?: number | undefined;
|
689 | columnWidth: number;
|
690 | headerIdWidths: Record<string, number>;
|
691 | columnWidths: any;
|
692 | isResizingColumn?: string | undefined;
|
693 | };
|
694 | }
|
695 |
|
696 | export interface UseResizeColumnsColumnOptions<D extends object> {
|
697 | disableResizing?: boolean | undefined;
|
698 | }
|
699 |
|
700 | export interface TableResizerProps {}
|
701 |
|
702 | export interface UseResizeColumnsColumnProps<D extends object> {
|
703 | getResizerProps: (props?: Partial<TableResizerProps>) => TableResizerProps;
|
704 | canResize: boolean;
|
705 | isResizing: boolean;
|
706 | }
|
707 |
|
708 |
|
709 |
|
710 |
|
711 | export function useRowSelect<D extends object = {}>(hooks: Hooks<D>): void;
|
712 |
|
713 | export namespace useRowSelect {
|
714 | const pluginName = 'useRowSelect';
|
715 | }
|
716 |
|
717 | export interface TableToggleAllRowsSelectedProps extends TableToggleCommonProps {}
|
718 |
|
719 | export interface TableToggleRowsSelectedProps extends TableToggleCommonProps {}
|
720 |
|
721 | export type UseRowSelectOptions<D extends object> = Partial<{
|
722 | manualRowSelectedKey: IdType<D>;
|
723 | autoResetSelectedRows: boolean;
|
724 | selectSubRows: boolean;
|
725 | }>;
|
726 |
|
727 | export interface UseRowSelectHooks<D extends object> {
|
728 | getToggleRowSelectedProps: Array<PropGetter<D, TableToggleRowsSelectedProps>>;
|
729 | getToggleAllRowsSelectedProps: Array<PropGetter<D, TableToggleAllRowsSelectedProps>>;
|
730 | getToggleAllPageRowsSelectedProps: Array<PropGetter<D, TableToggleAllRowsSelectedProps>>;
|
731 | }
|
732 |
|
733 | export interface UseRowSelectState<D extends object> {
|
734 | selectedRowIds: Record<IdType<D>, boolean>;
|
735 | }
|
736 |
|
737 | export interface UseRowSelectInstanceProps<D extends object> {
|
738 | toggleRowSelected: (rowId: IdType<D>, set?: boolean) => void;
|
739 | toggleAllRowsSelected: (value?: boolean) => void;
|
740 | getToggleAllRowsSelectedProps: (
|
741 | props?: Partial<TableToggleAllRowsSelectedProps>,
|
742 | ) => TableToggleAllRowsSelectedProps;
|
743 | getToggleAllPageRowsSelectedProps: (
|
744 | props?: Partial<TableToggleAllRowsSelectedProps>,
|
745 | ) => TableToggleAllRowsSelectedProps;
|
746 | isAllRowsSelected: boolean;
|
747 | selectedFlatRows: Array<Row<D>>;
|
748 | }
|
749 |
|
750 | export interface UseRowSelectRowProps<D extends object> {
|
751 | isSelected: boolean;
|
752 | isSomeSelected: boolean;
|
753 | toggleRowSelected: (set?: boolean) => void;
|
754 | getToggleRowSelectedProps: (props?: Partial<TableToggleRowsSelectedProps>) => TableToggleRowsSelectedProps;
|
755 | }
|
756 |
|
757 |
|
758 |
|
759 |
|
760 | export function useRowState<D extends object = {}>(hooks: Hooks<D>): void;
|
761 |
|
762 | export namespace useRowState {
|
763 | const pluginName = 'useRowState';
|
764 | }
|
765 |
|
766 | export type UseRowStateOptions<D extends object> = Partial<{
|
767 | initialRowStateAccessor: (row: Row<D>) => UseRowStateLocalState<D>;
|
768 | getResetRowStateDeps: (instance: TableInstance<D>) => any[];
|
769 | autoResetRowState?: boolean | undefined;
|
770 | }>;
|
771 |
|
772 | export interface UseRowStateState<D extends object> {
|
773 | rowState: Record<string, { cellState: UseRowStateLocalState<D> }>;
|
774 | }
|
775 |
|
776 | export interface UseRowStateInstanceProps<D extends object> {
|
777 | setRowState: (rowPath: string[], updater: UseRowUpdater) => void;
|
778 | setCellState: (rowPath: string[], columnId: IdType<D>, updater: UseRowUpdater) => void;
|
779 | }
|
780 |
|
781 | export interface UseRowStateRowProps<D extends object> {
|
782 | state: UseRowStateLocalState<D>;
|
783 | setState: (updater: UseRowUpdater) => void;
|
784 | }
|
785 |
|
786 | export interface UseRowStateCellProps<D extends object> {
|
787 | state: UseRowStateLocalState<D>;
|
788 | setState: (updater: UseRowUpdater) => void;
|
789 | }
|
790 |
|
791 | export type UseRowUpdater<T = unknown> = T | ((prev: T) => T);
|
792 | export type UseRowStateLocalState<D extends object, T = unknown> = Record<IdType<D>, T>;
|
793 | //#endregion
|
794 |
|
795 | //#region useSortBy
|
796 | export function useSortBy<D extends object = {}>(hooks: Hooks<D>): void;
|
797 |
|
798 | export namespace useSortBy {
|
799 | const pluginName = 'useSortBy';
|
800 | }
|
801 |
|
802 | export interface TableSortByToggleProps {
|
803 | title?: string | undefined;
|
804 | style?: CSSProperties | undefined;
|
805 | onClick?: ((e: MouseEvent) => void)| undefined;
|
806 | }
|
807 |
|
808 | export type UseSortByOptions<D extends object> = Partial<{
|
809 | manualSortBy: boolean;
|
810 | disableSortBy: boolean;
|
811 | defaultCanSort: boolean;
|
812 | disableMultiSort: boolean;
|
813 | isMultiSortEvent: (e: MouseEvent) => boolean;
|
814 | maxMultiSortColCount: number;
|
815 | disableSortRemove: boolean;
|
816 | disabledMultiRemove: boolean;
|
817 | orderByFn: (rows: Array<Row<D>>, sortFns: Array<OrderByFn<D>>, directions: boolean[]) => Array<Row<D>>;
|
818 | sortTypes: Record<string, SortByFn<D>>;
|
819 | autoResetSortBy?: boolean | undefined;
|
820 | }>;
|
821 |
|
822 | export interface UseSortByHooks<D extends object> {
|
823 | getSortByToggleProps: Array<PropGetter<D, TableCommonProps>>;
|
824 | }
|
825 |
|
826 | export interface UseSortByState<D extends object> {
|
827 | sortBy: Array<SortingRule<D>>;
|
828 | }
|
829 |
|
830 | export type UseSortByColumnOptions<D extends object> = Partial<{
|
831 | defaultCanSort: boolean;
|
832 | disableSortBy: boolean;
|
833 | sortDescFirst: boolean;
|
834 | sortInverted: boolean;
|
835 | sortType: SortByFn<D> | DefaultSortTypes | string;
|
836 | }>;
|
837 |
|
838 | export interface UseSortByInstanceProps<D extends object> {
|
839 | rows: Array<Row<D>>;
|
840 | preSortedRows: Array<Row<D>>;
|
841 | setSortBy: (sortBy: Array<SortingRule<D>>) => void;
|
842 | toggleSortBy: (columnId: IdType<D>, descending?: boolean, isMulti?: boolean) => void;
|
843 | }
|
844 |
|
845 | export interface UseSortByColumnProps<D extends object> {
|
846 | canSort: boolean;
|
847 | toggleSortBy: (descending?: boolean, multi?: boolean) => void;
|
848 | getSortByToggleProps: (props?: Partial<TableSortByToggleProps>) => TableSortByToggleProps;
|
849 | clearSortBy: () => void;
|
850 | isSorted: boolean;
|
851 | sortedIndex: number;
|
852 | isSortedDesc: boolean | undefined;
|
853 | }
|
854 |
|
855 | export type OrderByFn<D extends object> = (rowA: Row<D>, rowB: Row<D>) => number;
|
856 | export type SortByFn<D extends object> = (rowA: Row<D>, rowB: Row<D>, columnId: IdType<D>, desc?: boolean) => number;
|
857 |
|
858 | export type DefaultSortTypes = 'alphanumeric' | 'datetime' | 'basic' | 'string' | 'number';
|
859 |
|
860 | export interface SortingRule<D> {
|
861 | id: IdType<D>;
|
862 | desc?: boolean | undefined;
|
863 | }
|
864 |
|
865 |
|
866 |
|
867 |
|
868 | export const actions: Record<string, string>;
|
869 | export type ActionType = { type: string } & Record<string, any>;
|
870 | export const defaultColumn: Partial<Column> & Record<string, any>;
|
871 |
|
872 |
|
873 | export type StringKey<D> = Extract<keyof D, string>;
|
874 | export type IdType<D> = StringKey<D> | string;
|
875 | export type CellValue<V = any> = V;
|
876 |
|
877 | export type Renderer<Props> = ComponentType<Props> | ReactElement | string | number | ReactFragment;
|
878 |
|
879 | export interface PluginHook<D extends object> {
|
880 | (hooks: Hooks<D>): void;
|
881 | pluginName?: string | undefined;
|
882 | }
|
883 |
|
884 | export type TableDispatch<A = any> = (action: A) => void;
|
885 |
|
886 |
|
887 | export function defaultOrderByFn<D extends object = {}>(
|
888 | arr: Array<Row<D>>,
|
889 | funcs: Array<OrderByFn<D>>,
|
890 | dirs: boolean[],
|
891 | ): Array<Row<D>>;
|
892 |
|
893 | export function defaultGroupByFn<D extends object = {}>(
|
894 | rows: Array<Row<D>>,
|
895 | columnId: IdType<D>,
|
896 | ): Record<string, Array<Row<D>>>;
|
897 |
|
898 | export function makePropGetter(hooks: Hooks, ...meta: any[]): any;
|
899 |
|
900 | export function reduceHooks<T extends object = {}>(hooks: Hooks, initial: T, ...args: any[]): T;
|
901 |
|
902 | export function loopHooks(hooks: Hooks, ...args: any[]): void;
|
903 |
|
904 | export function ensurePluginOrder<D extends object = {}>(
|
905 | plugins: Array<PluginHook<D>>,
|
906 | befores: string[],
|
907 | pluginName: string,
|
908 | ): void;
|
909 |
|
910 | export function functionalUpdate<D extends object = {}>(
|
911 | updater: any,
|
912 | old: Partial<TableState<D>>,
|
913 | ): Partial<TableState<D>>;
|
914 |
|
915 | export function useGetLatest<T>(obj: T): () => T;
|
916 |
|
917 | export function safeUseLayoutEffect(effect: EffectCallback, deps?: DependencyList): void;
|
918 |
|
919 | export function useMountedLayoutEffect(effect: EffectCallback, deps?: DependencyList): void;
|
920 |
|
921 | export function useAsyncDebounce<F extends (...args: any[]) => any>(defaultFn: F, defaultWait?: number): F;
|
922 |
|
923 | export function makeRenderer(instance: TableInstance, column: ColumnInstance, meta?: any): ReactElement;
|