Unexpected types when using isNullish/isNonNullish in conditional

[JeongJuhyeon]

TS Version: 5.4.5

Example:

pipe(
      [{ x: 10 }, { x: 20 }], 
      firstBy(prop("x")), 
      conditional(
        [isNullish, (o) => o], // got "o: never", expected "o: undefined"
        [isNonNullish, (o) => o] // got: "o: {}", expected: "o: { x: number; }"
      )
    );

I checked separately if it had to do with the FirstBy type but that doesn't seem to be the case:

const k1 = pipe([{ x: 10 }, { x: 20 }], firstBy(prop("x"))); // FirstBy<{x: number; }[]>, as expected
type t1 = Extract<typeof k1, null | undefined>; // undefined, as expected
type t2 = NonNullable<typeof k1>; // {x: number; }, as expected

It looks like the conditional's Whens must be a type guard of the form is A where A is a primitive type, so not even "NonNullable". Is this correct and intended? If so, it would be good to reflect this in the documentation.

[eranhirsch]

We've got other reports about conditional acting different than expected for people. It's most likely a bug in our typing for conditional.

[grigorischristainas]

@eranhirsch I tried to modify the guards as a workaround and I think isNullish could be modified as follows:

import type { NarrowedTo } from "./internal/types";

export function isNullish<T>(
  data: T | null | undefined,
): data is NarrowedTo<T, null | undefined> {
  return data === null || data === undefined;
}

This narrowing allows for o in the example above being inferred as null | undefined, which I think is correct.

However, I am not sure what can be done about isNonNullish. Best I could do by modifying the guard is end up with o being inferred as unknown in conditional.