eslint-plugin-code-style 1.2.7 → 1.3.2

package/AGENTS.md

@@ -4,9 +4,9 @@ Instructions for AI coding agents working with this codebase.
 
 ## Project Overview
 
-**eslint-plugin-code-style** is an ESLint plugin providing 60 custom auto-fixable formatting rules for React/JSX projects. It's designed for ESLint v9+ flat config system.
+**eslint-plugin-code-style** is an ESLint plugin providing 61 custom auto-fixable formatting rules for React/JSX projects. It's designed for ESLint v9+ flat config system.
 
-- **Main entry:** `index.js` - Contains all 60 rules in a single file
+- **Main entry:** `index.js` - Contains all 61 rules in a single file
 - **Type definitions:** `index.d.ts` - TypeScript declarations for IDE support
 - **Recommended configs:** `recommended-configs/` - Ready-to-use ESLint configurations
 - **Test apps:** `_tests_/` - Sample apps for testing rules
@@ -44,7 +44,7 @@ index.js
 ├── imports (fs, path, url)
 ├── Rule 1 definition (const ruleName = { create(), meta: {} })
 ├── Rule 2 definition
-├── ... (60 rules total)
+├── ... (61 rules total)
 └── export default { meta: {}, rules: {} }
 ```
 
@@ -111,15 +111,113 @@ const ruleName = {
 };
 ```
 
-### Adding a New Rule
+### Adding a New Rule — Complete Checklist
 
-1. Add the rule definition (const) following the pattern above
-2. Add to the `rules` object in the default export (keep alphabetical within categories)
-3. Update `index.d.ts` to add the rule name to the `RuleNames` type
-4. Update `README.md`:
-   - Add to the Rules Summary table
-   - Add detailed description with examples
-5. Add to relevant recommended configs in `recommended-configs/`
+When creating a new rule, ALL of the following files must be updated:
+
+#### 1. `index.js` — Rule Implementation
+- [ ] Add JSDoc comment block with the standard format (see Rule Implementation Pattern above)
+- [ ] Include: Description, Options (if any), Good examples, Bad examples
+- [ ] Add `const ruleName = { create(), meta: {} }` definition
+- [ ] Add to `rules` object in default export (keep alphabetical order)
+- [ ] Update the rule count in any comments if present
+
+#### 2. `index.d.ts` — TypeScript Types
+- [ ] Add rule name to `RuleNames` type union (alphabetically sorted)
+- [ ] Add rule to `PluginRules` interface (alphabetically sorted)
+
+#### 3. `AGENTS.md` — Agent Instructions
+- [ ] Update rule count in "Project Overview" section (e.g., "61 custom auto-fixable formatting rules")
+- [ ] Update rule count in "Code Structure" section
+- [ ] Add rule to its category in "[Rule Categories](#rule-categories)" section (see list below for all categories)
+- [ ] Update rule count in "Documentation Files" section
+
+#### 4. `README.md` — Main Documentation
+- [ ] Update rule count in badges/header section
+- [ ] Update rule count in "Why This Plugin?" section
+- [ ] Update rule count in "Key Features" section
+- [ ] Update rule count in "Auto-Fixable Rules" section
+- [ ] Add rule to `rules: {}` example in "Quick Start" section
+- [ ] Add rule to "Rules Summary" table (with description)
+- [ ] Add detailed rule documentation with:
+  - "What it does" description
+  - Code examples (Good ✅ and Bad ❌)
+  - Options table (if rule has options)
+  - Configuration example (if rule has options)
+
+#### 5. Config Files — Add Rule to Configs
+- [ ] `recommended-configs/react/eslint.config.js`
+- [ ] `recommended-configs/react-ts-tw/eslint.config.js`
+- [ ] `_tests_/react/eslint.config.js`
+- [ ] `_tests_/react-ts-tw/eslint.config.js`
+
+#### 6. Config READMEs (if rule count changed)
+- [ ] `recommended-configs/react/README.md` — Update any rule counts
+- [ ] `recommended-configs/react-ts-tw/README.md` — Update any rule counts
+
+---
+
+### Editing an Existing Rule — Checklist
+
+When modifying an existing rule, check if these need updates:
+
+#### If changing rule behavior:
+- [ ] Update JSDoc in `index.js` (Good/Bad examples)
+- [ ] Update `README.md` rule documentation (examples, description)
+- [ ] Test in `_tests_/` apps with `npm run lint` and `npm run lint:fix`
+
+#### If adding new options:
+- [ ] Add option to `schema` in rule's `meta` object
+- [ ] Add option handling in `create()` function
+- [ ] Update JSDoc Options section in `index.js`
+- [ ] Update README.md options table for the rule
+- [ ] Add configuration example in README.md
+
+#### If adding auto-fix to rule that didn't have it:
+- [ ] Add `fixable: "code"` to rule's `meta` object
+- [ ] Add `fix()` function in `context.report()`
+
+#### If changing default values:
+- [ ] Update JSDoc in `index.js`
+- [ ] Update README.md options table
+- [ ] Consider if this is a MAJOR version bump (breaking change)
+
+---
+
+### Rule Documentation Format in README.md
+
+Each rule should have this format in the Rules Reference section:
+
+```markdown
+### `rule-name`
+
+**What it does:** One-line description of the rule's purpose.
+
+**Why use it:** Optional context for why this rule is helpful.
+
+> **Note:** Any special notes or dependencies (optional).
+
+\`\`\`javascript
+// ✅ Good — description
+const example = "correct code";
+
+// ❌ Bad — description
+const example = "incorrect code";
+\`\`\`
+
+**Options:** (if rule has options)
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `optionName` | `string` | `"value"` | What the option does |
+
+\`\`\`javascript
+// Configuration example
+"code-style/rule-name": ["error", { optionName: "value" }]
+\`\`\`
+
+---
+```
 
 ## Key Patterns & Conventions
 
