eslint-plugin-nextfriday 1.6.0 → 1.7.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # eslint-plugin-nextfriday
 
+## 1.7.0
+
+### Minor Changes
+
+- [#41](https://github.com/next-friday/eslint-plugin-nextfriday/pull/41) [`10b67d9`](https://github.com/next-friday/eslint-plugin-nextfriday/commit/10b67d941c47fef5b72408bfff2b56e98a46c26c) Thanks [@nextfridaydeveloper](https://github.com/nextfridaydeveloper)! - Add no-direct-date rule to disallow direct usage of Date constructor and methods (new Date(), Date.now(), Date.parse()) to enforce centralized date utilities like dayjs
+
 ## 1.6.0
 
 ### Minor Changes

package/README.md

@@ -22,7 +22,7 @@ pnpm add -D eslint-plugin-nextfriday
 import nextfriday from "eslint-plugin-nextfriday";
 
 export default [nextfriday.configs.base];
-// or use the recommended preset
+// or use the recommended preset (stricter)
 export default [nextfriday.configs["base/recommended"]];
 ```
 
@@ -59,19 +59,37 @@ export default [
       nextfriday,
     },
     rules: {
-      "nextfriday/no-emoji": "error",
+      // Variable Naming
+      "nextfriday/no-single-char-variables": "error",
+      "nextfriday/boolean-naming-prefix": "error",
+
+      // File Naming
       "nextfriday/file-kebab-case": "error",
+      "nextfriday/jsx-pascal-case": "error",
       "nextfriday/md-filename-case-restriction": "error",
+
+      // Code Style
+      "nextfriday/no-emoji": "error",
       "nextfriday/prefer-destructuring-params": "error",
-      "nextfriday/no-explicit-return-type": "error",
-      "nextfriday/prefer-import-type": "error",
-      "nextfriday/prefer-named-param-types": "error",
-      "nextfriday/prefer-react-import-types": "error",
+      "nextfriday/prefer-function-declaration": "error",
+      "nextfriday/require-explicit-return-type": "error",
       "nextfriday/no-complex-inline-return": "error",
       "nextfriday/no-logic-in-params": "error",
+      "nextfriday/enforce-sorted-destructuring": "error",
       "nextfriday/no-env-fallback": "error",
-      "nextfriday/jsx-pascal-case": "error",
+
+      // Import Optimization
+      "nextfriday/prefer-import-type": "error",
+      "nextfriday/prefer-react-import-types": "error",
+
+      // Type Patterns
+      "nextfriday/prefer-named-param-types": "error",
       "nextfriday/prefer-interface-over-inline-types": "error",
+
+      // React/JSX
+      "nextfriday/jsx-no-non-component-function": "error",
+      "nextfriday/jsx-no-variable-in-callback": "error",
+      "nextfriday/prefer-jsx-template-literals": "error",
       "nextfriday/react-props-destructure": "error",
       "nextfriday/enforce-readonly-component-props": "error",
     },
@@ -110,91 +128,119 @@ module.exports = {
 
 ## Rules
 
-| Rule                                                                                   | Description                                                                   | Fixable |
-| -------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------- | ------- |
-| [no-emoji](docs/rules/NO_EMOJI.md)                                                     | Disallow emojis in code                                                       | ❌      |
-| [file-kebab-case](docs/rules/FILE_KEBAB_CASE.md)                                       | Enforce kebab-case filenames for .ts and .js files                            | ❌      |
-| [jsx-pascal-case](docs/rules/JSX_PASCAL_CASE.md)                                       | Enforce PascalCase filenames for .jsx and .tsx files                          | ❌      |
-| [md-filename-case-restriction](docs/rules/MD_FILENAME_CASE_RESTRICTION.md)             | Enforce SNAKE_CASE filenames for .md files                                    | ❌      |
-| [prefer-destructuring-params](docs/rules/PREFER_DESTRUCTURING_PARAMS.md)               | Enforce destructuring for functions with multiple parameters                  | ❌      |
-| [no-explicit-return-type](docs/rules/NO_EXPLICIT_RETURN_TYPE.md)                       | Disallow explicit return types on functions                                   | ✅      |
-| [jsx-no-non-component-function](docs/rules/JSX_NO_NON_COMPONENT_FUNCTION.md)           | Disallow non-component functions at top level in .tsx and .jsx files          | ❌      |
-| [jsx-no-variable-in-callback](docs/rules/JSX_NO_VARIABLE_IN_CALLBACK.md)               | Disallow variable declarations inside callback functions within JSX           | ❌      |
-| [prefer-import-type](docs/rules/PREFER_IMPORT_TYPE.md)                                 | Enforce using 'import type' for type-only imports                             | ✅      |
-| [prefer-named-param-types](docs/rules/PREFER_NAMED_PARAM_TYPES.md)                     | Enforce named types for function parameters with object types                 | ❌      |
-| [prefer-interface-over-inline-types](docs/rules/PREFER_INTERFACE_OVER_INLINE_TYPES.md) | Enforce interface declarations over inline types for React props              | ❌      |
-| [prefer-jsx-template-literals](docs/rules/PREFER_JSX_TEMPLATE_LITERALS.md)             | Enforce using template literals instead of mixing text and JSX expressions    | ✅      |
-| [prefer-react-import-types](docs/rules/PREFER_REACT_IMPORT_TYPES.md)                   | Enforce direct imports from 'react' instead of React.X                        | ✅      |
-| [react-props-destructure](docs/rules/REACT_PROPS_DESTRUCTURE.md)                       | Enforce destructuring props inside React component body                       | ❌      |
-| [enforce-readonly-component-props](docs/rules/ENFORCE_READONLY_COMPONENT_PROPS.md)     | Enforce Readonly wrapper for React component props                            | ✅      |
-| [enforce-sorted-destructuring](docs/rules/ENFORCE_SORTED_DESTRUCTURING.md)             | Enforce alphabetical sorting of destructured properties with defaults first   | ❌      |
-| [no-complex-inline-return](docs/rules/NO_COMPLEX_INLINE_RETURN.md)                     | Disallow complex inline expressions in return statements - prefer const first | ❌      |
-| [no-logic-in-params](docs/rules/NO_LOGIC_IN_PARAMS.md)                                 | Disallow logic or conditions in function parameters - extract to const first  | ❌      |
-| [no-env-fallback](docs/rules/NO_ENV_FALLBACK.md)                                       | Disallow fallback values for environment variables as they can be dangerous   | ❌      |
-
-## Configurations
-
-### Base Configurations (for pure JS/TS projects)
-
-#### `base`
-
-Basic configuration without JSX-specific rules:
+### Variable Naming Rules
 
-- `nextfriday/no-emoji`: `"error"`
-- `nextfriday/file-kebab-case`: `"error"`
-- `nextfriday/md-filename-case-restriction`: `"error"`
-- `nextfriday/prefer-destructuring-params`: `"error"`
-- `nextfriday/no-explicit-return-type`: `"error"`
-- `nextfriday/prefer-import-type`: `"error"`
-- `nextfriday/prefer-named-param-types`: `"error"`
-- `nextfriday/prefer-react-import-types`: `"error"`
-- `nextfriday/no-complex-inline-return`: `"error"`
-- `nextfriday/no-logic-in-params`: `"error"`
-- `nextfriday/no-env-fallback`: `"error"`
+| Rule                                                               | Description                                                           | Fixable |
+| ------------------------------------------------------------------ | --------------------------------------------------------------------- | ------- |
+| [no-single-char-variables](docs/rules/NO_SINGLE_CHAR_VARIABLES.md) | Disallow single character variable names (e.g., `d`, `u`, `l`)        | ❌      |
+| [boolean-naming-prefix](docs/rules/BOOLEAN_NAMING_PREFIX.md)       | Enforce boolean variables to have prefix (is, has, should, can, etc.) | ❌      |
 
-#### `base/recommended`
+### File Naming Rules
 
-Same as `base` configuration (recommended preset for pure JS/TS projects).
+| Rule                                                                       | Description                                          | Fixable |
+| -------------------------------------------------------------------------- | ---------------------------------------------------- | ------- |
+| [file-kebab-case](docs/rules/FILE_KEBAB_CASE.md)                           | Enforce kebab-case filenames for .ts and .js files   | ❌      |
+| [jsx-pascal-case](docs/rules/JSX_PASCAL_CASE.md)                           | Enforce PascalCase filenames for .jsx and .tsx files | ❌      |
+| [md-filename-case-restriction](docs/rules/MD_FILENAME_CASE_RESTRICTION.md) | Enforce SNAKE_CASE filenames for .md files           | ❌      |
 
-### React Configurations
+### Code Style Rules
 
-#### `react`
+| Rule                                                                       | Description                                                            | Fixable |
+| -------------------------------------------------------------------------- | ---------------------------------------------------------------------- | ------- |
+| [no-emoji](docs/rules/NO_EMOJI.md)                                         | Disallow emoji characters in source code                               | ❌      |
+| [prefer-destructuring-params](docs/rules/PREFER_DESTRUCTURING_PARAMS.md)   | Enforce destructuring for functions with multiple parameters           | ❌      |
+| [prefer-function-declaration](docs/rules/PREFER_FUNCTION_DECLARATION.md)   | Enforce function declarations over arrow functions in .ts files        | ❌      |
+| [require-explicit-return-type](docs/rules/REQUIRE_EXPLICIT_RETURN_TYPE.md) | Require explicit return types on functions for better documentation    | ❌      |
+| [no-complex-inline-return](docs/rules/NO_COMPLEX_INLINE_RETURN.md)         | Disallow complex inline expressions in return - extract to const first | ❌      |
+| [no-logic-in-params](docs/rules/NO_LOGIC_IN_PARAMS.md)                     | Disallow logic/conditions in function parameters - extract to const    | ❌      |
+| [enforce-sorted-destructuring](docs/rules/ENFORCE_SORTED_DESTRUCTURING.md) | Enforce alphabetical sorting of destructured properties                | ❌      |
+| [no-env-fallback](docs/rules/NO_ENV_FALLBACK.md)                           | Disallow fallback values for environment variables                     | ❌      |
+| [no-direct-date](docs/rules/NO_DIRECT_DATE.md)                             | Disallow direct usage of Date constructor and methods                  | ❌      |
 
-Includes all base rules plus React-specific rules:
+### Import Optimization Rules
 
-- All base rules above
-- `nextfriday/jsx-pascal-case`: `"error"`
-- `nextfriday/prefer-interface-over-inline-types`: `"error"`
-- `nextfriday/react-props-destructure`: `"error"`
-- `nextfriday/enforce-readonly-component-props`: `"error"`
+| Rule                                                                 | Description                                            | Fixable |
+| -------------------------------------------------------------------- | ------------------------------------------------------ | ------- |
+| [prefer-import-type](docs/rules/PREFER_IMPORT_TYPE.md)               | Enforce using 'import type' for type-only imports      | ✅      |
+| [prefer-react-import-types](docs/rules/PREFER_REACT_IMPORT_TYPES.md) | Enforce direct imports from 'react' instead of React.X | ✅      |
 
-#### `react/recommended`
+### Type Pattern Rules
 
-Same as `react` configuration (recommended preset for React projects).
+| Rule                                                                                   | Description                                                      | Fixable |
+| -------------------------------------------------------------------------------------- | ---------------------------------------------------------------- | ------- |
+| [prefer-named-param-types](docs/rules/PREFER_NAMED_PARAM_TYPES.md)                     | Enforce named types for function parameters with object types    | ❌      |
+| [prefer-interface-over-inline-types](docs/rules/PREFER_INTERFACE_OVER_INLINE_TYPES.md) | Enforce interface declarations over inline types for React props | ❌      |
 
-### Next.js Configurations
+### React/JSX Rules
 
-#### `nextjs`
+| Rule                                                                               | Description                                                          | Fixable |
+| ---------------------------------------------------------------------------------- | -------------------------------------------------------------------- | ------- |
+| [jsx-no-non-component-function](docs/rules/JSX_NO_NON_COMPONENT_FUNCTION.md)       | Disallow non-component functions at top level in .tsx/.jsx files     | ❌      |
+| [jsx-no-variable-in-callback](docs/rules/JSX_NO_VARIABLE_IN_CALLBACK.md)           | Disallow variable declarations inside callback functions in JSX      | ❌      |
+| [prefer-jsx-template-literals](docs/rules/PREFER_JSX_TEMPLATE_LITERALS.md)         | Enforce template literals instead of mixing text and JSX expressions | ✅      |
+| [react-props-destructure](docs/rules/REACT_PROPS_DESTRUCTURE.md)                   | Enforce destructuring props inside React component body              | ❌      |
+| [enforce-readonly-component-props](docs/rules/ENFORCE_READONLY_COMPONENT_PROPS.md) | Enforce Readonly wrapper for React component props                   | ✅      |
 
-Includes all rules suitable for Next.js projects:
-
-- All base rules
-- `nextfriday/jsx-pascal-case`: `"error"`
-- `nextfriday/prefer-interface-over-inline-types`: `"error"`
-- `nextfriday/react-props-destructure`: `"error"`
-- `nextfriday/enforce-readonly-component-props`: `"error"`
-
-#### `nextjs/recommended`
+## Configurations
 
-Same as `nextjs` configuration (recommended preset for Next.js projects).
+### Configuration Presets Overview
+
+| Preset               | Severity | Base Rules | JSX Rules | Total Rules |
+| -------------------- | -------- | ---------- | --------- | ----------- |
+| `base`               | warn     | 16         | 0         | 16          |
+| `base/recommended`   | error    | 16         | 0         | 16          |
+| `react`              | warn     | 16         | 7         | 23          |
+| `react/recommended`  | error    | 16         | 7         | 23          |
+| `nextjs`             | warn     | 16         | 7         | 23          |
+| `nextjs/recommended` | error    | 16         | 7         | 23          |
+
+### Base Configuration Rules (16 rules)
+
+Included in `base`, `base/recommended`, and all other presets:
+
+- `nextfriday/boolean-naming-prefix`
+- `nextfriday/enforce-sorted-destructuring`
+- `nextfriday/file-kebab-case`
+- `nextfriday/md-filename-case-restriction`
+- `nextfriday/no-complex-inline-return`
+- `nextfriday/no-direct-date`
+- `nextfriday/no-emoji`
+- `nextfriday/no-env-fallback`
+- `nextfriday/require-explicit-return-type`
+- `nextfriday/no-logic-in-params`
+- `nextfriday/no-single-char-variables`
+- `nextfriday/prefer-destructuring-params`
+- `nextfriday/prefer-function-declaration`
+- `nextfriday/prefer-import-type`
+- `nextfriday/prefer-named-param-types`
+- `nextfriday/prefer-react-import-types`
+
+### JSX Rules (7 rules)
+
+Additionally included in `react`, `react/recommended`, `nextjs`, `nextjs/recommended`:
+
+- `nextfriday/enforce-readonly-component-props`
+- `nextfriday/jsx-no-non-component-function`
+- `nextfriday/jsx-no-variable-in-callback`
+- `nextfriday/jsx-pascal-case`
+- `nextfriday/prefer-interface-over-inline-types`
+- `nextfriday/prefer-jsx-template-literals`
+- `nextfriday/react-props-destructure`
+
+### Severity Levels
+
+- **`base` / `react` / `nextjs`**: All rules set to `"warn"`
+- **`base/recommended` / `react/recommended` / `nextjs/recommended`**: All rules set to `"error"`
 
 ## Features
 
-- **File naming enforcement**: Ensure consistent file naming conventions across your project
+- **Variable naming enforcement**: Prevent cryptic single-character names and enforce boolean prefixes
+- **File naming enforcement**: Ensure consistent file naming conventions (kebab-case, PascalCase, SNAKE_CASE)
+- **Function style**: Enforce function declarations over arrow functions in utility files
 - **Import optimization**: Automatically suggests better import patterns for TypeScript
 - **Code cleanup**: Helps remove unnecessary explicit type annotations
-- **React component conventions**: Enforces naming standards for JSX/TSX files
-- **Clean code practices**: Prevents emoji usage and enforces parameter destructuring
+- **React component conventions**: Enforces naming standards and patterns for JSX/TSX files
+- **Clean code practices**: Prevents emoji usage, enforces parameter destructuring, and more
 
 ## Need Help?
 

package/docs/rules/BOOLEAN_NAMING_PREFIX.md

@@ -0,0 +1,102 @@
+# boolean-naming-prefix
+
+Enforce boolean variables and parameters to have a prefix like is, has, should, can, did, will for better readability.
+
+## Rule Details
+
+This rule enforces that boolean variables and parameters use a descriptive prefix that makes them read like English sentences. Variables like `open`, `valid`, `user` are ambiguous - it's unclear whether they represent a value or a state. Boolean prefixes make the intent clear.
+
+**Recommended prefixes:** `is`, `has`, `should`, `can`, `did`, `will`, `was`, `are`, `does`, `had`
+
+**Incorrect** code for this rule:
+
+```typescript
+const valid = true;
+const user = false;
+const open = true;
+const closed = false;
+const active: boolean = true;
+const enabled: boolean = checkEnabled();
+
+const equal = a === b;
+const different = a !== b;
+const bigger = a > b;
+const negated = !value;
+const combined = a && b;
+const either = a || b;
+
+function process(active: boolean) {}
+const fn = (enabled: boolean) => {};
+function toggle(active = true) {}
+```
+
+**Correct** code for this rule:
+
+```typescript
+const isValid = true;
+const hasUser = false;
+const isOpen = true;
+const isClosed = false;
+const isActive: boolean = true;
+const isEnabled: boolean = checkEnabled();
+
+const isEqual = a === b;
+const isDifferent = a !== b;
+const isBigger = a > b;
+const isNegated = !value;
+const areCombined = a && b;
+const hasEither = a || b;
+
+function process(isActive: boolean) {}
+const fn = (hasAccess: boolean) => {};
+function toggle(isActive = true) {}
+```
+
+## What This Rule Detects
+
+The rule identifies boolean variables and parameters by:
+
+1. **Boolean type annotations**: Variables explicitly typed as `boolean`
+2. **Boolean literals**: Variables initialized with `true` or `false`
+3. **Comparison expressions**: `===`, `!==`, `==`, `!=`, `<`, `>`, `<=`, `>=`, `in`, `instanceof`
+4. **Logical expressions**: `&&`, `||`
+5. **Negation**: `!value`
+6. **Function parameters**: With boolean type annotation or default boolean value
+
+## Allowed Prefixes
+
+| Prefix   | Usage                         | Example                                       |
+| -------- | ----------------------------- | --------------------------------------------- |
+| `is`     | State or condition            | `isActive`, `isValid`, `isLoading`            |
+| `has`    | Possession or existence       | `hasUser`, `hasPermission`, `hasError`        |
+| `can`    | Ability or permission         | `canSubmit`, `canEdit`, `canDelete`           |
+| `should` | Recommendation or expectation | `shouldRender`, `shouldUpdate`, `shouldFetch` |
+| `will`   | Future action                 | `willUpdate`, `willRedirect`, `willExpire`    |
+| `did`    | Past action                   | `didLoad`, `didSubmit`, `didFail`             |
+| `was`    | Past state                    | `wasActive`, `wasVisible`, `wasProcessed`     |
+| `are`    | Plural state                  | `areEqual`, `areValid`, `areLoaded`           |
+| `does`   | Action capability             | `doesExist`, `doesMatch`, `doesContain`       |
+| `had`    | Past possession               | `hadError`, `hadAccess`, `hadPrevious`        |
+
+## Benefits
+
+- **Self-documenting code**: Boolean intent is immediately clear
+- **Reads like English**: `if (isActive)` reads as "if is active"
+- **Reduced ambiguity**: `user = false` vs `hasUser = false` - the latter is clear
+- **Consistent codebase**: Enforces uniform boolean naming across the project
+- **Better code review**: Reviewers can quickly understand boolean logic
+
+## When Not To Use
+
+- When working with external APIs that return boolean fields with different naming conventions
+- In mathematical or scientific code where single-letter variables are conventional
+- When interfacing with legacy code that would require extensive refactoring
+
+## Configuration
+
+This rule has no configuration options.
+
+## Related Rules
+
+- [no-single-char-variables](./NO_SINGLE_CHAR_VARIABLES.md) - Disallows single character variable names
+- [@typescript-eslint/naming-convention](https://typescript-eslint.io/rules/naming-convention/) - More comprehensive naming convention rule

package/docs/rules/NO_DIRECT_DATE.md

@@ -0,0 +1,36 @@
+# no-direct-date
+
+Disallow direct usage of Date constructor and methods to enforce centralized date utilities.
+
+## Rule Details
+
+This rule prevents the use of the native JavaScript `Date` constructor and its static methods (`Date.now()`, `Date.parse()`). Using a centralized date utility library like dayjs, date-fns, or Luxon provides better consistency, easier testing, and more predictable date handling across your application.
+
+## Examples
+
+**Incorrect** code for this rule:
+
+```js
+const now = new Date();
+const timestamp = Date.now();
+const parsed = Date.parse("2024-01-01");
+const specificDate = new Date("2024-01-01");
+const dateFromTimestamp = new Date(1704067200000);
+const dateFromParts = new Date(2024, 0, 1);
+```
+
+**Correct** code for this rule:
+
+```js
+import dayjs from "dayjs";
+
+const now = dayjs();
+const timestamp = dayjs().valueOf();
+const parsed = dayjs("2024-01-01");
+const specificDate = dayjs("2024-01-01");
+const dateFromTimestamp = dayjs(1704067200000);
+```
+
+## When Not To Use It
+
+If your project does not use a centralized date utility library and you prefer to work directly with the native JavaScript Date API, you can disable this rule.

package/docs/rules/NO_SINGLE_CHAR_VARIABLES.md

@@ -0,0 +1,108 @@
+# no-single-char-variables
+
+Disallow single character variable and parameter names for better code readability.
+
+## Rule Details
+
+This rule enforces descriptive variable and parameter names by disallowing single character identifiers. Single character names like `d`, `u`, `l`, `r` are cryptic and make code harder to understand. They require readers to guess or track what each variable represents.
+
+**Incorrect** code for this rule:
+
+```typescript
+const d = new Date();
+const u = await getUser();
+const l = list.length;
+const r = await fetch(url);
+
+users.map((u) => u.id);
+onClick((e) => e.preventDefault());
+
+const add = (a, b) => a + b;
+const e = (x) => x * 2;
+
+function f() {
+  return 1;
+}
+
+const { a } = obj;
+const [x] = array;
+
+try {
+} catch (e) {}
+```
+
+**Correct** code for this rule:
+
+```typescript
+const currentDate = new Date();
+const currentUser = await getUser();
+const itemCount = list.length;
+const response = await fetch(url);
+
+users.map((user) => user.id);
+onClick((event) => event.preventDefault());
+
+const add = (val1, val2) => val1 + val2;
+const add = (width, height) => width * height;
+const calculateDouble = (value) => value * 2;
+
+function getName() {
+  return "test";
+}
+
+const { alpha } = obj;
+const { a: alpha } = obj;
+const [first] = array;
+
+try {
+} catch (error) {}
+```
+
+## Exceptions
+
+The rule allows the following exceptions:
+
+### Loop Counters
+
+Single character loop counters `i`, `j`, `k`, `n` are allowed in traditional for loops:
+
+```typescript
+for (let i = 0; i < 10; i++) {}
+for (let j = 0; j < items.length; j++) {}
+for (let i = 0, j = 10; i < j; i++, j--) {}
+```
+
+Note: These are only allowed in traditional `for` loops, not in `for...of` or `for...in` loops.
+
+### Underscore for Unused Variables
+
+A single underscore `_` is allowed to indicate intentionally unused variables:
+
+```typescript
+const _ = unusedValue;
+const [_, second] = array;
+array.map((_, index) => index);
+```
+
+## Benefits
+
+- **Self-documenting code**: Descriptive names make code readable without additional comments
+- **Reduced cognitive load**: No need to track or guess what single letters represent
+- **Better IDE support**: Meaningful names provide better autocomplete and search results
+- **Easier debugging**: Clear variable names make debugging and code review faster
+- **Improved collaboration**: Team members can understand code without additional context
+
+## When Not To Use
+
+- For very short scripts or throwaway code
+- When working with mathematical formulas where single letters are conventional (e.g., `x`, `y` for coordinates)
+- In legacy codebases where this pattern is established and changing would be disruptive
+
+## Configuration
+
+This rule has no configuration options.
+
+## Related Rules
+
+- [prefer-destructuring-params](./PREFER_DESTRUCTURING_PARAMS.md) - Encourages destructuring for function parameters
+- [prefer-named-param-types](./PREFER_NAMED_PARAM_TYPES.md) - Encourages named parameters for better readability

package/docs/rules/PREFER_FUNCTION_DECLARATION.md

@@ -0,0 +1,139 @@
+# prefer-function-declaration
+
+Enforce function declarations over arrow functions assigned to variables in `.ts` files for better readability and hoisting.
+
+## Rule Details
+
+This rule requires using function declarations instead of arrow functions or function expressions when defining named functions in TypeScript utility files. Arrow functions used as callbacks (in `.map()`, `.filter()`, etc.) are still allowed.
+
+**Target:** `.ts` files only (not `.tsx`, `.js`, or `.d.ts`)
+
+**Incorrect** code for this rule:
+
+```typescript
+// utils/date.ts
+const formatThaiDate = (date: Date) => {
+  return date.toLocaleDateString("th-TH");
+};
+
+const formatDate = (date: Date) => date.toISOString();
+
+export const add = (a: number, b: number) => a + b;
+
+const greet = function (name: string) {
+  return `Hello ${name}`;
+};
+
+const fetchUser = async (id: string) => {
+  return await api.get(`/users/${id}`);
+};
+```
+
+**Correct** code for this rule:
+
+```typescript
+// utils/date.ts
+function formatThaiDate(date: Date) {
+  return date.toLocaleDateString("th-TH");
+}
+
+function formatDate(date: Date) {
+  return date.toISOString();
+}
+
+export function add(a: number, b: number) {
+  return a + b;
+}
+
+function greet(name: string) {
+  return `Hello ${name}`;
+}
+
+async function fetchUser(id: string) {
+  return await api.get(`/users/${id}`);
+}
+```
+
+## What This Rule Allows
+
+Arrow functions are still allowed in the following contexts:
+
+### Callbacks
+
+```typescript
+// All of these are allowed
+const years = dates.map((date) => date.getFullYear());
+const active = items.filter((item) => item.active);
+const sorted = items.sort((a, b) => a.name.localeCompare(b.name));
+items.forEach((item) => console.log(item));
+const total = items.reduce((sum, item) => sum + item.price, 0);
+setTimeout(() => console.log("done"), 1000);
+promise.then((result) => result.data);
+```
+
+### Object Properties
+
+```typescript
+const handler = {
+  onClick: () => console.log("clicked"),
+  onHover: () => setHovered(true),
+};
+```
+
+### Array Elements
+
+```typescript
+const callbacks = [() => 1, () => 2, () => 3];
+```
+
+### Return Values
+
+```typescript
+function createHandler() {
+  return () => console.log("handled");
+}
+```
+
+### Conditional/Logical Expressions
+
+```typescript
+const fn = condition ? () => valueA : () => valueB;
+const handler = defaultFn || (() => fallback);
+```
+
+### TSX Files
+
+```typescript
+// components/Button.tsx - Arrow functions allowed
+const Button = () => <button>Click me</button>;
+const handleClick = () => console.log("clicked");
+```
+
+## Benefits
+
+- **Hoisting**: Function declarations are hoisted, allowing you to call functions before they're defined
+- **Better readability**: Function declarations are more explicit about intent
+- **Clearer stack traces**: Named function declarations provide better debugging information
+- **Consistent style**: Enforces uniform function definition patterns in utility files
+- **Self-documenting**: `function formatDate()` is clearer than `const formatDate = () =>`
+
+## Why Only `.ts` Files?
+
+- **`.tsx` files**: Arrow functions are commonly used for React components and event handlers
+- **`.js` files**: JavaScript projects may have different conventions
+- **`.d.ts` files**: Declaration files don't contain implementations
+
+## When Not To Use
+
+- When you prefer arrow functions for all function definitions
+- In projects where arrow function style is established
+- When you need lexical `this` binding (arrow functions don't have their own `this`)
+
+## Configuration
+
+This rule has no configuration options.
+
+## Related Rules
+
+- [func-style](https://eslint.org/docs/rules/func-style) - Built-in ESLint rule for function style
+- [arrow-body-style](https://eslint.org/docs/rules/arrow-body-style) - Enforce arrow function body style