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);
}

[unional]

Destructuring + Partial also doesn't work:

function foo(v: Partial<{ a: number }>) {}

function boo({ a }: Partial<{ a: number }>) {
	// Argument of type '{ a: number | undefined; }' is not assignable 
	// to parameter of type 'Partial<{ a: number; }>' with 'exactOptionalPropertyTypes: true'
	foo({ a })
}

playground

Should that be tracked here or should it be a different issue?

[Szorcu]

I have encountered the same problem and cannot find a solution anywhere. Has anyone managed to solve it?

[GrantGryczan]

This is NOT just for the sake of exactOptionalPropertyTypes! It would also make it safer to set properties on an object whose type has an index signature. Currently, TS often just lets you get and set unknown properties on types with [key: string]: ... | undefined, since that covers all unknown properties. For instance, after renaming or removing a field in an interface, I generally don't get TS errors signaling me to rename or remove the field where it's set elsewhere.

This can lead to bugs that I only discover at runtime. Being able to use [key: string]?: ... in an interface (just like [Key in string]?: ..., which can't be used in interfaces) would prevent this, with or without exactOptionalPropertyTypes. Currently I have no alternative if I want to use interfaces (which are enforced by TS's stylistic ESLint config which my project, now regrettably, uses).

[Lonli-Lokli]

I have a related proposal - is it possible to report with noUncheckedIndexAccess=true just the record (but not arrays)?