Nested partition data structure JavaScript

I'm trying to figure out what would be the best data structure/class for my use case.

I have several arrays (all of length n) that I want to use to create a partition. I want to be able to nest the partition at least one layer deep (hopefully will be clear from the example). I also want to be able to summarize the values of some other arrays (also of length n) with a reduce-like function, both within the inner (nested) and the outer (non-nested) partitions.

I'm thinking an API like this:

const arr1 = [1, 0, 0, 1, 1, 0, 0, 1];
const arr2 = ["A", "A", "A", "B", "C", "B", "B", "A"];
const arr3 = [100, 250, 100, 300, 150, 250, 300, 150];

const partition = Partition.from(arr2)
  .nest(arr1)
  .reduceWith({arr3}, (a, b) => a + b, 0);

partition.outer() // { "A": { arr3: 600 }, "B": { arr3: 850 }, "C": { arr3: 150 } }
partition.inner() // { "A0": { arr3: 350 }, "A1" : { arr3: 250 }, "B0": { arr3: 550 }, "B1": { arr3: 300 }, "C1": { arr3: 150 } }
  

// ^^I used strings like "A0", "B1" etc..., as keys to make things a bit clearer,
// but in practice I might use JSON strings, e.g. "{"arr2":"B","arr1":0}", 
// to make the partition ids less ambiguous

Importantly, the specific values (but not the length or unique values) of the nesting arrays will change over time, so the data structure needs to allow for reactivity (I am using Solid JS). The inner partition might change more often than the outer one, and they should only be recomputed when necessary.

Anyone has any ideas/knows of a good pattern?

You could create a class Partition (which must be instanciated with new), and define a method addLevel (corresponding to both from and nest in your suggestion) which returns the instance again for chaining, and a method reduceWith which also returns the instance.

Then what you call outer and inner would be combined in a single method produce that takes a level as argument (like 1 for outer, and 2 for inner). This is more generic, and you could even generate a grand total (without partitioning) by passing level 0 as argument.

Here it is:

<!-- begin snippet: js hide: false console: true babel: false -->

<!-- language: lang-js -->

class Partition {
constructor() {
this.levels = [];
this.values = [];
}
addLevel(level) {
this.levels.push(level);
return this;
}
reduceWith(obj, reducer) {
[this.key, this.values] = Object.entries(obj)[0];
this.reducer = reducer;
return this;
}
produce(level=1) {
const levels = this.levels.slice(0, level);
const {key} = this;
return this.values.reduce((acc, value, i) => {
const group = levels.map(level => level[i]).join("");
if (group in acc) {
acc[group][key] = this.reducer(acc[group][key], value);
} else {
acc[group] = {[key]: value};
}
return acc;
}, {});
}
}
const arr1 = [1, 0, 0, 1, 1, 0, 0, 1];
const arr2 = ["A", "A", "A", "B", "C", "B", "B", "A"];
const arr3 = [100, 250, 100, 300, 150, 250, 300, 150];
const partition = new Partition()
.addLevel(arr2)
.addLevel(arr1)
.reduceWith({arr3}, (a, b) => a + b);
console.log(partition.produce(0)); // { "": { arr3: 1600 } }
console.log(partition.produce(1)); // { "A": { arr3: 600 }, "B": { arr3: 850 }, "C": { arr3: 150 } }
console.log(partition.produce(2)); // { "A0": { arr3: 350 }, "A1" : { arr3: 250 }, "B0": { arr3: 550 }, "B1": { arr3: 300 }, "C1": { arr3: 150 } }

<!-- end snippet -->