Specifying object literal types on the fly

[normalser]

Sometimes it would be handful to be able to specify type of object literal on the fly (without creating const / variable) with exact type definition

Hopefully it's not violating 'no new syntax' rule (too much)

So something like that:

interface A {
    a: string
}

const b = {
    c: {
        a: 'test'
    }:A   // b would be of type { c: A }
}


function test(d:string) {
    switch(d) {
        case 'anotherTest': return {a: 'test'}:A  // function would return type A
    }
}

Right now the closest I can get is to use type assertion

const b = {
    c: {
        a: 'test'
    } as A
}

but it will allow to provide more fields than necessary and I would want TS to throw an error if someone provides more fields

[kengorab]

No new syntax is needed for this. You could do

const b: { c: A } = { // <- Note the type annotation on b
  c: {
    a: text'
  }
}

and

function test(d:string): A {  // <- Note the type annotation on the function
    switch(d) {
        case 'anotherTest': return {a: 'test'}
    }
}

[RyanCavanaugh]

Same as #7481 ?

[normalser]

Sometimes it would be handful to be able to specify type of object literal on the fly (without creating const / variable) with exact type definition

@kengorab Thanks for answer but maybe my example shouldn't be as simple as I showed. I'm talking about building objects that are deeply nested and function that has multiple cases in switch statement

const z: {
  y: {
     x: {
        w: {
           v: {
                c: A
               }
           }
         }
      }
} = { y: { x: { w: { v: {c} } } } }

vs

const z =  { y: { x: { w: { v: { c }:A } } } }

and for functions with multiple case statements i would need to define const and then return const

[normalser]

That's it @RyanCavanaugh - thanks for pointing it out - tried to find something similar - but sometimes it's difficult

[normalser]

{c: 'test'}:A or {c: 'test'} is A would be awesome, but of course not sure if it has some other problems