Language: TypeScript · Versions: TypeScript 5.7 (strict: true, exactOptionalPropertyTypes: true)
The problem
I'm writing a type-safe event router that converts a union of event definitions into an overloaded handler intersection (UnionToIntersection) while preserving optional payload properties under exactOptionalPropertyTypes: true. When one of the union members is itself a generic or boolean-flagged variant ({ type: 'toggle'; force?: boolean }), distributing over the union splits boolean into true | false inside a nested conditional type and causes the resulting intersection of callbacks to reject valid callers with Argument of type 'boolean | undefined' is not assignable to parameter of type 'never'.
Minimal example
type Events =
| { type: "ping" }
| { type: "toggle"; force?: boolean };
// Attempt to turn union of events into a handler map where payload is optional if empty:
type Handler<E> = E extends { type: infer T extends string }
? Omit<E, "type"> extends Record<string, never>
? (type: T) => void
: (type: T, payload: Omit<E, "type">) => void
: never;
type UnionToIntersection<U> =
(U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
type Emit = UnionToIntersection<Handler<Events>>;
declare const emit: Emit;
// Why does `{ force?: boolean }` match `Record<string, never>` and omit the payload parameter?!
emit("toggle", { force: true });
Expected
emit("ping") requires 1 argument, and emit("toggle", { force: true }) accepts the second argument { force?: boolean }.
What happens instead
Because { force?: boolean } has only optional properties, { force?: boolean } extends Record<string, never> evaluates to true in TypeScript! Consequently, Handler<{ type: "toggle"; force?: boolean }> collapses to (type: "toggle") => void, and calling emit("toggle", { force: true }) fails with Expected 1 arguments, but got 2.
How do you accurately test in TypeScript 5.7 whether Omit<E, "type"> has zero keys (keyof Omit<E, "type"> extends never) rather than all-optional keys, without triggering undesirable distribution?
I couldn't run this, so what follows is from reading the checker's rules. I don't think the premise holds: { force?: boolean } extends Record<string, never> should be false, not true.
Why
Record<string, never> is { [k: string]: never }. A type-literal object type gets an implicit index signature, so the check is whether each known property's type is assignable to never. With exactOptionalPropertyTypes: true, force is boolean, which isn't assignable to never, so the check fails. Without the flag, TS strips undefined from an optional property in this check, so the result is the same. Only {} (no keys) passes. That is why ping takes the one-argument branch and toggle should not.
Two other things in the report don't fit:
booleanis not split by distribution. Only the naked type parameterEdistributes, and that splitsEventsinto its two members. Thebooleaninside a property is untouched.- The two errors you quote (
Expected 1 arguments, but got 2and... not assignable to parameter of type 'never') can't come from the same type. If you really see the first one, check whether you are on a different TS version than 5.7 or whetherEventsis declared differently. A tsc version and a playground link would settle it.
A more robust test
type Payload<E> = Omit<E, "type">;
type Handler<E> = E extends { type: infer T extends string }
? [keyof Payload<E>] extends [never]
? (type: T) => void // no payload keys at all
: {} extends Payload<E>
? (type: T, payload?: Payload<E>) => void // every key optional
: (type: T, payload: Payload<E>) => void // at least one required key
: never;
[keyof P] extends [never]is the standard zero-keys test. The tuple wrapper rules out any distribution whenkeyof Pisnever.{} extends Pis true only when every property ofPis optional. That lets you make the payload parameter optional instead of required, which is probably what you want fortoggle.
Your UnionToIntersection is fine as written. It gives an overload set, so emit("ping") and emit("toggle", { force: true }) should both type-check, and so should emit("toggle") with the third branch. I haven't compiled this.
One caveat: Omit on a union member that has an index signature collapses its keys to string. Your events don't, so it doesn't matter here.