fast-tree-builder 0.1.4 → 1.0.0-alpha.0

package/README.md

@@ -11,7 +11,7 @@
 
 - You have a list of items,
 - where each item is identifiable by a unique value,
-- and the items are connected via a parent relation.
+- and the items are connected via a *parent* OR a *childred* relation.
 
 ## Features
 
@@ -21,13 +21,13 @@
 
 - **Robust TypeScript Type Definitions**: Leverage type safety through extensive TypeScript type definitions. The package includes precise type annotations to improve code reliability and developer workflow.
 
-- **Fully Customizable Node Structure**: Tailor the structure of the nodes in the built tree to meet your specific requirements. You have the freedom to define data, parent, and children key names according to your application's needs. To avoid circular references parent links can be turned off which helps generating JSON data.
+- **Fully Customizable Node Structure**: Tailor the structure of the nodes in the built tree to meet your specific requirements. You have the freedom to define data, parent, and children key names according to your application's needs. To avoid circular references, parent links can be turned off which helps generating JSON data.
 
 - **Works on Any Iterable Data**: Designed to handle arrays, sets, and other iterable data structures efficiently, ensuring broad applicability.
 
 - **No Sorting Required**: The algorithm does not require your input data to be sorted, saving you preprocessing time and effort.
 
-- **Flexible Key and Parent Key Types**: You can use any JavaScript value for identifying items. Relations checked with strict (`key === parentKey`) comparison.
+- **Flexible Key and Parent Key Types**: You can use any JavaScript value for identifying items. Relations checked with strict (`childKey === parentKey`) comparison.
 
 - **Multiple Root Nodes**: Can efficiently construct trees with multiple root nodes, accommodating scenarios that necessitate distinct, separate tree structures within the same dataset.
 
@@ -60,6 +60,8 @@ Here are some examples showcasing the usage of `fast-tree-builder` and their exp
 
 ```typescript
 import buildTree from 'fast-tree-builder';
+// OR
+const { default: buildTree } = require('fast-tree-builder');
 
 const items = [
   { id: 1, parent: null, name: 'Root 1' },
@@ -70,8 +72,10 @@ const items = [
 ];
 
 const { roots, nodes } = buildTree(items, {
+  // the input items:
   key: 'id',
   parentKey: 'parent',
+  // the built node:
   nodeDataKey: 'data',
   nodeParentKey: 'parent',
   nodeChildrenKey: 'children',
@@ -113,7 +117,27 @@ console.log(nodes);
 ```
 
 
-### Example 2: Customized Node Structure
+### Example 2: Build tree by children
+
+```typescript
+import buildTree from 'fast-tree-builder';
+
+const items = [
+  { id: 1, children: [3, 4], name: 'Root 1' },
+  { id: 2, children: [5], name: 'Root 2' },
+  { id: 3, name: 'Child 1.1' },
+  { id: 4, name: 'Child 1.2' },
+  { id: 5, name: 'Child 2.1' },
+];
+
+const { roots, nodes } = buildTree(items, {
+  mode: 'children'
+});
+```
+
+> Produces the same output as **Example 1**.
+
+### Example 3: Customized Node Structure
 
 ```typescript
 import buildTree from 'fast-tree-builder';
@@ -171,7 +195,7 @@ console.log(nodes);
 ```
 
 
