Reference to own class in static variable initialization to a decorated class references undecorated class instead of decorated class

[mattyork]

TypeScript Playground link

[vladima]

pinging @rbuckton

[mhegazy]

more discussion in #8337

[hrajchert]

Any updates on this? I'm suffering from the same :(... or at least is there any workaround to reference the decorated class?

[rbuckton]

The best work around is probably lazily initializing the value using a getter, or assigning the value after the class declaration.

[hrajchert]

@rbuckton when you say lazy you meant this?

If so it still points to X.

I've noticed that in the generated output if you invert the order of the decorate and the static members it work as expected even without doing it lazy.

I mean doing this

var X = (function () {
    function X() {
    }
    X = __decorate([
        Wrapper
    ], X);
    X.p = createFactory(X);
    return X;
}());

instad of

var X = (function () {
    function X() {
    }
    X.p = createFactory(X);
    X = __decorate([
        Wrapper
    ], X);
    return X;
}());

Do you see any drawbacks of adding the static members after the decoration?

[rbuckton]

I mean something like this:

@Wrapper
class X {
  private static _p: X;
  static get p() {
    return this._p || (this._p = new X());
  }
}

[hrajchert]

In that example assuming we use the same Wrapper, Y.p is undefined. The wrapper needs to copy the static members (and the prototype as well) but in the process the static property gets evaluated and it points to X.

Here is the code

@Wrapper
class X {
  private static _p: X;
  static get p() {
    console.log('XorY', X.name);
    return this._p || (this._p = new X());
  }
}
function Wrapper(target) {
    function Y() { }
    // need to copy static properties or they are lost in Y... should also copy the prototype
    for (let s in target) {
        Y[s] = target[s];
    }
    return Y;
}

sorry if I'm misunderstanding something :D