Smarter type alias preservation for unions originating from type query types

[Gerrit0]

Suggestion

🔍 Search Terms

smarter type alias preservation, type query types

✅ Viability Checklist

My suggestion meets these guidelines:

• [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 feature would agree with the rest of TypeScript's Design Goals.

⭐ Suggestion

TypeScript 4.2 introduced intelligent type alias preservation for most union types. This greatly improved visibility when dealing with large union types. This preservation should be extended to union types created by via type query types.

Could probably also be considered a bug / missing edge case.

📃 Motivating Example

Playground link

export const SOME_CONST = {
  valuenum1: 1,
  valuenum2: 2,
  valuenum3: 3,
}

export type SomeConstType = typeof SOME_CONST

export type Keys = keyof SomeConstType
//          ^? type Keys = "valuenum1" | "valuenum2" | "valuenum3" | "valuenum4" | "valuenum5" | "valuenum6" - ☹️ 

// --------

export type SomeConstType2 = {
  valuenum1: number,
  valuenum2: number,
  valuenum3: number,
}

export type Keys2 = keyof SomeConstType2
//          ^? type Keys2 = keyof SomeConstType2 - 😄 

Ref: https://github.com/TypeStrong/typedoc/issues/1867

[RyanCavanaugh]

Is this in reference to declaration emit, quick info (aka tooltips), or something else?

[Gerrit0]

This is related to quick infos - declaration emit shows what I'd expect, preserving the keyof for both types.

[DanKaplanSES]

Personally, I'd prefer to see // ^? type Keys = "valuenum1" | "valuenum2" | "valuenum3" | "valuenum4" | "valuenum5" | "valuenum6" most of the time. typeof X in quick infos slows/distracts my ability to wrap my head around the types I'm investigating.

[Gerrit0]

Another example of this where keyof is not necessary:

crossbell.js has a 1400 line as const array which is referenced in some types.

One of those places is in a method parameter

class CharacterContract {
        // ...
    async create(
        {
            owner,
            handle,
            metadataOrUri,
            linkModule,
        }: {
            /** The Ethereum address of the character owner. */
            owner: Address
            /** The handle of the character you want to create. */
            handle: string
            /** The metadata or URI of the character. */
            metadataOrUri: CharacterMetadata | string
            linkModule?: MintOrLinkModuleConfig
        },
        overrides: WriteOverrides<Entry, 'createCharacter'> = {},
    ): Promise<Result<bigint, true>> {

When calling this function, TypeScript does not preserve the Entry alias, which results in a hover which can't really be reasoned about: