setprototypeof | Polyfill for Object.setPrototypeOf | User Interface library

I think the only way you're going to get something like this to work (without having to explicitly write out redundant type annotation information everywhere) is if you refactor the assignment of B and setting of its prototype into a single function call like this:

Is there something different about how prototypical inheritance works via extends versus via setPrototypeOf?

Yes. setPrototypeOf changes the prototype after the fact, so the original value is a "normal" object. With extends Array, the value will actually be an instance of Array, because it is the result of calling the Array constructor.

Are there effects that we can apply to an Object instance in addition to setPrototypeOf to get similar results to what we've achieved with extends?

Yes and no.

Exotic array objects have different implementation for the internal slot [[DefineOwnProperty]] and you cannot directly change an internal slot from "user land" code.

But you could potentially use a Proxy to intercept property assignment and implement the same behavior as [[DefineOwnProperty]].

Are you just not supposed to add things directly to the prototype in TS?

Typescript expects that you'll use the class syntax to define your classes. This syntax may not explicitly mention the prototype, but the functions are being added to the prototype none the less.

So the following example will add a getChunkLength function to the prototype:

perhaps that binding is somehow stored when the x object is created and retained even when the function is assigned to y.

Yes, precisely that is what happens. The getProtoPropViaSuper method basically closes over the object it was defined in. This is stored in the internal [[HomeObject]] slot of the function itself, which is why it is kept if you assign the method to a different object, or - more importantly - inherit it on an a different object¹. For method definitions in object literals, it's the object created by the literal; for method definitions in classes, it's the class's .prototype object.

_{1: For why it needs to be a static reference and not something invocation-dependent like Object.getPrototypeOf(this), see here.}

If it's holding onto the original object, it seems like that could cause memory leaks as the original object could not be garbage collected.

No, it's not causing any more memory leaks than other closures. Sure, the method prevents its home object from being garbage collected, but given that the home object is a prototype object - in normal usage at least - which is also referenced in the prototype chain of the objects on which the method is normally called, this is not an issue.

I would really appreciate it if someone could explain this behavior in plain language. How does super determine its value?

It takes the prototype of its bound home object, which is the object that the method was defined in. Notice however that accessing a property on super doesn't return an ordinary reference to the property of that object, but a special reference which when called (a method) will take the this value of the current scope as the this argument to the method call, not the prototype object. In short,

The problem is that splice returns an array with the removed items. This array is of the same species (read: subclass) as the method receiver (this value), i.e. a DefaultReorderableList in your case. And splice instantiates a new DefaultReorderableList(1) with the length, as any Array constructor should support it. Your constructor is breaking the contract to implement that interface, and causes an exception when trying to iterate the number in super(...items).

See also When Extending Array map is undefined.

Fix it by removing your constructor entirely (or reimplementing the default constructor(...items) { super(...items); }). If you want to create an instance and pass an array to initialise it, use DefaultReorderableList.from([…]).

When you assign to a property, it first searches the prototype chain for a setter. If a setter is found, it is simply executed.

If no setter is found, an ordinary property is either created or updated in the object itself. Assigning a property never assigns to an inherited property by itself (a setter could do so).

It looks like there is a mismatch between the environments you use. Try the following:

1. Remove sharp completely from your app.

To solve this, I deleted the "node_modules" folder in my build folder, did "npm install [module] --save" for each of the packages found in require statements in my server.js file, wiped my server clean and resynced my build files to it, then did "npm install" on the server.

So in classic fashion, I've found the solution right after posting.

I removed "node": "^14.4.0" from my package.json and it successfully built.