eslint-plugin-nextfriday 1.6.0 → 1.8.0

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # eslint-plugin-nextfriday
 
+## 1.8.0
+
+### Minor Changes
+
+- [#43](https://github.com/next-friday/eslint-plugin-nextfriday/pull/43) [`2fbee6d`](https://github.com/next-friday/eslint-plugin-nextfriday/commit/2fbee6df84009954cb99674bcdb1cb1cca3be4e6) Thanks [@nextfridaydeveloper](https://github.com/nextfridaydeveloper)! - feat(rules): add no-lazy-identifiers rule
+
+  Added a new rule `no-lazy-identifiers` that detects and disallows lazy variable names:
+  - Repeated characters (3+): `xxx`, `aaa`, `zzz`
+  - Keyboard sequences (4+): `asdf`, `qwerty`, `hjkl`, `zxcv`
+
+## 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,38 @@ export default [
       nextfriday,
     },
     rules: {
-      "nextfriday/no-emoji": "error",
+      // Variable Naming
+      "nextfriday/no-single-char-variables": "error",
+      "nextfriday/no-lazy-identifiers": "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 +129,121 @@ 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`)        | ❌      |
+| [no-lazy-identifiers](docs/rules/NO_LAZY_IDENTIFIERS.md)           | Disallow lazy identifiers like `xxx`, `asdf`, `qwerty`                | ❌      |
+| [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     | 17         | 0         | 17          |
+| `base/recommended`   | error    | 17         | 0         | 17          |
+| `react`              | warn     | 17         | 7         | 24          |
+| `react/recommended`  | error    | 17         | 7         | 24          |
+| `nextjs`             | warn     | 17         | 7         | 24          |
+| `nextjs/recommended` | error    | 17         | 7         | 24          |
+
+### Base Configuration Rules (17 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/no-lazy-identifiers`
+- `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`
+- `nextfriday/require-explicit-return-type`
+
+### 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_LAZY_IDENTIFIERS.md

@@ -0,0 +1,106 @@
+# no-lazy-identifiers
+
+Disallow lazy, meaningless variable names that hurt code readability.
+
+## Rule Details
+
+This rule enforces meaningful variable names by detecting and disallowing lazy identifiers. It uses pattern-based detection to find repeated characters and keyboard sequences.
+
+**Incorrect** code for this rule:
+
+```typescript
+const xxx = "value";
+const yyy = 123;
+const zzz = true;
+const aaa = [];
+
+const asdf = "keyboard pattern";
+const qwerty = "another pattern";
+
+function xxx() {
+  return 1;
+}
+
+const fn = (xxx) => xxx * 2;
+
+class aaaa {}
+
+const { xxx } = obj;
+const [aaa, bbb] = array;
+```
+
+**Correct** code for this rule:
+
+```typescript
+const userName = "john";
+const itemCount = 123;
+const isActive = true;
+const items = [];
+
+const keyboardType = "mechanical";
+const inputLayout = "us";
+
+function calculateTotal() {
+  return 1;
+}
+
+const double = (value) => value * 2;
+
+class UserService {}
+
+const { name } = obj;
+const [first, second] = array;
+```
+
+## Detection Patterns
+
+The rule detects two types of lazy patterns:
+
+### Repeated Characters (3+)
+
+Variables with 3 or more consecutive identical characters:
+
+- `xxx`, `aaa`, `zzz`, `qqqq`, `aaaa`
+
+### Keyboard Sequences (4+)
+
+Variables containing 4 or more consecutive keyboard row characters:
+
+- `asdf`, `qwerty`, `zxcv`, `hjkl`, `1234`
+- Also detects reversed sequences: `fdsa`, `lkjh`
+- Detects sequences embedded in names: `myAsdfVar`
+
+## Exceptions
+
+### Short Identifiers
+
+Identifiers shorter than 3 characters are ignored (use `no-single-char-variables` for those).
+
+### Underscore-Prefixed
+
+Variables starting with `_` are allowed (commonly used for unused variables):
+
+```typescript
+const _unused = getValue();
+```
+
+## Benefits
+
+- **Readable code**: Meaningful names make code self-documenting
+- **Maintainability**: Other developers can understand the purpose of variables
+- **Professionalism**: Clean code reflects well on the team
+- **Debugging**: Clear names make debugging easier
+
+## When Not To Use
+
+- In test files where placeholder data is acceptable
+- When working with legacy code that would be disruptive to change
+
+## Configuration
+
+This rule has no configuration options.
+
+## Related Rules
+
+- [no-single-char-variables](./NO_SINGLE_CHAR_VARIABLES.md) - Disallows single character variable names
+- [boolean-naming-prefix](./BOOLEAN_NAMING_PREFIX.md) - Enforces naming conventions for boolean variables

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