How to create an extended ES6-class constructor from a provided base class and from additionally provided and to be mixed-in behavior?

I tried to write a mixin function based on the ideas described here for inheritance. Method mixins are pretty easy, but I am struggling with constructor mixins.

I try to write a function, which takes a class and returns a new class, with an extended constructor.

This is my example:

function extend_constructor(original, extension) {
  let extended = function (...args) {
    console.log("extended constructor")
    original.prototype.constructor.apply(this, args)
    extension.apply(this, args)
  }
  Object.defineProperty(extended, 'name', Object.getOwnPropertyDescriptor(original, 'name'))
  extended.prototype = Object.create(original.prototype)
  Object.defineProperty(extended.prototype, 'constructor', {
    value: extended,
    writeable: true,
    configurable: true})
  return extended
}

function extension(id) {
  console.log(`Extension: ${id}`)
}

I works with function classes.

function Basefunc(id) {
  console.log(`Basefunc: ${id}`)
}

new Basefunc(1)

const BasefuncEx = extend_constructor(Basefunc, extension)

new BasefuncEx(2)

But fails with ES6 classes:

class Baseclass {
  constructor(id) {
    console.log(`Baseclass: ${id}`)
  }
}

new Baseclass(3)

const BaseclassEx = extend_constructor(Baseclass, extension)

new BaseclassEx(4)

The error is:

> TypeError: Class constructor Baseclass cannot be invoked without 'new'

But I think using new is not what I want, because new will create an instance of the original class and will apply the original constructor to it. I want to apply the original constructor of the original class to the instance of the extended class. And I am wondering how to do this with new.

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

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

function createSubClassWithMixinBehavior(
  subClassName, SuperClass, withBehavior
) {
  return ({
    [subClassName]: class extends SuperClass {
      constructor(...args) {
        super(...args);
        withBehavior.apply(this, args);
      }
    },
  })[subClassName];
}

class BaseType {
  constructor(id) {
    console.log(`constructing the BaseType logs ... ${ id }`);
  }
}
function extension(id) {
  this.id = id;
  console.log(`applying / mixin-in the extension logs ... ${ id }`);
}
const baseType = new BaseType(3);
const subType = new (
  createSubClassWithMixinBehavior('SubType', BaseType, extension)
)(4);

console.log({
  baseType,
  subType,
  nameOfSuperClass: baseType.constructor.name,
  nameOfSubClass: subType.constructor.name,
});

<!-- language: lang-css -->

.as-console-wrapper { min-height: 100%!important; top: 0; }

<!-- end snippet -->