We define the subtype relationships between Employee and Person, as well as between Author and Person, with extends. For instance, in m/Employee.js we define:

EmployeeCategoryEL =  new Enumeration(["Manager"]);

class Employee extends Person {
  constructor ({personId, name, empNo, category, department}) {
    super({personId, name});
    this.empNo = empNo;
    if (category) this.category = category;
    if (department) this.department = department;
  }
  ...
}

When retrieving the instances of a class hierarchy's root class (in our example, Person) from a persistent data store organized according to the TCI approach, we have to retrieve not only its direct instances from the table representing the root class (people), but also all indirect instances from all tables representing its subclasses (employees and authors), as shown in the following code:

Person.retrieveAll = function () {
  var people={}, employees={}, authors={};
  if (!localStorage["authors"]) localStorage["authors"] = "{}";
  if (!localStorage["employees"]) localStorage["employees"] = "{}";
  if (!localStorage["people"]) localStorage["people"] = "{}";
  try {
    people = JSON.parse( localStorage["people"]);
    employees = JSON.parse( localStorage["employees"]);
    authors = JSON.parse( localStorage["authors"]);
  } catch (e) {
    console.log("Error when reading from Local Storage\n" + e);
  }
  for (let key of Object.keys( authors)) {
    try {  // convert record to (typed) object
      Author.instances[key] = new Author( authors[key]);
      // create superclass extension
      Person.instances[key] = Author.instances[key];
    } catch (e) {
      console.log(`${e.constructor.name} while deserializing` +
          `author ${key}: ${e.message}`);
    }
  }
  ...
}

Each record of the authors table is retrieved and converted to an Author object, a reference to which is copied to Person.instances. Also the records of the employees table are processed in this way, while the records of the people table are simply retrieved and converted to Person objects:

Person.retrieveAll = function () {
  ...
  for (let key of Object.keys( employees)) {
    ...
  }
  for (let key of Object.keys( people)) {
    try {  // convert record to (typed) object
      Person.instances[key] = new Person( people[key]);
    } catch (e) {
      console.log(`${e.constructor.name} while deserializing` +
          `author ${key}: ${e.message}`);
    }
  }
}

Since the app's data is kept in main memory as long as the app is running (which is as long as the app's webpage is kept open in the browser), the data has to be saved to persistent storage when the app is exited (e.g., by closing its browser tab), When saving the instances of Employee and Author (as records of the JS entity tables employees and authors) to persistent storage in pl.v.employees.manage.exit and pl.v.authors.manage.exit, we also save the direct instances of Person (as records of the people table). This is necessary because changes to Employee or Author instances may imply changes of Person.instances.

For instance, for Employee data management, we define in v/employees.js:

pl.v.employees.manage = {
  ...
  exit: function () {
    Employee.saveAll();
    Person.saveAll();
  },
  ...
}