Rules Reference

When destructuring parameters in array method callbacks, enforces each property on its own line when there are 2 or more properties

Collapse arrays with few items to one line; expand larger arrays with each item on its own line

Each object in an array starts on its own line for better visual scanning

Disallow blank lines inside array literals — after the opening bracket, before the closing bracket, and between elements

Arrow functions with complex or multiline expressions should use block body or wrap in parentheses for consistent formatting

Collapse arrow functions returning simple single-element JSX to one line

Convert block body with single return to implicit return

Curried arrow functions start on same line as =>, not on new line

Format function call arguments consistently — one per line when threshold is met

Chain closing brackets on same line: })); not scattered across lines

No empty lines between arguments or after opening/before closing parentheses

Opening brackets in function arguments stay on same line as the function call

Collapse simple arrow function calls to single line

Function calls with a single simple argument stay on one line

Space after //, space inside /* */, convert single-line blocks to //

Component props must be destructured in the function parameter

Enforce inline type annotation for component props instead of interface reference

Enforce naming based on folder: suffix for views/layouts/pages/providers, camelCase for data/constants/strings/reducers/schemas. Services folder function exports drop the Service suffix (Handler from function-naming-convention is enough). Local/private variables are not checked.

Enforce consistent folder structure (flat vs wrapped) in module folders

Disallow file/folder names that redundantly include the parent folder name as a suffix

Disallow scattered component variants that share a trailing name token — collapse them into one folder named by the shared token

SVG components must end with 'Icon' suffix; 'Icon' suffix components must return SVG

Consistent spacing in class/method definitions: space before {, no space before (

Class declarations must end with 'Class' suffix

Newline after { and before } in block statements

Empty line required between closing } and next statement

Empty line between consecutive if blocks, no empty line between single-line if/else

{ on same line as if/else if, else on same line as }

Logical expressions with more than threshold operands get one per line

If conditions exceeding threshold get one per line

No empty lines at start of case blocks or between consecutive cases

Simple ternaries on one line; complex ones (>maxOperands) get multiline formatting

No space between function name and opening parenthesis

Convert function declarations to const arrow function expressions

Functions use camelCase, start with verb (get/set/fetch/post/put/patch/delete/...), end with Handler suffix. Functions in reducers/ folder are exempted (folder-based-naming-convention enforces Reducer suffix there instead).

Non-component functions should accept typed params and destructure in the body. Detects dot notation access of object params and suggests destructuring. Also enforces dot notation for module imports (configurable via moduleImportStyle option). Supports nested destructure with aliases, JSX usage, and three styles: smart (default), strict-dot, destructure.

When multiline, each parameter on its own line

No empty lines between parameters

React hooks: callback on new line, deps array on separate line

When hook deps exceed threshold, each dependency on its own line

Hook files in module subfolders must include the module name

Hook function name must match camelCase of file name

Boolean useState variables must start with is/has/with/without prefix

Use alias imports from index files, no relative imports across folders

Collapse short exports to one line; expand larger ones

Collapse short imports to one line; expand larger ones

No leading/trailing spaces inside import path strings

Index files: compact re-exports; regular files: blank lines between exports

Index files should only contain imports and re-exports, not code definitions. Subfolder indexes must contain component code (not a barrel); a component index must not re-export sibling modules it does not use — those belong in the module root barrel. Redux subfolders (types/, actions/, reducers/, etc.) are each treated as their own module root.

Enforce inline export declarations instead of grouped export statements

Index files must export all folder contents. A nested folder item is also considered exported when the module root barrel deep-exports it (e.g. export { CopyButton } from "./button/copy"), so a component index need not re-export its own siblings.

Dynamic expressions in className must be at the end of class strings

Long className strings broken into multiple lines

No extra/leading/trailing spaces in class strings

Tailwind class ordering in variables, objects, and return statements

Multiple JSX children: each on own line

No space before > or /> in JSX tags

Nested JSX elements on new lines; text children can stay inline

Remove unnecessary parens around conditions and JSX in logical expressions

Opening ( for multiline JSX on same line as return/=>

Props: camelCase for regular, kebab-case for data-*/aria-*

Collapse simple JSX with single text/expression child to one line

No leading/trailing whitespace inside JSX string attribute values

Simple ternaries on one line; complex branches get parens with indentation

No empty lines between children or after opening/before closing tags

No empty lines between properties or after {/before }

Collapse objects with 1 property; expand larger objects

Opening { of object value on same line as :, not on new line

Simple property values on same line as :

No leading/trailing whitespace inside string property keys

Assignment values start on same line as = (declarations and assignment expressions)

No spaces inside brackets in computed member expressions

Enforce consistent ordering in components: refs > state > redux > router > context > hooks > derived > memo > callback > handlers > effects > return

Enforce importing strings from constants/strings modules instead of hardcoding (skips CSS-style props, CSS-in-JS templates, responsive breakpoint objects)

Enforce enum naming (PascalCase + Enum suffix), UPPER_CASE members, trailing commas

Use enum values instead of string literals for variables typed with *Type

Enforce interface naming (PascalCase + Interface suffix), camelCase properties, commas

Inline union types in function params should be extracted to named types

Boolean props start with is/has/with/without, callbacks start with on

No space before colon, one space after colon, no space before generics

Enforce type naming (PascalCase + Type suffix), properties, union formatting

Enforce TypeScript definitions to be in designated folders (interfaces/, types/, enums/)

camelCase for variables, PascalCase for components, use prefix for hooks. Supports opt-in path-scoped case allowances (e.g., SCREAMING_SNAKE_CASE in Redux types folders)