Issue 1:
Example:

class Component {
static all : Array<typeof Component>
static constructor() {
Component.all.push( this )
}
}

class MyButton extends {}
class MyCheckbox extends {}
class MyRadio extends {}

console.assert( Component.all[0] === MyButton , 'registration MyButton' )
console.assert( Component.all[1] === MyCheckbox , 'registration MyChackbox' )
console.assert( Component.all[2] === MyRadio , 'registration MyRadio' )

This not works. But we have workaround:

/// Support for static constructors
var __extends = ( Sub , Sup ) => {
for( var prop in Sup ) if( Sup.hasOwnProperty( prop ) ) Sub[ prop ] = Sup[ prop ]
Sub.prototype = Object.create( Sup.prototype )
Sub.prototype.constructor = Sub
if( Sub.initializer ) Sub.initializer()
};

class Component {
static all : Array<typeof Component> = []
static initializer() {
Component.all.push( this )
}
}

class MyButton extends Component {}
class MyCheckbox extends Component {}
class MyRadio extends Component {}

console.assert( Component.all[0] === MyButton , 'registration MyButton' )
console.assert( Component.all[1] === MyCheckbox , 'registration MyChackbox' )
console.assert( Component.all[2] === MyRadio , 'registration MyRadio' )

But:

This is hack.

initializer calls only on descendant classes.

We can use decorators:

class Component {
static all : Array<typeof Component> = []
static register( comp : typeof Component ) {
Component.all.push( comp )
}
}

@ Component.register
class MyButton extends Component {}

@ Component.register
class MyCheckbox extends Component {}

@ Component.register
class MyRadio extends Component {}

console.assert( Component.all[0] === MyButton , 'registration MyButton' )
console.assert( Component.all[1] === MyCheckbox , 'registration MyChackbox' )
console.assert( Component.all[2] === MyRadio , 'registration MyRadio' )

But:

Too more code.

User may forget to register component and don't understand why his code not works.

Issue 2:
A static constructor is a function that is run only once when the class is loaded. It can be used to initialize static class members and maybe as entry point to the application.

Suggested syntax is:

class MyClass {
static initialized = false;

static constructor() {
MyClass.initialized = true;
}
}

alert(MyClass.initialized);

That would be same as the following:

class MyClass {
static initialized = false;

static __ctor = (() => {
MyClass.initialized = true;
})();
}

alert(MyClass.initialized);

Except that __ctor does not need to be assigned to the class in the output code, and only needs to be invoked in an anonymous function. Also compiler can check that no more than one static constructor is defined in a class.

Update: Since this generates an Immediately-Invoked Function Expression (IIFE), compiler should make sure to move it to the end of the class definition in the output JavaScript.

TypeScript:

class MyClass {
static constructor() {
MyClass.initialized = true;
}

static initialized = false;
}

Expected JavaScript output:

var MyClass = (function () {
function MyClass() {
}
MyClass.initialized = false;

// run last
(function () {
MyClass.initialized = true;
})();
return MyClass;
})();

Note that body of the static constructor is moved to the bottom and invoked.

Related suggestion in codeplex: Please add static constructors to classes