@infinite-table/infinite-react 9.4.0 → 9.4.1

package/index.d.ts

@@ -59,7 +59,12 @@ declare class DeepMap<KeyType, ValueType> {
     private map;
     private length;
     private revision;
+    private mutations;
     private emptyKey;
+    /**
+     * Increases on every set, delete and clear, so derived data can be cached until the map changes
+     */
+    get version(): number;
     static clone<KeyType, ValueType>(map: DeepMap<KeyType, ValueType>): DeepMap<KeyType, ValueType>;
     constructor(initial?: [KeyType[], ValueType][]);
     fill(initial?: [KeyType[], ValueType][]): void;
@@ -2454,6 +2459,10 @@ type RowSelectionStateConfig<T> = {
      * The count of all the rows - for lazy load, after the (remote) filter
      */
     totalCount: number;
+    /**
+     * Lazy load with grouping: the count of all the (leaf) rows, after the filter, when the server sends it
+     */
+    lazyGroupedRowCount?: number;
     /**
      * Lazy load: the count of all the rows without the filter, when the server sends it
      */
@@ -2489,6 +2498,14 @@ declare class RowSelectionState<T = any> {
         selectedCount: number;
         deselectedCount: number;
     }>;
+    /**
+     * Lazy load: the selected (true) and deselected (false) entries, in one map,
+     * for the given versions of the selection maps
+     */
+    private lazyEntries;
+    private lazyLoadedRows;
+    private lazyChildrenLoaded;
+    private lazyRowCounts;
     getConfig: GetRowSelectionStateConfig<T>;
     getGroupKeysForPrimaryKey(pk: any): any[];
     getGroupDeepMap(): DeepMap<any, DeepMapGroupValueType<T, any>> | undefined;
@@ -2518,6 +2535,32 @@ declare class RowSelectionState<T = any> {
      * its loaded groups - so the rows of the groups hidden by the filter or not loaded yet
      */
     getLazyHiddenRowsCount(groupKeys: any[]): number;
+    private getLazyEntries;
+    /**
+     * Lazy load: the count of the rows inside the group, as the server sent it
+     */
+    private getLazyRowCount;
+    private computeLazyRowCount;
+    /**
+     * Lazy load: whether the server sent all the direct children of the group
+     */
+    private areLazyChildrenLoaded;
+    private computeLazyChildrenLoaded;
+    /**
+     * Lazy load, at the last group level (or the root, without grouping): the primary keys
+     * of the loaded rows, and whether they are all the rows of the group
+     */
+    private getLazyLoadedRows;
+    /**
+     * Lazy load, with the counts after the filter: whether the row or group of a selection entry
+     * is known to be filtered out - its parent has all the children loaded, and it's not among them
+     */
+    private isLazyEntryFilteredOut;
+    /**
+     * Lazy load: counts the explicit selection entries inside the group, at any depth, by their own selection,
+     * whether their rows are loaded or not. The other rows of the group take its selection.
+     */
+    private getLazySelectionCountFor;
     getGroupCount(groupKeys: any[]): number;
     getGroupKeysDirectlyInsideGroup(groupKeys: any[]): any[][];
     getAllPrimaryKeysInsideGroup(groupKeys: any[]): any[];
@@ -3220,6 +3263,7 @@ type LazyRowInfoGroup<DataType> = {
     cache: boolean;
     totalCount: number;
     totalCountUnfiltered?: number;
+    totalChildrenCount?: number;
     totalChildrenCountUnfiltered?: number;
     error?: string;
 };

package/index.dev.js

@@ -316,6 +316,7 @@ var DeepMap = class _DeepMap {
     this.map = /* @__PURE__ */ new Map();
     this.length = 0;
     this.revision = 0;
+    this.mutations = 0;
     this.emptyKey = Symbol("emptyKey");
     this.visit = (fn) => {
       this.map.forEach((_, k) => this.visitKey(k, this.map, [], fn, false));
@@ -383,6 +384,12 @@ var DeepMap = class _DeepMap {
     };
     this.fill(initial);
   }
+  /**
+   * Increases on every set, delete and clear, so derived data can be cached until the map changes
+   */
+  get version() {
+    return this.mutations;
+  }
   static clone(map2) {
     const clone = new _DeepMap();
     map2.visit((pair, keys) => {
@@ -627,6 +634,7 @@ var DeepMap = class _DeepMap {
   }
   set(keys, value) {
     let currentMap = this.map;
+    this.mutations++;
     if (!keys.length) {
       keys = [this.emptyKey];
     }
@@ -688,9 +696,11 @@ var DeepMap = class _DeepMap {
     clearMap(this.map);
     this.length = 0;
     this.revision = 0;
+    this.mutations++;
   }
   delete(keys) {
     let currentMap = this.map;
+    this.mutations++;
     if (!keys.length) {
       keys = [this.emptyKey];
     } else {
@@ -15029,6 +15039,12 @@ function DEFAULT_TO_KEY(value) {
   return value;
 }
 
+// src/utils/groupAndPivot/notLoadedYet.ts
+var NOT_LOADED_YET_KEY_PREFIX = "____not_loaded_yet____";
+function isNotLoadedYetKey(key) {
+  return typeof key === "string" && key.startsWith(NOT_LOADED_YET_KEY_PREFIX);
+}
+
 // src/utils/groupAndPivot/sharedValueGetterParamsFlyweightObject.ts
 var sharedValueGetterParamsFlyweightObject = Object.seal({
   data: null,
@@ -15037,7 +15053,6 @@ var sharedValueGetterParamsFlyweightObject = Object.seal({
 
 // src/utils/groupAndPivot/index.ts
 var LAZY_ROOT_KEY_FOR_GROUPS = "____root____";
-var NOT_LOADED_YET_KEY_PREFIX = "____not_loaded_yet____";
 function returnFalse() {
   return false;
 }
@@ -16794,6 +16809,15 @@ var RowSelectionState = class _RowSelectionState {
     // TODO make it easy to share the cache with another instance
     this.selectionCache = new DeepMap();
     this.selectionCountCache = new DeepMap();
+    /**
+     * Lazy load: the selected (true) and deselected (false) entries, in one map,
+     * for the given versions of the selection maps
+     */
+    this.lazyEntries = null;
+    // the caches below depend on the config, so they only live until the next xcache()
+    this.lazyLoadedRows = null;
+    this.lazyChildrenLoaded = null;
+    this.lazyRowCounts = null;
     this.mapSet = (name, key) => {
       if (!Array.isArray(key)) {
         if (this.onlyUsePrimaryKeys) {
@@ -16914,6 +16938,174 @@ var RowSelectionState = class _RowSelectionState {
     });
     return Math.max(unfilteredCount - childrenCount, 0);
   }
+  getLazyEntries() {
+    const version = `${this.selectedMap.version}:${this.deselectedMap.version}`;
+    if (this.lazyEntries?.version !== version) {
+      const entries = new DeepMap();
+      this.selectedMap.getKeysStartingWith([]).forEach((keys) => entries.set(keys, true));
+      this.deselectedMap.getKeysStartingWith([]).forEach((keys) => entries.set(keys, false));
+      this.lazyEntries = { version, entries };
+    }
+    return this.lazyEntries.entries;
+  }
+  /**
+   * Lazy load: the count of the rows inside the group, as the server sent it
+   */
+  getLazyRowCount(groupKeys) {
+    this.lazyRowCounts = this.lazyRowCounts ?? new DeepMap();
+    const cached = this.lazyRowCounts.get(groupKeys);
+    if (cached !== void 0) {
+      return cached ?? void 0;
+    }
+    const result = this.computeLazyRowCount(groupKeys);
+    this.lazyRowCounts.set(groupKeys, result ?? null);
+    return result;
+  }
+  computeLazyRowCount(groupKeys) {
+    const config = this.getConfig();
+    const groupByLength = this.getGroupByLength();
+    const unfilteredCount = this.getLazyUnfilteredCount(groupKeys);
+    if (unfilteredCount !== void 0) {
+      return unfilteredCount;
+    }
+    if (!groupKeys.length && !groupByLength) {
+      return config.totalCount;
+    }
+    const group2 = groupKeys.length ? config.groupDeepMap?.get(groupKeys) : void 0;
+    const count = groupKeys.length ? group2?.totalChildrenCount : config.lazyGroupedRowCount;
+    if (count != null) {
+      return count;
+    }
+    if (groupKeys.length === groupByLength) {
+      return group2?.childrenAvailable ? group2.items.length : void 0;
+    }
+    const childKeys = config.groupDeepMap?.getKeysStartingWith(groupKeys, {
+      excludeSelf: true,
+      depthLimit: 1
+    }) ?? [];
+    if (!childKeys.length) {
+      return void 0;
+    }
+    return childKeys.reduce(
+      (sum2, keys) => sum2 + (isNotLoadedYetKey(keys[keys.length - 1]) ? 1 : this.getLazyRowCount(keys) ?? 1),
+      0
+    );
+  }
+  /**
+   * Lazy load: whether the server sent all the direct children of the group
+   */
+  areLazyChildrenLoaded(groupKeys) {
+    this.lazyChildrenLoaded = this.lazyChildrenLoaded ?? new DeepMap();
+    const cached = this.lazyChildrenLoaded.get(groupKeys);
+    if (cached !== void 0) {
+      return cached;
+    }
+    const result = this.computeLazyChildrenLoaded(groupKeys);
+    this.lazyChildrenLoaded.set(groupKeys, result);
+    return result;
+  }
+  computeLazyChildrenLoaded(groupKeys) {
+    const { groupDeepMap } = this.getConfig();
+    const group2 = groupKeys.length ? groupDeepMap?.get(groupKeys) : void 0;
+    if (groupKeys.length && !group2?.childrenAvailable) {
+      return false;
+    }
+    if (groupKeys.length === this.getGroupByLength()) {
+      return this.getLazyLoadedRows(groupKeys).complete;
+    }
+    return (groupDeepMap?.getKeysStartingWith(groupKeys, {
+      excludeSelf: true,
+      depthLimit: 1
+    }) ?? []).every((keys) => !isNotLoadedYetKey(keys[keys.length - 1]));
+  }
+  /**
+   * Lazy load, at the last group level (or the root, without grouping): the primary keys
+   * of the loaded rows, and whether they are all the rows of the group
+   */
+  getLazyLoadedRows(groupKeys) {
+    this.lazyLoadedRows = this.lazyLoadedRows ?? new DeepMap();
+    let loadedRows = this.lazyLoadedRows.get(groupKeys);
+    if (!loadedRows) {
+      const { groupDeepMap, originalDataArray, toPrimaryKey, totalCount } = this.getConfig();
+      const group2 = groupKeys.length ? groupDeepMap?.get(groupKeys) : void 0;
+      const items = group2 ? group2.items : originalDataArray ?? [];
+      const rowCount = group2 ? group2.totalChildrenCount : totalCount;
+      const primaryKeys = /* @__PURE__ */ new Set();
+      let complete = rowCount == null || items.length >= rowCount;
+      for (let i = 0; i < items.length; i++) {
+        const item = items[i];
+        if (item == null) {
+          complete = false;
+        } else {
+          primaryKeys.add(toPrimaryKey(item));
+        }
+      }
+      loadedRows = { primaryKeys, complete };
+      this.lazyLoadedRows.set(groupKeys, loadedRows);
+    }
+    return loadedRows;
+  }
+  /**
+   * Lazy load, with the counts after the filter: whether the row or group of a selection entry
+   * is known to be filtered out - its parent has all the children loaded, and it's not among them
+   */
+  isLazyEntryFilteredOut(keys) {
+    const { groupDeepMap } = this.getConfig();
+    const groupByLength = this.getGroupByLength();
+    for (let length = 1; length <= keys.length; length++) {
+      const parentKeys = keys.slice(0, length - 1);
+      const loaded = length > groupByLength ? this.getLazyLoadedRows(parentKeys).primaryKeys.has(keys[length - 1]) : !!groupDeepMap?.get(keys.slice(0, length));
+      if (!loaded) {
+        return this.areLazyChildrenLoaded(parentKeys);
+      }
+    }
+    return false;
+  }
+  /**
+   * Lazy load: counts the explicit selection entries inside the group, at any depth, by their own selection,
+   * whether their rows are loaded or not. The other rows of the group take its selection.
+   */
+  getLazySelectionCountFor(groupKeys, selected) {
+    const cachedResult = this.selectionCountCache.get(groupKeys);
+    if (cachedResult != null) {
+      return cachedResult;
+    }
+    const entries = this.getLazyEntries();
+    const leafLength = this.getGroupByLength() + 1;
+    const countsIncludeFilteredOutRows = this.getLazyUnfilteredCount([]) !== void 0;
+    let selectedCount = 0;
+    let deselectedCount = 0;
+    entries.getKeysOfFirstChildOnEachBranchStartingWith(groupKeys, {
+      excludeSelf: true,
+      respectOrder: false
+    }).forEach((keys) => {
+      if (!countsIncludeFilteredOutRows && this.isLazyEntryFilteredOut(keys)) {
+        return;
+      }
+      const entrySelected = entries.get(keys);
+      if (keys.length >= leafLength) {
+        if (entrySelected) {
+          selectedCount++;
+        } else {
+          deselectedCount++;
+        }
+        return;
+      }
+      const count = this.getLazySelectionCountFor(keys, entrySelected);
+      selectedCount += count.selectedCount;
+      deselectedCount += count.deselectedCount;
+    });
+    const rowCount = this.getLazyRowCount(groupKeys);
+    const otherRowsCount = rowCount === void 0 ? 1 : Math.max(rowCount - selectedCount - deselectedCount, 0);
+    if (selected) {
+      selectedCount += otherRowsCount;
+    } else {
+      deselectedCount += otherRowsCount;
+    }
+    const result = { selectedCount, deselectedCount };
+    this.selectionCountCache.set(groupKeys, result);
+    return result;
+  }
   getGroupCount(groupKeys) {
     if (groupKeys.length == 0) {
       return this.getLazyUnfilteredCount([]) ?? this.getConfig().totalCount;
@@ -16980,6 +17172,9 @@ var RowSelectionState = class _RowSelectionState {
   xcache() {
     this.selectionCache.clear();
     this.selectionCountCache.clear();
+    this.lazyLoadedRows = null;
+    this.lazyChildrenLoaded = null;
+    this.lazyRowCounts = null;
   }
   getState() {
     const normalize = (allKeys) => {
@@ -17311,6 +17506,12 @@ var RowSelectionState = class _RowSelectionState {
       this.selectionCountCache.set(groupKeys, result2);
       return result2;
     }
+    if (this.getConfig().lazyLoad && (!this.onlyUsePrimaryKeys || !groupByLength)) {
+      return this.getLazySelectionCountFor(
+        groupKeys,
+        parentSelected ?? this.getGroupRowBooleanSelectionStateFromParent(groupKeys)
+      );
+    }
     if (this.onlyUsePrimaryKeys && (groupByLength || this.targetsVisibleRowsOnly())) {
       const allKeys2 = this.getAllPrimaryKeysInsideGroup(groupKeys);
       let selectedCount2 = 0;
@@ -17375,23 +17576,6 @@ var RowSelectionState = class _RowSelectionState {
     }
     let selectedCount = 0;
     let deselectedCount = 0;
-    const { lazyLoad, groupDeepMap } = this.getConfig();
-    if (lazyLoad && !allKeys.length) {
-      const totalChildrenCount = this.getLazyUnfilteredCount(groupKeys) ?? (groupDeepMap?.get(groupKeys)?.totalChildrenCount || 0);
-      if (parentSelected) {
-        selectedCount = totalChildrenCount;
-        deselectedCount = this.deselectedMap.getAllChildrenSizeFor(groupKeys);
-        if (deselectedCount === totalChildrenCount) {
-          selectedCount = 0;
-        }
-      } else {
-        deselectedCount = totalChildrenCount;
-        selectedCount = this.selectedMap.getAllChildrenSizeFor(groupKeys);
-        if (selectedCount === totalChildrenCount) {
-          deselectedCount = 0;
-        }
-      }
-    }
     allKeys.forEach((keys) => {
       let isSelected = this.selectedMap.get(keys);
       let isDeselected = this.deselectedMap.get(keys);
@@ -17400,12 +17584,6 @@ var RowSelectionState = class _RowSelectionState {
       selectedCount += selCount;
       deselectedCount += deselCount;
     });
-    const hiddenCount = allKeys.length ? this.getLazyHiddenRowsCount(groupKeys) : 0;
-    if (parentSelected) {
-      selectedCount += hiddenCount;
-    } else {
-      deselectedCount += hiddenCount;
-    }
     const result = {
       selectedCount,
       deselectedCount
@@ -17436,6 +17614,7 @@ function rowSelectionStateConfigGetter(stateOrStateGetter) {
       groupDeepMap: state.groupDeepMap,
       indexer: state.indexer,
       totalCount: lazyLoad ? originalDataArray?.length ?? 0 : state.unfilteredCount,
+      lazyGroupedRowCount: state.groupBy.length ? lazyRoot?.totalChildrenCount : void 0,
       lazyUnfilteredCount: state.groupBy.length ? lazyRoot?.totalChildrenCountUnfiltered : lazyRoot?.totalCountUnfiltered,
       multiRowSelectionTarget: state.multiRowSelectionTarget,
       someRowsFilteredOut: !state.lazyLoad && !!originalDataArray && !!postFilterDataArray && postFilterDataArray.length < originalDataArray.length,
@@ -21621,6 +21800,24 @@ var haveDepsChanged = (state1, state2, deps) => {
   }
   return false;
 };
+function getLazyGroupedRowCount(lazyGroupData) {
+  const root = lazyGroupData.get([LAZY_ROOT_KEY_FOR_GROUPS]);
+  if (!root) {
+    return void 0;
+  }
+  if (root.totalChildrenCount != null) {
+    return root.totalChildrenCount;
+  }
+  let count = 0;
+  for (let i = 0; i < root.children.length; i++) {
+    const groupCount = root.children[i]?.totalChildrenCount;
+    if (groupCount == null) {
+      return void 0;
+    }
+    count += groupCount;
+  }
+  return count;
+}
 function returnFalse2() {
   return false;
 }
@@ -22001,7 +22198,7 @@ function concludeReducer(params) {
     state.lastFilterDataArray = dataArray;
     state.filteredAt = now;
   }
-  state.filteredCount = dataArray.length;
+  state.filteredCount = (state.lazyLoad && groupBy.length ? getLazyGroupedRowCount(state.originalLazyGroupData) : void 0) ?? dataArray.length;
   state.postFilterDataArray = dataArray;
   if (shouldSort) {
     const prevKnownTypes = multisort.knownTypes;
@@ -22331,7 +22528,8 @@ function concludeReducer(params) {
   state.dataArray = rowInfoDataArray;
   state.reducedAt = now;
   if (state.selectionMode === "multi-row") {
-    if (shouldGroup && state.lazyLoad) {
+    const groupKeysSelection = state.rowSelection instanceof RowSelectionState && !state.rowSelection.onlyUsePrimaryKeys;
+    if (shouldGroup && state.lazyLoad && !groupKeysSelection) {
       if (debugId) {
         marker = getMarker(
           debugId
@@ -22599,6 +22797,7 @@ function loadData(data, componentState, actions, overrides, masterContext) {
             totalCount: remoteData2.totalCount ?? dataArray2.length,
             // set even when missing, so a previous response's values are not kept
             totalCountUnfiltered: remoteData2.totalCountUnfiltered,
+            totalChildrenCount: remoteData2.totalChildrenCount,
             totalChildrenCountUnfiltered: remoteData2.totalChildrenCountUnfiltered,
             children: dataArray2,
             error: remoteData2.error
@@ -28159,7 +28358,7 @@ var useLicense = (licenseKey = "") => {
     }
     let valid2 = isValidLicense(licenseKey, {
       publishedAt: 1624970570587,
-      version: "9.4.0"
+      version: "9.4.1"
     });
     if (!licenseKey && !valid2 && isInsidePlayground) {
       return true;