@infinite-table/infinite-react 0.6.1 → 0.6.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (4) hide show
  1. package/index.d.ts +282 -254
  2. package/index.esm.js +2 -2
  3. package/index.js +2 -2
  4. package/package.json +2 -2
package/index.d.ts CHANGED
@@ -1,8 +1,8 @@
1
1
  import * as React$1 from 'react';
2
2
  import { CSSProperties, HTMLProps, RefCallback, MutableRefObject, MouseEvent, KeyboardEvent, ReactNode } from 'react';
3
3
 
4
- declare type SortDir = 1 | -1;
5
- declare type MultisortInfo<T> = {
4
+ type SortDir = 1 | -1;
5
+ type MultisortInfo<T> = {
6
6
  /**
7
7
  * The sorting direction
8
8
  */
@@ -22,7 +22,7 @@ declare type MultisortInfo<T> = {
22
22
  */
23
23
  valueGetter?: (item: T) => any;
24
24
  };
25
- declare type MultisortInfoAllowMultipleFields<T> = Omit<MultisortInfo<T>, 'field'> & {
25
+ type MultisortInfoAllowMultipleFields<T> = Omit<MultisortInfo<T>, 'field'> & {
26
26
  field?: keyof T | (keyof T)[];
27
27
  };
28
28
  declare const multisort: {
@@ -32,14 +32,14 @@ declare const multisort: {
32
32
  };
33
33
  };
34
34
 
35
- declare type VoidFn$1 = () => void;
36
- declare type Pair<KeyType, ValueType> = {
35
+ type VoidFn$1 = () => void;
36
+ type Pair<KeyType, ValueType> = {
37
37
  value?: ValueType;
38
38
  map?: Map<KeyType, Pair<KeyType, ValueType>>;
39
39
  length: number;
40
40
  revision?: number;
41
41
  };
42
- declare type DeepMapVisitFn<KeyType, ValueType> = (pair: Pair<KeyType, ValueType>, keys: KeyType[], next: VoidFn$1) => void;
42
+ type DeepMapVisitFn<KeyType, ValueType> = (pair: Pair<KeyType, ValueType>, keys: KeyType[], next: VoidFn$1) => void;
43
43
  declare class DeepMap<KeyType, ValueType> {
44
44
  private map;
45
45
  private length;
@@ -89,14 +89,37 @@ declare enum InfiniteTableActionType {
89
89
  SET_DRAGGING_COLUMN_ID = 8
90
90
  }
91
91
 
92
- declare type InfiniteTableAction = {
92
+ type InfiniteTableAction = {
93
93
  type: InfiniteTableActionType;
94
94
  payload?: any;
95
95
  };
96
96
 
97
- declare type Renderable = React$1.ReactNode | JSX.Element;
97
+ type Renderable = React$1.ReactNode | JSX.Element;
98
98
 
99
- declare function useInfiniteHeaderCell<T>(): InfiniteTableColumnHeaderParam<T, InfiniteTableComputedColumn<T>>;
99
+ declare function useInfiniteHeaderCell<T>(): {
100
+ dragging: boolean;
101
+ column: InfiniteTableComputedColumn<T>;
102
+ columnsMap: Map<string, InfiniteTableComputedColumn<T>>;
103
+ columnSortInfo: DataSourceSingleSortInfo<T> | null;
104
+ columnFilterValue: DataSourceFilterValueItem<T> | null;
105
+ selectionMode: DataSourcePropSelectionMode;
106
+ allRowsSelected: boolean;
107
+ someRowsSelected: boolean;
108
+ api: InfiniteTableApi<T>;
109
+ renderBag: {
110
+ all?: Renderable;
111
+ header: Renderable;
112
+ sortIcon?: Renderable;
113
+ menuIcon?: Renderable;
114
+ selectionCheckBox?: Renderable;
115
+ };
116
+ } & {
117
+ domRef: ((instance: HTMLElement | null) => void) | undefined;
118
+ insideColumnMenu: false;
119
+ } & {
120
+ domRef: ((instance: HTMLElement | null) => void) | undefined;
121
+ insideColumnMenu: false;
122
+ };
100
123
 
101
124
  declare function useInfiniteColumnCell<T>(): InfiniteTableColumnCellContextType<T>;
102
125
 
@@ -115,7 +138,7 @@ interface Size {
115
138
  height: number;
116
139
  }
117
140
 
118
- declare type InfiniteTableBaseCellProps<T> = {
141
+ type InfiniteTableBaseCellProps<T> = {
119
142
  column: InfiniteTableComputedColumn<T>;
120
143
  rowId?: any;
121
144
  renderChildren: () => Renderable;
@@ -130,23 +153,22 @@ declare type InfiniteTableBaseCellProps<T> = {
130
153
  cssPosition?: CSSProperties['position'];
131
154
  domRef?: React.RefCallback<HTMLElement>;
132
155
  };
133
- declare type InfiniteTableCellProps<T> = ({
156
+ type InfiniteTableCellProps<T> = ({
134
157
  cellType: 'header';
135
158
  } & InfiniteTableBaseCellProps<T>) | ({
136
159
  cellType: 'body';
137
160
  } & InfiniteTableBaseCellProps<T>);
138
161
 
139
- declare type DiscriminatedUnion<A, B> = (A & {
162
+ type DiscriminatedUnion<A, B> = (A & {
140
163
  [K in keyof B]?: undefined;
141
164
  }) | (B & {
142
165
  [K in keyof A]?: undefined;
143
166
  });
144
- declare type KeyOfNoSymbol<T> = Exclude<keyof T, Symbol>;
167
+ type KeyOfNoSymbol<T> = Exclude<keyof T, Symbol>;
145
168
 
146
- declare type InfiniteTableToggleGroupRowFn = (groupKeys: any[]) => void;
147
- declare type InfiniteTableSelectRowFn = (id: any) => void;
148
- declare type InfiniteTableColumnHeaderParam<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = {
149
- domRef: InfiniteTableCellProps<DATA_TYPE>['domRef'];
169
+ type InfiniteTableToggleGroupRowFn = (groupKeys: any[]) => void;
170
+ type InfiniteTableSelectRowFn = (id: any) => void;
171
+ type InfiniteTableColumnHeaderParam<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = {
150
172
  dragging: boolean;
151
173
  column: COL_TYPE;
152
174
  columnsMap: Map<string, COL_TYPE>;
@@ -163,14 +185,19 @@ declare type InfiniteTableColumnHeaderParam<DATA_TYPE, COL_TYPE = InfiniteTableC
163
185
  menuIcon?: Renderable;
164
186
  selectionCheckBox?: Renderable;
165
187
  };
166
- };
167
- declare type InfiniteTableColumnRenderBag = {
188
+ } & ({
189
+ domRef: InfiniteTableCellProps<DATA_TYPE>['domRef'];
190
+ insideColumnMenu: false;
191
+ } | {
192
+ insideColumnMenu: true;
193
+ });
194
+ type InfiniteTableColumnRenderBag = {
168
195
  value: string | number | Renderable;
169
196
  groupIcon?: Renderable;
170
197
  all?: Renderable;
171
198
  selectionCheckBox?: Renderable;
172
199
  };
173
- declare type InfiniteTableColumnRenderParamBase<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = {
200
+ type InfiniteTableColumnRenderParamBase<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = {
174
201
  domRef: InfiniteTableCellProps<DATA_TYPE>['domRef'];
175
202
  value: string | number | Renderable;
176
203
  renderBag: InfiniteTableColumnRenderBag;
@@ -195,58 +222,58 @@ declare type InfiniteTableColumnRenderParamBase<DATA_TYPE, COL_TYPE = InfiniteTa
195
222
  rootGroupBy: DataSourceState<DATA_TYPE>['groupBy'];
196
223
  pivotBy?: DataSourceState<DATA_TYPE>['pivotBy'];
197
224
  };
198
- declare type InfiniteTableColumnRenderParam<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = InfiniteTableColumnRenderParamBase<DATA_TYPE, COL_TYPE> & InfiniteTableRowInfoDataDiscriminator<DATA_TYPE>;
199
- declare type InfiniteTableColumnCellContextType<DATA_TYPE> = InfiniteTableColumnRenderParam<DATA_TYPE> & {};
200
- declare type InfiniteTableColumnRenderValueParam<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = InfiniteTableColumnRenderParam<DATA_TYPE, COL_TYPE>;
201
- declare type InfiniteTableColumnRowspanParam<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = {
225
+ type InfiniteTableColumnRenderParam<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = InfiniteTableColumnRenderParamBase<DATA_TYPE, COL_TYPE> & InfiniteTableRowInfoDataDiscriminator<DATA_TYPE>;
226
+ type InfiniteTableColumnCellContextType<DATA_TYPE> = InfiniteTableColumnRenderParam<DATA_TYPE> & {};
227
+ type InfiniteTableColumnRenderValueParam<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = InfiniteTableColumnRenderParam<DATA_TYPE, COL_TYPE>;
228
+ type InfiniteTableColumnRowspanParam<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = {
202
229
  rowInfo: InfiniteTableRowInfo<DATA_TYPE>;
203
230
  data: DATA_TYPE | Partial<DATA_TYPE> | null;
204
231
  dataArray: InfiniteTableRowInfo<DATA_TYPE>[];
205
232
  rowIndex: number;
206
233
  column: COL_TYPE;
207
234
  };
208
- declare type InfiniteTableColumnRenderFunctionForGroupRows<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = (renderParams: InfiniteTableColumnRenderParam<DATA_TYPE, COL_TYPE> & {
235
+ type InfiniteTableColumnRenderFunctionForGroupRows<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = (renderParams: InfiniteTableColumnRenderParam<DATA_TYPE, COL_TYPE> & {
209
236
  isGroupRow: true;
210
237
  }) => Renderable | null;
211
- declare type InfiniteTableColumnRenderFunctionForNormalRows<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = (renderParams: InfiniteTableColumnRenderParam<DATA_TYPE, COL_TYPE> & {
238
+ type InfiniteTableColumnRenderFunctionForNormalRows<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = (renderParams: InfiniteTableColumnRenderParam<DATA_TYPE, COL_TYPE> & {
212
239
  isGroupRow: false;
213
240
  }) => Renderable | null;
214
- declare type InfiniteTableColumnRenderFunction<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = (renderParams: InfiniteTableColumnRenderParam<DATA_TYPE, COL_TYPE>) => Renderable | null;
215
- declare type InfiniteTableColumnHeaderRenderFunction<T> = (headerParams: InfiniteTableColumnHeaderParam<T>) => Renderable;
216
- declare type InfiniteTableColumnContentFocusable<T> = boolean | InfiniteTableColumnContentFocusableFn<T>;
217
- declare type InfiniteTableColumnEditable<T> = boolean | InfiniteTableColumnEditableFn<T>;
218
- declare type InfiniteTableColumnContentFocusableFn<T> = (params: InfiniteTableColumnContentFocusableParams<T>) => boolean;
219
- declare type InfiniteTableColumnEditableFn<T> = (params: InfiniteTableColumnEditableParams<T>) => boolean;
220
- declare type InfiniteTableColumnContentFocusableParams<T> = InfiniteTableColumnValueFormatterParams<T> & {
241
+ type InfiniteTableColumnRenderFunction<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = (renderParams: InfiniteTableColumnRenderParam<DATA_TYPE, COL_TYPE>) => Renderable | null;
242
+ type InfiniteTableColumnHeaderRenderFunction<T> = (headerParams: InfiniteTableColumnHeaderParam<T>) => Renderable;
243
+ type InfiniteTableColumnContentFocusable<T> = boolean | InfiniteTableColumnContentFocusableFn<T>;
244
+ type InfiniteTableColumnEditable<T> = boolean | InfiniteTableColumnEditableFn<T>;
245
+ type InfiniteTableColumnContentFocusableFn<T> = (params: InfiniteTableColumnContentFocusableParams<T>) => boolean;
246
+ type InfiniteTableColumnEditableFn<T> = (params: InfiniteTableColumnEditableParams<T>) => boolean;
247
+ type InfiniteTableColumnContentFocusableParams<T> = InfiniteTableColumnValueFormatterParams<T> & {
221
248
  column: InfiniteTableComputedColumn<T>;
222
249
  };
223
- declare type InfiniteTableColumnEditableParams<T> = InfiniteTableColumnContentFocusableParams<T>;
224
- declare type InfiniteTableColumnAlign = 'start' | 'center' | 'end';
225
- declare type InfiniteTableColumnVerticalAlign = 'start' | 'center' | 'end';
226
- declare type InfiniteTableColumnHeader<T> = Renderable | InfiniteTableColumnHeaderRenderFunction<T>;
227
- declare type InfiniteTableDataTypeNames = 'string' | 'number' | 'date' | string;
228
- declare type InfiniteTableColumnTypeNames = 'string' | 'number' | 'date' | string;
229
- declare type InfiniteTableColumnStyleFnParams<T> = {
250
+ type InfiniteTableColumnEditableParams<T> = InfiniteTableColumnContentFocusableParams<T>;
251
+ type InfiniteTableColumnAlign = 'start' | 'center' | 'end';
252
+ type InfiniteTableColumnVerticalAlign = 'start' | 'center' | 'end';
253
+ type InfiniteTableColumnHeader<T> = Renderable | InfiniteTableColumnHeaderRenderFunction<T>;
254
+ type InfiniteTableDataTypeNames = 'string' | 'number' | 'date' | string;
255
+ type InfiniteTableColumnTypeNames = 'string' | 'number' | 'date' | string;
256
+ type InfiniteTableColumnStyleFnParams<T> = {
230
257
  value: Renderable;
231
258
  column: InfiniteTableComputedColumn<T>;
232
259
  } & InfiniteTableRowInfoDataDiscriminator<T>;
233
- declare type InfiniteTableColumnStyleFn<T> = (params: InfiniteTableColumnStyleFnParams<T>) => undefined | React.CSSProperties;
234
- declare type InfiniteTableColumnHeaderClassNameFn<T> = (params: InfiniteTableColumnHeaderParam<T>) => undefined | string;
235
- declare type InfiniteTableColumnHeaderStyleFn<T> = (params: InfiniteTableColumnHeaderParam<T>) => undefined | React.CSSProperties;
236
- declare type InfiniteTableColumnClassNameFn<T> = (params: InfiniteTableColumnStyleFnParams<T>) => undefined | string;
237
- declare type InfiniteTableColumnStyle<T> = CSSProperties | InfiniteTableColumnStyleFn<T>;
238
- declare type InfiniteTableColumnHeaderStyle<T> = CSSProperties | InfiniteTableColumnHeaderStyleFn<T>;
239
- declare type InfiniteTableColumnClassName<T> = string | InfiniteTableColumnClassNameFn<T>;
240
- declare type InfiniteTableColumnHeaderClassName<T> = string | InfiniteTableColumnHeaderClassNameFn<T>;
241
- declare type InfiniteTableColumnValueGetterParams<T> = {
260
+ type InfiniteTableColumnStyleFn<T> = (params: InfiniteTableColumnStyleFnParams<T>) => undefined | React.CSSProperties;
261
+ type InfiniteTableColumnHeaderClassNameFn<T> = (params: InfiniteTableColumnHeaderParam<T>) => undefined | string;
262
+ type InfiniteTableColumnHeaderStyleFn<T> = (params: InfiniteTableColumnHeaderParam<T>) => undefined | React.CSSProperties;
263
+ type InfiniteTableColumnClassNameFn<T> = (params: InfiniteTableColumnStyleFnParams<T>) => undefined | string;
264
+ type InfiniteTableColumnStyle<T> = CSSProperties | InfiniteTableColumnStyleFn<T>;
265
+ type InfiniteTableColumnHeaderStyle<T> = CSSProperties | InfiniteTableColumnHeaderStyleFn<T>;
266
+ type InfiniteTableColumnClassName<T> = string | InfiniteTableColumnClassNameFn<T>;
267
+ type InfiniteTableColumnHeaderClassName<T> = string | InfiniteTableColumnHeaderClassNameFn<T>;
268
+ type InfiniteTableColumnValueGetterParams<T> = {
242
269
  data: T;
243
270
  field?: keyof T;
244
271
  };
245
- declare type InfiniteTableColumnValueFormatterParams<T> = InfiniteTableRowInfoDataDiscriminator<T>;
246
- declare type InfiniteTableColumnValueGetter<T, VALUE_GETTER_TYPE = string | number | boolean | Date | null | undefined> = (params: InfiniteTableColumnValueGetterParams<T>) => VALUE_GETTER_TYPE;
247
- declare type InfiniteTableColumnValueFormatter<T, VALUE_FORMATTER_TYPE = string | number | boolean | Date | null | undefined> = (params: InfiniteTableColumnValueFormatterParams<T>) => VALUE_FORMATTER_TYPE;
248
- declare type InfiniteTableColumnRowspanFn<T> = (params: InfiniteTableColumnRowspanParam<T>) => number;
249
- declare type InfiniteTableColumnComparer<T> = (a: T, b: T) => number;
272
+ type InfiniteTableColumnValueFormatterParams<T> = InfiniteTableRowInfoDataDiscriminator<T>;
273
+ type InfiniteTableColumnValueGetter<T, VALUE_GETTER_TYPE = string | number | boolean | Date | null | undefined> = (params: InfiniteTableColumnValueGetterParams<T>) => VALUE_GETTER_TYPE;
274
+ type InfiniteTableColumnValueFormatter<T, VALUE_FORMATTER_TYPE = string | number | boolean | Date | null | undefined> = (params: InfiniteTableColumnValueFormatterParams<T>) => VALUE_FORMATTER_TYPE;
275
+ type InfiniteTableColumnRowspanFn<T> = (params: InfiniteTableColumnRowspanParam<T>) => number;
276
+ type InfiniteTableColumnComparer<T> = (a: T, b: T) => number;
250
277
  /**
251
278
  * Defines a column in the table.
252
279
  *
@@ -254,7 +281,7 @@ declare type InfiniteTableColumnComparer<T> = (a: T, b: T) => number;
254
281
  *
255
282
  * Can be bound to a field which is a `keyof DATA_TYPE`.
256
283
  */
257
- declare type InfiniteTableColumn<DATA_TYPE> = {
284
+ type InfiniteTableColumn<DATA_TYPE> = {
258
285
  sortable?: boolean;
259
286
  draggable?: boolean;
260
287
  resizable?: boolean;
@@ -304,12 +331,12 @@ declare type InfiniteTableColumn<DATA_TYPE> = {
304
331
  HeaderCell?: React.FunctionComponent<HTMLProps<HTMLDivElement>>;
305
332
  };
306
333
  };
307
- declare type InfiniteTableGeneratedGroupColumn<T> = Omit<InfiniteTableColumn<T>, 'sortable'> & {
334
+ type InfiniteTableGeneratedGroupColumn<T> = Omit<InfiniteTableColumn<T>, 'sortable'> & {
308
335
  groupByField: string | string[];
309
336
  id?: string;
310
337
  };
311
- declare type InfiniteTablePivotColumn<T> = InfiniteTableColumn<T> & ColumnTypeWithInherit<Partial<InfiniteTablePivotFinalColumnVariant<T, any>>>;
312
- declare type InfiniteTablePivotFinalColumnGroup<DataType, KeyType extends any = any> = InfiniteTableColumnGroup & {
338
+ type InfiniteTablePivotColumn<T> = InfiniteTableColumn<T> & ColumnTypeWithInherit<Partial<InfiniteTablePivotFinalColumnVariant<T, any>>>;
339
+ type InfiniteTablePivotFinalColumnGroup<DataType, KeyType extends any = any> = InfiniteTableColumnGroup & {
313
340
  pivotBy: DataSourcePivotBy<DataType>[];
314
341
  pivotTotalColumnGroup?: true;
315
342
  pivotGroupKeys: KeyType[];
@@ -317,7 +344,7 @@ declare type InfiniteTablePivotFinalColumnGroup<DataType, KeyType extends any =
317
344
  pivotGroupKey: KeyType;
318
345
  pivotIndex: number;
319
346
  };
320
- declare type InfiniteTablePivotFinalColumn<DataType, KeyType extends any = any> = InfiniteTableColumn<DataType> & {
347
+ type InfiniteTablePivotFinalColumn<DataType, KeyType extends any = any> = InfiniteTableColumn<DataType> & {
321
348
  pivotBy: DataSourcePivotBy<DataType>[];
322
349
  pivotColumn: true;
323
350
  pivotTotalColumn: boolean;
@@ -328,8 +355,8 @@ declare type InfiniteTablePivotFinalColumn<DataType, KeyType extends any = any>
328
355
  pivotIndex: number;
329
356
  pivotGroupKey: KeyType;
330
357
  };
331
- declare type InfiniteTablePivotFinalColumnVariant<DataType, KeyType extends any = any> = InfiniteTablePivotFinalColumn<DataType, KeyType>;
332
- declare type InfiniteTableComputedColumnBase<T> = {
358
+ type InfiniteTablePivotFinalColumnVariant<DataType, KeyType extends any = any> = InfiniteTablePivotFinalColumn<DataType, KeyType>;
359
+ type InfiniteTableComputedColumnBase<T> = {
333
360
  computedFilterType: string;
334
361
  computedSortType: string;
335
362
  computedDataType: string;
@@ -364,8 +391,8 @@ declare type InfiniteTableComputedColumnBase<T> = {
364
391
  colType: InfiniteTableColumnType<T>;
365
392
  id: string;
366
393
  };
367
- declare type InfiniteTableComputedColumn<T> = InfiniteTableColumn<T> & InfiniteTableComputedColumnBase<T> & Partial<InfiniteTablePivotFinalColumn<T>> & Partial<InfiniteTableGeneratedGroupColumn<T>>;
368
- declare type InfiniteTableComputedPivotFinalColumn<T> = InfiniteTableComputedColumn<T> & InfiniteTablePivotFinalColumn<T>;
394
+ type InfiniteTableComputedColumn<T> = InfiniteTableColumn<T> & InfiniteTableComputedColumnBase<T> & Partial<InfiniteTablePivotFinalColumn<T>> & Partial<InfiniteTableGeneratedGroupColumn<T>>;
395
+ type InfiniteTableComputedPivotFinalColumn<T> = InfiniteTableComputedColumn<T> & InfiniteTablePivotFinalColumn<T>;
369
396
 
370
397
  interface LogFn {
371
398
  (...args: any[]): LogFn;
@@ -381,21 +408,21 @@ interface ScrollPosition {
381
408
  scrollTop: number;
382
409
  scrollLeft: number;
383
410
  }
384
- declare type OnScrollFn = (scrollPosition: ScrollPosition) => void;
411
+ type OnScrollFn = (scrollPosition: ScrollPosition) => void;
385
412
 
386
- declare type VoidFn = () => void;
413
+ type VoidFn = () => void;
387
414
 
388
- declare type FixedPosition = false | 'start' | 'end';
389
- declare type SpanFunction = ({ rowIndex, colIndex, }: {
415
+ type FixedPosition = false | 'start' | 'end';
416
+ type SpanFunction = ({ rowIndex, colIndex, }: {
390
417
  rowIndex: number;
391
418
  colIndex: number;
392
419
  }) => number;
393
- declare type RenderRangeType = {
420
+ type RenderRangeType = {
394
421
  startIndex: number;
395
422
  endIndex: number;
396
423
  };
397
- declare type ItemSizeFunction = (index: number) => number;
398
- declare type MatrixBrainOptions = {
424
+ type ItemSizeFunction = (index: number) => number;
425
+ type MatrixBrainOptions = {
399
426
  width: number;
400
427
  height: number;
401
428
  cols: number;
@@ -405,23 +432,23 @@ declare type MatrixBrainOptions = {
405
432
  rowspan?: SpanFunction;
406
433
  colspan?: SpanFunction;
407
434
  };
408
- declare type TableRenderRange = {
435
+ type TableRenderRange = {
409
436
  start: [number, number];
410
437
  end: [number, number];
411
438
  rowFixed?: FixedPosition;
412
439
  colFixed?: FixedPosition;
413
440
  };
414
- declare type WhichDirection = {
441
+ type WhichDirection = {
415
442
  horizontal?: boolean;
416
443
  vertical?: boolean;
417
444
  };
418
- declare type FnOnRenderRangeChange = (range: TableRenderRange) => void;
419
- declare type FnOnDirectionalRenderRangeChange = (range: [number, number]) => void;
420
- declare type FnOnRenderCountChange = ({ horizontal, vertical, }: {
445
+ type FnOnRenderRangeChange = (range: TableRenderRange) => void;
446
+ type FnOnDirectionalRenderRangeChange = (range: [number, number]) => void;
447
+ type FnOnRenderCountChange = ({ horizontal, vertical, }: {
421
448
  horizontal: number;
422
449
  vertical: number;
423
450
  }) => void;
424
- declare type OnAvailableSizeChange = (size: Size) => void;
451
+ type OnAvailableSizeChange = (size: Size) => void;
425
452
  declare class MatrixBrain extends Logger {
426
453
  private scrolling;
427
454
  private width;
@@ -643,8 +670,8 @@ declare class MatrixBrain extends Logger {
643
670
  destroy: () => void;
644
671
  }
645
672
 
646
- declare type RowSelectionStateItem = (any | any[])[];
647
- declare type RowSelectionStateObject = {
673
+ type RowSelectionStateItem = (any | any[])[];
674
+ type RowSelectionStateObject = {
648
675
  selectedRows: RowSelectionStateItem;
649
676
  deselectedRows: RowSelectionStateItem;
650
677
  defaultSelection: boolean;
@@ -657,7 +684,7 @@ declare type RowSelectionStateObject = {
657
684
  selectedRows: RowSelectionStateItem;
658
685
  deselectedRows?: RowSelectionStateItem;
659
686
  };
660
- declare type RowSelectionStateConfig<T> = {
687
+ type RowSelectionStateConfig<T> = {
661
688
  groupBy: DataSourceState<T>['groupBy'];
662
689
  groupDeepMap: DataSourceState<T>['groupDeepMap'];
663
690
  toPrimaryKey: DataSourceState<T>['toPrimaryKey'];
@@ -666,8 +693,8 @@ declare type RowSelectionStateConfig<T> = {
666
693
  lazyLoad: boolean;
667
694
  onlyUsePrimaryKeys: boolean;
668
695
  };
669
- declare type GetRowSelectionStateConfig<T> = () => RowSelectionStateConfig<T>;
670
- declare type RowSelectionStateOverride = {
696
+ type GetRowSelectionStateConfig<T> = () => RowSelectionStateConfig<T>;
697
+ type RowSelectionStateOverride = {
671
698
  getGroupKeysForPrimaryKey: RowSelectionState<any>['getGroupKeysForPrimaryKey'];
672
699
  getGroupByLength: RowSelectionState<any>['getGroupByLength'];
673
700
  getGroupCount: RowSelectionState<any>['getGroupCount'];
@@ -751,7 +778,7 @@ declare class RowSelectionState<T = any> {
751
778
  };
752
779
  }
753
780
 
754
- declare type MultiRowSelectorOptions = {
781
+ type MultiRowSelectorOptions = {
755
782
  getIdForIndex: (index: number) => string | number;
756
783
  };
757
784
  declare class MultiRowSelector {
@@ -808,7 +835,7 @@ interface InfiniteTableComputedValues<T> {
808
835
  columnSize: (colIndex: number) => number;
809
836
  }
810
837
 
811
- declare type TableRenderCellFnParam = {
838
+ type TableRenderCellFnParam = {
812
839
  domRef: RefCallback<HTMLElement>;
813
840
  rowIndex: number;
814
841
  colIndex: number;
@@ -824,7 +851,7 @@ declare type TableRenderCellFnParam = {
824
851
  onMouseEnter: VoidFunction;
825
852
  onMouseLeave: VoidFunction;
826
853
  };
827
- declare type TableRenderCellFn = (param: TableRenderCellFnParam) => Renderable;
854
+ type TableRenderCellFn = (param: TableRenderCellFnParam) => Renderable;
828
855
  declare class ReactHeadlessTableRenderer extends Logger {
829
856
  private brain;
830
857
  private destroyed;
@@ -900,36 +927,36 @@ declare class ReactHeadlessTableRenderer extends Logger {
900
927
  reset(): void;
901
928
  }
902
929
 
903
- declare type ComponentStateContext<T_STATE, T_ACTIONS> = {
930
+ type ComponentStateContext<T_STATE, T_ACTIONS> = {
904
931
  getComponentState: () => T_STATE;
905
932
  componentState: T_STATE;
906
933
  componentActions: T_ACTIONS;
907
934
  };
908
- declare type ComponentStateGeneratedActions<T_STATE> = {
935
+ type ComponentStateGeneratedActions<T_STATE> = {
909
936
  [k in keyof T_STATE]: T_STATE[k] | React.SetStateAction<T_STATE[k]>;
910
937
  };
911
- declare type ComponentInterceptedActions<T_STATE> = {
938
+ type ComponentInterceptedActions<T_STATE> = {
912
939
  [k in keyof T_STATE]?: (value: T_STATE[k], { actions, state, }: {
913
940
  actions: ComponentStateGeneratedActions<T_STATE>;
914
941
  state: T_STATE;
915
942
  }) => void | boolean;
916
943
  };
917
- declare type ComponentMappedCallbacks<T_STATE> = {
944
+ type ComponentMappedCallbacks<T_STATE> = {
918
945
  [k in keyof T_STATE]: (value: T_STATE[k], state: T_STATE) => {
919
946
  callbackName: string;
920
947
  callbackParams: any[];
921
948
  };
922
949
  };
923
- declare type ComponentStateActions<T_STATE> = ComponentStateGeneratedActions<T_STATE>;
950
+ type ComponentStateActions<T_STATE> = ComponentStateGeneratedActions<T_STATE>;
924
951
 
925
- declare type CellPosition = {
952
+ type CellPosition = {
926
953
  rowIndex: number;
927
954
  colIndex: number;
928
955
  };
929
956
 
930
- declare type NonUndefined<T> = T extends undefined ? never : T;
957
+ type NonUndefined<T> = T extends undefined ? never : T;
931
958
 
932
- declare type SubscriptionCallbackOnChangeFn<T> = (node: T | null) => void;
959
+ type SubscriptionCallbackOnChangeFn<T> = (node: T | null) => void;
933
960
  interface SubscriptionCallback<T> {
934
961
  (node: T, callback?: () => void): void;
935
962
  get: () => T | null;
@@ -985,9 +1012,9 @@ interface InfiniteTableSetupState<T> {
985
1012
  pinnedStartScrollListener: ScrollListener;
986
1013
  pinnedEndScrollListener: ScrollListener;
987
1014
  }
988
- declare type InfiniteTableColumnGroupsDepthsMap = Map<string, number>;
989
- declare type InfiniteTablePropPivotTotalColumnPosition = false | 'start' | 'end';
990
- declare type InfiniteTablePropPivotGrandTotalColumnPosition = InfiniteTablePropPivotTotalColumnPosition;
1015
+ type InfiniteTableColumnGroupsDepthsMap = Map<string, number>;
1016
+ type InfiniteTablePropPivotTotalColumnPosition = false | 'start' | 'end';
1017
+ type InfiniteTablePropPivotGrandTotalColumnPosition = InfiniteTablePropPivotTotalColumnPosition;
991
1018
  interface InfiniteTableMappedState<T> {
992
1019
  id: InfiniteTableProps<T>['id'];
993
1020
  scrollTopKey: InfiniteTableProps<T>['scrollTopKey'];
@@ -1070,7 +1097,7 @@ interface InfiniteTableDerivedState<T> {
1070
1097
  columnHeaderHeightCSSVar: string;
1071
1098
  controlledColumnVisibility: boolean;
1072
1099
  }
1073
- declare type InfiniteTableActions<T> = ComponentStateActions<InfiniteTableState<T>>;
1100
+ type InfiniteTableActions<T> = ComponentStateActions<InfiniteTableState<T>>;
1074
1101
  interface InfiniteTableState<T> extends InfiniteTableMappedState<T>, InfiniteTableDerivedState<T>, InfiniteTableSetupState<T> {
1075
1102
  }
1076
1103
 
@@ -1081,22 +1108,23 @@ interface InfiniteTableContextValue<T> {
1081
1108
  computed: InfiniteTableComputedValues<T>;
1082
1109
  getComputed: () => InfiniteTableComputedValues<T>;
1083
1110
  getState: () => InfiniteTableState<T>;
1111
+ getDataSourceState: () => DataSourceState<T>;
1084
1112
  }
1085
1113
 
1086
- declare type GroupKeyType$1<T extends any = any> = T;
1087
- declare type GroupBy<DataType, KeyType> = {
1114
+ type GroupKeyType$1<T extends any = any> = T;
1115
+ type GroupBy<DataType, KeyType> = {
1088
1116
  field: KeyOfNoSymbol<DataType>;
1089
1117
  toKey?: (value: any, data: DataType) => GroupKeyType$1<KeyType>;
1090
1118
  column?: Partial<InfiniteTableGroupColumnBase<DataType>>;
1091
1119
  };
1092
1120
 
1093
- declare type RenderRange = {
1121
+ type RenderRange = {
1094
1122
  renderStartIndex: number;
1095
1123
  renderEndIndex: number;
1096
1124
  };
1097
1125
 
1098
- declare type BooleanDeepCollectionStateKeys<KeyType> = true | KeyType[][];
1099
- declare type BooleanDeepCollectionStateObject<KeyType> = {
1126
+ type BooleanDeepCollectionStateKeys<KeyType> = true | KeyType[][];
1127
+ type BooleanDeepCollectionStateObject<KeyType> = {
1100
1128
  positiveItems: BooleanDeepCollectionStateKeys<KeyType>;
1101
1129
  negativeItems: BooleanDeepCollectionStateKeys<KeyType>;
1102
1130
  };
@@ -1166,16 +1194,16 @@ interface DataSourceDataParams<T> {
1166
1194
  __cursorId?: DataSourceSetupState<T>['cursorId'];
1167
1195
  changes?: DataSourceDataParamsChanges<T>;
1168
1196
  }
1169
- declare type DataSourceDataParamsChanges<T> = Partial<Record<keyof Omit<DataSourceDataParams<T>, 'originalDataArray' | 'changes'>, true>>;
1170
- declare type DataSourceSingleSortInfo<T> = Omit<MultisortInfo<T>, 'field'> & {
1197
+ type DataSourceDataParamsChanges<T> = Partial<Record<keyof Omit<DataSourceDataParams<T>, 'originalDataArray' | 'changes'>, true>>;
1198
+ type DataSourceSingleSortInfo<T> = Omit<MultisortInfo<T>, 'field'> & {
1171
1199
  field?: keyof T | (keyof T)[];
1172
1200
  id?: string;
1173
1201
  };
1174
- declare type DataSourceGroupBy<T> = GroupBy<T, any>;
1175
- declare type DataSourcePivotBy<T> = PivotBy<T, any>;
1176
- declare type DataSourceSortInfo<T> = null | DataSourceSingleSortInfo<T> | DataSourceSingleSortInfo<T>[];
1177
- declare type DataSourcePropSortInfo<T> = DataSourceSortInfo<T>;
1178
- declare type DataSourceRemoteData<T> = {
1202
+ type DataSourceGroupBy<T> = GroupBy<T, any>;
1203
+ type DataSourcePivotBy<T> = PivotBy<T, any>;
1204
+ type DataSourceSortInfo<T> = null | DataSourceSingleSortInfo<T> | DataSourceSingleSortInfo<T>[];
1205
+ type DataSourcePropSortInfo<T> = DataSourceSortInfo<T>;
1206
+ type DataSourceRemoteData<T> = {
1179
1207
  data: T[] | LazyGroupDataItem<T>[];
1180
1208
  mappings?: DataSourceMappings;
1181
1209
  cache?: boolean;
@@ -1184,14 +1212,14 @@ declare type DataSourceRemoteData<T> = {
1184
1212
  totalCountUnfiltered?: number;
1185
1213
  livePaginationCursor?: DataSourceLivePaginationCursorValue;
1186
1214
  };
1187
- declare type DataSourceData<T> = T[] | DataSourceRemoteData<T> | Promise<T[] | DataSourceRemoteData<T>> | ((dataInfo: DataSourceDataParams<T>) => T[] | Promise<T[] | DataSourceRemoteData<T>>);
1188
- declare type DataSourceGroupRowsList<KeyType> = true | KeyType[][];
1189
- declare type DataSourcePropGroupRowsStateObject<KeyType> = {
1215
+ type DataSourceData<T> = T[] | DataSourceRemoteData<T> | Promise<T[] | DataSourceRemoteData<T>> | ((dataInfo: DataSourceDataParams<T>) => T[] | Promise<T[] | DataSourceRemoteData<T>>);
1216
+ type DataSourceGroupRowsList<KeyType> = true | KeyType[][];
1217
+ type DataSourcePropGroupRowsStateObject<KeyType> = {
1190
1218
  expandedRows: DataSourceGroupRowsList<KeyType>;
1191
1219
  collapsedRows: DataSourceGroupRowsList<KeyType>;
1192
1220
  };
1193
- declare type DataSourcePropGroupBy<T> = DataSourceGroupBy<T>[];
1194
- declare type DataSourcePropPivotBy<T> = DataSourcePivotBy<T>[];
1221
+ type DataSourcePropGroupBy<T> = DataSourceGroupBy<T>[];
1222
+ type DataSourcePropPivotBy<T> = DataSourcePivotBy<T>[];
1195
1223
  interface DataSourceMappedState<T> {
1196
1224
  aggregationReducers?: DataSourceProps<T>['aggregationReducers'];
1197
1225
  livePagination: DataSourceProps<T>['livePagination'];
@@ -1214,7 +1242,7 @@ interface DataSourceMappedState<T> {
1214
1242
  collapseGroupRowsOnDataFunctionChange: NonUndefined<DataSourceProps<T>['collapseGroupRowsOnDataFunctionChange']>;
1215
1243
  sortInfo: DataSourceSingleSortInfo<T>[] | null;
1216
1244
  }
1217
- declare type DataSourceAggregationReducer<T, AggregationResultType> = {
1245
+ type DataSourceAggregationReducer<T, AggregationResultType> = {
1218
1246
  name?: string;
1219
1247
  field?: keyof T;
1220
1248
  initialValue?: AggregationResultType;
@@ -1225,11 +1253,11 @@ declare type DataSourceAggregationReducer<T, AggregationResultType> = {
1225
1253
  column: InfiniteTablePivotFinalColumnVariant<T>;
1226
1254
  }) => ColumnTypeWithInherit<Partial<InfiniteTablePivotColumn<T>>>);
1227
1255
  };
1228
- declare type ColumnTypeWithInherit<COL_TYPE> = COL_TYPE & {
1256
+ type ColumnTypeWithInherit<COL_TYPE> = COL_TYPE & {
1229
1257
  inheritFromColumn?: string | boolean;
1230
1258
  };
1231
- declare type DataSourceMappings = Record<'totals' | 'values', string>;
1232
- declare type LazyGroupDataItem<DataType> = {
1259
+ type DataSourceMappings = Record<'totals' | 'values', string>;
1260
+ type LazyGroupDataItem<DataType> = {
1233
1261
  data: Partial<DataType>;
1234
1262
  keys: any[];
1235
1263
  aggregations?: Record<string, any>;
@@ -1240,7 +1268,7 @@ declare type LazyGroupDataItem<DataType> = {
1240
1268
  totals?: Record<string, any>;
1241
1269
  };
1242
1270
  };
1243
- declare type LazyRowInfoGroup<DataType> = {
1271
+ type LazyRowInfoGroup<DataType> = {
1244
1272
  /**
1245
1273
  * Those are direct children of the current lazy group row
1246
1274
  */
@@ -1252,7 +1280,7 @@ declare type LazyRowInfoGroup<DataType> = {
1252
1280
  totalCountUnfiltered: number;
1253
1281
  error?: string;
1254
1282
  };
1255
- declare type LazyGroupDataDeepMap<DataType, KeyType = string> = DeepMap<KeyType, LazyRowInfoGroup<DataType>>;
1283
+ type LazyGroupDataDeepMap<DataType, KeyType = string> = DeepMap<KeyType, LazyRowInfoGroup<DataType>>;
1256
1284
  interface DataSourceSetupState<T> {
1257
1285
  indexer: Indexer<T, any>;
1258
1286
  unfilteredCount: number;
@@ -1295,19 +1323,19 @@ interface DataSourceSetupState<T> {
1295
1323
  pivotColumns?: Map<string, InfiniteTableColumn<T>>;
1296
1324
  pivotColumnGroups?: Map<string, InfiniteTableColumnGroup>;
1297
1325
  }
1298
- declare type DataSourcePropAggregationReducers<T> = Record<string, DataSourceAggregationReducer<T, any>>;
1299
- declare type DataSourcePropMultiRowSelectionChangeParamType = RowSelectionStateObject;
1300
- declare type DataSourcePropRowSelection = DataSourcePropRowSelection_MultiRow | DataSourcePropRowSelection_SingleRow;
1301
- declare type DataSourcePropRowSelection_MultiRow = RowSelectionStateObject;
1302
- declare type DataSourcePropRowSelection_SingleRow = null | string | number;
1303
- declare type DataSourcePropCellSelection = any;
1304
- declare type DataSourcePropSelectionMode = false | 'single-cell' | 'single-row' | 'multi-cell' | 'multi-row';
1305
- declare type DataSourcePropOnRowSelectionChange_MultiRow = (rowSelection: DataSourcePropRowSelection_MultiRow, selectionMode: 'multi-row') => void;
1306
- declare type DataSourcePropOnRowSelectionChange_SingleRow = (rowSelection: DataSourcePropRowSelection_SingleRow, selectionMode: 'single-row') => void;
1307
- declare type DataSourcePropOnRowSelectionChange = DataSourcePropOnRowSelectionChange_SingleRow | DataSourcePropOnRowSelectionChange_MultiRow;
1308
- declare type DataSourcePropOnCellSelectionChange = (cellSelectionParams: any) => void;
1309
- declare type DataSourcePropIsRowSelected<T> = (rowInfo: InfiniteTableRowInfo<T>, rowSelectionState: RowSelectionState, selectionMode: 'multi-row') => boolean | null;
1310
- declare type DataSourceProps<T> = {
1326
+ type DataSourcePropAggregationReducers<T> = Record<string, DataSourceAggregationReducer<T, any>>;
1327
+ type DataSourcePropMultiRowSelectionChangeParamType = RowSelectionStateObject;
1328
+ type DataSourcePropRowSelection = DataSourcePropRowSelection_MultiRow | DataSourcePropRowSelection_SingleRow;
1329
+ type DataSourcePropRowSelection_MultiRow = RowSelectionStateObject;
1330
+ type DataSourcePropRowSelection_SingleRow = null | string | number;
1331
+ type DataSourcePropCellSelection = any;
1332
+ type DataSourcePropSelectionMode = false | 'single-cell' | 'single-row' | 'multi-cell' | 'multi-row';
1333
+ type DataSourcePropOnRowSelectionChange_MultiRow = (rowSelection: DataSourcePropRowSelection_MultiRow, selectionMode: 'multi-row') => void;
1334
+ type DataSourcePropOnRowSelectionChange_SingleRow = (rowSelection: DataSourcePropRowSelection_SingleRow, selectionMode: 'single-row') => void;
1335
+ type DataSourcePropOnRowSelectionChange = DataSourcePropOnRowSelectionChange_SingleRow | DataSourcePropOnRowSelectionChange_MultiRow;
1336
+ type DataSourcePropOnCellSelectionChange = (cellSelectionParams: any) => void;
1337
+ type DataSourcePropIsRowSelected<T> = (rowInfo: InfiniteTableRowInfo<T>, rowSelectionState: RowSelectionState, selectionMode: 'multi-row') => boolean | null;
1338
+ type DataSourceProps<T> = {
1311
1339
  children: React$1.ReactNode | ((contextData: DataSourceState<T>) => React$1.ReactNode);
1312
1340
  primaryKey: keyof T | ((data: T) => string);
1313
1341
  fields?: (keyof T)[];
@@ -1372,17 +1400,17 @@ declare type DataSourceProps<T> = {
1372
1400
  } | {
1373
1401
  selectionMode?: false;
1374
1402
  });
1375
- declare type DataSourcePropSortTypes = Record<string, (first: any, second: any) => number>;
1376
- declare type DataSourcePropFilterTypes<T> = Record<string, DataSourceFilterType<T>>;
1377
- declare type DataSourceFilterFunctionParam<T> = {
1403
+ type DataSourcePropSortTypes = Record<string, (first: any, second: any) => number>;
1404
+ type DataSourcePropFilterTypes<T> = Record<string, DataSourceFilterType<T>>;
1405
+ type DataSourceFilterFunctionParam<T> = {
1378
1406
  data: T;
1379
1407
  index: number;
1380
1408
  dataArray: T[];
1381
1409
  primaryKey: any;
1382
1410
  };
1383
- declare type DataSourcePropFilterFunction<T> = (filterParam: DataSourceFilterFunctionParam<T>) => boolean;
1384
- declare type DataSourcePropFilterValue<T> = DataSourceFilterValueItem<T>[];
1385
- declare type DataSourceFilterValueItem<T> = DiscriminatedUnion<{
1411
+ type DataSourcePropFilterFunction<T> = (filterParam: DataSourceFilterFunctionParam<T>) => boolean;
1412
+ type DataSourcePropFilterValue<T> = DataSourceFilterValueItem<T>[];
1413
+ type DataSourceFilterValueItem<T> = DiscriminatedUnion<{
1386
1414
  field: keyof T;
1387
1415
  }, {
1388
1416
  id: string;
@@ -1393,35 +1421,35 @@ declare type DataSourceFilterValueItem<T> = DiscriminatedUnion<{
1393
1421
  filterType: string;
1394
1422
  operator: string;
1395
1423
  };
1396
- declare type DataSourceFilterValueItemValueGetter<T> = (param: DataSourceFilterFunctionParam<T>) => any;
1397
- declare type DataSourceFilterType<T> = {
1424
+ type DataSourceFilterValueItemValueGetter<T> = (param: DataSourceFilterFunctionParam<T>) => any;
1425
+ type DataSourceFilterType<T> = {
1398
1426
  emptyValues: Set<any>;
1399
1427
  label?: string;
1400
1428
  defaultOperator: string;
1401
1429
  operators: DataSourceFilterOperator<T>[];
1402
1430
  };
1403
- declare type DataSourceFilterOperator<T> = {
1431
+ type DataSourceFilterOperator<T> = {
1404
1432
  name: string;
1405
1433
  label?: string;
1406
1434
  fn: DataSourceFilterOperatorFunction<T>;
1407
1435
  };
1408
- declare type DataSourceFilterOperatorFunction<T> = (filterOperatorFunctionParam: DataSourceFilterOperatorFunctionParam<T>) => boolean;
1409
- declare type DataSourceFilterOperatorFunctionParam<T> = {
1436
+ type DataSourceFilterOperatorFunction<T> = (filterOperatorFunctionParam: DataSourceFilterOperatorFunctionParam<T>) => boolean;
1437
+ type DataSourceFilterOperatorFunctionParam<T> = {
1410
1438
  currentValue: any;
1411
1439
  filterValue: any;
1412
1440
  emptyValues: Set<any>;
1413
1441
  } & DataSourceFilterFunctionParam<T>;
1414
- declare type DataSourcePropLivePaginationCursor<T> = DataSourceLivePaginationCursorValue | DataSourceLivePaginationCursorFn<T>;
1415
- declare type DataSourceLivePaginationCursorFn<T> = (params: DataSourceLivePaginationCursorParams<T>) => DataSourceLivePaginationCursorValue;
1416
- declare type DataSourceLivePaginationCursorParams<T> = {
1442
+ type DataSourcePropLivePaginationCursor<T> = DataSourceLivePaginationCursorValue | DataSourceLivePaginationCursorFn<T>;
1443
+ type DataSourceLivePaginationCursorFn<T> = (params: DataSourceLivePaginationCursorParams<T>) => DataSourceLivePaginationCursorValue;
1444
+ type DataSourceLivePaginationCursorParams<T> = {
1417
1445
  array: T[];
1418
1446
  lastItem: T | Partial<T> | null;
1419
1447
  length: number;
1420
1448
  };
1421
- declare type DataSourceLivePaginationCursorValue = string | number | null;
1449
+ type DataSourceLivePaginationCursorValue = string | number | null;
1422
1450
  interface DataSourceState<T> extends DataSourceSetupState<T>, DataSourceDerivedState<T>, DataSourceMappedState<T> {
1423
1451
  }
1424
- declare type DataSourceDerivedState<T> = {
1452
+ type DataSourceDerivedState<T> = {
1425
1453
  toPrimaryKey: (data: T) => any;
1426
1454
  operatorsByFilterType: Record<string, Record<string, DataSourceFilterOperator<T>>>;
1427
1455
  filterMode: NonUndefined<DataSourceProps<T>['filterMode']>;
@@ -1434,7 +1462,7 @@ declare type DataSourceDerivedState<T> = {
1434
1462
  rowSelection: RowSelectionState | null | number | string;
1435
1463
  selectionMode: NonUndefined<DataSourceProps<T>['selectionMode']>;
1436
1464
  };
1437
- declare type DataSourceComponentActions<T> = ComponentStateActions<DataSourceState<T>>;
1465
+ type DataSourceComponentActions<T> = ComponentStateActions<DataSourceState<T>>;
1438
1466
  interface DataSourceContextValue<T> {
1439
1467
  getState: () => DataSourceState<T>;
1440
1468
  componentState: DataSourceState<T>;
@@ -1457,10 +1485,10 @@ declare function useDataSource<T>(): DataSourceState<T>;
1457
1485
 
1458
1486
  declare function DataSource<T>(props: DataSourceProps<T>): JSX.Element;
1459
1487
 
1460
- declare type AggregationReducer<T, AggregationResultType = any> = DataSourceAggregationReducer<T, AggregationResultType> & {
1488
+ type AggregationReducer<T, AggregationResultType = any> = DataSourceAggregationReducer<T, AggregationResultType> & {
1461
1489
  id: string;
1462
1490
  };
1463
- declare type AggregationReducerResult<AggregationResultType extends any = any> = AggregationResultType;
1491
+ type AggregationReducerResult<AggregationResultType extends any = any> = AggregationResultType;
1464
1492
  /**
1465
1493
  * InfiniteTableRowInfo can have different object shape depending on the presence or absence of grouping.
1466
1494
  *
@@ -1469,8 +1497,8 @@ declare type AggregationReducerResult<AggregationResultType extends any = any> =
1469
1497
  * you can use `isGroupRow: boolean` to discriminate between group rows vs normal rows.
1470
1498
  *
1471
1499
  */
1472
- declare type InfiniteTableRowInfo<T> = InfiniteTable_HasGrouping_RowInfoNormal<T> | InfiniteTable_HasGrouping_RowInfoGroup<T> | InfiniteTable_NoGrouping_RowInfoNormal<T>;
1473
- declare type InfiniteTableRowInfoDataDiscriminator_RowInfoNormal<T> = {
1500
+ type InfiniteTableRowInfo<T> = InfiniteTable_HasGrouping_RowInfoNormal<T> | InfiniteTable_HasGrouping_RowInfoGroup<T> | InfiniteTable_NoGrouping_RowInfoNormal<T>;
1501
+ type InfiniteTableRowInfoDataDiscriminator_RowInfoNormal<T> = {
1474
1502
  data: T;
1475
1503
  isGroupRow: false;
1476
1504
  rowActive: boolean;
@@ -1479,7 +1507,7 @@ declare type InfiniteTableRowInfoDataDiscriminator_RowInfoNormal<T> = {
1479
1507
  value: any;
1480
1508
  rowSelected: boolean | null;
1481
1509
  };
1482
- declare type InfiniteTableRowInfoDataDiscriminator_RowInfoGroup<T> = {
1510
+ type InfiniteTableRowInfoDataDiscriminator_RowInfoGroup<T> = {
1483
1511
  rowActive: boolean;
1484
1512
  data: Partial<T> | null;
1485
1513
  rowInfo: InfiniteTable_HasGrouping_RowInfoGroup<T>;
@@ -1488,24 +1516,24 @@ declare type InfiniteTableRowInfoDataDiscriminator_RowInfoGroup<T> = {
1488
1516
  value: any;
1489
1517
  rowSelected: boolean | null;
1490
1518
  };
1491
- declare type InfiniteTableRowInfoDataDiscriminator<T> = InfiniteTableRowInfoDataDiscriminator_RowInfoNormal<T> | InfiniteTableRowInfoDataDiscriminator_RowInfoGroup<T>;
1519
+ type InfiniteTableRowInfoDataDiscriminator<T> = InfiniteTableRowInfoDataDiscriminator_RowInfoNormal<T> | InfiniteTableRowInfoDataDiscriminator_RowInfoGroup<T>;
1492
1520
  /**
1493
1521
  * This is the base row info for all scenarios - things every
1494
1522
  * rowInfo is guaranteed to have (be it group or normal row, or dataSource with or without grouping)
1495
1523
  *
1496
1524
  */
1497
- declare type InfiniteTable_RowInfoBase<_T> = {
1525
+ type InfiniteTable_RowInfoBase<_T> = {
1498
1526
  id: any;
1499
1527
  value?: any;
1500
1528
  indexInAll: number;
1501
1529
  rowSelected: boolean | null;
1502
1530
  };
1503
- declare type InfiniteTable_HasGrouping_RowInfoNormal<T> = {
1531
+ type InfiniteTable_HasGrouping_RowInfoNormal<T> = {
1504
1532
  dataSourceHasGrouping: true;
1505
1533
  data: T;
1506
1534
  isGroupRow: false;
1507
1535
  } & InfiniteTable_HasGrouping_RowInfoBase<T> & InfiniteTable_RowInfoBase<T>;
1508
- declare type InfiniteTable_HasGrouping_RowInfoGroup<T> = {
1536
+ type InfiniteTable_HasGrouping_RowInfoGroup<T> = {
1509
1537
  dataSourceHasGrouping: true;
1510
1538
  data: Partial<T> | null;
1511
1539
  isGroupRow: true;
@@ -1583,13 +1611,13 @@ declare type InfiniteTable_HasGrouping_RowInfoGroup<T> = {
1583
1611
  */
1584
1612
  childrenLoading: boolean;
1585
1613
  } & InfiniteTable_HasGrouping_RowInfoBase<T> & InfiniteTable_RowInfoBase<T>;
1586
- declare type InfiniteTable_NoGrouping_RowInfoNormal<T> = {
1614
+ type InfiniteTable_NoGrouping_RowInfoNormal<T> = {
1587
1615
  dataSourceHasGrouping: false;
1588
1616
  data: T;
1589
1617
  isGroupRow: false;
1590
1618
  selfLoaded: boolean;
1591
1619
  } & InfiniteTable_RowInfoBase<T>;
1592
- declare type InfiniteTable_HasGrouping_RowInfoBase<T> = {
1620
+ type InfiniteTable_HasGrouping_RowInfoBase<T> = {
1593
1621
  indexInGroup: number;
1594
1622
  /**
1595
1623
  * Available on all rowInfo objects when the datasource is grouped, otherwise, it will be undefined.
@@ -1677,14 +1705,14 @@ declare type InfiniteTable_HasGrouping_RowInfoBase<T> = {
1677
1705
  */
1678
1706
  selfLoaded: boolean;
1679
1707
  };
1680
- declare type GroupKeyType<T extends any = any> = T;
1681
- declare type PivotReducerResults<T = any> = Record<string, AggregationReducerResult<T>>;
1682
- declare type PivotGroupValueType<DataType, KeyType> = {
1708
+ type GroupKeyType<T extends any = any> = T;
1709
+ type PivotReducerResults<T = any> = Record<string, AggregationReducerResult<T>>;
1710
+ type PivotGroupValueType<DataType, KeyType> = {
1683
1711
  reducerResults: PivotReducerResults<KeyType>;
1684
1712
  items: DataType[];
1685
1713
  };
1686
- declare type PivotValuesDeepMap<DataType, KeyType> = DeepMap<GroupKeyType<KeyType>, PivotGroupValueType<DataType, KeyType>>;
1687
- declare type DeepMapGroupValueType<DataType, KeyType> = {
1714
+ type PivotValuesDeepMap<DataType, KeyType> = DeepMap<GroupKeyType<KeyType>, PivotGroupValueType<DataType, KeyType>>;
1715
+ type DeepMapGroupValueType<DataType, KeyType> = {
1688
1716
  /**
1689
1717
  * These are leaf items. This array may be empty when there is batched lazy loading
1690
1718
  */
@@ -1698,7 +1726,7 @@ declare type DeepMapGroupValueType<DataType, KeyType> = {
1698
1726
  reducerResults: Record<string, AggregationReducerResult>;
1699
1727
  pivotDeepMap?: DeepMap<GroupKeyType<KeyType>, PivotGroupValueType<DataType, KeyType>>;
1700
1728
  };
1701
- declare type PivotBy<DataType, KeyType> = Omit<GroupBy<DataType, KeyType>, 'column'> & {
1729
+ type PivotBy<DataType, KeyType> = Omit<GroupBy<DataType, KeyType>, 'column'> & {
1702
1730
  column?: ColumnTypeWithInherit<Partial<InfiniteTableColumn<DataType>>> | (({ column, }: {
1703
1731
  column: InfiniteTablePivotFinalColumnVariant<DataType, KeyType>;
1704
1732
  }) => Partial<InfiniteTablePivotColumn<DataType>>);
@@ -1706,13 +1734,13 @@ declare type PivotBy<DataType, KeyType> = Omit<GroupBy<DataType, KeyType>, 'colu
1706
1734
  columnGroup: InfiniteTablePivotFinalColumnGroup<DataType, KeyType>;
1707
1735
  }) => ColumnTypeWithInherit<Partial<InfiniteTablePivotFinalColumnGroup<DataType>>>);
1708
1736
  };
1709
- declare type GroupParams<DataType, KeyType> = {
1737
+ type GroupParams<DataType, KeyType> = {
1710
1738
  groupBy: GroupBy<DataType, KeyType>[];
1711
1739
  defaultToKey?: (value: any, item: DataType) => GroupKeyType<KeyType>;
1712
1740
  pivot?: PivotBy<DataType, KeyType>[];
1713
1741
  reducers?: Record<string, DataSourceAggregationReducer<DataType, any>>;
1714
1742
  };
1715
- declare type DataGroupResult<DataType, KeyType extends any> = {
1743
+ type DataGroupResult<DataType, KeyType extends any> = {
1716
1744
  deepMap: DeepMap<GroupKeyType<KeyType>, DeepMapGroupValueType<DataType, KeyType>>;
1717
1745
  groupParams: GroupParams<DataType, KeyType>;
1718
1746
  initialData: DataType[];
@@ -1723,8 +1751,8 @@ declare type DataGroupResult<DataType, KeyType extends any> = {
1723
1751
  declare function group<DataType, KeyType = any>(groupParams: GroupParams<DataType, KeyType>, data: DataType[]): DataGroupResult<DataType, KeyType>;
1724
1752
  declare function flatten<DataType, KeyType extends any>(groupResult: DataGroupResult<DataType, KeyType>): DataType[];
1725
1753
 
1726
- declare type InfiniteCheckBoxPropChecked = true | false | null;
1727
- declare type InfiniteCheckBoxProps = {
1754
+ type InfiniteCheckBoxPropChecked = true | false | null;
1755
+ type InfiniteCheckBoxProps = {
1728
1756
  disabled?: boolean;
1729
1757
  checked?: InfiniteCheckBoxPropChecked;
1730
1758
  defaultChecked?: InfiniteCheckBoxPropChecked;
@@ -1733,8 +1761,8 @@ declare type InfiniteCheckBoxProps = {
1733
1761
  };
1734
1762
  declare function InfiniteCheckBox(props: InfiniteCheckBoxProps): JSX.Element;
1735
1763
 
1736
- declare type ArrayOfIds = Pick<InfiniteTable_RowInfoBase<any>, 'id'>[];
1737
- declare type InfiniteTableSelectionApi = {
1764
+ type ArrayOfIds = Pick<InfiniteTable_RowInfoBase<any>, 'id'>[];
1765
+ type InfiniteTableSelectionApi = {
1738
1766
  get allRowsSelected(): boolean;
1739
1767
  isRowSelected(pk: any, groupKeys?: any[]): boolean;
1740
1768
  isRowDeselected(pk: any, groupKeys?: any[]): boolean;
@@ -1750,41 +1778,41 @@ declare type InfiniteTableSelectionApi = {
1750
1778
  deselectAll(): void;
1751
1779
  };
1752
1780
 
1753
- declare type PointCoords = {
1781
+ type PointCoords = {
1754
1782
  top: number;
1755
1783
  left: number;
1756
1784
  };
1757
1785
 
1758
- declare type CoordsWithSize = {
1786
+ type CoordsWithSize = {
1759
1787
  width: number;
1760
1788
  height: number;
1761
1789
  left: number;
1762
1790
  top: number;
1763
1791
  };
1764
- declare type CoordsNoSize = {
1792
+ type CoordsNoSize = {
1765
1793
  right: number;
1766
1794
  bottom: number;
1767
1795
  left: number;
1768
1796
  top: number;
1769
1797
  };
1770
- declare type RectangleCoords = CoordsWithSize | CoordsNoSize;
1798
+ type RectangleCoords = CoordsWithSize | CoordsNoSize;
1771
1799
 
1772
- declare type Alignable = RectangleCoords | HTMLElement | DOMRect;
1773
- declare type AlignPositionEnum = 'TopLeft' | 'TopCenter' | 'TopRight' | 'CenterRight' | 'BottomRight' | 'BottomCenter' | 'BottomLeft' | 'CenterLeft' | 'Center';
1774
- declare type AlignPositionItem = [AlignPositionEnum, AlignPositionEnum];
1775
- declare type AlignPositionOptions = {
1800
+ type Alignable = RectangleCoords | HTMLElement | DOMRect;
1801
+ type AlignPositionEnum = 'TopLeft' | 'TopCenter' | 'TopRight' | 'CenterRight' | 'BottomRight' | 'BottomCenter' | 'BottomLeft' | 'CenterLeft' | 'Center';
1802
+ type AlignPositionItem = [AlignPositionEnum, AlignPositionEnum];
1803
+ type AlignPositionOptions = {
1776
1804
  alignPosition: AlignPositionItem[];
1777
1805
  constrainTo?: Alignable;
1778
1806
  alignAnchor: Alignable;
1779
1807
  alignTarget: Alignable;
1780
1808
  };
1781
1809
 
1782
- declare type OverlayParams = {
1810
+ type OverlayParams = {
1783
1811
  portalContainer?: ElementContainerGetter | null | false;
1784
1812
  constrainTo?: OverlayShowParams['constrainTo'];
1785
1813
  };
1786
- declare type ElementContainerGetter = (() => HTMLElement | string | Promise<HTMLElement | string>) | string | HTMLElement | Promise<HTMLElement | string>;
1787
- declare type AdvancedAlignable = Alignable | ElementContainerGetter;
1814
+ type ElementContainerGetter = (() => HTMLElement | string | Promise<HTMLElement | string>) | string | HTMLElement | Promise<HTMLElement | string>;
1815
+ type AdvancedAlignable = Alignable | ElementContainerGetter;
1788
1816
  /**
1789
1817
  * If portal container is given, it will create a React portal from that element
1790
1818
  * otherwise it will simply render another node as portal
@@ -1792,7 +1820,7 @@ declare type AdvancedAlignable = Alignable | ElementContainerGetter;
1792
1820
  * @param portalContainer
1793
1821
  */
1794
1822
  declare function useOverlayPortal(content: ReactNode, portalContainer?: ElementContainerGetter | null | false): string | number | boolean | JSX.Element | React$1.ReactFragment | null | undefined;
1795
- declare type OverlayShowParams = {
1823
+ type OverlayShowParams = {
1796
1824
  id?: string | number;
1797
1825
  constrainTo?: AdvancedAlignable | boolean;
1798
1826
  alignPosition: AlignPositionOptions['alignPosition'];
@@ -1821,9 +1849,9 @@ we don't want to allow the above `y` as a valid declaration
1821
1849
  it breaks some types in the Menu component as well
1822
1850
 
1823
1851
  */
1824
- declare type RemoveObject<T> = T extends null | undefined ? T : T extends unknown ? keyof T extends never ? never : T : never;
1852
+ type RemoveObject<T> = T extends null | undefined ? T : T extends unknown ? keyof T extends never ? never : T : never;
1825
1853
 
1826
- declare type MenuSetupState = {
1854
+ type MenuSetupState = {
1827
1855
  domRef: MutableRefObject<HTMLDivElement | null>;
1828
1856
  keyboardActiveItemKey: string | null;
1829
1857
  activeItemKey: string | null;
@@ -1831,13 +1859,13 @@ declare type MenuSetupState = {
1831
1859
  focused: boolean;
1832
1860
  destroyed: boolean;
1833
1861
  };
1834
- declare type MenuDerivedState = {
1862
+ type MenuDerivedState = {
1835
1863
  runtimeItems: MenuRuntimeItem[];
1836
1864
  runtimeSelectableItems: MenuRuntimeItemSelectable[];
1837
1865
  columns: MenuColumn[];
1838
1866
  menuId: string;
1839
1867
  };
1840
- declare type MenuMappedState = {
1868
+ type MenuMappedState = {
1841
1869
  parentMenuId: MenuProps['parentMenuId'];
1842
1870
  parentMenuItemKey: MenuProps['parentMenuItemKey'];
1843
1871
  constrainTo: MenuProps['constrainTo'];
@@ -1850,14 +1878,14 @@ declare type MenuMappedState = {
1850
1878
  };
1851
1879
  interface MenuState extends MenuMappedState, MenuDerivedState, MenuSetupState {
1852
1880
  }
1853
- declare type MenuApi = {
1881
+ type MenuApi = {
1854
1882
  focus: VoidFunction;
1855
1883
  getMenuId: () => string;
1856
1884
  getParentMenuId: () => string | undefined;
1857
1885
  };
1858
1886
 
1859
- declare type MenuRenderable = string | number | RemoveObject<Renderable>;
1860
- declare type MenuRuntimeItemSelectable = {
1887
+ type MenuRenderable = string | number | RemoveObject<Renderable>;
1888
+ type MenuRuntimeItemSelectable = {
1861
1889
  type: 'item';
1862
1890
  key: string;
1863
1891
  parentMenuId: string;
@@ -1871,18 +1899,18 @@ declare type MenuRuntimeItemSelectable = {
1871
1899
  menu: MenuProps | (() => MenuProps) | null;
1872
1900
  originalMenuItem: MenuItemObject;
1873
1901
  };
1874
- declare type MenuRuntimeItem = MenuRuntimeItemSelectable | {
1902
+ type MenuRuntimeItem = MenuRuntimeItemSelectable | {
1875
1903
  type: 'decoration';
1876
1904
  value: MenuDecoration;
1877
1905
  style: CSSProperties;
1878
1906
  span: number;
1879
1907
  };
1880
- declare type MenuChildrenFnParam = {
1908
+ type MenuChildrenFnParam = {
1881
1909
  item: MenuRuntimeItem;
1882
1910
  column: MenuColumn;
1883
1911
  columns: MenuColumn[];
1884
1912
  };
1885
- declare type MenuProps = {
1913
+ type MenuProps = {
1886
1914
  id?: string;
1887
1915
  portalContainer?: ElementContainerGetter | false | null;
1888
1916
  items?: MenuItemDefinition[];
@@ -1900,12 +1928,12 @@ declare type MenuProps = {
1900
1928
  parentMenuItemKey?: string;
1901
1929
  autoFocus?: boolean;
1902
1930
  };
1903
- declare type MenuSeparator = '-';
1904
- declare type MenuItemDefinition = MenuItemObject | MenuDecoration | MenuSeparator;
1905
- declare type MenuItemSubMenu = Omit<MenuProps, 'children' | 'items'> & {
1931
+ type MenuSeparator = '-';
1932
+ type MenuItemDefinition = MenuItemObject | MenuDecoration | MenuSeparator;
1933
+ type MenuItemSubMenu = Omit<MenuProps, 'children' | 'items'> & {
1906
1934
  items: (MenuItemObject | MenuSeparator)[];
1907
1935
  };
1908
- declare type MenuItemObject = {
1936
+ type MenuItemObject = {
1909
1937
  key: string;
1910
1938
  label: NonUndefined<MenuRenderable>;
1911
1939
  span?: number;
@@ -1918,8 +1946,8 @@ declare type MenuItemObject = {
1918
1946
  onAction?: (key: string, item: MenuItemObject) => void;
1919
1947
  [k: string]: any;
1920
1948
  };
1921
- declare type MenuDecoration = MenuRenderable;
1922
- declare type MenuColumn = {
1949
+ type MenuDecoration = MenuRenderable;
1950
+ type MenuColumn = {
1923
1951
  flex?: number;
1924
1952
  width?: string | number;
1925
1953
  style?: CSSProperties;
@@ -1927,14 +1955,14 @@ declare type MenuColumn = {
1927
1955
  field?: string;
1928
1956
  render?: (param: MenuColumnRenderParam) => MenuRenderable;
1929
1957
  };
1930
- declare type MenuColumnRenderParam = {
1958
+ type MenuColumnRenderParam = {
1931
1959
  item: MenuItemObject;
1932
1960
  column: MenuColumn;
1933
1961
  value: MenuRenderable;
1934
1962
  domProps: HTMLProps<HTMLDivElement>;
1935
1963
  };
1936
1964
 
1937
- declare type InfiniteTableEventHandlerContext<T> = {
1965
+ type InfiniteTableEventHandlerContext<T> = {
1938
1966
  getComputed: () => InfiniteTableComputedValues<T>;
1939
1967
  getState: () => InfiniteTableState<T>;
1940
1968
  actions: InfiniteTableActions<T>;
@@ -1943,35 +1971,35 @@ declare type InfiniteTableEventHandlerContext<T> = {
1943
1971
  dataSourceActions: DataSourceComponentActions<T>;
1944
1972
  api: InfiniteTableApi<T>;
1945
1973
  };
1946
- declare type InfiniteTableKeyboardEventHandlerContext<T> = InfiniteTableEventHandlerContext<T>;
1947
- declare type InfiniteTableCellClickEventHandlerContext<T> = InfiniteTableEventHandlerContext<T> & {
1974
+ type InfiniteTableKeyboardEventHandlerContext<T> = InfiniteTableEventHandlerContext<T>;
1975
+ type InfiniteTableCellClickEventHandlerContext<T> = InfiniteTableEventHandlerContext<T> & {
1948
1976
  rowIndex: number;
1949
1977
  colIndex: number;
1950
1978
  };
1951
1979
 
1952
- declare type OnCellClickContext<T> = InfiniteTableCellClickEventHandlerContext<T> & InfiniteTableKeyboardEventHandlerContext<T>;
1980
+ type OnCellClickContext<T> = InfiniteTableCellClickEventHandlerContext<T> & InfiniteTableKeyboardEventHandlerContext<T>;
1953
1981
 
1954
- declare type LoadMaskProps = {
1982
+ type LoadMaskProps = {
1955
1983
  visible: boolean;
1956
1984
  children: Renderable;
1957
1985
  };
1958
- declare type InfiniteTablePropColumnOrderNormalized = string[];
1959
- declare type InfiniteTablePropColumnOrder = InfiniteTablePropColumnOrderNormalized | true;
1960
- declare type InfiniteTablePropColumnVisibility = Record<string, false>;
1961
- declare type InfiniteTableColumnPinnedValues = false | 'start' | 'end';
1962
- declare type InfiniteTablePropColumnPinning = Record<string, true | 'start' | 'end'>;
1963
- declare type InfiniteTableRowStyleFnParams<T> = {
1986
+ type InfiniteTablePropColumnOrderNormalized = string[];
1987
+ type InfiniteTablePropColumnOrder = InfiniteTablePropColumnOrderNormalized | true;
1988
+ type InfiniteTablePropColumnVisibility = Record<string, false>;
1989
+ type InfiniteTableColumnPinnedValues = false | 'start' | 'end';
1990
+ type InfiniteTablePropColumnPinning = Record<string, true | 'start' | 'end'>;
1991
+ type InfiniteTableRowStyleFnParams<T> = {
1964
1992
  rowIndex: number;
1965
1993
  } & InfiniteTableRowInfoDataDiscriminator<T>;
1966
- declare type InfiniteTableRowStyleFn<T> = (params: InfiniteTableRowStyleFnParams<T>) => undefined | React$1.CSSProperties;
1967
- declare type InfiniteTableRowClassNameFn<T> = (params: InfiniteTableRowStyleFnParams<T>) => string | undefined;
1968
- declare type InfiniteTablePropRowStyle<T> = React$1.CSSProperties | InfiniteTableRowStyleFn<T>;
1969
- declare type InfiniteTablePropRowClassName<T> = string | InfiniteTableRowClassNameFn<T>;
1970
- declare type InfiniteTableColumnAggregator<T, AggregationResultType> = Omit<AggregationReducer<T, AggregationResultType>, 'getter' | 'id'> & {
1994
+ type InfiniteTableRowStyleFn<T> = (params: InfiniteTableRowStyleFnParams<T>) => undefined | React$1.CSSProperties;
1995
+ type InfiniteTableRowClassNameFn<T> = (params: InfiniteTableRowStyleFnParams<T>) => string | undefined;
1996
+ type InfiniteTablePropRowStyle<T> = React$1.CSSProperties | InfiniteTableRowStyleFn<T>;
1997
+ type InfiniteTablePropRowClassName<T> = string | InfiniteTableRowClassNameFn<T>;
1998
+ type InfiniteTableColumnAggregator<T, AggregationResultType> = Omit<AggregationReducer<T, AggregationResultType>, 'getter' | 'id'> & {
1971
1999
  getter?: AggregationReducer<T, AggregationResultType>['getter'];
1972
2000
  field?: keyof T;
1973
2001
  };
1974
- declare type InfiniteTableColumnType<T> = {
2002
+ type InfiniteTableColumnType<T> = {
1975
2003
  minWidth?: number;
1976
2004
  maxWidth?: number;
1977
2005
  filterType?: string;
@@ -2008,15 +2036,15 @@ declare type InfiniteTableColumnType<T> = {
2008
2036
  headerStyle?: InfiniteTableColumn<T>['headerStyle'];
2009
2037
  headerClassName?: InfiniteTableColumn<T>['headerClassName'];
2010
2038
  };
2011
- declare type InfiniteTablePropColumnTypes<T> = Record<'default' | string, InfiniteTableColumnType<T>>;
2012
- declare type InfiniteTableColumnSizingOptions = {
2039
+ type InfiniteTablePropColumnTypes<T> = Record<'default' | string, InfiniteTableColumnType<T>>;
2040
+ type InfiniteTableColumnSizingOptions = {
2013
2041
  flex?: number;
2014
2042
  width?: number;
2015
2043
  minWidth?: number;
2016
2044
  maxWidth?: number;
2017
2045
  };
2018
- declare type InfiniteTablePropColumnSizing = Record<string, InfiniteTableColumnSizingOptions>;
2019
- declare type InfiniteTableApi<T> = {
2046
+ type InfiniteTablePropColumnSizing = Record<string, InfiniteTableColumnSizingOptions>;
2047
+ type InfiniteTableApi<T> = {
2020
2048
  get selectionApi(): InfiniteTableSelectionApi;
2021
2049
  setColumnOrder: (columnOrder: InfiniteTablePropColumnOrder) => void;
2022
2050
  setColumnVisibility: (columnVisibility: InfiniteTablePropColumnVisibility) => void;
@@ -2048,22 +2076,22 @@ declare type InfiniteTableApi<T> = {
2048
2076
  getState: () => InfiniteTableState<T>;
2049
2077
  getDataSourceState: () => DataSourceState<T>;
2050
2078
  };
2051
- declare type InfiniteTablePropVirtualizeColumns<T> = boolean | ((columns: InfiniteTableComputedColumn<T>[]) => boolean);
2052
- declare type InfiniteTableColumnsMap<T, ColumnType = InfiniteTableColumn<T>> = Map<string, ColumnType>;
2053
- declare type InfiniteTablePropColumns<T, ColumnType = InfiniteTableColumn<T>> = Record<string, ColumnType> | InfiniteTableColumnsMap<T, ColumnType>;
2054
- declare type InfiniteTablePropColumnGroupsMap = Map<string, InfiniteTableColumnGroup>;
2055
- declare type InfiniteTablePropColumnGroupsRecord = Record<string, InfiniteTableColumnGroup>;
2056
- declare type InfiniteTablePropColumnGroups = InfiniteTablePropColumnGroupsRecord | InfiniteTablePropColumnGroupsMap;
2057
- declare type InfiniteTablePropCollapsedColumnGroups = Map<string[], string>;
2058
- declare type InfiniteTableColumnGroupHeaderRenderParams = {
2079
+ type InfiniteTablePropVirtualizeColumns<T> = boolean | ((columns: InfiniteTableComputedColumn<T>[]) => boolean);
2080
+ type InfiniteTableColumnsMap<T, ColumnType = InfiniteTableColumn<T>> = Map<string, ColumnType>;
2081
+ type InfiniteTablePropColumns<T, ColumnType = InfiniteTableColumn<T>> = Record<string, ColumnType> | InfiniteTableColumnsMap<T, ColumnType>;
2082
+ type InfiniteTablePropColumnGroupsMap = Map<string, InfiniteTableColumnGroup>;
2083
+ type InfiniteTablePropColumnGroupsRecord = Record<string, InfiniteTableColumnGroup>;
2084
+ type InfiniteTablePropColumnGroups = InfiniteTablePropColumnGroupsRecord | InfiniteTablePropColumnGroupsMap;
2085
+ type InfiniteTablePropCollapsedColumnGroups = Map<string[], string>;
2086
+ type InfiniteTableColumnGroupHeaderRenderParams = {
2059
2087
  columnGroup: InfiniteTableComputedColumnGroup;
2060
2088
  };
2061
- declare type InfiniteTableColumnGroupHeaderRenderFunction = (params: InfiniteTableColumnGroupHeaderRenderParams) => Renderable;
2062
- declare type InfiniteTableColumnGroup = {
2089
+ type InfiniteTableColumnGroupHeaderRenderFunction = (params: InfiniteTableColumnGroupHeaderRenderParams) => Renderable;
2090
+ type InfiniteTableColumnGroup = {
2063
2091
  columnGroup?: string;
2064
2092
  header?: Renderable | InfiniteTableColumnGroupHeaderRenderFunction;
2065
2093
  };
2066
- declare type InfiniteTableComputedColumnGroup = InfiniteTableColumnGroup & {
2094
+ type InfiniteTableComputedColumnGroup = InfiniteTableColumnGroup & {
2067
2095
  id: string;
2068
2096
  groupOffset: number;
2069
2097
  computedWidth: number;
@@ -2071,7 +2099,7 @@ declare type InfiniteTableComputedColumnGroup = InfiniteTableColumnGroup & {
2071
2099
  columns: string[];
2072
2100
  depth: number;
2073
2101
  };
2074
- declare type InfiniteTableGroupColumnGetterOptions<T> = {
2102
+ type InfiniteTableGroupColumnGetterOptions<T> = {
2075
2103
  groupIndexForColumn?: number;
2076
2104
  groupByForColumn?: DataSourceGroupBy<T>;
2077
2105
  selectionMode: DataSourcePropSelectionMode;
@@ -2081,34 +2109,34 @@ declare type InfiniteTableGroupColumnGetterOptions<T> = {
2081
2109
  pivotBy?: DataSourcePivotBy<T>[];
2082
2110
  sortable?: boolean;
2083
2111
  };
2084
- declare type InfiniteTablePivotColumnGetterOptions<T, COL_TYPE = InfiniteTableColumn<T>> = {
2112
+ type InfiniteTablePivotColumnGetterOptions<T, COL_TYPE = InfiniteTableColumn<T>> = {
2085
2113
  column: COL_TYPE;
2086
2114
  groupBy: DataSourcePropGroupBy<T>;
2087
2115
  pivotBy: DataSourcePropPivotBy<T>;
2088
2116
  };
2089
- declare type InfiniteTablePropGroupRenderStrategy = 'single-column' | 'multi-column' | 'inline';
2090
- declare type InfiniteTableGroupColumnBase<T> = Partial<InfiniteTableColumn<T>> & {
2117
+ type InfiniteTablePropGroupRenderStrategy = 'single-column' | 'multi-column' | 'inline';
2118
+ type InfiniteTableGroupColumnBase<T> = Partial<InfiniteTableColumn<T>> & {
2091
2119
  renderGroupIcon?: InfiniteTableColumnRenderFunctionForGroupRows<T>;
2092
2120
  id?: string;
2093
2121
  };
2094
- declare type InfiniteTablePivotColumnBase<T> = InfiniteTableColumn<T> & {
2122
+ type InfiniteTablePivotColumnBase<T> = InfiniteTableColumn<T> & {
2095
2123
  renderValue?: InfiniteTableColumnRenderFunction<T, InfiniteTableComputedPivotFinalColumn<T>>;
2096
2124
  };
2097
- declare type InfiniteTablePropGroupColumn<T> = InfiniteTableGroupColumnBase<T> | InfiniteTableGroupColumnFunction<T>;
2098
- declare type InfiniteTableGroupColumnFunction<T> = (options: InfiniteTableGroupColumnGetterOptions<T>, toggleGroupRow: (groupKeys: any[]) => void) => Partial<InfiniteTableGroupColumnBase<T>>;
2099
- declare type InfiniteTablePropPivotColumn<T, COL_TYPE = InfiniteTableColumn<T>> = Partial<InfiniteTablePivotColumnBase<T>> | ((options: InfiniteTablePivotColumnGetterOptions<T, COL_TYPE>) => InfiniteTablePivotColumnBase<T>);
2100
- declare type InfiniteTablePropComponents = {
2125
+ type InfiniteTablePropGroupColumn<T> = InfiniteTableGroupColumnBase<T> | InfiniteTableGroupColumnFunction<T>;
2126
+ type InfiniteTableGroupColumnFunction<T> = (options: InfiniteTableGroupColumnGetterOptions<T>, toggleGroupRow: (groupKeys: any[]) => void) => Partial<InfiniteTableGroupColumnBase<T>>;
2127
+ type InfiniteTablePropPivotColumn<T, COL_TYPE = InfiniteTableColumn<T>> = Partial<InfiniteTablePivotColumnBase<T>> | ((options: InfiniteTablePivotColumnGetterOptions<T, COL_TYPE>) => InfiniteTablePivotColumnBase<T>);
2128
+ type InfiniteTablePropComponents = {
2101
2129
  LoadMask?: React$1.FC<React$1.PropsWithChildren<LoadMaskProps>>;
2102
2130
  CheckBox?: React$1.FC<InfiniteCheckBoxProps>;
2103
2131
  Menu?: React$1.FC<React$1.PropsWithChildren<MenuProps>>;
2104
2132
  };
2105
- declare type ScrollStopInfo = {
2133
+ type ScrollStopInfo = {
2106
2134
  scrollTop: number;
2107
2135
  firstVisibleRowIndex: number;
2108
2136
  lastVisibleRowIndex: number;
2109
2137
  };
2110
- declare type InfiniteTablePropFilterEditors<T> = Record<string, React$1.FC<InfiniteTableFilterEditorProps<T>>>;
2111
- declare type InfiniteTableFilterEditorProps<T extends any> = {
2138
+ type InfiniteTablePropFilterEditors<T> = Record<string, React$1.FC<InfiniteTableFilterEditorProps<T>>>;
2139
+ type InfiniteTableFilterEditorProps<T extends any> = {
2112
2140
  filterType: string;
2113
2141
  operator: string;
2114
2142
  ariaLabel: string;
@@ -2231,22 +2259,22 @@ interface InfiniteTableProps<T> {
2231
2259
  actions: InfiniteTableActions<T>;
2232
2260
  }) => MenuProps['items'];
2233
2261
  }
2234
- declare type InfiniteTablePropKeyboardNavigation = 'cell' | 'row' | false;
2235
- declare type InfiniteTablePropKeyboardSelection = boolean;
2236
- declare type InfiniteTablePropHeaderOptions = {
2262
+ type InfiniteTablePropKeyboardNavigation = 'cell' | 'row' | false;
2263
+ type InfiniteTablePropKeyboardSelection = boolean;
2264
+ type InfiniteTablePropHeaderOptions = {
2237
2265
  alwaysReserveSpaceForSortIcon: boolean;
2238
2266
  };
2239
- declare type InfiniteTablePropAutoSizeColumnsKey = string | number | {
2267
+ type InfiniteTablePropAutoSizeColumnsKey = string | number | {
2240
2268
  key: string | number;
2241
2269
  columnsToSkip?: string[];
2242
2270
  columnsToResize?: string[];
2243
2271
  includeHeader?: boolean;
2244
2272
  };
2245
- declare type Scrollbars = {
2273
+ type Scrollbars = {
2246
2274
  vertical: boolean;
2247
2275
  horizontal: boolean;
2248
2276
  };
2249
- declare type ScrollAdjustPosition = 'start' | 'end' | 'center';
2277
+ type ScrollAdjustPosition = 'start' | 'end' | 'center';
2250
2278
 
2251
2279
  declare function debounce(fn: Function, { wait }: {
2252
2280
  wait: number;
@@ -2259,10 +2287,10 @@ declare namespace Menu {
2259
2287
  };
2260
2288
  }
2261
2289
 
2262
- declare type ForwardPropsToStateFnResult<TYPE_PROPS, TYPE_RESULT> = {
2290
+ type ForwardPropsToStateFnResult<TYPE_PROPS, TYPE_RESULT> = {
2263
2291
  [propName in keyof TYPE_PROPS & keyof TYPE_RESULT]: 1 | ((value: TYPE_PROPS[propName]) => TYPE_RESULT[propName]);
2264
2292
  };
2265
- declare type ComponentStateRootConfig<T_PROPS, COMPONENT_MAPPED_STATE, COMPONENT_SETUP_STATE = {}, COMPONENT_DERIVED_STATE = {}, T_ACTIONS = {}, T_PARENT_STATE = {}> = {
2293
+ type ComponentStateRootConfig<T_PROPS, COMPONENT_MAPPED_STATE, COMPONENT_SETUP_STATE = {}, COMPONENT_DERIVED_STATE = {}, T_ACTIONS = {}, T_PARENT_STATE = {}> = {
2266
2294
  debugName?: string;
2267
2295
  initSetupState?: () => COMPONENT_SETUP_STATE;
2268
2296
  layoutEffect?: boolean;
@@ -2297,7 +2325,7 @@ declare function getComponentStateRoot<T_PROPS, COMPONENT_MAPPED_STATE extends o
2297
2325
  }>;
2298
2326
  declare function useComponentState<COMPONENT_STATE>(): ComponentStateContext<COMPONENT_STATE, ComponentStateGeneratedActions<COMPONENT_STATE>>;
2299
2327
 
2300
- declare type InterceptedMapFns<K, V> = {
2328
+ type InterceptedMapFns<K, V> = {
2301
2329
  set?: (k: K, v: V) => void;
2302
2330
  beforeClear?: (map: Map<K, V>) => void;
2303
2331
  clear?: () => void;