@infinite-table/infinite-react 9.3.0 → 9.4.1

package/index.dev.mjs

@@ -235,6 +235,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));
@@ -302,6 +303,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) => {
@@ -546,6 +553,7 @@ var DeepMap = class _DeepMap {
   }
   set(keys, value) {
     let currentMap = this.map;
+    this.mutations++;
     if (!keys.length) {
       keys = [this.emptyKey];
     }
@@ -607,9 +615,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 {
@@ -14963,6 +14973,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,
@@ -14971,7 +14987,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;
 }
@@ -16728,6 +16743,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) {
@@ -16848,6 +16872,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;
@@ -16914,6 +17106,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) => {
@@ -17245,6 +17440,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;
@@ -17309,23 +17510,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);
@@ -17334,12 +17518,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
@@ -17370,6 +17548,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,
@@ -21068,10 +21247,11 @@ function deriveStateFromProps(params) {
       state.logger
     );
   }
-  const groupMode = typeof props.data === "function" ? propsGroupMode ?? "local" : "local";
+  const remoteByDefault = typeof props.data === "function" && !!props.lazyLoad;
+  const groupMode = typeof props.data === "function" ? propsGroupMode ?? (remoteByDefault ? "remote" : "local") : "local";
   const sortMode = props.sortFunction ? "local" : propsSortMode ?? (controlledSort ? "remote" : "local");
   const filterMode = typeof props.filterFunction === "function" || typeof props.treeFilterFunction === "function" ? "local" : propsFilterMode ?? (typeof props.data === "function" ? "remote" : "local");
-  const pivotMode = shouldReloadData.pivotBy ? "remote" : "local";
+  const pivotMode = shouldReloadData.pivotBy ?? remoteByDefault ? "remote" : "local";
   const rowDisabledState = state.rowDisabledState;
   let isRowDisabled = props.isRowDisabled;
   if (!isRowDisabled && rowDisabledState) {
@@ -21554,6 +21734,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;
 }
@@ -21934,7 +22132,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;
@@ -22264,7 +22462,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
@@ -22532,6 +22731,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
@@ -28097,7 +28297,7 @@ var useLicense = (licenseKey = "") => {
     }
     let valid2 = isValidLicense(licenseKey, {
       publishedAt: 1624970570587,
-      version: "9.3.0"
+      version: "9.4.1"
     });
     if (!licenseKey && !valid2 && isInsidePlayground) {
       return true;