Typescript: Using the type of a static inner class

Question

I\'m trying to write a class that exposes an inner data structure to its consumers, a data structure that the class itself will be using.

Example:

class Ou         


        

Answer 1

I found a better workaround for this, that even allows the inner class to access the private members of the outer class, like you would expect in a C#-like language. You can actually easily get the type of the static property with the typeof operator. This small modification to your example works:

class Outer
{
    static Inner = class
    {
        inInner: number = 0;
    };

    constructor(public inner: typeof Outer.Inner.prototype) { }
}

But referring to the type as typeof Outer.Inner.prototype gets cumbersome really quickly, so add in this underneath and you can simply refer to it as Outer.Inner as you'd like:

namespace Outer
{
    export type Inner = typeof Outer.Inner.prototype;
}

Combine this with another workaround to allow us to put decorators on the class by making it not an anonymous class and we end up with a fully functional true inner class:

class Outer
{
    static Inner = (() =>
    {
        @decoratable()
        class OuterInner
        {
            inInner: number = 0;
        }
        return OuterInner;
    })();

    constructor(public inner: Outer.Inner) { }
}

namespace Outer
{
    export type Inner = typeof Outer.Inner.prototype;
}

Answer 2

Your second "workaround" is the prefer way to go:

class Outer {
    constructor(public inner: Outer.Inner) { }
}

namespace Outer {
    export class Inner {
        inInner: number
    };
}

// Spec
let outer1 = new Outer({ inInner: 3 });

let outerInner = new Outer.Inner();
let outer2 = new Outer(outerInner);

There are three types of declarations in TypeScript: namespace, type, and value. You could use namespace to organize types and value.

http://www.typescriptlang.org/docs/handbook/declaration-merging.html

It does not reduce readability because there is no concept of an "Inner Class" in TypeScript.

Remember that the class syntax is just sugar of es5 prototypal inheritance. How would you represent an inner class in prototypal inheritance? Do you put is as an instance variable? or under Outer.prototype.???

what it ends up in es5 is something like this:

var Outer = function Outer(...) { ... }
Outer.Inner = function Inner() { ... }

If you look at it, the Outer in Outer.Inner is only served as a "namespace" to hold the Inner class.