Inconsistency of mapped type and `Parameters<T>` between TS and JS

[AlCalzone]

TypeScript Version: 3.1.4

Search Terms: mapped type parameters js

Code

// TypeScript
const Foo = Object.freeze({
  a: (arg1: string) => arg1,
  b: (arg1: string, arg2: boolean) => arg2,
});
// typeof Foo = Readonly<{
//    a: (arg1: string) => string;
//    b: (arg1: string, arg2: boolean) => boolean;
//}>

type Bar = {[K in keyof typeof Foo]: (...args: Parameters<(typeof Foo)[K]>) => void}
// typeof Bar = { 
//     readonly a: (arg1: string) => void; 
//     readonly b: (arg1: string, arg2: boolean) => void;
// }

// JavaScript
const Foo = Object.freeze({
	a: (/** @type {string} */arg1) => arg1,
	b: (/** @type {string} */arg1, /** @type {boolean} */arg2) => arg2,
});
// typeof Foo = Readonly<{
//    a: (arg1: string) => string;
//    b: (arg1: string, arg2: boolean) => boolean;
//}>
// ^ is identical to TS

/** @typedef {{[K in keyof typeof Foo]: (...args: Parameters<(typeof Foo)[K]>) => void}} Bar */
// typeof Bar = {
//     readonly a: (arg1?: string) => void;
//     readonly b: (arg1?: string, arg2?: boolean) => void;
// }
// ^ why optional??

Expected behavior:
Bar.{a,b} having the same signatures in TS and JS

Actual behavior:
Bar.{a,b} have only optional parameters in JS.

[niksajanjic]

This looks similar to what I have encountered, but I don't want to create new issue unnecessarily, so I'll explain it here.

This type of code complies with an error, although it's valid JS code:

const CONTACTS = Object.freeze([{
  email: 'test@email.com',
  phone: '+01 11 5 1234 5678'
}, {
  email: 'test2@email.com',
  phone: '+01 11 5 1234 8765'
}, {
  email: 'test3@email.com',
  phone: '+01 11 5 4321 5678'
}].map(Object.freeze));


CONTACTS.map(({ email, phone }, i) => {
  console.log(email, phone)
})

These 2 errors would be reported:
Property 'email' does not exist on type 'Readonly<{}>'
Property 'phone' does not exist on type 'Readonly<{}>'

A simple fix would be:

}].map(obj => Object.freeze(obj)));

Of course, this code up there isn't very comprehensive, so I changed it to:

interface ContactType {
  email: string;
  phone: string;
}

const CONTACTS: ReadonlyArray<Readonly<ContactType>> = [{
  email: 'test@email.com',
  phone: '+01 11 5 1234 5678'
}, {
  email: 'test2@email.com',
  phone: '+01 11 5 1234 8765'
}, {
  email: 'test3@email.com',
  phone: '+01 11 5 4321 5678'
}]

I prefer this way of defining readonly/frozen array of objects, but first example should be working too. If needed, I can create a separate issue.