-### Example 3: Crazy ideas
+### Example 4: Crazy ideas
 
 ```typescript
 import buildTree from 'fast-tree-builder';
@@ -219,13 +243,14 @@ Parameters
 
 - `items`: An iterable data structure containing the items to build the tree from.
 - `options`: An object specifying the build options. It has the following properties:
+  - `mode`: (Optional) Defines the item connection method. `children` means an item defines its children in a list, and connects that way; `parent` means an item defines its parent, and connects to it that way. Defaults to `parent`.
 	- `key`: (Optional) The key used to identify items. It can be a string, number, symbol, or a function that extracts the key from an item. Defaults to `'id'`.
-	- `parentKey`: (Optional) The key used to identify the parent of each item. It can be a string, number, symbol, or a function that extracts the parent key from an item. Defaults to `'parent'`.
-	- `nodeDataKey`: (Optional) The key used to store the item's data in each node. It can be a string, number, symbol, or false if the data should be merged directly into the node. Defaults to `'data'`.
-	- `nodeParentKey`: (Optional) The key used to store the parent node in each node. It can be a string, number, symbol, or false if the parent node should not be included. Defaults to `'parent'`.
-	- `nodeChildrenKey`: (Optional) The key used to store the children nodes in each node. It can be a string, number, symbol. Defaults to `'children'`.
+	- `parentKey`: (Optional) The key used to identify the parent of each item. It can be a `string`, `number`, `symbol`, or a `function` that extracts the parent key from an item. Defaults to `'parent'`.
+	- `nodeDataKey`: (Optional) The key used to store the item's data in each node. It can be a `string`, `number`, `symbol`, or `false` if the data should be merged directly into the node. Defaults to `'data'`.
+	- `nodeParentKey`: (Optional) The key used to store the parent node in each node. It can be a `string`, `number`, `symbol`, or `false` if the parent node should not be included. Defaults to `'parent'`.
+	- `nodeChildrenKey`: (Optional) The key used to store the children nodes in each node. It can be a `string`, `number`, `symbol`. Defaults to `'children'`.
 	- `mapNodeData`: (Optional) A function that maps an item to its corresponding node data. It allows transforming the item before assigning it to the node. Defaults to `undefined`.
-	- `validateParentKeys`: (Optional) An iterable containing parent key values that can be accepted as root nodes. If provided, any item with a parent key not present in this iterable will cause an error to be thrown. Defaults to `undefined`.
+	- `validRootKeys`: (Optional) An iterable containing key values that can be accepted as root nodes. If provided, any item with a key not present in this iterable will cause an error to be thrown. Defaults to `undefined`.
   - `validateTree`: (Optional) A boolean flag that determines whether to validate the resulting data structure. If the structure is a cyclic graph, an `Error` will be thrown. Requires additional `O(n)` time to compute. Defaults to `false`.
 
 Returns
@@ -238,7 +263,7 @@ An object with the following properties:
 Throws `Error` when:
 
 - A duplicate identifier is recieved,
-- or `validateParentKeys` is set and an invalid parent key is recieved,
+- or `validRootKeys` is set and an invalid parent key is recieved,
 - or `validateTree` is set to `true` and a cyclic graph is the result.
 
 ## Comparison with other tree building libraries

package/index.cjs

@@ -1,76 +1,152 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 function buildTree(items, options = {}) {
-    const { key = 'id', parentKey = 'parent', nodeDataKey = 'data', nodeParentKey = 'parent', nodeChildrenKey = 'children', mapNodeData, validateParentKeys, validateTree = false, } = options;
+    const { mode = 'parent', key = 'id', parentKey = 'parent', childrenKey = 'children', nodeDataKey = 'data', nodeParentKey = 'parent', nodeChildrenKey = 'children', mapNodeData, validRootKeys, validateTree = false, } = options;
+    const roots = [];
     const nodes = new Map();
     const danglingNodes = new Map();
-    for (const item of items) {
-        const keyOfNode = typeof key === 'function' ? key(item) : item[key];
-        if (nodes.has(keyOfNode)) {
-            throw new Error(`Duplicate identifier detected for "${keyOfNode}"`);
-        }
-        // Current node can be new or already created by a child item as its parent
-        let node = danglingNodes.get(keyOfNode);
-        if (node) {
-            danglingNodes.delete(keyOfNode);
-        }
-        else {
-            node = {};
+    if (mode === 'parent') {
+        for (const item of items) {
+            const keyOfNode = typeof key === 'function' ? key(item) : item[key];
+            const keyOfParentNode = typeof parentKey === 'function' ? parentKey(item) : item[parentKey];
+            if (nodes.has(keyOfNode)) {
+                throw new Error(`Duplicate identifier detected for "${keyOfNode}"`);
+            }
+            // Current node can be new or already created by a child item as its parent
+            let node = danglingNodes.get(keyOfNode);
+            if (node) {
+                danglingNodes.delete(keyOfNode);
+            }
+            else {
+                node = {};
+            }
+            nodes.set(keyOfNode, node);
+            // Set the data of the node
+            const nodeData = typeof mapNodeData === 'function' ? mapNodeData(item) : item;
+            if (nodeDataKey !== false) {
+                node[nodeDataKey] = nodeData;
+            }
+            else {
+                Object.assign(node, nodeData);
+            }
+            // Link this node to its parent
+            let parentNode = nodes.get(keyOfParentNode) ?? danglingNodes.get(keyOfParentNode);
+            if (!parentNode) {
+                // No parent node exists yet, create as dangling node
+                parentNode = {};
+                // Track as dangling node, we dont know yet if it really exists
+                danglingNodes.set(keyOfParentNode, parentNode);
+            }
+            // When no children added yet
+            if (!parentNode[nodeChildrenKey]) {
+                parentNode[nodeChildrenKey] = [];
+            }
+            // Add as child
+            parentNode[nodeChildrenKey].push(node);
+            // Set the parent on this node
+            if (nodeParentKey !== false) {
+                node[nodeParentKey] = parentNode;
+            }
         }
-        nodes.set(keyOfNode, node);
-        // Set the data of the node
-        const nodeData = typeof mapNodeData === 'function' ? mapNodeData(item) : item;
-        if (nodeDataKey !== false) {
-            node[nodeDataKey] = nodeData;
+        // Children of dangling nodes will become the root nodes
+        if (validRootKeys) {
+            const validParentKeys = new Set(validRootKeys);
+            for (const [key, node] of danglingNodes.entries()) {
+                if (!validParentKeys.has(key)) {
+                    throw new Error(`Invalid parent key "${key}"`);
+                }
+                for (const root of node[nodeChildrenKey]) {
+                    // Root nodes does not have a parent, unlink the dangling node
+                    if (nodeParentKey !== false) {
+                        delete root[nodeParentKey];
+                    }
+                    roots.push(root);
+                }
+            }
         }
         else {
-            Object.assign(node, nodeData);
-        }
-        // Link this node to its parent
-        const keyOfParentNode = typeof parentKey === 'function' ? parentKey(item) : item[parentKey];
-        let parent = nodes.get(keyOfParentNode) ?? danglingNodes.get(keyOfParentNode);
-        if (!parent) {
-            // No parent node exists yet, create as dangling node
-            parent = {};
-            // Track as dangling node, we dont know yet if it really exists
-            danglingNodes.set(keyOfParentNode, parent);
-        }
-        // When no children added yet
-        if (!parent[nodeChildrenKey]) {
-            parent[nodeChildrenKey] = [];
-        }
-        // Add as child
-        parent[nodeChildrenKey].push(node);
-        // Set the parent on this node
-        if (nodeParentKey !== false) {
-            node[nodeParentKey] = parent;
-        }
-    }
-    // Children of dangling nodes will become the root nodes
-    const roots = [];
-    if (validateParentKeys) {
-        const validParentKeys = new Set(validateParentKeys);
-        for (const [key, node] of danglingNodes.entries()) {
-            if (!validParentKeys.has(key)) {
-                throw new Error(`Invalid parent key "${key}"`);
-            }
-            for (const root of node[nodeChildrenKey]) {
-                // Root nodes does not have a parent, unlink the dangling node
-                if (nodeParentKey !== false) {
-                    delete root[nodeParentKey];
+            for (const node of danglingNodes.values()) {
+                for (const root of node[nodeChildrenKey]) {
+                    // Root nodes does not have a parent, unlink the dangling node
+                    if (nodeParentKey !== false) {
+                        delete root[nodeParentKey];
+                    }
+                    roots.push(root);
                 }
-                roots.push(root);
             }
         }
     }
     else {
-        for (const node of danglingNodes.values()) {
-            for (const root of node[nodeChildrenKey]) {
-                // Root nodes does not have a parent, unlink the dangling node
-                if (nodeParentKey !== false) {
-                    delete root[nodeParentKey];
+        const knownNodes = new Set();
+        const incompleteNodes = new Set();
+        for (const item of items) {
+            const keyOfNode = typeof key === 'function' ? key(item) : item[key];
+            const keyOfChildNodes = typeof childrenKey === 'function' ? childrenKey(item) : item[childrenKey];
+            if (knownNodes.has(keyOfNode)) {
+                throw new Error(`Duplicate identifier detected for "${keyOfNode}"`);
+            }
+            knownNodes.add(keyOfNode);
+            incompleteNodes.delete(keyOfNode);
+            let node = nodes.get(keyOfNode);
+            if (!node) {
+                node = {};
+                danglingNodes.set(keyOfNode, node);
+            }
+            // Set the data of the node
+            const nodeData = typeof mapNodeData === 'function' ? mapNodeData(item) : item;
+            if (nodeDataKey !== false) {
+                node[nodeDataKey] = nodeData;
+            }
+            else {
+                Object.assign(node, nodeData);
+            }
+            // Link children to this node
+            if (keyOfChildNodes) {
+                node[nodeChildrenKey] = [];
+                for (const keyOfChildNode of keyOfChildNodes) {
+                    let childNode = danglingNodes.get(keyOfChildNode);
+                    if (childNode) {
+                        nodes.set(keyOfChildNode, childNode);
+                        danglingNodes.delete(keyOfChildNode);
+                        // Set the parent on child node
+                        if (nodeParentKey !== false) {
+                            childNode[nodeParentKey] = node;
+                        }
+                    }
+                    else if (nodes.has(keyOfChildNode)) {
+                        throw new Error(`Duplicate parent detected for "${keyOfChildNode}"`);
+                    }
+                    else {
+                        // We create a new temporary node
+                        childNode = {};
+                        // Set the parent on child node
+                        if (nodeParentKey !== false) {
+                            childNode[nodeParentKey] = node;
+                        }
+                        nodes.set(keyOfChildNode, childNode);
+                        incompleteNodes.add(keyOfChildNode);
+                    }
+                    node[nodeChildrenKey].push(childNode);
+                }
+            }
+        }
+        if (incompleteNodes.size > 0) {
+            throw new Error(`Some nodes miss their referenced children (${incompleteNodes.size}).`);
+        }
+        if (validRootKeys) {
+            const validParentKeys = new Set(validRootKeys);
+            for (const [key, node] of danglingNodes.entries()) {
+                if (!validParentKeys.has(key)) {
+                    throw new Error(`Invalid parent key "${key}"`);
                 }
-                roots.push(root);
+                roots.push(node);
+                nodes.set(key, node);
+            }
+        }
+        else {
+            for (const [key, node] of danglingNodes.entries()) {
+                roots.push(node);
+                nodes.set(key, node);
             }
         }
     }

package/index.d.ts

@@ -17,15 +17,17 @@ type TreeNode<T, D extends string | number | symbol | false, P extends string |
 }));
 type KeyReturnType<T, P extends keyof T | ((item: T) => any)> = P extends ((item: T) => infer R) ? R : P extends keyof T ? T[P] : never;
 declare function buildTree<T extends (D extends false ? object : unknown), K extends keyof T | ((item: T) => any), M extends (D extends false ? object : unknown) = T, D extends string | number | symbol | false = 'data', P extends string | number | symbol | false = 'parent', C extends string | number | symbol = 'children'>(items: Iterable<T>, options?: {
+    mode?: 'parent' | 'children';
     key?: K;
     parentKey?: keyof T | ((item: T) => KeyReturnType<T, K>);
+    childrenKey?: keyof T | ((item: T) => KeyReturnType<T, K>);
     nodeDataKey?: D;
     nodeParentKey?: P;
     nodeChildrenKey?: C;
     mapNodeData?: {
         (item: T): M;
     };
-    validateParentKeys?: Iterable<unknown>;
+    validRootKeys?: Iterable<unknown>;
     validateTree?: boolean;
 }): {
     roots: TreeNode<M extends undefined ? T : M, D, P, C>[];

package/index.js

@@ -1,74 +1,150 @@
 function buildTree(items, options = {}) {
-    const { key = 'id', parentKey = 'parent', nodeDataKey = 'data', nodeParentKey = 'parent', nodeChildrenKey = 'children', mapNodeData, validateParentKeys, validateTree = false, } = options;
+    const { mode = 'parent', key = 'id', parentKey = 'parent', childrenKey = 'children', nodeDataKey = 'data', nodeParentKey = 'parent', nodeChildrenKey = 'children', mapNodeData, validRootKeys, validateTree = false, } = options;
+    const roots = [];
     const nodes = new Map();
     const danglingNodes = new Map();
-    for (const item of items) {
-        const keyOfNode = typeof key === 'function' ? key(item) : item[key];
-        if (nodes.has(keyOfNode)) {
-            throw new Error(`Duplicate identifier detected for "${keyOfNode}"`);
-        }
-        // Current node can be new or already created by a child item as its parent
-        let node = danglingNodes.get(keyOfNode);
-        if (node) {
-            danglingNodes.delete(keyOfNode);
-        }
-        else {
-            node = {};
+    if (mode === 'parent') {
+        for (const item of items) {
+            const keyOfNode = typeof key === 'function' ? key(item) : item[key];
+            const keyOfParentNode = typeof parentKey === 'function' ? parentKey(item) : item[parentKey];
+            if (nodes.has(keyOfNode)) {
+                throw new Error(`Duplicate identifier detected for "${keyOfNode}"`);
+            }
+            // Current node can be new or already created by a child item as its parent
+            let node = danglingNodes.get(keyOfNode);
+            if (node) {
+                danglingNodes.delete(keyOfNode);
+            }
+            else {
+                node = {};
+            }
+            nodes.set(keyOfNode, node);
+            // Set the data of the node
+            const nodeData = typeof mapNodeData === 'function' ? mapNodeData(item) : item;
+            if (nodeDataKey !== false) {
+                node[nodeDataKey] = nodeData;
+            }
+            else {
+                Object.assign(node, nodeData);
+            }
+            // Link this node to its parent
+            let parentNode = nodes.get(keyOfParentNode) ?? danglingNodes.get(keyOfParentNode);
+            if (!parentNode) {
+                // No parent node exists yet, create as dangling node
+                parentNode = {};
+                // Track as dangling node, we dont know yet if it really exists
+                danglingNodes.set(keyOfParentNode, parentNode);
+            }
+            // When no children added yet
+            if (!parentNode[nodeChildrenKey]) {
+                parentNode[nodeChildrenKey] = [];
+            }
+            // Add as child
+            parentNode[nodeChildrenKey].push(node);
+            // Set the parent on this node
+            if (nodeParentKey !== false) {
+                node[nodeParentKey] = parentNode;
+            }
         }
-        nodes.set(keyOfNode, node);
-        // Set the data of the node
-        const nodeData = typeof mapNodeData === 'function' ? mapNodeData(item) : item;
-        if (nodeDataKey !== false) {
-            node[nodeDataKey] = nodeData;
+        // Children of dangling nodes will become the root nodes
+        if (validRootKeys) {
+            const validParentKeys = new Set(validRootKeys);
+            for (const [key, node] of danglingNodes.entries()) {
+                if (!validParentKeys.has(key)) {
+                    throw new Error(`Invalid parent key "${key}"`);
+                }
+                for (const root of node[nodeChildrenKey]) {
+                    // Root nodes does not have a parent, unlink the dangling node
+                    if (nodeParentKey !== false) {
+                        delete root[nodeParentKey];
+                    }
+                    roots.push(root);
+                }
+            }
         }
         else {
-            Object.assign(node, nodeData);
-        }
-        // Link this node to its parent
-        const keyOfParentNode = typeof parentKey === 'function' ? parentKey(item) : item[parentKey];
-        let parent = nodes.get(keyOfParentNode) ?? danglingNodes.get(keyOfParentNode);
-        if (!parent) {
-            // No parent node exists yet, create as dangling node
-            parent = {};
-            // Track as dangling node, we dont know yet if it really exists
-            danglingNodes.set(keyOfParentNode, parent);
-        }
-        // When no children added yet
-        if (!parent[nodeChildrenKey]) {
-            parent[nodeChildrenKey] = [];
-        }
-        // Add as child
-        parent[nodeChildrenKey].push(node);
-        // Set the parent on this node
-        if (nodeParentKey !== false) {
-            node[nodeParentKey] = parent;
-        }
-    }
-    // Children of dangling nodes will become the root nodes
-    const roots = [];
-    if (validateParentKeys) {
-        const validParentKeys = new Set(validateParentKeys);
-        for (const [key, node] of danglingNodes.entries()) {
-            if (!validParentKeys.has(key)) {
-                throw new Error(`Invalid parent key "${key}"`);
-            }
-            for (const root of node[nodeChildrenKey]) {
-                // Root nodes does not have a parent, unlink the dangling node
-                if (nodeParentKey !== false) {
-                    delete root[nodeParentKey];
+            for (const node of danglingNodes.values()) {
+                for (const root of node[nodeChildrenKey]) {
+                    // Root nodes does not have a parent, unlink the dangling node
+                    if (nodeParentKey !== false) {
+                        delete root[nodeParentKey];
+                    }
+                    roots.push(root);
                 }
-                roots.push(root);
             }
         }
     }
     else {
-        for (const node of danglingNodes.values()) {
-            for (const root of node[nodeChildrenKey]) {
-                // Root nodes does not have a parent, unlink the dangling node
-                if (nodeParentKey !== false) {
-                    delete root[nodeParentKey];
+        const knownNodes = new Set();
+        const incompleteNodes = new Set();
+        for (const item of items) {
+            const keyOfNode = typeof key === 'function' ? key(item) : item[key];
+            const keyOfChildNodes = typeof childrenKey === 'function' ? childrenKey(item) : item[childrenKey];
+            if (knownNodes.has(keyOfNode)) {
+                throw new Error(`Duplicate identifier detected for "${keyOfNode}"`);
+            }
+            knownNodes.add(keyOfNode);
+            incompleteNodes.delete(keyOfNode);
+            let node = nodes.get(keyOfNode);
+            if (!node) {
+                node = {};
+                danglingNodes.set(keyOfNode, node);
+            }
+            // Set the data of the node
+            const nodeData = typeof mapNodeData === 'function' ? mapNodeData(item) : item;
+            if (nodeDataKey !== false) {
+                node[nodeDataKey] = nodeData;
+            }
+            else {
+                Object.assign(node, nodeData);
+            }
+            // Link children to this node
+            if (keyOfChildNodes) {
+                node[nodeChildrenKey] = [];
+                for (const keyOfChildNode of keyOfChildNodes) {
+                    let childNode = danglingNodes.get(keyOfChildNode);
+                    if (childNode) {
+                        nodes.set(keyOfChildNode, childNode);
+                        danglingNodes.delete(keyOfChildNode);
+                        // Set the parent on child node
+                        if (nodeParentKey !== false) {
+                            childNode[nodeParentKey] = node;
+                        }
+                    }
+                    else if (nodes.has(keyOfChildNode)) {
+                        throw new Error(`Duplicate parent detected for "${keyOfChildNode}"`);
+                    }
+                    else {
+                        // We create a new temporary node
+                        childNode = {};
+                        // Set the parent on child node
+                        if (nodeParentKey !== false) {
+                            childNode[nodeParentKey] = node;
+                        }
+                        nodes.set(keyOfChildNode, childNode);
+                        incompleteNodes.add(keyOfChildNode);
+                    }
+                    node[nodeChildrenKey].push(childNode);
+                }
+            }
+        }
+        if (incompleteNodes.size > 0) {
+            throw new Error(`Some nodes miss their referenced children (${incompleteNodes.size}).`);
+        }
+        if (validRootKeys) {
+            const validParentKeys = new Set(validRootKeys);
+            for (const [key, node] of danglingNodes.entries()) {
+                if (!validParentKeys.has(key)) {
+                    throw new Error(`Invalid parent key "${key}"`);
                 }
-                roots.push(root);
+                roots.push(node);
+                nodes.set(key, node);
+            }
+        }
+        else {
+            for (const [key, node] of danglingNodes.entries()) {
+                roots.push(node);
+                nodes.set(key, node);
             }
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fast-tree-builder",
-  "version": "0.1.4",
+  "version": "1.0.0-alpha.0",
   "description": "Efficiently construct highly customizable bi-directional tree structures from iterable data.",
   "type": "module",
   "module": "./index.js",
@@ -16,18 +16,17 @@
   "scripts": {
     "prepack": "npm run build && npm run test",
     "postversion": "git push && git push --tags",
-    "clean": "rimraf --glob \"!(.*).{d.ts,js,cjs,mjs}\" build coverage",
-    "build": "node scripts/build-esm.js && node scripts/build-cjs.js",
+    "clean": "node scripts/clean.js",
+    "build": "node scripts/build.js",
     "watch": "node scripts/watch.js",
     "test": "mocha",
     "coverage": "c8 -r text -r text-summary -r lcov --include \"*.js\" npm test"
   },
   "devDependencies": {
-    "c8": "^8.0.0",
+    "c8": "^9.1.0",
     "chokidar": "^3.5.3",
     "mocha": "^10.2.0",
-    "rimraf": "^5.0.1",
-    "typescript": "^5.1.3"
+    "typescript": "^5.3.3"
   },
   "homepage": "https://github.com/lionel87/fast-tree-builder#readme",
   "repository": {