update

zhangfisher · zhangfisher · commit aaa84ce00b0e · 2025-06-08T22:15:20.000+08:00
diff --git a/packages/core/__tests__/flextree.test.ts b/packages/core/__tests__/flextree.test.ts
@@ -97,5 +97,11 @@ describe("FlexTree类型系统测试", () => {
             ]
             return true
         })!
+        const node = tree.get('123')!
+
+        type keyFieldCases = [
+            Expect<Equal<typeof node.id, string>>,
+            Expect<Equal<typeof node.treeId, string>>
+        ]
     })
 })
diff --git a/packages/core/src/errors.ts b/packages/core/src/errors.ts
@@ -1,14 +1,15 @@
-export class FlexTreeError extends Error {}
-export class FlexTreeNotExists extends FlexTreeError {}
-export class FlexTreeVerifyError extends Error {}
-export class FlexTreeInvalidError extends FlexTreeError {}
+export class FlexTreeError extends Error { }
+export class FlexTreeNotExists extends FlexTreeError { }
+export class FlexTreeVerifyError extends Error { }
+export class FlexTreeInvalidError extends FlexTreeError { }
+export class FlexTreeAbortError extends FlexTreeError { }
 
-export class FlexTreeNotFoundError extends FlexTreeError {}
-export class FlexTreeDriverError extends FlexTreeError {}
+export class FlexTreeNotFoundError extends FlexTreeError { }
+export class FlexTreeDriverError extends FlexTreeError { }
 // 当树操作没有在update方法内更新时抛出
-export class FlexTreeInvalidUpdateError extends FlexTreeError {}
+export class FlexTreeInvalidUpdateError extends FlexTreeError { }
 
 // 节点
-export class FlexTreeNodeError extends FlexTreeError {}
-export class FlexTreeNodeNotFoundError extends FlexTreeNodeError {}
-export class FlexTreeNodeInvalidOperationError extends FlexTreeNodeError {}
+export class FlexTreeNodeError extends FlexTreeError { }
+export class FlexTreeNodeNotFoundError extends FlexTreeNodeError { }
+export class FlexTreeNodeInvalidOperationError extends FlexTreeNodeError { }
diff --git a/packages/core/src/manager.ts b/packages/core/src/manager.ts
@@ -10,7 +10,7 @@ import { mix } from 'ts-mixer'
 import mitt from 'mitt'
 import type { IFlexTreeAdapter } from './adapter'
 import { FlexTreeDriverError, FlexTreeError, FlexTreeInvalidUpdateError } from './errors'
-import type { CustomTreeKeyFields, DefaultTreeKeyFields, FlexTreeEvents, IFlexTreeNode, NonUndefined } from './types'
+import type { CustomTreeKeyFields, DefaultTreeKeyFields, FlexTreeEvents, IFlexTreeNodeFields, NonUndefined } from './types'
 import { MoveNodeMixin } from './mixins/move.mixin'
 import { DeleteNodeMixin } from './mixins/delete.mixin'
 import { AddNodeMixin } from './mixins/add.mixin'
