pivot-editor/index.html

<script>
var N = {
    Create:(inMeta, ...inChildren) =>
    {
        var output = {
            Meta:inMeta,

            Children:[],
            Parents:[],
            /*
            WalkID:0,

            GetUpward:[],
            GetDownward:[],
            GetOutside:[],

            SetUpward:[],
            SetDownward:[],
            SetOutside:[]
            */
        };
        inChildren.forEach( inChild => N.Connect(output, "Children", inChild, "Parents") );
        return output;
    },
    Connect:(inParent, inParentRefs, inChild, inChildRefs) =>
    {
        inParent[inParentRefs].push(inChild);
        inChild[inChildRefs].push(inParent);
    },
    Disconnect:(inParent, inParentRefs, inChild, inChildRefs) =>
    {
        let checkRemove = (inArray, inMember) =>
        {
            inArray.findIndex( (inMember, inIndex, inArray) => (inMember === match) ? inArray.splice(inIndex, 1) : false );
        };
        checkRemove(inParent[inParentRefs], inChild);
        checkRemove(inChild[inChildRefs], inParent);
    },
    Walk:(inNode, inKey, inIterator, inWalkID) =>
    {
        let array = inNode[inKey];
        for(let i=0; i<array.length; i++)
        {
            let next = array[i];
            if(next.WalkID !== inWalkID)
            {
                next.WalkID = inWalkID;
                let results = inIterator(next);
                if(results !== false)
                {
                    N.Walk(next, inKey, inIterator, inWalkID);
                }
            }
        }
    },
    Modify(inNode)
    {
        inNode.WalkID = "tweak-"+Math.random();

        let leaves = [];
        let gatherUp = n => N.Connect(inNode, "SetUpward", n, "GetUpward");
        let gatherDown = n =>
        {
            N.Connect(inNode, "SetDownward", n, "GetDownward");
            n.Children.length == 0 ?  leaves.push(n) : null;
        };
        let gatherOut = n => N.Connect(inNode, "SetOutside", n, "GetOutside");

        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));
    }
    // delete modify
    // 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) =>
{
    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", 
        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>
-->