onchain-utility 0.0.16 → 0.0.17

package/dist/OnchainUtility.js

@@ -1145,6 +1145,46 @@ function levelTransformTree({
   });
   return root.children;
 }
+
+/** 获取全部子孙节点  */
+function getTreeDescendants({
+  data,
+  key,
+  signKey = 'id',
+  childrenKey = 'children'
+}) {
+  const {
+    self
+  } = getTreeRelation({
+    childrenKey,
+    data,
+    lookup(item, index) {
+      return item[signKey] === key;
+    }
+  });
+  return arrayAttributeFlat({
+    childrenKey,
+    data: self?.[childrenKey] || []
+  });
+}
+
+/** 获取全部祖先节点 */
+function getTreeAncestors({
+  data,
+  key,
+  signKey = 'id',
+  childrenKey = 'children'
+}) {
+  return getTreeRelation({
+    childrenKey,
+    data,
+    lookup(item, index) {
+      return item[signKey] === key;
+    }
+  }).stack;
+}
+
+/** 删除树节点 */
 function deleteTreeNodes({
   data,
   selectedKeys,
@@ -1298,6 +1338,51 @@ function getSiblings({
   return keys;
 }
 
+/**
+ * @description 是否跨层
+ * @date 2022-11-21 20:03:52
+ * @export
+ * @param {string[]} hierarchy 选中任务的层级
+ * @returns {*}
+ */
+function getSelectedNodeHierarchyStatus({
+  data,
+  selectedKeys,
+  signKey = 'id',
+  childrenKey = 'children'
+}) {
+  const relations = selectedKeys.map(key => getTreeRelation({
+    childrenKey,
+    data,
+    lookup(item, index) {
+      return item[signKey] === key;
+    }
+  }));
+  // 深度集合
+  const deepSet = new Set(relations.map(rel => rel.stack.length));
+  const isDifferentDepths = deepSet.size > 1;
+  if (isDifferentDepths) {
+    return {
+      isDifferentDepths,
+      isIncludedParent: relations.sort((a, b) => {
+        return b.stack.length - a.stack.length;
+      }).some(item => {
+        const ancestors = getTreeAncestors({
+          childrenKey,
+          data,
+          key: item.self[signKey],
+          signKey
+        }).map(item => item[signKey]);
+        return selectedKeys.some(id => ancestors.includes(id));
+      })
+    };
+  }
+  return {
+    isDifferentDepths,
+    isIncludedParent: false
+  };
+}
+
 /**
  * @description 合并相邻的选中数据
  * @date 2023-02-15 16:11:16
@@ -1622,7 +1707,12 @@ async function upgrade({
         });
         const insert = (data, index) => {
           data.splice(index, 0, ...selected);
-          onUpgraded?.(selected);
+          onUpgraded?.(selected, getExpandedState({
+            childrenKey,
+            originalParent: parent,
+            parent: grandpa,
+            signKey
+          }));
         };
         const insertIndex = getInsertIdx({
           leader: start,
@@ -1684,7 +1774,12 @@ async function downgrade({
         const newChildren = [...(before[childrenKey] || []), ...children];
         if (children.length) {
           before[childrenKey] = [...newChildren];
-          onDowngraded?.(children);
+          onDowngraded?.(children, getExpandedState({
+            childrenKey,
+            originalParent: parent,
+            parent: before,
+            signKey
+          }));
         }
       }
     }
@@ -1737,6 +1832,18 @@ function treeSearch({
     }
   }).filter(row => !!row);
 }
+function getExpandedState({
+  originalParent,
+  parent,
+  signKey = 'id',
+  childrenKey = 'children'
+}) {
+  const isRemove = !originalParent[childrenKey]?.length;
+  return {
+    add: parent[signKey],
+    remove: isRemove ? originalParent[signKey] : null
+  };
+}
 
 exports._isMoment = _isMoment;
 exports.arrayAttributeFlat = arrayAttributeFlat;
@@ -1755,7 +1862,10 @@ exports.generatedAcrossHierarchySort = generatedAcrossHierarchySort;
 exports.getBase64Regular = getBase64Regular;
 exports.getHTMLTagString = getHTMLTagString;
 exports.getI18nText = getI18nText;
+exports.getSelectedNodeHierarchyStatus = getSelectedNodeHierarchyStatus;
 exports.getSiblings = getSiblings;
+exports.getTreeAncestors = getTreeAncestors;
+exports.getTreeDescendants = getTreeDescendants;
 exports.getTreeRelation = getTreeRelation;
 exports.hasOwnProperty = hasOwnProperty;
 exports.initTranslateI18nFn = initTranslateI18nFn;

package/dist/OnchainUtility.mjs

@@ -1143,6 +1143,46 @@ function levelTransformTree({
   });
   return root.children;
 }
+
+/** 获取全部子孙节点  */
+function getTreeDescendants({
+  data,
+  key,
+  signKey = 'id',
+  childrenKey = 'children'
+}) {
+  const {
+    self
+  } = getTreeRelation({
+    childrenKey,
+    data,
+    lookup(item, index) {
+      return item[signKey] === key;
+    }
+  });
+  return arrayAttributeFlat({
+    childrenKey,
+    data: self?.[childrenKey] || []
+  });
+}
+
+/** 获取全部祖先节点 */
+function getTreeAncestors({
+  data,
+  key,
+  signKey = 'id',
+  childrenKey = 'children'
+}) {
+  return getTreeRelation({
+    childrenKey,
+    data,
+    lookup(item, index) {
+      return item[signKey] === key;
+    }
+  }).stack;
+}
+
+/** 删除树节点 */
 function deleteTreeNodes({
   data,
   selectedKeys,
@@ -1296,6 +1336,51 @@ function getSiblings({
   return keys;
 }
 
+/**
+ * @description 是否跨层
+ * @date 2022-11-21 20:03:52
+ * @export
+ * @param {string[]} hierarchy 选中任务的层级
+ * @returns {*}
+ */
+function getSelectedNodeHierarchyStatus({
+  data,
+  selectedKeys,
+  signKey = 'id',
+  childrenKey = 'children'
+}) {
+  const relations = selectedKeys.map(key => getTreeRelation({
+    childrenKey,
+    data,
+    lookup(item, index) {
+      return item[signKey] === key;
+    }
+  }));
+  // 深度集合
+  const deepSet = new Set(relations.map(rel => rel.stack.length));
+  const isDifferentDepths = deepSet.size > 1;
+  if (isDifferentDepths) {
+    return {
+      isDifferentDepths,
+      isIncludedParent: relations.sort((a, b) => {
+        return b.stack.length - a.stack.length;
+      }).some(item => {
+        const ancestors = getTreeAncestors({
+          childrenKey,
+          data,
+          key: item.self[signKey],
+          signKey
+        }).map(item => item[signKey]);
+        return selectedKeys.some(id => ancestors.includes(id));
+      })
+    };
+  }
+  return {
+    isDifferentDepths,
+    isIncludedParent: false
+  };
+}
+
 /**
  * @description 合并相邻的选中数据
  * @date 2023-02-15 16:11:16
@@ -1620,7 +1705,12 @@ async function upgrade({
         });
         const insert = (data, index) => {
           data.splice(index, 0, ...selected);
-          onUpgraded?.(selected);
+          onUpgraded?.(selected, getExpandedState({
+            childrenKey,
+            originalParent: parent,
+            parent: grandpa,
+            signKey
+          }));
         };
         const insertIndex = getInsertIdx({
           leader: start,
@@ -1682,7 +1772,12 @@ async function downgrade({
         const newChildren = [...(before[childrenKey] || []), ...children];
         if (children.length) {
           before[childrenKey] = [...newChildren];
-          onDowngraded?.(children);
+          onDowngraded?.(children, getExpandedState({
+            childrenKey,
+            originalParent: parent,
+            parent: before,
+            signKey
+          }));
         }
       }
     }
@@ -1735,5 +1830,17 @@ function treeSearch({
     }
   }).filter(row => !!row);
 }
+function getExpandedState({
+  originalParent,
+  parent,
+  signKey = 'id',
+  childrenKey = 'children'
+}) {
+  const isRemove = !originalParent[childrenKey]?.length;
+  return {
+    add: parent[signKey],
+    remove: isRemove ? originalParent[signKey] : null
+  };
+}
 
-export { _isMoment, arrayAttributeFlat, asyncDfs, base64ToFile, base64ToMimeType, baseTemplate, bfs, createEnumObject, deleteTreeNodes, dfs, downgrade, fromBase64UTF8, generateSecureUUID, generatedAcrossHierarchySort, getBase64Regular, getHTMLTagString, getI18nText, getSiblings, getTreeRelation, hasOwnProperty, initTranslateI18nFn, insert, isArray, isBoolean, isEmptyObject, isFunction, isIntegerKey, isNaN, isNil, isNull, isNumber, isObject, isString, isUndefined, levelTransformTree, makeDestructurable, mergeAdjacent, movUp, move, moveDown, t, toBase64UTF8, toRawType, toTypeString, translateI18n, treeSearch, upgrade, useReactive, useShallowReactive, useStore };
+export { _isMoment, arrayAttributeFlat, asyncDfs, base64ToFile, base64ToMimeType, baseTemplate, bfs, createEnumObject, deleteTreeNodes, dfs, downgrade, fromBase64UTF8, generateSecureUUID, generatedAcrossHierarchySort, getBase64Regular, getHTMLTagString, getI18nText, getSelectedNodeHierarchyStatus, getSiblings, getTreeAncestors, getTreeDescendants, getTreeRelation, hasOwnProperty, initTranslateI18nFn, insert, isArray, isBoolean, isEmptyObject, isFunction, isIntegerKey, isNaN, isNil, isNull, isNumber, isObject, isString, isUndefined, levelTransformTree, makeDestructurable, mergeAdjacent, movUp, move, moveDown, t, toBase64UTF8, toRawType, toTypeString, translateI18n, treeSearch, upgrade, useReactive, useShallowReactive, useStore };

package/dist/Tree.js

@@ -61,6 +61,46 @@ function levelTransformTree({
   });
   return root.children;
 }
+
+/** 获取全部子孙节点  */
+function getTreeDescendants({
+  data,
+  key,
+  signKey = 'id',
+  childrenKey = 'children'
+}) {
+  const {
+    self
+  } = getTreeRelation({
+    childrenKey,
+    data,
+    lookup(item, index) {
+      return item[signKey] === key;
+    }
+  });
+  return arrayAttributeFlat({
+    childrenKey,
+    data: self?.[childrenKey] || []
+  });
+}
+
+/** 获取全部祖先节点 */
+function getTreeAncestors({
+  data,
+  key,
+  signKey = 'id',
+  childrenKey = 'children'
+}) {
+  return getTreeRelation({
+    childrenKey,
+    data,
+    lookup(item, index) {
+      return item[signKey] === key;
+    }
+  }).stack;
+}
+
+/** 删除树节点 */
 function deleteTreeNodes({
   data,
   selectedKeys,
@@ -214,6 +254,51 @@ function getSiblings({
   return keys;
 }
 
+/**
+ * @description 是否跨层
+ * @date 2022-11-21 20:03:52
+ * @export
+ * @param {string[]} hierarchy 选中任务的层级
+ * @returns {*}
+ */
+function getSelectedNodeHierarchyStatus({
+  data,
+  selectedKeys,
+  signKey = 'id',
+  childrenKey = 'children'
+}) {
+  const relations = selectedKeys.map(key => getTreeRelation({
+    childrenKey,
+    data,
+    lookup(item, index) {
+      return item[signKey] === key;
+    }
+  }));
+  // 深度集合
+  const deepSet = new Set(relations.map(rel => rel.stack.length));
+  const isDifferentDepths = deepSet.size > 1;
+  if (isDifferentDepths) {
+    return {
+      isDifferentDepths,
+      isIncludedParent: relations.sort((a, b) => {
+        return b.stack.length - a.stack.length;
+      }).some(item => {
+        const ancestors = getTreeAncestors({
+          childrenKey,
+          data,
+          key: item.self[signKey],
+          signKey
+        }).map(item => item[signKey]);
+        return selectedKeys.some(id => ancestors.includes(id));
+      })
+    };
+  }
+  return {
+    isDifferentDepths,
+    isIncludedParent: false
+  };
+}
+
 /**
  * @description 合并相邻的选中数据
  * @date 2023-02-15 16:11:16
@@ -538,7 +623,12 @@ async function upgrade({
         });
         const insert = (data, index) => {
           data.splice(index, 0, ...selected);
-          onUpgraded?.(selected);
+          onUpgraded?.(selected, getExpandedState({
+            childrenKey,
+            originalParent: parent,
+            parent: grandpa,
+            signKey
+          }));
         };
         const insertIndex = getInsertIdx({
           leader: start,
@@ -600,7 +690,12 @@ async function downgrade({
         const newChildren = [...(before[childrenKey] || []), ...children];
         if (children.length) {
           before[childrenKey] = [...newChildren];
-          onDowngraded?.(children);
+          onDowngraded?.(children, getExpandedState({
+            childrenKey,
+            originalParent: parent,
+            parent: before,
+            signKey
+          }));
         }
       }
     }
@@ -653,12 +748,27 @@ function treeSearch({
     }
   }).filter(row => !!row);
 }
+function getExpandedState({
+  originalParent,
+  parent,
+  signKey = 'id',
+  childrenKey = 'children'
+}) {
+  const isRemove = !originalParent[childrenKey]?.length;
+  return {
+    add: parent[signKey],
+    remove: isRemove ? originalParent[signKey] : null
+  };
+}
 
 exports.arrayAttributeFlat = arrayAttributeFlat;
 exports.deleteTreeNodes = deleteTreeNodes;
 exports.downgrade = downgrade;
 exports.generatedAcrossHierarchySort = generatedAcrossHierarchySort;
+exports.getSelectedNodeHierarchyStatus = getSelectedNodeHierarchyStatus;
 exports.getSiblings = getSiblings;
+exports.getTreeAncestors = getTreeAncestors;
+exports.getTreeDescendants = getTreeDescendants;
 exports.getTreeRelation = getTreeRelation;
 exports.insert = insert;
 exports.levelTransformTree = levelTransformTree;

package/dist/Tree.mjs

@@ -59,6 +59,46 @@ function levelTransformTree({
   });
   return root.children;
 }
+
+/** 获取全部子孙节点  */
+function getTreeDescendants({
+  data,
+  key,
+  signKey = 'id',
+  childrenKey = 'children'
+}) {
+  const {
+    self
+  } = getTreeRelation({
+    childrenKey,
+    data,
+    lookup(item, index) {
+      return item[signKey] === key;
+    }
+  });
+  return arrayAttributeFlat({
+    childrenKey,
+    data: self?.[childrenKey] || []
+  });
+}
+
+/** 获取全部祖先节点 */
+function getTreeAncestors({
+  data,
+  key,
+  signKey = 'id',
+  childrenKey = 'children'
+}) {
+  return getTreeRelation({
+    childrenKey,
+    data,
+    lookup(item, index) {
+      return item[signKey] === key;
+    }
+  }).stack;
+}
+
+/** 删除树节点 */
 function deleteTreeNodes({
   data,
   selectedKeys,
@@ -212,6 +252,51 @@ function getSiblings({
   return keys;
 }
 
+/**
+ * @description 是否跨层
+ * @date 2022-11-21 20:03:52
+ * @export
+ * @param {string[]} hierarchy 选中任务的层级
+ * @returns {*}
+ */
+function getSelectedNodeHierarchyStatus({
+  data,
+  selectedKeys,
+  signKey = 'id',
+  childrenKey = 'children'
+}) {
+  const relations = selectedKeys.map(key => getTreeRelation({
+    childrenKey,
+    data,
+    lookup(item, index) {
+      return item[signKey] === key;
+    }
+  }));
+  // 深度集合
+  const deepSet = new Set(relations.map(rel => rel.stack.length));
+  const isDifferentDepths = deepSet.size > 1;
+  if (isDifferentDepths) {
+    return {
+      isDifferentDepths,
+      isIncludedParent: relations.sort((a, b) => {
+        return b.stack.length - a.stack.length;
+      }).some(item => {
+        const ancestors = getTreeAncestors({
+          childrenKey,
+          data,
+          key: item.self[signKey],
+          signKey
+        }).map(item => item[signKey]);
+        return selectedKeys.some(id => ancestors.includes(id));
+      })
+    };
+  }
+  return {
+    isDifferentDepths,
+    isIncludedParent: false
+  };
+}
+
 /**
  * @description 合并相邻的选中数据
  * @date 2023-02-15 16:11:16
@@ -536,7 +621,12 @@ async function upgrade({
         });
         const insert = (data, index) => {
           data.splice(index, 0, ...selected);
-          onUpgraded?.(selected);
+          onUpgraded?.(selected, getExpandedState({
+            childrenKey,
+            originalParent: parent,
+            parent: grandpa,
+            signKey
+          }));
         };
         const insertIndex = getInsertIdx({
           leader: start,
@@ -598,7 +688,12 @@ async function downgrade({
         const newChildren = [...(before[childrenKey] || []), ...children];
         if (children.length) {
           before[childrenKey] = [...newChildren];
-          onDowngraded?.(children);
+          onDowngraded?.(children, getExpandedState({
+            childrenKey,
+            originalParent: parent,
+            parent: before,
+            signKey
+          }));
         }
       }
     }
@@ -651,5 +746,17 @@ function treeSearch({
     }
   }).filter(row => !!row);
 }
+function getExpandedState({
+  originalParent,
+  parent,
+  signKey = 'id',
+  childrenKey = 'children'
+}) {
+  const isRemove = !originalParent[childrenKey]?.length;
+  return {
+    add: parent[signKey],
+    remove: isRemove ? originalParent[signKey] : null
+  };
+}
 
-export { arrayAttributeFlat, deleteTreeNodes, downgrade, generatedAcrossHierarchySort, getSiblings, getTreeRelation, insert, levelTransformTree, mergeAdjacent, movUp, move, moveDown, treeSearch, upgrade };
+export { arrayAttributeFlat, deleteTreeNodes, downgrade, generatedAcrossHierarchySort, getSelectedNodeHierarchyStatus, getSiblings, getTreeAncestors, getTreeDescendants, getTreeRelation, insert, levelTransformTree, mergeAdjacent, movUp, move, moveDown, treeSearch, upgrade };

package/package.json

@@ -2,7 +2,7 @@
   "name": "onchain-utility",
   "description": "This package contains misc utilities for onchain.",
   "license": "MIT",
-  "version": "0.0.16",
+  "version": "0.0.17",
   "files": [
     "dist",
     "src"

package/src/Tree/index.ts

@@ -79,9 +79,44 @@ export function levelTransformTree<T extends Item>({
     }
   });
 
-  return root.children;
+  type _Item = T & {children: _Item[]};
+  return root.children as _Item[];
 }
 
+/** 获取全部子孙节点  */
+export function getTreeDescendants<T extends Item>({
+  data,
+  key,
+  signKey = 'id',
+  childrenKey = 'children',
+}: Params<T> & {key: string}) {
+  const {self} = getTreeRelation({
+    childrenKey,
+    data,
+    lookup(item, index) {
+      return item[signKey] === key;
+    },
+  });
+  return arrayAttributeFlat({childrenKey, data: self?.[childrenKey] || []});
+}
+
+/** 获取全部祖先节点 */
+export function getTreeAncestors<T extends Item>({
+  data,
+  key,
+  signKey = 'id',
+  childrenKey = 'children',
+}: Params<T> & {key: string}) {
+  return getTreeRelation({
+    childrenKey,
+    data,
+    lookup(item, index) {
+      return item[signKey] === key;
+    },
+  }).stack;
+}
+
+/** 删除树节点 */
 export function deleteTreeNodes<T extends Item>({
   data,
   selectedKeys,
@@ -264,6 +299,63 @@ export function getSiblings<T extends Item>({
   return keys;
 }
 
+/**
+ * @description 是否跨层
+ * @date 2022-11-21 20:03:52
+ * @export
+ * @param {string[]} hierarchy 选中任务的层级
+ * @returns {*}
+ */
+export function getSelectedNodeHierarchyStatus<T extends Item>({
+  data,
+  selectedKeys,
+  signKey = 'id',
+  childrenKey = 'children',
+}: Params<T> & {
+  selectedKeys: string[];
+}): {
+  /** 层级深度是否有差别 */
+  isDifferentDepths: boolean;
+  /** 选中是否包含了祖先节点和其后的节点 */
+  isIncludedParent: boolean;
+} {
+  const relations = selectedKeys.map((key) =>
+    getTreeRelation({
+      childrenKey,
+      data,
+      lookup(item, index) {
+        return item[signKey] === key;
+      },
+    }),
+  );
+  // 深度集合
+  const deepSet = new Set(relations.map((rel) => rel.stack.length));
+  const isDifferentDepths = deepSet.size > 1;
+  if (isDifferentDepths) {
+    return {
+      isDifferentDepths,
+      isIncludedParent: relations
+        .sort((a, b) => {
+          return b.stack.length - a.stack.length;
+        })
+        .some((item) => {
+          const ancestors = getTreeAncestors({
+            childrenKey,
+            data,
+            key: item.self[signKey],
+            signKey,
+          }).map((item) => item[signKey]);
+          return selectedKeys.some((id) => ancestors.includes(id));
+        }),
+    };
+  }
+
+  return {
+    isDifferentDepths,
+    isIncludedParent: false,
+  };
+}
+
 /**
  * @description 合并相邻的选中数据
  * @date 2023-02-15 16:11:16
@@ -438,6 +530,16 @@ type MoveParams<T> = Params<T> & {
   onError?: (params: {selected: T[]; isMoveUp?: boolean}) => boolean | void;
 };
 
+interface ParentParams<T> {
+  originalParent: T;
+  parent: T;
+}
+
+interface ExpandedState<T> {
+  add: T;
+  remove: T | null;
+}
+
 export function move<T extends Item>({
   data,
   signKey = 'id',
@@ -509,6 +611,12 @@ export function moveDown<T extends Item>(_: MoveParams<T>) {
   });
 }
 
+interface OnUpgradeParams<T> {
+  selected: T[];
+  parent: T;
+  grandpa?: T;
+}
+
 export async function upgrade<T extends Item>({
   data,
   signKey = 'id',
@@ -526,12 +634,11 @@ export async function upgrade<T extends Item>({
   isSupportMultipleRoot?: boolean;
   onStopFollow?: (item: T) => boolean;
   onFilterFollow?: (item: T[]) => T[];
-  onUpgrade?: (params: {
-    selected: T[];
-    parent: T;
-    grandpa?: T;
-  }) => Promise<boolean> | boolean;
-  onUpgraded?: (upgrades: T[]) => void;
+  onUpgrade?: (params: OnUpgradeParams<T>) => Promise<boolean> | boolean;
+  onUpgraded?: (
+    upgrades: T[],
+    params: ExpandedState<T[typeof signKey]>,
+  ) => void;
 }) {
   data = optimizeStructure({childrenKey, data, isSupportMultipleRoot, signKey});
   const layers = mergeAdjacent({childrenKey, data, selectKeys, signKey});
@@ -606,7 +713,16 @@ export async function upgrade<T extends Item>({
 
         const insert = (data: T[], index: number) => {
           data.splice(index, 0, ...selected);
-          onUpgraded?.(selected);
+          onUpgraded?.(
+            selected,
+            getExpandedState({
+              childrenKey,
+              data,
+              originalParent: parent,
+              parent: grandpa!,
+              signKey,
+            }),
+          );
         };
         const insertIndex = getInsertIdx({
           leader: start,
@@ -619,6 +735,12 @@ export async function upgrade<T extends Item>({
   }
 }
 
+interface OnDowngradedParams<T> {
+  selected: T[];
+  beforeSibling: T[];
+  parent: T | undefined;
+}
+
 export async function downgrade<T extends Item>({
   data,
   signKey = 'id',
@@ -628,12 +750,11 @@ export async function downgrade<T extends Item>({
   childrenKey = 'children',
   onError,
 }: MoveParams<T> & {
-  onDowngrade?: (params: {
-    selected: T[];
-    beforeSibling: T[];
-    parent: T | undefined;
-  }) => Promise<boolean> | boolean;
-  onDowngraded?: (downgrades: T[]) => void;
+  onDowngrade?: (params: OnDowngradedParams<T>) => Promise<boolean> | boolean;
+  onDowngraded?: (
+    downgrades: T[],
+    params: ExpandedState<T[typeof signKey]>,
+  ) => void;
 }) {
   data = optimizeStructure({childrenKey, data, signKey});
   const layers = mergeAdjacent({childrenKey, data, selectKeys, signKey});
@@ -662,7 +783,16 @@ export async function downgrade<T extends Item>({
         const newChildren = [...(before[childrenKey] || []), ...children];
         if (children.length) {
           (before as Item)[childrenKey] = [...newChildren];
-          onDowngraded?.(children);
+          onDowngraded?.(
+            children,
+            getExpandedState({
+              childrenKey,
+              data,
+              originalParent: parent,
+              parent: before,
+              signKey,
+            }),
+          );
         }
       }
     }
@@ -722,3 +852,19 @@ export function treeSearch<T extends Record<string, any>>({
     })
     .filter((row): row is T => !!row);
 }
+
+function getExpandedState<T extends Item>({
+  originalParent,
+  parent,
+  signKey = 'id',
+  childrenKey = 'children',
+}: ParentParams<T> & Params<T>) {
+  const isRemove = !originalParent[childrenKey]?.length;
+
+  type Key = T[typeof signKey];
+
+  return {
+    add: parent[signKey] as Key,
+    remove: isRemove ? (originalParent[signKey] as Key) : null,
+  };
+}