Additional safety with typescript

Recently discovered cool typescript feature: noUncheckedIndexedAccess compiler option

It helps to avoid runtime errors in many cases.

type User = { name: string; age: number };

const users: User[] = [
  { name: "John", age: 23 },
  { name: "Bob", age: 60 },
];

const firstFilteredUserName = users.filter(({ age }) => age > 100)[0].name;        

Here filter returns an empty array and you'll catch the bug only after running the code or even on production in some edge cases

Another example:

const usersMap: Record<string, User> = {
  id1: { name: "John", age: 23 },
  id2: { name: "Bob", age: 60 },
};

const username = usersMap.id3.name;        

This also doesn't throw compile error because usersMap key has type string

Enabling noUncheckedIndexedAccess will save you from unexpected bugs, in examples above typescript will tell you that object can be undefined and you need to do additional check.

Looks awesome, however in some cases it behaves weird.

String.split returns string[] which means that it might be an empty array, but in fact, that's not true. First element element is always a string, it can be empty empty string but not undefined. So the standard type definition is not correct.

Thanks to declaration files, we can fix it. First we define NonEmptyArray type

type NonEmptyArray<T> = [T, ...T[]]          

Than in .d.ts file define overload for split method

declare interface String {
  split(separator: string | RegExp, limit?: number | undefined): NonEmptyArray<string>;
}        

Works like a charm.

Did you face similar issues with standard type definitions?