What is the purpose of the super() call in TS subclasses?

Question

Besides being annoying and making it so that every single subclass needs to be touched when a parent class is updated...

Answer 1

Consider the following code:

class A {
    protected sum: number;

    constructor(protected x: number, protected y: number) {
        this.sum = this.x + this.y;
    }
}

class B extends A {
    constructor(x: number, y: number) {
        super(x, y);
    }
}

The call to super in the ctor of class B calls the ctor of class A, and if we look at the compiled javascript code:

var __extends = (this && this.__extends) || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
    function __() { this.constructor = d; }
    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
var A = (function () {
    function A(x, y) {
        this.x = x;
        this.y = y;
        this.sum = this.x + this.y;
    }
    return A;
}());
var B = (function (_super) {
    __extends(B, _super);
    function B(x, y) {
        _super.call(this, x, y);
    }
    return B;
}(A));

It should be clear why we do that, because otherwise everything that happens in the ctor of A wouldn't happen, that is members x, y and sum wouldn't be assigned in the instances of class B.

You might then ask "well, fine, but why doesn't that happen automatically? why can't the compiler just call super for me?"
That's a fair question, and I can think of 2 main reasons:

(1) Because sometimes you want to want to do something before calling super, for example:

class A {
    protected sum: number;

    constructor(protected x: number, protected y: number) {
        this.sum = this.x + this.y;
    }
}

class B extends A {
    constructor(x: number, y: number) {
        if (x % 2 === 0) {
            super(x, y);
        } else {
            super(x + 1, y);
        }
    }
}

You must call super before you access this in the ctor of B.

(2) It makes it explicit that this is what's happening, otherwise you might not expect it to happen because you don't see it.

This requirement is only valid for constructors, class methods are not required to call their super, but you are free to do so if you want to execute the parent method functionality.