onchain-utility 0.0.14 → 0.0.16

package/README.md

@@ -1,5 +1,265 @@
-# `@lexical/utils`
+## Base
+### _isMoment
+判断是否是Moment对象，并且不依赖moment包
 
-[![See API Documentation](https://lexical.dev/img/see-api-documentation.svg)](https://lexical.dev/docs/api/modules/lexical_utils)
+```ts
+_isMoment({}) // falsesd
+_isMoment(Moment()) // truea
+```
 
-This package contains misc utilities for Lexical.
+### makeDestructurable
+优化返回值结构  
+```ts
+const params = makeDestructurable({
+  name: 'AIC',
+  age: 16
+}, ['AIC', 16]);
+const { name, age } = params;
+const [name, age] = params;
+```
+
+### createEnumObject
+创建一个对象枚举，主要用于解决真正的枚举导出类型和导出前枚举不相等的问题
+```ts
+createEnumObject({
+  SET: 'SET',
+  ADD: 'ADD',
+  DELETE: 'DELETE',
+  CLEAR: 'CLEAR',
+})
+```
+
+### toRawType
+接收任意数据，生成对应类型的字符串
+```ts
+toRawType(() => {}) // 'Function'
+toRawType(new Map) //'Map'
+toRawType({}) // 'Object'
+toRawType([]) // 'Array'
+toRawType(0) // 'Number'
+```
+
+### hasOwnProperty
+判断对象是否存在某个属性
+```ts
+const data  = { name: 'aic' };
+hasOwnProperty(data, 'name') // true
+hasOwnProperty(data, 24) // false
+```
+
+### isEmptyObject
+是否是空对象
+```ts
+isEmptyObject({}) // true,
+isEmptyObject({name: 'aic'}) // false
+```
+
+### getHTMLTagString
+接收一个对象 
+- `type`: `string`；标签名称，例如：`div`或`a`或`span`...,
+- `attributes`: `Record<string, any>`；html标签属性，例如：`{style:'color:#fff;font-size:12px !important;'}`
+- `context`: `string`；标签内容。
+
+返回html字符串
+```ts
+getHTMLTagString({
+  type:"span", 
+  attributes: {
+    style:'color:#fff;font-size:12px !important;'
+  }, 
+  context: 'text'
+}) // <span style="color:#fff;font-size:12px !important;">text</span>
+```
+
+### generateSecureUUID
+生成UUID
+```ts
+generateSecureUUID() // 'a6ab72c0-31ab-49bb-a591-54f776c0b2d9'
+```
+
+## Base64
+### getBase64Regular
+生成base64匹配正则
+```ts
+const regular = getBase64Regular();
+const png = `data:image/png;base64,iVBORwOKGgoAAA
+ANSUhEUgAAALgA...whHJTEQgHn4pg1J8
+1Av8HEfyAJO5uun8AAAAASUVORK5CYIl=`;
+regular.test(png) // true
+```
+
+### base64ToMimeType
+接收base64字符串，返回
+- `mimeType`: `string`；MIME类型；例如："image/png"
+- `suffix`: `string`；文件格式；例如："png"
+- `type`: `string`；文件类型；例如："image"
+```ts
+const png = `data:image/png;base64,iVBORwOKGgoAAA
+ANSUhEUgAAALgA...whHJTEQgHn4pg1J8
+1Av8HEfyAJO5uun8AAAAASUVORK5CYIl=`;
+base64ToMimeType(png); // { "mimeType":"image/png", "suffix":"png", "type":"image" }
+```
+
+### base64ToFile
+接收对象
+- `text`: `string`；base64字符串
+- `type`: `string | undefined`；文件类型；例如："image"
+- `filename`: `string | undefined`；自定义文件名称
+- `suffix`: `string | undefined`；文件格式；例如："png"
+
+返回`File`对象
+```ts
+const png = `data:image/png;base64,iVBORwOKGgoAAA
+ANSUhEUgAAALgA...whHJTEQgHn4pg1J8
+1Av8HEfyAJO5uun8AAAAASUVORK5CYIl=`;
+base64ToFile({text: png}) // File {name: 'f37e4949-f912-45f8-abde-109aa8e60a28.undefined', lastModified: 1768899504506, lastModifiedDate: Tue Jan 20 2026 16:58:24 GMT+0800 (中国标准时间), webkitRelativePath: '', size: 9470, …};
+```
+
+### toBase64UTF8
+接收任意值返回base64字符串
+```ts
+const element = document.createElement('equation');
+const equation = toBase64UTF8(this.__equation);
+element.setAttribute('data-lexical-equation', equation);
+```
+
+### fromBase64UTF8
+接收base64字符串返回任意值
+```ts
+const element = document.createElement('equation');
+const equation = toBase64UTF8(this.__equation);
+element.setAttribute('data-lexical-equation', equation);
+```
+
+## Hooks
+### reactive 
+react响应式数据更新
+#### useReactive
+无限层次响应式代理, 包含`object`,`array`,`set`,`map`,`WeakMap`,`WeakSet`
+```tsx
+const Dome = () => {
+  const store = useReactive({
+    name: 'aic',
+    age: 12,
+    set: new Set,
+    map: new Map,
+    list: [{hobby: 'play game'}, {hobby: ''}]
+  })
+  return <div onClick={() => {
+    store.age++ // 更新渲染
+    store.list[1].hobby = 'play basketball' // 更新渲染
+  }}>
+    <span>{store.name}</span>
+    {store.list.map(({ hobby }) => <span>{hobby}</span>)}
+  </div>
+}
+```
+
+#### useShallowReactive
+单层对象响应式代理
+```tsx
+const Dome = () => {
+  const store = useShallowReactive({
+    name: 'aic',
+    age: 12,
+    set: new Set,
+    map: new Map,
+    list: [{hobby: 'play game'}, {hobby: ''}]
+  })
+  return <div onClick={() => {
+    store.age++ // 更新渲染
+    store.list[1].hobby = 'play basketball' // 不会触发渲染
+  }}>
+    <span>{store.name}</span>
+    {store.list.map(({ hobby }) => <span>{hobby}</span>)}
+  </div>
+}
+```
+
+#### protection
+在代理的过程中用来保护某些属性不受响应式代理
+```tsx
+const Dome = () => {
+  const store = useReactive({
+    name: 'aic',
+    age: 12,
+    set: new Set,
+    map: new Map,
+    list: [protection({hobby: 'play game'}), {hobby: ''}]
+  })
+  return <div onClick={() => {
+    store.list[0].hobby = '' // 不会触发渲染          
+    store.list[1].hobby = 'play basketball' // 更新渲染
+    store.set = protection(new Set); // 设置值的时候进行保护
+    store.set.add('1') // 不会触发渲染
+  }}>
+    <span>{store.name}</span>
+    {store.list.map(({ hobby }) => <span>{hobby}</span>)}
+  </div>
+}
+```
+
+#### toRaw
+接收一个代理对象，返回这个对象的原始对象，解决某些组件无法使用Proxy后的对象
+```ts
+const Table = ({list, setHobby}: {list: any[], setHobby: (params: any) => void) => {
+  return list.map((item) => <span onClick={(item) => { item.hobby = 'init' }}>{item.hobby}</span>)
+}
+
+const Dome = () => {
+  const store = useReactive({
+    name: 'aic',
+    age: 12,
+    set: new Set,
+    map: new Map,
+    list: [{hobby: 'play game'}, {hobby: ''}]
+  });
+  return <Table list={toRaw(store.list)} setHobby={() => {}} />
+}
+```
+
+
+#### toProxy
+接收一个原始对象，返回这个对象的代理对象，解决转为原始对象后，修改数据无法更新渲染
+```ts
+const Table = ({list, setHobby}: {list: any[], setHobby: (params: any) => void) => {
+  return list.map((item) => <span onClick={() => setHobby(item)}>{item.hobby}</span>)
+}
+
+const Dome = () => {
+  const store = useReactive({
+    name: 'aic',
+    age: 12,
+    set: new Set,
+    map: new Map,
+    list: [{hobby: 'play game'}, {hobby: ''}]
+  });
+  return <Table list={toRaw(store.list)} setHobby={(item) => {
+    const hobby = toProxy(item);
+    hobby = 'init'
+  }} />
+}
+```
+
+### useStore
+简单的 react hook 状态管理器
+
+```ts
+
+const Dome = () => {
+  const { store, setStore, resetStore, latestStore, setSilenceStore } = useStore(() => {
+    return {
+      name: 'aic',
+      age: 12
+    }
+  });
+  useEffect(() => {
+    setStore({
+      age: 24
+    })
+  }, []);
+  // 使用
+  return <div>{store.name}</div>
+}
+
+```

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}"`;
@@ -1353,9 +1416,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 +1524,7 @@ async function upgrade({
   data,
   signKey = 'id',
   isFollow,
+  isSupportMultipleRoot = false,
   onStopFollow,
   onFilterFollow,
   onUpgrade,
@@ -1471,6 +1536,7 @@ async function upgrade({
   data = optimizeStructure({
     childrenKey,
     data,
+    isSupportMultipleRoot,
     signKey
   });
   const layers = mergeAdjacent({
@@ -1694,8 +1760,18 @@ 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}"`;
@@ -1351,9 +1414,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 +1522,7 @@ async function upgrade({
   data,
   signKey = 'id',
   isFollow,
+  isSupportMultipleRoot = false,
   onStopFollow,
   onFilterFollow,
   onUpgrade,
@@ -1469,6 +1534,7 @@ async function upgrade({
   data = optimizeStructure({
     childrenKey,
     data,
+    isSupportMultipleRoot,
     signKey
   });
   const layers = mergeAdjacent({
@@ -1670,4 +1736,4 @@ function treeSearch({
   }).filter(row => !!row);
 }
 
-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, 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 };

package/dist/Tree.js

@@ -332,9 +332,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 +440,7 @@ async function upgrade({
   data,
   signKey = 'id',
   isFollow,
+  isSupportMultipleRoot = false,
   onStopFollow,
   onFilterFollow,
   onUpgrade,
@@ -450,6 +452,7 @@ async function upgrade({
   data = optimizeStructure({
     childrenKey,
     data,
+    isSupportMultipleRoot,
     signKey
   });
   const layers = mergeAdjacent({

package/dist/Tree.mjs

@@ -330,9 +330,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 +438,7 @@ async function upgrade({
   data,
   signKey = 'id',
   isFollow,
+  isSupportMultipleRoot = false,
   onStopFollow,
   onFilterFollow,
   onUpgrade,
@@ -448,6 +450,7 @@ async function upgrade({
   data = optimizeStructure({
     childrenKey,
     data,
+    isSupportMultipleRoot,
     signKey
   });
   const layers = mergeAdjacent({

package/package.json

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

package/src/Tree/index.ts

@@ -399,8 +399,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,
@@ -512,6 +513,7 @@ export async function upgrade<T extends Item>({
   data,
   signKey = 'id',
   isFollow,
+  isSupportMultipleRoot = false,
   onStopFollow,
   onFilterFollow,
   onUpgrade,
@@ -521,6 +523,7 @@ export async function upgrade<T extends Item>({
   onError,
 }: MoveParams<T> & {
   isFollow?: boolean;
+  isSupportMultipleRoot?: boolean;
   onStopFollow?: (item: T) => boolean;
   onFilterFollow?: (item: T[]) => T[];
   onUpgrade?: (params: {
@@ -530,7 +533,7 @@ export async function upgrade<T extends Item>({
   }) => Promise<boolean> | boolean;
   onUpgraded?: (upgrades: T[]) => void;
 }) {
-  data = optimizeStructure({childrenKey, data, signKey});
+  data = optimizeStructure({childrenKey, data, isSupportMultipleRoot, signKey});
   const layers = mergeAdjacent({childrenKey, data, selectKeys, signKey});
   const {crossLayerSort, getInsertIdx} = generatedAcrossHierarchySort({
     signKey,

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>;