@infinite-table/infinite-react 0.0.10 → 0.1.3

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 (6) hide show
  1. package/index.css +8 -9
  2. package/index.d.ts +347 -207
  3. package/index.esm.css +8 -9
  4. package/index.esm.js +1307 -864
  5. package/index.js +1455 -1010
  6. package/package.json +2 -2
package/index.d.ts CHANGED
@@ -49,18 +49,14 @@ declare module "utils/multisort/index" {
49
49
  const getMultisortFunction: <T>(sortInfo: MultisortInfo<T>[], get?: ((item: any) => T) | undefined) => (first: T, second: T) => number;
50
50
  export { getMultisortFunction, getSortFunctions };
51
51
  }
52
- declare module "components/hooks/useOnce" {
52
+ declare module "utils/DeepMap/once" {
53
53
  export function once<ReturnType>(fn: () => ReturnType): () => ReturnType;
54
- export function useOnce<ReturnType>(fn: () => ReturnType): ReturnType;
55
- }
56
- declare module "components/types/VoidFn" {
57
- export type VoidFn = () => void;
58
54
  }
59
- declare module "utils/sortAscending" {
55
+ declare module "utils/DeepMap/sortAscending" {
60
56
  export const sortAscending: (a: number, b: number) => number;
61
57
  }
62
- declare module "utils/DeepMap" {
63
- import { VoidFn } from "components/types/VoidFn";
58
+ declare module "utils/DeepMap/index" {
59
+ type VoidFn = () => void;
64
60
  type Pair<KeyType, ValueType> = {
65
61
  value?: ValueType;
66
62
  map?: Map<KeyType, Pair<KeyType, ValueType>>;
@@ -71,6 +67,7 @@ declare module "utils/DeepMap" {
71
67
  private map;
72
68
  private length;
73
69
  private revision;
70
+ static clone<KeyType, ValueType>(map: DeepMap<KeyType, ValueType>): DeepMap<KeyType, ValueType>;
74
71
  constructor(initial?: [KeyType[], ValueType][]);
75
72
  set(keys: KeyType[] & {
76
73
  length: Omit<number, 0>;
@@ -148,7 +145,7 @@ declare module "components/hooks/useComponentState" {
148
145
  [k in keyof T_STATE]?: (value: T_STATE[k], { actions, state, }: {
149
146
  actions: ComponentStateGeneratedActions<T_STATE>;
150
147
  state: T_STATE;
151
- }) => void;
148
+ }) => void | boolean;
152
149
  };
153
150
  export type ComponentStateActions<T_STATE> = ComponentStateGeneratedActions<T_STATE>;
154
151
  export type ForwardPropsToStateFnResult<TYPE_PROPS, TYPE_RESULT> = Partial<{
@@ -157,9 +154,14 @@ declare module "components/hooks/useComponentState" {
157
154
  type ComponentStateRootConfig<T_PROPS, COMPONENT_MAPPED_STATE, COMPONENT_SETUP_STATE = {}, COMPONENT_DERIVED_STATE = {}, T_ACTIONS = {}, T_PARENT_STATE = {}> = {
158
155
  debugName?: string;
159
156
  initSetupState?: () => COMPONENT_SETUP_STATE;
160
- forwardProps?: () => ForwardPropsToStateFnResult<T_PROPS, COMPONENT_MAPPED_STATE>;
157
+ forwardProps?: (setupState: COMPONENT_SETUP_STATE) => ForwardPropsToStateFnResult<T_PROPS, COMPONENT_MAPPED_STATE>;
161
158
  allowedControlledPropOverrides?: Record<keyof T_PROPS, true>;
162
159
  interceptActions?: ComponentInterceptedActions<COMPONENT_MAPPED_STATE & COMPONENT_DERIVED_STATE & COMPONENT_SETUP_STATE>;
160
+ onPropChange?: (params: {
161
+ name: keyof T_PROPS;
162
+ oldValue: any;
163
+ newValue: any;
164
+ }, props: T_PROPS, actions: ComponentStateActions<COMPONENT_MAPPED_STATE & COMPONENT_DERIVED_STATE & COMPONENT_SETUP_STATE>) => void;
163
165
  mapPropsToState?: (params: {
164
166
  props: T_PROPS;
165
167
  state: COMPONENT_MAPPED_STATE & COMPONENT_SETUP_STATE & Partial<COMPONENT_DERIVED_STATE>;
@@ -184,6 +186,9 @@ declare module "components/hooks/useComponentState" {
184
186
  declare module "components/types/NonUndefined" {
185
187
  export type NonUndefined<T> = T extends undefined ? never : T;
186
188
  }
189
+ declare module "components/types/VoidFn" {
190
+ export type VoidFn = () => void;
191
+ }
187
192
  declare module "components/types/SubscriptionCallback" {
188
193
  import { VoidFn } from "components/types/VoidFn";
189
194
  export type SubscriptionCallbackOnChangeFn<T> = (node: T | null) => void;
@@ -197,105 +202,158 @@ declare module "components/types/SubscriptionCallback" {
197
202
  declare module "components/DataSource/types" {
198
203
  import * as React from 'react';
199
204
  import { MultisortInfo } from "utils/multisort/index";
200
- import { DeepMap } from "utils/DeepMap";
201
- import { AggregationReducer, DeepMapGroupValueType, GroupBy, GroupKeyType, PivotBy } from "utils/groupAndPivot/index";
205
+ import { DeepMap } from "utils/DeepMap/index";
206
+ import { DeepMapGroupValueType, GroupBy, GroupKeyType, PivotBy } from "utils/groupAndPivot/index";
202
207
  import { InfiniteTableColumn, InfiniteTableColumnGroup, InfiniteTableRowInfo, Scrollbars } from "components/InfiniteTable/index";
203
208
  import { ComponentStateActions } from "components/hooks/useComponentState";
204
209
  import { GroupRowsState } from "components/DataSource/GroupRowsState";
205
210
  import { InfiniteTablePropPivotTotalColumnPosition } from "components/InfiniteTable/types/InfiniteTableState";
206
211
  import { NonUndefined } from "components/types/NonUndefined";
207
212
  import { SubscriptionCallback } from "components/types/SubscriptionCallback";
213
+ import { ScrollStopInfo } from "components/InfiniteTable/types/InfiniteTableProps";
208
214
  export interface DataSourceDataParams<T> {
209
215
  originalDataArray: T[];
210
216
  sortInfo?: DataSourceSortInfo<T>;
211
- groupRowsBy?: DataSourcePropGroupRowsBy<T>;
217
+ groupBy?: DataSourcePropGroupBy<T>;
212
218
  pivotBy?: DataSourcePropPivotBy<T>;
219
+ lazyLoadBatchSize?: number;
220
+ lazyLoadStartIndex?: number;
221
+ groupKeys?: any[];
222
+ aggregationReducers?: DataSourcePropAggregationReducers<T>;
213
223
  livePaginationCursor?: DataSourceLivePaginationCursorValue;
224
+ cursorId?: DataSourceSetupState<T>['cursorId'];
225
+ changes?: DataSourceDataParamsChanges<T>;
214
226
  }
227
+ export type DataSourceDataParamsChanges<T> = Partial<Record<keyof Omit<DataSourceDataParams<T>, 'originalDataArray' | 'changes'>, true>>;
215
228
  export type DataSourceSingleSortInfo<T> = MultisortInfo<T> & {
216
229
  field?: keyof T;
217
230
  id?: string;
218
231
  };
219
- export type DataSourceGroupRowsBy<T> = GroupBy<T, any>;
232
+ export type DataSourceGroupBy<T> = GroupBy<T, any>;
220
233
  export type DataSourcePivotBy<T> = PivotBy<T, any>;
221
234
  export type DataSourceSortInfo<T> = null | DataSourceSingleSortInfo<T> | DataSourceSingleSortInfo<T>[];
222
235
  export type DataSourceRemoteData<T> = {
223
236
  data: T[];
237
+ mappings?: DataSourceMappings;
238
+ totalCount?: number;
224
239
  livePaginationCursor?: DataSourceLivePaginationCursorValue;
225
240
  };
226
- export type DataSourceData<T> = T[] | Promise<T[] | DataSourceRemoteData<T>> | ((dataInfo: DataSourceDataParams<T>) => T[] | Promise<T[] | DataSourceRemoteData<T>>);
241
+ export type DataSourceData<T> = T[] | DataSourceRemoteData<T> | Promise<T[] | DataSourceRemoteData<T>> | ((dataInfo: DataSourceDataParams<T>) => T[] | Promise<T[] | DataSourceRemoteData<T>>);
227
242
  export type DataSourceGroupRowsList<KeyType> = true | KeyType[][];
228
243
  export type DataSourceExpandedAndCollapsedGroupRows<KeyType> = {
229
244
  expandedRows: DataSourceGroupRowsList<KeyType>;
230
245
  collapsedRows: DataSourceGroupRowsList<KeyType>;
231
246
  };
232
- export type DataSourcePropGroupRowsBy<T> = DataSourceGroupRowsBy<T>[];
247
+ export type DataSourcePropGroupBy<T> = DataSourceGroupBy<T>[];
233
248
  export type DataSourcePropPivotBy<T> = DataSourcePivotBy<T>[];
234
249
  export interface DataSourceMappedState<T> {
250
+ aggregationReducers?: DataSourceProps<T>['aggregationReducers'];
235
251
  livePagination: DataSourceProps<T>['livePagination'];
236
- livePaginationCursor: DataSourceProps<T>['livePaginationCursor'];
237
- remoteCount: DataSourceProps<T>['remoteCount'];
252
+ fullLazyLoad: DataSourceProps<T>['fullLazyLoad'];
253
+ lazyLoadBatchSize: DataSourceProps<T>['lazyLoadBatchSize'];
238
254
  onDataParamsChange: DataSourceProps<T>['onDataParamsChange'];
239
255
  data: DataSourceProps<T>['data'];
240
256
  primaryKey: DataSourceProps<T>['primaryKey'];
241
- groupRowsBy: NonUndefined<DataSourceProps<T>['groupRowsBy']>;
257
+ groupBy: NonUndefined<DataSourceProps<T>['groupBy']>;
242
258
  groupRowsState: NonUndefined<DataSourceProps<T>['groupRowsState']>;
243
259
  pivotBy: DataSourceProps<T>['pivotBy'];
244
260
  loading: NonUndefined<DataSourceProps<T>['loading']>;
261
+ collapseGroupRowsOnDataFunctionChange: NonUndefined<DataSourceProps<T>['collapseGroupRowsOnDataFunctionChange']>;
245
262
  sortInfo: DataSourceSingleSortInfo<T>[] | null;
246
263
  }
264
+ export type DataSourceAggregationReducer<T, AggregationResultType> = {
265
+ name?: string;
266
+ field?: keyof T;
267
+ initialValue?: AggregationResultType;
268
+ getter?: (data: T) => any;
269
+ reducer: string | ((accumulator: any, value: any, data: T) => AggregationResultType | any);
270
+ done?: (accumulatedValue: AggregationResultType | any, array: T[]) => AggregationResultType;
271
+ };
272
+ export type DataSourceMappings = Record<'totals' | 'values', string>;
273
+ export type LazyGroupDataItem<DataType> = {
274
+ data: Partial<DataType>;
275
+ keys: any[];
276
+ aggregations?: Record<string, any>;
277
+ pivot?: {
278
+ values: Record<string, any>;
279
+ totals?: Record<string, any>;
280
+ };
281
+ };
282
+ export type LazyGroupRowInfo<DataType> = {
283
+ items: LazyGroupDataItem<DataType>[];
284
+ totalCount: number;
285
+ };
286
+ export type LazyGroupDataDeepMap<DataType, KeyType = string> = DeepMap<KeyType, LazyGroupRowInfo<DataType>>;
247
287
  export interface DataSourceSetupState<T> {
288
+ pivotMappings?: DataSourceMappings;
289
+ propsCache: Map<keyof DataSourceProps<T>, WeakMap<any, any>>;
290
+ showSeparatePivotColumnForSingleAggregation: boolean;
248
291
  dataParams?: DataSourceDataParams<T>;
292
+ originalLazyGroupData: LazyGroupDataDeepMap<T>;
249
293
  notifyScrollbarsChange: SubscriptionCallback<Scrollbars>;
294
+ notifyScrollStop: SubscriptionCallback<ScrollStopInfo>;
250
295
  originalDataArray: T[];
251
296
  lastSortDataArray?: T[];
252
297
  lastGroupDataArray?: InfiniteTableRowInfo<T>[];
253
298
  dataArray: InfiniteTableRowInfo<T>[];
254
299
  groupDeepMap?: DeepMap<GroupKeyType, DeepMapGroupValueType<T, any>>;
255
300
  pivotTotalColumnPosition: InfiniteTablePropPivotTotalColumnPosition;
256
- scrollBottomId: number | Symbol | DataSourceLivePaginationCursorValue;
301
+ cursorId: number | Symbol | DataSourceLivePaginationCursorValue;
257
302
  updatedAt: number;
258
303
  reducedAt: number;
259
304
  groupedAt: number;
260
305
  sortedAt: number;
261
306
  generateGroupRows: boolean;
262
- aggregationReducers?: AggregationReducer<T, any>[];
263
307
  postSortDataArray?: T[];
264
308
  postGroupDataArray?: InfiniteTableRowInfo<T>[];
265
309
  pivotColumns?: Map<string, InfiniteTableColumn<T>>;
266
310
  pivotColumnGroups?: Map<string, InfiniteTableColumnGroup>;
267
311
  }
268
- export interface DataSourceProps<T> {
312
+ export type DataSourcePropAggregationReducers<T> = Record<string, DataSourceAggregationReducer<T, any>>;
313
+ export type DataSourceProps<T> = {
269
314
  children: React.ReactNode | ((contextData: DataSourceState<T>) => React.ReactNode);
270
315
  primaryKey: keyof T;
271
316
  fields?: (keyof T)[];
272
- remoteCount?: number;
273
317
  data: DataSourceData<T>;
318
+ fullLazyLoad?: boolean;
319
+ lazyLoadBatchSize?: number;
274
320
  loading?: boolean;
275
321
  defaultLoading?: boolean;
276
322
  onLoadingChange?: (loading: boolean) => void;
277
323
  pivotBy?: DataSourcePropPivotBy<T>;
278
324
  defaultPivotBy?: DataSourcePropPivotBy<T>;
279
325
  onPivotByChange?: (pivotBy: DataSourcePropPivotBy<T>) => void;
280
- groupRowsBy?: DataSourcePropGroupRowsBy<T>;
281
- defaultGroupRowsBy?: DataSourcePropGroupRowsBy<T>;
282
- onGroupRowsByChange?: (groupBy: DataSourcePropGroupRowsBy<T>) => void;
326
+ aggregationReducers?: DataSourcePropAggregationReducers<T>;
327
+ defaultAggregationReducers?: DataSourcePropAggregationReducers<T>;
328
+ groupBy?: DataSourcePropGroupBy<T>;
329
+ defaultGroupBy?: DataSourcePropGroupBy<T>;
330
+ onGroupByChange?: (groupBy: DataSourcePropGroupBy<T>) => void;
283
331
  groupRowsState?: GroupRowsState;
284
332
  defaultGroupRowsState?: GroupRowsState;
285
333
  onGroupRowsStateChange?: (groupRowsState: GroupRowsState) => void;
334
+ collapseGroupRowsOnDataFunctionChange?: boolean;
286
335
  sortInfo?: DataSourceSortInfo<T>;
287
336
  defaultSortInfo?: DataSourceSortInfo<T>;
288
337
  onSortInfoChange?: ((sortInfo: DataSourceSingleSortInfo<T> | null) => void) | ((sortInfo: DataSourceSingleSortInfo<T>[]) => void);
289
338
  onDataParamsChange?: (dataParamsChange: DataSourceDataParams<T>) => void;
290
339
  livePagination?: boolean;
291
- livePaginationCursor?: DataSourceLivePaginationCursorValue;
292
- }
293
- export type DataSourceLivePaginationCursorValue = string | number;
340
+ livePaginationCursor?: DataSourcePropLivePaginationCursor<T>;
341
+ onLivePaginationCursorChange?: (livePaginationCursor: DataSourceLivePaginationCursorValue) => void;
342
+ };
343
+ export type DataSourcePropLivePaginationCursor<T> = DataSourceLivePaginationCursorValue | DataSourceLivePaginationCursorFn<T>;
344
+ export type DataSourceLivePaginationCursorFn<T> = (params: DataSourceLivePaginationCursorParams<T>) => DataSourceLivePaginationCursorValue;
345
+ export type DataSourceLivePaginationCursorParams<T> = {
346
+ array: T[];
347
+ lastItem: T | Partial<T> | null;
348
+ length: number;
349
+ };
350
+ export type DataSourceLivePaginationCursorValue = string | number | null;
294
351
  export interface DataSourceState<T> extends DataSourceSetupState<T>, DataSourceDerivedState<T>, DataSourceMappedState<T> {
295
352
  }
296
353
  export interface DataSourceDerivedState<_T> {
297
354
  multiSort: boolean;
298
355
  controlledSort: boolean;
356
+ livePaginationCursor?: DataSourceLivePaginationCursorValue;
299
357
  }
300
358
  export type DataSourceComponentActions<T> = ComponentStateActions<DataSourceState<T>>;
301
359
  export interface DataSourceContextValue<T> {
@@ -331,21 +389,22 @@ declare module "components/hooks/useEffectWithChanges" {
331
389
  export function useEffectWithObject(fn: EffectCallback, deps: Record<string, any>): void;
332
390
  }
333
391
  declare module "components/DataSource/privateHooks/useLoadData" {
334
- import { DataSourceDataParams, DataSourceState } from "components/DataSource/types";
335
- export function buildDataSourceDataParams<T>(componentState: DataSourceState<T>): DataSourceDataParams<T>;
392
+ import { ComponentStateGeneratedActions } from "components/hooks/useComponentState";
393
+ import { DataSourceDataParams, DataSourceData, DataSourceState } from "components/DataSource/types";
394
+ export function buildDataSourceDataParams<T>(componentState: DataSourceState<T>, overrides?: Partial<DataSourceDataParams<T>>): DataSourceDataParams<T>;
395
+ export function loadData<T>(data: DataSourceData<T>, componentState: DataSourceState<T>, actions: ComponentStateGeneratedActions<DataSourceState<T>>, overrides?: Partial<DataSourceDataParams<T>>): void;
336
396
  export function useLoadData<T>(): void;
337
- export function useLivePagination<T>(): void;
338
397
  }
339
398
  declare module "components/DataSource/state/normalizeSortInfo" {
340
399
  import { DataSourceSingleSortInfo, DataSourceSortInfo } from "components/DataSource/types";
341
- export const normalizeSortInfo: <T>(sortInfo?: DataSourceSortInfo<T> | undefined) => DataSourceSingleSortInfo<T>[];
400
+ export const normalizeSortInfo: <T>(initialSortInfo?: DataSourceSortInfo<T> | undefined, weakMap?: WeakMap<any, any> | undefined) => DataSourceSingleSortInfo<T>[];
342
401
  }
343
402
  declare module "components/utils/buildSubscriptionCallback" {
344
403
  import { SubscriptionCallback } from "components/types/SubscriptionCallback";
345
404
  export function buildSubscriptionCallback<T>(): SubscriptionCallback<T>;
346
405
  }
347
406
  declare module "utils/shallowEqualObjects" {
348
- export function shallowEqualObjects<T extends object | null>(objA: T, objB: T): boolean;
407
+ export function shallowEqualObjects<T extends object | null>(objA: T, objB: T, ignoreKeys?: Set<string>): boolean;
349
408
  }
350
409
  declare module "components/utils/discardCallsWithEqualArg" {
351
410
  export function discardCallsWithEqualArg<T = any>(fn: (arg: T) => void, timeframe?: number, getCompareObject?: (arg: T) => any): (arg: T) => void;
@@ -354,25 +413,33 @@ declare module "components/DataSource/state/getInitialState" {
354
413
  import { DataSourceMappedState, DataSourceProps, DataSourceDerivedState, DataSourceSetupState, DataSourceState } from "components/DataSource/types";
355
414
  import { GroupRowsState } from "components/DataSource/GroupRowsState";
356
415
  import { ComponentInterceptedActions, ForwardPropsToStateFnResult } from "components/hooks/useComponentState";
357
- import { DataSourceDataParams } from "components/DataSource/index";
416
+ import { DataSourceComponentActions, DataSourceDataParams } from "components/DataSource/index";
417
+ export const defaultCursorId: unique symbol;
358
418
  export function initSetupState<T>(): DataSourceSetupState<T>;
359
- export const forwardProps: <T>() => Partial<{
419
+ export const forwardProps: <T>(setupState: DataSourceSetupState<T>) => Partial<{
360
420
  data: 1 | ((value: import("components/DataSource").DataSourceData<T>) => import("components/DataSource").DataSourceData<T>);
361
421
  loading: 1 | ((value: boolean | undefined) => boolean);
422
+ sortInfo: 1 | ((value: import("components/DataSource").DataSourceSortInfo<T> | undefined) => import("components/DataSource").DataSourceSingleSortInfo<T>[] | null);
423
+ groupBy: 1 | ((value: import("components/DataSource").DataSourcePropGroupBy<T> | undefined) => import("components/DataSource").DataSourcePropGroupBy<T>);
424
+ pivotBy: 1 | ((value: import("components/DataSource").DataSourcePropPivotBy<T> | undefined) => import("components/DataSource").DataSourcePropPivotBy<T> | undefined);
425
+ lazyLoadBatchSize: 1 | ((value: number | undefined) => number | undefined);
426
+ aggregationReducers: 1 | ((value: import("components/DataSource").DataSourcePropAggregationReducers<T> | undefined) => import("components/DataSource").DataSourcePropAggregationReducers<T> | undefined);
362
427
  livePagination: 1 | ((value: boolean | undefined) => boolean | undefined);
363
- livePaginationCursor: 1 | ((value: import("components/DataSource").DataSourceLivePaginationCursorValue | undefined) => import("components/DataSource").DataSourceLivePaginationCursorValue | undefined);
364
- remoteCount: 1 | ((value: number | undefined) => number | undefined);
428
+ fullLazyLoad: 1 | ((value: boolean | undefined) => boolean | undefined);
365
429
  onDataParamsChange: 1 | ((value: ((dataParamsChange: DataSourceDataParams<T>) => void) | undefined) => ((dataParamsChange: DataSourceDataParams<T>) => void) | undefined);
366
430
  primaryKey: 1 | ((value: keyof T) => keyof T);
367
- groupRowsBy: 1 | ((value: import("components/DataSource").DataSourcePropGroupRowsBy<T> | undefined) => import("components/DataSource").DataSourcePropGroupRowsBy<T>);
368
431
  groupRowsState: 1 | ((value: GroupRowsState<any> | undefined) => GroupRowsState<any>);
369
- pivotBy: 1 | ((value: import("components/DataSource").DataSourcePropPivotBy<T> | undefined) => import("components/DataSource").DataSourcePropPivotBy<T> | undefined);
370
- sortInfo: 1 | ((value: import("components/DataSource").DataSourceSortInfo<T> | undefined) => import("components/DataSource").DataSourceSingleSortInfo<T>[] | null);
432
+ collapseGroupRowsOnDataFunctionChange: 1 | ((value: boolean | undefined) => boolean);
371
433
  }>;
372
434
  export function mapPropsToState<T extends any>(params: {
373
435
  props: DataSourceProps<T>;
374
436
  state: DataSourceState<T>;
437
+ oldState: DataSourceState<T> | null;
375
438
  }): DataSourceDerivedState<T>;
439
+ export function onPropChange<T>(params: {
440
+ name: keyof T;
441
+ newValue: any;
442
+ }, props: DataSourceProps<T>, actions: DataSourceComponentActions<T>): void;
376
443
  export function getInterceptActions<T>(): ComponentInterceptedActions<DataSourceState<T>>;
377
444
  }
378
445
  declare module "components/types/Renderable" {
@@ -381,6 +448,7 @@ declare module "components/types/Renderable" {
381
448
  }
382
449
  declare module "components/InfiniteTable/types/Utility" {
383
450
  export type ArrayElement<ArrayType extends readonly unknown[]> = ArrayType extends readonly (infer ElementType)[] ? ElementType : never;
451
+ export type MapOrRecord<K extends string, V> = Map<K, V> | Record<K, V>;
384
452
  export type RequireOnlyOneProperty<T, Keys extends keyof T> = Pick<T, Exclude<keyof T, Keys>> & {
385
453
  [K in Keys]-?: Required<Pick<T, K>> & Partial<Record<Exclude<Keys, K>, undefined>>;
386
454
  }[Keys];
@@ -400,26 +468,31 @@ declare module "components/InfiniteTable/types/InfiniteTableColumn" {
400
468
  import type { Renderable } from "components/types/Renderable";
401
469
  import type { DataSourcePivotBy, DataSourceSingleSortInfo, DataSourceState } from "components/DataSource/types";
402
470
  import type { DiscriminatedUnion, RequireAtLeastOne } from "components/InfiniteTable/types/Utility";
403
- import type { InfiniteTableRowInfo } from "components/InfiniteTable/types/index";
471
+ import type { InfiniteTableColumnGroup, InfiniteTableRowInfo } from "components/InfiniteTable/types/index";
404
472
  import { CSSProperties } from 'react';
405
- import { PivotBy } from "utils/groupAndPivot/index";
473
+ import { AggregationReducer, InfiniteTableRowInfoGroup, InfiniteTableRowInfoNormal, PivotBy } from "utils/groupAndPivot/index";
474
+ import { InfiniteTableColumnPinnedValues } from "components/InfiniteTable/types/InfiniteTableProps";
406
475
  export type { DiscriminatedUnion, RequireAtLeastOne };
407
476
  export type InfiniteTableToggleGroupRowFn = (groupKeys: any[]) => void;
408
- export interface InfiniteTableColumnRenderParam<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> {
477
+ export type InfiniteTableColumnRenderParam<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = {
409
478
  value: string | number | Renderable;
410
- data: DATA_TYPE | null;
411
- rowInfo: InfiniteTableRowInfo<DATA_TYPE>;
412
479
  groupRowInfo: InfiniteTableRowInfo<DATA_TYPE> | null;
413
480
  rowIndex: number;
414
481
  column: COL_TYPE;
415
482
  toggleCurrentGroupRow: () => void;
416
483
  toggleGroupRow: InfiniteTableToggleGroupRowFn;
417
- groupRowsBy: DataSourceState<DATA_TYPE>['groupRowsBy'];
418
- }
484
+ groupBy: DataSourceState<DATA_TYPE>['groupBy'];
485
+ } & ({
486
+ rowInfo: InfiniteTableRowInfoNormal<DATA_TYPE>;
487
+ data: DATA_TYPE;
488
+ } | {
489
+ rowInfo: InfiniteTableRowInfoGroup<DATA_TYPE>;
490
+ data: Partial<DATA_TYPE> | null;
491
+ });
419
492
  export type InfiniteTableColumnRenderValueParam<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = InfiniteTableColumnRenderParam<DATA_TYPE, COL_TYPE>;
420
493
  export type InfiniteTableColumnRowspanFnParams<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = {
421
- data: DATA_TYPE | null;
422
494
  rowInfo: InfiniteTableRowInfo<DATA_TYPE>;
495
+ data: DATA_TYPE | Partial<DATA_TYPE> | null;
423
496
  groupRowInfo: InfiniteTableRowInfo<DATA_TYPE> | null;
424
497
  dataArray: InfiniteTableRowInfo<DATA_TYPE>[];
425
498
  rowIndex: number;
@@ -429,8 +502,7 @@ declare module "components/InfiniteTable/types/InfiniteTableColumn" {
429
502
  column: InfiniteTableComputedColumn<T>;
430
503
  columnSortInfo: DataSourceSingleSortInfo<T> | null | undefined;
431
504
  }
432
- export type InfiniteTableColumnPinned = 'start' | 'end' | false;
433
- export type InfiniteTableColumnRenderFunction<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = ({ value, rowIndex, column, data, toggleGroupRow, toggleCurrentGroupRow, rowInfo, groupRowsBy, }: InfiniteTableColumnRenderParam<DATA_TYPE, COL_TYPE>) => Renderable | null;
505
+ export type InfiniteTableColumnRenderFunction<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = ({ value, rowIndex, column, data, toggleGroupRow, toggleCurrentGroupRow, rowInfo, groupBy, }: InfiniteTableColumnRenderParam<DATA_TYPE, COL_TYPE>) => Renderable | null;
434
506
  export type InfiniteTableColumnRenderValueFunction<DATA_TYPE, COL_TYPE = InfiniteTableComputedColumn<DATA_TYPE>> = InfiniteTableColumnRenderFunction<DATA_TYPE, COL_TYPE>;
435
507
  export type InfiniteTableColumnHeaderRenderFunction<T> = ({ columnSortInfo, column, }: InfiniteTableColumnHeaderRenderParams<T>) => Renderable;
436
508
  export type InfiniteTableColumnWithField<T> = {
@@ -453,19 +525,25 @@ declare module "components/InfiniteTable/types/InfiniteTableColumn" {
453
525
  valueGetter?: InfiniteTableColumnValueGetter<T>;
454
526
  }, 'render' | 'renderValue' | 'field' | 'valueGetter'>;
455
527
  export type InfiniteTableColumnStyleFnParams<T> = {
456
- data: T | null;
457
528
  value: Renderable;
458
- rowInfo: InfiniteTableRowInfo<T>;
459
529
  column: InfiniteTableColumn<T>;
460
- };
530
+ } & ({
531
+ data: T;
532
+ rowInfo: InfiniteTableRowInfoNormal<T>;
533
+ } | {
534
+ data: Partial<T> | null;
535
+ rowInfo: InfiniteTableRowInfoGroup<T>;
536
+ });
461
537
  export type InfiniteTableColumnStyleFn<T> = (params: InfiniteTableColumnStyleFnParams<T>) => undefined | React.CSSProperties;
462
538
  export type InfiniteTableColumnClassNameFn<T> = (params: InfiniteTableColumnStyleFnParams<T>) => undefined | string;
463
539
  export type InfiniteTableColumnStyle<T> = CSSProperties | InfiniteTableColumnStyleFn<T>;
464
540
  export type InfiniteTableColumnClassName<T> = string | InfiniteTableColumnClassNameFn<T>;
465
541
  export type InfiniteTableColumnValueGetterParams<T> = {
466
- data: T | null;
467
- rowInfo: InfiniteTableRowInfo<T>;
468
- groupRowInfo: InfiniteTableRowInfo<T> | null;
542
+ data: T;
543
+ rowInfo: InfiniteTableRowInfoNormal<T>;
544
+ } | {
545
+ data: Partial<T> | null;
546
+ rowInfo: InfiniteTableRowInfoGroup<T>;
469
547
  };
470
548
  export type InfiniteTableColumnValueGetter<T, VALUE_GETTER_TYPE = Renderable> = (params: InfiniteTableColumnValueGetterParams<T>) => VALUE_GETTER_TYPE;
471
549
  export type InfiniteTableColumnRowspanFn<T> = (params: InfiniteTableColumnRowspanFnParams<T>) => number;
@@ -475,6 +553,7 @@ declare module "components/InfiniteTable/types/InfiniteTableColumn" {
475
553
  draggable?: boolean;
476
554
  resizable?: boolean;
477
555
  comparer?: InfiniteTableColumnComparer<T>;
556
+ hiddenWhenGrouped?: boolean;
478
557
  align?: InfiniteTableColumnAlign;
479
558
  verticalAlign?: InfiniteTableColumnVerticalAlign;
480
559
  columnGroup?: string;
@@ -487,28 +566,35 @@ declare module "components/InfiniteTable/types/InfiniteTableColumn" {
487
566
  className?: InfiniteTableColumnClassName<T>;
488
567
  rowspan?: InfiniteTableColumnRowspanFn<T>;
489
568
  valueGetter?: InfiniteTableColumnValueGetter<T>;
569
+ defaultWidth?: number;
570
+ defaultFlex?: number;
490
571
  };
491
572
  export type InfiniteTableColumn<T> = {} & InfiniteTableBaseColumn<T> & InfiniteTableColumnWithRenderOrRenderValueOrFieldOrValueGetter<T>;
492
573
  export type InfiniteTableGeneratedGroupColumn<T> = InfiniteTableColumn<T> & {
493
- groupByField?: string | string[];
574
+ groupByField: string | string[];
494
575
  id?: string;
495
576
  };
496
- export type InfiniteTablePivotColumn<T> = InfiniteTableColumn<T> & {
497
- pivotBy?: DataSourcePivotBy<T>[];
498
- pivotColumn?: true;
499
- pivotTotalColumn?: true;
500
- pivotGroupKeys?: any[];
501
- pivotByForColumn?: DataSourcePivotBy<T>;
502
- pivotIndexForColumn?: number;
503
- pivotGroupKeyForColumn?: any;
577
+ export type InfiniteTablePivotColumn<T> = InfiniteTableColumn<T> & Partial<InfiniteTablePivotFinalColumnVariant<T, any>>;
578
+ export type InfiniteTablePivotFinalColumnGroup<DataType, KeyType extends any = any> = InfiniteTableColumnGroup & {
579
+ pivotBy: DataSourcePivotBy<DataType>[];
580
+ pivotTotalColumnGroup?: true;
581
+ pivotGroupKeys: KeyType[];
582
+ pivotByAtIndex: PivotBy<DataType, KeyType>;
583
+ pivotGroupKey: KeyType;
584
+ pivotIndex: number;
504
585
  };
505
- export type InfiniteTablePivotFinalColumn<DataType, KeyType extends any = any> = InfiniteTablePivotColumn<DataType> & {
586
+ export type InfiniteTablePivotFinalColumn<DataType, KeyType extends any = any> = InfiniteTableColumn<DataType> & {
506
587
  pivotBy: DataSourcePivotBy<DataType>[];
588
+ pivotColumn: true;
589
+ pivotTotalColumn: boolean;
590
+ pivotAggregator: AggregationReducer<DataType, any>;
591
+ pivotAggregatorIndex: number;
507
592
  pivotGroupKeys: KeyType[];
508
- pivotByForColumn: PivotBy<DataType, KeyType>;
509
- pivotIndexForColumn: number;
510
- pivotGroupKeyForColumn: KeyType;
593
+ pivotByAtIndex?: PivotBy<DataType, KeyType>;
594
+ pivotIndex: number;
595
+ pivotGroupKey: KeyType;
511
596
  };
597
+ export type InfiniteTablePivotFinalColumnVariant<DataType, KeyType extends any = any> = InfiniteTablePivotFinalColumn<DataType, KeyType>;
512
598
  type InfiniteTableComputedColumnBase<T> = {
513
599
  computedWidth: number;
514
600
  computedOffset: number;
@@ -522,7 +608,7 @@ declare module "components/InfiniteTable/types/InfiniteTableColumn" {
522
608
  computedSortIndex: number;
523
609
  computedVisibleIndex: number;
524
610
  computedMultiSort: boolean;
525
- computedPinned: InfiniteTableColumnPinned;
611
+ computedPinned: InfiniteTableColumnPinnedValues;
526
612
  computedDraggable: boolean;
527
613
  computedFirstInCategory: boolean;
528
614
  computedLastInCategory: boolean;
@@ -531,19 +617,27 @@ declare module "components/InfiniteTable/types/InfiniteTableColumn" {
531
617
  toggleSort: () => void;
532
618
  id: string;
533
619
  };
534
- export type InfiniteTableComputedColumn<T> = InfiniteTableColumn<T> & InfiniteTableComputedColumnBase<T> & InfiniteTablePivotColumn<T> & InfiniteTableGeneratedGroupColumn<T>;
620
+ export type InfiniteTableComputedColumn<T> = InfiniteTableColumn<T> & InfiniteTableComputedColumnBase<T> & Partial<InfiniteTablePivotFinalColumn<T>> & Partial<InfiniteTableGeneratedGroupColumn<T>>;
621
+ export type InfiniteTableComputedPivotFinalColumn<T> = InfiniteTableComputedColumn<T> & InfiniteTablePivotFinalColumn<T>;
535
622
  }
536
623
  declare module "utils/groupAndPivot/getPivotColumnsAndColumnGroups" {
537
- import type { DataSourcePivotBy } from "components/DataSource/index";
538
- import type { InfiniteTablePropColumnGroups, InfiniteTablePropColumnsMap } from "components/InfiniteTable/index";
624
+ import type { DataSourceAggregationReducer, DataSourcePivotBy } from "components/DataSource/index";
625
+ import type { InfiniteTablePropColumnsMap } from "components/InfiniteTable/index";
539
626
  import type { InfiniteTablePivotColumn } from "components/InfiniteTable/types/InfiniteTableColumn";
627
+ import { InfiniteTablePropColumnGroupsMap } from "components/InfiniteTable/types/InfiniteTableProps";
540
628
  import type { InfiniteTablePropPivotTotalColumnPosition } from "components/InfiniteTable/types/InfiniteTableState";
541
- import { DeepMap } from "utils/DeepMap";
629
+ import { DeepMap } from "utils/DeepMap/index";
542
630
  export type ComputedColumnsAndGroups<DataType> = {
543
631
  columns: InfiniteTablePropColumnsMap<DataType, InfiniteTablePivotColumn<DataType>>;
544
- columnGroups: InfiniteTablePropColumnGroups;
632
+ columnGroups: InfiniteTablePropColumnGroupsMap;
545
633
  };
546
- export function getPivotColumnsAndColumnGroups<DataType, KeyType = any>(deepMap: DeepMap<KeyType, boolean>, pivotBy: DataSourcePivotBy<DataType>[], pivotTotalColumnPosition: InfiniteTablePropPivotTotalColumnPosition): ComputedColumnsAndGroups<DataType>;
634
+ export function getPivotColumnsAndColumnGroups<DataType, KeyType = any>({ deepMap, pivotBy, pivotTotalColumnPosition, reducers, showSeparatePivotColumnForSingleAggregation, }: {
635
+ deepMap: DeepMap<KeyType, boolean>;
636
+ pivotBy: DataSourcePivotBy<DataType>[];
637
+ pivotTotalColumnPosition: InfiniteTablePropPivotTotalColumnPosition;
638
+ reducers?: Record<string, DataSourceAggregationReducer<DataType, any>>;
639
+ showSeparatePivotColumnForSingleAggregation?: boolean;
640
+ }): ComputedColumnsAndGroups<DataType>;
547
641
  }
548
642
  declare module "components/DataSource/state/reducer" {
549
643
  import type { DataSourceState, DataSourceDerivedState } from "components/DataSource/types";
@@ -587,22 +681,34 @@ declare module "components/DataSource/GroupRowsState" {
587
681
  }
588
682
  }
589
683
  declare module "utils/groupAndPivot/index" {
684
+ import { DataSourceAggregationReducer, DataSourceMappings, LazyGroupDataDeepMap } from "@infinite-table/infinite-react";
590
685
  import { GroupRowsState } from "components/DataSource/GroupRowsState";
591
- import { InfiniteTablePivotColumn, InfiniteTablePivotFinalColumn } from "components/InfiniteTable/types/InfiniteTableColumn";
592
- import { InfiniteTableGroupColumnBase } from "components/InfiniteTable/types/InfiniteTableProps";
593
- import { DeepMap } from "utils/DeepMap";
594
- export type AggregationReducer<T, AggregationResultType> = {
595
- initialValue: AggregationResultType;
596
- getter: (data: T) => any;
597
- reducer: (accumulator: any, value: any, data: T) => AggregationResultType | any;
598
- done?: (accumulatedValue: AggregationResultType | any, array: T[]) => AggregationResultType;
686
+ import { InfiniteTableColumn, InfiniteTablePivotColumn, InfiniteTablePivotFinalColumnGroup, InfiniteTablePivotFinalColumnVariant } from "components/InfiniteTable/types/InfiniteTableColumn";
687
+ import { InfiniteTableColumnGroup, InfiniteTableGroupColumnBase } from "components/InfiniteTable/types/InfiniteTableProps";
688
+ import { DeepMap } from "utils/DeepMap/index";
689
+ export const LAZY_ROOT_KEY_FOR_GROUPS: string;
690
+ export type AggregationReducer<T, AggregationResultType = any> = DataSourceAggregationReducer<T, AggregationResultType> & {
691
+ id: string;
692
+ };
693
+ export type AggregationReducerResult<AggregationResultType extends any = any> = {
694
+ value: AggregationResultType;
695
+ id: string;
696
+ };
697
+ export type InfiniteTableRowInfoNormalType<DataType> = {
698
+ data: DataType;
699
+ isGroupRow: false;
599
700
  };
600
- export interface InfiniteTableRowInfo<T> {
701
+ export type InfiniteTableRowInfoGroupType<DataType> = {
702
+ data: Partial<DataType> | null;
703
+ isGroupRow: true;
704
+ };
705
+ export type InfiniteTableRowInfoNormal<T> = InfiniteTableRowInfoBase<T> & InfiniteTableRowInfoNormalType<T>;
706
+ export type InfiniteTableRowInfoGroup<T> = InfiniteTableRowInfoBase<T> & InfiniteTableRowInfoGroupType<T>;
707
+ export type InfiniteTableRowInfo<T> = InfiniteTableRowInfoNormal<T> | InfiniteTableRowInfoGroup<T>;
708
+ export type InfiniteTableRowInfoBase<T> = {
601
709
  id: any;
602
- data: T | null;
603
- groupData?: T[];
604
710
  value?: any;
605
- isGroupRow?: boolean;
711
+ groupData?: T[];
606
712
  collapsed: boolean;
607
713
  collapsedChildrenCount?: number;
608
714
  collapsedGroupsCount?: number;
@@ -615,10 +721,10 @@ declare module "utils/groupAndPivot/index" {
615
721
  groupCount?: number;
616
722
  groupBy?: (keyof T)[];
617
723
  pivotValuesMap?: PivotValuesDeepMap<T, any>;
618
- reducerResults?: any[];
619
- }
620
- export interface InfiniteTableEnhancedGroupInfo<T> extends InfiniteTableRowInfo<T> {
621
- data: null;
724
+ reducerResults?: Record<string, AggregationReducerResult>;
725
+ };
726
+ export type InfiniteTableEnhancedGroupInfo<T> = InfiniteTableRowInfo<T> & {
727
+ data: Partial<T> | null;
622
728
  groupData: T[];
623
729
  value: any;
624
730
  isGroupRow: true;
@@ -629,9 +735,9 @@ declare module "utils/groupAndPivot/index" {
629
735
  groupCount: number;
630
736
  groupBy: (keyof T)[];
631
737
  pivotValuesMap?: PivotValuesDeepMap<T, any>;
632
- }
738
+ };
633
739
  export type GroupKeyType<T extends any = any> = T;
634
- type PivotReducerResults<T = any> = T[];
740
+ type PivotReducerResults<T = any> = Record<string, AggregationReducerResult<T>>;
635
741
  type PivotGroupValueType<DataType, KeyType> = {
636
742
  reducerResults: PivotReducerResults<KeyType>;
637
743
  items: DataType[];
@@ -639,7 +745,7 @@ declare module "utils/groupAndPivot/index" {
639
745
  export type PivotValuesDeepMap<DataType, KeyType> = DeepMap<GroupKeyType<KeyType>, PivotGroupValueType<DataType, KeyType>>;
640
746
  export type DeepMapGroupValueType<DataType, KeyType> = {
641
747
  items: DataType[];
642
- reducerResults: any[];
748
+ reducerResults: Record<string, AggregationReducerResult>;
643
749
  pivotDeepMap?: DeepMap<GroupKeyType<KeyType>, PivotGroupValueType<DataType, KeyType>>;
644
750
  };
645
751
  export type GroupBy<DataType, KeyType> = {
@@ -648,30 +754,38 @@ declare module "utils/groupAndPivot/index" {
648
754
  column?: Partial<InfiniteTableGroupColumnBase<DataType>>;
649
755
  };
650
756
  export type PivotBy<DataType, KeyType> = Omit<GroupBy<DataType, KeyType>, 'column'> & {
651
- column?: InfiniteTablePivotColumn<DataType> | (({ column, }: {
652
- column: InfiniteTablePivotFinalColumn<DataType, KeyType>;
757
+ column?: InfiniteTableColumn<DataType> | (({ column, }: {
758
+ column: InfiniteTablePivotFinalColumnVariant<DataType, KeyType>;
653
759
  }) => Partial<InfiniteTablePivotColumn<DataType>>);
760
+ columnGroup?: InfiniteTableColumnGroup | (({ columnGroup, }: {
761
+ columnGroup: InfiniteTablePivotFinalColumnGroup<DataType, KeyType>;
762
+ }) => Partial<InfiniteTablePivotFinalColumnGroup<DataType>>);
654
763
  };
655
764
  type GroupParams<DataType, KeyType> = {
656
765
  groupBy: GroupBy<DataType, KeyType>[];
657
766
  defaultToKey?: (value: any, item: DataType) => GroupKeyType<KeyType>;
658
767
  pivot?: PivotBy<DataType, KeyType>[];
659
- reducers?: AggregationReducer<DataType, any>[];
768
+ reducers?: Record<string, DataSourceAggregationReducer<DataType, any>>;
769
+ };
770
+ type LazyGroupParams = {
771
+ mappings?: DataSourceMappings;
660
772
  };
661
773
  export type DataGroupResult<DataType, KeyType extends any> = {
662
774
  deepMap: DeepMap<GroupKeyType<KeyType>, DeepMapGroupValueType<DataType, KeyType>>;
663
775
  groupParams: GroupParams<DataType, KeyType>;
664
776
  initialData: DataType[];
665
- reducerResults?: any[];
777
+ reducerResults?: Record<string, AggregationReducerResult>;
666
778
  topLevelPivotColumns?: DeepMap<GroupKeyType<KeyType>, boolean>;
667
779
  pivot?: PivotBy<DataType, KeyType>[];
668
780
  };
781
+ export function lazyGroup<DataType, KeyType extends string = string>(groupParams: GroupParams<DataType, KeyType> & LazyGroupParams, rootData: LazyGroupDataDeepMap<DataType>): DataGroupResult<DataType, KeyType>;
669
782
  export function group<DataType, KeyType = any>(groupParams: GroupParams<DataType, KeyType>, data: DataType[]): DataGroupResult<DataType, KeyType>;
670
783
  export function flatten<DataType, KeyType extends any>(groupResult: DataGroupResult<DataType, KeyType>): DataType[];
671
784
  export type EnhancedFlattenParam<DataType, KeyType = any> = {
672
785
  groupResult: DataGroupResult<DataType, KeyType>;
673
786
  toPrimaryKey: (data: DataType) => any;
674
787
  groupRowsState?: GroupRowsState;
788
+ reducers?: Record<string, DataSourceAggregationReducer<DataType, any>>;
675
789
  generateGroupRows: boolean;
676
790
  };
677
791
  export function enhancedFlatten<DataType, KeyType = any>(param: EnhancedFlattenParam<DataType, KeyType>): {
@@ -859,35 +973,43 @@ declare module "components/InfiniteTable/components/LoadMask" {
859
973
  declare module "components/InfiniteTable/types/InfiniteTableProps" {
860
974
  import * as React from 'react';
861
975
  import { InfiniteTableState } from "components/InfiniteTable/types/index";
862
- import { AggregationReducer, InfiniteTableRowInfo } from "utils/groupAndPivot/index";
863
- import { DataSourceGroupRowsBy, DataSourcePropGroupRowsBy, DataSourcePropPivotBy, DataSourceState } from "components/DataSource/index";
976
+ import { AggregationReducer, InfiniteTableRowInfoGroup, InfiniteTableRowInfoNormal } from "utils/groupAndPivot/index";
977
+ import { DataSourceGroupBy, DataSourcePropGroupBy, DataSourcePropPivotBy, DataSourceState } from "components/DataSource/index";
864
978
  import { Renderable } from "components/types/Renderable";
865
979
  import { LoadMaskProps } from "components/InfiniteTable/components/LoadMask";
866
- import type { InfiniteTableBaseColumn, InfiniteTableColumn, InfiniteTableColumnRenderFunction, InfiniteTableComputedColumn, InfiniteTablePivotColumn } from "components/InfiniteTable/types/InfiniteTableColumn";
980
+ import type { InfiniteTableColumn, InfiniteTableColumnRenderFunction, InfiniteTableComputedColumn, InfiniteTableComputedPivotFinalColumn, InfiniteTablePivotColumn, InfiniteTablePivotFinalColumn } from "components/InfiniteTable/types/InfiniteTableColumn";
867
981
  import { InfiniteTablePropPivotTotalColumnPosition } from "components/InfiniteTable/types/InfiniteTableState";
868
982
  export type InfiniteTablePropColumnOrderNormalized = string[];
869
983
  export type InfiniteTablePropColumnOrder = InfiniteTablePropColumnOrderNormalized | true;
870
- export type InfiniteTablePropColumnVisibility = Map<string, false>;
871
- export type InfiniteTablePropColumnPinning = Map<string, true | 'start' | 'end'>;
984
+ export type InfiniteTablePropColumnVisibility = Record<string, false>;
985
+ export type InfiniteTablePropColumnPinningMap = Map<string, true | 'start' | 'end'>;
986
+ export type InfiniteTableColumnPinnedValues = false | 'start' | 'end';
987
+ export type InfiniteTablePropColumnPinningRecord = Record<string, true | 'start' | 'end'>;
988
+ export type InfiniteTablePropColumnPinning = InfiniteTablePropColumnPinningRecord | InfiniteTablePropColumnPinningMap;
872
989
  export type InfiniteTableRowStyleFnParams<T> = {
873
- data: T | null;
874
- rowInfo: InfiniteTableRowInfo<T>;
875
990
  rowIndex: number;
876
- groupRowsBy?: (keyof T)[];
877
- };
991
+ groupBy?: (keyof T)[];
992
+ } & ({
993
+ data: T;
994
+ rowInfo: InfiniteTableRowInfoNormal<T>;
995
+ } | {
996
+ data: Partial<T> | null;
997
+ rowInfo: InfiniteTableRowInfoGroup<T>;
998
+ });
878
999
  export type InfiniteTableRowStyleFn<T> = (params: InfiniteTableRowStyleFnParams<T>) => undefined | React.CSSProperties;
879
1000
  export type InfiniteTableRowClassNameFn<T> = (params: InfiniteTableRowStyleFnParams<T>) => string | undefined;
880
1001
  export type InfiniteTablePropRowStyle<T> = React.CSSProperties | InfiniteTableRowStyleFn<T>;
881
1002
  export type InfiniteTablePropRowClassName<T> = string | InfiniteTableRowClassNameFn<T>;
882
- export type InfiniteTableColumnAggregator<T, AggregationResultType> = Omit<AggregationReducer<T, AggregationResultType>, 'getter'> & {
1003
+ export type InfiniteTableColumnAggregator<T, AggregationResultType> = Omit<AggregationReducer<T, AggregationResultType>, 'getter' | 'id'> & {
883
1004
  getter?: AggregationReducer<T, AggregationResultType>['getter'];
1005
+ field?: keyof T;
884
1006
  };
885
- export type InfiniteTablePropColumnAggregations<T> = Map<string, InfiniteTableColumnAggregator<T, any>>;
886
1007
  export type InfiniteTableColumnType<T> = {
887
1008
  minWidth?: number;
888
1009
  maxWidth?: number;
889
- width?: number;
890
- flex?: number;
1010
+ defaultWidth?: number;
1011
+ defaultFlex?: number;
1012
+ defaultPinned?: InfiniteTableColumnPinnedValues;
891
1013
  header?: InfiniteTableColumn<T>['header'];
892
1014
  comparer?: InfiniteTableColumn<T>['comparer'];
893
1015
  draggable?: InfiniteTableColumn<T>['draggable'];
@@ -897,6 +1019,7 @@ declare module "components/InfiniteTable/types/InfiniteTableProps" {
897
1019
  verticalAlign?: InfiniteTableColumn<T>['verticalAlign'];
898
1020
  renderValue?: InfiniteTableColumn<T>['renderValue'];
899
1021
  render?: InfiniteTableColumn<T>['render'];
1022
+ valueGetter?: InfiniteTableColumn<T>['valueGetter'];
900
1023
  };
901
1024
  export type InfiniteTablePropColumnTypesMap<T> = Map<'default' | string, InfiniteTableColumnType<T>>;
902
1025
  export type InfiniteTablePropColumnTypes<T> = InfiniteTablePropColumnTypesMap<T> | Record<'default' | string, InfiniteTableColumnType<T>>;
@@ -911,7 +1034,6 @@ declare module "components/InfiniteTable/types/InfiniteTableProps" {
911
1034
  export type InfiniteTableImperativeApi<T> = {
912
1035
  setColumnOrder: (columnOrder: InfiniteTablePropColumnOrder) => void;
913
1036
  setColumnVisibility: (columnVisibility: InfiniteTablePropColumnVisibility) => void;
914
- setColumnAggregations: (columnAggregations: InfiniteTablePropColumnAggregations<T>) => void;
915
1037
  x?: T;
916
1038
  getState: () => InfiniteTableState<T>;
917
1039
  getDataSourceState: () => DataSourceState<T>;
@@ -925,11 +1047,14 @@ declare module "components/InfiniteTable/types/InfiniteTableProps" {
925
1047
  export type InfiniteTablePropColumns<T, ColumnType = InfiniteTableColumn<T>> = InfiniteTablePropColumnsMap<T, ColumnType> | Record<string, ColumnType>;
926
1048
  export type InfiniteTableColumns<T> = InfiniteTablePropColumns<T>;
927
1049
  export type InfiniteTableColumnsMap<T> = InfiniteTablePropColumnsMap<T>;
928
- export type InfiniteTablePropColumnGroups = Map<string, InfiniteTableColumnGroup>;
1050
+ export type InfiniteTablePropColumnGroupsMap = Map<string, InfiniteTableColumnGroup>;
1051
+ export type InfiniteTablePropColumnGroupsRecord = Record<string, InfiniteTableColumnGroup>;
1052
+ export type InfiniteTablePropColumnGroups = InfiniteTablePropColumnGroupsRecord | InfiniteTablePropColumnGroupsMap;
929
1053
  /**
930
1054
  * the keys is an array of strings: first string in the array is the column group id, next strings are the ids of all columns in the group
931
1055
  * the value is the id of the column to leave as visible
932
1056
  */
1057
+ export type InfiniteTablePropCollapsedColumnGroupsMap = Map<string[], string>;
933
1058
  export type InfiniteTablePropCollapsedColumnGroups = Map<string[], string>;
934
1059
  export type InfiniteTableColumnGroupHeaderRenderParams = {
935
1060
  columnGroup: InfiniteTableComputedColumnGroup;
@@ -949,52 +1074,54 @@ declare module "components/InfiniteTable/types/InfiniteTableProps" {
949
1074
  };
950
1075
  export type InfiniteTableGroupColumnGetterOptions<T> = {
951
1076
  groupIndexForColumn?: number;
952
- groupByForColumn?: DataSourceGroupRowsBy<T>;
1077
+ groupByForColumn?: DataSourceGroupBy<T>;
953
1078
  groupRenderStrategy: InfiniteTablePropGroupRenderStrategy;
954
1079
  groupCount: number;
955
- groupRowsBy: DataSourceGroupRowsBy<T>[];
1080
+ groupBy: DataSourceGroupBy<T>[];
956
1081
  };
957
- export type InfiniteTablePivotColumnGetterOptions<T> = {
958
- column: InfiniteTablePivotColumn<T>;
959
- groupRowsBy: DataSourcePropGroupRowsBy<T>;
1082
+ export type InfiniteTablePivotColumnGetterOptions<T, COL_TYPE = InfiniteTableColumn<T>> = {
1083
+ column: COL_TYPE;
1084
+ groupBy: DataSourcePropGroupBy<T>;
960
1085
  pivotBy: DataSourcePropPivotBy<T>;
961
1086
  };
962
1087
  export type InfiniteTablePropGroupRenderStrategy = 'single-column' | 'multi-column' | 'inline';
963
- export type InfiniteTableGroupColumnBase<T> = InfiniteTableBaseColumn<T> & {
1088
+ export type InfiniteTableGroupColumnBase<T> = InfiniteTableColumn<T> & {
964
1089
  renderValue?: InfiniteTableColumnRenderFunction<T>;
965
1090
  id?: string;
966
1091
  };
967
1092
  export type InfiniteTablePivotColumnBase<T> = InfiniteTableColumn<T> & {
968
- renderValue?: InfiniteTableColumnRenderFunction<T>;
969
- id?: string;
1093
+ renderValue?: InfiniteTableColumnRenderFunction<T, InfiniteTableComputedPivotFinalColumn<T>>;
970
1094
  };
971
1095
  export type InfiniteTablePropGroupColumn<T> = InfiniteTableGroupColumnBase<T> | InfiniteTableGroupColumnFunction<T>;
972
1096
  export type InfiniteTableGroupColumnFunction<T> = (options: InfiniteTableGroupColumnGetterOptions<T>, toggleGroupRow: (groupKeys: any[]) => void) => InfiniteTableGroupColumnBase<T>;
973
- export type InfiniteTablePropPivotColumn<T> = InfiniteTablePivotColumnBase<T> | ((options: InfiniteTablePivotColumnGetterOptions<T>) => InfiniteTablePivotColumnBase<T>);
1097
+ export type InfiniteTablePropPivotColumn<T, COL_TYPE = InfiniteTableColumn<T>> = Partial<InfiniteTablePivotColumnBase<T>> | ((options: InfiniteTablePivotColumnGetterOptions<T, COL_TYPE>) => InfiniteTablePivotColumnBase<T>);
974
1098
  export type InfiniteTablePropPivotRowLabelsColumn<T> = InfiniteTablePropPivotColumn<T>;
975
1099
  export type InfiniteTablePropComponents = {
976
1100
  LoadMask?: React.FC<LoadMaskProps>;
977
1101
  };
1102
+ export type ScrollStopInfo = {
1103
+ scrollTop: number;
1104
+ firstVisibleRowIndex: number;
1105
+ lastVisibleRowIndex: number;
1106
+ };
978
1107
  export interface InfiniteTableProps<T> {
979
1108
  columns: InfiniteTablePropColumns<T>;
980
1109
  pivotColumns?: InfiniteTablePropColumnsMap<T, InfiniteTablePivotColumn<T>>;
981
1110
  loadingText?: Renderable;
982
1111
  components?: InfiniteTablePropComponents;
983
1112
  viewportReservedWidth?: number;
984
- pivotColumn?: Partial<InfiniteTablePropPivotColumn<T>>;
985
- pivotRowLabelsColumn?: Partial<InfiniteTablePropPivotRowLabelsColumn<T>>;
1113
+ pivotColumn?: InfiniteTablePropPivotColumn<T, InfiniteTableColumn<T> & InfiniteTablePivotFinalColumn<T>>;
1114
+ pivotRowLabelsColumn?: InfiniteTablePropPivotRowLabelsColumn<T>;
986
1115
  pivotTotalColumnPosition?: InfiniteTablePropPivotTotalColumnPosition;
987
1116
  groupColumn?: Partial<InfiniteTablePropGroupColumn<T>>;
988
1117
  groupRenderStrategy?: InfiniteTablePropGroupRenderStrategy;
989
1118
  hideEmptyGroupColumns?: boolean;
990
1119
  columnVisibility?: InfiniteTablePropColumnVisibility;
991
1120
  defaultColumnVisibility?: InfiniteTablePropColumnVisibility;
992
- columnPinning?: InfiniteTablePropColumnPinning;
993
1121
  pinnedStartMaxWidth?: number;
994
1122
  pinnedEndMaxWidth?: number;
1123
+ columnPinning?: InfiniteTablePropColumnPinning;
995
1124
  defaultColumnPinning?: InfiniteTablePropColumnPinning;
996
- defaultColumnAggregations?: InfiniteTablePropColumnAggregations<T>;
997
- columnAggregations?: InfiniteTablePropColumnAggregations<T>;
998
1125
  columnSizing?: InfiniteTablePropColumnSizing;
999
1126
  defaultColumnSizing?: InfiniteTablePropColumnSizing;
1000
1127
  pivotColumnGroups?: InfiniteTablePropColumnGroups;
@@ -1005,6 +1132,7 @@ declare module "components/InfiniteTable/types/InfiniteTableProps" {
1005
1132
  onScrollbarsChange?: (scrollbars: Scrollbars) => void;
1006
1133
  onColumnVisibilityChange?: (columnVisibility: InfiniteTablePropColumnVisibility) => void;
1007
1134
  columnTypes?: InfiniteTablePropColumnTypes<T>;
1135
+ showSeparatePivotColumnForSingleAggregation?: boolean;
1008
1136
  rowHeight: number | string;
1009
1137
  rowStyle?: InfiniteTablePropRowStyle<T>;
1010
1138
  rowClassName?: InfiniteTablePropRowClassName<T>;
@@ -1032,6 +1160,8 @@ declare module "components/InfiniteTable/types/InfiniteTableProps" {
1032
1160
  onBlurWithin?: (event: React.FocusEvent<HTMLDivElement>) => void;
1033
1161
  onScrollToTop?: () => void;
1034
1162
  onScrollToBottom?: () => void;
1163
+ scrollStopDelay?: number;
1164
+ onScrollStop?: (param: ScrollStopInfo) => void;
1035
1165
  scrollToBottomOffset?: number;
1036
1166
  defaultColumnOrder?: InfiniteTablePropColumnOrder;
1037
1167
  columnOrder?: InfiniteTablePropColumnOrder;
@@ -1071,7 +1201,7 @@ declare module "components/VirtualBrain/ScrollListener" {
1071
1201
  }
1072
1202
  declare module "components/InfiniteTable/types/InfiniteTableState" {
1073
1203
  import type { ScrollPosition } from "components/types/ScrollPosition";
1074
- import type { InfiniteTableColumnGroup, InfiniteTablePropColumnGroups, InfiniteTablePropColumnSizingMap, InfiniteTablePropColumnsMap, InfiniteTablePropColumnTypesMap, InfiniteTableProps } from "components/InfiniteTable/types/InfiniteTableProps";
1204
+ import type { InfiniteTableColumnGroup, InfiniteTablePropColumnGroupsMap, InfiniteTablePropColumnPinningMap, InfiniteTablePropColumnSizingMap, InfiniteTablePropColumnsMap, InfiniteTablePropColumnTypesMap, InfiniteTablePropColumnVisibility, InfiniteTableProps } from "components/InfiniteTable/types/InfiniteTableProps";
1075
1205
  import { Size } from "components/types/Size";
1076
1206
  import { MutableRefObject } from 'react';
1077
1207
  import { SubscriptionCallback } from "components/types/SubscriptionCallback";
@@ -1079,12 +1209,13 @@ declare module "components/InfiniteTable/types/InfiniteTableState" {
1079
1209
  import { NonUndefined } from "components/types/NonUndefined";
1080
1210
  import { InfiniteTableColumn, InfiniteTablePivotColumn } from "components/InfiniteTable/types/InfiniteTableColumn";
1081
1211
  import { ComponentStateActions } from "components/hooks/useComponentState";
1082
- import { DataSourceGroupRowsBy, DataSourceProps } from "components/DataSource/types";
1083
- export type GroupRowsMap<T> = Map<keyof T, {
1084
- groupBy: DataSourceGroupRowsBy<T>;
1212
+ import { DataSourceGroupBy, DataSourceProps } from "components/DataSource/types";
1213
+ export type GroupByMap<T> = Map<keyof T, {
1214
+ groupBy: DataSourceGroupBy<T>;
1085
1215
  groupIndex: number;
1086
1216
  }>;
1087
1217
  export interface InfiniteTableSetupState<T> {
1218
+ propsCache: Map<keyof InfiniteTableProps<T>, WeakMap<any, any>>;
1088
1219
  columnsWhenInlineGroupRenderStrategy?: Map<string, InfiniteTableColumn<T>>;
1089
1220
  domRef: MutableRefObject<HTMLDivElement | null>;
1090
1221
  scrollerDOMRef: MutableRefObject<HTMLDivElement | null>;
@@ -1121,13 +1252,16 @@ declare module "components/InfiniteTable/types/InfiniteTableState" {
1121
1252
  onSelfBlur: InfiniteTableProps<T>['onSelfBlur'];
1122
1253
  onFocusWithin: InfiniteTableProps<T>['onFocusWithin'];
1123
1254
  onBlurWithin: InfiniteTableProps<T>['onBlurWithin'];
1255
+ scrollStopDelay: NonUndefined<InfiniteTableProps<T>['scrollStopDelay']>;
1124
1256
  onScrollToTop: InfiniteTableProps<T>['onScrollToTop'];
1125
1257
  onScrollToBottom: InfiniteTableProps<T>['onScrollToBottom'];
1258
+ onScrollStop: InfiniteTableProps<T>['onScrollStop'];
1126
1259
  scrollToBottomOffset: InfiniteTableProps<T>['scrollToBottomOffset'];
1127
1260
  focusedClassName: InfiniteTableProps<T>['focusedClassName'];
1128
1261
  focusedWithinClassName: InfiniteTableProps<T>['focusedWithinClassName'];
1129
1262
  focusedStyle: InfiniteTableProps<T>['focusedStyle'];
1130
1263
  focusedWithinStyle: InfiniteTableProps<T>['focusedWithinStyle'];
1264
+ showSeparatePivotColumnForSingleAggregation: NonUndefined<InfiniteTableProps<T>['showSeparatePivotColumnForSingleAggregation']>;
1131
1265
  domProps: InfiniteTableProps<T>['domProps'];
1132
1266
  rowStyle: InfiniteTableProps<T>['rowStyle'];
1133
1267
  rowProps: InfiniteTableProps<T>['rowProps'];
@@ -1136,7 +1270,7 @@ declare module "components/InfiniteTable/types/InfiniteTableState" {
1136
1270
  pinnedEndMaxWidth: InfiniteTableProps<T>['pinnedEndMaxWidth'];
1137
1271
  pivotColumn: InfiniteTableProps<T>['pivotColumn'];
1138
1272
  pivotRowLabelsColumn: InfiniteTableProps<T>['pivotRowLabelsColumn'];
1139
- pivotColumnGroups: InfiniteTableProps<T>['pivotColumnGroups'];
1273
+ pivotColumnGroups: InfiniteTablePropColumnGroupsMap;
1140
1274
  activeIndex: NonUndefined<InfiniteTableProps<T>['activeIndex']>;
1141
1275
  columnMinWidth: NonUndefined<InfiniteTableProps<T>['columnMinWidth']>;
1142
1276
  columnMaxWidth: NonUndefined<InfiniteTableProps<T>['columnMaxWidth']>;
@@ -1152,23 +1286,22 @@ declare module "components/InfiniteTable/types/InfiniteTableState" {
1152
1286
  rowHeight: number;
1153
1287
  headerHeight: number;
1154
1288
  licenseKey: NonUndefined<InfiniteTableProps<T>['licenseKey']>;
1155
- columnVisibility: NonUndefined<InfiniteTableProps<T>['columnVisibility']>;
1156
- columnPinning: NonUndefined<InfiniteTableProps<T>['columnPinning']>;
1289
+ columnVisibility: InfiniteTablePropColumnVisibility;
1290
+ columnPinning: InfiniteTablePropColumnPinningMap;
1157
1291
  columnSizing: InfiniteTablePropColumnSizingMap;
1158
1292
  columnTypes: InfiniteTablePropColumnTypesMap<T>;
1159
- columnAggregations: NonUndefined<InfiniteTableProps<T>['columnAggregations']>;
1160
- columnGroups: NonUndefined<InfiniteTableProps<T>['columnGroups']>;
1293
+ columnGroups: InfiniteTablePropColumnGroupsMap;
1161
1294
  collapsedColumnGroups: NonUndefined<InfiniteTableProps<T>['collapsedColumnGroups']>;
1162
1295
  pivotTotalColumnPosition: NonUndefined<InfiniteTableProps<T>['pivotTotalColumnPosition']>;
1163
1296
  }
1164
1297
  export interface InfiniteTableDerivedState<T> {
1165
- groupRowsBy: DataSourceProps<T>['groupRowsBy'];
1298
+ groupBy: DataSourceProps<T>['groupBy'];
1166
1299
  computedColumns: Map<string, InfiniteTableColumn<T>>;
1167
1300
  virtualizeHeader: boolean;
1168
1301
  groupRenderStrategy: NonUndefined<InfiniteTableProps<T>['groupRenderStrategy']>;
1169
1302
  columnGroupsDepthsMap: InfiniteTableColumnGroupsDepthsMap;
1170
1303
  columnGroupsMaxDepth: number;
1171
- computedColumnGroups: InfiniteTablePropColumnGroups;
1304
+ computedColumnGroups: InfiniteTablePropColumnGroupsMap;
1172
1305
  rowHeightCSSVar: string;
1173
1306
  headerHeightCSSVar: string;
1174
1307
  }
@@ -1236,21 +1369,24 @@ declare module "components/InfiniteTable/types/index" {
1236
1369
  import type { InfiniteTableState } from "components/InfiniteTable/types/InfiniteTableState";
1237
1370
  import type { InfiniteTableAction } from "components/InfiniteTable/types/InfiniteTableAction";
1238
1371
  import type { InfiniteTableActionType } from "components/InfiniteTable/types/InfiniteTableActionType";
1239
- import type { InfiniteTableProps, InfiniteTableImperativeApi, InfiniteTablePropColumnOrder, InfiniteTablePropColumnVisibility, InfiniteTablePropColumnPinning, InfiniteTableColumnAggregator, InfiniteTableColumnGroup, InfiniteTablePropGroupRenderStrategy, InfiniteTablePropColumnAggregations, InfiniteTablePropColumnGroups, InfiniteTablePropRowStyle, InfiniteTableRowStyleFn, InfiniteTableRowClassNameFn, InfiniteTablePropRowClassName, InfiniteTablePropColumns, InfiniteTablePropColumnsMap, InfiniteTablePropComponents, InfiniteTableGroupColumnFunction, InfiniteTableGroupColumnGetterOptions, InfiniteTablePropColumnSizingMap, InfiniteTablePropColumnSizing, InfiniteTablePropColumnTypes, InfiniteTablePropColumnTypesMap, InfiniteTableColumnSizingOptions, Scrollbars } from "components/InfiniteTable/types/InfiniteTableProps";
1372
+ import type { InfiniteTableProps, InfiniteTableImperativeApi, InfiniteTablePropColumnOrder, InfiniteTablePropColumnVisibility, InfiniteTablePropColumnPinning, InfiniteTableColumnAggregator, InfiniteTableColumnGroup, InfiniteTablePropGroupRenderStrategy, InfiniteTablePropColumnGroups, InfiniteTablePropRowStyle, InfiniteTableRowStyleFn, InfiniteTableRowClassNameFn, InfiniteTablePropRowClassName, InfiniteTablePropColumns, InfiniteTablePropColumnsMap, InfiniteTablePropComponents, InfiniteTableGroupColumnFunction, InfiniteTableGroupColumnGetterOptions, InfiniteTablePropColumnSizingMap, InfiniteTablePropColumnSizing, InfiniteTablePropColumnTypes, InfiniteTablePropColumnTypesMap, InfiniteTableColumnSizingOptions, Scrollbars } from "components/InfiniteTable/types/InfiniteTableProps";
1240
1373
  import type { InfiniteTableColumn, InfiniteTableColumnComparer, InfiniteTableComputedColumn, InfiniteTableColumnRenderParam, InfiniteTableColumnRenderValueParam } from "components/InfiniteTable/types/InfiniteTableColumn";
1241
1374
  import type { InfiniteTableComputedValues } from "components/InfiniteTable/types/InfiniteTableComputedValues";
1242
1375
  import type { InfiniteTableContextValue } from "components/InfiniteTable/types/InfiniteTableContextValue";
1243
1376
  import type { InfiniteTableRowInfo } from "utils/groupAndPivot/index";
1244
- export type { Scrollbars, InfiniteTableColumnAggregator, InfiniteTableComputedValues, InfiniteTablePropColumns, InfiniteTablePropColumnsMap, InfiniteTableRowInfo, InfiniteTableGroupColumnFunction, InfiniteTablePropColumnOrder, InfiniteTablePropComponents, InfiniteTablePropColumnVisibility, InfiniteTablePropColumnPinning, InfiniteTableColumnGroup, InfiniteTableColumn, InfiniteTableColumnComparer, InfiniteTableComputedColumn, InfiniteTableColumnRenderParam, InfiniteTableColumnRenderValueParam, InfiniteTableContextValue, InfiniteTablePropGroupRenderStrategy, InfiniteTablePropColumnAggregations, InfiniteTablePropColumnGroups, InfiniteTablePropColumnSizing, InfiniteTablePropColumnSizingMap, InfiniteTableColumnSizingOptions, InfiniteTableState, InfiniteTableAction, InfiniteTableProps, InfiniteTablePropColumnTypes, InfiniteTablePropColumnTypesMap, InfiniteTableImperativeApi, InfiniteTableActionType, InfiniteTablePropRowStyle, InfiniteTablePropRowClassName, InfiniteTableRowStyleFn, InfiniteTableRowClassNameFn, InfiniteTableGroupColumnGetterOptions, };
1377
+ export type { Scrollbars, InfiniteTableColumnAggregator, InfiniteTableComputedValues, InfiniteTablePropColumns, InfiniteTablePropColumnsMap, InfiniteTableRowInfo, InfiniteTableGroupColumnFunction, InfiniteTablePropColumnOrder, InfiniteTablePropComponents, InfiniteTablePropColumnVisibility as InfiniteTablePropColumnVisibility, InfiniteTablePropColumnPinning, InfiniteTableColumnGroup, InfiniteTableColumn, InfiniteTableColumnComparer, InfiniteTableComputedColumn, InfiniteTableColumnRenderParam, InfiniteTableColumnRenderValueParam, InfiniteTableContextValue, InfiniteTablePropGroupRenderStrategy, InfiniteTablePropColumnGroups, InfiniteTablePropColumnSizing, InfiniteTablePropColumnSizingMap, InfiniteTableColumnSizingOptions, InfiniteTableState, InfiniteTableAction, InfiniteTableProps, InfiniteTablePropColumnTypes, InfiniteTablePropColumnTypesMap, InfiniteTableImperativeApi, InfiniteTableActionType, InfiniteTablePropRowStyle, InfiniteTablePropRowClassName, InfiniteTableRowStyleFn, InfiniteTableRowClassNameFn, InfiniteTableGroupColumnGetterOptions, };
1245
1378
  }
1246
1379
  declare module "components/InfiniteTable/InfiniteTableContext" {
1247
1380
  import { InfiniteTableContextValue } from "components/InfiniteTable/types/InfiniteTableContextValue";
1248
1381
  export function getInfiniteTableContext<T>(): React.Context<InfiniteTableContextValue<T>>;
1249
1382
  }
1383
+ declare module "components/InfiniteTable/utils/toMap" {
1384
+ export function toMap<K extends string, V>(mapOrObject?: Map<K, V> | Record<K, V>, weakMapCache?: WeakMap<any, any>): Map<K, V>;
1385
+ }
1250
1386
  declare module "components/InfiniteTable/state/computeColumnGroupsDepths" {
1251
- import type { InfiniteTablePropColumnGroups } from "components/InfiniteTable/types/InfiniteTableProps";
1387
+ import type { InfiniteTablePropColumnGroupsMap } from "components/InfiniteTable/types/InfiniteTableProps";
1252
1388
  import type { InfiniteTableColumnGroupsDepthsMap } from "components/InfiniteTable/types/InfiniteTableState";
1253
- export function computeColumnGroupsDepths(columnGroups: InfiniteTablePropColumnGroups): InfiniteTableColumnGroupsDepthsMap;
1389
+ export function computeColumnGroupsDepths(columnGroups: InfiniteTablePropColumnGroupsMap): InfiniteTableColumnGroupsDepthsMap;
1254
1390
  }
1255
1391
  declare module "components/InfiniteTable/state/getInitialState" {
1256
1392
  import { DataSourceState } from "components/DataSource/index";
@@ -1263,59 +1399,61 @@ declare module "components/InfiniteTable/state/getInitialState" {
1263
1399
  * be affected by props
1264
1400
  */
1265
1401
  export function initSetupState<T>(): InfiniteTableSetupState<T>;
1266
- export const forwardProps: <T>() => Partial<{
1402
+ export const forwardProps: <T>(setupState: InfiniteTableSetupState<T>) => Partial<{
1267
1403
  columns: 1 | ((value: import("components/InfiniteTable/types").InfiniteTablePropColumns<T, import("components/InfiniteTable/types").InfiniteTableColumn<T>>) => import("components/InfiniteTable/types").InfiniteTablePropColumnsMap<T, import("components/InfiniteTable/types").InfiniteTableColumn<T>>);
1268
1404
  header: 1 | ((value: boolean | undefined) => boolean);
1405
+ showSeparatePivotColumnForSingleAggregation: 1 | ((value: boolean | undefined) => boolean);
1269
1406
  pivotTotalColumnPosition: 1 | ((value: import("components/InfiniteTable/types/InfiniteTableState").InfiniteTablePropPivotTotalColumnPosition | undefined) => import("components/InfiniteTable/types/InfiniteTableState").InfiniteTablePropPivotTotalColumnPosition);
1270
1407
  pivotColumns: 1 | ((value: import("components/InfiniteTable/types").InfiniteTablePropColumnsMap<T, import("components/InfiniteTable/types/InfiniteTableColumn").InfiniteTablePivotColumn<T>> | undefined) => import("components/InfiniteTable/types").InfiniteTablePropColumnsMap<T, import("components/InfiniteTable/types/InfiniteTableColumn").InfiniteTablePivotColumn<T>> | undefined);
1271
- pivotColumnGroups: 1 | ((value: import("components/InfiniteTable/types").InfiniteTablePropColumnGroups | undefined) => import("components/InfiniteTable/types").InfiniteTablePropColumnGroups | undefined);
1272
- pivotColumn: 1 | ((value: Partial<import("components/InfiniteTable/types/InfiniteTableProps").InfiniteTablePropPivotColumn<T>> | undefined) => Partial<import("components/InfiniteTable/types/InfiniteTableProps").InfiniteTablePropPivotColumn<T>> | undefined);
1408
+ pivotColumnGroups: 1 | ((value: import("components/InfiniteTable/types").InfiniteTablePropColumnGroups | undefined) => import("components/InfiniteTable/types/InfiniteTableProps").InfiniteTablePropColumnGroupsMap);
1273
1409
  sortable: 1 | ((value: boolean | undefined) => boolean);
1410
+ pivotColumn: 1 | ((value: import("components/InfiniteTable/types/InfiniteTableProps").InfiniteTablePropPivotColumn<T, import("components/InfiniteTable/types").InfiniteTableColumn<T> & import("components/InfiniteTable/types/InfiniteTableColumn").InfiniteTablePivotFinalColumn<T, any>> | undefined) => import("components/InfiniteTable/types/InfiniteTableProps").InfiniteTablePropPivotColumn<T, import("components/InfiniteTable/types").InfiniteTableColumn<T> & import("components/InfiniteTable/types/InfiniteTableColumn").InfiniteTablePivotFinalColumn<T, any>> | undefined);
1274
1411
  components: 1 | ((value: import("components/InfiniteTable/types").InfiniteTablePropComponents | undefined) => import("components/InfiniteTable/types").InfiniteTablePropComponents | undefined);
1275
- scrollTopId: 1 | ((value: string | number | undefined) => string | number | undefined);
1412
+ loadingText: 1 | ((value: import("react").ReactNode) => import("react").ReactNode);
1276
1413
  viewportReservedWidth: 1 | ((value: number | undefined) => number | undefined);
1414
+ pivotRowLabelsColumn: 1 | ((value: import("components/InfiniteTable/types/InfiniteTableProps").InfiniteTablePropPivotRowLabelsColumn<T> | undefined) => import("components/InfiniteTable/types/InfiniteTableProps").InfiniteTablePropPivotRowLabelsColumn<T> | undefined);
1277
1415
  groupColumn: 1 | ((value: Partial<InfiniteTablePropGroupColumn<T>> | undefined) => Partial<InfiniteTablePropGroupColumn<T>> | undefined);
1416
+ hideEmptyGroupColumns: 1 | ((value: boolean | undefined) => boolean);
1417
+ columnVisibility: 1 | ((value: import("components/InfiniteTable/types").InfiniteTablePropColumnVisibility | undefined) => import("components/InfiniteTable/types").InfiniteTablePropColumnVisibility);
1418
+ pinnedStartMaxWidth: 1 | ((value: number | undefined) => number | undefined);
1419
+ pinnedEndMaxWidth: 1 | ((value: number | undefined) => number | undefined);
1420
+ columnPinning: 1 | ((value: import("components/InfiniteTable/types").InfiniteTablePropColumnPinning | undefined) => import("components/InfiniteTable/types/InfiniteTableProps").InfiniteTablePropColumnPinningMap);
1421
+ columnSizing: 1 | ((value: import("components/InfiniteTable/types").InfiniteTablePropColumnSizing | undefined) => import("components/InfiniteTable/types").InfiniteTablePropColumnSizingMap);
1422
+ columnGroups: 1 | ((value: import("components/InfiniteTable/types").InfiniteTablePropColumnGroups | undefined) => import("components/InfiniteTable/types/InfiniteTableProps").InfiniteTablePropColumnGroupsMap);
1423
+ collapsedColumnGroups: 1 | ((value: import("components/InfiniteTable/types/InfiniteTableProps").InfiniteTablePropCollapsedColumnGroups | undefined) => import("components/InfiniteTable/types/InfiniteTableProps").InfiniteTablePropCollapsedColumnGroups);
1278
1424
  onScrollbarsChange: 1 | ((value: ((scrollbars: import("components/InfiniteTable/types").Scrollbars) => void) | undefined) => ((scrollbars: import("components/InfiniteTable/types").Scrollbars) => void) | undefined);
1279
- loadingText: 1 | ((value: import("react").ReactNode) => import("react").ReactNode);
1280
- onReady: 1 | ((value: ((api: import("components/InfiniteTable/types").InfiniteTableImperativeApi<T>) => void) | undefined) => ((api: import("components/InfiniteTable/types").InfiniteTableImperativeApi<T>) => void) | undefined);
1425
+ columnTypes: 1 | ((value: import("components/InfiniteTable/types").InfiniteTablePropColumnTypes<T> | undefined) => import("components/InfiniteTable/types").InfiniteTablePropColumnTypesMap<T>);
1426
+ rowHeight: 1 | ((value: string | number) => number);
1427
+ rowStyle: 1 | ((value: import("components/InfiniteTable/types").InfiniteTablePropRowStyle<T> | undefined) => import("components/InfiniteTable/types").InfiniteTablePropRowStyle<T> | undefined);
1428
+ rowClassName: 1 | ((value: import("components/InfiniteTable/types").InfiniteTablePropRowClassName<T> | undefined) => import("components/InfiniteTable/types").InfiniteTablePropRowClassName<T> | undefined);
1429
+ headerHeight: 1 | ((value: string | number) => number);
1430
+ domProps: 1 | ((value: import("react").HTMLProps<HTMLDivElement> | undefined) => import("react").HTMLProps<HTMLDivElement> | undefined);
1431
+ showZebraRows: 1 | ((value: boolean | undefined) => boolean);
1432
+ showHoverRows: 1 | ((value: boolean | undefined) => boolean);
1433
+ draggableColumns: 1 | ((value: boolean | undefined) => boolean);
1434
+ focusedClassName: 1 | ((value: string | undefined) => string | undefined);
1435
+ focusedWithinClassName: 1 | ((value: string | undefined) => string | undefined);
1436
+ focusedStyle: 1 | ((value: import("react").CSSProperties | undefined) => import("react").CSSProperties | undefined);
1437
+ focusedWithinStyle: 1 | ((value: import("react").CSSProperties | undefined) => import("react").CSSProperties | undefined);
1438
+ columnDefaultWidth: 1 | ((value: number | undefined) => number);
1439
+ columnMinWidth: 1 | ((value: number | undefined) => number);
1440
+ columnMaxWidth: 1 | ((value: number | undefined) => number);
1441
+ virtualizeColumns: 1 | ((value: import("components/InfiniteTable/types/InfiniteTableProps").InfiniteTablePropVirtualizeColumns<T> | undefined) => import("components/InfiniteTable/types/InfiniteTableProps").InfiniteTablePropVirtualizeColumns<T>);
1442
+ activeIndex: 1 | ((value: number | undefined) => number);
1281
1443
  onSelfFocus: 1 | ((value: ((event: import("react").FocusEvent<HTMLDivElement, Element>) => void) | undefined) => ((event: import("react").FocusEvent<HTMLDivElement, Element>) => void) | undefined);
1282
1444
  onSelfBlur: 1 | ((value: ((event: import("react").FocusEvent<HTMLDivElement, Element>) => void) | undefined) => ((event: import("react").FocusEvent<HTMLDivElement, Element>) => void) | undefined);
1283
1445
  onFocusWithin: 1 | ((value: ((event: import("react").FocusEvent<HTMLDivElement, Element>) => void) | undefined) => ((event: import("react").FocusEvent<HTMLDivElement, Element>) => void) | undefined);
1284
1446
  onBlurWithin: 1 | ((value: ((event: import("react").FocusEvent<HTMLDivElement, Element>) => void) | undefined) => ((event: import("react").FocusEvent<HTMLDivElement, Element>) => void) | undefined);
1285
1447
  onScrollToTop: 1 | ((value: (() => void) | undefined) => (() => void) | undefined);
1286
1448
  onScrollToBottom: 1 | ((value: (() => void) | undefined) => (() => void) | undefined);
1449
+ scrollStopDelay: 1 | ((value: number | undefined) => number);
1450
+ onScrollStop: 1 | ((value: ((param: import("components/InfiniteTable/types/InfiniteTableProps").ScrollStopInfo) => void) | undefined) => ((param: import("components/InfiniteTable/types/InfiniteTableProps").ScrollStopInfo) => void) | undefined);
1287
1451
  scrollToBottomOffset: 1 | ((value: number | undefined) => number | undefined);
1288
- focusedClassName: 1 | ((value: string | undefined) => string | undefined);
1289
- focusedWithinClassName: 1 | ((value: string | undefined) => string | undefined);
1290
- focusedStyle: 1 | ((value: import("react").CSSProperties | undefined) => import("react").CSSProperties | undefined);
1291
- focusedWithinStyle: 1 | ((value: import("react").CSSProperties | undefined) => import("react").CSSProperties | undefined);
1292
- domProps: 1 | ((value: import("react").HTMLProps<HTMLDivElement> | undefined) => import("react").HTMLProps<HTMLDivElement> | undefined);
1293
- rowStyle: 1 | ((value: import("components/InfiniteTable/types").InfiniteTablePropRowStyle<T> | undefined) => import("components/InfiniteTable/types").InfiniteTablePropRowStyle<T> | undefined);
1294
- rowProps: 1 | ((value: import("react").HTMLProps<HTMLDivElement> | ((rowArgs: import("components/InfiniteTable/types/InfiniteTableProps").InfiniteTableRowStyleFnParams<T>) => import("react").HTMLProps<HTMLDivElement>) | undefined) => import("react").HTMLProps<HTMLDivElement> | ((rowArgs: import("components/InfiniteTable/types/InfiniteTableProps").InfiniteTableRowStyleFnParams<T>) => import("react").HTMLProps<HTMLDivElement>) | undefined);
1295
- rowClassName: 1 | ((value: import("components/InfiniteTable/types").InfiniteTablePropRowClassName<T> | undefined) => import("components/InfiniteTable/types").InfiniteTablePropRowClassName<T> | undefined);
1296
- pinnedStartMaxWidth: 1 | ((value: number | undefined) => number | undefined);
1297
- pinnedEndMaxWidth: 1 | ((value: number | undefined) => number | undefined);
1298
- pivotRowLabelsColumn: 1 | ((value: Partial<import("components/InfiniteTable/types/InfiniteTableProps").InfiniteTablePropPivotRowLabelsColumn<T>> | undefined) => Partial<import("components/InfiniteTable/types/InfiniteTableProps").InfiniteTablePropPivotRowLabelsColumn<T>> | undefined);
1299
- activeIndex: 1 | ((value: number | undefined) => number);
1300
- columnMinWidth: 1 | ((value: number | undefined) => number);
1301
- columnMaxWidth: 1 | ((value: number | undefined) => number);
1302
- columnDefaultWidth: 1 | ((value: number | undefined) => number);
1303
- draggableColumns: 1 | ((value: boolean | undefined) => boolean);
1304
- hideEmptyGroupColumns: 1 | ((value: boolean | undefined) => boolean);
1305
1452
  columnOrder: 1 | ((value: import("components/InfiniteTable/types").InfiniteTablePropColumnOrder | undefined) => import("components/InfiniteTable/types").InfiniteTablePropColumnOrder);
1306
- showZebraRows: 1 | ((value: boolean | undefined) => boolean);
1307
- showHoverRows: 1 | ((value: boolean | undefined) => boolean);
1308
- virtualizeColumns: 1 | ((value: import("components/InfiniteTable/types/InfiniteTableProps").InfiniteTablePropVirtualizeColumns<T> | undefined) => import("components/InfiniteTable/types/InfiniteTableProps").InfiniteTablePropVirtualizeColumns<T>);
1453
+ onReady: 1 | ((value: ((api: import("components/InfiniteTable/types").InfiniteTableImperativeApi<T>) => void) | undefined) => ((api: import("components/InfiniteTable/types").InfiniteTableImperativeApi<T>) => void) | undefined);
1454
+ rowProps: 1 | ((value: import("react").HTMLProps<HTMLDivElement> | ((rowArgs: import("components/InfiniteTable/types/InfiniteTableProps").InfiniteTableRowStyleFnParams<T>) => import("react").HTMLProps<HTMLDivElement>) | undefined) => import("react").HTMLProps<HTMLDivElement> | ((rowArgs: import("components/InfiniteTable/types/InfiniteTableProps").InfiniteTableRowStyleFnParams<T>) => import("react").HTMLProps<HTMLDivElement>) | undefined);
1309
1455
  licenseKey: 1 | ((value: string | undefined) => string);
1310
- columnVisibility: 1 | ((value: import("components/InfiniteTable/types").InfiniteTablePropColumnVisibility | undefined) => import("components/InfiniteTable/types").InfiniteTablePropColumnVisibility);
1311
- columnPinning: 1 | ((value: import("components/InfiniteTable/types").InfiniteTablePropColumnPinning | undefined) => import("components/InfiniteTable/types").InfiniteTablePropColumnPinning);
1312
- columnAggregations: 1 | ((value: import("components/InfiniteTable/types").InfiniteTablePropColumnAggregations<T> | undefined) => import("components/InfiniteTable/types").InfiniteTablePropColumnAggregations<T>);
1313
- columnGroups: 1 | ((value: import("components/InfiniteTable/types").InfiniteTablePropColumnGroups | undefined) => import("components/InfiniteTable/types").InfiniteTablePropColumnGroups);
1314
- collapsedColumnGroups: 1 | ((value: import("components/InfiniteTable/types/InfiniteTableProps").InfiniteTablePropCollapsedColumnGroups | undefined) => import("components/InfiniteTable/types/InfiniteTableProps").InfiniteTablePropCollapsedColumnGroups);
1315
- columnSizing: 1 | ((value: import("components/InfiniteTable/types").InfiniteTablePropColumnSizing | undefined) => import("components/InfiniteTable/types").InfiniteTablePropColumnSizingMap);
1316
- columnTypes: 1 | ((value: import("components/InfiniteTable/types").InfiniteTablePropColumnTypes<T> | undefined) => import("components/InfiniteTable/types").InfiniteTablePropColumnTypesMap<T>);
1317
- rowHeight: 1 | ((value: string | number) => number);
1318
- headerHeight: 1 | ((value: string | number) => number);
1456
+ scrollTopId: 1 | ((value: string | number | undefined) => string | number | undefined);
1319
1457
  }>;
1320
1458
  export const mapPropsToState: <T>(params: {
1321
1459
  props: InfiniteTableProps<T>;
@@ -1392,9 +1530,8 @@ declare module "components/flexbox/index" {
1392
1530
  export const computeFlex: (params: FlexComputeParams) => FlexComputeResult;
1393
1531
  }
1394
1532
  declare module "components/InfiniteTable/utils/adjustColumnOrderForPinning" {
1395
- import { InfiniteTablePropColumnPinning } from "components/InfiniteTable/types/index";
1396
- import { InfiniteTablePropColumnOrderNormalized } from "components/InfiniteTable/types/InfiniteTableProps";
1397
- export const adjustColumnOrderForPinning: (columnOrder: InfiniteTablePropColumnOrderNormalized, columnPinning: InfiniteTablePropColumnPinning) => InfiniteTablePropColumnOrderNormalized;
1533
+ import { InfiniteTablePropColumnOrderNormalized, InfiniteTablePropColumnPinningMap } from "components/InfiniteTable/types/InfiniteTableProps";
1534
+ export const adjustColumnOrderForPinning: (columnOrder: InfiniteTablePropColumnOrderNormalized, columnPinning: InfiniteTablePropColumnPinningMap) => InfiniteTablePropColumnOrderNormalized;
1398
1535
  }
1399
1536
  declare module "utils/getGlobal" {
1400
1537
  export function getGlobal<T extends Window>(): T;
@@ -1411,7 +1548,7 @@ declare module "components/InfiniteTable/utils/getComputedVisibleColumns" {
1411
1548
  import type { InfiniteTableColumn, InfiniteTableComputedColumn } from "components/InfiniteTable/types/InfiniteTableColumn";
1412
1549
  import type { Size } from "components/types/Size";
1413
1550
  import type { DataSourceSingleSortInfo } from "components/DataSource/types";
1414
- import type { InfiniteTablePropColumnOrder, InfiniteTablePropColumnOrderNormalized, InfiniteTablePropColumnPinning, InfiniteTablePropColumnSizingMap, InfiniteTablePropColumnTypesMap, InfiniteTablePropColumnVisibility } from "components/InfiniteTable/types/InfiniteTableProps";
1551
+ import type { InfiniteTablePropColumnOrder, InfiniteTablePropColumnOrderNormalized, InfiniteTablePropColumnPinningMap, InfiniteTablePropColumnSizingMap, InfiniteTablePropColumnTypesMap, InfiniteTablePropColumnVisibility } from "components/InfiniteTable/types/InfiniteTableProps";
1415
1552
  export type SortInfoMap<T> = {
1416
1553
  [key: string]: {
1417
1554
  sortInfo: DataSourceSingleSortInfo<T>;
@@ -1453,7 +1590,7 @@ declare module "components/InfiniteTable/utils/getComputedVisibleColumns" {
1453
1590
  setSortInfo: (sortInfo: DataSourceSingleSortInfo<T>[]) => void;
1454
1591
  draggableColumns?: boolean;
1455
1592
  columnOrder: InfiniteTablePropColumnOrder;
1456
- columnPinning: InfiniteTablePropColumnPinning;
1593
+ columnPinning: InfiniteTablePropColumnPinningMap;
1457
1594
  columnSizing: InfiniteTablePropColumnSizingMap;
1458
1595
  columnTypes: InfiniteTablePropColumnTypesMap<T>;
1459
1596
  columnVisibility: InfiniteTablePropColumnVisibility;
@@ -1489,7 +1626,7 @@ declare module "components/InfiniteTable/hooks/useRerenderOnKeyChange" {
1489
1626
  declare module "components/InfiniteTable/hooks/useComputedVisibleColumns" {
1490
1627
  import type { DataSourceSingleSortInfo } from "components/DataSource/types";
1491
1628
  import type { InfiniteTableColumn } from "components/InfiniteTable/types/index";
1492
- import type { InfiniteTablePropColumnOrder, InfiniteTablePropColumnPinning, InfiniteTablePropColumnSizingMap, InfiniteTablePropColumnTypesMap, InfiniteTablePropColumnVisibility } from "components/InfiniteTable/types/InfiniteTableProps";
1629
+ import type { InfiniteTablePropColumnOrder, InfiniteTablePropColumnPinningMap, InfiniteTablePropColumnSizingMap, InfiniteTablePropColumnTypesMap, InfiniteTablePropColumnVisibility } from "components/InfiniteTable/types/InfiniteTableProps";
1493
1630
  import type { Size } from "components/types/Size";
1494
1631
  import type { GetComputedVisibleColumnsResult } from "components/InfiniteTable/utils/getComputedVisibleColumns";
1495
1632
  type UseComputedVisibleColumnsParam<T> = {
@@ -1506,7 +1643,7 @@ declare module "components/InfiniteTable/hooks/useComputedVisibleColumns" {
1506
1643
  multiSort: boolean;
1507
1644
  sortInfo?: DataSourceSingleSortInfo<T>[];
1508
1645
  setSortInfo: (sortInfo: DataSourceSingleSortInfo<T>[]) => void;
1509
- columnPinning: InfiniteTablePropColumnPinning;
1646
+ columnPinning: InfiniteTablePropColumnPinningMap;
1510
1647
  columnSizing: InfiniteTablePropColumnSizingMap;
1511
1648
  columnTypes: InfiniteTablePropColumnTypesMap<T>;
1512
1649
  columnOrder: InfiniteTablePropColumnOrder;
@@ -1532,13 +1669,6 @@ declare module "components/InfiniteTable/hooks/useComputedVisibleColumns" {
1532
1669
  };
1533
1670
  export const useComputedVisibleColumns: <T extends unknown>({ columns, bodySize, columnMinWidth, columnMaxWidth, columnDefaultWidth, sortable, draggableColumns, sortInfo, multiSort, setSortInfo, columnOrder, columnPinning, columnTypes, pinnedEndMaxWidth, pinnedStartMaxWidth, viewportReservedWidth, columnVisibility, columnVisibilityAssumeVisible, columnSizing, }: UseComputedVisibleColumnsParam<T>) => UseComputedVisibleColumnsResult<T>;
1534
1671
  }
1535
- declare module "components/DataSource/publicHooks/useDataSourceActions" {
1536
- import { DataSourceComponentActions } from "components/DataSource/types";
1537
- export default function useDataSourceActions<T>(): DataSourceComponentActions<T>;
1538
- }
1539
- declare module "components/InfiniteTable/hooks/useColumnAggregations" {
1540
- export function useColumnAggregations<T>(): void;
1541
- }
1542
1672
  declare module "components/InfiniteTable/hooks/useColumnGroups" {
1543
1673
  export function useColumnGroups<T>(): void;
1544
1674
  }
@@ -1546,6 +1676,15 @@ declare module "utils/join" {
1546
1676
  const join: (...args: (string | number | void | null)[]) => string;
1547
1677
  export { join };
1548
1678
  }
1679
+ declare module "components/InfiniteTable/components/icons/ExpanderIcon.css" {
1680
+ export const ExpanderIconCls: string;
1681
+ export const ExpanderIconClsVariants: import("@vanilla-extract/recipes/dist/declarations/src/types").RuntimeFn<{
1682
+ expanded: {
1683
+ true: string;
1684
+ false: {};
1685
+ };
1686
+ }>;
1687
+ }
1549
1688
  declare module "components/InfiniteTable/components/icons/ExpanderIcon" {
1550
1689
  import * as React from 'react';
1551
1690
  type ExpanderIconProps = {
@@ -1590,7 +1729,7 @@ declare module "components/InfiniteTable/components/InfiniteTableRow/row.css" {
1590
1729
  export const GroupRowExpanderCls: string;
1591
1730
  }
1592
1731
  declare module "components/InfiniteTable/state/getComputedPivotColumnsFromDataSourcePivotColumns" {
1593
- import { DataSourcePropGroupRowsBy, DataSourcePropPivotBy } from "components/DataSource/index";
1732
+ import { DataSourcePropGroupBy, DataSourcePropPivotBy } from "components/DataSource/index";
1594
1733
  import { InfiniteTableProps } from "components/InfiniteTable/types/index";
1595
1734
  import { InfiniteTableState } from "components/InfiniteTable/types/InfiniteTableState";
1596
1735
  export function getComputedPivotColumnsFromDataSourcePivotColumns<T>(pivotColumns: InfiniteTableProps<T>['pivotColumns'], params: {
@@ -1599,13 +1738,13 @@ declare module "components/InfiniteTable/state/getComputedPivotColumnsFromDataSo
1599
1738
  pivotRowLabelsColumn: InfiniteTableProps<T>['pivotRowLabelsColumn'];
1600
1739
  pivotTotalColumnPosition: InfiniteTableState<T>['pivotTotalColumnPosition'];
1601
1740
  pivotBy: DataSourcePropPivotBy<T>;
1602
- groupRowsBy: DataSourcePropGroupRowsBy<T>;
1741
+ groupBy: DataSourcePropGroupBy<T>;
1603
1742
  }): InfiniteTableProps<T>['pivotColumns'];
1604
1743
  }
1605
1744
  declare module "components/InfiniteTable/utils/getColumnForGroupBy" {
1606
1745
  import * as React from 'react';
1607
1746
  import { InfiniteTableColumnRenderParam } from "components/InfiniteTable/index";
1608
- import { DataSourceGroupRowsBy } from "components/DataSource/index";
1747
+ import { DataSourceGroupBy } from "components/DataSource/index";
1609
1748
  import { InfiniteTableGeneratedGroupColumn } from "components/InfiniteTable/types/InfiniteTableColumn";
1610
1749
  import { InfiniteTableGroupColumnGetterOptions, InfiniteTablePropGroupColumn, InfiniteTablePropGroupRenderStrategy } from "components/InfiniteTable/types/InfiniteTableProps";
1611
1750
  export function getGroupColumnRender<T>({ groupIndexForColumn, groupRenderStrategy, toggleGroupRow, }: {
@@ -1615,9 +1754,9 @@ declare module "components/InfiniteTable/utils/getColumnForGroupBy" {
1615
1754
  }): (renderOptions: InfiniteTableColumnRenderParam<T>) => React.ReactNode;
1616
1755
  export function getColumnForGroupBy<T>(options: InfiniteTableGroupColumnGetterOptions<T> & {
1617
1756
  groupIndexForColumn: number;
1618
- groupByForColumn: DataSourceGroupRowsBy<T>;
1619
- }, toggleGroupRow: (groupRowKeys: any[]) => void, groupColumnFromProps?: InfiniteTablePropGroupColumn<T>): InfiniteTableGeneratedGroupColumn<T>;
1620
- export function getSingleGroupColumn<T>(options: InfiniteTableGroupColumnGetterOptions<T>, toggleGroupRow: (groupRowKeys: any[]) => void, groupColumnFromProps?: InfiniteTablePropGroupColumn<T>): InfiniteTableGeneratedGroupColumn<T>;
1757
+ groupByForColumn: DataSourceGroupBy<T>;
1758
+ }, toggleGroupRow: (groupRowKeys: any[]) => void, groupColumnFromProps?: Partial<InfiniteTablePropGroupColumn<T>>): InfiniteTableGeneratedGroupColumn<T>;
1759
+ export function getSingleGroupColumn<T>(options: InfiniteTableGroupColumnGetterOptions<T>, toggleGroupRow: (groupRowKeys: any[]) => void, groupColumnFromProps?: Partial<InfiniteTablePropGroupColumn<T>>): InfiniteTableGeneratedGroupColumn<T>;
1621
1760
  }
1622
1761
  declare module "components/InfiniteTable/hooks/useToggleGroupRow" {
1623
1762
  export type ToggleGrouRowFn = (groupKeys: any[]) => void;
@@ -1625,12 +1764,12 @@ declare module "components/InfiniteTable/hooks/useToggleGroupRow" {
1625
1764
  }
1626
1765
  declare module "components/InfiniteTable/hooks/useColumnsWhen" {
1627
1766
  import type { InfiniteTableColumn } from "components/InfiniteTable/index";
1628
- import type { DataSourceGroupRowsBy } from "components/DataSource/index";
1767
+ import type { DataSourceGroupBy } from "components/DataSource/index";
1629
1768
  import type { InfiniteTablePropGroupRenderStrategy, InfiniteTableProps } from "components/InfiniteTable/types/InfiniteTableProps";
1630
1769
  export function useColumnsWhen<T>(): void;
1631
1770
  export function getColumnsWhenGrouping<T>(params: {
1632
1771
  columns: Map<string, InfiniteTableColumn<T>>;
1633
- groupRowsBy: DataSourceGroupRowsBy<T>[];
1772
+ groupBy: DataSourceGroupBy<T>[];
1634
1773
  toggleGroupRow: (groupKeys: any[]) => void;
1635
1774
  groupColumn: InfiniteTableProps<T>['groupColumn'];
1636
1775
  groupRenderStrategy: InfiniteTablePropGroupRenderStrategy;
@@ -1823,9 +1962,7 @@ declare module "components/InfiniteTable/components/cell.css" {
1823
1962
  unpinned: {};
1824
1963
  pinnedStartLastInCategory: {
1825
1964
  borderRight: import("@vanilla-extract/private").CSSVarFunction;
1826
- vars: {
1827
- [x: string]: import("@vanilla-extract/private").CSSVarFunction;
1828
- };
1965
+ vars: {};
1829
1966
  };
1830
1967
  pinnedEndFirstInCategory: {
1831
1968
  borderLeft: import("@vanilla-extract/private").CSSVarFunction;
@@ -2047,15 +2184,14 @@ declare module "components/InfiniteTable/components/InfiniteTableHeader/Infinite
2047
2184
  import { Renderable } from "components/types/Renderable";
2048
2185
  import { VirtualBrain } from "components/VirtualBrain/index";
2049
2186
  import { ScrollListener } from "components/VirtualBrain/ScrollListener";
2050
- import { InfiniteTableColumnPinned } from "components/InfiniteTable/types/InfiniteTableColumn";
2051
- import { InfiniteTableComputedColumnGroup } from "components/InfiniteTable/types/InfiniteTableProps";
2187
+ import { InfiniteTableColumnPinnedValues, InfiniteTableComputedColumnGroup } from "components/InfiniteTable/types/InfiniteTableProps";
2052
2188
  export type InfiniteTableHeaderProps<T> = {
2053
2189
  repaintId?: string | number;
2054
2190
  brain: VirtualBrain;
2055
2191
  columns: InfiniteTableComputedColumn<T>[];
2056
2192
  totalWidth: number;
2057
2193
  availableWidth: number;
2058
- pinning: InfiniteTableColumnPinned;
2194
+ pinning: InfiniteTableColumnPinnedValues;
2059
2195
  };
2060
2196
  export type InfiniteTableHeaderGroupProps<T> = {
2061
2197
  columns: InfiniteTableComputedColumn<T>[];
@@ -2562,6 +2698,9 @@ declare module "components/InfiniteTable/hooks/usePinnedRendering" {
2562
2698
  pinnedStartScrollbarPlaceholder: JSX.Element | null;
2563
2699
  };
2564
2700
  }
2701
+ declare module "components/hooks/useOnce" {
2702
+ export function useOnce<ReturnType>(fn: () => ReturnType): ReturnType;
2703
+ }
2565
2704
  declare module "components/InfiniteTable/hooks/useColumnSizeFn" {
2566
2705
  import { InfiniteTableComputedColumn } from "components/InfiniteTable/types/index";
2567
2706
  /**
@@ -3060,4 +3199,5 @@ declare module "@infinite-table/infinite-react" {
3060
3199
  export { group, flatten } from "utils/groupAndPivot/index";
3061
3200
  export { useComponentState, getComponentStateRoot, } from "components/hooks/useComponentState";
3062
3201
  export { interceptMap } from "components/hooks/useInterceptedMap";
3202
+ export { useEffectWithChanges } from "components/hooks/useEffectWithChanges";
3063
3203
  }