prefer-type-fest-optional-keys-of

Require TypeFest OptionalKeysOf<T> over expanded optional-key extraction helpers.

Targeted pattern scope

This rule reports the exact TypeFest mapped-key composition that derives optional keys from IsOptionalKeyOf<T, K>.

It supports direct, aliased, and namespace-qualified TypeFest imports for IsOptionalKeyOf.

What this rule reports

This rule reports expanded optional-key extraction helpers that can be replaced by OptionalKeysOf<T>.

Why this rule exists

OptionalKeysOf<T> is the canonical TypeFest utility for extracting optional keys. Using it directly avoids repeating a fragile mapped-type helper and makes the type intent easier to scan.

❌ Incorrect

import type { IsOptionalKeyOf } from "type-fest";

type Result<Type extends object> = Type extends unknown
    ? (keyof {
          [Key in keyof Type as IsOptionalKeyOf<Type, Key> extends false
              ? never
              : Key]: never;
      }) &
          keyof Type
    : never;

✅ Correct

import type { OptionalKeysOf } from "type-fest";

type Result<Type extends object> = OptionalKeysOf<Type>;

Behavior and migration notes

The IsOptionalKeyOf reference must resolve to a type-fest import.
The rule only reports the exact distributive mapped-key shape used by TypeFest.
Custom mapped-key filters and non-distributive helpers are ignored.
Autofix is skipped when OptionalKeysOf is shadowed in the local scope.

Additional examples

❌ Incorrect — Namespace import

import type * as TypeFest from "type-fest";

type Result<Type extends object> = Type extends unknown
    ? (keyof {
          [Key in keyof Type as TypeFest.IsOptionalKeyOf<
              Type,
              Key
          > extends false
              ? never
              : Key]: never;
      }) &
          keyof Type
    : never;

✅ Correct — Namespace import

import type { OptionalKeysOf } from "type-fest";

type Result<Type extends object> = OptionalKeysOf<Type>;

✅ Correct — Custom mapping

import type { IsOptionalKeyOf } from "type-fest";

type Result<Type extends object> = keyof {
    [Key in keyof Type as IsOptionalKeyOf<Type, Key> extends false
        ? never
        : Key]: never;
};

ESLint flat config example

import typefest from "eslint-plugin-typefest";

export default [
    {
        plugins: { typefest },
        rules: {
            "typefest/prefer-type-fest-optional-keys-of": "error",
        },
    },
];

When not to use it

Disable this rule if a public helper must intentionally expose the expanded mapped-type implementation.

Package documentation

TypeFest package documentation:

Source file: source/optional-keys-of.d.ts

Rule catalog ID: R121

prefer-type-fest-optional-keys-of

Targeted pattern scope

What this rule reports

Why this rule exists

❌ Incorrect

✅ Correct

Behavior and migration notes

Additional examples

❌ Incorrect — Namespace import

✅ Correct — Namespace import

✅ Correct — Custom mapping

ESLint flat config example

When not to use it

Package documentation

Further reading

Adoption resources

Targeted pattern scope​

What this rule reports​

Why this rule exists​

❌ Incorrect​

✅ Correct​

Behavior and migration notes​

Additional examples​

❌ Incorrect — Namespace import​

✅ Correct — Namespace import​

✅ Correct — Custom mapping​

ESLint flat config example​

When not to use it​

Package documentation​

Further reading​

Adoption resources​

Targeted pattern scope

What this rule reports

Why this rule exists

❌ Incorrect

✅ Correct

Behavior and migration notes

Additional examples

❌ Incorrect — Namespace import

✅ Correct — Namespace import

✅ Correct — Custom mapping

ESLint flat config example

When not to use it

Package documentation

Further reading

Adoption resources