@infinite-table/infinite-react 7.2.1 → 7.2.2

package/index.dev.mjs

@@ -233,34 +233,76 @@ var DeepMap = class _DeepMap {
       });
     }
   }
-  getValuesStartingWith(keys, excludeSelf, depthLimit) {
+  getValuesStartingWith(keys, options) {
     const result = [];
     this.getStartingWith(
       keys,
       (_keys, value) => {
         result.push(value);
       },
-      excludeSelf,
-      depthLimit
+      options
     );
     return result;
   }
-  getEntriesStartingWith(keys, excludeSelf, depthLimit) {
+  getEntriesStartingWith(keys, options) {
     const result = [];
     this.getStartingWith(
       keys,
       (keys2, value) => {
         result.push([keys2, value]);
       },
-      excludeSelf,
-      depthLimit
+      options
     );
     return result;
   }
-  getUnnestedKeysStartingWith(keys, excludeSelf, depthLimit) {
+  getLeafNodesStartingWith(keys, withPair, options) {
+    const { respectOrder = false } = options || {};
     const pairs = [];
+    const result = [];
+    this.getStartingWith(
+      keys,
+      (_keys, _value, pair) => {
+        if (!pair.map && pair.hasOwnProperty("value")) {
+          if (respectOrder) {
+            pairs.push(pair);
+          } else {
+            result.push(withPair(pair));
+          }
+        }
+      },
+      options
+    );
+    if (respectOrder) {
+      return pairs.sort(SORT_ASC_REVISION).map(withPair);
+    }
+    return result;
+  }
+  getKeysForLeafNodesStartingWith(keys, options) {
+    return this.getLeafNodesStartingWith(keys, (pair) => pair.keys, options);
+  }
+  getKeysAndValuesForLeafNodesStartingWith(keys, options) {
+    return this.getLeafNodesStartingWith(
+      keys,
+      (pair) => [pair.keys, pair.value],
+      options
+    );
+  }
+  /**
+   * @param keys - the keys of the node to start from
+   * @param excludeSelf - whether to exclude the start node
+   * @param depthLimit - the depth limit
+   * @returns the keys of the first child on each branch (starting from the node with the given keys)
+   */
+  getKeysOfFirstChildOnEachBranchStartingWith(keys, options) {
+    const { excludeSelf, depthLimit, respectOrder = true } = options || {};
+    const pairs = [];
+    const result = [];
     const fn = (pair2) => {
-      pairs.push(pair2);
+      if (respectOrder) {
+        pairs.push(pair2);
+      } else {
+        result.push(pair2.keys);
+      }
     };
     let currentMap = this.map;
     let pair;
@@ -295,7 +337,10 @@ var DeepMap = class _DeepMap {
       }
     }
     if (stop) {
-      return pairs.sort(SORT_ASC_REVISION).map((pair2) => pair2.keys);
+      if (respectOrder) {
+        return pairs.sort(SORT_ASC_REVISION).map((pair2) => pair2.keys);
+      }
+      return result;
     }
     this.visitWithNext(
       keys,
@@ -307,21 +352,24 @@ var DeepMap = class _DeepMap {
       depthLimit,
       excludeSelf
     );
-    return pairs.sort(SORT_ASC_REVISION).map((pair2) => pair2.keys);
+    if (respectOrder) {
+      return pairs.sort(SORT_ASC_REVISION).map((pair2) => pair2.keys);
+    }
+    return result;
   }
-  getKeysStartingWith(keys, excludeSelf, depthLimit) {
+  getKeysStartingWith(keys, options) {
     const result = [];
     this.getStartingWith(
       keys,
       (keys2) => {
         result.push(keys2);
       },
-      excludeSelf,
-      depthLimit
+      options
     );
     return result;
   }
-  getStartingWith(keys, fn, excludeSelf, depthLimit) {
+  getStartingWith(keys, fn, options) {
+    const { excludeSelf, depthLimit } = options || {};
     let currentMap = this.map;
     let pair;
     let stop = false;
@@ -343,7 +391,7 @@ var DeepMap = class _DeepMap {
     }
     if (pair && pair.value !== void 0) {
       if (!excludeSelf) {
-        fn(keys, pair.value);
+        fn(keys, pair.value, { ...pair, keys });
       }
     }
     if (stop) {
@@ -351,8 +399,8 @@ var DeepMap = class _DeepMap {
     }
     this.visitWithNext(
       keys,
-      (value, keys2, _i, next) => {
-        fn(keys2, value);
+      (value, keys2, _i, next, pair2) => {
+        fn(keys2, value, { ...pair2, keys: keys2 });
         next?.();
       },
       false,
@@ -669,6 +717,7 @@ var DeepMap = class _DeepMap {
   //   return makeIterator();
   // }
 };
+globalThis.DeepMap = DeepMap;
 
 // src/utils/getGlobal.ts
 function getGlobal() {
@@ -798,7 +847,9 @@ function isChannelTargeted(channel, permissionToken) {
   const hasWildcard = new Set(tokenParts).has(CHANNEL_WILDCARD);
   const indexOfToken = tokenParts.indexOf(CHANNEL_WILDCARD);
   const storagePartsWithoutWildcard = hasWildcard ? tokenParts.slice(0, indexOfToken) : tokenParts;
-  if (partsMap.getKeysStartingWith(storagePartsWithoutWildcard, hasWildcard).length > 0) {
+  if (partsMap.getKeysStartingWith(storagePartsWithoutWildcard, {
+    excludeSelf: hasWildcard
+  }).length > 0) {
     const remainingParts = tokenParts.slice(indexOfToken + 1);
     if (remainingParts.length) {
       return channel.endsWith(remainingParts.join(CHANNEL_SEPARATOR));
@@ -3323,7 +3374,10 @@ var GridCellManager = class extends Logger {
     return this.matrix.rawKeysAt([]).sort(ASC_SORT);
   }
   getColumnsWithCells() {
-    const positions = this.matrix.getUnnestedKeysStartingWith([], true);
+    const positions = this.matrix.getKeysOfFirstChildOnEachBranchStartingWith(
+      [],
+      { excludeSelf: true }
+    );
     const columns = new Set(positions.map((pos) => pos[1]));
     return [...columns.values()].sort(ASC_SORT);
   }
@@ -14541,7 +14595,10 @@ function toTreeDataArray(data, options) {
     treeMap.set(path, item);
   }
   function traverse(path, arr) {
-    const nextLevelKeys = treeMap.getKeysStartingWith(path, true, 1);
+    const nextLevelKeys = treeMap.getKeysStartingWith(path, {
+      excludeSelf: true,
+      depthLimit: 1
+    });
     for (const nextLevelKey of nextLevelKeys) {
       const p = [...path, nextLevelKey[nextLevelKey.length - 1]];
       let item = treeMap.get(p);
@@ -15023,12 +15080,18 @@ var RowSelectionState = class _RowSelectionState {
   }
   getGroupKeysDirectlyInsideGroup(groupKeys) {
     const { groupDeepMap } = this.getConfig();
-    return groupDeepMap?.getKeysStartingWith(groupKeys, true, 1) || [];
+    return groupDeepMap?.getKeysStartingWith(groupKeys, {
+      excludeSelf: true,
+      depthLimit: 1
+    }) || [];
   }
   getAllPrimaryKeysInsideGroup(groupKeys) {
     const { groupDeepMap } = this.getConfig();
     if (!groupKeys.length) {
-      const topLevelKeys = groupDeepMap?.getKeysStartingWith([], true, 1) || [];
+      const topLevelKeys = groupDeepMap?.getKeysStartingWith([], {
+        excludeSelf: true,
+        depthLimit: 1
+      }) || [];
       return topLevelKeys.map((groupKeys2) => this.getAllPrimaryKeysInsideGroup(groupKeys2)).flat();
     }
     const group2 = groupDeepMap?.get(groupKeys);
@@ -15234,7 +15297,9 @@ var RowSelectionState = class _RowSelectionState {
       this.xcache();
       return;
     }
-    const selectedKeys = this.selectedMap.getKeysStartingWith(groupKeys, true);
+    const selectedKeys = this.selectedMap.getKeysStartingWith(groupKeys, {
+      excludeSelf: true
+    });
     selectedKeys.forEach((groupKeys2) => {
       this.selectedMap.delete(groupKeys2);
     });
@@ -15260,10 +15325,9 @@ var RowSelectionState = class _RowSelectionState {
       this.xcache();
       return;
     }
-    const deselectedKeys = this.deselectedMap.getKeysStartingWith(
-      groupKeys,
-      true
-    );
+    const deselectedKeys = this.deselectedMap.getKeysStartingWith(groupKeys, {
+      excludeSelf: true
+    });
     deselectedKeys.forEach((groupKeys2) => {
       this.deselectedMap.delete(groupKeys2);
     });
@@ -15390,16 +15454,14 @@ var RowSelectionState = class _RowSelectionState {
     if (groupKeys.length === this.getGroupByLength()) {
       const selectionState = this.selectedMap.has(groupKeys) ? true : this.deselectedMap.has(groupKeys) ? false : parentSelected;
       const totalCount = this.getGroupCount(groupKeys);
-      let selectedCount2 = this.selectedMap.getKeysStartingWith(
-        groupKeys,
-        true,
-        1
-      ).length;
-      let deselectedCount2 = this.deselectedMap.getKeysStartingWith(
-        groupKeys,
-        true,
-        1
-      ).length;
+      let selectedCount2 = this.selectedMap.getKeysStartingWith(groupKeys, {
+        excludeSelf: true,
+        depthLimit: 1
+      }).length;
+      let deselectedCount2 = this.deselectedMap.getKeysStartingWith(groupKeys, {
+        excludeSelf: true,
+        depthLimit: 1
+      }).length;
       const notSpecifiedCount = totalCount - (selectedCount2 + deselectedCount2);
       const result2 = {
         selectedCount: selectedCount2 + (selectionState ? notSpecifiedCount : 0),
@@ -16954,6 +17016,26 @@ var TreeSelectionState = class _TreeSelectionState {
   getTreeDeepMap() {
     return this.getConfig().treeDeepMap;
   }
+  getSelectedLeafNodePaths(rootNodePath = [], treeDeepMap) {
+    treeDeepMap = treeDeepMap || this.getConfig().treeDeepMap;
+    const selectedLeafPaths = [];
+    treeDeepMap.getLeafNodesStartingWith(rootNodePath, (pair) => {
+      if (this.isNodeSelected(pair.keys)) {
+        selectedLeafPaths.push(pair.keys);
+      }
+    });
+    return selectedLeafPaths;
+  }
+  getDeselectedLeafNodePaths(rootNodePath = [], treeDeepMap) {
+    treeDeepMap = treeDeepMap || this.getConfig().treeDeepMap;
+    const deselectedLeafPaths = [];
+    treeDeepMap.getLeafNodesStartingWith(rootNodePath, (pair) => {
+      if (!this.isNodeSelected(pair.keys)) {
+        deselectedLeafPaths.push(pair.keys);
+      }
+    });
+    return deselectedLeafPaths;
+  }
   isLeafNode(nodePath) {
     return !this.getTreeDeepMap().has(nodePath);
   }
@@ -17051,7 +17133,9 @@ var TreeSelectionState = class _TreeSelectionState {
     const leafCount = this.getLeafNodesCount(nodePath);
     let currentSelectionState = this.isSelfSelected(nodePath);
     const { selectionMap } = this;
-    const childPaths = selectionMap.getUnnestedKeysStartingWith(nodePath, true).sort(shortestToLongest);
+    const childPaths = selectionMap.getKeysOfFirstChildOnEachBranchStartingWith(nodePath, {
+      excludeSelf: true
+    }).sort(shortestToLongest);
     if (!childPaths.length) {
       if (currentSelectionState !== null) {
         const res2 = leafCount ? currentSelectionState : (
@@ -17240,6 +17324,52 @@ var TreeApiImpl = class {
     this.actions = param.actions;
     this.dataSourceApi = param.dataSourceApi;
   }
+  getSelectedLeafNodePaths(config) {
+    const { treePaths } = this.getState();
+    const treeSelectionState = config?.treeSelectionState || this.getState().treeSelectionState;
+    if (!treeSelectionState) {
+      return [];
+    }
+    return treeSelectionState.getSelectedLeafNodePaths(
+      config?.rootNodePath,
+      treePaths
+    );
+  }
+  getDeselectedLeafNodePaths(config) {
+    const { treePaths } = this.getState();
+    const treeSelectionState = config?.treeSelectionState || this.getState().treeSelectionState;
+    if (!treeSelectionState) {
+      return [];
+    }
+    return treeSelectionState.getDeselectedLeafNodePaths(
+      config?.rootNodePath,
+      treePaths
+    );
+  }
+  getSelectedLeafRowInfos(config) {
+    const { treePaths } = this.getState();
+    const treeSelectionState = config?.treeSelectionState || this.getState().treeSelectionState;
+    if (!treePaths || !treeSelectionState) {
+      return [];
+    }
+    const rootNodePath = config?.rootNodePath || [];
+    const selectedLeafRowInfos = [];
+    treePaths.getLeafNodesStartingWith(
+      rootNodePath,
+      (pair) => {
+        if (treeSelectionState.isNodeSelected(pair.keys)) {
+          const rowInfo = this.getRowInfoByPath(
+            pair.keys
+          );
+          if (rowInfo) {
+            selectedLeafRowInfos.push(rowInfo);
+          }
+        }
+      },
+      { excludeSelf: true }
+    );
+    return selectedLeafRowInfos;
+  }
   get allRowsSelected() {
     return this.getState().allRowsSelected;
   }
@@ -20546,12 +20676,16 @@ function getMappedCallbacks() {
           callbackParams: callbackParams2
         };
       }
+      const dataSourceApi = state.__apiRef.current;
+      const treeApi = dataSourceApi.treeApi;
       const callbackParams = [
         treeSelection2.getState(),
         {
+          treeSelectionState: treeSelection2,
           selectionMode: "multi-row",
           lastUpdatedNodePath: state.lastSelectionUpdatedNodePathRef.current,
-          dataSourceApi: state.__apiRef.current
+          dataSourceApi,
+          treeApi
         }
       ];
       return {
@@ -25536,7 +25670,7 @@ var useLicense = (licenseKey = "") => {
     }
     let valid2 = isValidLicense(licenseKey, {
       publishedAt: 1624970570587,
-      version: "7.2.1"
+      version: "7.2.2"
     });
     if (!licenseKey && !valid2 && isInsidePlayground) {
       return true;