Easier/general way to implement Typescript's "key remapping via as" approach

[jrencz]

What I refer to in the title as 'the "key remapping via as" approach' is https://www.typescriptlang.org/docs/handbook/2/mapped-types.html#key-remapping-via-as

Looking through resolved issues related to Template Literal and Mapped types I found the resolved #913

Inspired by that I tried to rebuild the example from the TS Handbook, (link below) and I think it shows an idea for a nice feature to be added: a way to use both the TMappedKey and the original key in TMappedFunction.

I imagine it would mean Type.Mapped knows not only about the "new" keys (as it does now, the 1st argument) but somehow it can be given both the keys and the function that maps keys, not only the function that maps values, the TMappedFunction.

Here's playground with description of the concept, until the point, where the suggested new syntax would make things easier.

[sinclairzx81]

@jrencz Hi, thanks for the suggestion! This is a cool idea.

I'll spend some time looking into this when I next get a bit of free time to deep dive into this aspect of the library. I think being able to remap property names would be awesome (an essential) addition to the Mapped type feature. I expect this feature would need to be realized by way of new type (Type.MappedAs, Type.KeyAs, Type.As or similar), something to provide the Mapped functions key parameter a bit more context (essentially a source and target mapping for each property key)

There's not too much I can implement at this stage, so will convert this issue into a discussion thread for now as new features like this are usually best discussed there. Happy to field any questions if you wanted to have a go at a prototype implementation :)

Cheers!
S

[jrencz]

I expect this feature would need to be realized by way of new type (Type.MappedAs, Type.KeyAs, Type.As or similar), something to provide the Mapped functions key parameter a bit more context (essentially a source and target mapping for each property key)

Just purely from the user's point of view, I think having a distinct function to create this flavour of mapped type would be less predictable than having some kind of yet another a signature of the Type.Mapped but for those already existing:

typebox/src/type/mapped/mapped.ts

Lines 261 to 264 in d387b2a

	/** `[Json]` Creates a Mapped object type */
	export function Mapped<K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>, F extends TMappedFunction<I> = TMappedFunction<I>, R extends TMapped<I, F> = TMapped<I, F>>(key: K, map: F, options?: ObjectOptions): R
	/** `[Json]` Creates a Mapped object type */
	export function Mapped<K extends PropertyKey[], F extends TMappedFunction<K> = TMappedFunction<K>, R extends TMapped<K, F> = TMapped<K, F>>(key: [...K], map: F, options?: ObjectOptions): R

export function Mapped<…>(key: K, keyMap: F1, map: F2, options?: ObjectOptions): R

(I'm skipping the type parameters for brevity)

Here's why I think it would make sense to at least give it a try to fit the as syntax into the Type.Mapped with 3(4 with options) arguments (where I honestly don't have experience to judge if it makes sense or if it's going to make implementation harder, but anyway): 3 elements is what AST for that original syntax is.

Let's consider the AST Typescript produces for both syntaxes:

type NoRemap<Type> = {
    [Property in keyof Type]: Type[Property]
};

type WithRemap<Type> = {
    [Property in keyof Type as `prefixed${string & Property}`]: Type[Property]
};

https://ts-ast-viewer.com/#code/C4TwDgpgBAcg9gJQgWwIZgDwBVwQHxQC8UA3gFBSVQDaACgE5yT2hQCWAdlANYQhwAzKDkgBdAFzDcdRs1CiyAXwDcZMqEhQA6m2AALJGkwj8RUhSoymEFiHZde-ISaioAzlAAGYehAFsADwgAEwASEjdgek4AcygAMigGa1tFTwkpSCs5EAUVMiA

SourceFile
  TypeAliasDeclaration
    Identifier
    TypeParameter
    MappedType
      TypeParameter     <-- in Typebox it's the TKeyOf
      IndexedAccessType <-- in Typebox it's the TMappedFunction
  TypeAliasDeclaration
    Identifier
    TypeParameter
    MappedType
      TypeParameter
      TemplateLiteralType <-- in Typebox it would be a TMappedKeyMapFunction (proposed name)
      IndexedAccessType
  EndOfFileToken

in Typebox the first is

Type.Mapped(
  Type.KeyOf(T),

  // K is a TKeyOf
  (K) => Type.Index(Type, K)
)

the second I propose to be

Type.Mapped(
  Type.KeyOf(Type),

  // what I earlier named TMappedKeyMapFunction
  // K here is a TKeyOf
  (K) => Type.TemplateLiteral([Type.Const('prefixed'), K])
  
  // in proposed 3(4)-argument signature TMappedFunction would have not 1 but 2 arguments
  // or maybe there's a TMappedAsFunction (another proposed name) type, in which where
  // - K is a TKeyOf - same as in TMappedFunction
  // - A is the TTemplateLiteral - possibly for convenience of nor repeating oneself, in case it
  //   actually might be needed (it's not used in discussed case)
  (K, A) => Type.Index(Type, K)
)