eslint-plugin-code-style 2.0.0 → 2.0.2

package/CLAUDE.md

@@ -1,12 +0,0 @@
-# Claude Code Configuration
-
-> For general project instructions, see [AGENTS.md](./AGENTS.md).
-
-## Claude-Specific Behavior
-
-When working on this codebase, Claude Code should:
-
-- Do NOT include `Co-Authored-By` lines in commits
-- Do NOT include Claude Code signature/footer in commits
-- Keep commit messages clean and standard (no AI attribution)
-- When user asks to "commit" with approval, follow the full release workflow in [AGENTS.md](./AGENTS.md#release-steps)

package/docs/rules/README.md

@@ -1,31 +0,0 @@
-# Rules Reference
-
-> **79 rules total** — 70 with auto-fix 🔧, 19 configurable ⚙️, 9 report-only
->
-> **Legend:** 🔧 Auto-fixable with `eslint --fix` • ⚙️ Customizable options
-
-## Categories
-
-| Category | Rules | Description |
-|----------|-------|-------------|
-| [Array Rules](./arrays.md) | 3 | Array formatting, callback destructuring, object-in-array line breaks |
-| [Arrow Function Rules](./arrow-functions.md) | 4 | Block body, simple JSX collapse, implicit return, curried arrows |
-| [Call Expression Rules](./call-expressions.md) | 6 | Argument formatting, nested brackets, opening brackets, single-line calls |
-| [Class Rules](./classes.md) | 2 | Class method formatting, naming conventions |
-| [Comment Rules](./comments.md) | 1 | Comment spacing and formatting |
-| [Component Rules](./components.md) | 6 | Props destructuring, folder naming, structure consistency, SVG icons |
-| [Control Flow Rules](./control-flow.md) | 8 | Block newlines, if/else formatting, logical expressions, ternaries, switch cases |
-| [Function Rules](./functions.md) | 6 | Call spacing, declaration style, naming, params, destructuring |
-| [Hook Rules](./hooks.md) | 3 | Callback formatting, deps-per-line, useState naming |
-| [Import/Export Rules](./imports-exports.md) | 8 | Absolute imports, format, index exports, module exports |
-| [JSX Rules](./jsx.md) | 14 | ClassName handling, children formatting, logical expressions, ternaries |
-| [Object Rules](./objects.md) | 5 | Property formatting, empty lines, string property spacing |
-| [React Rules](./react.md) | 1 | Component/hook code ordering |
-| [Spacing Rules](./spacing.md) | 2 | Assignment values, bracket spacing |
-| [String Rules](./strings.md) | 1 | No hardcoded strings |
-| [TypeScript Rules](./typescript.md) | 8 | Enum/interface/type formatting, definition location, prop naming |
-| [Variable Rules](./variables.md) | 1 | Variable naming conventions (camelCase, PascalCase) |
-
----
-
-[← Back to Main README](../../README.md)

package/docs/rules/arrays.md

@@ -1,107 +0,0 @@
-# Array Rules
-
-### `array-callback-destructure`
-
-**What it does:** When destructuring parameters in array method callbacks (map, filter, find, etc.), enforces each property on its own line when there are 2 or more properties.
-
-**Why use it:** Improves readability of array transformations by making destructured properties easy to scan vertically.
-
-```javascript
-// Good — each destructured property on its own line
-const result = items.map(({
-    name,
-    value,
-}) => `${name}: ${value}`);
-
-const filtered = users.filter(({
-    age,
-    isActive,
-}) => age > 18 && isActive);
-
-// Good — single property stays inline
-const names = items.map(({ name }) => name);
-
-// Bad — multiple properties on same line
-const result = items.map(({ name, value, id }) => `${name}: ${value}`);
-
-// Bad — hard to scan properties
-const data = records.filter(({ status, type, category }) => status === "active");
-```
-
----
-
-### `array-items-per-line`
-
-**What it does:** Controls array formatting based on the number of items. Short arrays stay on one line for compactness, while longer arrays get expanded with each item on its own line for better readability.
-
-**Why use it:** Prevents overly long single-line arrays that are hard to scan, while avoiding unnecessary vertical expansion for simple arrays.
-
-```javascript
-// Good — 3 or fewer items stay compact
-const colors = ["red", "green", "blue"];
-const nums = [1, 2, 3];
-
-// Good — 4+ items expand for readability
-const weekdays = [
-    "Monday",
-    "Tuesday",
-    "Wednesday",
-    "Thursday",
-    "Friday",
-];
-
-// Bad — too many items on one line
-const weekdays = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"];
-
-// Bad — inconsistent formatting
-const items = [item1,
-    item2, item3,
-    item4];
-```
-
-**Options:**
-
-| Option | Type | Default | Description |
-|--------|------|---------|-------------|
-| `maxItems` | `integer` | `3` | Maximum items to keep on single line |
-
-```javascript
-// Example: Allow up to 4 items on single line
-"code-style/array-items-per-line": ["error", { maxItems: 4 }]
-```
-
----
-
-### `array-objects-on-new-lines`
-
-**What it does:** In arrays containing objects, ensures each object starts on its own line regardless of object size.
-
-**Why use it:** Object literals in arrays are visually complex. Putting each on its own line makes it easier to scan, compare, and edit individual items.
-
-```javascript
-// Good — each object clearly separated
-const users = [
-    { id: 1, name: "Alice", role: "admin" },
-    { id: 2, name: "Bob", role: "user" },
-    { id: 3, name: "Charlie", role: "user" },
-];
-
-// Good — even short objects get their own line
-const points = [
-    { x: 0, y: 0 },
-    { x: 10, y: 20 },
-];
-
-// Bad — objects crammed together
-const users = [{ id: 1, name: "Alice" }, { id: 2, name: "Bob" }];
-
-// Bad — inconsistent line breaks
-const items = [{ id: 1 },
-    { id: 2 }, { id: 3 }];
-```
-
-<br />
-
----
-
-[<- Back to Rules Index](./README.md) | [<- Back to Main README](../../README.md)

package/docs/rules/arrow-functions.md

@@ -1,115 +0,0 @@
-# Arrow Function Rules
-
-### `arrow-function-block-body`
-
-**What it does:** Ensures arrow functions with multiline expressions use block body with explicit return, wrapped in parentheses when needed.
-
-**Why use it:** Multiline expressions without block body can be confusing. Clear boundaries with `{` and `}` make the function body obvious.
-
-```javascript
-// Good — block body for complex logic
-const handleSubmit = () => {
-    validateForm();
-    submitData();
-    return result;
-};
-
-// Good — multiline JSX wrapped properly
-const Button = () => (
-    <button className="primary">
-        Click me
-    </button>
-);
-
-// Bad — comma operator is confusing
-const handleSubmit = () => (validateForm(), submitData(), result);
-
-// Bad — multiline without clear boundaries
-const Button = () => <button className="primary">
-    Click me
-</button>;
-```
-
----
-
-### `arrow-function-simple-jsx`
-
-**What it does:** Collapses arrow functions that return a single simple JSX element onto one line by removing unnecessary parentheses and line breaks.
-
-**Why use it:** Simple component wrappers don't need multi-line formatting. Single-line is more scannable and reduces vertical space.
-
-```javascript
-// Good — simple JSX on one line
-export const Layout = ({ children }) => <Container>{children}</Container>;
-export const Icon = () => <SVGIcon />;
-const Wrapper = (props) => <div {...props} />;
-
-// Bad — unnecessary multi-line for simple JSX
-export const Layout = ({ children }) => (
-    <Container>{children}</Container>
-);
-
-// Bad — extra parentheses not needed
-const Icon = () => (
-    <SVGIcon />
-);
-```
-
----
-
-### `arrow-function-simplify`
-
-**What it does:** Converts arrow functions with a single return statement to use implicit return, removing the block body and `return` keyword.
-
-**Why use it:** Implicit returns are more concise and idiomatic JavaScript. They reduce noise and make the code easier to read.
-
-```javascript
-// Good — implicit return
-const double = (x) => x * 2;
-const getName = (user) => user.name;
-const items = data.map((item) => item.value);
-const isValid = (x) => x > 0 && x < 100;
-
-// Bad — unnecessary block body and return
-const double = (x) => { return x * 2; };
-const getName = (user) => { return user.name; };
-const items = data.map((item) => { return item.value; });
-const isValid = (x) => { return x > 0 && x < 100; };
-```
-
----
-
-### `curried-arrow-same-line`
-
-**What it does:** Ensures that when an arrow function returns another function, the returned function starts on the same line as `=>`.
-
-**Why use it:** Curried functions are easier to read when the chain is visible. Breaking after `=>` obscures the function structure.
-
-```javascript
-// Good — curried function visible on same line
-const createAction = (type) => (payload) => ({ type, payload });
-
-const withLogger = (fn) => (...args) => {
-    console.log("Called with:", args);
-    return fn(...args);
-};
-
-const mapDispatch = () => async (dispatch) => {
-    await dispatch(fetchData());
-};
-
-// Bad — chain broken across lines
-const createAction = (type) =>
-    (payload) => ({ type, payload });
-
-const mapDispatch = () =>
-    async (dispatch) => {
-        await dispatch(fetchData());
-    };
-```
-
-<br />
-
----
-
-[<- Back to Rules Index](./README.md) | [<- Back to Main README](../../README.md)

package/docs/rules/call-expressions.md

@@ -1,275 +0,0 @@
-# Call Expression Rules
-
-### `function-arguments-format`
-
-**What it does:** Enforces consistent formatting for function call arguments:
-- Single simple argument stays on one line
-- 2+ arguments get one per line
-- Multiline arguments trigger full expansion
-- React hooks are skipped by default (they have their own rule)
-
-**Why use it:** Consistent argument formatting makes function calls scannable and diffs clean when adding/removing arguments.
-
-```javascript
-// Good — single argument stays compact
-fetchUser(userId);
-console.log(message);
-dispatch(action);
-
-// Good — 2+ arguments get one per line
-setValue(
-    "email",
-    "user@example.com",
-);
-
-createUser(
-    name,
-    email,
-    password,
-);
-
-// Good — multiline argument triggers expansion
-processData(
-    {
-        id: 1,
-        name: "test",
-    },
-);
-
-// Good — callback with body triggers expansion
-items.forEach(
-    (item) => {
-        process(item);
-        save(item);
-    },
-);
-
-// Bad — multiple arguments on same line
-setValue("email", "user@example.com");
-createUser(name, email, password);
-
-// Bad — inconsistent formatting
-fn(arg1,
-    arg2, arg3);
-```
-
-**Options:**
-
-| Option | Type | Default | Description |
-|--------|------|---------|-------------|
-| `minArgs` | `integer` | `2` | Minimum arguments to enforce multiline |
-| `skipHooks` | `boolean` | `true` | Skip React hooks (useEffect, etc.) |
-| `skipSingleArg` | `boolean` | `true` | Skip calls with single complex argument |
-
-```javascript
-// Example: Require multiline for 3+ arguments
-"code-style/function-arguments-format": ["error", { minArgs: 3 }]
-
-// Example: Don't skip React hooks
-"code-style/function-arguments-format": ["error", { skipHooks: false }]
-```
-
----
-
-### `nested-call-closing-brackets`
-
-**What it does:** Ensures nested function calls (common in styled-components, HOCs) have closing brackets on the same line: `}));`
-
-**Why use it:** Scattered closing brackets (`}\n);\n` ) waste vertical space and make it harder to see where expressions end.
-
-```javascript
-// Good — closing brackets together
-const StyledCard = styled(Card)(({ theme }) => ({
-    color: theme.palette.text.primary,
-    padding: theme.spacing(2),
-}));
-
-const StyledButton = styled("button")(({ theme }) => ({
-    backgroundColor: theme.colors.primary,
-}));
-
-// Good — multiple levels
-const Component = connect(
-    mapStateToProps,
-    mapDispatchToProps,
-)(withRouter(MyComponent));
-
-// Bad — closing brackets scattered
-const StyledCard = styled(Card)(({ theme }) => ({
-    color: theme.palette.text.primary,
-})
-);
-
-// Bad — each bracket on its own line
-const StyledCard = styled(Card)(({ theme }) => ({
-    color: theme.colors.primary,
-})
-)
-;
-```
-
----
-
-### `no-empty-lines-in-function-calls`
-
-**What it does:** Removes empty lines within function call argument lists — between arguments and after opening/before closing parentheses.
-
-**Why use it:** Empty lines between arguments break visual grouping. Arguments should flow as a cohesive list.
-
-```javascript
-// Good — no empty lines
-createUser(
-    name,
-    email,
-    password,
-    role,
-);
-
-fetchData(
-    url,
-    {
-        method: "POST",
-        body: data,
-    },
-);
-
-// Bad — empty line between arguments
-createUser(
-    name,
-
-    email,
-
-    password,
-);
-
-// Bad — empty line after opening paren
-fetchData(
-
-    url,
-    options,
-);
-
-// Bad — empty line before closing paren
-fetchData(
-    url,
-    options,
-
-);
-```
-
----
-
-### `opening-brackets-same-line`
-
-**What it does:** Ensures opening brackets (`{`, `[`, `(`) in function arguments stay on the same line as the function call.
-
-**Why use it:** Opening brackets on new lines create unnecessary indentation and vertical space.
-
-```javascript
-// Good — brackets on same line as call
-fn({ key: value });
-process([1, 2, 3]);
-items.map(({ id }) => id);
-configure({ debug: true });
-
-// Good — multiline content is fine
-fn({
-    key: value,
-    other: data,
-});
-
-items.map(({ id, name }) => (
-    <Item key={id} name={name} />
-));
-
-// Bad — opening bracket on new line
-fn(
-    { key: value }
-);
-
-process(
-    [1, 2, 3]
-);
-
-items.map(
-    ({ id }) => id
-);
-```
-
----
-
-### `simple-call-single-line`
-
-**What it does:** Collapses simple function calls with an arrow function onto one line when the result fits within 120 characters. Handles:
-- Zero-param callbacks: `lazy(() => import("./Page"))`
-- Callbacks with params and simple expression bodies: `.find((f) => f.code === x)`
-- Optional chaining: `.find(...)?.symbol`
-
-**Why use it:** Common patterns like `lazy(() => import(...))` and `.find((item) => item.id === id)` don't need multiline formatting. Single line is cleaner.
-
-```javascript
-// Good — simple patterns on one line
-const Page = lazy(() => import("./Page"));
-setTimeout(() => callback(), 100);
-const symbol = items.find(({ code }) => code === currency)?.symbol;
-
-// Good — complex callbacks stay multiline
-const Page = lazy(() => {
-    console.log("Loading page");
-    return import("./Page");
-});
-
-// Bad — unnecessary multiline for simple pattern
-const Page = lazy(
-    () => import("./Page"),
-);
-
-const symbol = items.find(({ code }) =>
-    code === currency)?.symbol;
-
-const symbol = items.find(({ code }) => code === currency)?.
-    symbol;
-```
-
----
-
-### `single-argument-on-one-line`
-
-**What it does:** Ensures function calls with a single simple argument (literal, identifier, member expression) stay on one line.
-
-**Why use it:** Single-argument calls don't need multiline formatting. Expanding them wastes vertical space.
-
-```javascript
-// Good — single argument on one line
-fetchUser(userId);
-console.log(message);
-process(data.items);
-dispatch(action);
-setValue("key");
-getElement(document.body);
-
-// Good — complex single argument can be multiline
-processConfig({
-    key: value,
-    other: data,
-});
-
-// Bad — simple argument expanded unnecessarily
-fetchUser(
-    userId,
-);
-
-console.log(
-    message,
-);
-
-dispatch(
-    action,
-);
-```
-
-<br />
-
----
-
-[<- Back to Rules Index](./README.md) | [<- Back to Main README](../../README.md)

package/docs/rules/classes.md

@@ -1,88 +0,0 @@
-# Class Rules
-
-### `class-method-definition-format`
-
-**What it does:** Enforces consistent spacing in class and method definitions:
-- Space before opening brace `{` in class declarations
-- No space between method name and opening parenthesis `(`
-- Space before opening brace `{` in method definitions
-- Opening brace must be on same line as class/method signature
-
-**Why use it:** Consistent formatting makes code more readable and prevents common spacing inconsistencies in class definitions.
-
-```javascript
-// Good — proper spacing in class and methods
-class ApiServiceClass {
-    getDataHandler(): string {
-        return "data";
-    }
-
-    async fetchUserHandler(id: string): Promise<User> {
-        return await this.fetch(id);
-    }
-}
-
-// Bad — missing space before { in class
-class ApiServiceClass{
-    getDataHandler(): string {
-        return "data";
-    }
-}
-
-// Bad — space between method name and (
-class ApiServiceClass {
-    getDataHandler (): string {
-        return "data";
-    }
-}
-
-// Bad — missing space before { in method
-class ApiServiceClass {
-    getDataHandler(): string{
-        return "data";
-    }
-}
-
-// Bad — opening brace on different line
-class ApiServiceClass {
-    getDataHandler(): string
-    {
-        return "data";
-    }
-}
-```
-
----
-
-### `class-naming-convention`
-
-**What it does:** Enforces that class declarations must end with "Class" suffix. This distinguishes class definitions from other PascalCase names like React components or type definitions.
-
-**Why use it:** Clear naming conventions prevent confusion between classes, components, and types. The "Class" suffix immediately identifies the construct.
-
-```javascript
-// Good — class ends with "Class"
-class ApiServiceClass {
-    constructor() {}
-    fetch() {}
-}
-
-class UserRepositoryClass {
-    save(user) {}
-}
-
-// Bad — missing "Class" suffix
-class ApiService {
-    constructor() {}
-}
-
-class UserRepository {
-    save(user) {}
-}
-```
-
-<br />
-
----
-
-[<- Back to Rules Index](./README.md) | [<- Back to Main README](../../README.md)

package/docs/rules/comments.md

@@ -1,42 +0,0 @@
-# Comment Rules
-
-### `comment-format`
-
-**What it does:** Enforces proper comment formatting:
-- Space after `//` in line comments
-- Space after `/*` and before `*/` in block comments
-- Single-line block comments converted to line comments
-- No blank lines between consecutive comments at file top
-
-**Why use it:** Consistent comment formatting improves readability and maintains a clean, professional codebase.
-
-```javascript
-// Good — proper spacing
-// This is a comment
-/* This is a block comment */
-
-/*
- * This is a multi-line
- * block comment
- */
-
-// Good — file-top comments without gaps
-// File: utils.js
-// Author: John Doe
-// License: MIT
-
-// Bad — missing space after //
-//This is a comment
-
-// Bad — no space in block comment
-/*No space*/
-
-// Bad — single-line block should be line comment
-/* This should use // syntax */
-```
-
-<br />
-
----
-
-[<- Back to Rules Index](./README.md) | [<- Back to Main README](../../README.md)