PR Checklist

• Addresses an existing open issue: related to #000
• Steps in Contributing were taken

Overview

Currently, the OptionalKeys type doesn’t handle primitives and arrays as expected.

Handling Primitives Correctly

Since OptionalKeys is a homomorphic mapped type, so when it’s instantiated with a primitive Type, it simply returns back Type. As a result, instantiating OptionalKeys with string yields string[keyof string], which isn’t the intended result.

The fix here is straightforward, we simply bypass primitives by changing the conditional from Type extends unknown to Type extends object. So, when OptionalKeys is instantiated with primitives, the condition evaluates to false, returning never as expected.

Handling Arrays Correctly

Ideally, OptionalKeys<[1, 2?]> should return "1", but instead, it returns a bunch of unintended things.

Here's the existing code for reference:

export type OptionalKeys<Type> = Type extends unknown
  ? {
      [Key in keyof Type]-?: undefined extends { [Key2 in keyof Type]: Key2 }[Key] ? Key : never;
    }[keyof Type]
  : never;

Let's break down what happens when OptionalKeys is instantiated with [1, 2?].

• Since the inner mapped type ({ [Key2 in keyof Type]: Key2 }) is homomorphic, it correctly preserves the tuple structure and evaluates to [Key2, Key2?] (Note: Key2 is insignificant here; could have simply been never as well). Therefore, the conditional undefined extends ... evaluates to true only when Key is "1".
• Consequently, because the outer mapped type is also homomorphic, it correctly evaluates to [never, "1"].
• However, the problem arises when we try to do [never, "1"][keyof T] as this yields a bunch of unintended keys. Instead, if we index it with the number type, we get the desired result of "1".

The fix involves using number as the index for arrays instead of keyof Type.

Additional Improvements & Tests:

1. Added a couple of more test cases to cover arrays and functions.
2. Replaced Key2 with never in the inner mapped type for better readability. Using a specific type like Key2 can imply that its value is being utilised, which isn’t the case here.