Mixin pattern issues when "declaration:true" is used - tsc cannot infer class def properly

[Hotell]

TypeScript Version: 2.2.1

Code

Demo you have to download and run it on your machine with declaration: true

// A *self-contained* demonstration of the problem follows...
export class Point {
    constructor(public x: number, public y: number) {}
}

export class Person {
    constructor(public name: string) {}
}

export type Constructor<T> = new (...args: any[]) => T;

export type TaggedProps = {
    tag: string,
    isTagged(): boolean,
}

export function Tagged<T extends Constructor<{}>>(Base: T): Constructor<TaggedProps> & T {
    return class TaggedMixin extends Base {
        tag: string;
        constructor(...args: any[]) {
          super(...args);
          this.tag = '';
        }
        isTagged() { return Boolean(this.tag.length); }
    }
}

export const TaggedPoint = Tagged(Point);

const point = new TaggedPoint(10, 20);
point.tag = 'hello';
point.isTagged();
console.log(point.x);

export class Customer extends Tagged(Person) {
    accountBalance: number;

    onFoo() {
      return this.isTagged() ? this.tag : 'ups';
    }
}

const customer = new Customer('Joe');
customer.tag = 'test';
customer.accountBalance = 0;
customer.onFoo();

Expected behavior:
No errors when using declaration:true and proper type inference of returned mixin class from function

Actual behavior:
Provided code works without errors, but when we want generate type definitions via declaration:true tsc will error out.

Problem is that TSC is not able to infer the returned class type definition when generating ambient definitions ( so that's why I explicitly provide return type export function Tagged<T extends Constructor<{}>>(Base: T): Constructor<TaggedProps> & T { )

Although that is not the exact type that TSC inferes when declaration is not turned on:

Infered type definition:

function Tagged<T extends Constructor<{}>>(Base: T): { 
  new (...args: any[]): TaggedMixin; 
  prototype: Tagged<any>.TaggedMixin; 
} & T

[RyanCavanaugh]

The issue is that .d.ts files can't contain expression code, and the extends operand Tagged(Person) is an expression rather than an identifier which points to a type+value.

[Hotell]

Right, are there any plans to improve this in the future?

For anyone else the fix is simple enough ( although it took me quite a lot time to figure it out :D )

++const TaggedPerson = Tagged(Person);
--export class Customer extends Tagged(Person) {
++export class Customer extends TaggedPerson {
    accountBalance: number;

    onFoo() {
      return this.isTagged() ? this.tag : 'ups';
    }
}

also fixed here wc-catalogue/blaze-elements@d5d435e

[mhegazy]

This is tracked by #14075, either allow some intersection type in extends clause of classes in ambient context, or add the const as suggested by @Hotell.

[Hotell]

Right closing in favor of #14209 and #14075

Thanks guys!