@painekillers/tree-builder-core 1.0.0 → 1.1.1

package/graph.js

@@ -79,8 +79,28 @@ export class LayoutNode {
     }
 }
 
+/*
+Recursion settings
+Null: No recursion
+False: Creates fake nodes when encountering recursion
+True: Connects back to existing instance of a node when recursing
+#: Real recursion to depths #
+*/
+
+/*
+Strategies
+- [X] Current BFS (First) — Layer by shortest distance from root; first discovery determines placement.
+- [X] Undirected BFS (Undirected) — Shortest distance to root; layering is one directional.
+- [X] Directed BFS, outward only (Outwards) — Follow prerequisite-to-dependent edges only.
+- [X] Furthest-parent layering (Furthest) — Place each node one layer below its deepest prerequisite.
+*/
+
 export class LayoutGraph {
-    constructor(graph, root, recurse) {
+    constructor(graph, root, recurse, strategy = "First") {
+        if(strategy == "First" && typeof recurse == "number") {
+            throw new Error(`Cannot use strategy ${strategy} with numeric recursion setting`);
+        }
+
         this.layers = new Map()
 
         const rootNode = graph.nodeFromId(root)
@@ -96,13 +116,13 @@ export class LayoutGraph {
         const visited = new Map()
         const connections = new Set()
 
-        const addConnection = (ln, from) => {
+        const addConnection = (ln, from, lnPos) => {
             const fromNode =
                 this.layers.get(from.layer)?.[from.ind]
 
             if(!fromNode) return
 
-            const a = `${ln.layer}:${ln.ind}`
+            const a = `${lnPos.layer}:${lnPos.ind}`
             const b = `${from.layer}:${from.ind}`
 
             const key = [a, b].sort().join("|")
@@ -145,13 +165,29 @@ export class LayoutGraph {
 
                     //holy crap i cannot think bruh
                     if(((recurse === false) || (recurse === null)) && pos.layer !== layer) { 
-                        if(recurse === null) { continue }
+                        if (
+                            recurse === null ||
+                            strategy == "Outwards" &&
+                            from !== null &&
+                            Math.abs(layer) < Math.abs(from.layer)
+                        ) { continue }
+
+                        if (
+                            strategy == "Furthest" &&
+                            (
+                                (layer > 0 && !node.parents.every(val => visited.has(val.id)))
+                                ||
+                                (layer < 0 && !node.children.every(val => visited.has(val.id)))
+                            )
+                        ) { continue }
+
+                        //this part makes the fake node btw
                         const fn = new LayoutNode(node, layer, this.layers.get(pos.layer)[pos.ind])
                         this.layers.get(layer).push(fn)
 
-                        addConnection(fn, from)
+                        addConnection(fn, from, pos)
                     } else {
-                        addConnection(ln, from)
+                        addConnection(ln, from, pos)
 
                     }
                 }
@@ -159,6 +195,37 @@ export class LayoutGraph {
                 continue
             }
 
+            if (
+                strategy == "Outwards" &&
+                from !== null &&
+                Math.abs(layer) < Math.abs(from.layer)
+            ) { continue }
+
+            if (strategy == "Furthest") {
+                if (layer > 0 && !node.parents.every(val => visited.has(val.id))) {
+                    for (const parent of node.parents) {
+                        queue.push({
+                            node: parent,
+                            layer: layer - 1,
+                            from: null
+                        })
+                    }
+
+                    continue
+                } else 
+                if (layer < 0 && !node.children.every(val => visited.has(val.id))) {
+                    for (const child of node.children) {
+                        queue.push({
+                            node: child,
+                            layer: layer + 1,
+                            from: null
+                        })
+                    }
+
+                    continue
+                }
+            }
+
             const ln = new LayoutNode(node, layer)
 
             this.layers.get(layer).push(ln)
@@ -171,7 +238,7 @@ export class LayoutGraph {
             visited.set(key, pos)
 
             if(from) {
-                addConnection(ln, from)
+                addConnection(ln, from, pos)
             }
 
             for (const child of node.children) {
@@ -185,10 +252,11 @@ export class LayoutGraph {
             for (const parent of node.parents) {
                 queue.push({
                     node: parent,
-                    layer: layer - 1,
+                    layer: strategy !== "Undirected" ? layer - 1: layer + 1,
                     from: pos
                 })
             }
+
         }
     }
 }

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@painekillers/tree-builder-core",
-  "version": "1.0.0",
+  "version": "1.1.1",
   "type": "module",
   "exports": {
     ".": "./index.js",
     "./themes/*": "./themes/*"
   }
-}
+}

package/world/bridge.js

@@ -25,8 +25,8 @@ export default class Bridge {
         }
     }
 
-    calculateLayout(root, recurse){ // Real maxdepth, since we cant actually make it infinite
-        this.layout = new LayoutGraph(this.graph, root, recurse)
+    calculateLayout(root, recurse, strategy = "First"){ // Real maxdepth, since we cant actually make it infinite
+        this.layout = new LayoutGraph(this.graph, root, recurse, strategy)
         // Since JS is goofy like this ill just have recurse be a number when we want recursive
         this.root = this.graph.nodes.get(root)