Allow for optional index signatures (for the sake of `exactOptionalPropertyTypes`)

[OliverJAsh]

Bug Report

🔎 Search Terms

exactOptionalPropertyTypes strictoptionalProperties Partial index signature dictionary record

🕗 Version & Regression Information

• This is the behavior in every version I tried, and I reviewed the FAQ for entries about exactOptionalPropertyTypes

⏯ Playground Link

Playground link with relevant code

💻 Code

type MyRecord = { x: string; z: string };

const r: Partial<MyRecord> = {
    x: "y",
    // Error as expected ✅
    z: undefined,
};

type MyDict = { [key: string]: string };

const d: Partial<MyDict> = {
    x: "y",
    // Expected error but got none ❌
    z: undefined,
};

🙁 Actual behavior

See code comments above.

🙂 Expected behavior

See code comments above.

---

This was briefly discussed in #44524 and #44421 (comment).

[ahejlsberg]

This is effectively a design limitation. We don't support the notion of optional index signatures (i.e. it isn't possible to specify a ? in the declaration of an index signature) and before --exactOptionalPropertyTypes there was really no reason to. By their nature index signatures represent optional properties, and all an optional index signature would do is add undefined to the type--which you could just do manually. However, with --exactOptionalPropertyTypes we now have two kinds of undefined, and the only way to get the missing-property kind is through the ? modifier on a property declaration. For this reason we may want to consider supporting the ? modifier on index signatures.

[sgvictorino]

Is there a way to detect that a type is indexed (but not mapped) as a workaround?

Update: I ended up with the following. If anyone stumbles upon this and has an idea for improvement please let me know:

type IsIndexed<T> = {
    [IndexType in string | number | symbol]: IndexType extends keyof T
        ? true
        : false;
}[keyof T];

interface Test {
    prop: string;
}
const value: IsIndexed<string> = false;
const object: IsIndexed<Test> = false;
const mapped: IsIndexed<Record<keyof Test, unknown>> = false;
const indexed: IsIndexed<Record<keyof Test | string, unknown>> = true;
const indexedWithoutString: IsIndexed<Record<number | symbol, unknown>> = true;

[jeremybparagon]

If we were able to use Object.values on a Partial type without getting undefined included in the array type, that would be pretty nice. I like to mark index signature values with the undefined possibility, but then when I use Object.values on the object, I have to filter out undefined values that aren't really there. For example (link):

// Use Partial since ranges might not be set for all keys
type RangeDictionary = Partial<{ [key: string]: { start: number, end: number }}>;

function getRangeEnds(rangeDictionary: RangeDictionary) {
  // TypeScript wants me to consider the possibility that range is undefined here
  return Object.values(rangeDictionary).map(range => range.end);
}