TypeScript mixin is not transformed as a complete Polymer module definition

[tpluscode]

A mixin in TypeScript can be defined as a function returning class containing properties and methods

Expected behavior

Properties are transformed to the static get properties method.

Actual behavior

Only methods are copied to the output file.

Example

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

export function MyMixin<T extends Constructor<{}>>(Base: T) {
    return class extends Base {
        some: String;

        _abstract() {

        }

        static _static() {

        }
    }
}

produces

function MyMixin(Base) {
  return class extends Base {
    _abstract() {}
    static _static() {}
  };
}

[Buslowicz]

Need a hand with the decision by which mixin should be transformed into Polymer Mixin. We can have something like that:

function Mixin<T extends Constructor>(Super: T) {
  @Mixin()
  class Mixin extends Super {
    test: number;
  }
  return Mixin;
}

This however requires that:

• mixin is a function or arrow function with body
• inside the body, class is not exported right away
• class is decorated with an annotation
• class is returned from the mixin function

This would not allow to to a shorthand syntax:

const Mixin = <T extends Constructor>(Super: T) => class Mixin extends Super {
  test: number;
};

We could also use a JSDoc to mark mixins for transformation, which would match exactly how Polymer Tools require it:

/**
 * @mixinFunction
 * @polymer
 */  
const Mixin = <T extends Constructor>(Super: T) =>
  /**
   * @mixinClass
   * @polymer
   */
  class Mixin extends Super {
    test: number;
  }

or with marking just the function:

/**
 * @mixinFunction
 * @polymer
 */  
const Mixin = <T extends Constructor>(Super: T) => class Mixin extends Super {
  test: number;
}

What looks properly? Or should we have all of the above working?