TypeScript - Weak Types leads to Index Signatures, leading to poor type checking - angularjs

Question

This is more of a concern about the use of index signatures than AngularJs's use of it, but it is a key issue I believe needs resolving somehow with TypeScript types.
With TypeScript 2.4's Weak Types addition, the #types/angularjs IController started complaining about Weak Types, and the fix (the only possible fix at this point) is to add an index signature, as was referenced here:
https://github.com/DefinitelyTyped/DefinitelyTyped/issues/17257
https://github.com/DefinitelyTyped/DefinitelyTyped/pull/17303
But BEFORE this change, TypeScript errors would help ensure that when you typed your IController with the properties in your object, it would complain (appropriately) that you missed defining properties, which is one of the very helpful things that makes TypeScript a great language (at least IMO).
Here's a direct example using a simplified AngularJs 1.5 Component:
let MyComponent = function(): angular.IComponentOptions {
return {
bindings: {},
controller: MyController,
controllerAs: 'vm',
}
}
interface IController extends angular.IController {
x: string;
}
function MyController(this: IController) {
let vm = this;
vm.x = "foo"; // OK
vm.x = 1; // ERROR: As expected due to the definition - great
// This next line would have complained before this,
// now it will let it thru unscathed, same with functions,
// arrays, etc. - this is the problem
vm.y = "bar"; // OK now, ERROR before
}
Is there a way to both allow AngularJs's types to avoid the Weak Types concern (which makes sense), while still allowing proper checking on child types?
Personally I feel that index signatures should be avoided wherever possible because of this issue, and are not great solutions for avoiding compiler errors (although currently likely the only way).
Thanks

Answer 1

The only solution I can come up with would require a change in your local angular type definition files (or maybe it could be pushed upstream). Right now the definition of IController in angular looks something like this:
interface IController {
$onInit?(): void;
$doCheck?(): void;
$onChanges?(onChangesObj: IOnChangesObject): void;
$onDestroy?(): void;
$postLink?(): void;
[s: string]: any;
}
Maybe it should be changed to this:
interface IControllerWeak {
$onInit?(): void;
$doCheck?(): void;
$onChanges?(onChangesObj: IOnChangesObject): void;
$onDestroy?(): void;
$postLink?(): void;
}
interface IController extends IControllerWeak {
[s: string]: any;
}
This should be exactly the same for everyone downstream, but it now gives you a reference to IControllerWeak, which is just IController without the index signature. In most (all?) cases, something which asks for an IController will accept an IControllerWeak and vice-versa.
So now you can extend IControllerWeak with a required property, and you have a non-weak (strong?) type with the guarantees you want:
interface IController extends angular.IControllerWeak {
x: string;
}
function MyController(this: IController) {
let vm = this;
vm.x = "foo"; // OK
vm.x = 1; // ERROR
vm.y = "bar"; // ERROR as desired
}
And an IComponentOptions.controller is happy enough to accept MyController (or a constructor for a subtype of IControllerWeak):
let MyComponent = function(): angular.IComponentOptions {
return {
bindings: {},
controller: MyController,
controllerAs: 'vm',
}
}
Does that work for you?

Answer 2

Can you solve it with mapped types, which lets you define a strong interface, but make its properties optional with the Partial mapped type...
// We don't want a weak type... or an index signature...
interface WeakType {
x?: string;
}
interface StrongType {
x: string;
}
type PartialStrongType = Partial<StrongType>;
function doSomething(options: PartialStrongType) {
return options.x || '';
}
doSomething({}); // OK
doSomething({ x: 'str' }); // OK
doSomething({ x: 1 }); // x can't be a number
doSomething({ y: 'str' }); // hey, you typed 'y', did you mean 'x'