@infinite-table/infinite-react 7.2.5-canary.1 → 7.2.5

package/index.dev.mjs

@@ -1416,13 +1416,17 @@ function AvoidReactDiffFn(props) {
           cancelAnimationFrame(rafId.current);
         }
         rafId.current = requestAnimationFrame(() => {
-          flushSync(() => {
-            setChildren(children2);
+          queueMicrotask(() => {
+            flushSync(() => {
+              setChildren(children2);
+            });
           });
         });
       } else {
-        flushSync(() => {
-          setChildren(children2);
+        queueMicrotask(() => {
+          flushSync(() => {
+            setChildren(children2);
+          });
         });
       }
     }
@@ -9462,6 +9466,15 @@ var getHeaderWrapperNodes = (root) => {
   );
 };
 
+// src/utils/isTargetInput.ts
+function isTargetInput(target) {
+  if (!target) {
+    return false;
+  }
+  const tagName = target.tagName;
+  return tagName === "INPUT" || tagName === "BUTTON";
+}
+
 // src/components/InfiniteTable/hooks/useColumnPointerEvents.ts
 var baseZIndexForCells2 = stripVar(InternalVars.baseZIndexForCells);
 var equalPinning = (pinning1, pinning2) => {
@@ -9504,8 +9517,7 @@ var useColumnPointerEvents = ({
   }, []);
   const onPointerDown = useCallback9(
     (e) => {
-      const tagName = e.target?.tagName;
-      if (tagName === "INPUT" || tagName === "BUTTON") {
+      if (isTargetInput(e.target)) {
         return;
       }
       const { brain, draggableColumnsRestrictTo } = getState();
@@ -17011,52 +17023,103 @@ var TreeSelectionState = class _TreeSelectionState {
     this.defaultSelection = false;
     this.selectionMap = new DeepMap();
     this.cache = new DeepMap();
-    const stateObject = state instanceof Object.getPrototypeOf(this).constructor ? (
+    this.correctnessChecks = false;
+    const isTreeSelectionStateInstance = state instanceof Object.getPrototypeOf(this).constructor;
+    const stateObject = isTreeSelectionStateInstance ? (
       //@ts-ignore
       state.getState()
     ) : state;
-    this.setConfigFn(getConfig);
+    this.setConfig(
+      getConfig || (isTreeSelectionStateInstance ? state.config : {
+        treePaths: new DeepMap()
+      })
+    );
+    this.disableCorrectnessChecks();
     this.update(stateObject);
+    this.enableCorrectnessChecks();
   }
-  getTreeDeepMap() {
-    return this.getConfig().treeDeepMap;
+  getTreePaths(treePaths) {
+    if (treePaths) {
+      if (Array.isArray(treePaths)) {
+        return new DeepMap(treePaths.map((path) => [path, true]));
+      }
+      return treePaths;
+    }
+    return this.config.treePaths;
+  }
+  withTreePaths(fn, treePaths) {
+    const initialTreePaths = this.config.treePaths;
+    treePaths = this.getTreePaths(treePaths);
+    const treePathsDifferent = treePaths !== initialTreePaths;
+    if (treePathsDifferent) {
+      this.xcache();
+    }
+    this.config.treePaths = treePaths;
+    const result = fn(treePaths);
+    this.config.treePaths = initialTreePaths;
+    if (treePathsDifferent) {
+      this.xcache();
+    }
+    return result;
+  }
+  getLeafNodePaths(rootNodePath = [], treePaths) {
+    return this.withTreePaths((paths) => {
+      return paths.getKeysForLeafNodesStartingWith(rootNodePath);
+    }, treePaths);
+  }
+  forEachLeafNodePath(fn, rootNodePath = [], treePaths) {
+    const selectedObj = { selected: false };
+    this.withTreePaths((paths) => {
+      paths.getLeafNodesStartingWith(rootNodePath, (pair) => {
+        selectedObj.selected = this.isNodeSelected(pair.keys) === true;
+        fn(pair.keys, selectedObj);
+      });
+    }, treePaths);
   }
   getSelectedLeafNodePaths(rootNodePath = [], treePaths) {
-    treePaths = treePaths || this.getConfig().treePaths;
     const selectedLeafPaths = [];
-    treePaths.getLeafNodesStartingWith(rootNodePath, (pair) => {
-      if (this.isNodeSelected(pair.keys)) {
-        selectedLeafPaths.push(pair.keys);
-      }
-    });
+    this.withTreePaths((paths) => {
+      paths.getLeafNodesStartingWith(rootNodePath, (pair) => {
+        if (this.isNodeSelected(pair.keys)) {
+          selectedLeafPaths.push(pair.keys);
+        }
+      });
+    }, treePaths);
     return selectedLeafPaths;
   }
   getDeselectedLeafNodePaths(rootNodePath = [], treePaths) {
-    treePaths = treePaths || this.getConfig().treePaths;
     const deselectedLeafPaths = [];
-    treePaths.getLeafNodesStartingWith(rootNodePath, (pair) => {
-      if (!this.isNodeSelected(pair.keys)) {
-        deselectedLeafPaths.push(pair.keys);
-      }
-    });
+    this.withTreePaths((paths) => {
+      paths.getLeafNodesStartingWith(rootNodePath, (pair) => {
+        if (!this.isNodeSelected(pair.keys)) {
+          deselectedLeafPaths.push(pair.keys);
+        }
+      });
+    }, treePaths);
     return deselectedLeafPaths;
   }
   isLeafNode(nodePath) {
-    return !this.getTreeDeepMap().has(nodePath);
+    const { treePaths } = this.config;
+    if (!treePaths.has(nodePath)) {
+      return null;
+    }
+    const keys = treePaths.getKeysForLeafNodesStartingWith(nodePath);
+    if (keys.length === 1) {
+      return true;
+    }
+    return false;
   }
   getLeafNodesCount(nodePath) {
-    const treeDeepMap = this.getTreeDeepMap();
-    const deepMapValue = treeDeepMap.get(nodePath);
-    if (!deepMapValue) {
-      return 1;
-    }
-    return deepMapValue.items.length;
+    return this.config.treePaths.getKeysForLeafNodesStartingWith(nodePath).length;
   }
   static from(treeSelectionState, getConfig) {
     return new _TreeSelectionState(treeSelectionState, getConfig);
   }
-  setConfigFn(getConfig) {
-    this.getConfig = getConfig;
+  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
+    };
     this.xcache();
   }
   xcache() {
@@ -17077,6 +17140,9 @@ var TreeSelectionState = class _TreeSelectionState {
     this.xcache();
   }
   setSelectionForPath(nodePath, selected) {
+    if (!this.isPathAvailable(nodePath)) {
+      return;
+    }
     this.selectionMap.set(nodePath, selected);
   }
   getState() {
@@ -17109,6 +17175,19 @@ var TreeSelectionState = class _TreeSelectionState {
       selectedPaths: []
     });
   }
+  enableCorrectnessChecks() {
+    this.correctnessChecks = true;
+  }
+  disableCorrectnessChecks() {
+    this.correctnessChecks = false;
+  }
+  isPathAvailable(nodePath) {
+    if (!this.correctnessChecks) {
+      return true;
+    }
+    const { treePaths } = this.config;
+    return treePaths.has(nodePath);
+  }
   isNodeSelected(nodePath) {
     return this.isPathSelected(nodePath);
   }
@@ -17124,7 +17203,7 @@ var TreeSelectionState = class _TreeSelectionState {
     if (cachedResult) {
       return cachedResult;
     }
-    if (this.isLeafNode(nodePath)) {
+    if (this.isLeafNode(nodePath) !== false) {
       const selected = this.isSelfSelected(nodePath);
       if (selected !== null) {
         return this.cacheIt(nodePath, {
@@ -17138,9 +17217,12 @@ var TreeSelectionState = class _TreeSelectionState {
     const leafCount = this.getLeafNodesCount(nodePath);
     let currentSelectionState = this.isSelfSelected(nodePath);
     const { selectionMap } = this;
-    const childPaths = selectionMap.getKeysOfFirstChildOnEachBranchStartingWith(nodePath, {
+    let childPaths = selectionMap.getKeysOfFirstChildOnEachBranchStartingWith(nodePath, {
       excludeSelf: true
     }).sort(shortestToLongest);
+    if (this.correctnessChecks) {
+      childPaths = childPaths.filter((path) => this.isPathAvailable(path));
+    }
     if (!childPaths.length) {
       if (currentSelectionState !== null) {
         const res2 = leafCount ? currentSelectionState : (
@@ -17214,6 +17296,9 @@ var TreeSelectionState = class _TreeSelectionState {
     });
   }
   isPathSelected(nodePath) {
+    if (!this.isPathAvailable(nodePath)) {
+      return false;
+    }
     return this.getSelectionStateForNode(nodePath, true).selected;
   }
   getNodeBooleanSelectionStateFromParent(initialNodePath) {
@@ -17235,6 +17320,7 @@ var TreeSelectionState = class _TreeSelectionState {
     if (!nodePath.length) {
       return;
     }
+    this.xcache();
     const keys = this.selectionMap.getKeysStartingWith(nodePath);
     keys.forEach((nodePath2) => {
       this.selectionMap.delete(nodePath2);
@@ -17274,7 +17360,7 @@ var TreeSelectionState = class _TreeSelectionState {
     };
   }
   destroy() {
-    this.getConfig = null;
+    this.config = void 0;
     this.xcache();
     this.selectionMap.clear();
   }
@@ -17291,8 +17377,7 @@ function treeSelectionStateConfigGetter(stateOrStateGetter) {
   return () => {
     const state = typeof stateOrStateGetter === "function" ? stateOrStateGetter() : stateOrStateGetter;
     return {
-      treePaths: state.treePaths,
-      treeDeepMap: state.treeDeepMap
+      treePaths: state.treePaths
     };
   };
 }
@@ -17318,7 +17403,10 @@ var TreeApiImpl = class {
         treeSelectionStateConfigGetter(this.getState)
       );
       treeSelectionState.setNodeSelection(nodePath, selected);
-      this.getState().lastSelectionUpdatedNodePathRef.current = nodePath;
+      this.getState().lastSelectionUpdatedNodePathRef.current = {
+        nodePath,
+        selected
+      };
       this.actions.treeSelection = treeSelectionState;
     };
     this.getCallbackParam = (_nodePath) => {
@@ -17476,8 +17564,7 @@ var TreeApiImpl = class {
     }
   }
   getNodeDataByPath(nodePath) {
-    const { treeDeepMap } = this.getState();
-    if (!treeDeepMap || !nodePath.length) {
+    if (!nodePath.length) {
       return null;
     }
     const rowInfo = this.getRowInfoByPath(nodePath);
@@ -18960,6 +19047,14 @@ function concludeReducer(params) {
   const shouldTreeAgain = shouldTree && (treeDepsChanged || cacheAffectedParts.tree || !state.lastTreeDataArray) || treeSelectionDepsChanged || rowDisabledStateDepsChanged || rowInfoReducersChanged;
   const now = Date.now();
   let dataArray = state.originalDataArray;
+  if (shouldTree && shouldTreeAgain) {
+    const treeParams = {
+      isLeafNode,
+      getNodeChildren,
+      toKey: toPrimaryKey
+    };
+    state.unfilteredTreePaths = tree(treeParams, dataArray).treePaths;
+  }
   if (!shouldFilter) {
     state.unfilteredCount = dataArray.length;
   }
@@ -20258,6 +20353,7 @@ var cleanupDataSource = (state) => {
   };
   state.treeExpandState?.destroy();
   state.treePaths?.clear();
+  state.unfilteredTreePaths?.clear();
   state.waitForNodePathPromises.clear();
   state.pathToIndexMap?.clear();
   state.rowDisabledState?.destroy();
@@ -20417,7 +20513,7 @@ function getTreeSelectionState(currentTreeSelection, selectionMode, state) {
   }
   const config = treeSelectionStateConfigGetter(state);
   if (currentTreeSelection instanceof TreeSelectionState) {
-    currentTreeSelection.setConfigFn(config);
+    currentTreeSelection.setConfig(config);
     return currentTreeSelection;
   }
   if (currentTreeSelection === null || currentTreeSelection === void 0 || typeof currentTreeSelection != "object") {
@@ -20426,7 +20522,7 @@ function getTreeSelectionState(currentTreeSelection, selectionMode, state) {
   const treeSelectionStateObject = currentTreeSelection ?? treeSelectionStateDefaultObject;
   let instance = weakMap.get(treeSelectionStateObject);
   if (instance) {
-    instance.setConfigFn(config);
+    instance.setConfig(config);
   }
   instance = instance ?? new TreeSelectionState(treeSelectionStateObject, config);
   weakMap.set(treeSelectionStateObject, instance);
@@ -20688,8 +20784,10 @@ function getMappedCallbacks() {
         treeSelection2.getState(),
         {
           treeSelectionState: treeSelection2,
+          prevTreeSelectionState: state.treeSelectionState,
           selectionMode: "multi-row",
-          lastUpdatedNodePath: state.lastSelectionUpdatedNodePathRef.current,
+          lastUpdatedNodeInfo: state.lastSelectionUpdatedNodePathRef.current,
+          unfilteredTreePaths: state.unfilteredTreePaths,
           dataSourceApi,
           treeApi
         }
@@ -25676,7 +25774,7 @@ var useLicense = (licenseKey = "") => {
     }
     let valid2 = isValidLicense(licenseKey, {
       publishedAt: 1624970570587,
-      version: "7.2.5-canary.1"
+      version: "7.2.5"
     });
     if (!licenseKey && !valid2 && isInsidePlayground) {
       return true;
@@ -25778,6 +25876,9 @@ function onCellClick(context, event) {
   context.getState().onCellClick?.(context, event);
 }
 function onCellDoubleClick(context, event) {
+  if (isTargetInput(event.target)) {
+    return;
+  }
   const { onCellDoubleClick: onCellDoubleClick2 } = context.getState();
   let dblClickResult = {
     preventEdit: false
@@ -30142,6 +30243,36 @@ import * as React78 from "react";
 function TreeGrid(props) {
   return /* @__PURE__ */ React78.createElement(InfiniteTable, { ...props });
 }
+var withSelectedLeafNodesOnly = (callback) => {
+  const onTreeSelectionChange = (_, {
+    unfilteredTreePaths,
+    treeSelectionState,
+    prevTreeSelectionState,
+    lastUpdatedNodeInfo
+  }) => {
+    const newTreeSelection = new TreeSelectionState(prevTreeSelectionState, {
+      treePaths: unfilteredTreePaths
+    });
+    treeSelectionState.forEachLeafNodePath((nodePath, { selected }) => {
+      newTreeSelection.setNodeSelection(nodePath, selected);
+    });
+    if (lastUpdatedNodeInfo) {
+      treeSelectionState.forEachLeafNodePath((nodePath) => {
+        newTreeSelection.setNodeSelection(
+          nodePath,
+          lastUpdatedNodeInfo.selected
+        );
+      }, lastUpdatedNodeInfo.nodePath);
+    }
+    const selectedPaths = newTreeSelection.getSelectedLeafNodePaths();
+    const treeSelectionObject = {
+      defaultSelection: false,
+      selectedPaths
+    };
+    callback(treeSelectionObject);
+  };
+  return onTreeSelectionChange;
+};
 
 // src/components/DataSource/DataLoader/DataQuery.ts
 var DataQuery = class {
@@ -30900,6 +31031,7 @@ export {
   useOverlayPortal,
   usePrevious,
   useRowInfoReducers,
-  useVisibleColumnSizes
+  useVisibleColumnSizes,
+  withSelectedLeafNodesOnly
 };
 //!collapsed || lazyLoad;