Loosen property access strictness if nullish operator is being used

[sod]

🔍 Search Terms

Example:

const languages = ['de', 'en', 'fr'] as const;
type Language = (typeof languages)[number];

const fallback = 'lorem';
const customByLanguage = {
    de: 'ipsum',
} satisfies Partial<Record<Language, string>>

function getValue(language: Language): string {
    return customByLanguage[language] ?? fallback;
           // ts error: Element implicitly has an 'any' type because expression of type '"de" | "en" | "fr"' can't be used to index type '{ de: string; }'.
           //                Property 'en' does not exist on type '{ de: string; }'.(7053)
}

This error seems counter intuitive as a fallback if the property doesn't match was given via ?? fallback. Right now I need to add either typescript or javascript boilerplate to get rid of this error.

playground

✅ Viability Checklist

• [x] This wouldn't be a breaking change in existing TypeScript/JavaScript code
• [x] This wouldn't change the runtime behavior of existing JavaScript code
• [x] This could be implemented without emitting different JS based on the types of the expressions
• [x] This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, new syntax sugar for JS, etc.)
• [x] This isn't a request to add a new utility type: https://github.com/microsoft/TypeScript/wiki/No-New-Utility-Types
• [x] This feature would agree with the rest of our Design Goals: https://github.com/Microsoft/TypeScript/wiki/TypeScript-Design-Goals

⭐ Suggestion

I'd expect typescript to not complain about lack of perfect key overlap if the nullish operator is being used to fallback if they key does not exist.

A bonus would be, if typescript still complained if key and object had no overlap at all, as that seems to be most likely an error.

💻 Use Cases

Now having to work with strict property access due to removal of suppressImplicitAnyIndexErrors: false in typescript 5.6

[nmain]

satisfies is not the same as an inferred or explicitly annotated type. customByLanguage has the more specific type of { de: string } and no index or record signature. If you want the wider type, just use that:

Playground

const customByLanguage: Partial<Record<Language, string>> = {
    de: 'ipsum',
}