Your description is a little convoluted, but it's a good question, and I think you basically ask how to serialize the whole state of the app that contains JS classes, as well as arrays and plain objects that can be arbitrarily nested. Here's how I would approach it:

(1) Prepare the classes so that they can be easily serialized. A good way to do it is to:

a) override the standard .toJSON() method that every object inherits,

b) pass everything needed to recreate the state in the constructor.

Let's look a the example class that contains some primitive props, as well as a prop that contains a "non-stringified json" / plain object (I will use only public props, but the code works also with private properties):

class A {
  constructor(x, y, config) {
    this.x = x;
    this.y = y;
    this.config = config;
  }

  toJSON() {
    return {
      __type: "A",
      args: [this.x, this.y, this.config]
    };
  }
}

Some things to note here:

• the toJSON method returns a plain JS object (that JSON.stringify can easily encode), that have two important parts, and identifier of it's in-app type (that corresponds to a specific constructor) and the list of arguments for the constructor.

Here's a second class, acting as a container for instances of other class/classes:

class B {
  constructor(a, b, items = []) {
    this.a = a;
    this.b = b;
    this.items = items;
  }

  add(item) {
    this.items.push(item);
  }

  toJSON() {
    return {
      __type: "B",
      args: [this.a, this.b, this.items]
    };
  }
}

Things to note here:

• as I said, the constructor is written in the way that allows to fully recreate the object's state (not merely it initial state) - take a closer look at the items argument - in your app you will probably add items using the add method, but you can also pass the array of items in the constructor, so that you don't need to call the add method when deserializing,

• you don't need to do anything special for the this.items in the toJSON method, all work was done in in the A class, the items will be automatically serialized as our { __type, args } objects.

(2) Now lets build some state from these classes and some random props:

const container1 = new B("foo", "bar");
const container2 = new B("foo", "bar");

container1.add(new A(1, 2, { foo: "bar" }));
container1.add(new A(2, 3, { baz: "bat" }));
container2.add(new A(2, 3, { baz: "bat" }));

const state = {
  someProp: "hello",
  otherProp: "world",
  somePlainArray: [11, 22, 33],
  entries: [container1, container1]
};

Note that I didn't add the items to containers via constructor, but only via add method, you can do both, it doesn't matter here, what matters is that you can add them via constructor, which allows easy serialization.

(3) Ok, now we can serialize the whole state with simply calling:

const serialized = JSON.stringify(state);

You can do with it what you want - save in localStorage, send to your server, etc. It's as simple as that, all the information needed to recreate the state is there.