@painekillers/tree-builder-core 1.0.0 → 1.1.0

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 on 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)
@@ -145,7 +165,22 @@ 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 }
+
                         const fn = new LayoutNode(node, layer, this.layers.get(pos.layer)[pos.ind])
                         this.layers.get(layer).push(fn)
 
@@ -159,6 +194,21 @@ export class LayoutGraph {
                 continue
             }
 
+            if (
+                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 }
+
             const ln = new LayoutNode(node, layer)
 
             this.layers.get(layer).push(ln)
@@ -185,10 +235,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.0",
   "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)