tree-element 0.1.1 → 0.3.0

package/src/dragAndDropHandler/iterateVisibleNodes.ts

@@ -1,91 +1,89 @@
 import type { Node } from "../node";
 
 interface Options {
-    handleAfterOpenFolder: (node: Node, nextNode: Node | null) => void;
-    handleClosedFolder: (
-        node: Node,
-        nextNode: Node | null,
-        element: HTMLElement,
-    ) => void;
-    handleFirstNode: (node: Node) => void;
-    handleNode: (
-        node: Node,
-        nextNode: Node | null,
-        element: HTMLElement,
-    ) => void;
+  handleAfterOpenFolder: (node: Node, nextNode: Node | null) => void;
+  handleClosedFolder: (
+    node: Node,
+    nextNode: Node | null,
+    element: HTMLElement,
+  ) => void;
+  handleFirstNode: (node: Node) => void;
+  handleNode: (node: Node, nextNode: Node | null, element: HTMLElement) => void;
 
-    /*
+  /*
     override
     return
         - true: continue iterating
         - false: stop iterating
     */
-    handleOpenFolder: (node: Node, element: HTMLElement) => boolean;
+  handleOpenFolder: (node: Node, element: HTMLElement) => boolean;
 }
 
 const iterateVisibleNodes = (
-    tree: Node,
-    {
-        handleAfterOpenFolder,
-        handleClosedFolder,
-        handleFirstNode,
-        handleNode,
-        handleOpenFolder,
-    }: Options,
+  tree: Node,
+  {
+    handleAfterOpenFolder,
+    handleClosedFolder,
+    handleFirstNode,
+    handleNode,
+    handleOpenFolder,
+  }: Options,
 ) => {
-    let isFirstNode = true;
+  let isFirstNode = true;
 
-    const iterate = (node: Node, nextNode: Node | null): void => {
-        let mustIterateInside =
-            (node.is_open === true || !node.element) && node.hasChildren();
+  const iterate = (node: Node, nextNode: Node | null): void => {
+    let mustIterateInside =
+      (node.is_open === true || !node.element) && node.hasChildren();
 
-        let element: HTMLElement | null = null;
+    let element: HTMLElement | null = null;
 
-        // Is the element visible?
-        if (node.element?.offsetParent) {
-            element = node.element;
+    // Is the element visible?
+    if (node.element?.offsetParent) {
+      element = node.element;
 
-            if (isFirstNode) {
-                handleFirstNode(node);
-                isFirstNode = false;
-            }
+      if (isFirstNode) {
+        handleFirstNode(node);
+        isFirstNode = false;
+      }
 
-            if (!node.hasChildren()) {
-                handleNode(node, nextNode, node.element);
-            } else if (node.is_open) {
-                if (!handleOpenFolder(node, node.element)) {
-                    mustIterateInside = false;
-                }
-            } else {
-                handleClosedFolder(node, nextNode, element);
-            }
+      if (!node.hasChildren()) {
+        handleNode(node, nextNode, node.element);
+      } else if (node.is_open) {
+        if (!handleOpenFolder(node, node.element)) {
+          mustIterateInside = false;
         }
+      } else {
+        handleClosedFolder(node, nextNode, element);
+      }
+    }
 
-        if (mustIterateInside) {
-            const childrenLength = node.children.length;
-            node.children.forEach((_, i) => {
-                const child = node.children[i];
+    if (!mustIterateInside) {
+      return;
+    }
 
-                if (child) {
-                    if (i === childrenLength - 1) {
-                        iterate(child, null);
-                    } else {
-                        const nextChild = node.children[i + 1];
+    const childrenLength = node.children.length;
+    for (const i of node.children.keys()) {
+      const child = node.children[i];
 
-                        if (nextChild) {
-                            iterate(child, nextChild);
-                        }
-                    }
-                }
-            });
+      if (child) {
+        if (i === childrenLength - 1) {
+          iterate(child, null);
+        } else {
+          const nextChild = node.children[i + 1];
 
-            if (node.is_open && element) {
-                handleAfterOpenFolder(node, nextNode);
-            }
+          if (nextChild) {
+            iterate(child, nextChild);
+          }
         }
-    };
+      }
+    }
 
-    iterate(tree, null);
+    if (node.is_open && element) {
+      handleAfterOpenFolder(node, nextNode);
+    }
+  };
+
+  iterate(tree, null);
 };
 
 export default iterateVisibleNodes;

package/src/dragAndDropHandler/types.ts

@@ -1,12 +1,12 @@
 import type { Node, Position } from "../node";
 
 export interface DropHint {
-    remove: () => void;
+  remove: () => void;
 }
 
 export interface HitArea {
-    bottom: number;
-    node: Node;
-    position: Position;
-    top: number;
+  bottom: number;
+  node: Node;
+  position: Position;
+  top: number;
 }