Refactor code structure and improve type annotations

Author: jbruwes

src/index.ts

@@ -3,17 +3,18 @@ import { computed, isReactive, reactive } from "vue";
 
 export type unObject = Record<string, unknown>;
 
-const configurable = true,
-  /**
-   * Creates an array of node objects with parent and siblings
-   *
-   * @param {unObject[]} siblings - Array of sibling nodes
-   * @param {unObject} [parent] - Parent node
-   * @returns {{ node: unObject; parent: unObject; siblings: unObject }[]}
-   *   Array of objects containing node, parent, and siblings
-   */
-  getItems = (siblings: unObject[], parent?: unObject) =>
-    [...siblings].reverse().map((node) => ({ node, parent, siblings }));
+const configurable = true;
+
+/**
+ * Creates an array of node objects with parent and siblings
+ *
+ * @param {unObject[]} siblings - Array of sibling nodes
+ * @param {unObject} [parent] - Parent node
+ * @returns {{ node: unObject; parent: unObject; siblings: unObject }[]} Array
+ *   of objects containing node, parent, and siblings
+ */
+const getItems = (siblings: unObject[], parent?: unObject) =>
+  [...siblings].reverse().map((node: unObject) => ({ node, parent, siblings }));
 
 /**
  * Creates a flat representation of a JSON tree with helper functions to
@@ -70,9 +71,14 @@ export default (
        * @returns {number} Index of the node in its siblings array
        */
       get(this: unObject): number {
-        return (this[keySiblings] as unObject[]).findIndex(
-          (sibling) => this[keyId] === sibling[keyId],
-        );
+        /**
+         * Checks if the given sibling is the same as the current node
+         *
+         * @param {unObject} sibling - The sibling to compare
+         * @returns {boolean} True if the sibling matches the current node
+         */
+        const isSibling = (sibling: unObject) => this[keyId] === sibling[keyId];
+        return (this[keySiblings] as unObject[]).findIndex(isSibling);
       },
     },
     [keyNext]: {
@@ -101,18 +107,25 @@ export default (
       },
     },
   };
+
   /**
    * Generator function that traverses the tree and yields each node
    *
    * @param {unObject[]} nodes - Array of nodes to traverse
    * @yields {unObject} Each node in the tree
-   * @returns {Generator<unObject>} Generator that yields nodes
    */
