Different behavior exhibited between homomorphic mapped types

[corymharper]

Bug Report

🔎 Search Terms

mapped, generic, string, union

🕗 Version & Regression Information

• This is the behavior in every version I tried. (I tried every version the Typescript Playground has listed, and didn't see a pertinent answer in the FAQ)

⏯ Playground Link

Playground link with relevant code

💻 Code

// API Types
type NewParameters<EndpointParameters = never> = { [key in keyof EndpointParameters]: (NonNullable<EndpointParameters[key]>)[] };

// Test type v1
interface TestV1 {
	foo: 'foo' | 'bar' | 'baz';
}

// Test type v2
interface Split1 {
	foo: 'foo';
}

interface Split2 {
	foo: 'bar';
}

interface Split3 {
	foo: 'baz';
}

type TestV2 = Split1 | Split2 | Split3;

// Tests
// This throws an error
const test1: NewParameters<TestV2> = { foo: ['baz', 'foo', 'bar'] };

// These do not
const test2: { [key in keyof TestV2]: (NonNullable<TestV2[key]>)[] } = { foo: ['baz', 'foo', 'bar'] };

const test3: NewParameters<TestV1> = { foo: ['baz', 'foo', 'bar'] };

🙁 Actual behavior

Test examples 1 and 2 produce different types.

🙂 Expected behavior

Behavior should be consistent between the first two test examples.

[whzx5byb]

I'm not sure but it seems like an intended behavior caused by an unwritten rule.

According to #23345 (comment), homomorphic mapped types are also distributive, though this behavior is never mentioned in the documentation.

If TestV2 is a distributive union here, so NewParameters<TestV2>is mapped over to NewParameters<Split1> | NewParameters<Split2> | NewParameters<Split3>, which resolves to {foo: 'foo'[]} | {foo: 'bar'[] } | foo: 'baz'[]}.

[corymharper]

I'm not sure but it seems like an intended behavior caused by an unwritten rule.

According to #23345 (comment), homomorphic mapped types are also distributive, though this behavior is never mentioned in the documentation.

If TestV2 is a distributive union here, so NewParameters<TestV2>is mapped over to NewParameters<Split1> | NewParameters<Split2> | NewParameters<Split3>, which resolves to {foo: 'foo'[]} | {foo: 'bar'[] } | foo: 'baz'[]}.

That would explain the behavior, but I don't exactly understand why the behavior in NewParameters<TestV2> differs from { [key in keyof TestV2]: (NonNullable<TestV2[key]>)[] } as I would expect that to be distributive as well if that were the case.

[whzx5byb]

I'm not sure but it seems like an intended behavior caused by an unwritten rule.
According to #23345 (comment), homomorphic mapped types are also distributive, though this behavior is never mentioned in the documentation.
If TestV2 is a distributive union here, so NewParameters<TestV2>is mapped over to NewParameters<Split1> | NewParameters<Split2> | NewParameters<Split3>, which resolves to {foo: 'foo'[]} | {foo: 'bar'[] } | foo: 'baz'[]}.

That would explain the behavior, but I don't exactly understand why the behavior in NewParameters<TestV2> differs from { [key in keyof TestV2]: (NonNullable<TestV2[key]>)[] } as I would expect that to be distributive as well if that were the case.

I guess this is because TestV2 appears as a generic type parameter in NewParameters<TestV2>, but does not in { [key in keyof TestV2]: (NonNullable<TestV2[key]>)[] }.
This is similar to the rule described in the documentation.

[corymharper]

the documentation

I had seen that in the documentation, but it describes what happens in the case of a conditional type, of which this is not, but you are right that the behavior seems pretty much in line with what is described there.

[typescript-bot]

This issue has been marked 'Working as Intended' and has seen no recent activity. It has been automatically closed for house-keeping purposes.