onchain-utility 0.0.15 → 0.0.17

package/dist/Hooks.js

@@ -87,6 +87,7 @@ var useUpdate = function () {
  */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
+/** 是否是Moment对象（_表示为内部函数谨慎使用） */
 function _isMoment(obj) {
   return obj != null && typeof obj === 'object' &&
   // 检查内部标志
@@ -96,6 +97,13 @@ function _isMoment(obj) {
   // 检查内部属性
   '_d' in obj && '_i' in obj;
 }
+
+/**
+ * 创建一个可解构的对象，该对象同时具有原始对象的属性和数组的迭代器，使其可以使用对象和数组两种解构方式
+ * @param obj - 需要转换的对象
+ * @param arr - 用于提供迭代器的数组
+ * @returns 一个结合了对象属性和数组迭代器的新对象
+ */
 function makeDestructurable(obj, arr) {
   if (typeof Symbol !== 'undefined') {
     const clone = {
@@ -118,6 +126,8 @@ function makeDestructurable(obj, arr) {
     return Object.assign([...arr], obj);
   }
 }
+
+/** 创建对象枚举，可以避免两个相同枚举缺不相等 */
 function createEnumObject(o) {
   return o;
 }
@@ -128,9 +138,13 @@ function toRawType(value) {
   // 从字符串中提取“RawType”，如“[object RawType]”
   return toTypeString(value).slice(8, -1);
 }
+
+/** 判断对象是否有某个属性 */
 function hasOwnProperty(data, key) {
   return data && Object.prototype.hasOwnProperty.call(data, key);
 }
+
+/** 是否是整型key */
 function isIntegerKey(key) {
   return typeof key === 'string' && key !== 'NaN' && key[0] !== '-' && '' + parseInt(key, 10) === key;
 }

package/dist/Hooks.mjs

@@ -85,6 +85,7 @@ var useUpdate = function () {
  */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
+/** 是否是Moment对象（_表示为内部函数谨慎使用） */
 function _isMoment(obj) {
   return obj != null && typeof obj === 'object' &&
   // 检查内部标志
@@ -94,6 +95,13 @@ function _isMoment(obj) {
   // 检查内部属性
   '_d' in obj && '_i' in obj;
 }
+
+/**
+ * 创建一个可解构的对象，该对象同时具有原始对象的属性和数组的迭代器，使其可以使用对象和数组两种解构方式
+ * @param obj - 需要转换的对象
+ * @param arr - 用于提供迭代器的数组
+ * @returns 一个结合了对象属性和数组迭代器的新对象
+ */
 function makeDestructurable(obj, arr) {
   if (typeof Symbol !== 'undefined') {
     const clone = {
@@ -116,6 +124,8 @@ function makeDestructurable(obj, arr) {
     return Object.assign([...arr], obj);
   }
 }
+
+/** 创建对象枚举，可以避免两个相同枚举缺不相等 */
 function createEnumObject(o) {
   return o;
 }
@@ -126,9 +136,13 @@ function toRawType(value) {
   // 从字符串中提取“RawType”，如“[object RawType]”
   return toTypeString(value).slice(8, -1);
 }
+
+/** 判断对象是否有某个属性 */
 function hasOwnProperty(data, key) {
   return data && Object.prototype.hasOwnProperty.call(data, key);
 }
+
+/** 是否是整型key */
 function isIntegerKey(key) {
   return typeof key === 'string' && key !== 'NaN' && key[0] !== '-' && '' + parseInt(key, 10) === key;
 }

package/dist/OnchainUtility.js

@@ -19,6 +19,7 @@ var react = require('react');
  */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
+/** 是否是Moment对象（_表示为内部函数谨慎使用） */
 function _isMoment(obj) {
   return obj != null && typeof obj === 'object' &&
   // 检查内部标志
@@ -28,6 +29,13 @@ function _isMoment(obj) {
   // 检查内部属性
   '_d' in obj && '_i' in obj;
 }
+
+/**
+ * 创建一个可解构的对象，该对象同时具有原始对象的属性和数组的迭代器，使其可以使用对象和数组两种解构方式
+ * @param obj - 需要转换的对象
+ * @param arr - 用于提供迭代器的数组
+ * @returns 一个结合了对象属性和数组迭代器的新对象
+ */
 function makeDestructurable(obj, arr) {
   if (typeof Symbol !== 'undefined') {
     const clone = {
@@ -50,6 +58,8 @@ function makeDestructurable(obj, arr) {
     return Object.assign([...arr], obj);
   }
 }
+
+/** 创建对象枚举，可以避免两个相同枚举缺不相等 */
 function createEnumObject(o) {
   return o;
 }
@@ -60,15 +70,68 @@ function toRawType(value) {
   // 从字符串中提取“RawType”，如“[object RawType]”
   return toTypeString(value).slice(8, -1);
 }
+function isString(value) {
+  return toRawType(value) === 'String';
+}
+function isNumber(value) {
+  return toRawType(value) === 'Number';
+}
+
+/** 判断值是否为NaN */
+function isNaN(value) {
+  return Number.isNaN(value);
+}
+function isBoolean(value) {
+  return toRawType(value) === 'Boolean';
+}
+function isUndefined(value) {
+  return toRawType(value) === 'Undefined';
+}
+function isNull(value) {
+  return toRawType(value) === 'Null';
+}
+function isNil(value) {
+  return isNull(value) || isUndefined(value);
+}
+
+/**
+ * 判断是否是 `null` 或 `undefined`
+ * @example
+ * _.isNil(null);
+ * // => true
+ *
+ * _.isNil(void 0);
+ * // => true
+ *
+ * _.isNil(NaN);
+ * // => false
+ */
+function isObject(value) {
+  return toRawType(value) === 'Object';
+}
+function isArray(value) {
+  return toRawType(value) === 'Array';
+}
+function isFunction(value) {
+  return toRawType(value) === 'Function';
+}
+
+/** 判断对象是否有某个属性 */
 function hasOwnProperty(data, key) {
   return data && Object.prototype.hasOwnProperty.call(data, key);
 }
+
+/** 是否是整型key */
 function isIntegerKey(key) {
   return typeof key === 'string' && key !== 'NaN' && key[0] !== '-' && '' + parseInt(key, 10) === key;
 }
+
+/** 是否是空对象 */
 function isEmptyObject(obj) {
   return obj ? !Object.keys(obj).length : true;
 }
+
+/** 生成 innerHTML  */
 function getHTMLTagString(params) {
   const attrsString = Object.entries(params.attributes || {}).map(([key, value]) => {
     return ` ${key}="${value}"`;
@@ -1082,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,
@@ -1235,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
@@ -1353,9 +1501,10 @@ function generatedAcrossHierarchySort({
 function optimizeStructure({
   data,
   childrenKey = 'children',
-  signKey = 'id'
+  signKey = 'id',
+  isSupportMultipleRoot = false
 }) {
-  if (data.length > 1) {
+  if (data.length > 1 || isSupportMultipleRoot) {
     return [{
       [childrenKey]: data,
       isCustom: true,
@@ -1460,6 +1609,7 @@ async function upgrade({
   data,
   signKey = 'id',
   isFollow,
+  isSupportMultipleRoot = false,
   onStopFollow,
   onFilterFollow,
   onUpgrade,
@@ -1471,6 +1621,7 @@ async function upgrade({
   data = optimizeStructure({
     childrenKey,
     data,
+    isSupportMultipleRoot,
     signKey
   });
   const layers = mergeAdjacent({
@@ -1556,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,
@@ -1618,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
+          }));
         }
       }
     }
@@ -1671,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;
@@ -1689,13 +1862,26 @@ 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;
 exports.insert = insert;
+exports.isArray = isArray;
+exports.isBoolean = isBoolean;
 exports.isEmptyObject = isEmptyObject;
+exports.isFunction = isFunction;
 exports.isIntegerKey = isIntegerKey;
+exports.isNaN = isNaN;
+exports.isNil = isNil;
+exports.isNull = isNull;
+exports.isNumber = isNumber;
+exports.isObject = isObject;
+exports.isString = isString;
+exports.isUndefined = isUndefined;
 exports.levelTransformTree = levelTransformTree;
 exports.makeDestructurable = makeDestructurable;
 exports.mergeAdjacent = mergeAdjacent;

package/dist/OnchainUtility.mjs

@@ -17,6 +17,7 @@ import { useRef, useState, useCallback, useLayoutEffect } from 'react';
  */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
+/** 是否是Moment对象（_表示为内部函数谨慎使用） */
 function _isMoment(obj) {
   return obj != null && typeof obj === 'object' &&
   // 检查内部标志
@@ -26,6 +27,13 @@ function _isMoment(obj) {
   // 检查内部属性
   '_d' in obj && '_i' in obj;
 }
+
+/**
+ * 创建一个可解构的对象，该对象同时具有原始对象的属性和数组的迭代器，使其可以使用对象和数组两种解构方式
+ * @param obj - 需要转换的对象
+ * @param arr - 用于提供迭代器的数组
+ * @returns 一个结合了对象属性和数组迭代器的新对象
+ */
 function makeDestructurable(obj, arr) {
   if (typeof Symbol !== 'undefined') {
     const clone = {
@@ -48,6 +56,8 @@ function makeDestructurable(obj, arr) {
     return Object.assign([...arr], obj);
   }
 }
+
+/** 创建对象枚举，可以避免两个相同枚举缺不相等 */
 function createEnumObject(o) {
   return o;
 }
@@ -58,15 +68,68 @@ function toRawType(value) {
   // 从字符串中提取“RawType”，如“[object RawType]”
   return toTypeString(value).slice(8, -1);
 }
+function isString(value) {
+  return toRawType(value) === 'String';
+}
+function isNumber(value) {
+  return toRawType(value) === 'Number';
+}
+
+/** 判断值是否为NaN */
+function isNaN(value) {
+  return Number.isNaN(value);
+}
+function isBoolean(value) {
+  return toRawType(value) === 'Boolean';
+}
+function isUndefined(value) {
+  return toRawType(value) === 'Undefined';
+}
+function isNull(value) {
+  return toRawType(value) === 'Null';
+}
+function isNil(value) {
+  return isNull(value) || isUndefined(value);
+}
+
+/**
+ * 判断是否是 `null` 或 `undefined`
+ * @example
+ * _.isNil(null);
+ * // => true
+ *
+ * _.isNil(void 0);
+ * // => true
+ *
+ * _.isNil(NaN);
+ * // => false
+ */
+function isObject(value) {
+  return toRawType(value) === 'Object';
+}
+function isArray(value) {
+  return toRawType(value) === 'Array';
+}
+function isFunction(value) {
+  return toRawType(value) === 'Function';
+}
+
+/** 判断对象是否有某个属性 */
 function hasOwnProperty(data, key) {
   return data && Object.prototype.hasOwnProperty.call(data, key);
 }
+
+/** 是否是整型key */
 function isIntegerKey(key) {
   return typeof key === 'string' && key !== 'NaN' && key[0] !== '-' && '' + parseInt(key, 10) === key;
 }
+
+/** 是否是空对象 */
 function isEmptyObject(obj) {
   return obj ? !Object.keys(obj).length : true;
 }
+
+/** 生成 innerHTML  */
 function getHTMLTagString(params) {
   const attrsString = Object.entries(params.attributes || {}).map(([key, value]) => {
     return ` ${key}="${value}"`;
@@ -1080,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,
@@ -1233,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
@@ -1351,9 +1499,10 @@ function generatedAcrossHierarchySort({
 function optimizeStructure({
   data,
   childrenKey = 'children',
-  signKey = 'id'
+  signKey = 'id',
+  isSupportMultipleRoot = false
 }) {
-  if (data.length > 1) {
+  if (data.length > 1 || isSupportMultipleRoot) {
     return [{
       [childrenKey]: data,
       isCustom: true,
@@ -1458,6 +1607,7 @@ async function upgrade({
   data,
   signKey = 'id',
   isFollow,
+  isSupportMultipleRoot = false,
   onStopFollow,
   onFilterFollow,
   onUpgrade,
@@ -1469,6 +1619,7 @@ async function upgrade({
   data = optimizeStructure({
     childrenKey,
     data,
+    isSupportMultipleRoot,
     signKey
   });
   const layers = mergeAdjacent({
@@ -1554,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,
@@ -1616,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
+          }));
         }
       }
     }
@@ -1669,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, isEmptyObject, isIntegerKey, 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
@@ -332,9 +417,10 @@ function generatedAcrossHierarchySort({
 function optimizeStructure({
   data,
   childrenKey = 'children',
-  signKey = 'id'
+  signKey = 'id',
+  isSupportMultipleRoot = false
 }) {
-  if (data.length > 1) {
+  if (data.length > 1 || isSupportMultipleRoot) {
     return [{
       [childrenKey]: data,
       isCustom: true,
@@ -439,6 +525,7 @@ async function upgrade({
   data,
   signKey = 'id',
   isFollow,
+  isSupportMultipleRoot = false,
   onStopFollow,
   onFilterFollow,
   onUpgrade,
@@ -450,6 +537,7 @@ async function upgrade({
   data = optimizeStructure({
     childrenKey,
     data,
+    isSupportMultipleRoot,
     signKey
   });
   const layers = mergeAdjacent({
@@ -535,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,
@@ -597,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
+          }));
         }
       }
     }
@@ -650,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
@@ -330,9 +415,10 @@ function generatedAcrossHierarchySort({
 function optimizeStructure({
   data,
   childrenKey = 'children',
-  signKey = 'id'
+  signKey = 'id',
+  isSupportMultipleRoot = false
 }) {
-  if (data.length > 1) {
+  if (data.length > 1 || isSupportMultipleRoot) {
     return [{
       [childrenKey]: data,
       isCustom: true,
@@ -437,6 +523,7 @@ async function upgrade({
   data,
   signKey = 'id',
   isFollow,
+  isSupportMultipleRoot = false,
   onStopFollow,
   onFilterFollow,
   onUpgrade,
@@ -448,6 +535,7 @@ async function upgrade({
   data = optimizeStructure({
     childrenKey,
     data,
+    isSupportMultipleRoot,
     signKey
   });
   const layers = mergeAdjacent({
@@ -533,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,
@@ -595,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
+          }));
         }
       }
     }
@@ -648,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.15",
+  "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
@@ -399,8 +491,9 @@ function optimizeStructure<T>({
   data,
   childrenKey = 'children',
   signKey = 'id',
-}: Params<T>): T[] {
-  if (data.length > 1) {
+  isSupportMultipleRoot = false,
+}: Params<T> & {isSupportMultipleRoot?: boolean}): T[] {
+  if (data.length > 1 || isSupportMultipleRoot) {
     return [
       {
         [childrenKey]: data,
@@ -437,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',
@@ -508,10 +611,17 @@ 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',
   isFollow,
+  isSupportMultipleRoot = false,
   onStopFollow,
   onFilterFollow,
   onUpgrade,
@@ -521,16 +631,16 @@ export async function upgrade<T extends Item>({
   onError,
 }: MoveParams<T> & {
   isFollow?: boolean;
+  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, signKey});
+  data = optimizeStructure({childrenKey, data, isSupportMultipleRoot, signKey});
   const layers = mergeAdjacent({childrenKey, data, selectKeys, signKey});
   const {crossLayerSort, getInsertIdx} = generatedAcrossHierarchySort({
     signKey,
@@ -603,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,
@@ -616,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',
@@ -625,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});
@@ -659,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,
+            }),
+          );
         }
       }
     }
@@ -719,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,
+  };
+}

package/src/base.ts

@@ -7,6 +7,7 @@
  */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
+/** 是否是Moment对象（_表示为内部函数谨慎使用） */
 export function _isMoment(obj: any) {
   return (
     obj != null &&
@@ -22,6 +23,12 @@ export function _isMoment(obj: any) {
   );
 }
 
+/**
+ * 创建一个可解构的对象，该对象同时具有原始对象的属性和数组的迭代器，使其可以使用对象和数组两种解构方式
+ * @param obj - 需要转换的对象
+ * @param arr - 用于提供迭代器的数组
+ * @returns 一个结合了对象属性和数组迭代器的新对象
+ */
 export function makeDestructurable<
   T extends Record<string, unknown>,
   A extends readonly [any, ...any],
@@ -47,6 +54,7 @@ export function makeDestructurable<
   }
 }
 
+/** 创建对象枚举，可以避免两个相同枚举缺不相等 */
 export function createEnumObject<T extends string>(o: {[P in T]: P}) {
   return o;
 }
@@ -54,14 +62,71 @@ export function createEnumObject<T extends string>(o: {[P in T]: P}) {
 export function toTypeString<T>(value: T): string {
   return Object.prototype.toString.call(value);
 }
+
 export function toRawType<T>(value: T): string {
   // 从字符串中提取“RawType”，如“[object RawType]”
   return toTypeString(value).slice(8, -1);
 }
+
+export function isString(value: any): value is string {
+  return toRawType(value) === 'String';
+}
+
+export function isNumber(value: any): value is number {
+  return toRawType(value) === 'Number';
+}
+
+/** 判断值是否为NaN */
+export function isNaN(value?: any): value is number {
+  return Number.isNaN(value);
+}
+
+export function isBoolean(value?: any): value is boolean {
+  return toRawType(value) === 'Boolean';
+}
+
+export function isUndefined(value?: any): value is undefined {
+  return toRawType(value) === 'Undefined';
+}
+
+export function isNull(value?: any): value is null {
+  return toRawType(value) === 'Null';
+}
+
+export function isNil(value?: any): value is null | undefined {
+  return isNull(value) || isUndefined(value);
+}
+
+/**
+ * 判断是否是 `null` 或 `undefined`
+ * @example
+ * _.isNil(null);
+ * // => true
+ *
+ * _.isNil(void 0);
+ * // => true
+ *
+ * _.isNil(NaN);
+ * // => false
+ */
+export function isObject(value?: any): value is object {
+  return toRawType(value) === 'Object';
+}
+
+export function isArray(value?: unknown): value is unknown[] {
+  return toRawType(value) === 'Array';
+}
+
+export function isFunction(value?: any): value is (...args: any[]) => any {
+  return toRawType(value) === 'Function';
+}
+
+/** 判断对象是否有某个属性 */
 export function hasOwnProperty<T>(data: T, key: string | symbol | number) {
   return data && Object.prototype.hasOwnProperty.call(data, key);
 }
 
+/** 是否是整型key */
 export function isIntegerKey(key: unknown) {
   return (
     typeof key === 'string' &&
@@ -70,10 +135,13 @@ export function isIntegerKey(key: unknown) {
     '' + parseInt(key, 10) === key
   );
 }
+
+/** 是否是空对象 */
 export function isEmptyObject(obj: object | undefined | null) {
   return obj ? !Object.keys(obj).length : true;
 }
 
+/** 生成 innerHTML  */
 export function getHTMLTagString(params: {
   type: string;
   attributes?: Record<string, any>;