Dynamic typing of child of abstract class

Question

I have an abstract class defined statically and an implementation of it retrieved dynamically Ie

export abstract class Foo {
   abstract get();
}

const dynamicClass: typeof Foo = ( function() {
    return class Bar {
        get: function() {
            console.log('get');
        }

       constructor() {
         super();
         console.log('cons');
       }
    }
}();

This is working fine exept one thing : I cannot call the constructor without "cheating" IE new Bar() output cannot instantiate abstract class I have resolved that by doing

// @ts-ignore new Bar();

But I feel i could do better.

The whole usecase for that is that the funciton that create the class at runtime will act differently based on the system it is (dynamiccally loading extra libraries that i removed for the sake of simplicity)

Answer 1

The easiest thing you can do is to not use an explicit type annotation, let the compiler infer what it will for dynamicClass:

export abstract class Foo {
   abstract get(): void;
}

const dynamicClass = (function() {
    return class Bar extends Foo {
        get() {
            console.log('get');
        }

       constructor() {
         super();
         console.log('cons');
       }
    }
})();

new dynamicClass();

Playground Link

If you want to go the explicit route you can use a constructor signature that returns Foo, this should mostly remove the abstarctness of the constructor:

export abstract class Foo {
   abstract get(): void;
}

const dynamicClass: new () => Foo = (function() {
    return class Bar extends Foo {
        get() {
            console.log('get');
        }

       constructor() {
         super();
         console.log('cons');
       }
    }
})();

new dynamicClass();

Playground Link