@@ -200,21 +298,36 @@ if (node.parent?.type === "CallExpression") return;
 
 Rules are organized in these categories (alphabetically sorted in index.js and README.md):
 
-- **Array Rules:** `array-items-per-line`, `array-objects-on-new-lines`
-- **Arrow Function Rules:** `arrow-function-block-body`, `arrow-function-simple-jsx`, `arrow-function-simplify`, `curried-arrow-same-line`
-- **Call Expression Rules:** `function-arguments-format`, `nested-call-closing-brackets`, `no-empty-lines-in-function-calls`, `opening-brackets-same-line`, `simple-call-single-line`, `single-argument-on-one-line`
-- **Comment Rules:** `comment-format`
-- **Component Rules:** `component-props-destructure`, `component-props-inline-type`
-- **Control Flow Rules:** `block-statement-newlines`, `if-statement-format`, `multiline-if-conditions`, `no-empty-lines-in-switch-cases`
-- **Function Rules:** `function-call-spacing`, `function-naming-convention`, `function-object-destructure`, `function-params-per-line`, `no-empty-lines-in-function-params`
-- **Hook Rules:** `hook-callback-format`, `hook-deps-per-line`
-- **Import/Export Rules:** `absolute-imports-only`, `export-format`, `import-format`, `import-source-spacing`, `index-export-style`, `module-index-exports`
-- **JSX Rules:** `classname-dynamic-at-end`, `classname-multiline`, `classname-no-extra-spaces`, `classname-order`, `jsx-children-on-new-line`, `jsx-closing-bracket-spacing`, `jsx-element-child-new-line`, `jsx-logical-expression-simplify`, `jsx-parentheses-position`, `jsx-prop-naming-convention`, `jsx-simple-element-one-line`, `jsx-string-value-trim`, `jsx-ternary-format`, `no-empty-lines-in-jsx`
-- **Object Rules:** `no-empty-lines-in-objects`, `object-property-per-line`, `object-property-value-brace`, `object-property-value-format`, `string-property-spacing`
-- **React Rules:** `react-code-order`
-- **Spacing Rules:** `assignment-value-same-line`, `member-expression-bracket-spacing`
-- **TypeScript Rules:** `enum-format`, `interface-format`, `type-annotation-spacing`, `type-format`, `typescript-definition-location`
-- **Variable Rules:** `variable-naming-convention`
+- **Array Rules** — Rules for array formatting
+  - `array-items-per-line`, `array-objects-on-new-lines`
+- **Arrow Function Rules** — Arrow function syntax and style
+  - `arrow-function-block-body`, `arrow-function-simple-jsx`, `arrow-function-simplify`, `curried-arrow-same-line`
+- **Call Expression Rules** — Function call formatting
+  - `function-arguments-format`, `nested-call-closing-brackets`, `no-empty-lines-in-function-calls`, `opening-brackets-same-line`, `simple-call-single-line`, `single-argument-on-one-line`
+- **Comment Rules** — Comment formatting
+  - `comment-format`
+- **Component Rules** — React component patterns
+  - `component-props-destructure`, `component-props-inline-type`
+- **Control Flow Rules** — if/switch/block statements
+  - `block-statement-newlines`, `if-statement-format`, `multiline-if-conditions`, `no-empty-lines-in-switch-cases`
+- **Function Rules** — Function declarations and params
+  - `function-call-spacing`, `function-declaration-style`, `function-naming-convention`, `function-object-destructure`, `function-params-per-line`, `no-empty-lines-in-function-params`
+- **Hook Rules** — React hooks formatting
+  - `hook-callback-format`, `hook-deps-per-line`
+- **Import/Export Rules** — Import/export statements
+  - `absolute-imports-only`, `export-format`, `import-format`, `import-source-spacing`, `index-export-style`, `module-index-exports`
+- **JSX Rules** — JSX elements and attributes
+  - `classname-dynamic-at-end`, `classname-multiline`, `classname-no-extra-spaces`, `classname-order`, `jsx-children-on-new-line`, `jsx-closing-bracket-spacing`, `jsx-element-child-new-line`, `jsx-logical-expression-simplify`, `jsx-parentheses-position`, `jsx-prop-naming-convention`, `jsx-simple-element-one-line`, `jsx-string-value-trim`, `jsx-ternary-format`, `no-empty-lines-in-jsx`
+- **Object Rules** — Object literal formatting
+  - `no-empty-lines-in-objects`, `object-property-per-line`, `object-property-value-brace`, `object-property-value-format`, `string-property-spacing`
+- **React Rules** — React-specific patterns
+  - `react-code-order`
+- **Spacing Rules** — General spacing rules
+  - `assignment-value-same-line`, `member-expression-bracket-spacing`
+- **TypeScript Rules** — TypeScript-specific rules (TS configs only)
+  - `enum-format`, `interface-format`, `type-annotation-spacing`, `type-format`, `typescript-definition-location`
+- **Variable Rules** — Variable declarations and naming
+  - `variable-naming-convention`
 
 ## Naming Conventions
 
