Compile Optimization: Prototype Objects

[only-cliches]

TypeScript Version: 2.1.4

While working on a recent project I was looking at the compiled javascript code and noticed "prototype" was written dozens of times, once for each public method. The library I was working on is 13Kb in size minified, and removing all the "prototypes" reduced the size to 12.5Kb, that's half a kilobyte!

Compiled JavaScript files could considerably smaller if we applied all methods to the prototype as an object, instead of one at time.

Let's take a simple class

export class foo {
    public bar() {
        alert("bar");
    }
    public baz() {
        alert("baz");
    }
}

Existing Behavior

Once we compile with tsc, we get this:

"use strict";
var foo = (function () {
    function foo() {
    }
    foo.prototype.bar = function () {
        alert("bar");
    };
    foo.prototype.baz = function () {
        alert("baz");
    };
    return foo;
}());
exports.foo = foo;

Notice that we get the "prototype" syntax twice, once for each method.

New Suggested Behavior

Instead, the compiler could combine the multiple methods into a JS object applied to the prototype, saving a good deal of space:

"use strict";
var foo = (function () {
    function foo() {
    }
    foo.prototype = {
        bar: function () {
            alert("bar");
        },
        baz: function () {
            alert("baz");
        }
    };
    return foo;
}());
exports.foo = foo;

The performance of the code should be identical and larger libs see a huge size improvement for free. For example, the BabylonJS core lib could be almost 20Kb smaller.

[RyanCavanaugh]

Duplicate of #9638?

[only-cliches]

Good find sir! Yes it is, closing this issue...