@@ -39,7 +39,7 @@ export interface FlexTreeManagerOptions<TreeIdType = number> {
 export interface FlexTreeManager<
     Fields extends Record<string, any> = object,
     KeyFields extends CustomTreeKeyFields = DefaultTreeKeyFields,
-    TreeNode extends IFlexTreeNode<Fields, KeyFields> = IFlexTreeNode<Fields, KeyFields>,
+    TreeNode extends IFlexTreeNodeFields<Fields, KeyFields> = IFlexTreeNodeFields<Fields, KeyFields>,
     NodeId = NonUndefined<KeyFields['id']>[1],
     TreeId = NonUndefined<KeyFields['treeId']>[1],
 > extends MoveNodeMixin<Fields, KeyFields, TreeNode, NodeId, TreeId>,
@@ -83,7 +83,7 @@ export class FlexTreeManager<
     Fields extends Record<string, any> = object,
     KeyFields extends CustomTreeKeyFields = DefaultTreeKeyFields,
     // eslint-disable-next-line unused-imports/no-unused-vars
-    TreeNode extends IFlexTreeNode<Fields, KeyFields> = IFlexTreeNode<Fields, KeyFields>,
+    TreeNode extends IFlexTreeNodeFields<Fields, KeyFields> = IFlexTreeNodeFields<Fields, KeyFields>,
     // eslint-disable-next-line unused-imports/no-unused-vars
     NodeId = NonUndefined<KeyFields['id']>[1],
     TreeId = NonUndefined<KeyFields['treeId']>[1],
diff --git a/packages/core/src/mixins/add.mixin.ts b/packages/core/src/mixins/add.mixin.ts
@@ -1,13 +1,13 @@
 import type { FlexTreeManager } from '../manager'
-import type { CustomTreeKeyFields, DefaultTreeKeyFields, IFlexTreeNode, NonUndefined } from '../types'
+import type { CustomTreeKeyFields, DefaultTreeKeyFields, IFlexTreeNodeFields, NonUndefined } from '../types'
 import { FlexNodeRelPosition } from '../types'
 import { FlexTreeError } from '../errors'
 import { escapeSqlString } from '../utils/escapeSqlString'
 
 export class AddNodeMixin<
     Fields extends Record<string, any> = object,
     KeyFields extends CustomTreeKeyFields = DefaultTreeKeyFields,
-    TreeNode extends IFlexTreeNode<Fields, KeyFields> = IFlexTreeNode<Fields, KeyFields>,
+    TreeNode extends IFlexTreeNodeFields<Fields, KeyFields> = IFlexTreeNodeFields<Fields, KeyFields>,
     NodeId = NonUndefined<KeyFields['id']>[1],
     TreeId = NonUndefined<KeyFields['treeId']>[1],
 > {
diff --git a/packages/core/src/mixins/delete.mixin.ts b/packages/core/src/mixins/delete.mixin.ts
@@ -1,10 +1,10 @@
 import type { FlexTreeManager } from '../manager'
-import type { CustomTreeKeyFields, DefaultTreeKeyFields, IFlexTreeNode, NonUndefined } from '../types'
+import type { CustomTreeKeyFields, DefaultTreeKeyFields, IFlexTreeNodeFields, NonUndefined } from '../types'
 
 export class DeleteNodeMixin<
     Fields extends Record<string, any> = object,
     KeyFields extends CustomTreeKeyFields = DefaultTreeKeyFields,
-    TreeNode extends IFlexTreeNode<Fields, KeyFields> = IFlexTreeNode<Fields, KeyFields>,
+    TreeNode extends IFlexTreeNodeFields<Fields, KeyFields> = IFlexTreeNodeFields<Fields, KeyFields>,
     NodeId = NonUndefined<KeyFields['id']>[1],
     TreeId = NonUndefined<KeyFields['treeId']>[1],
 > {
diff --git a/packages/core/src/mixins/find.mixin.ts b/packages/core/src/mixins/find.mixin.ts
@@ -1,13 +1,13 @@
 import sqlstring from 'sqlstring'
 import type { FlexTreeManager } from '../manager'
-import type { CustomTreeKeyFields, DefaultTreeKeyFields, IFlexTreeNode, NonUndefined } from '../types'
+import type { CustomTreeKeyFields, DefaultTreeKeyFields, IFlexTreeNodeFields, NonUndefined } from '../types'
 import { FlexTreeError, FlexTreeNodeNotFoundError } from '../errors'
 import { escapeSqlString } from '../utils/escapeSqlString'
 
 export class FindNodeMixin<
     Fields extends Record<string, any> = object,
     KeyFields extends CustomTreeKeyFields = DefaultTreeKeyFields,
-    TreeNode extends IFlexTreeNode<Fields, KeyFields> = IFlexTreeNode<Fields, KeyFields>,
+    TreeNode extends IFlexTreeNodeFields<Fields, KeyFields> = IFlexTreeNodeFields<Fields, KeyFields>,
     NodeId = NonUndefined<KeyFields['id']>[1],
     TreeId = NonUndefined<KeyFields['treeId']>[1],
 > {
diff --git a/packages/core/src/mixins/get.mixin.ts b/packages/core/src/mixins/get.mixin.ts
@@ -1,5 +1,5 @@
 import type { FlexTreeManager } from '../manager'
-import type { CustomTreeKeyFields, DefaultTreeKeyFields, IFlexTreeNode, NonUndefined } from '../types'
+import type { CustomTreeKeyFields, DefaultTreeKeyFields, IFlexTreeNodeFields, NonUndefined } from '../types'
 import { FlexTreeError, FlexTreeNodeNotFoundError, FlexTreeNotExists } from '../errors'
 import { escapeSqlString } from '../utils/escapeSqlString'
 import { isLikeNode } from '../utils/isLikeNode'
@@ -9,7 +9,7 @@ import { isNull } from '../utils/isNull'
 export class GetNodeMixin<
     Fields extends Record<string, any> = object,
     KeyFields extends CustomTreeKeyFields = DefaultTreeKeyFields,
-    TreeNode extends IFlexTreeNode<Fields, KeyFields> = IFlexTreeNode<Fields, KeyFields>,
+    TreeNode extends IFlexTreeNodeFields<Fields, KeyFields> = IFlexTreeNodeFields<Fields, KeyFields>,
     NodeId = NonUndefined<KeyFields['id']>[1],
     TreeId = NonUndefined<KeyFields['treeId']>[1],
 > {
@@ -47,9 +47,9 @@ export class GetNodeMixin<
      * @param {number}  [options.level]            限定返回的层级,0表示不限制,1表示只返回根节点，2表示返回根节点和其子节点, 依次类推
      * @returns TreeNode[]
      */
-    async getNodes(this: FlexTreeManager<Fields, KeyFields, TreeNode, NodeId, TreeId>, options?: { level?: number,fields?:keyof TreeNode }): Promise<TreeNode[]> {
-        const { level,fields } = Object.assign({ level: 0,fields:[] }, options)
-        const fieldList = fields.length>0 ? fields.map(f=>`${f}`).join(',') : '*'
+    async getNodes(this: FlexTreeManager<Fields, KeyFields, TreeNode, NodeId, TreeId>, options?: { level?: number, fields?: keyof TreeNode }): Promise<TreeNode[]> {
+        const { level, fields } = Object.assign({ level: 0, fields: [] }, options)
+        const fieldList = fields.length > 0 ? fields.map(f => `${f}`).join(',') : '*'
         const sql = this._sql(`SELECT ${fieldList} FROM ${this.tableName} 
             WHERE {__TREE_ID__} ${this.keyFields.leftValue}>0 AND ${this.keyFields.rightValue}>0
                 ${level > 0 ? `AND ${this.keyFields.level}<=${level}` : ''}
@@ -106,8 +106,8 @@ export class GetNodeMixin<
      * @param {number}  [options.level]           限制返回的级别
      * @param {boolean} [options.includeSelf]     返回结果是否包括自身
      */
-    async getDescendants(this: FlexTreeManager<Fields, KeyFields, TreeNode, NodeId, TreeId>, nodeId?: NodeId | TreeNode, options?: { level?: number, includeSelf?: boolean }): Promise<IFlexTreeNode<Fields, KeyFields>[]> {
-        if(isNull(nodeId)) {
+    async getDescendants(this: FlexTreeManager<Fields, KeyFields, TreeNode, NodeId, TreeId>, nodeId?: NodeId | TreeNode, options?: { level?: number, includeSelf?: boolean }): Promise<IFlexTreeNodeFields<Fields, KeyFields>[]> {
+        if (isNull(nodeId)) {
             return await this.getNodes(options)
         }
         const { level, includeSelf } = Object.assign({ includeSelf: false, level: 0 }, options)
diff --git a/packages/core/src/mixins/is.mixin.ts b/packages/core/src/mixins/is.mixin.ts
@@ -1,10 +1,10 @@
 import type { FlexTreeManager } from '../manager'
-import type { CustomTreeKeyFields, DefaultTreeKeyFields, IFlexTreeNode, NonUndefined } from '../types'
+import type { CustomTreeKeyFields, DefaultTreeKeyFields, IFlexTreeNodeFields, NonUndefined } from '../types'
 
 export class IsNodeMixin<
     Fields extends Record<string, any> = object,
     KeyFields extends CustomTreeKeyFields = DefaultTreeKeyFields,
-    TreeNode extends IFlexTreeNode<Fields, KeyFields> = IFlexTreeNode<Fields, KeyFields>,
+    TreeNode extends IFlexTreeNodeFields<Fields, KeyFields> = IFlexTreeNodeFields<Fields, KeyFields>,
     NodeId = NonUndefined<KeyFields['id']>[1],
     TreeId = NonUndefined<KeyFields['treeId']>[1],
 > {
diff --git a/packages/core/src/mixins/move.mixin.ts b/packages/core/src/mixins/move.mixin.ts
@@ -1,12 +1,12 @@
 import type { FlexTreeManager } from '../manager'
-import type { CustomTreeKeyFields, DefaultTreeKeyFields, IFlexTreeNode, NonUndefined } from '../types'
+import type { CustomTreeKeyFields, DefaultTreeKeyFields, IFlexTreeNodeFields, NonUndefined } from '../types'
 import { FlexNodeRelPosition, FlexTreeNodeRelation } from '../types'
 import { FlexTreeError, FlexTreeNodeInvalidOperationError } from '../errors'
 
 export class MoveNodeMixin<
     Fields extends Record<string, any> = object,
     KeyFields extends CustomTreeKeyFields = DefaultTreeKeyFields,
-    TreeNode extends IFlexTreeNode<Fields, KeyFields> = IFlexTreeNode<Fields, KeyFields>,
+    TreeNode extends IFlexTreeNodeFields<Fields, KeyFields> = IFlexTreeNodeFields<Fields, KeyFields>,
     NodeId = NonUndefined<KeyFields['id']>[1],
     TreeId = NonUndefined<KeyFields['treeId']>[1],
 > {
@@ -55,7 +55,7 @@ export class MoveNodeMixin<
 
         const leftValue = fromNode[this.keyFields.leftValue]
 
-        const sqls: string[] =  [
+        const sqls: string[] = [
             this._sql(`
                 UPDATE ${this.tableName} 
                 SET 
@@ -91,7 +91,7 @@ export class MoveNodeMixin<
                 WHERE 
                     {__TREE_ID__} ${this.keyFields.rightValue} < 0
             `),
-        ] 
+        ]
 
         return sqls
     }
@@ -138,7 +138,7 @@ export class MoveNodeMixin<
                 WHERE 
                     {__TREE_ID__} ${this.keyFields.rightValue} < 0
             `),
-        ] 
+        ]
         return sqls
     }
 
@@ -273,10 +273,12 @@ export class MoveNodeMixin<
 
         const sqls: string[] = []
         // 1. 将源节点及其子节点标记为已删除, 没有真正删除，只是标记为已删除, 执行后要移动的节点就从树中脱离，但是数据还在，仅是左右值变成负数
-        await this.deleteNode(srcNode.id, { onlyMark: true, onExecuteBefore: (delSqls) => {
-            sqls.push(...delSqls)
-            return false
-        } })
+        await this.deleteNode(srcNode.id, {
+            onlyMark: true, onExecuteBefore: (delSqls) => {
+                sqls.push(...delSqls)
+                return false
+            }
+        })
 
         if (pos === FlexNodeRelPosition.LastChild) {
             sqls.push(...this._moveToLastChild(srcNode, targetNode))
diff --git a/packages/core/src/mixins/relation.mixin.ts b/packages/core/src/mixins/relation.mixin.ts
@@ -1,11 +1,11 @@
 import type { FlexTreeManager } from '../manager'
-import type { CustomTreeKeyFields, DefaultTreeKeyFields, IFlexTreeNode, NonUndefined } from '../types'
+import type { CustomTreeKeyFields, DefaultTreeKeyFields, IFlexTreeNodeFields, NonUndefined } from '../types'
 import { FlexTreeNodeRelation } from '../types'
 
 export class RelationMixin<
     Fields extends Record<string, any> = object,
     KeyFields extends CustomTreeKeyFields = DefaultTreeKeyFields,
-    TreeNode extends IFlexTreeNode<Fields, KeyFields> = IFlexTreeNode<Fields, KeyFields>,
+    TreeNode extends IFlexTreeNodeFields<Fields, KeyFields> = IFlexTreeNodeFields<Fields, KeyFields>,
     NodeId = NonUndefined<KeyFields['id']>[1],
     TreeId = NonUndefined<KeyFields['treeId']>[1],
 > {
diff --git a/packages/core/src/mixins/root.mixin.ts b/packages/core/src/mixins/root.mixin.ts
@@ -1,13 +1,13 @@
 import sqlstring from 'sqlstring'
 import type { FlexTreeManager } from '../manager'
-import type { CustomTreeKeyFields, DefaultTreeKeyFields, IFlexTreeNode, NonUndefined } from '../types'
+import type { CustomTreeKeyFields, DefaultTreeKeyFields, IFlexTreeNodeFields, NonUndefined } from '../types'
 import { FlexTreeNodeError } from '../errors'
 import { escapeSqlString } from '../utils/escapeSqlString'
 
 export class RootNodeMixin<
     Fields extends Record<string, any> = object,
     KeyFields extends CustomTreeKeyFields = DefaultTreeKeyFields,
-    TreeNode extends IFlexTreeNode<Fields, KeyFields> = IFlexTreeNode<Fields, KeyFields>,
+    TreeNode extends IFlexTreeNodeFields<Fields, KeyFields> = IFlexTreeNodeFields<Fields, KeyFields>,
     NodeId = NonUndefined<KeyFields['id']>[1],
     TreeId = NonUndefined<KeyFields['treeId']>[1],
 > {
diff --git a/packages/core/src/mixins/sql.mixin.ts b/packages/core/src/mixins/sql.mixin.ts
@@ -1,10 +1,10 @@
 import type { FlexTreeManager } from '../manager'
-import type { CustomTreeKeyFields, DefaultTreeKeyFields, IFlexTreeNode, NonUndefined } from '../types'
+import type { CustomTreeKeyFields, DefaultTreeKeyFields, IFlexTreeNodeFields, NonUndefined } from '../types'
 
 export class SqlMixin<
     Fields extends Record<string, any> = object,
     KeyFields extends CustomTreeKeyFields = DefaultTreeKeyFields,
-    TreeNode extends IFlexTreeNode<Fields, KeyFields> = IFlexTreeNode<Fields, KeyFields>,
+    TreeNode extends IFlexTreeNodeFields<Fields, KeyFields> = IFlexTreeNodeFields<Fields, KeyFields>,
     NodeId = NonUndefined<KeyFields['id']>[1],
     TreeId = NonUndefined<KeyFields['treeId']>[1],
 > {
diff --git a/packages/core/src/mixins/update.mixin.ts b/packages/core/src/mixins/update.mixin.ts
@@ -6,13 +6,13 @@
 import sqlstring from 'sqlstring'
 import { FlexTreeInvalidUpdateError, FlexTreeNodeError } from '../errors'
 import type { FlexTreeManager } from '../manager'
-import type { CustomTreeKeyFields, DefaultTreeKeyFields, IFlexTreeNode, NonUndefined } from '../types'
+import type { CustomTreeKeyFields, DefaultTreeKeyFields, IFlexTreeNodeFields, NonUndefined } from '../types'
 import { escapeSqlString } from '../utils/escapeSqlString'
 
 export class UpdateNodeMixin<
     Fields extends Record<string, any> = object,
     KeyFields extends CustomTreeKeyFields = DefaultTreeKeyFields,
-    TreeNode extends IFlexTreeNode<Fields, KeyFields> = IFlexTreeNode<Fields, KeyFields>,
+    TreeNode extends IFlexTreeNodeFields<Fields, KeyFields> = IFlexTreeNodeFields<Fields, KeyFields>,
     NodeId = NonUndefined<KeyFields['id']>[1],
     TreeId = NonUndefined<KeyFields['treeId']>[1],
 > {
diff --git a/packages/core/src/mixins/verify.mixin.ts b/packages/core/src/mixins/verify.mixin.ts
@@ -1,11 +1,11 @@
 import type { FlexTreeManager } from '../manager'
-import type { CustomTreeKeyFields, DefaultTreeKeyFields, IFlexTreeNode, NonUndefined } from '../types'
+import type { CustomTreeKeyFields, DefaultTreeKeyFields, IFlexTreeNodeFields, NonUndefined } from '../types'
 import { FlexTreeVerifyError } from '../errors'
 
 export class VerifyTreeMixin<
     Fields extends Record<string, any> = object,
     KeyFields extends CustomTreeKeyFields = DefaultTreeKeyFields,
-    TreeNode extends IFlexTreeNode<Fields, KeyFields> = IFlexTreeNode<Fields, KeyFields>,
+    TreeNode extends IFlexTreeNodeFields<Fields, KeyFields> = IFlexTreeNodeFields<Fields, KeyFields>,
     NodeId = NonUndefined<KeyFields['id']>[1],
     TreeId = NonUndefined<KeyFields['treeId']>[1],
 > {
@@ -17,29 +17,29 @@ export class VerifyTreeMixin<
     async verify(this: FlexTreeManager<Fields, KeyFields, TreeNode, NodeId, TreeId>, nodes?: TreeNode[]) {
         nodes = nodes || await this.getNodes({
             // @ts-ignore
-            fields:[
+            fields: [
                 this.keyFields.id,
                 this.keyFields.name,
                 this.keyFields.leftValue,
                 this.keyFields.rightValue,
                 this.keyFields.level
             ]
         })
-        const pnodes: IFlexTreeNode[] = []
+        const pnodes: IFlexTreeNodeFields[] = []
         for (let i = 0; i < nodes.length; i++) {
-            const node = nodes[i] as IFlexTreeNode
-            if (node[this.keyFields.rightValue]- node[this.keyFields.leftValue] === 1) { // 无子节点
+            const node = nodes[i] as IFlexTreeNodeFields
+            if (node[this.keyFields.rightValue] - node[this.keyFields.leftValue] === 1) { // 无子节点
                 if (pnodes.length > 0) {
                     const pnode = pnodes[pnodes.length - 1]
-                    if (pnode[this.keyFields.level] !== node[this.keyFields.level]  - 1) {
+                    if (pnode[this.keyFields.level] !== node[this.keyFields.level] - 1) {
                         throw new FlexTreeVerifyError(`level error ${node[this.keyFields.name]}(${node[this.keyFields.id]})`)
                     } else if (!(node[this.keyFields.leftValue] > pnode[this.keyFields.leftValue])) {
                         throw new FlexTreeVerifyError(`leftValue error ${node[this.keyFields.name]}(${node[this.keyFields.id]})`)
-                    } else if (!(node[this.keyFields.rightValue]< pnode[this.keyFields.rightValue])) {
+                    } else if (!(node[this.keyFields.rightValue] < pnode[this.keyFields.rightValue])) {
                         throw new FlexTreeVerifyError(`rightValue error ${node[this.keyFields.name]}(${node[this.keyFields.id]})`)
                     }
                     // 子节点结束
-                    if (node[this.keyFields.rightValue]+ 1 === pnode[this.keyFields.rightValue]) {
+                    if (node[this.keyFields.rightValue] + 1 === pnode[this.keyFields.rightValue]) {
                         let preNode = pnodes.pop()
                         if (pnodes.length > 0) {
                             while (preNode![this.keyFields.rightValue] + 1 === pnodes[pnodes.length - 1]?.[this.keyFields.rightValue]) {
@@ -51,12 +51,12 @@ export class VerifyTreeMixin<
                         }
                     }
                 }
-                if ((node[this.keyFields.rightValue]- node[this.keyFields.leftValue] - 1) % 2 !== 0) {
-                    throw new FlexTreeVerifyError(`${node[this.keyFields.name] }(${node[this.keyFields.id] }) rightValue - leftValue error `)
+                if ((node[this.keyFields.rightValue] - node[this.keyFields.leftValue] - 1) % 2 !== 0) {
+                    throw new FlexTreeVerifyError(`${node[this.keyFields.name]}(${node[this.keyFields.id]}) rightValue - leftValue error `)
                 }
-            } else if (node[this.keyFields.rightValue]- node[this.keyFields.leftValue] >= 3) { // 有子节点
+            } else if (node[this.keyFields.rightValue] - node[this.keyFields.leftValue] >= 3) { // 有子节点
                 //  rightValue-leftValue一定是奇数,否则说明有问题
-                if ((node[this.keyFields.rightValue]- node[this.keyFields.leftValue] - 1) % 2 === 0) {
+                if ((node[this.keyFields.rightValue] - node[this.keyFields.leftValue] - 1) % 2 === 0) {
                     pnodes.push(node) // 先保存父节点
                 } else {
                     throw new FlexTreeVerifyError(`${node.name}(${node[this.keyFields.id]}) rightValue - leftValue error `)
diff --git a/packages/core/src/node.ts b/packages/core/src/node.ts
diff --git a/packages/core/src/tree.ts b/packages/core/src/tree.ts
diff --git a/packages/core/src/types.ts b/packages/core/src/types.ts
diff --git a/packages/tests/treeobject/createTree.ts b/packages/tests/treeobject/createTree.ts
diff --git a/packages/tests/treeobject/findnode.test.ts b/packages/tests/treeobject/findnode.test.ts
diff --git a/packages/tests/treeobject/node.test.ts b/packages/tests/treeobject/node.test.ts
