Hey Jason, Would you mind typing up a quick example?

I would suggest you to use EventEmitter or, it's better descendent, Streams. Let's consider your example for a bit:

class CommonEmitter extends EventEmitter {}

Then, define a constant which is used by the base class as well as any other modules using it: const emitter = new CommonEmitter();.

Once we have that, you can emit different events based on the instantiation:

class Base {
  constructor() {
    emitter.emit( 'base-init' );
  }

  computeFoos() {
    function* computeFoo( someParam ) {
      yield someParam + 1;
      yield someParam + 2; // you get the idea
    }

    emitter.emit( 'foo', computeFoo().next().value );
  }
}

In your derived class:

class Sub extends Base {
  constructor() {
    super();

    emitter.emit( 'sub-init' );
  }

  doStuff() {
    super.computeFoos();
    // you can add a listener here.
  }
 }

Then, you can use it like so:

emitter.once( 'base-init', () => {
  emitter.on( 'foo', console.log );
} );

const myObject = new Sub();
myObject.doStuff();
// do something with sub here.

This is, of course, a very simple example. Since I do not know your exact use case, I can't advice any further without some information. Regardless, I hope this helps. :)

Maybe? Ultimately, I'm wondering if subclasses could access async data of a super class. I think that would mean an asynchronous constructor but I'm not sure. Am I making sense?

Asynchronous constructor is not possible. By design, constructors should return the instance of the class so it means it cannot return a Promise object.

You could do something like this though:

class Base {

    constructor() {

        // Cannot be asynchronous

    }

    async computeFoos() {
        // Add your asynchronous code here
        return foos
    }

}

class Sub extends Base {

    constructor() {

        super()

        // Still Cannot be asynchronous

    }

}

const start = async () => {

    const obj = new Sub()
    const foos = await obj.computeFoos()

    console.log(foos)

}

start()