Suggestion

🔍 Search Terms

template string index signature number bigint

✅ Viability Checklist

My suggestion meets these guidelines:

• This wouldn't be a breaking change in existing TypeScript/JavaScript code
• This wouldn't change the runtime behavior of existing JavaScript code
• This could be implemented without emitting different JS based on the types of the expressions
• This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, new syntax sugar for JS, etc.)
• This feature would agree with the rest of TypeScript's Design Goals.

⭐ Suggestion

Currently, only strings or numbers can be used as index signatures. Until template strings were added, mapped types could work around this:

// this won't work:
// type Foo = {[x: 'foo' | 'bar']: number}

// this does:
type Foo = {[K in 'foo' | 'bar']: number} // or alternatively Record<'foo' | 'bar', number>

However, when attempting to use mapped types for template string types, the type becomes {}:

type TemplateString = `${number}: ${string}`
// DoesntWork is {}
type DoesntWork = Record<TemplateString, number>

📃 Motivating Example

Say you had a UUID type:

type UUID = `${string}-${string}-${string}-${string}-${string}`

This feature would allow more type-safe index signatures (instead of simply Record<UUID, User>, for example):

interface User {
  username: string
  // ...
}

const users: Record<UUID, User>

users['01234567-89ab-cdef-0123-456789abcdef'] = {username: 'Alice'}

// Compile error
users['invalid'] = {username: 'Bob'}

// Compile error
const someUser = users['invalid']

I'll change this example if I or anyone else comes up with a better one.

💻 Use Cases

Discord uses snowflakes, which are 64-bit integers, for IDs. The package discord-api-types exports this:

export type Snowflake = `${bigint}`

My use case is that I want to have a Record<Snowflake, SomeType>, but I was a little surprised and disappointed when that turned out to be {}.

An alternative that would fix my specific use case would be to allow bigints in index signatures, but in my opinion that would be confusing as property keys are converted to strings anyway. I believe allowing template strings in index signatures is a more general solution that could be helpful in many use cases.