@infinite-table/infinite-react 9.1.4 → 9.2.0

package/index.dev.js

@@ -16736,6 +16736,52 @@ function getGroupKeysForDataItem(data, groupBy) {
 }
 
 // src/components/DataSource/RowSelectionState.ts
+var EMPTY_UNFILTERED_GROUPS = new DeepMap();
+var unfilteredGroupsCache = /* @__PURE__ */ new WeakMap();
+function getUnfilteredGroups(config) {
+  const { originalDataArray, groupBy, toPrimaryKey } = config;
+  if (!originalDataArray || !groupBy.length) {
+    return EMPTY_UNFILTERED_GROUPS;
+  }
+  const cached = unfilteredGroupsCache.get(originalDataArray);
+  if (cached && cached.groupBy === groupBy) {
+    return cached.groups;
+  }
+  const groups = new DeepMap();
+  const lastLevel = groupBy.length;
+  const keys = [];
+  originalDataArray.forEach((data) => {
+    const groupKeys = getGroupKeysForDataItem(data, groupBy);
+    keys.length = 0;
+    for (let i = 0; i < groupKeys.length; i++) {
+      keys.push(groupKeys[i]);
+      let group2 = groups.get(keys);
+      if (!group2) {
+        group2 = { count: 0 };
+        if (keys.length === lastLevel) {
+          group2.primaryKeys = [];
+        }
+        groups.set(keys, group2);
+      }
+      group2.count++;
+      group2.primaryKeys?.push(toPrimaryKey(data));
+    }
+  });
+  unfilteredGroupsCache.set(originalDataArray, { groupBy, groups });
+  return groups;
+}
+function getUnfilteredPrimaryKeysInsideGroup(groups, groupKeys) {
+  const result = [];
+  groups.getLeafNodesStartingWith(groupKeys, (pair) => {
+    const primaryKeys = pair.value?.primaryKeys;
+    if (primaryKeys) {
+      for (let i = 0; i < primaryKeys.length; i++) {
+        result.push(primaryKeys[i]);
+      }
+    }
+  });
+  return result;
+}
 var RowSelectionState = class _RowSelectionState {
   constructor(state, getConfig, _forTestingOnly) {
     this.selectedRows = null;
@@ -16787,10 +16833,62 @@ var RowSelectionState = class _RowSelectionState {
   getGroupDeepMap() {
     return this.getConfig().groupDeepMap;
   }
+  /**
+   * The selection acts only on the rows that pass the filter, and some rows are filtered out
+   */
+  targetsVisibleRowsOnly() {
+    const { multiRowSelectionTarget, someRowsFilteredOut } = this.getConfig();
+    return multiRowSelectionTarget === "visible" && !!someRowsFilteredOut;
+  }
+  /**
+   * The selection also acts on rows that are filtered out, and some rows are filtered out
+   */
+  targetsFilteredOutRows() {
+    const { multiRowSelectionTarget, someRowsFilteredOut } = this.getConfig();
+    return multiRowSelectionTarget !== "visible" && !!someRowsFilteredOut;
+  }
+  getVisibleDataInsideGroup(groupKeys) {
+    const { postFilterDataArray, groupDeepMap } = this.getConfig();
+    if (!groupKeys.length) {
+      return postFilterDataArray ?? [];
+    }
+    return groupDeepMap?.get(groupKeys)?.items ?? [];
+  }
+  hasFilteredOutRowsInsideGroup(groupKeys) {
+    const config = this.getConfig();
+    if (!config.someRowsFilteredOut) {
+      return false;
+    }
+    const allCount = groupKeys.length ? getUnfilteredGroups(config).get(groupKeys)?.count ?? 0 : config.originalDataArray?.length ?? 0;
+    return allCount > this.getVisibleDataInsideGroup(groupKeys).length;
+  }
+  /**
+   * Sets the selection of each visible row inside the group, by its full path,
+   * so the rows of the group that are filtered out keep their selection
+   */
+  setVisibleRowsSelection(groupKeys, selected) {
+    const { groupBy, toPrimaryKey } = this.getConfig();
+    const mapToSet = selected ? this.selectedMap : this.deselectedMap;
+    const mapToClear = selected ? this.deselectedMap : this.selectedMap;
+    this.xcache();
+    this.getVisibleDataInsideGroup(groupKeys).forEach((data) => {
+      const rowGroupKeys = getGroupKeysForDataItem(data, groupBy);
+      const pk = toPrimaryKey(data);
+      const finalKey = [...rowGroupKeys, pk];
+      mapToClear.delete(finalKey);
+      if (this.isRowSelected(pk, rowGroupKeys) !== selected) {
+        mapToSet.set(finalKey, true);
+      }
+    });
+    this.xcache();
+  }
   getGroupCount(groupKeys) {
     if (groupKeys.length == 0) {
       return this.getConfig().totalCount;
     }
+    if (this.targetsFilteredOutRows()) {
+      return getUnfilteredGroups(this.getConfig()).get(groupKeys)?.count ?? 0;
+    }
     const groupDeepMap = this.getGroupDeepMap();
     const deepMapValue = groupDeepMap?.get(groupKeys);
     if (!deepMapValue) {
@@ -16799,14 +16897,28 @@ var RowSelectionState = class _RowSelectionState {
     return deepMapValue.totalChildrenCount ?? (deepMapValue.items.length || 0);
   }
   getGroupKeysDirectlyInsideGroup(groupKeys) {
-    const { groupDeepMap } = this.getConfig();
-    return groupDeepMap?.getKeysStartingWith(groupKeys, {
-      excludeSelf: true,
-      depthLimit: 1
-    }) || [];
+    const config = this.getConfig();
+    const options = { excludeSelf: true, depthLimit: 1 };
+    if (this.targetsFilteredOutRows()) {
+      return getUnfilteredGroups(config).getKeysStartingWith(
+        groupKeys,
+        options
+      );
+    }
+    return config.groupDeepMap?.getKeysStartingWith(groupKeys, options) || [];
   }
   getAllPrimaryKeysInsideGroup(groupKeys) {
-    const { groupDeepMap } = this.getConfig();
+    const config = this.getConfig();
+    const { groupDeepMap, toPrimaryKey } = config;
+    if (this.targetsFilteredOutRows()) {
+      return groupKeys.length ? getUnfilteredPrimaryKeysInsideGroup(
+        getUnfilteredGroups(config),
+        groupKeys
+      ) : (config.originalDataArray ?? []).map(toPrimaryKey);
+    }
+    if (!config.groupBy.length) {
+      return this.getVisibleDataInsideGroup([]).map(toPrimaryKey);
+    }
     if (!groupKeys.length) {
       const topLevelKeys = groupDeepMap?.getKeysStartingWith([], {
         excludeSelf: true,
@@ -16844,7 +16956,7 @@ var RowSelectionState = class _RowSelectionState {
         if (this.onlyUsePrimaryKeys) {
           return keys[0];
         }
-        return keys.length > groupByLength ? keys.pop() : keys;
+        return groupByLength === 0 && keys.length === 1 ? keys[0] : keys;
       });
     };
     const selectedRows = normalize(this.selectedMap.topDownKeys());
@@ -16856,6 +16968,14 @@ var RowSelectionState = class _RowSelectionState {
     };
   }
   deselectAll() {
+    if (this.targetsVisibleRowsOnly()) {
+      if (this.onlyUsePrimaryKeys) {
+        this.deselectGroupRow([]);
+      } else {
+        this.setVisibleRowsSelection([], false);
+      }
+      return;
+    }
     this.update({
       defaultSelection: false,
       selectedRows: [],
@@ -16863,6 +16983,14 @@ var RowSelectionState = class _RowSelectionState {
     });
   }
   selectAll() {
+    if (this.targetsVisibleRowsOnly()) {
+      if (this.onlyUsePrimaryKeys) {
+        this.selectGroupRow([]);
+      } else {
+        this.setVisibleRowsSelection([], true);
+      }
+      return;
+    }
     this.update({
       defaultSelection: true,
       deselectedRows: [],
@@ -17017,6 +17145,10 @@ var RowSelectionState = class _RowSelectionState {
       this.xcache();
       return;
     }
+    if (this.targetsVisibleRowsOnly() && this.hasFilteredOutRowsInsideGroup(groupKeys)) {
+      this.setVisibleRowsSelection(groupKeys, true);
+      return;
+    }
     const selectedKeys = this.selectedMap.getKeysStartingWith(groupKeys, {
       excludeSelf: true
     });
@@ -17045,6 +17177,10 @@ var RowSelectionState = class _RowSelectionState {
       this.xcache();
       return;
     }
+    if (this.targetsVisibleRowsOnly() && this.hasFilteredOutRowsInsideGroup(groupKeys)) {
+      this.setVisibleRowsSelection(groupKeys, false);
+      return;
+    }
     const deselectedKeys = this.deselectedMap.getKeysStartingWith(groupKeys, {
       excludeSelf: true
     });
@@ -17143,7 +17279,7 @@ var RowSelectionState = class _RowSelectionState {
       this.selectionCountCache.set(groupKeys, result2);
       return result2;
     }
-    if (groupByLength && this.onlyUsePrimaryKeys) {
+    if (this.onlyUsePrimaryKeys && (groupByLength || this.targetsVisibleRowsOnly())) {
       const allKeys2 = this.getAllPrimaryKeysInsideGroup(groupKeys);
       let selectedCount2 = 0;
       let deselectedCount2 = 0;
@@ -17169,6 +17305,21 @@ var RowSelectionState = class _RowSelectionState {
       this.selectionCountCache.set(groupKeys, result2);
       return result2;
     }
+    if (groupKeys.length === groupByLength && this.targetsVisibleRowsOnly()) {
+      const { toPrimaryKey } = this.getConfig();
+      let selectedCount2 = 0;
+      let deselectedCount2 = 0;
+      this.getVisibleDataInsideGroup(groupKeys).forEach((data) => {
+        if (this.isRowSelected(toPrimaryKey(data), groupKeys)) {
+          selectedCount2++;
+        } else {
+          deselectedCount2++;
+        }
+      });
+      const result2 = { selectedCount: selectedCount2, deselectedCount: deselectedCount2 };
+      this.selectionCountCache.set(groupKeys, result2);
+      return result2;
+    }
     parentSelected = parentSelected ?? this.getGroupRowBooleanSelectionStateFromParent(groupKeys);
     let allKeys = this.getGroupKeysDirectlyInsideGroup(groupKeys);
     if (groupKeys.length === this.getGroupByLength()) {
@@ -17235,6 +17386,7 @@ function cloneRowSelection(rowSelection, stateOrGetDataSourceState) {
 function rowSelectionStateConfigGetter(stateOrStateGetter) {
   return () => {
     const state = typeof stateOrStateGetter === "function" ? stateOrStateGetter() : stateOrStateGetter;
+    const { originalDataArray, postFilterDataArray } = state;
     return {
       lazyLoad: !!state.lazyLoad,
       toPrimaryKey: state.toPrimaryKey,
@@ -17242,7 +17394,11 @@ function rowSelectionStateConfigGetter(stateOrStateGetter) {
       groupBy: state.groupBy,
       groupDeepMap: state.groupDeepMap,
       indexer: state.indexer,
-      totalCount: state.unfilteredCount
+      totalCount: state.unfilteredCount,
+      multiRowSelectionTarget: state.multiRowSelectionTarget,
+      someRowsFilteredOut: !state.lazyLoad && !!originalDataArray && !!postFilterDataArray && postFilterDataArray.length < originalDataArray.length,
+      originalDataArray,
+      postFilterDataArray
     };
   };
 }
@@ -18177,6 +18333,9 @@ var TreeExpandState = class {
 };
 
 // src/components/DataSource/TreeSelectionState.ts
+var toTreePathsMap = (treePaths) => {
+  return Array.isArray(treePaths) ? new DeepMap(treePaths.map((path) => [path, true])) : treePaths;
+};
 var shortestToLongest = (a, b) => a.length - b.length;
 var TreeSelectionState = class _TreeSelectionState {
   constructor(state, getConfig) {
@@ -18203,13 +18362,7 @@ var TreeSelectionState = class _TreeSelectionState {
     }
   }
   getTreePaths(treePaths) {
-    if (treePaths) {
-      if (Array.isArray(treePaths)) {
-        return new DeepMap(treePaths.map((path) => [path, true]));
-      }
-      return treePaths;
-    }
-    return this.config.treePaths;
+    return treePaths ? toTreePathsMap(treePaths) : this.config.treePaths;
   }
   withTreePaths(fn, treePaths) {
     const initialTreePaths = this.config.treePaths;
@@ -18282,11 +18435,38 @@ var TreeSelectionState = class _TreeSelectionState {
   setConfig(getConfig) {
     const config = typeof getConfig === "function" ? getConfig() : getConfig;
     this.config = {
-      treePaths: Array.isArray(config.treePaths) ? new DeepMap(config.treePaths.map((path) => [path, true])) : config.treePaths,
-      strictCheckPaths: config.strictCheckPaths ?? true
+      treePaths: toTreePathsMap(config.treePaths),
+      strictCheckPaths: config.strictCheckPaths ?? true,
+      multiRowSelectionTarget: config.multiRowSelectionTarget,
+      unfilteredTreePaths: config.unfilteredTreePaths ? toTreePathsMap(config.unfilteredTreePaths) : void 0
     };
     this.xcache();
   }
+  hasFilteredOutLeavesInside(nodePath) {
+    const { multiRowSelectionTarget, unfilteredTreePaths, treePaths } = this.config;
+    if (multiRowSelectionTarget !== "visible" || !unfilteredTreePaths || unfilteredTreePaths === treePaths) {
+      return false;
+    }
+    return unfilteredTreePaths.getAllChildrenSizeFor(nodePath) > treePaths.getAllChildrenSizeFor(nodePath);
+  }
+  /**
+   * Sets the selection of each visible leaf node inside the node, by its path,
+   * so the leaf nodes that are filtered out keep their selection
+   */
+  setVisibleLeafNodesSelection(nodePath, selected) {
+    const { unfilteredTreePaths, treePaths } = this.config;
+    this.xcache();
+    treePaths.getKeysForLeafNodesStartingWith(nodePath).forEach((leafPath) => {
+      if (unfilteredTreePaths.getAllChildrenSizeFor(leafPath) > 0) {
+        return;
+      }
+      this.selectionMap.delete(leafPath);
+      if (this.isNodeSelected(leafPath) !== selected) {
+        this.setSelectionForPath(leafPath, selected);
+      }
+    });
+    this.xcache();
+  }
   xcache() {
     this.cache.clear();
   }
@@ -18327,6 +18507,10 @@ var TreeSelectionState = class _TreeSelectionState {
     };
   }
   deselectAll() {
+    if (this.hasFilteredOutLeavesInside([])) {
+      this.setVisibleLeafNodesSelection([], false);
+      return;
+    }
     this.update({
       defaultSelection: false,
       selectedPaths: [],
@@ -18334,6 +18518,10 @@ var TreeSelectionState = class _TreeSelectionState {
     });
   }
   selectAll() {
+    if (this.hasFilteredOutLeavesInside([])) {
+      this.setVisibleLeafNodesSelection([], true);
+      return;
+    }
     this.update({
       defaultSelection: true,
       deselectedPaths: [],
@@ -18485,6 +18673,10 @@ var TreeSelectionState = class _TreeSelectionState {
     if (!nodePath.length) {
       return;
     }
+    if (this.hasFilteredOutLeavesInside(nodePath)) {
+      this.setVisibleLeafNodesSelection(nodePath, selected);
+      return;
+    }
     this.xcache();
     const keys = this.selectionMap.getKeysStartingWith(nodePath);
     keys.forEach((nodePath2) => {
@@ -18541,8 +18733,17 @@ function cloneTreeSelection(treeSelection2, stateOrGetState) {
 function treeSelectionStateConfigGetter(stateOrStateGetter) {
   return () => {
     const state = typeof stateOrStateGetter === "function" ? stateOrStateGetter() : stateOrStateGetter;
+    const { treePaths, unfilteredTreePaths, multiRowSelectionTarget } = state;
+    if (multiRowSelectionTarget === "visible") {
+      return {
+        treePaths,
+        unfilteredTreePaths,
+        multiRowSelectionTarget
+      };
+    }
     return {
-      treePaths: state.treePaths
+      treePaths: unfilteredTreePaths ?? treePaths,
+      multiRowSelectionTarget
     };
   };
 }
@@ -20607,6 +20808,7 @@ var forwardProps3 = (setupState, props) => {
     treeFilterFunction: 1,
     filterValue: 1,
     useGroupKeysForMultiRowSelection: (useGroupKeysForMultiRowSelection) => useGroupKeysForMultiRowSelection ?? false,
+    multiRowSelectionTarget: (multiRowSelectionTarget) => multiRowSelectionTarget ?? "all",
     filterDelay: (filterDelay) => filterDelay ?? 200,
     filterTypes: (filterTypes) => {
       return { ...defaultFilterTypes2, ...filterTypes };
@@ -21670,12 +21872,14 @@ function concludeReducer(params) {
     "rowSelection",
     "cellSelection",
     "isRowSelected",
+    "multiRowSelectionTarget",
     "originalLazyGroupDataChangeDetect"
   ]);
   const treeSelectionDepsChanged = haveDepsChanged(previousState, state, [
     "treeSelection",
     "cellSelection",
     "isNodeSelected",
+    "multiRowSelectionTarget",
     "originalLazyGroupDataChangeDetect"
   ]);
   const groupsDepsChanged = originalDataArrayChanged || sortDepsChanged || haveDepsChanged(previousState, state, [
@@ -21809,6 +22013,9 @@ function concludeReducer(params) {
   const rowSelectionState = state.rowSelection instanceof RowSelectionState ? state.rowSelection : void 0;
   const treeExpandState = state.treeExpandState instanceof TreeExpandState ? state.treeExpandState : void 0;
   const cellSelectionState = state.cellSelection instanceof CellSelectionState ? state.cellSelection : void 0;
+  if (rowSelectionState) {
+    rowSelectionState.getConfig = rowSelectionStateConfigGetter(state);
+  }
   rowSelectionState?.xcache();
   let isRowSelected = state.selectionMode === "single-row" ? (rowInfo) => {
     return rowInfo.id === state.rowSelection;
@@ -22115,10 +22322,14 @@ function concludeReducer(params) {
           debugId
         ).track.DataSource.label.ComputeSelectionCount.start();
       }
-      const dataArrayCount = state.isTree ? state.totalLeafNodesCount : state.filteredCount;
-      const selectedRowCount = state.isTree ? state.treeSelectionState ? state.treeSelectionState.getSelectedCount() : 0 : state.rowSelection.getSelectedCount();
-      state.allRowsSelected = dataArrayCount === selectedRowCount;
-      state.someRowsSelected = selectedRowCount > 0;
+      const selectionCount = state.isTree ? state.treeSelectionState?.getSelectionCountFor([]) : state.rowSelection.getSelectionCountFor([]);
+      if (selectionCount) {
+        state.allRowsSelected = selectionCount.deselectedCount === 0;
+        state.someRowsSelected = selectionCount.selectedCount > 0;
+      } else {
+        state.allRowsSelected = state.totalLeafNodesCount === 0;
+        state.someRowsSelected = false;
+      }
       if (debugId) {
         marker?.end();
         marker = void 0;
@@ -22217,6 +22428,7 @@ function buildDataSourceDataParams(componentState, overrides, masterContext) {
       dataSourceParams.lazyLoadStartIndex = 0;
     }
     dataSourceParams.groupKeys = [];
+    dataSourceParams.multiRowSelectionTarget = componentState.multiRowSelectionTarget;
   }
   if (overrides) {
     Object.assign(dataSourceParams, overrides);
@@ -27893,7 +28105,7 @@ var useLicense = (licenseKey = "") => {
     }
     let valid2 = isValidLicense(licenseKey, {
       publishedAt: 1624970570587,
-      version: "9.1.4"
+      version: "9.2.0"
     });
     if (!licenseKey && !valid2 && isInsidePlayground) {
       return true;