-  const getNodes = function* (nodes: unObject[]) {
+  const genNodes = function* (nodes: unObject[]) {
       const stack = getItems(nodes);
       while (stack.length) {
         const { node, parent, siblings } = stack.pop() ?? {};
         if (node) {
+          /**
+           * Checks if a property key is not already defined in the node
+           *
+           * @param {string} key - The property key to check
+           * @returns {boolean} True if the key is not in the node
+           */
+          const isNotInNode = (key: string) => !(key in node);
           if (node[keyParent] !== parent)
             Object.defineProperty(node, keyParent, {
               configurable,
@@ -123,7 +136,7 @@ export default (
               configurable,
               value: siblings,
             });
-          if (Object.keys(properties).some((key) => !(key in node)))
+          if (Object.keys(properties).some(isNotInNode))
             Object.defineProperties(node, properties);
           yield node;
           stack.push(
@@ -132,93 +145,111 @@ export default (
         }
       }
     },
-    nodes = computed(() => [
-      ...getNodes(isReactive(tree) ? tree : reactive(tree)),
-    ]),
-    nodesMap = computed(() =>
-      Object.fromEntries(
-        nodes.value.map((node) => [node[keyId] as string, node]),
-      ),
-    ),
     /**
-     * Function to run actions on nodes
+     * Generates a flat array of nodes from the tree structure
      *
-     * @param {string} pId - ID of the node to perform action on
-     * @param {string} action - Action to perform (add, addChild, remove, up,
-     *   down, left, right)
-     * @returns {string | undefined} ID of the affected node or undefined
+     * @returns {unObject[]} Array of nodes in the tree
      */
-    run = (pId: string, action: string) => {
-      const the = nodesMap.value[pId];
-      if (the) {
-        const [root] = nodes.value,
-          index = the[keyIndex] as number,
-          next = the[keyNext] as undefined | unObject,
-          nextIndex = index + 1,
-          parent = the[keyParent] as undefined | unObject,
-          prev = the[keyPrev] as undefined | unObject,
-          prevIndex = index - 1,
-          siblings = the[keySiblings] as unObject[];
-        switch (action) {
-          case "add": {
-            const id = uid();
-            siblings.splice(nextIndex, 0, { [keyId]: id });
-            return id;
-          }
-          case "addChild": {
-            const id = uid();
-            if (!Array.isArray(the[keyChildren])) the[keyChildren] = [];
-            (the[keyChildren] as unObject[]).unshift({ [keyId]: id });
-            return id;
+    getNodes = () => [...genNodes(isReactive(tree) ? tree : reactive(tree))];
+
+  const nodes = computed(getNodes);
+
+  /**
+   * Gets the entry (key-value pair) for a node using its ID
+   *
+   * @param {unObject} node - The node to create an entry for
+   * @returns {[string, unObject]} A tuple with the node ID and the node object
+   */
+  const getNodeEntry = (node: unObject) => [node[keyId] as string, node],
+    /**
+     * Creates a map of nodes with node IDs as keys
+     *
+     * @returns {Record<string, unObject>} Object mapping node IDs to node
+     *   objects
+     */
+    getNodesMap = () => Object.fromEntries(nodes.value.map(getNodeEntry));
+
+  const nodesMap = computed(getNodesMap);
+
+  /**
+   * Function to run actions on nodes
+   *
+   * @param {string} pId - ID of the node to perform action on
+   * @param {string} action - Action to perform (add, addChild, remove, up,
+   *   down, left, right)
+   * @returns {string | undefined} ID of the affected node or undefined
+   */
+  const run = (pId: string, action: string) => {
+    const the = nodesMap.value[pId];
+    if (the) {
+      const [root] = nodes.value,
+        index = the[keyIndex] as number,
+        next = the[keyNext] as undefined | unObject,
+        nextIndex = index + 1,
+        parent = the[keyParent] as undefined | unObject,
+        prev = the[keyPrev] as undefined | unObject,
+        prevIndex = index - 1,
+        siblings = the[keySiblings] as unObject[];
+      switch (action) {
+        case "add": {
+          const id = uid();
+          siblings.splice(nextIndex, 0, { [keyId]: id });
+          return id;
+        }
+        case "addChild": {
+          const id = uid();
+          if (!Array.isArray(the[keyChildren])) the[keyChildren] = [];
+          (the[keyChildren] as unObject[]).unshift({ [keyId]: id });
+          return id;
+        }
+        case "down":
+          if (
+            index < siblings.length - 1 &&
+            siblings[index] &&
+            siblings[nextIndex]
+          )
+            [siblings[index], siblings[nextIndex]] = [
+              siblings[nextIndex],
+              siblings[index],
+            ];
+          break;
+        case "left":
+          if (parent?.[keyParent]) {
+            (parent[keySiblings] as unObject[]).splice(
+              (parent[keyIndex] as number) + 1,
+              0,
+              ...siblings.splice(index, 1),
+            );
+            return parent[keyId] as string;
           }
-          case "down":
-            if (
-              index < siblings.length - 1 &&
-              siblings[index] &&
-              siblings[nextIndex]
-            )
-              [siblings[index], siblings[nextIndex]] = [
-                siblings[nextIndex],
-                siblings[index],
-              ];
-            break;
-          case "left":
-            if (parent?.[keyParent]) {
-              (parent[keySiblings] as unObject[]).splice(
-                (parent[keyIndex] as number) + 1,
-                0,
-                ...siblings.splice(index, 1),
-              );
-              return parent[keyId] as string;
-            }
-            break;
-          case "remove": {
-            const id = (next?.[keyId] ??
-              prev?.[keyId] ??
-              parent?.[keyId] ??
-              root?.[keyId]) as string | undefined;
-            siblings.splice(index, 1);
+          break;
+        case "remove": {
+          const id = (next?.[keyId] ??
+            prev?.[keyId] ??
+            parent?.[keyId] ??
+            root?.[keyId]) as string | undefined;
+          siblings.splice(index, 1);
+          return id;
+        }
+        case "right":
+          if (prev) {
+            const children = (prev[keyChildren] ?? []) as unObject[],
+              id = prev[keyId] as string;
+            prev[keyChildren] = [...children, ...siblings.splice(index, 1)];
             return id;
           }
-          case "right":
-            if (prev) {
-              const children = (prev[keyChildren] ?? []) as unObject[],
-                id = prev[keyId] as string;
-              prev[keyChildren] = [...children, ...siblings.splice(index, 1)];
-              return id;
-            }
-            break;
-          case "up":
-            if (index && siblings[index] && siblings[prevIndex])
-              [siblings[prevIndex], siblings[index]] = [
-                siblings[index],
-                siblings[prevIndex],
-              ];
-            break;
-        }
+          break;
+        case "up":
+          if (index && siblings[index] && siblings[prevIndex])
+            [siblings[prevIndex], siblings[index]] = [
+              siblings[index],
+              siblings[prevIndex],
+            ];
+          break;
       }
-      return;
-    };
+    }
+    return;
+  };
 
   return {
     /**