prefer-ts-extras-object-keys

Prefer objectKeys from ts-extras over Object.keys(...).

objectKeys(...) preserves stronger key typing and avoids repeated casts in iteration paths.

Targeted pattern scope

This rule focuses on direct Object.keys(value) calls that can be migrated to objectKeys(value) with deterministic fixes.

Object.keys(value) call sites that can use objectKeys(value).

Alias indirection, wrapper helpers, and non-canonical call shapes are excluded to keep objectKeys(value) migrations safe.

What this rule reports

This rule reports Object.keys(value) call sites when objectKeys(value) is the intended replacement.

Object.keys(value) call sites that can use objectKeys(value).

Why this rule exists

objectKeys improves key typing for indexed access and iteration paths.

Fewer as Array<keyof T> casts in loops.
Safer indexed reads after key iteration.
One canonical helper for key iteration patterns.

❌ Incorrect

const keys = Object.keys(monitorConfig);

✅ Correct

const keys = objectKeys(monitorConfig);

Behavior and migration notes

Runtime semantics align with Object.keys (own enumerable string keys only).
Symbol keys are excluded, same as native behavior.
Numeric keys are still returned as strings, matching native output.

Additional examples

❌ Incorrect — Additional example

const keys = Object.keys(model);

✅ Correct — Additional example

const keys = objectKeys(model);

✅ Correct — Repository-wide usage

for (const key of objectKeys(theme)) {
    void key;
}

ESLint flat config example

import typefest from "eslint-plugin-typefest";

export default [
    {
        plugins: { typefest },
        rules: {
            "typefest/prefer-ts-extras-object-keys": "error",
        },
    },
];

When not to use it

Disable this rule if you must keep direct Object.keys calls for interop constraints.

Package documentation

ts-extras package documentation:

Source file: source/object-keys.ts

/**
A strongly-typed version of `Object.keys()`.

This is useful since `Object.keys()` always returns an array of strings. This function returns a strongly-typed array of the keys of the given object.

- [Explanation](https://stackoverflow.com/questions/55012174/why-doesnt-object-keys-return-a-keyof-type-in-typescript)
- [TypeScript issues about this](https://github.com/microsoft/TypeScript/issues/45390)

@example
```
import {objectKeys} from 'ts-extras';

const stronglyTypedItems = objectKeys({a: 1, b: 2, c: 3}); // => Array<'a' | 'b' | 'c'>
const untypedItems = Object.keys({a: 1, b: 2, c: 3}); // => Array<string>
```

@category Improved builtin
@category Type guard
*/

Rule catalog ID: R030

prefer-ts-extras-object-keys

Targeted pattern scope

What this rule reports

Why this rule exists

❌ Incorrect

✅ Correct

Behavior and migration notes

Additional examples

❌ Incorrect — Additional example

✅ Correct — Additional example

✅ Correct — Repository-wide usage

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 — Additional example​

✅ Correct — Additional example​

✅ Correct — Repository-wide usage​

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 — Additional example

✅ Correct — Additional example

✅ Correct — Repository-wide usage

ESLint flat config example

When not to use it

Package documentation

Further reading

Adoption resources