From a127d702a38131c6a12a0c2e12d246233c896656 Mon Sep 17 00:00:00 2001
From: TreetopFlyer <seth111@gmail.com>
Date: Sat, 8 May 2021 09:56:44 -0400
Subject: [PATCH 01/16] collect unique and sum

---
 index.html | 34 ++++++++++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)

diff --git a/index.html b/index.html
index 1d9966b..e93994a 100644
--- a/index.html
+++ b/index.html
@@ -71,6 +71,40 @@ var N = {
     }
 };
 </script>
+
+<script>
+
+var rows = [
+    ["a", 1],
+    ["b", 2],
+    ["a", 3],
+    ["b", 1],
+    ["a", 0],
+    ["b", 7],
+];
+Uniques = (inRows, inColumnIndex, inSumIndicies) =>
+{
+    let uniques = {};
+    inRows.forEach((inRow)=>
+    {
+        let value = inRow[inColumnIndex];
+        let match = uniques[value];
+        if(!match)
+        {
+            match = uniques[value] = {Sum:[...inRow], Rows:[]};
+        }
+        else
+        {
+            inSumIndicies.forEach(inIndex => match.Sum[inIndex] += inRow[inIndex]);
+        }
+        match.Rows.push(inRow);
+    });
+    return uniques;
+};
+console.log(Uniques(rows, 0, [1]));
+
+</script>
+
 <script>
 let tree1 = N.Create("root1",
     N.Create("branch1", 

From f372cef4b307b0f5818da92042561a3d7d3faa4b Mon Sep 17 00:00:00 2001
From: TreetopFlyer <TreetopFlyer>
Date: Sat, 8 May 2021 13:21:43 -0400
Subject: [PATCH 02/16] pivot working?

---
 index.html | 91 +++++++++++++++++++++++++++++++++++++++++++++---------
 1 file changed, 77 insertions(+), 14 deletions(-)

diff --git a/index.html b/index.html
index e93994a..450d45e 100644
--- a/index.html
+++ b/index.html
@@ -7,6 +7,7 @@ var N = {
 
             Children:[],
             Parents:[],
+            /*
             WalkID:0,
 
             GetUpward:[],
@@ -16,6 +17,7 @@ var N = {
             SetUpward:[],
             SetDownward:[],
             SetOutside:[]
+            */
         };
         inChildren.forEach( inChild => N.Connect(output, "Children", inChild, "Parents") );
         return output;
@@ -69,29 +71,27 @@ var N = {
         N.Walk(inNode, "Children", gatherDown, inNode.WalkID);
         leaves.forEach(leaf=>N.Walk(leaf, "Parents", gatherOut, inNode.WalkID));
     }
+    // delete modify
+    // create pivot
+    // delete pivot
 };
 </script>
 
 <script>
 
-var rows = [
-    ["a", 1],
-    ["b", 2],
-    ["a", 3],
-    ["b", 1],
-    ["a", 0],
-    ["b", 7],
-];
-Uniques = (inRows, inColumnIndex, inSumIndicies) =>
+
+
+Subdivide = (inNode, inColumnIndex, inSumIndicies) =>
 {
     let uniques = {};
-    inRows.forEach((inRow)=>
+    inNode.Meta.Rows.forEach((inRow)=>
     {
         let value = inRow[inColumnIndex];
         let match = uniques[value];
         if(!match)
         {
             match = uniques[value] = {Sum:[...inRow], Rows:[]};
+            N.Connect(inNode, "Children", N.Create(match), "Parents");
         }
         else
         {
@@ -99,12 +99,74 @@ Uniques = (inRows, inColumnIndex, inSumIndicies) =>
         }
         match.Rows.push(inRow);
     });
-    return uniques;
+    return inNode;
 };
-console.log(Uniques(rows, 0, [1]));
+
+
+let Leafify = inRows => inRows.map(r => N.Create({Row:r}));
+let Pivot = (inParent, inColumnIndicies, inSumIndicies, inDepth) =>
+{
+    let depth = inDepth||0;
+    let uniques = {};
+    let columnIndex = inColumnIndicies[depth];
+    inParent.Meta.Leaves.forEach((inLeaf)=>
+    {
+        try{
+            let row = inLeaf.Meta.Row;
+            let value = row[columnIndex];
+            let match = uniques[value];
+            if(!match)
+            {
+                match = uniques[value] = {_:value, Row:[...row], Leaves:[]};
+                N.Connect(inParent, "Children", N.Create(match), "Parents");
+            }
+            else
+            {
+                inSumIndicies.forEach(inIndex => match.Row[inIndex] += row[inIndex]);
+            }
+            match.Leaves.push(inLeaf);
+        }
+        catch(e)
+        {
+            console.log(e);
+        }
+    });
+
+    //delete inParent.Meta.Leaves;
+    if(depth == inColumnIndicies.length-1)
+    {
+        // cant go any deeper
+        inParent.Children.forEach( inChild =>
+        {
+            inChild.Meta.Leaves.forEach( inLeaf =>
+            {
+                N.Connect(inChild, "Children", inLeaf, "Parents");
+            });
+        });
+    }
+    else
+    {
+        inParent.Children.forEach( child =>
+        {
+            Pivot(child, inColumnIndicies, inSumIndicies, depth+1);
+        });
+    }
+};
+let csv = Leafify([
+    ["a", "long",  1],
+    ["b", "long",  2],
+    ["b", "short",  2],
+    ["a", "long",  3],
+    ["b", "short", 1],
+    ["a", "short", 0],
+    ["b", "short", 7],
+]);
+let pivotRoot = N.Create({Leaves:csv});
+Pivot(pivotRoot, [0, 1], [2]);
+console.log(pivotRoot);
 
 </script>
-
+<!--=
 <script>
 let tree1 = N.Create("root1",
     N.Create("branch1", 
@@ -144,4 +206,5 @@ let orchard = N.Create("orchard", tree1, tree2);
 N.Modify(tree1);
 console.log(tree1);
 
-</script>
\ No newline at end of file
+</script>
+-->
\ No newline at end of file

From 258dfefb219f308097f8c0219568b8a60d5c0be3 Mon Sep 17 00:00:00 2001
From: TreetopFlyer <TreetopFlyer>
Date: Sat, 8 May 2021 13:51:19 -0400
Subject: [PATCH 03/16] render pivot

---
 index.html | 125 +++++++++++++++++++++++++++--------------------------
 1 file changed, 63 insertions(+), 62 deletions(-)

diff --git a/index.html b/index.html
index 450d45e..9d79970 100644
--- a/index.html
+++ b/index.html
@@ -1,4 +1,8 @@
-<script>
+<div id="app"></div>
+<script type="module">
+
+import { h, Component, render } from 'https://unpkg.com/preact?module';
+
 var N = {
     Create:(inMeta, ...inChildren) =>
     {
@@ -75,33 +79,6 @@ var N = {
     // create pivot
     // delete pivot
 };
-</script>
-
-<script>
-
-
-
-Subdivide = (inNode, inColumnIndex, inSumIndicies) =>
-{
-    let uniques = {};
-    inNode.Meta.Rows.forEach((inRow)=>
-    {
-        let value = inRow[inColumnIndex];
-        let match = uniques[value];
-        if(!match)
-        {
-            match = uniques[value] = {Sum:[...inRow], Rows:[]};
-            N.Connect(inNode, "Children", N.Create(match), "Parents");
-        }
-        else
-        {
-            inSumIndicies.forEach(inIndex => match.Sum[inIndex] += inRow[inIndex]);
-        }
-        match.Rows.push(inRow);
-    });
-    return inNode;
-};
-
 
 let Leafify = inRows => inRows.map(r => N.Create({Row:r}));
 let Pivot = (inParent, inColumnIndicies, inSumIndicies, inDepth) =>
@@ -109,62 +86,86 @@ let Pivot = (inParent, inColumnIndicies, inSumIndicies, inDepth) =>
     let depth = inDepth||0;
     let uniques = {};
     let columnIndex = inColumnIndicies[depth];
+    
     inParent.Meta.Leaves.forEach((inLeaf)=>
     {
-        try{
-            let row = inLeaf.Meta.Row;
-            let value = row[columnIndex];
-            let match = uniques[value];
-            if(!match)
-            {
-                match = uniques[value] = {_:value, Row:[...row], Leaves:[]};
-                N.Connect(inParent, "Children", N.Create(match), "Parents");
-            }
-            else
-            {
-                inSumIndicies.forEach(inIndex => match.Row[inIndex] += row[inIndex]);
-            }
-            match.Leaves.push(inLeaf);
-        }
-        catch(e)
+        let row = inLeaf.Meta.Row;
+        let value = row[columnIndex];
+        let match = uniques[value];
+        if(!match)
         {
-            console.log(e);
+            match = uniques[value] = {Label:value, Row:[...row], Leaves:[]};
+            N.Connect(inParent, "Children", N.Create(match), "Parents");
         }
+        else
+        {
+            inSumIndicies.forEach(inIndex => match.Row[inIndex] += row[inIndex]);
+        }
+        match.Leaves.push(inLeaf);
     });
 
-    //delete inParent.Meta.Leaves;
+    delete inParent.Meta.Leaves;
     if(depth == inColumnIndicies.length-1)
     {
         // cant go any deeper
         inParent.Children.forEach( inChild =>
         {
-            inChild.Meta.Leaves.forEach( inLeaf =>
-            {
-                N.Connect(inChild, "Children", inLeaf, "Parents");
-            });
+            inChild.Meta.Leaves.forEach( inLeaf => N.Connect(inChild, "Children", inLeaf, "Parents") );
+            delete inChild.Meta.Leaves;
         });
     }
     else
     {
-        inParent.Children.forEach( child =>
-        {
-            Pivot(child, inColumnIndicies, inSumIndicies, depth+1);
-        });
+        inParent.Children.forEach( child => Pivot(child, inColumnIndicies, inSumIndicies, depth+1) );
     }
 };
 let csv = Leafify([
-    ["a", "long",  1],
-    ["b", "long",  2],
-    ["b", "short",  2],
-    ["a", "long",  3],
-    ["b", "short", 1],
-    ["a", "short", 0],
-    ["b", "short", 7],
+    ["#1", "a", "long",  1],
+    ["#2", "b", "long",  2],
+    ["#3", "b", "short", 2],
+    ["#4", "a", "long",  3],
+    ["#5", "b", "short", 1],
+    ["#6", "a", "short", 0],
+    ["#7", "b", "short", 7],
 ]);
 let pivotRoot = N.Create({Leaves:csv});
-Pivot(pivotRoot, [0, 1], [2]);
+Pivot(pivotRoot, [1, 2], [3]);
 console.log(pivotRoot);
 
+let ElNode = ({node}) =>
+{
+    var children = [];
+    var table = [];
+    if(node.Children.length)
+    {
+        if(node.Meta.Row)
+        {
+            table = node.Meta.Row.map( cell => h("span", {style:{padding:"10px"}}, cell));
+        }
+        children = [
+            h("strong", null, node.Meta.Label||"a node"),
+            ...table,
+            ...node.Children.map( inChild => h(ElNode, {node:inChild}))
+        ];
+    }
+    else
+    {
+        children = [
+            h("strong", null, node.Meta.Label||"a node"),
+            ...node.Meta.Row.map( cell => h("span", {style:{padding:"10px"}}, cell))
+        ];
+    }
+    return h("div", {style:{padding:"10px"}}, children);
+}
+let ElRoot = ({root}) =>
+{
+    return h("div", null, [
+        h("h3", null, "tree view"),
+        h(ElNode, {node:root})
+    ])
+};
+render(h(ElRoot, {root:pivotRoot}, null), document.querySelector("#app"));
+
 </script>
 <!--=
 <script>

From 12e71c5baf7f198bcc8120de4bb96e26c09d27f1 Mon Sep 17 00:00:00 2001
From: TreetopFlyer <TreetopFlyer>
Date: Sat, 8 May 2021 15:32:40 -0400
Subject: [PATCH 04/16] rendering

---
 index.html | 48 ++++++++++++++++++++++++++++++++++++------------
 1 file changed, 36 insertions(+), 12 deletions(-)

diff --git a/index.html b/index.html
index 9d79970..73d18a6 100644
--- a/index.html
+++ b/index.html
@@ -83,27 +83,41 @@ var N = {
 let Leafify = inRows => inRows.map(r => N.Create({Row:r}));
 let Pivot = (inParent, inColumnIndicies, inSumIndicies, inDepth) =>
 {
+    /*
+    arguments:
+        - a Node with leaf Nodes temporarily stored in its Meta.Leaves
+            - where each leaf Node has a row of table data in it's Meta.Row
+        - a list of columns to pivot on
+        - a list of columns to sum
+        - optional traversal depth, defaults to 0
+    */
     let depth = inDepth||0;
     let uniques = {};
-    let columnIndex = inColumnIndicies[depth];
-    
     inParent.Meta.Leaves.forEach((inLeaf)=>
     {
-        let row = inLeaf.Meta.Row;
-        let value = row[columnIndex];
-        let match = uniques[value];
+        let row = inLeaf.Meta.Row; // get the raw "CSV" row out of the leaf Node's Meta
+        let value = row[inColumnIndicies[depth]]; // get the pivot column
+        let match = uniques[value]; // check in the uniques list if this pivot column exists
         if(!match)
         {
-            match = uniques[value] = {Label:value, Row:[...row], Leaves:[]};
+            // if not, store a value under that key that will be the meta object for a new child
+            match = uniques[value] = {
+                Label:value,
+                Row:inSumIndicies.map((inColumnIndex, inIndex, inArray) => row[inColumnIndex]), // create a Meta.Row also on the new child nodes to store summed totals
+                Leaves:[]
+            };
+            // grow a child off of the parent using the meta object
             N.Connect(inParent, "Children", N.Create(match), "Parents");
         }
         else
         {
-            inSumIndicies.forEach(inIndex => match.Row[inIndex] += row[inIndex]);
+            // if a match does exist, sum the appropriate columns
+            inSumIndicies.forEach((inColumnIndex, inIndex, inArray) => match.Row[inIndex] += row[inColumnIndex]);
         }
+        // move the leaves into the child
         match.Leaves.push(inLeaf);
     });
-
+    
     delete inParent.Meta.Leaves;
     if(depth == inColumnIndicies.length-1)
     {
@@ -128,9 +142,12 @@ let csv = Leafify([
     ["#6", "a", "short", 0],
     ["#7", "b", "short", 7],
 ]);
-let pivotRoot = N.Create({Leaves:csv});
-Pivot(pivotRoot, [1, 2], [3]);
-console.log(pivotRoot);
+let pivotRoot1 = N.Create({Leaves:csv});
+Pivot(pivotRoot1, [1, 2], [3]);
+let pivotRoot2 = N.Create({Leaves:csv});
+Pivot(pivotRoot2, [2, 1], [3]);
+
+let pivots = [pivotRoot1, pivotRoot2];
 
 let ElNode = ({node}) =>
 {
@@ -157,7 +174,14 @@ let ElNode = ({node}) =>
     }
     return h("div", {style:{padding:"10px"}}, children);
 }
-let ElRoot = ({root}) =>
+
+let ElPivot = ({pivot}) =>
+{
+    return h("div", {}, [
+
+    ]);
+}
+let ElRoot = () =>
 {
     return h("div", null, [
         h("h3", null, "tree view"),

From 8c135954d828f0fd11c3392ad02008ba743407d2 Mon Sep 17 00:00:00 2001
From: TreetopFlyer <TreetopFlyer>
Date: Sat, 8 May 2021 23:34:54 -0400
Subject: [PATCH 05/16] multiple pivots

---
 index.html | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/index.html b/index.html
index 73d18a6..65de943 100644
--- a/index.html
+++ b/index.html
@@ -177,18 +177,18 @@ let ElNode = ({node}) =>
 
 let ElPivot = ({pivot}) =>
 {
-    return h("div", {}, [
-
+    return h("div", {style:{display:"inline-block"}}, [
+        h(ElNode, {node:pivot})
     ]);
 }
-let ElRoot = () =>
+let ElRoot = ({pivots}) =>
 {
     return h("div", null, [
         h("h3", null, "tree view"),
-        h(ElNode, {node:root})
+        ...pivots.map(pivot=>h(ElPivot, {pivot}))
     ])
 };
-render(h(ElRoot, {root:pivotRoot}, null), document.querySelector("#app"));
+render(h(ElRoot, {pivots}, null), document.querySelector("#app"));
 
 </script>
 <!--=

From 11dd9f056923a9cbe07298f793849e908544a083 Mon Sep 17 00:00:00 2001
From: TreetopFlyer <TreetopFlyer>
Date: Sun, 9 May 2021 14:19:13 -0400
Subject: [PATCH 06/16] Link Conventions

---
 index.html | 236 ++++++++++++++++++++++++++++-------------------------
 1 file changed, 124 insertions(+), 112 deletions(-)

diff --git a/index.html b/index.html
index 65de943..9dc1bb9 100644
--- a/index.html
+++ b/index.html
@@ -4,98 +4,152 @@
 import { h, Component, render } from 'https://unpkg.com/preact?module';
 
 var N = {
+    ID:{
+        Walk:0,
+        Instance:0
+    },
     Create:(inMeta, ...inChildren) =>
     {
         var output = {
             Meta:inMeta,
-
-            Children:[],
-            Parents:[],
-            /*
-            WalkID:0,
-
-            GetUpward:[],
-            GetDownward:[],
-            GetOutside:[],
-
-            SetUpward:[],
-            SetDownward:[],
-            SetOutside:[]
-            */
+            Link:{
+                Hierarchy: {Get:[], Set:[]},
+                ModifyUp:  {Get:[], Set:[]},
+                ModifyDown:{Get:[], Set:[]},
+                ModifyOut: {Get:[], Set:[]},
+            },
+            ID:{
+                Walk:0,
+                Instance:N.ID.Instance++
+            }
         };
-        inChildren.forEach( inChild => N.Connect(output, "Children", inChild, "Parents") );
+        inChildren.forEach( inChild => N.Connect(output, inChild, "Hierarchy") );
         return output;
     },
-    Connect:(inParent, inParentRefs, inChild, inChildRefs) =>
+    Flow:(inNode, inType, inForward) => (inForward === undefined || inForward === true) ? inNode.Link[inType].Set : inNode.Link[inType].Get,
+    Connect:(inNodeMajor, inNodeMinor, inKey) =>
     {
-        inParent[inParentRefs].push(inChild);
-        inChild[inChildRefs].push(inParent);
+        inNodeMajor.Link[inKey].Set.push(inNodeMinor);
+        inNodeMinor.Link[inKey].Get.push(inNodeMajor);
     },
-    Disconnect:(inParent, inParentRefs, inChild, inChildRefs) =>
+    Disconnect:(inNodeMajor, inNodeMinor, inKey) =>
     {
-        let checkRemove = (inArray, inMember) =>
-        {
-            inArray.findIndex( (inMember, inIndex, inArray) => (inMember === match) ? inArray.splice(inIndex, 1) : false );
-        };
-        checkRemove(inParent[inParentRefs], inChild);
-        checkRemove(inChild[inChildRefs], inParent);
+        let checkRemove = (inArray, inMember) => inArray.findIndex( (inMember, inIndex, inArray) => (inMember === match) ? inArray.splice(inIndex, 1) : false );
+        
+        // if no minor node was passed, cut all of the major node's "Set" connections under inKey (removes all "children")
+        if(inNodeMinor == null){
+            let array = inNodeMajor[inKey].Set
+            array.forEach( nodeMinor =>
+            {
+                checkRemove(nodeMinor.Link[inKey].Get, nodeMinor);
+            });
+            array = [];
+            return;
+        }
+
+        // if no major node was passed, cut all of the minor node's "Get" connections under inKey (removes all "parents")
+        if(inNodeMajor == null){
+            let array = inNodeMinor[inKey].Get
+            array.forEach( nodeMajor =>
+            {
+                checkRemove(nodeMajor.Link[inKey].Set, nodeMajor);
+            });
+            array = [];
+            return;
+        }
+
+        checkRemove(inNodeMajor.Link[inKey].Set, inNodeMinor);
+        checkRemove(inNodeMinor.Link[inKey].Get, inNodeMajor);
     },
-    Walk:(inNode, inKey, inIterator, inWalkID) =>
+    Walk:(inIterator, inNode, inKey, inForwards) =>
     {
-        let array = inNode[inKey];
+        let array = N.Flow(inNode, inKey, inForwards);
         for(let i=0; i<array.length; i++)
         {
             let next = array[i];
-            if(next.WalkID !== inWalkID)
+            if(next.ID.Walk !== N.ID.Walk)
             {
-                next.WalkID = inWalkID;
+                next.ID.Walk = N.ID.Walk;
                 let results = inIterator(next);
                 if(results !== false)
                 {
-                    N.Walk(next, inKey, inIterator, inWalkID);
+                    N.Walk(inIterator, next, inKey, inForwards);
                 }
             }
         }
     },
     Modify(inNode)
     {
-        inNode.WalkID = "tweak-"+Math.random();
+        N.ID.Walk++;
 
         let leaves = [];
-        let gatherUp = n => N.Connect(inNode, "SetUpward", n, "GetUpward");
+        let gatherUp = n => N.Connect(inNode, n, "ModifyUp");
         let gatherDown = n =>
         {
-            N.Connect(inNode, "SetDownward", n, "GetDownward");
-            n.Children.length == 0 ?  leaves.push(n) : null;
+            N.Connect(inNode, n, "ModifyDown");
+            N.Flow(n, "Hierarchy").length == 0 ?  leaves.push(n) : null;
         };
-        let gatherOut = n => N.Connect(inNode, "SetOutside", n, "GetOutside");
+        let gatherOut = n => N.Connect(inNode, n, "ModifyOut");
 
-        N.Walk(inNode, "Parents", gatherUp, inNode.WalkID);
-        N.Connect(inNode, "SetDownward", inNode, "GetDownward");
-        N.Walk(inNode, "Children", gatherDown, inNode.WalkID);
-        leaves.forEach(leaf=>N.Walk(leaf, "Parents", gatherOut, inNode.WalkID));
+        N.Walk(gatherUp, inNode, "Hierarchy", false);
+        N.Connect(inNode, inNode, "ModifyDown");
+        N.Walk(gatherDown, inNode, "Hierarchy");
+        leaves.forEach(leaf=>N.Walk(gatherOut, leaf, "Hierarchy", false));
     }
-    // delete modify
-    // create pivot
-    // delete pivot
 };
 
+
+let tree1 = N.Create("root1",
+    N.Create("branch1", 
+        N.Create("leaf1"),
+        N.Create("leaf2"),
+        N.Create("leaf3"),
+    ),
+    N.Create("branch2",
+        N.Create("leaft3"),
+        N.Create("leaft4")
+    )
+);
+
+let leaves = [];
+let leavesCollect = n =>
+{
+    if(n.Children.length == 0)
+    {
+        leaves.push(n);
+    }
+};
+N.Walk(leavesCollect, tree1, "Hierarchy");
+
+let tree2 = N.Create("root2", 
+    N.Create("branch3",
+        N.Create("leaf5"),
+        N.Create("leaf6")
+    ),
+    N.Create("branch4", ...leaves)
+);
+
+let orchard = N.Create("orchard", tree1, tree2);
+
+
+N.Modify(tree1);
+
+
 let Leafify = inRows => inRows.map(r => N.Create({Row:r}));
 let Pivot = (inParent, inColumnIndicies, inSumIndicies, inDepth) =>
 {
-    /*
-    arguments:
-        - a Node with leaf Nodes temporarily stored in its Meta.Leaves
-            - where each leaf Node has a row of table data in it's Meta.Row
-        - a list of columns to pivot on
-        - a list of columns to sum
-        - optional traversal depth, defaults to 0
-    */
+    
+    //arguments:
+    //    - a Node with leaf Nodes temporarily stored in its Meta.Leaves
+    //        - where each leaf Node has a row of table data in it's Meta.Row
+    //    - a list of columns to pivot on
+    //    - a list of columns to sum
+    //    - optional traversal depth, defaults to 0
     let depth = inDepth||0;
     let uniques = {};
     inParent.Meta.Leaves.forEach((inLeaf)=>
     {
-        let row = inLeaf.Meta.Row; // get the raw "CSV" row out of the leaf Node's Meta
+        let row = inLeaf.Meta.Row; // shorthand for the raw "CSV" row in the leaf Node's Meta
         let value = row[inColumnIndicies[depth]]; // get the pivot column
         let match = uniques[value]; // check in the uniques list if this pivot column exists
         if(!match)
@@ -107,7 +161,7 @@ let Pivot = (inParent, inColumnIndicies, inSumIndicies, inDepth) =>
                 Leaves:[]
             };
             // grow a child off of the parent using the meta object
-            N.Connect(inParent, "Children", N.Create(match), "Parents");
+            N.Connect(inParent, N.Create(match), "Hierarchy");
         }
         else
         {
@@ -119,19 +173,20 @@ let Pivot = (inParent, inColumnIndicies, inSumIndicies, inDepth) =>
     });
     
     delete inParent.Meta.Leaves;
-    if(depth == inColumnIndicies.length-1)
+    var children = N.Flow(inParent, "Hierarchy");
+    if(depth >= inColumnIndicies.length-1)
     {
-        // cant go any deeper
-        inParent.Children.forEach( inChild =>
+        children.forEach( inChild =>
         {
-            inChild.Meta.Leaves.forEach( inLeaf => N.Connect(inChild, "Children", inLeaf, "Parents") );
+            inChild.Meta.Leaves.forEach( inLeaf => N.Connect(inChild, inLeaf, "Hierarchy") );
             delete inChild.Meta.Leaves;
         });
     }
     else
     {
-        inParent.Children.forEach( child => Pivot(child, inColumnIndicies, inSumIndicies, depth+1) );
+        children.forEach( child => Pivot(child, inColumnIndicies, inSumIndicies, depth+1) );
     }
+
 };
 let csv = Leafify([
     ["#1", "a", "long",  1],
@@ -151,25 +206,24 @@ let pivots = [pivotRoot1, pivotRoot2];
 
 let ElNode = ({node}) =>
 {
+    var nodeChildren = N.Flow(node, "Hierarchy");
     var children = [];
     var table = [];
-    if(node.Children.length)
+
+    if(node.Meta.Row)
     {
-        if(node.Meta.Row)
-        {
-            table = node.Meta.Row.map( cell => h("span", {style:{padding:"10px"}}, cell));
-        }
-        children = [
-            h("strong", null, node.Meta.Label||"a node"),
-            ...table,
-            ...node.Children.map( inChild => h(ElNode, {node:inChild}))
-        ];
+        table = node.Meta.Row.map( cell => h("span", {style:{padding:"10px"}}, cell));
     }
-    else
+    children =  [
+        h("strong", null, node.Meta.Label||"a node"),
+        ...table
+    ];
+
+    if(nodeChildren.length)
     {
         children = [
-            h("strong", null, node.Meta.Label||"a node"),
-            ...node.Meta.Row.map( cell => h("span", {style:{padding:"10px"}}, cell))
+            ...children,
+            ...nodeChildren.map( inChild => h(ElNode, {node:inChild}))
         ];
     }
     return h("div", {style:{padding:"10px"}}, children);
@@ -191,45 +245,3 @@ let ElRoot = ({pivots}) =>
 render(h(ElRoot, {pivots}, null), document.querySelector("#app"));
 
 </script>
-<!--=
-<script>
-let tree1 = N.Create("root1",
-    N.Create("branch1", 
-        N.Create("leaf1"),
-        N.Create("leaf2"),
-        N.Create("leaf3"),
-    ),
-    N.Create("branch2",
-        N.Create("leaft3"),
-        N.Create("leaft4")
-    )
-);
-
-let leaves = [];
-let leavesCollect = n =>
-{
-    if(n.Children.length == 0)
-    {
-        leaves.push(n);
-    }
-};
-N.Walk(tree1, "Children", leavesCollect, 1);
-
-let tree2 = N.Create("root2", 
-    N.Create("branch3",
-        N.Create("leaf5"),
-        N.Create("leaf6")
-    ),
-    N.Create("branch4", ...leaves)
-);
-
-let orchard = N.Create("orchard", tree1, tree2);
-
-
-/*************************************************************/
-
-N.Modify(tree1);
-console.log(tree1);
-
-</script>
--->
\ No newline at end of file

From 687ac9e7ccb7dfe74e860718913980d9c0e3a988 Mon Sep 17 00:00:00 2001
From: SethTrowbridge <TreetopFlyer>
Date: Sun, 9 May 2021 20:26:40 -0400
Subject: [PATCH 07/16] Flow create, Disconnect purge

---
 index.html | 290 ++++++++++++++++++++++++++++++-----------------------
 1 file changed, 163 insertions(+), 127 deletions(-)

diff --git a/index.html b/index.html
index 9dc1bb9..5077f7b 100644
--- a/index.html
+++ b/index.html
@@ -1,22 +1,18 @@
 <div id="app"></div>
-<script type="module">
+<script>
 
-import { h, Component, render } from 'https://unpkg.com/preact?module';
-
-var N = {
+var N =
+{
     ID:{
         Walk:0,
         Instance:0
     },
-    Create:(inMeta, ...inChildren) =>
+    Create(inMeta, ...inChildren)
     {
         var output = {
             Meta:inMeta,
             Link:{
-                Hierarchy: {Get:[], Set:[]},
-                ModifyUp:  {Get:[], Set:[]},
-                ModifyDown:{Get:[], Set:[]},
-                ModifyOut: {Get:[], Set:[]},
+
             },
             ID:{
                 Walk:0,
@@ -26,44 +22,90 @@ var N = {
         inChildren.forEach( inChild => N.Connect(output, inChild, "Hierarchy") );
         return output;
     },
-    Flow:(inNode, inType, inForward) => (inForward === undefined || inForward === true) ? inNode.Link[inType].Set : inNode.Link[inType].Get,
-    Connect:(inNodeMajor, inNodeMinor, inKey) =>
+    Flow(inNode, inType, inForward)
     {
-        inNodeMajor.Link[inKey].Set.push(inNodeMinor);
-        inNodeMinor.Link[inKey].Get.push(inNodeMajor);
+        let connectionGroup = inNode.Link[inType];
+        if(!connectionGroup)
+        {
+            inNode.Link[inType] = connectionGroup = {Get:[], Set:[]};
+        }
+        return (inForward === undefined || inForward === true) ? connectionGroup.Set : connectionGroup.Get
     },
-    Disconnect:(inNodeMajor, inNodeMinor, inKey) =>
+    Connect(inNodeMajor, inNodeMinor, inKey)
     {
-        let checkRemove = (inArray, inMember) => inArray.findIndex( (inMember, inIndex, inArray) => (inMember === match) ? inArray.splice(inIndex, 1) : false );
-        
-        // if no minor node was passed, cut all of the major node's "Set" connections under inKey (removes all "children")
-        if(inNodeMinor == null){
-            let array = inNodeMajor[inKey].Set
-            array.forEach( nodeMinor =>
+        N.Flow(inNodeMajor, inKey, true ).push(inNodeMinor);
+        N.Flow(inNodeMinor, inKey, false).push(inNodeMajor);
+    },
+    Disconnect(inNodeMajor, inNodeMinor, inKey)
+    {
+        let remove = (inArray, inMatch) => inArray.findIndex( (inMember, inIndex, inArray) => (inMember === inMatch) ? inArray.splice(inIndex, 1) : false );
+
+        if(inNodeMinor === null)
+        {
+            inNodeMajor.Link[inKey].Set.forEach( inLoopNode => 
             {
-                checkRemove(nodeMinor.Link[inKey].Get, nodeMinor);
+                if(inLoopNode.Link[inKey].Get.length == 1)
+                {
+                    // we're about to delete the last get reference on a minor node, just purge the key entirely
+                    delete inLoopNode.Link[inKey];
+                }
+                else
+                {
+                    remove( inLoopNode.Link[inKey].Get, inNodeMajor);
+                }
+
             });
-            array = [];
+            // we just wiped out all set, if get is empty we can purge the key from major
+            if(inNodeMajor.Link[inKey].Get.length == 0)
+            {
+                delete inNodeMajor.Link[inKey];
+            }
             return;
         }
 
-        // if no major node was passed, cut all of the minor node's "Get" connections under inKey (removes all "parents")
-        if(inNodeMajor == null){
-            let array = inNodeMinor[inKey].Get
-            array.forEach( nodeMajor =>
+        if(inNodeMajor === null)
+        {
+            inNodeMinor.Link[inKey].Get.forEach( inLoopNode => 
             {
-                checkRemove(nodeMajor.Link[inKey].Set, nodeMajor);
+                if(inLoopNode.Link[inKey].Set.length == 1)
+                {
+                    delete inLoopNode.Link[inKey];
+                }
+                else
+                {
+                    remove( inLoopNode.Link[inKey].Set, inNodeMinor);
+                }
             });
-            array = [];
+            // we just wiped out all get, if set is empty we can purge the key from minor
+            if(inNodeMinor.Link[inKey].Set.length == 0)
+            {
+                delete inNodeMinor.Link[inKey];
+            }
             return;
         }
 
-        checkRemove(inNodeMajor.Link[inKey].Set, inNodeMinor);
-        checkRemove(inNodeMinor.Link[inKey].Get, inNodeMajor);
+
+        if(inNodeMajor.Link[inKey].Set.length == 1)
+        {
+            delete inNodeMajor.Link[inKey];
+        }
+        else
+        {
+            remove(inNodeMajor.Link[inKey].Set, inNodeMinor);
+        }
+        if(inNodeMinor.Link[inKey].Get.length == 1)
+        {
+            delete inNodeMinor.Link[inKey];
+        }
+        else
+        {
+            remove(inNodeMinor.Link[inKey].Get, inNodeMajor);
+        }
+
     },
-    Walk:(inIterator, inNode, inKey, inForwards) =>
+    Walk(inIterator, inNode, inKey, inForward)
     {
-        let array = N.Flow(inNode, inKey, inForwards);
+        let array = N.Flow(inNode, inKey, inForward);
         for(let i=0; i<array.length; i++)
         {
             let next = array[i];
@@ -73,10 +115,86 @@ var N = {
                 let results = inIterator(next);
                 if(results !== false)
                 {
-                    N.Walk(inIterator, next, inKey, inForwards);
+                    N.Walk(inIterator, next, inKey, inForward);
                 }
             }
         }
+    }
+};
+
+let a = N.Create({name:"A"});
+let b = N.Create({name:"B"});
+let c = N.Create({name:"C"});
+N.Connect(a, b, "parent");
+N.Connect(a, c, "parent");
+N.Disconnect(a, c, "parent");
+
+</script>
+
+<script>
+var Pivot = 
+{
+    Leaves:{},
+    Init(inRows)
+    {
+        Pivot.Leaves = inRows.map(r => N.Create({Row:r}));
+        Pivot.Init = ()=>{};
+    },
+    Pivot(inParent, inColumnIndicies, inSumIndicies, inDepth)
+    {
+        //arguments:
+        //    - a Node with leaf Nodes temporarily stored in its Meta.Leaves
+        //        - where each leaf Node has a row of table data in it's Meta.Row
+        //    - a list of columns to pivot on
+        //    - a list of columns to sum
+        //    - optional traversal depth, defaults to 0
+        let depth = inDepth||0;
+        let uniques = {};
+        inParent.Meta.Leaves.forEach((inLeaf)=>
+        {
+            let row = inLeaf.Meta.Row; // shorthand for the raw "CSV" row in the leaf Node's Meta
+            let value = row[inColumnIndicies[depth]]; // get the pivot column
+            let match = uniques[value]; // check in the uniques list if this pivot column exists
+            if(!match)
+            {
+                // if not, store a value under that key that will be the meta object for a new child
+                match = uniques[value] = {
+                    Label:value,
+                    Row:inSumIndicies.map((inColumnIndex, inIndex, inArray) => row[inColumnIndex]), // create a Meta.Row also on the new child nodes to store summed totals
+                    Leaves:[]
+                };
+                // grow a child off of the parent using the meta object
+                N.Connect(inParent, N.Create(match), "Hierarchy");
+            }
+            else
+            {
+                // if a match does exist, sum the appropriate columns
+                inSumIndicies.forEach((inColumnIndex, inIndex, inArray) => match.Row[inIndex] += row[inColumnIndex]);
+            }
+            // move the leaves into the child
+            match.Leaves.push(inLeaf);
+        });
+        
+        delete inParent.Meta.Leaves;
+        var iterator;
+        if(depth >= inColumnIndicies.length-1)
+        {
+            iterator = inChild =>
+            {
+                inChild.Meta.Leaves.forEach( inLeaf => N.Connect(inChild, inLeaf, "Hierarchy") );
+                delete inChild.Meta.Leaves;
+            }
+        }
+        else
+        {
+            iterator = child => Pivot.Pivot(child, inColumnIndicies, inSumIndicies, depth+1);
+        }
+        N.Flow(inParent, "Hierarchy").forEach(iterator);
+        return inParent;
+    },
+    Create(inColumnIndicies, inSumIndicies)
+    {
+        return Pivot.Pivot(N.Create({Leaves:Pivot.Leaves}), inColumnIndicies, inSumIndicies);
     },
     Modify(inNode)
     {
@@ -95,100 +213,21 @@ var N = {
         N.Connect(inNode, inNode, "ModifyDown");
         N.Walk(gatherDown, inNode, "Hierarchy");
         leaves.forEach(leaf=>N.Walk(gatherOut, leaf, "Hierarchy", false));
+    },
+    Unmodify(inNode)
+    {
+        N.Disconnect(inNode, null, "ModifyUp");
+        N.Disconnect(inNode, null, "ModifyDown");
+        N.Disconnect(inNode, null, "ModifyOut");
     }
 };
+</script>
 
+<script type="module">
 
-let tree1 = N.Create("root1",
-    N.Create("branch1", 
-        N.Create("leaf1"),
-        N.Create("leaf2"),
-        N.Create("leaf3"),
-    ),
-    N.Create("branch2",
-        N.Create("leaft3"),
-        N.Create("leaft4")
-    )
-);
+import { h, Component, render } from 'https://unpkg.com/preact?module';
 
-let leaves = [];
-let leavesCollect = n =>
-{
-    if(n.Children.length == 0)
-    {
-        leaves.push(n);
-    }
-};
-N.Walk(leavesCollect, tree1, "Hierarchy");
-
-let tree2 = N.Create("root2", 
-    N.Create("branch3",
-        N.Create("leaf5"),
-        N.Create("leaf6")
-    ),
-    N.Create("branch4", ...leaves)
-);
-
-let orchard = N.Create("orchard", tree1, tree2);
-
-
-N.Modify(tree1);
-
-
-let Leafify = inRows => inRows.map(r => N.Create({Row:r}));
-let Pivot = (inParent, inColumnIndicies, inSumIndicies, inDepth) =>
-{
-    
-    //arguments:
-    //    - a Node with leaf Nodes temporarily stored in its Meta.Leaves
-    //        - where each leaf Node has a row of table data in it's Meta.Row
-    //    - a list of columns to pivot on
-    //    - a list of columns to sum
-    //    - optional traversal depth, defaults to 0
-    let depth = inDepth||0;
-    let uniques = {};
-    inParent.Meta.Leaves.forEach((inLeaf)=>
-    {
-        let row = inLeaf.Meta.Row; // shorthand for the raw "CSV" row in the leaf Node's Meta
-        let value = row[inColumnIndicies[depth]]; // get the pivot column
-        let match = uniques[value]; // check in the uniques list if this pivot column exists
-        if(!match)
-        {
-            // if not, store a value under that key that will be the meta object for a new child
-            match = uniques[value] = {
-                Label:value,
-                Row:inSumIndicies.map((inColumnIndex, inIndex, inArray) => row[inColumnIndex]), // create a Meta.Row also on the new child nodes to store summed totals
-                Leaves:[]
-            };
-            // grow a child off of the parent using the meta object
-            N.Connect(inParent, N.Create(match), "Hierarchy");
-        }
-        else
-        {
-            // if a match does exist, sum the appropriate columns
-            inSumIndicies.forEach((inColumnIndex, inIndex, inArray) => match.Row[inIndex] += row[inColumnIndex]);
-        }
-        // move the leaves into the child
-        match.Leaves.push(inLeaf);
-    });
-    
-    delete inParent.Meta.Leaves;
-    var children = N.Flow(inParent, "Hierarchy");
-    if(depth >= inColumnIndicies.length-1)
-    {
-        children.forEach( inChild =>
-        {
-            inChild.Meta.Leaves.forEach( inLeaf => N.Connect(inChild, inLeaf, "Hierarchy") );
-            delete inChild.Meta.Leaves;
-        });
-    }
-    else
-    {
-        children.forEach( child => Pivot(child, inColumnIndicies, inSumIndicies, depth+1) );
-    }
-
-};
-let csv = Leafify([
+let csv = Pivot.Init([
     ["#1", "a", "long",  1],
     ["#2", "b", "long",  2],
     ["#3", "b", "short", 2],
@@ -197,11 +236,8 @@ let csv = Leafify([
     ["#6", "a", "short", 0],
     ["#7", "b", "short", 7],
 ]);
-let pivotRoot1 = N.Create({Leaves:csv});
-Pivot(pivotRoot1, [1, 2], [3]);
-let pivotRoot2 = N.Create({Leaves:csv});
-Pivot(pivotRoot2, [2, 1], [3]);
-
+let pivotRoot1 = Pivot.Create([1, 2], [3]);
+let pivotRoot2 = Pivot.Create([2, 1], [3]);
 let pivots = [pivotRoot1, pivotRoot2];
 
 let ElNode = ({node}) =>

From 055e81b02acc9135ffc5d7c405484401173653a1 Mon Sep 17 00:00:00 2001
From: SethTrowbridge <TreetopFlyer>
Date: Tue, 11 May 2021 06:26:18 -0400
Subject: [PATCH 08/16] misc renaming

---
 index.html | 83 +++++++++++++++++++++++++++++++++++++-----------------
 1 file changed, 57 insertions(+), 26 deletions(-)

diff --git a/index.html b/index.html
index 5077f7b..7152f15 100644
--- a/index.html
+++ b/index.html
@@ -1,4 +1,5 @@
 <div id="app"></div>
+
 <script>
 
 var N =
@@ -7,22 +8,18 @@ var N =
         Walk:0,
         Instance:0
     },
-    Create(inMeta, ...inChildren)
+    Create(inMeta)
     {
-        var output = {
-            Meta:inMeta,
-            Link:{
-
-            },
+        return {
             ID:{
                 Walk:0,
                 Instance:N.ID.Instance++
-            }
+            },
+            Meta:inMeta||{},
+            Link:{}
         };
-        inChildren.forEach( inChild => N.Connect(output, inChild, "Hierarchy") );
-        return output;
     },
-    Flow(inNode, inType, inForward)
+    Step(inNode, inType, inForward)
     {
         let connectionGroup = inNode.Link[inType];
         if(!connectionGroup)
@@ -33,8 +30,8 @@ var N =
     },
     Connect(inNodeMajor, inNodeMinor, inKey)
     {
-        N.Flow(inNodeMajor, inKey, true ).push(inNodeMinor);
-        N.Flow(inNodeMinor, inKey, false).push(inNodeMajor);
+        N.Step(inNodeMajor, inKey, true ).push(inNodeMinor);
+        N.Step(inNodeMinor, inKey, false).push(inNodeMajor);
     },
     Disconnect(inNodeMajor, inNodeMinor, inKey)
     {
@@ -105,7 +102,7 @@ var N =
     },
     Walk(inIterator, inNode, inKey, inForward)
     {
-        let array = N.Flow(inNode, inKey, inForward);
+        let array = N.Step(inNode, inKey, inForward);
         for(let i=0; i<array.length; i++)
         {
             let next = array[i];
@@ -122,12 +119,24 @@ var N =
     }
 };
 
+`
+A     C
+ \   / \
+  \ /   \
+   B     D
+`
 let a = N.Create({name:"A"});
 let b = N.Create({name:"B"});
 let c = N.Create({name:"C"});
+let d = N.Create({name:"D"});
 N.Connect(a, b, "parent");
-N.Connect(a, c, "parent");
-N.Disconnect(a, c, "parent");
+N.Connect(c, b, "parent");
+N.Connect(c, d, "parent");
+N.Disconnect(a, null, "parent");
+console.log(a.Link);
+console.log(b.Link);
+console.log(c.Link);
+console.log(d.Link);
 
 </script>
 
@@ -135,6 +144,8 @@ N.Disconnect(a, c, "parent");
 var Pivot = 
 {
     Leaves:{},
+    Root:{},
+    
     Init(inRows)
     {
         Pivot.Leaves = inRows.map(r => N.Create({Row:r}));
@@ -189,7 +200,7 @@ var Pivot =
         {
             iterator = child => Pivot.Pivot(child, inColumnIndicies, inSumIndicies, depth+1);
         }
-        N.Flow(inParent, "Hierarchy").forEach(iterator);
+        N.Step(inParent, "Hierarchy").forEach(iterator);
         return inParent;
     },
     Create(inColumnIndicies, inSumIndicies)
@@ -205,7 +216,7 @@ var Pivot =
         let gatherDown = n =>
         {
             N.Connect(inNode, n, "ModifyDown");
-            N.Flow(n, "Hierarchy").length == 0 ?  leaves.push(n) : null;
+            N.Step(n, "Hierarchy").length == 0 ?  leaves.push(n) : null;
         };
         let gatherOut = n => N.Connect(inNode, n, "ModifyOut");
 
@@ -225,9 +236,11 @@ var Pivot =
 
 <script type="module">
 
-import { h, Component, render } from 'https://unpkg.com/preact?module';
+import {h, render, createContext} from 'https://cdn.skypack.dev/preact';
+import {useReducer} from 'https://cdn.skypack.dev/preact/hooks';
+import { css, cx } from 'https://cdn.skypack.dev/@emotion/css';
 
-let csv = Pivot.Init([
+Pivot.Init([
     ["#1", "a", "long",  1],
     ["#2", "b", "long",  2],
     ["#3", "b", "short", 2],
@@ -240,9 +253,20 @@ let pivotRoot1 = Pivot.Create([1, 2], [3]);
 let pivotRoot2 = Pivot.Create([2, 1], [3]);
 let pivots = [pivotRoot1, pivotRoot2];
 
+
+let Store = createContext(null);
+let StoreState = 
+{
+    count:7
+};
+let StoreReducer = (inState, inAction) =>
+{
+
+}
+
 let ElNode = ({node}) =>
 {
-    var nodeChildren = N.Flow(node, "Hierarchy");
+    var nodeChildren = N.Step(node, "Hierarchy");
     var children = [];
     var table = [];
 
@@ -252,7 +276,11 @@ let ElNode = ({node}) =>
     }
     children =  [
         h("strong", null, node.Meta.Label||"a node"),
-        ...table
+        ...table,
+        h(Store.Consumer, null, value=>
+        {
+            return value.get.count;
+        })
     ];
 
     if(nodeChildren.length)
@@ -264,7 +292,6 @@ let ElNode = ({node}) =>
     }
     return h("div", {style:{padding:"10px"}}, children);
 }
-
 let ElPivot = ({pivot}) =>
 {
     return h("div", {style:{display:"inline-block"}}, [
@@ -273,10 +300,14 @@ let ElPivot = ({pivot}) =>
 }
 let ElRoot = ({pivots}) =>
 {
-    return h("div", null, [
-        h("h3", null, "tree view"),
-        ...pivots.map(pivot=>h(ElPivot, {pivot}))
-    ])
+    let [get, set] = useReducer(StoreReducer, StoreState);
+
+    return h(Store.Provider, {value:{get, set}}, [
+        h("div", null, [
+            h("h3", null, "tree view"),
+            ...pivots.map(pivot=>h(ElPivot, {pivot}))
+        ])
+    ]);
 };
 render(h(ElRoot, {pivots}, null), document.querySelector("#app"));
 

From 87903308e912d14e79c987bf91f5a47f037c5a60 Mon Sep 17 00:00:00 2001
From: SethTrowbridge <TreetopFlyer>
Date: Tue, 11 May 2021 23:18:08 -0400
Subject: [PATCH 09/16] pivots and modifications

---
 index.html | 81 ++++++++++++++++++++++++++++++++++++++++++------------
 1 file changed, 63 insertions(+), 18 deletions(-)

diff --git a/index.html b/index.html
index 7152f15..16b3fd6 100644
--- a/index.html
+++ b/index.html
@@ -8,6 +8,7 @@ var N =
         Walk:0,
         Instance:0
     },
+
     Create(inMeta)
     {
         return {
@@ -19,19 +20,10 @@ var N =
             Link:{}
         };
     },
-    Step(inNode, inType, inForward)
-    {
-        let connectionGroup = inNode.Link[inType];
-        if(!connectionGroup)
-        {
-            inNode.Link[inType] = connectionGroup = {Get:[], Set:[]};
-        }
-        return (inForward === undefined || inForward === true) ? connectionGroup.Set : connectionGroup.Get
-    },
     Connect(inNodeMajor, inNodeMinor, inKey)
     {
-        N.Step(inNodeMajor, inKey, true ).push(inNodeMinor);
-        N.Step(inNodeMinor, inKey, false).push(inNodeMajor);
+        N.Step(inNodeMajor, inKey, true, true).push(inNodeMinor);
+        N.Step(inNodeMinor, inKey, false, true).push(inNodeMajor);
     },
     Disconnect(inNodeMajor, inNodeMinor, inKey)
     {
@@ -99,6 +91,23 @@ var N =
             remove(inNodeMinor.Link[inKey].Get, inNodeMajor);
         }
 
+    },
+    Step(inNode, inKey, inForward, inForceCreate)
+    {
+        let connectionGroup = inNode.Link[inKey];
+        if(!connectionGroup)
+        {
+            if(inForceCreate)
+            {
+                inNode.Link[inKey] = connectionGroup = {Get:[], Set:[]};
+            }
+            else
+            {
+                return false;
+            }
+        }
+        return (inForward === undefined || inForward === true) ? connectionGroup.Set : connectionGroup.Get;
+        
     },
     Walk(inIterator, inNode, inKey, inForward)
     {
@@ -116,9 +125,21 @@ var N =
                 }
             }
         }
+    },
+    Path(inArray, inNode, inKey, inForward)
+    {
+        var current = inNode;
+        var direction = inForward||true;
+        for(let i=0; i<inArray.length; i++)
+        {
+            current = N.Step(current, inKey, direction)[inArray[i]];
+        }
+        return current;
     }
 };
+</script>
 
+<script>
 `
 A     C
  \   / \
@@ -133,11 +154,12 @@ N.Connect(a, b, "parent");
 N.Connect(c, b, "parent");
 N.Connect(c, d, "parent");
 N.Disconnect(a, null, "parent");
+/*
 console.log(a.Link);
 console.log(b.Link);
 console.log(c.Link);
 console.log(d.Link);
-
+*/
 </script>
 
 <script>
@@ -211,19 +233,23 @@ var Pivot =
     {
         N.ID.Walk++;
 
+        let modifier = N.Create({});
+
         let leaves = [];
-        let gatherUp = n => N.Connect(inNode, n, "ModifyUp");
+        let gatherUp = n => N.Connect(modifier, n, "ModifyUp");
         let gatherDown = n =>
         {
-            N.Connect(inNode, n, "ModifyDown");
+            N.Connect(modifier, n, "ModifyDown");
             N.Step(n, "Hierarchy").length == 0 ?  leaves.push(n) : null;
         };
-        let gatherOut = n => N.Connect(inNode, n, "ModifyOut");
+        let gatherOut = n => N.Connect(modifier, n, "ModifyOut");
 
         N.Walk(gatherUp, inNode, "Hierarchy", false);
-        N.Connect(inNode, inNode, "ModifyDown");
+        N.Connect(modifier, inNode, "ModifyDown");
         N.Walk(gatherDown, inNode, "Hierarchy");
         leaves.forEach(leaf=>N.Walk(gatherOut, leaf, "Hierarchy", false));
+
+        return modifier;
     },
     Unmodify(inNode)
     {
@@ -253,6 +279,10 @@ let pivotRoot1 = Pivot.Create([1, 2], [3]);
 let pivotRoot2 = Pivot.Create([2, 1], [3]);
 let pivots = [pivotRoot1, pivotRoot2];
 
+let select = N.Path([0, 1], pivotRoot1, "Hierarchy");
+let mod = Pivot.Modify(select);
+
+
 
 let Store = createContext(null);
 let StoreState = 
@@ -262,7 +292,7 @@ let StoreState =
 let StoreReducer = (inState, inAction) =>
 {
 
-}
+};
 
 let ElNode = ({node}) =>
 {
@@ -270,12 +300,27 @@ let ElNode = ({node}) =>
     var children = [];
     var table = [];
 
+    let styles = {
+    };
+    if(node.Link["ModifyOut"])
+    {
+        styles.backgroundColor = "lightgrey";
+    }
+    if(node.Link["ModifyDown"])
+    {
+        styles.backgroundColor = "yellow";
+    }
+    if(node.Link["ModifyUp"])
+    {
+        styles.backgroundColor = "lavender";
+    }
+
     if(node.Meta.Row)
     {
         table = node.Meta.Row.map( cell => h("span", {style:{padding:"10px"}}, cell));
     }
     children =  [
-        h("strong", null, node.Meta.Label||"a node"),
+        h("strong", {style:styles}, node.Meta.Label||"a node"),
         ...table,
         h(Store.Consumer, null, value=>
         {

From 005ff073e40a90cf80bbe66207de7651eee500ed Mon Sep 17 00:00:00 2001
From: SethTrowbridge <TreetopFlyer>
Date: Wed, 12 May 2021 07:17:08 -0400
Subject: [PATCH 10/16] table layout

---
 index.html | 86 ++++++++++++++++++++++++++++++++----------------------
 1 file changed, 51 insertions(+), 35 deletions(-)

diff --git a/index.html b/index.html
index 16b3fd6..d273b74 100644
--- a/index.html
+++ b/index.html
@@ -166,7 +166,6 @@ console.log(d.Link);
 var Pivot = 
 {
     Leaves:{},
-    Root:{},
     
     Init(inRows)
     {
@@ -245,7 +244,7 @@ var Pivot =
         let gatherOut = n => N.Connect(modifier, n, "ModifyOut");
 
         N.Walk(gatherUp, inNode, "Hierarchy", false);
-        N.Connect(modifier, inNode, "ModifyDown");
+        N.Connect(modifier, inNode, "ModifyAt");
         N.Walk(gatherDown, inNode, "Hierarchy");
         leaves.forEach(leaf=>N.Walk(gatherOut, leaf, "Hierarchy", false));
 
@@ -294,53 +293,70 @@ let StoreReducer = (inState, inAction) =>
 
 };
 
-let ElNode = ({node}) =>
+let ElNode = ({node, depth}) =>
 {
-    var nodeChildren = N.Step(node, "Hierarchy");
-    var children = [];
-    var table = [];
+    var color;
 
-    let styles = {
-    };
-    if(node.Link["ModifyOut"])
+    if(N.Step(node, "ModifyDown"))
     {
-        styles.backgroundColor = "lightgrey";
+        color = `yellow`;
     }
-    if(node.Link["ModifyDown"])
+    if(N.Step(node, "ModifyUp"))
     {
-        styles.backgroundColor = "yellow";
+        color = `skyblue`;
     }
-    if(node.Link["ModifyUp"])
+    if(N.Step(node, "ModifyOut"))
     {
-        styles.backgroundColor = "lavender";
+        color = `lightgrey`;
+    }
+    if(N.Step(node, "ModifyAt"))
+    {
+        color = `red`;
     }
 
-    if(node.Meta.Row)
-    {
-        table = node.Meta.Row.map( cell => h("span", {style:{padding:"10px"}}, cell));
-    }
-    children =  [
-        h("strong", {style:styles}, node.Meta.Label||"a node"),
-        ...table,
-        h(Store.Consumer, null, value=>
+    let nodeBase = css`
+        position:relative;
+        padding:0;
+        margin:0;
+        border-top:1px solid lightgrey;
+
+        .Label
         {
-            return value.get.count;
-        })
-    ];
+            display:inline-block;
+            width:200px;
+            background:${color};
+        }
+        .Label::before
+        {
+            content:" ";
+            display:inline-block;
+            width:${depth*15}px;
+        }
+        .Table
+        {
+            display:inline-block;
+            text-align:right;
+        }
+        .Cell
+        {
+            width:50px;
+            display:inline-block;
+            padding:10px;
+        }
+    `;
 
-    if(nodeChildren.length)
-    {
-        children = [
-            ...children,
-            ...nodeChildren.map( inChild => h(ElNode, {node:inChild}))
-        ];
-    }
-    return h("div", {style:{padding:"10px"}}, children);
+    return h("div", {className:css(nodeBase)}, [
+        h("div", {className:"Upper"}, [
+            h("div", {className:"Label"}, (node.Meta.Label || "a node") ),
+            h("div", {className:"Table"}, (node.Meta.Row || []).map( cell => h("div", {className:"Cell"}, cell)) )
+        ]),
+        h("div", {className:"Nodes"}, N.Step(node, "Hierarchy").map(child=>h(ElNode, {node:child, depth:depth+1})) )
+    ]);
 }
 let ElPivot = ({pivot}) =>
 {
-    return h("div", {style:{display:"inline-block"}}, [
-        h(ElNode, {node:pivot})
+    return h("div", {style:{display:"inline-block", width:"500px"}}, [
+        h(ElNode, {node:pivot, depth:0})
     ]);
 }
 let ElRoot = ({pivots}) =>

From 3fbf0673d2fb34be9362ad90873561b5d360f6d6 Mon Sep 17 00:00:00 2001
From: SethTrowbridge <TreetopFlyer>
Date: Wed, 12 May 2021 19:08:52 -0400
Subject: [PATCH 11/16] correct summation / rendering

---
 index.html | 31 +++++++++++++++++++------------
 1 file changed, 19 insertions(+), 12 deletions(-)

diff --git a/index.html b/index.html
index d273b74..499c231 100644
--- a/index.html
+++ b/index.html
@@ -172,7 +172,7 @@ var Pivot =
         Pivot.Leaves = inRows.map(r => N.Create({Row:r}));
         Pivot.Init = ()=>{};
     },
-    Pivot(inParent, inColumnIndicies, inSumIndicies, inDepth)
+    Pivot(inParent, inPivotIndicies, inSumIndicies, inDepth)
     {
         //arguments:
         //    - a Node with leaf Nodes temporarily stored in its Meta.Leaves
@@ -185,14 +185,21 @@ var Pivot =
         inParent.Meta.Leaves.forEach((inLeaf)=>
         {
             let row = inLeaf.Meta.Row; // shorthand for the raw "CSV" row in the leaf Node's Meta
-            let value = row[inColumnIndicies[depth]]; // get the pivot column
+            let value = row[inPivotIndicies[depth]]; // get the pivot column
             let match = uniques[value]; // check in the uniques list if this pivot column exists
             if(!match)
             {
                 // if not, store a value under that key that will be the meta object for a new child
+
+                let clone = row.map(r=>null);
+                inSumIndicies.forEach((inSumIndex, inIndex, inArray)=>
+                {
+                    clone[inSumIndex] = row[inSumIndex]
+                });
+
                 match = uniques[value] = {
                     Label:value,
-                    Row:inSumIndicies.map((inColumnIndex, inIndex, inArray) => row[inColumnIndex]), // create a Meta.Row also on the new child nodes to store summed totals
+                    Row:clone, 
                     Leaves:[]
                 };
                 // grow a child off of the parent using the meta object
@@ -201,7 +208,7 @@ var Pivot =
             else
             {
                 // if a match does exist, sum the appropriate columns
-                inSumIndicies.forEach((inColumnIndex, inIndex, inArray) => match.Row[inIndex] += row[inColumnIndex]);
+                inSumIndicies.forEach((inSumIndex) => match.Row[inSumIndex] += row[inSumIndex]);
             }
             // move the leaves into the child
             match.Leaves.push(inLeaf);
@@ -209,7 +216,7 @@ var Pivot =
         
         delete inParent.Meta.Leaves;
         var iterator;
-        if(depth >= inColumnIndicies.length-1)
+        if(depth >= inPivotIndicies.length-1)
         {
             iterator = inChild =>
             {
@@ -219,14 +226,14 @@ var Pivot =
         }
         else
         {
-            iterator = child => Pivot.Pivot(child, inColumnIndicies, inSumIndicies, depth+1);
+            iterator = child => Pivot.Pivot(child, inPivotIndicies, inSumIndicies, depth+1);
         }
         N.Step(inParent, "Hierarchy").forEach(iterator);
         return inParent;
     },
-    Create(inColumnIndicies, inSumIndicies)
+    Create(inPivotIndicies, inSumIndicies)
     {
-        return Pivot.Pivot(N.Create({Leaves:Pivot.Leaves}), inColumnIndicies, inSumIndicies);
+        return Pivot.Pivot(N.Create({Leaves:Pivot.Leaves}), inPivotIndicies, inSumIndicies);
     },
     Modify(inNode)
     {
@@ -320,13 +327,13 @@ let ElNode = ({node, depth}) =>
         margin:0;
         border-top:1px solid lightgrey;
 
-        .Label
+        & > .Label
         {
             display:inline-block;
             width:200px;
             background:${color};
         }
-        .Label::before
+        & > .Label::before
         {
             content:" ";
             display:inline-block;
@@ -345,8 +352,8 @@ let ElNode = ({node, depth}) =>
         }
     `;
 
-    return h("div", {className:css(nodeBase)}, [
-        h("div", {className:"Upper"}, [
+    return h("div", {className:"Node"}, [
+        h("div", {className:cx(css(nodeBase), "Upper")}, [
             h("div", {className:"Label"}, (node.Meta.Label || "a node") ),
             h("div", {className:"Table"}, (node.Meta.Row || []).map( cell => h("div", {className:"Cell"}, cell)) )
         ]),

From a64119c6663649e04a17e08e186abee8153d34b2 Mon Sep 17 00:00:00 2001
From: SethTrowbridge <TreetopFlyer>
Date: Thu, 13 May 2021 19:54:42 -0400
Subject: [PATCH 12/16] directional icon system

---
 index.html | 119 ++++++++++++++++++++++++++---------------------------
 1 file changed, 58 insertions(+), 61 deletions(-)

diff --git a/index.html b/index.html
index 499c231..de788dc 100644
--- a/index.html
+++ b/index.html
@@ -114,6 +114,7 @@ var N =
         let array = N.Step(inNode, inKey, inForward);
         for(let i=0; i<array.length; i++)
         {
+
             let next = array[i];
             if(next.ID.Walk !== N.ID.Walk)
             {
@@ -237,25 +238,32 @@ var Pivot =
     },
     Modify(inNode)
     {
-        N.ID.Walk++;
-
-        let modifier = N.Create({});
-
+        let modified = N.Create({});
         let leaves = [];
-        let gatherUp = n => N.Connect(modifier, n, "ModifyUp");
+
+        let gatherUp = n => 
+        {
+            N.Connect(modified, n, "ModifyUp");
+        };
         let gatherDown = n =>
         {
-            N.Connect(modifier, n, "ModifyDown");
+            N.Connect(modified, n, "ModifyDown");
             N.Step(n, "Hierarchy").length == 0 ?  leaves.push(n) : null;
         };
-        let gatherOut = n => N.Connect(modifier, n, "ModifyOut");
+        let gatherOut = n => 
+        {
+            N.Connect(modified, n, "ModifyOut");
+        };
+
+        N.ID.Walk++;
+        inNode.ID.Walk = N.ID.Walk;
+        N.Connect(modified, inNode, "ModifyAt");
 
         N.Walk(gatherUp, inNode, "Hierarchy", false);
-        N.Connect(modifier, inNode, "ModifyAt");
         N.Walk(gatherDown, inNode, "Hierarchy");
         leaves.forEach(leaf=>N.Walk(gatherOut, leaf, "Hierarchy", false));
 
-        return modifier;
+        return modified;
     },
     Unmodify(inNode)
     {
@@ -289,56 +297,14 @@ let select = N.Path([0, 1], pivotRoot1, "Hierarchy");
 let mod = Pivot.Modify(select);
 
 
-
-let Store = createContext(null);
-let StoreState = 
-{
-    count:7
-};
-let StoreReducer = (inState, inAction) =>
-{
-
-};
-
 let ElNode = ({node, depth}) =>
 {
-    var color;
-
-    if(N.Step(node, "ModifyDown"))
-    {
-        color = `yellow`;
-    }
-    if(N.Step(node, "ModifyUp"))
-    {
-        color = `skyblue`;
-    }
-    if(N.Step(node, "ModifyOut"))
-    {
-        color = `lightgrey`;
-    }
-    if(N.Step(node, "ModifyAt"))
-    {
-        color = `red`;
-    }
-
     let nodeBase = css`
         position:relative;
         padding:0;
         margin:0;
         border-top:1px solid lightgrey;
 
-        & > .Label
-        {
-            display:inline-block;
-            width:200px;
-            background:${color};
-        }
-        & > .Label::before
-        {
-            content:" ";
-            display:inline-block;
-            width:${depth*15}px;
-        }
         .Table
         {
             display:inline-block;
@@ -351,10 +317,45 @@ let ElNode = ({node, depth}) =>
             padding:10px;
         }
     `;
+    let label = css`
+        display:inline-block;
+        width:200px;
+
+        &::before
+        {
+            content:" ";
+            display:inline-block;
+            width:${depth*15}px;
+        }
+        .Modify
+        {
+            float:right;
+        }
+    `;
+
+    let mCombined = cx(
+        css`
+            display:inline-block;
+            width:0px;
+            height:0px;
+            border:7px solid white;
+        `,
+        {
+            [css`border-bottom-color:lightblue;`]: N.Step(node, "ModifyUp"  ),
+            [css`border-top-color:orange;`      ]: N.Step(node, "ModifyDown"),
+            [css`border-left-color:grey;`       ]: N.Step(node, "ModifyOut" ),
+            [css`border-right-color:red;`       ]: N.Step(node, "ModifyAt"  )
+        },
+    );
 
     return h("div", {className:"Node"}, [
-        h("div", {className:cx(css(nodeBase), "Upper")}, [
-            h("div", {className:"Label"}, (node.Meta.Label || "a node") ),
+        h("div", {className:cx(nodeBase, "Upper")}, [
+            h("div", {className:label}, [
+                h("span", {className:"Icon Expand"}, "+"),
+                h("span", {className:"Name"}, (node.Meta.Label || "a node")+" "+node.ID.Walk),
+                h("span", {className:mCombined}),
+                h("span", {className:"Icon Modify"}, "Modify")
+            ] ),
             h("div", {className:"Table"}, (node.Meta.Row || []).map( cell => h("div", {className:"Cell"}, cell)) )
         ]),
         h("div", {className:"Nodes"}, N.Step(node, "Hierarchy").map(child=>h(ElNode, {node:child, depth:depth+1})) )
@@ -368,14 +369,10 @@ let ElPivot = ({pivot}) =>
 }
 let ElRoot = ({pivots}) =>
 {
-    let [get, set] = useReducer(StoreReducer, StoreState);
-
-    return h(Store.Provider, {value:{get, set}}, [
-        h("div", null, [
-            h("h3", null, "tree view"),
-            ...pivots.map(pivot=>h(ElPivot, {pivot}))
-        ])
-    ]);
+    return h("div", null, [
+        h("h3", null, "tree view"),
+        ...pivots.map(pivot=>h(ElPivot, {pivot}))
+    ])
 };
 render(h(ElRoot, {pivots}, null), document.querySelector("#app"));
 

From c807b450c4d618670b206fa23e0041ba0520e1f8 Mon Sep 17 00:00:00 2001
From: SethTrowbridge <TreetopFlyer>
Date: Fri, 14 May 2021 06:47:30 -0400
Subject: [PATCH 13/16] modification add/remove

---
 index.html | 59 ++++++++++++++++++++++++++++++++++++++----------------
 1 file changed, 42 insertions(+), 17 deletions(-)

diff --git a/index.html b/index.html
index de788dc..a349f09 100644
--- a/index.html
+++ b/index.html
@@ -267,16 +267,21 @@ var Pivot =
     },
     Unmodify(inNode)
     {
-        N.Disconnect(inNode, null, "ModifyUp");
-        N.Disconnect(inNode, null, "ModifyDown");
-        N.Disconnect(inNode, null, "ModifyOut");
+        let modifier = N.Step(inNode, "ModifyAt", false)[0];
+        console.log(modifier);
+
+        
+        N.Disconnect(modifier, null, "ModifyUp");
+        N.Disconnect(modifier, null, "ModifyDown");
+        N.Disconnect(modifier, null, "ModifyOut");
+        N.Disconnect(modifier, null, "ModifyAt");
     }
 };
 </script>
 
 <script type="module">
 
-import {h, render, createContext} from 'https://cdn.skypack.dev/preact';
+import {h, render, createContext, Fragment} from 'https://cdn.skypack.dev/preact';
 import {useReducer} from 'https://cdn.skypack.dev/preact/hooks';
 import { css, cx } from 'https://cdn.skypack.dev/@emotion/css';
 
@@ -293,8 +298,10 @@ let pivotRoot1 = Pivot.Create([1, 2], [3]);
 let pivotRoot2 = Pivot.Create([2, 1], [3]);
 let pivots = [pivotRoot1, pivotRoot2];
 
+/*
 let select = N.Path([0, 1], pivotRoot1, "Hierarchy");
 let mod = Pivot.Modify(select);
+*/
 
 
 let ElNode = ({node, depth}) =>
@@ -333,14 +340,13 @@ let ElNode = ({node, depth}) =>
         }
     `;
 
-    let mCombined = cx(
-        css`
-            display:inline-block;
-            width:0px;
-            height:0px;
-            border:7px solid white;
-        `,
+    let icon = cx(
         {
+            [css`
+                display:inline-block;
+                width:0px;
+                height:0px;
+                border:7px solid white;`        ]: true,
             [css`border-bottom-color:lightblue;`]: N.Step(node, "ModifyUp"  ),
             [css`border-top-color:orange;`      ]: N.Step(node, "ModifyDown"),
             [css`border-left-color:grey;`       ]: N.Step(node, "ModifyOut" ),
@@ -348,32 +354,51 @@ let ElNode = ({node, depth}) =>
         },
     );
 
+    let buttonModify = h("span", {
+        className:"Icon Modify Add",
+        onClick:e=>
+        {
+            Pivot.Modify(node);
+            Render();
+        }
+    }, "Modify");
+
+    let buttonUnmodify = h("span", {
+        className:"Icon Modify remove",
+        onClick:e=>
+        {
+            Pivot.Unmodify(node);
+            Render();
+        }
+    }, "Unmodify");
+
     return h("div", {className:"Node"}, [
         h("div", {className:cx(nodeBase, "Upper")}, [
             h("div", {className:label}, [
                 h("span", {className:"Icon Expand"}, "+"),
                 h("span", {className:"Name"}, (node.Meta.Label || "a node")+" "+node.ID.Walk),
-                h("span", {className:mCombined}),
-                h("span", {className:"Icon Modify"}, "Modify")
+                h("span", {className: icon}),
+                N.Step(node, "ModifyAt") ? buttonUnmodify : buttonModify
             ] ),
             h("div", {className:"Table"}, (node.Meta.Row || []).map( cell => h("div", {className:"Cell"}, cell)) )
         ]),
         h("div", {className:"Nodes"}, N.Step(node, "Hierarchy").map(child=>h(ElNode, {node:child, depth:depth+1})) )
     ]);
-}
+};
 let ElPivot = ({pivot}) =>
 {
     return h("div", {style:{display:"inline-block", width:"500px"}}, [
         h(ElNode, {node:pivot, depth:0})
     ]);
-}
-let ElRoot = ({pivots}) =>
+};
+let ElRoot = props =>
 {
     return h("div", null, [
         h("h3", null, "tree view"),
         ...pivots.map(pivot=>h(ElPivot, {pivot}))
     ])
 };
-render(h(ElRoot, {pivots}, null), document.querySelector("#app"));
+let Render = () => render(h(ElRoot), document.querySelector("#app"));
+Render();
 
 </script>

From 437a56221abe6cf6c15767d26483223579e948e9 Mon Sep 17 00:00:00 2001
From: SethTrowbridge <TreetopFlyer>
Date: Fri, 14 May 2021 07:11:23 -0400
Subject: [PATCH 14/16] modifications flow into new pivots

---
 index.html | 105 +++++++++++++++++++++++++++++++++--------------------
 1 file changed, 65 insertions(+), 40 deletions(-)

diff --git a/index.html b/index.html
index a349f09..0fdb3d7 100644
--- a/index.html
+++ b/index.html
@@ -20,8 +20,19 @@ var N =
             Link:{}
         };
     },
-    Connect(inNodeMajor, inNodeMinor, inKey)
+    Connect(inNodeMajor, inNodeMinor, inKey, inUnique)
     {
+        if(inUnique) // bail if the nodes are already connected
+        {
+            let check = N.Step(inNodeMajor, inKey, true);
+            if(check)
+            {
+                if(check.indexOf(inNodeMinor) < 0)
+                {
+                    return;
+                }
+            }
+        }
         N.Step(inNodeMajor, inKey, true, true).push(inNodeMinor);
         N.Step(inNodeMinor, inKey, false, true).push(inNodeMajor);
     },
@@ -31,7 +42,9 @@ var N =
 
         if(inNodeMinor === null)
         {
-            inNodeMajor.Link[inKey].Set.forEach( inLoopNode => 
+            let check = N.Step(inNodeMajor, inKey);
+            if(!check){ return; }
+            check.forEach( inLoopNode => 
             {
                 if(inLoopNode.Link[inKey].Get.length == 1)
                 {
@@ -140,29 +153,6 @@ var N =
 };
 </script>
 
-<script>
-`
-A     C
- \   / \
-  \ /   \
-   B     D
-`
-let a = N.Create({name:"A"});
-let b = N.Create({name:"B"});
-let c = N.Create({name:"C"});
-let d = N.Create({name:"D"});
-N.Connect(a, b, "parent");
-N.Connect(c, b, "parent");
-N.Connect(c, d, "parent");
-N.Disconnect(a, null, "parent");
-/*
-console.log(a.Link);
-console.log(b.Link);
-console.log(c.Link);
-console.log(d.Link);
-*/
-</script>
-
 <script>
 var Pivot = 
 {
@@ -197,7 +187,6 @@ var Pivot =
                 {
                     clone[inSumIndex] = row[inSumIndex]
                 });
-
                 match = uniques[value] = {
                     Label:value,
                     Row:clone, 
@@ -219,10 +208,41 @@ var Pivot =
         var iterator;
         if(depth >= inPivotIndicies.length-1)
         {
-            iterator = inChild =>
+            iterator = inLastBranch =>
             {
-                inChild.Meta.Leaves.forEach( inLeaf => N.Connect(inChild, inLeaf, "Hierarchy") );
-                delete inChild.Meta.Leaves;
+                inLastBranch.Meta.Leaves.forEach( inLeaf =>
+                {
+                    // collect modifiers effecting leaves
+                    let modifiers = [];
+                    let check = N.Step(inLeaf, "ModifyAt", false);
+                    if(check)
+                    {
+                        modifiers = modifiers.concat(check);
+                    }
+                    check = N.Step(inLeaf, "ModifyDown", false);
+                    if(check)
+                    {
+                        modifiers = modifiers.concat(check);
+                    }
+
+                    if(modifiers.length)
+                    {
+                        // apply them to the branch
+                        inLastBranch.ID.Walk = N.ID.Walk;
+                        modifiers.forEach( inModifier => N.Connect(inModifier, inLastBranch, "ModifyUp") )
+
+                        // also walk them up, but with a unique check connection
+                        N.Walk( inNode=>
+                        {
+                            modifiers.forEach( inModifier => N.Connect(inModifier, inNode, "ModifyUp", true) )
+                        }
+                        , inLastBranch, "Hierarchy", false);
+                    }
+
+                    // lastly connect the leaf to the branch
+                    N.Connect(inLastBranch, inLeaf, "Hierarchy");
+                });
+                delete inLastBranch.Meta.Leaves;
             }
         }
         else
@@ -234,6 +254,7 @@ var Pivot =
     },
     Create(inPivotIndicies, inSumIndicies)
     {
+        N.ID.Walk++;
         return Pivot.Pivot(N.Create({Leaves:Pivot.Leaves}), inPivotIndicies, inSumIndicies);
     },
     Modify(inNode)
@@ -268,9 +289,7 @@ var Pivot =
     Unmodify(inNode)
     {
         let modifier = N.Step(inNode, "ModifyAt", false)[0];
-        console.log(modifier);
 
-        
         N.Disconnect(modifier, null, "ModifyUp");
         N.Disconnect(modifier, null, "ModifyDown");
         N.Disconnect(modifier, null, "ModifyOut");
@@ -281,8 +300,8 @@ var Pivot =
 
 <script type="module">
 
-import {h, render, createContext, Fragment} from 'https://cdn.skypack.dev/preact';
-import {useReducer} from 'https://cdn.skypack.dev/preact/hooks';
+import { h, render, createContext, Fragment } from 'https://cdn.skypack.dev/preact';
+import { useReducer } from 'https://cdn.skypack.dev/preact/hooks';
 import { css, cx } from 'https://cdn.skypack.dev/@emotion/css';
 
 Pivot.Init([
@@ -295,14 +314,14 @@ Pivot.Init([
     ["#7", "b", "short", 7],
 ]);
 let pivotRoot1 = Pivot.Create([1, 2], [3]);
-let pivotRoot2 = Pivot.Create([2, 1], [3]);
-let pivots = [pivotRoot1, pivotRoot2];
-
-/*
-let select = N.Path([0, 1], pivotRoot1, "Hierarchy");
-let mod = Pivot.Modify(select);
-*/
+//let pivotRoot2 = Pivot.Create([2, 1], [3]);
+//let pivots = [pivotRoot1, pivotRoot2];
+let pivots = [pivotRoot1];
 
+let AddNewPivot = () =>
+{
+    pivots.push(Pivot.Create([2, 1], [3]));
+}
 
 let ElNode = ({node, depth}) =>
 {
@@ -395,6 +414,12 @@ let ElRoot = props =>
 {
     return h("div", null, [
         h("h3", null, "tree view"),
+        h("button", { onClick:e=>
+        {
+            AddNewPivot();
+            Render();
+        }
+        }, "add new pivot"),
         ...pivots.map(pivot=>h(ElPivot, {pivot}))
     ])
 };

From c30c20e8b2f4a584c0b2a12d3eca451408357fa4 Mon Sep 17 00:00:00 2001
From: SethTrowbridge <TreetopFlyer>
Date: Sat, 15 May 2021 07:30:52 -0400
Subject: [PATCH 15/16] app-as-graph

---
 index.html | 87 +++++++++++++++++++++++++++++++++++++++---------------
 1 file changed, 64 insertions(+), 23 deletions(-)

diff --git a/index.html b/index.html
index 0fdb3d7..49e492e 100644
--- a/index.html
+++ b/index.html
@@ -122,12 +122,17 @@ var N =
         return (inForward === undefined || inForward === true) ? connectionGroup.Set : connectionGroup.Get;
         
     },
-    Walk(inIterator, inNode, inKey, inForward)
+    Walk(inIterator, inNode, inKey, inForward, inTerminal)
     {
         let array = N.Step(inNode, inKey, inForward);
+
+        if(!array.length && inTerminal)
+        {
+            return inTerminal(inNode);
+        }
+
         for(let i=0; i<array.length; i++)
         {
-
             let next = array[i];
             if(next.ID.Walk !== N.ID.Walk)
             {
@@ -135,7 +140,7 @@ var N =
                 let results = inIterator(next);
                 if(results !== false)
                 {
-                    N.Walk(inIterator, next, inKey, inForward);
+                    N.Walk(inIterator, next, inKey, inForward, inTerminal);
                 }
             }
         }
@@ -157,7 +162,8 @@ var N =
 var Pivot = 
 {
     Leaves:{},
-    
+    Root:N.Create({}),
+
     Init(inRows)
     {
         Pivot.Leaves = inRows.map(r => N.Create({Row:r}));
@@ -255,26 +261,47 @@ var Pivot =
     Create(inPivotIndicies, inSumIndicies)
     {
         N.ID.Walk++;
-        return Pivot.Pivot(N.Create({Leaves:Pivot.Leaves}), inPivotIndicies, inSumIndicies);
+        
+        let pivotRoot = N.Create({Leaves:Pivot.Leaves});
+        N.Connect(Pivot.Root, pivotRoot, "Pivot");
+        return Pivot.Pivot(pivotRoot, inPivotIndicies, inSumIndicies);
+    },
+    Delete(inRoot)
+    {
+        N.ID.Walk++;
+
+        let scan = n =>
+        {
+
+        };
+
+        N.Walk(scan, inRoot, "Hierarchy")
     },
     Modify(inNode)
     {
         let modified = N.Create({});
-        let leaves = [];
-
-        let gatherUp = n => 
+        N.ID.Walk++;
+        if(N.Step(inNode, "Hierarchy").length)
         {
-            N.Connect(modified, n, "ModifyUp");
-        };
+            N.Walk(()=>{}, inNode, "Hierarchy", false, (inRoot)=>
+            {
+                N.Connect(inRoot, modified, "Modifier");
+            });
+        }
+        else
+        {
+
+            N.Connect(Pivot.Root, modified, "Modifier");
+        }
+
+        let leaves = [];
+        let gatherUp = n => N.Connect(modified, n, "ModifyUp");
         let gatherDown = n =>
         {
             N.Connect(modified, n, "ModifyDown");
             N.Step(n, "Hierarchy").length == 0 ?  leaves.push(n) : null;
         };
-        let gatherOut = n => 
-        {
-            N.Connect(modified, n, "ModifyOut");
-        };
+        let gatherOut = n => N.Connect(modified, n, "ModifyOut");
 
         N.ID.Walk++;
         inNode.ID.Walk = N.ID.Walk;
@@ -294,6 +321,7 @@ var Pivot =
         N.Disconnect(modifier, null, "ModifyDown");
         N.Disconnect(modifier, null, "ModifyOut");
         N.Disconnect(modifier, null, "ModifyAt");
+        N.Disconnect(null, modifier, "Modifier");
     }
 };
 </script>
@@ -313,15 +341,13 @@ Pivot.Init([
     ["#6", "a", "short", 0],
     ["#7", "b", "short", 7],
 ]);
-let pivotRoot1 = Pivot.Create([1, 2], [3]);
-//let pivotRoot2 = Pivot.Create([2, 1], [3]);
-//let pivots = [pivotRoot1, pivotRoot2];
-let pivots = [pivotRoot1];
+Pivot.Create([1, 2], [3]);
 
 let AddNewPivot = () =>
 {
-    pivots.push(Pivot.Create([2, 1], [3]));
-}
+    Pivot.Create([2], [3]);
+    Render();
+};
 
 let ElNode = ({node, depth}) =>
 {
@@ -405,22 +431,37 @@ let ElNode = ({node, depth}) =>
     ]);
 };
 let ElPivot = ({pivot}) =>
-{
+{   
     return h("div", {style:{display:"inline-block", width:"500px"}}, [
+        h(ElModifiers, {node:pivot}),
         h(ElNode, {node:pivot, depth:0})
     ]);
 };
+let ElModifiers = ({node}) =>
+{
+    let modifiers = N.Step(node, "Modifier") || [];
+
+    return h("div", null, [
+        h("strong", null, "modifiers"),
+        ...modifiers.map( m => h("span", {onClick:e=>
+        {
+            Pivot.Unmodify(N.Step(m, "ModifyAt")[0]);
+            Render();
+        }
+        }, "modifier"))
+    ]);
+};
 let ElRoot = props =>
 {
     return h("div", null, [
         h("h3", null, "tree view"),
+        h(ElModifiers, {node:Pivot.Root}),
         h("button", { onClick:e=>
         {
             AddNewPivot();
-            Render();
         }
         }, "add new pivot"),
-        ...pivots.map(pivot=>h(ElPivot, {pivot}))
+        ...N.Step(Pivot.Root, "Pivot").map(pivot=>h(ElPivot, {pivot}))
     ])
 };
 let Render = () => render(h(ElRoot), document.querySelector("#app"));

From 23c7c60b5b2695494d340dfffcc366b6cb080b29 Mon Sep 17 00:00:00 2001
From: SethTrowbridge <TreetopFlyer>
Date: Sat, 15 May 2021 10:47:22 -0400
Subject: [PATCH 16/16] fixed disconnect! can remove all modifiers in pivot

---
 index.html | 92 +++++++++++++++++++++++++++++-------------------------
 1 file changed, 50 insertions(+), 42 deletions(-)

diff --git a/index.html b/index.html
index 49e492e..6ebb739 100644
--- a/index.html
+++ b/index.html
@@ -40,24 +40,27 @@ var N =
     {
         let remove = (inArray, inMatch) => inArray.findIndex( (inMember, inIndex, inArray) => (inMember === inMatch) ? inArray.splice(inIndex, 1) : false );
 
+        // if no specific child was passed
         if(inNodeMinor === null)
         {
+            // get all the children
             let check = N.Step(inNodeMajor, inKey);
             if(!check){ return; }
-            check.forEach( inLoopNode => 
-            {
-                if(inLoopNode.Link[inKey].Get.length == 1)
-                {
-                    // we're about to delete the last get reference on a minor node, just purge the key entirely
-                    delete inLoopNode.Link[inKey];
-                }
-                else
-                {
-                    remove( inLoopNode.Link[inKey].Get, inNodeMajor);
-                }
 
+            // go down to each child ...
+            check.forEach( inNodeMinor => 
+            {
+                let connections = inNodeMinor.Link[inKey];
+                remove( connections.Get, inNodeMajor); // ... and remove any reference to the parent
+
+                // if after the remove operation, this child has no connections on inKey, scrub the key
+                if(!connections.Set.length && !connections.Get.length)
+                {
+                    delete inNodeMinor.Link[inKey];
+                }
             });
-            // we just wiped out all set, if get is empty we can purge the key from major
+
+            // we just wiped out all outgoing connections to the parent, if incoming connections are empty too we can purge the key there as well
             if(inNodeMajor.Link[inKey].Get.length == 0)
             {
                 delete inNodeMajor.Link[inKey];
@@ -65,20 +68,27 @@ var N =
             return;
         }
 
+        // if no specific parent was passed
         if(inNodeMajor === null)
         {
-            inNodeMinor.Link[inKey].Get.forEach( inLoopNode => 
+            // get all the parents
+            let check = N.Step(inNodeMinor, inKey, false);
+            if(!check){ return; }
+            
+            // go up to each parent ...
+            check.forEach( inNodeMajor => 
             {
-                if(inLoopNode.Link[inKey].Set.length == 1)
+                let connections = inNodeMajor.Link[inKey];
+                remove( connections.Set, inNodeMinor); // ... and remove any reference to the child
+                
+                // if after the remove operation, this parent has no connections on inKey, scrub the key
+                if( !connections.Set.length && !connections.Get.length )
                 {
-                    delete inLoopNode.Link[inKey];
-                }
-                else
-                {
-                    remove( inLoopNode.Link[inKey].Set, inNodeMinor);
+                    delete inNodeMajor.Link[inKey];
                 }
             });
-            // we just wiped out all get, if set is empty we can purge the key from minor
+
+            // we just wiped out all incoming connections to the child, if outgoing connections are empty too we can purge the key there as well
             if(inNodeMinor.Link[inKey].Set.length == 0)
             {
                 delete inNodeMinor.Link[inKey];
@@ -86,7 +96,7 @@ var N =
             return;
         }
 
-
+        // if a specific parent and child were passed
         if(inNodeMajor.Link[inKey].Set.length == 1)
         {
             delete inNodeMajor.Link[inKey];
@@ -110,7 +120,7 @@ var N =
         let connectionGroup = inNode.Link[inKey];
         if(!connectionGroup)
         {
-            if(inForceCreate)
+            if(inForceCreate === true)
             {
                 inNode.Link[inKey] = connectionGroup = {Get:[], Set:[]};
             }
@@ -262,24 +272,24 @@ var Pivot =
     {
         N.ID.Walk++;
         
-        let pivotRoot = N.Create({Leaves:Pivot.Leaves});
+        let pivotRoot = N.Create({Label:"Pivot Root", Leaves:Pivot.Leaves});
         N.Connect(Pivot.Root, pivotRoot, "Pivot");
         return Pivot.Pivot(pivotRoot, inPivotIndicies, inSumIndicies);
     },
     Delete(inRoot)
     {
-        N.ID.Walk++;
-
-        let scan = n =>
+        let check = N.Step(inRoot, "Modifier");
+        if(check)
         {
-
-        };
-
-        N.Walk(scan, inRoot, "Hierarchy")
+            while(check.length>0)
+            {
+                Pivot.Unmodify(check[0]);
+            }
+        }
     },
     Modify(inNode)
     {
-        let modified = N.Create({});
+        let modified = N.Create({Label:"Modifier"});
         N.ID.Walk++;
         if(N.Step(inNode, "Hierarchy").length)
         {
@@ -290,7 +300,6 @@ var Pivot =
         }
         else
         {
-
             N.Connect(Pivot.Root, modified, "Modifier");
         }
 
@@ -313,15 +322,13 @@ var Pivot =
 
         return modified;
     },
-    Unmodify(inNode)
+    Unmodify(inModifier)
     {
-        let modifier = N.Step(inNode, "ModifyAt", false)[0];
-
-        N.Disconnect(modifier, null, "ModifyUp");
-        N.Disconnect(modifier, null, "ModifyDown");
-        N.Disconnect(modifier, null, "ModifyOut");
-        N.Disconnect(modifier, null, "ModifyAt");
-        N.Disconnect(null, modifier, "Modifier");
+        N.Disconnect(inModifier, null, "ModifyUp");
+        N.Disconnect(inModifier, null, "ModifyDown");
+        N.Disconnect(inModifier, null, "ModifyOut");
+        N.Disconnect(inModifier, null, "ModifyAt");
+        N.Disconnect(null, inModifier, "Modifier");
     }
 };
 </script>
@@ -412,7 +419,7 @@ let ElNode = ({node, depth}) =>
         className:"Icon Modify remove",
         onClick:e=>
         {
-            Pivot.Unmodify(node);
+            Pivot.Unmodify(N.Step(node, "ModifyAt", false)[0]);
             Render();
         }
     }, "Unmodify");
@@ -433,6 +440,7 @@ let ElNode = ({node, depth}) =>
 let ElPivot = ({pivot}) =>
 {   
     return h("div", {style:{display:"inline-block", width:"500px"}}, [
+        h("button", {onClick:e=>{Pivot.Delete(pivot);Render();}}, "delete?"),
         h(ElModifiers, {node:pivot}),
         h(ElNode, {node:pivot, depth:0})
     ]);
@@ -445,7 +453,7 @@ let ElModifiers = ({node}) =>
         h("strong", null, "modifiers"),
         ...modifiers.map( m => h("span", {onClick:e=>
         {
-            Pivot.Unmodify(N.Step(m, "ModifyAt")[0]);
+            Pivot.Unmodify(m);
             Render();
         }
         }, "modifier"))