@@ -230,7 +343,7 @@ Rules are organized in these categories (alphabetically sorted in index.js and R
 
 ## Documentation Files
 
-- `README.md` - Main documentation with all 60 rules
+- `README.md` - Main documentation with all 61 rules
 - `recommended-configs/<config-name>/README.md` - Config-specific documentation (references main README for rule details)
 - `index.d.ts` - TypeScript types for IDE autocomplete
 
@@ -241,3 +354,324 @@ Rules are organized in these categories (alphabetically sorted in index.js and R
 - Object properties in `context.report()` must be alphabetically sorted
 - Keep rules self-sufficient (no dependencies on other ESLint rules)
 - Test with relevant test app in `_tests_/` before publishing
+
+## Git Workflow
+
+### Commit Message Format
+
+Follow [Conventional Commits](https://www.conventionalcommits.org/) specification:
+
+```
+<type>: <subject>
+
+[optional body]
+```
+
+**Types:**
+- `feat` - New feature or rule
+- `fix` - Bug fix
+- `docs` - Documentation only changes
+- `refactor` - Code change that neither fixes a bug nor adds a feature
+- `chore` - Maintenance tasks (deps, configs)
+
+**Subject line rules:**
+- Use lowercase (except proper nouns)
+- No period at the end
+- Maximum 72 characters
+- Use imperative mood ("add" not "added")
+
+**Examples:**
+```
+feat: add function-declaration-style rule
+fix: allow relative imports in entry files
+docs: update options descriptions
+```
+
+**Multi-feature commits:**
+```
+feat: add function-declaration-style rule and enhancements
+
+New rule:
+- function-declaration-style: auto-fixes to arrow expressions
+
+Enhancements:
+- function-naming-convention: add auto-fix
+```
+
+---
+
+### Versioning (SemVer)
+
+Format: `MAJOR.MINOR.PATCH` (e.g., `1.2.8`)
+
+| Change Type | Version | Examples |
+|-------------|---------|----------|
+| **PATCH** | `x.x.+1` | Bug fixes, typo corrections, doc updates |
+| **MINOR** | `x.+1.0` | New rules, new features, new options |
+| **MAJOR** | `+1.0.0` | Breaking changes, removed/renamed rules |
+
+**Decision guide:**
+- New rule → MINOR
+- Auto-fix to existing rule → MINOR
+- New option → MINOR
+- Bug fix → PATCH
+- Doc update only → PATCH
+- Change default values → MAJOR (breaking)
+- Rename/remove rule → MAJOR (breaking)
+
+---
+
+### Release Steps
+
+1. **Update version in package.json**
+2. **Commit changes:** `git commit -m "feat: description"`
+3. **Create annotated tag:**
+   ```bash
+   git tag -a v1.2.9 -m "v1.2.9
+
+   - Feature description 1
+   - Feature description 2"
+   ```
+4. **Push (requires explicit approval):** `git push origin HEAD && git push origin v1.2.9`
+5. **Publish (requires explicit approval):** `npm publish`
+
+---
+
+### GitHub Releases (Grouped Tags)
+
+GitHub Releases group multiple version tags into a single release announcement. Create a release when a significant milestone is reached (new features, major enhancements).
+
+**When to create a GitHub Release:**
+- After multiple PATCH/MINOR versions accumulate significant changes
+- When a new major feature is complete
+- At logical milestones (e.g., v1.2.0 → v1.3.0)
+
+**Release format:**
+
+```markdown
+## Release Title
+<Short, descriptive title summarizing the main changes>
+
+## Version Range
+vX.X.X → vY.Y.Y
+
+---
+
+## What's New
+
+<Brief intro paragraph mentioning key highlights and rule count change>
+
+### New Rules
+
+| Rule | Description |
+|------|-------------|
+| `rule-name` | What it does |
+
+### Enhancements
+
+| Rule | Enhancement |
+|------|-------------|
+| `rule-name` | What was improved |
+
+### New Features
+
+- Feature 1 description
+- Feature 2 description
+
+### Bug Fixes
+
+- Fix 1 description
+- Fix 2 description
+
+### Documentation
+
+- Doc change 1
+- Doc change 2
+
+## Installation
+
+\`\`\`bash
+npm install eslint-plugin-code-style@Y.Y.Y
+\`\`\`
+
+## Stats
+
+- Total Rules: X (was Y)
+- All rules are auto-fixable with `eslint --fix`
+
+**Full Changelog**: https://github.com/Mohamed-Elhawary/eslint-plugin-code-style/compare/vX.X.X...vY.Y.Y
+```
+
+**Steps to create a GitHub Release:**
+
+1. Go to repository → Releases → "Draft a new release"
+2. Choose the latest tag (e.g., `v1.3.0`)
+3. Set release title (short, descriptive)
+4. Paste the release description following the format above
+5. Update `CHANGELOG.md` with the same information
+6. Publish release
+
+**CHANGELOG.md:**
+
+All releases are documented in `CHANGELOG.md` at the project root. Update this file whenever creating a GitHub Release.
+
+Each release entry in CHANGELOG.md must include a **Full Changelog** link at the end:
+
+```markdown
+**Full Changelog:** https://github.com/Mohamed-Elhawary/eslint-plugin-code-style/compare/vFIRST...vLAST
+```
+
+Where:
+- `vFIRST` = First version tag in the release range (the tag after the last tag of the previous release)
+- `vLAST` = Last version tag in the release range (current release)
+
+Example: For release 1.2.0 with version range v1.1.10 → v1.2.0:
+```markdown
+**Full Changelog:** https://github.com/Mohamed-Elhawary/eslint-plugin-code-style/compare/v1.1.10...v1.2.0
+```
+
+## Skills
+
+This project includes reusable skills in the `.skills/` directory following the [Agent Skills](https://agentskills.io) open standard. These work with Claude Code, Cursor, VS Code, GitHub Copilot, Gemini CLI, and other compatible agents.
+
+| Skill | Description |
+|-------|-------------|
+| `test-rule` | Test an ESLint rule after creating or modifying it |
+| `validate-types` | Verify TypeScript definitions match rules in index.js |
+| `review-config` | Review a recommended ESLint configuration |
+| `audit-docs` | Verify documentation accuracy across all files |
+
+See `.skills/*/SKILL.md` for detailed instructions.
+
+---
+
+## Workflows
+
+Reusable workflows for common tasks. Any AI agent should follow these when performing the specified task.
+
+---
+
+### Workflow: Test Rule
+
+Test an ESLint rule to verify it works correctly.
+
+**When to use:** After creating or modifying a rule.
+
+**Steps:**
+
+1. **Find the rule** in `index.js` and understand what it checks
+2. **Identify test app** — Use `_tests_/react/` for JS rules or `_tests_/react-ts-tw/` for TS rules
+3. **Create test cases** in the test app:
+   - Add code that should PASS (no violations)
+   - Add code that should FAIL (triggers violations)
+4. **Run the linter:**
+   ```bash
+   cd _tests_/<config-name>
+   npm run lint        # Check for violations
+   npm run lint:fix    # Verify auto-fix works
+   ```
+5. **Verify results:**
+   - Valid code produces no errors
+   - Invalid code triggers the expected error message
+   - Auto-fix transforms code correctly
+
+---
+
+### Workflow: Validate Types
+
+Verify TypeScript definitions match the rules in `index.js`.
+
+**When to use:** After adding new rules or before releases.
+
+**Steps:**
+
+1. **Count rules in index.js:**
+   ```bash
+   grep -c "^const .* = {$" index.js
+   ```
+   Or count entries in the `rules` export object.
+
+2. **Check index.d.ts:**
+   - Verify `RuleNames` type includes all rule names (alphabetically sorted)
+   - Verify `PluginRules` interface includes all rules
+
+3. **Look for mismatches:**
+   - Rules in `index.js` missing from `index.d.ts`?
+   - Rules in `index.d.ts` that don't exist in `index.js`?
+
+4. **Report:**
+   - Total rules: X
+   - Types match: Yes/No
+   - Missing types: [list]
+   - Extra types: [list]
+
+---
+
+### Workflow: Review Config
+
+Review a recommended ESLint configuration for consistency.
+
+**When to use:** After adding rules or modifying configs.
+
+**Arguments:** `<config-name>` (e.g., `react`, `react-ts-tw`)
+
+**Steps:**
+
+1. **Check config file:** `recommended-configs/<config-name>/eslint.config.js`
+   - Does it import the plugin correctly?
+   - Are rules set to `"error"` (not `"off"`)?
+   - Are rule options valid per the rule's schema?
+
+2. **Compare with test config:** `_tests_/<config-name>/eslint.config.js`
+   - Should have the same rules enabled
+   - Test config may have additional test-specific settings
+
+3. **Test the config:**
+   ```bash
+   cd _tests_/<config-name>
+   npm run lint
+   ```
+
+4. **Check README:** `recommended-configs/<config-name>/README.md`
+   - Does it list all enabled rules?
+   - Are rule counts accurate?
+
+5. **Report:**
+   - Config valid: Yes/No
+   - Rules enabled: X
+   - Issues found: [list]
+
+---
+
+### Workflow: Audit Docs
+
+Verify documentation accuracy across all files.
+
+**When to use:** Before releases or after adding rules.
+
+**Steps:**
+
+1. **Count actual rules:**
+   ```bash
+   grep -c "^const .* = {$" index.js
+   ```
+
+2. **Check rule count references:**
+   - `AGENTS.md`: "61 custom auto-fixable formatting rules"
+   - `README.md`: Multiple mentions of rule count
+   - `recommended-configs/*/README.md`: Any rule count mentions
+
+3. **Verify version consistency:**
+   - `package.json` version matches latest tag
+   - No outdated version references in docs
+
+4. **Check links:**
+   - Config paths in README exist
+   - Test app paths exist
+   - Internal markdown links work
+
+5. **Report:**
+   - Actual rule count: X
+   - Documented counts match: Yes/No
+   - Outdated references: [list]
+   - Broken links: [list]

package/README.md

@@ -10,7 +10,7 @@
 [![Node.js](https://img.shields.io/badge/Node.js-%3E%3D20.0.0-339933?style=for-the-badge&logo=node.js&logoColor=white)](https://nodejs.org/)
 [![React](https://img.shields.io/badge/React-JSX%20Support-61DAFB?style=for-the-badge&logo=react&logoColor=black)](https://react.dev/)
 [![TypeScript](https://img.shields.io/badge/TypeScript-%3E%3D5.0.0-3178C6?style=for-the-badge&logo=typescript&logoColor=white)](https://www.typescriptlang.org/)
-[![Tailwind CSS](https://img.shields.io/badge/Tailwind%20CSS-%3E%3D4.0.0-06B6D4?style=for-the-badge&logo=tailwindcss&logoColor=white)](https://tailwindcss.com/)
+[![Tailwind CSS](https://img.shields.io/badge/Tailwind%20CSS-%3E%3D3.0.0-06B6D4?style=for-the-badge&logo=tailwindcss&logoColor=white)](https://tailwindcss.com/)
 
 [![GitHub stars](https://img.shields.io/github/stars/Mohamed-Elhawary/eslint-plugin-code-style?style=for-the-badge&logo=github&color=yellow)](https://github.com/Mohamed-Elhawary/eslint-plugin-code-style/stargazers)
 [![GitHub issues](https://img.shields.io/github/issues/Mohamed-Elhawary/eslint-plugin-code-style?style=for-the-badge&logo=github)](https://github.com/Mohamed-Elhawary/eslint-plugin-code-style/issues)
@@ -19,7 +19,7 @@
 
 **A powerful ESLint plugin for enforcing consistent code formatting and style rules in React/JSX projects.**
 
-*60 auto-fixable rules to keep your codebase clean and consistent*
+*61 auto-fixable rules to keep your codebase clean and consistent*
 
 </div>
 
@@ -27,7 +27,7 @@
 
 ## 🎯 Why This Plugin?
 
-This plugin provides **60 custom auto-fixable rules** for code formatting. Built for **ESLint v9 flat configs**.
+This plugin provides **61 custom auto-fixable rules** for code formatting. Built for **ESLint v9 flat configs**.
 
 > **Note:** ESLint [deprecated 79 formatting rules](https://eslint.org/blog/2023/10/deprecating-formatting-rules/) in v8.53.0. Our recommended configs use `@stylistic/eslint-plugin` as the replacement for these deprecated rules.
 
@@ -36,7 +36,7 @@ This plugin provides **60 custom auto-fixable rules** for code formatting. Built
 - **Works alongside existing tools** — Complements ESLint's built-in rules and packages like eslint-plugin-react, eslint-plugin-import, etc
 - **Self-sufficient rules** — Each rule handles complete formatting independently
 - **Consistency at scale** — Reduces code-style differences between team members by enforcing uniform formatting across your projects
-- **Fully automated** — All 60 rules support auto-fix, eliminating manual style reviews
+- **Fully automated** — All 61 rules support auto-fix, eliminating manual style reviews
 
 When combined with ESLint's native rules and other popular plugins, this package helps create a complete code style solution that keeps your codebase clean and consistent.
 
@@ -60,7 +60,7 @@ We provide **ready-to-use ESLint flat configuration files** that combine `eslint
 
 ### 💡 Why Use These Configs?
 
-- **Complete Coverage** — Combines ESLint built-in rules, third-party plugins, and all 60 code-style rules
+- **Complete Coverage** — Combines ESLint built-in rules, third-party plugins, and all 61 code-style rules
 - **Ready-to-Use** — Copy the config file and start linting immediately
 - **Battle-Tested** — These configurations have been refined through real-world usage
 - **Fully Documented** — Each config includes detailed instructions and explanations
@@ -97,7 +97,7 @@ We provide **ready-to-use ESLint flat configuration files** that combine `eslint
 <td width="50%">
 
 ### 🔧 Auto-Fixable Rules
-All **60 rules** support automatic fixing with `eslint --fix`. No manual code changes needed.
+All **61 rules** support automatic fixing with `eslint --fix`. No manual code changes needed.
 
 </td>
 <td width="50%">
@@ -200,6 +200,7 @@ rules: {
     "code-style/export-format": "error",
     "code-style/function-arguments-format": "error",
     "code-style/function-call-spacing": "error",
+    "code-style/function-declaration-style": "error",
     "code-style/function-naming-convention": "error",
     "code-style/function-object-destructure": "error",
     "code-style/function-params-per-line": "error",
@@ -247,9 +248,9 @@ rules: {
 
 ---
 
-## 📖 Rules Summary
+## 📖 Rules Categories
 
-> All **60 rules** are auto-fixable. See detailed examples for each rule in the [Rules Reference](#-rules-reference) section below.
+> All **61 rules** are auto-fixable. See detailed examples for each rule in the [Rules Reference](#-rules-reference) section below.
 >
 > Rules marked with ⚙️ support customization options (e.g., extending default folder lists).
 
@@ -282,6 +283,7 @@ rules: {
 | `no-empty-lines-in-switch-cases` | No empty line after `case X:` before code, no empty lines between cases |
 | **Function Rules** | |
 | `function-call-spacing` | No space between function name and `(`: `fn()` not `fn ()` |
+| `function-declaration-style` | Auto-fix for `func-style`: converts function declarations to arrow expressions |
 | `function-naming-convention` | Functions use camelCase, start with verb (get/set/handle/is/has), handlers end with Handler |
 | `function-object-destructure` | Non-component functions: use typed params (not destructured), destructure in body; report dot notation access |
 | `function-params-per-line` | When multiline, each param on own line with consistent indentation |
@@ -1079,6 +1081,46 @@ array.map ((x) => x * 2);
 
 ---
 
+### `function-declaration-style`
+
+**What it does:** Converts function declarations to `const` arrow function expressions. This is the auto-fixable companion to ESLint's built-in `func-style` rule.
+
+**Why use it:** The built-in `func-style: ["error", "expression"]` rule reports function declarations but does not auto-fix them. This rule provides the auto-fix. Both rules should be used together for the best experience.
+
+> **Important:** This rule depends on `func-style: ["error", "expression"]` being configured. If `func-style` is set to `"declaration"` or is disabled, do not enable this rule — it would conflict.
+
+```typescript
+// ✅ Good — arrow function expression
+export const getToken = (): string | null => getCookie(tokenKey);
+
+export const clearAuth = (): void => {
+    removeToken();
+    clearStorage();
+};
+
+const isAuthenticated = (): boolean => {
+    const token = getToken();
+    return !!token;
+};
+
+// ❌ Bad — function declaration
+export function getToken(): string | null {
+    return getCookie(tokenKey);
+}
+
+export function clearAuth(): void {
+    removeToken();
+    clearStorage();
+}
+
+function isAuthenticated(): boolean {
+    const token = getToken();
+    return !!token;
+}
+```
+
+---
+
 ### `function-naming-convention`
 
 **What it does:** Enforces naming conventions for functions:
@@ -1373,24 +1415,24 @@ import { fetchUsers } from "@/apis/users/fetchUsers";
 ```
 
 **Default Allowed Folders:**
-`actions`, `apis`, `assets`, `atoms`, `components`, `config`, `configs`, `constants`, `contexts`, `data`, `enums`, `helpers`, `hooks`, `interfaces`, `layouts`, `lib`, `middlewares`, `providers`, `reducers`, `redux`, `requests`, `routes`, `schemas`, `services`, `store`, `styles`, `theme`, `thunks`, `types`, `ui`, `utils`, `utilities`, `views`
+`actions`, `apis`, `assets`, `atoms`, `components`, `config`, `configs`, `constants`, `contexts`, `data`, `enums`, `helpers`, `hooks`, `interfaces`, `layouts`, `lib`, `middlewares`, `pages`, `providers`, `reducers`, `redux`, `requests`, `routes`, `schemas`, `services`, `store`, `styles`, `theme`, `thunks`, `types`, `ui`, `utils`, `utilities`, `views`
 
 **Customization Options:**
 
 | Option | Type | Description |
 |--------|------|-------------|
-| `extraAllowedFolders` | `string[]` | Add extra folders to the default list |
-| `extraReduxSubfolders` | `string[]` | Add extra redux subfolders (default: `actions`, `reducers`, `store`, `thunks`, `types`) |
-| `extraDeepImportFolders` | `string[]` | Add extra folders that allow deep imports (default: `assets`) |
-| `aliasPrefix` | `string` | Change the import alias prefix (default: `@/`) |
-| `allowedFolders` | `string[]` | Replace default folders entirely |
-| `reduxSubfolders` | `string[]` | Replace default redux subfolders entirely |
-| `deepImportFolders` | `string[]` | Replace default deep import folders entirely |
+| `extraAllowedFolders` | `string[]` | Add custom folders that can be imported with `@/folder`. Extends defaults without replacing them. Use when your project has folders like `features/`, `modules/`, etc. |
+| `extraReduxSubfolders` | `string[]` | Add Redux-related subfolders that can be imported directly (`@/selectors`) or nested (`@/redux/selectors`). Default subfolders: `actions`, `reducers`, `store`, `thunks`, `types` |
+| `extraDeepImportFolders` | `string[]` | Add folders where direct file imports are allowed (`@/assets/images/logo.svg`). Use for folders without index files like images, fonts, etc. Default: `assets` |
+| `aliasPrefix` | `string` | Change the path alias prefix if your project uses something other than `@/` (e.g., `~/`, `src/`) |
+| `allowedFolders` | `string[]` | Completely replace the default allowed folders list. Use only if you need full control over which folders are valid |
+| `reduxSubfolders` | `string[]` | Completely replace the default Redux subfolders list |
+| `deepImportFolders` | `string[]` | Completely replace the default deep import folders list |
 
 ```javascript
 // Example: Add custom folders to the defaults
 "code-style/absolute-imports-only": ["error", {
-    extraAllowedFolders: ["features", "modules", "lib"],
+    extraAllowedFolders: ["features", "modules"],
     extraDeepImportFolders: ["images", "fonts"]
 }]
 ```
@@ -1617,7 +1659,7 @@ import { Button } from "@/components/Button/Button"; // Avoid this!
 ```
 
 **Default Module Folders:**
-`actions`, `apis`, `assets`, `atoms`, `components`, `config`, `configs`, `constants`, `contexts`, `data`, `enums`, `helpers`, `hooks`, `interfaces`, `layouts`, `lib`, `middlewares`, `providers`, `reducers`, `redux`, `requests`, `routes`, `schemas`, `services`, `store`, `styles`, `theme`, `thunks`, `types`, `ui`, `utils`, `utilities`, `views`
+`actions`, `apis`, `assets`, `atoms`, `components`, `config`, `configs`, `constants`, `contexts`, `data`, `enums`, `helpers`, `hooks`, `interfaces`, `layouts`, `lib`, `middlewares`, `pages`, `providers`, `reducers`, `redux`, `requests`, `routes`, `schemas`, `services`, `store`, `styles`, `theme`, `thunks`, `types`, `ui`, `utils`, `utilities`, `views`
 
 **Default Ignore Patterns:**
 `index.js`, `index.jsx`, `index.ts`, `index.tsx`, `.DS_Store`, `__tests__`, `__mocks__`, `*.test.js`, `*.test.jsx`, `*.test.ts`, `*.test.tsx`, `*.spec.js`, `*.spec.jsx`, `*.spec.ts`, `*.spec.tsx`
@@ -1626,18 +1668,18 @@ import { Button } from "@/components/Button/Button"; // Avoid this!
 
 | Option | Type | Description |
 |--------|------|-------------|
-| `extraModuleFolders` | `string[]` | Add extra module folders to the default list |
-| `extraLazyLoadFolders` | `string[]` | Add extra lazy load folders (default: `views`) |
-| `extraIgnorePatterns` | `string[]` | Add extra ignore patterns (supports wildcards) |
-| `moduleFolders` | `string[]` | Replace default module folders entirely |
-| `lazyLoadFolders` | `string[]` | Replace default lazy load folders entirely |
-| `ignorePatterns` | `string[]` | Replace default ignore patterns entirely |
+| `extraModuleFolders` | `string[]` | Add folders that should have an `index.js` re-exporting all public files. Use for project-specific folders like `features/`, `modules/` that follow the same pattern |
+| `extraLazyLoadFolders` | `string[]` | Add folders exempt from index file requirements. Use for route/page components loaded via dynamic `import()`. Default: `pages`, `views` |
+| `extraIgnorePatterns` | `string[]` | Add file patterns to skip when checking for index exports. Supports wildcards like `*.stories.js`, `*.mock.js` |
+| `moduleFolders` | `string[]` | Completely replace the default module folders list. Use only if you need full control over which folders require index files |
+| `lazyLoadFolders` | `string[]` | Completely replace the default lazy load folders list |
+| `ignorePatterns` | `string[]` | Completely replace the default ignore patterns list |
 
 ```javascript
 // Example: Add custom folders and patterns
 "code-style/module-index-exports": ["error", {
-    extraModuleFolders: ["features", "modules", "lib"],
-    extraLazyLoadFolders: ["pages"],
+    extraModuleFolders: ["features", "modules"],
+    extraLazyLoadFolders: ["screens"],
     extraIgnorePatterns: ["*.stories.js", "*.mock.js"]
 }]
 ```

package/index.d.ts

@@ -20,6 +20,7 @@ export type RuleNames =
     | "code-style/export-format"
     | "code-style/function-arguments-format"
     | "code-style/function-call-spacing"
+    | "code-style/function-declaration-style"
     | "code-style/function-naming-convention"
     | "code-style/function-object-destructure"
     | "code-style/function-params-per-line"
@@ -101,6 +102,7 @@ interface PluginRules {
     "export-format": Rule.RuleModule;
     "function-arguments-format": Rule.RuleModule;
     "function-call-spacing": Rule.RuleModule;
+    "function-declaration-style": Rule.RuleModule;
     "function-naming-convention": Rule.RuleModule;
     "function-object-destructure": Rule.RuleModule;
     "function-params-per-line": Rule.RuleModule;

package/index.js

@@ -1679,6 +1679,92 @@ const functionCallSpacing = {
     },
 };
 
+/**
+ * ───────────────────────────────────────────────────────────────
+ * Rule: Function Declaration Style
+ * ───────────────────────────────────────────────────────────────
+ *
+ * Description:
+ *   Enforce function expressions (arrow functions) instead of
+ *   function declarations. Auto-fixes by converting to const
+ *   arrow function expressions.
+ *
+ * ✓ Good:
+ *   const getToken = (): string | null => getCookie(tokenKey);
+ *   const clearAuth = (): void => {
+ *       removeToken();
+ *       clearStorage();
+ *   };
+ *
+ * ✗ Bad:
+ *   function getToken(): string | null { return getCookie(tokenKey); }
+ *   function clearAuth(): void {
+ *       removeToken();
+ *       clearStorage();
+ *   }
+ */
+const functionDeclarationStyle = {
+    create(context) {
+        const sourceCode = context.sourceCode || context.getSourceCode();
+
+        return {
+            FunctionDeclaration(node) {
+                if (!node.id) return;
+
+                const name = node.id.name;
+
+                // Build the params text
+                const paramsText = node.params.map((p) => sourceCode.getText(p)).join(", ");
+
+                // Build return type annotation if present
+                let returnType = "";
+
+                if (node.returnType) {
+                    returnType = sourceCode.getText(node.returnType);
+                }
+
+                // Build type parameters if present (generics)
+                let typeParams = "";
+
+                if (node.typeParameters) {
+                    typeParams = sourceCode.getText(node.typeParameters);
+                }
+
+                // Check if async
+                const isAsync = node.async;
+                const asyncPrefix = isAsync ? "async " : "";
+
+                // Get the body text
+                const bodyText = sourceCode.getText(node.body);
+
+                // Check for export keywords
+                const parentNode = node.parent;
+                const isExported = parentNode && parentNode.type === "ExportNamedDeclaration";
+
+                const exportPrefix = isExported ? "export " : "";
+
+                context.report({
+                    fix(fixer) {
+                        const fixTarget = isExported ? parentNode : node;
+
+                        const replacement = `${exportPrefix}const ${name} = ${asyncPrefix}(${paramsText})${returnType} => ${bodyText};`;
+
+                        return fixer.replaceText(fixTarget, replacement);
+                    },
+                    message: `Expected a function expression. Use \`const ${name} = ${asyncPrefix}(${paramsText})${returnType} => ...\` instead.`,
+                    node: node.id,
+                });
+            },
+        };
+    },
+    meta: {
+        docs: { description: "Enforce arrow function expressions instead of function declarations" },
+        fixable: "code",
+        schema: [],
+        type: "suggestion",
+    },
+};
+
 /**
  * ───────────────────────────────────────────────────────────────
  * Rule: Function Naming Convention
@@ -1772,9 +1858,37 @@ const functionNamingConvention = {
                     node: node.id || node.parent.id,
                 });
             } else if (!hasHandlerSuffix) {
+                const identifierNode = node.id || node.parent.id;
+                const newName = `${name}Handler`;
+
                 context.report({
-                    message: `Function "${name}" should end with "Handler" suffix (e.g., ${name}Handler)`,
-                    node: node.id || node.parent.id,
+                    fix(fixer) {
+                        const scope = context.sourceCode
+                            ? context.sourceCode.getScope(node)
+                            : context.getScope();
+
+                        // Find all references to this variable in the scope
+                        const variable = scope.variables.find((v) => v.name === name)
+                            || (scope.upper && scope.upper.variables.find((v) => v.name === name));
+
+                        if (!variable) return fixer.replaceText(identifierNode, newName);
+
+                        const fixes = [];
+
+                        // Fix the definition
+                        variable.defs.forEach((def) => {
+                            fixes.push(fixer.replaceText(def.name, newName));
+                        });
+
+                        // Fix all references
+                        variable.references.forEach((ref) => {
+                            fixes.push(fixer.replaceText(ref.identifier, newName));
+                        });
+
+                        return fixes;
+                    },
+                    message: `Function "${name}" should end with "Handler" suffix (e.g., ${newName})`,
+                    node: identifierNode,
                 });
             }
         };
@@ -1787,6 +1901,7 @@ const functionNamingConvention = {
     },
     meta: {
         docs: { description: "Enforce function names to start with a verb AND end with Handler" },
+        fixable: "code",
         schema: [],
         type: "suggestion",
     },
@@ -3113,13 +3228,13 @@ const multilineIfConditions = {
  *   folder-level index files.
  *
  * Options:
- *   - aliasPrefix: string (default: "@/") - The import alias prefix
- *   - extraAllowedFolders: string[] - Additional folders to allow (extends defaults)
- *   - extraReduxSubfolders: string[] - Additional redux subfolders (extends defaults)
- *   - extraDeepImportFolders: string[] - Additional folders allowing deep imports (extends "assets")
- *   - allowedFolders: string[] - Replace default folders entirely (use extraAllowedFolders to extend)
- *   - reduxSubfolders: string[] - Replace default redux subfolders entirely
- *   - deepImportFolders: string[] - Replace default deep import folders entirely
+ *   - aliasPrefix: string (default: "@/") - Change path alias prefix if your project uses something other than @/ (e.g., ~/, src/)
+ *   - extraAllowedFolders: string[] - Add custom folders that can be imported with @/folder. Extends defaults without replacing them
+ *   - extraReduxSubfolders: string[] - Add Redux subfolders importable directly (@/selectors) or nested (@/redux/selectors). Default: actions, reducers, store, thunks, types
+ *   - extraDeepImportFolders: string[] - Add folders where direct file imports are allowed (@/assets/images/logo.svg). Use for folders without index files. Default: assets
+ *   - allowedFolders: string[] - Completely replace the default allowed folders list. Use only if you need full control
+ *   - reduxSubfolders: string[] - Completely replace the default Redux subfolders list
+ *   - deepImportFolders: string[] - Completely replace the default deep import folders list
  *
  * ✓ Good:
  *   import { Button } from "@/components";
@@ -3131,7 +3246,7 @@ const multilineIfConditions = {
  *
  * Configuration Example:
  *   "code-style/absolute-imports-only": ["error", {
- *       extraAllowedFolders: ["features", "modules", "lib"],
+ *       extraAllowedFolders: ["features", "modules"],
  *       extraDeepImportFolders: ["images", "fonts"]
  *   }]
  */
@@ -3170,6 +3285,7 @@ const absoluteImportsOnly = {
             "layouts",
             "lib",
             "middlewares",
+            "pages",
             "providers",
             "reducers",
             "redux",
@@ -3216,10 +3332,14 @@ const absoluteImportsOnly = {
                 // for re-exporting their contents
                 const isIndexFile = /\/index\.(js|jsx|ts|tsx)$/.test(normalizedFilename);
 
+                // Check if this is an entry file (main.tsx, main.ts, etc.) - entry files are allowed
+                // to use relative imports for app root and styles (e.g., ./index.css, ./app)
+                const isEntryFile = /\/main\.(js|jsx|ts|tsx)$/.test(normalizedFilename);
+
                 // 1. Disallow relative imports (starting with ./ or ../)
                 // EXCEPT in index files which need relative imports for re-exports
                 if (importPath.startsWith("./") || importPath.startsWith("../")) {
-                    if (!isIndexFile) {
+                    if (!isIndexFile && !isEntryFile) {
                         context.report({
                             message: `Relative imports are not allowed. Use absolute imports with "${aliasPrefix}" prefix instead.`,
                             node: node.source,
@@ -3780,12 +3900,12 @@ const importSourceSpacing = {
  *   subfolders and files in the module.
  *
  * Options:
- *   - extraModuleFolders: string[] - Additional module folders (extends defaults)
- *   - extraLazyLoadFolders: string[] - Additional lazy load folders (extends defaults)
- *   - extraIgnorePatterns: string[] - Additional ignore patterns (extends defaults)
- *   - moduleFolders: string[] - Replace default module folders entirely
- *   - lazyLoadFolders: string[] - Replace default lazy load folders entirely
- *   - ignorePatterns: string[] - Replace default ignore patterns entirely
+ *   - extraModuleFolders: string[] - Add folders that should have an index.js re-exporting all public files. Use for project-specific folders like features/, modules/
+ *   - extraLazyLoadFolders: string[] - Add folders exempt from index file requirements. Use for route/page components loaded via dynamic import(). Default: pages, views
+ *   - extraIgnorePatterns: string[] - Add file patterns to skip when checking for index exports. Supports wildcards like *.stories.js, *.mock.js
+ *   - moduleFolders: string[] - Completely replace the default module folders list. Use only if you need full control
+ *   - lazyLoadFolders: string[] - Completely replace the default lazy load folders list
+ *   - ignorePatterns: string[] - Completely replace the default ignore patterns list
  *
  * ✓ Good:
  *   // index.js
@@ -3797,8 +3917,8 @@ const importSourceSpacing = {
  *
  * Configuration Example:
  *   "code-style/module-index-exports": ["error", {
- *       extraModuleFolders: ["features", "modules", "lib"],
- *       extraLazyLoadFolders: ["pages"],
+ *       extraModuleFolders: ["features", "modules"],
+ *       extraLazyLoadFolders: ["screens"],
  *       extraIgnorePatterns: ["*.stories.js", "*.mock.js"]
  *   }]
  */
@@ -3829,6 +3949,7 @@ const moduleIndexExports = {
             "layouts",
             "lib",
             "middlewares",
+            "pages",
             "providers",
             "reducers",
             "redux",
@@ -3853,7 +3974,7 @@ const moduleIndexExports = {
             || [...defaultModuleFolders, ...(options.extraModuleFolders || [])];
 
         // Default lazy load folders
-        const defaultLazyLoadFolders = ["views"];
+        const defaultLazyLoadFolders = ["pages", "views"];
 
         // Folders that use lazy loading and shouldn't require index exports
         // These folders typically have components loaded via dynamic import()
@@ -14184,6 +14305,7 @@ export default {
 
         // Function rules
         "function-call-spacing": functionCallSpacing,
+        "function-declaration-style": functionDeclarationStyle,
         "function-naming-convention": functionNamingConvention,
         "function-object-destructure": functionObjectDestructure,
         "function-params-per-line": functionParamsPerLine,

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "eslint-plugin-code-style",
-    "version": "1.2.7",
+    "version": "1.3.2",
     "description": "A custom ESLint plugin for enforcing consistent code formatting and style rules in React/JSX projects",
     "main": "index.js",
     "types": "index.d.ts",