eslint-plugin-nextfriday 1.19.0 → 1.21.0

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # eslint-plugin-nextfriday
 
+## 1.21.0
+
+### Minor Changes
+
+- [#87](https://github.com/next-friday/eslint-plugin-nextfriday/pull/87) [`ed401e3`](https://github.com/next-friday/eslint-plugin-nextfriday/commit/ed401e39db04857995ddcc29d7444298181ee60b) Thanks [@joetakara](https://github.com/joetakara)! - Add `no-inline-return-properties` rule that enforces shorthand-only properties in return objects
+
+- [#90](https://github.com/next-friday/eslint-plugin-nextfriday/pull/90) [`d5e9db5`](https://github.com/next-friday/eslint-plugin-nextfriday/commit/d5e9db562cb9e38beadd59da39f8618b6f5825ed) Thanks [@joetakara](https://github.com/joetakara)! - Add comprehensive naming convention rules and fix prefer-import-type JSX prop bug
+  - Add `enforce-camel-case` rule: ban snake_case variables/functions, restrict PascalCase to React components
+  - Add `enforce-property-case` rule: enforce camelCase for unquoted object property keys
+  - Refactor `enforce-constant-case` to only check global scope, support RegExp/objects/arrays/as const
+  - Refactor `no-misleading-constant-case` to flag SCREAMING_SNAKE_CASE in local scope
+  - Fix `prefer-import-type` incorrectly converting imports used as JSX prop values to type imports
+
+## 1.20.0
+
+### Minor Changes
+
+- [#85](https://github.com/next-friday/eslint-plugin-nextfriday/pull/85) [`280a864`](https://github.com/next-friday/eslint-plugin-nextfriday/commit/280a864f31d32433856d6914f742861d3bb43ec9) Thanks [@joetakara](https://github.com/joetakara)! - feat(rules): add no-misleading-constant-case rule and improve enforce-constant-case
+  - Add `no-misleading-constant-case` rule that disallows SCREAMING_SNAKE_CASE for mutable bindings (let/var) and non-static values (function calls, objects, arrays, dynamic templates, computed expressions)
+  - Add `prefer-inline-type-export` rule that requires type/interface declarations to be exported inline
+  - Update `enforce-constant-case` to exempt booleans with standard prefixes (is, has, should, etc.) to resolve conflict with `boolean-naming-prefix`
+  - Update existing rules: enforce-constant-case, jsx-newline-between-elements, no-lazy-identifiers
+
 ## 1.19.0
 
 ### Minor Changes

package/README.md

@@ -117,6 +117,7 @@ export default [
       "nextfriday/no-nested-interface-declaration": "error",
       "nextfriday/prefer-named-param-types": "error",
       "nextfriday/prefer-inline-literal-union": "error",
+      "nextfriday/prefer-inline-type-export": "error",
       "nextfriday/prefer-interface-over-inline-types": "error",
       "nextfriday/sort-type-alphabetically": "error",
       "nextfriday/sort-type-required-first": "error",
@@ -149,12 +150,15 @@ export default [
 
 ### Variable Naming Rules
 
-| 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.) | ❌      |
-| [enforce-constant-case](docs/rules/ENFORCE_CONSTANT_CASE.md)       | Enforce SCREAMING_SNAKE_CASE for constant primitive values            | ❌      |
+| 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.) | ❌      |
+| [enforce-camel-case](docs/rules/ENFORCE_CAMEL_CASE.md)                   | Ban snake_case and restrict PascalCase to React components            | ❌      |
+| [enforce-constant-case](docs/rules/ENFORCE_CONSTANT_CASE.md)             | Enforce SCREAMING_SNAKE_CASE for global static constant values        | ❌      |
+| [enforce-property-case](docs/rules/ENFORCE_PROPERTY_CASE.md)             | Enforce camelCase for unquoted object property keys                   | ❌      |
+| [no-misleading-constant-case](docs/rules/NO_MISLEADING_CONSTANT_CASE.md) | Disallow SCREAMING_SNAKE_CASE in local scope and for dynamic values   | ❌      |
 
 ### File Naming Rules
 
@@ -183,6 +187,7 @@ export default [
 | [newline-after-multiline-block](docs/rules/NEWLINE_AFTER_MULTILINE_BLOCK.md) | Require a blank line after multi-line statements                       | ✅      |
 | [newline-before-return](docs/rules/NEWLINE_BEFORE_RETURN.md)                 | Require a blank line before return statements                          | ✅      |
 | [no-inline-nested-object](docs/rules/NO_INLINE_NESTED_OBJECT.md)             | Require nested objects and arrays to span multiple lines               | ✅      |
+| [no-inline-return-properties](docs/rules/NO_INLINE_RETURN_PROPERTIES.md)     | Require return object properties to use shorthand notation             | ❌      |
 | [prefer-async-await](docs/rules/PREFER_ASYNC_AWAIT.md)                       | Enforce async/await over .then() promise chains                        | ❌      |
 | [enforce-curly-newline](docs/rules/ENFORCE_CURLY_NEWLINE.md)                 | Enforce curly braces for multi-line if, forbid for single-line         | ✅      |
 | [no-nested-ternary](docs/rules/NO_NESTED_TERNARY.md)                         | Disallow nested ternary expressions                                    | ❌      |
@@ -206,6 +211,7 @@ export default [
 | [no-nested-interface-declaration](docs/rules/NO_NESTED_INTERFACE_DECLARATION.md)       | Disallow inline object types in interface/type properties        | ❌      |
 | [prefer-named-param-types](docs/rules/PREFER_NAMED_PARAM_TYPES.md)                     | Enforce named types for function parameters with object types    | ❌      |
 | [prefer-inline-literal-union](docs/rules/PREFER_INLINE_LITERAL_UNION.md)               | Enforce inlining literal union types for better IDE hover info   | ✅      |
+| [prefer-inline-type-export](docs/rules/PREFER_INLINE_TYPE_EXPORT.md)                   | Require type/interface exports inline at the declaration         | ✅      |
 | [prefer-interface-over-inline-types](docs/rules/PREFER_INTERFACE_OVER_INLINE_TYPES.md) | Enforce interface declarations over inline types for React props | ❌      |
 | [sort-type-alphabetically](docs/rules/SORT_TYPE_ALPHABETICALLY.md)                     | Enforce A-Z sorting of properties within type groups             | ✅      |
 | [sort-type-required-first](docs/rules/SORT_TYPE_REQUIRED_FIRST.md)                     | Enforce required properties before optional in types/interfaces  | ✅      |
@@ -214,7 +220,7 @@ export default [
 
 | Rule                                                                                     | Description                                                           | Fixable |
 | ---------------------------------------------------------------------------------------- | --------------------------------------------------------------------- | ------- |
-| [jsx-newline-between-elements](docs/rules/JSX_NEWLINE_BETWEEN_ELEMENTS.md)               | Require empty lines between sibling multi-line JSX elements           | ✅      |
+| [jsx-newline-between-elements](docs/rules/JSX_NEWLINE_BETWEEN_ELEMENTS.md)               | Require empty lines between sibling multi-line JSX children           | ✅      |
 | [jsx-no-inline-object-prop](docs/rules/JSX_NO_INLINE_OBJECT_PROP.md)                     | Disallow inline object literals in JSX props                          | ❌      |
 | [jsx-no-newline-single-line-elements](docs/rules/JSX_NO_NEWLINE_SINGLE_LINE_ELEMENTS.md) | Disallow empty lines between single-line sibling JSX elements         | ✅      |
 | [jsx-no-non-component-function](docs/rules/JSX_NO_NON_COMPONENT_FUNCTION.md)             | Disallow non-component functions at top level in .tsx/.jsx files      | ❌      |
@@ -240,14 +246,14 @@ export default [
 
 | Preset               | Severity | Base Rules | JSX Rules | Next.js Rules | Total Rules |
 | -------------------- | -------- | ---------- | --------- | ------------- | ----------- |
-| `base`               | warn     | 36         | 0         | 0             | 36          |
-| `base/recommended`   | error    | 36         | 0         | 0             | 36          |
-| `react`              | warn     | 36         | 15        | 0             | 51          |
-| `react/recommended`  | error    | 36         | 15        | 0             | 51          |
-| `nextjs`             | warn     | 36         | 15        | 1             | 52          |
-| `nextjs/recommended` | error    | 36         | 15        | 1             | 52          |
+| `base`               | warn     | 37         | 0         | 0             | 37          |
+| `base/recommended`   | error    | 37         | 0         | 0             | 37          |
+| `react`              | warn     | 37         | 15        | 0             | 52          |
+| `react/recommended`  | error    | 37         | 15        | 0             | 52          |
+| `nextjs`             | warn     | 37         | 15        | 1             | 53          |
+| `nextjs/recommended` | error    | 37         | 15        | 1             | 53          |
 
-### Base Configuration Rules (36 rules)
+### Base Configuration Rules (37 rules)
 
 Included in `base`, `base/recommended`, and all other presets:
 
@@ -280,6 +286,7 @@ Included in `base`, `base/recommended`, and all other presets:
 - `nextfriday/prefer-guard-clause`
 - `nextfriday/prefer-import-type`
 - `nextfriday/prefer-inline-literal-union`
+- `nextfriday/prefer-inline-type-export`
 - `nextfriday/prefer-named-param-types`
 - `nextfriday/prefer-react-import-types`
 - `nextfriday/require-explicit-return-type`
@@ -332,7 +339,7 @@ Additionally included in `nextjs`, `nextjs/recommended` only:
 
 ## Agent Skill
 
-This plugin ships with an [Agent Skill](https://github.com/anthropics/skills) that teaches AI coding assistants (Claude Code, Cursor, etc.) all 52 rules so they generate compliant code from the start.
+This plugin ships with an [Agent Skill](https://github.com/anthropics/skills) that teaches AI coding assistants (Claude Code, Cursor, etc.) all 53 rules so they generate compliant code from the start.
 
 ```bash
 npx skills add next-friday/eslint-plugin-nextfriday --skill eslint-plugin-nextfriday

package/docs/rules/ENFORCE_CAMEL_CASE.md

@@ -0,0 +1,68 @@
+# enforce-camel-case
+
+Enforce camelCase for variables and functions, ban snake_case, and restrict PascalCase to React components.
+
+## Rule Details
+
+This rule enforces consistent naming conventions across your codebase:
+
+- Variables and functions must use camelCase
+- snake_case is banned for all variable and function declarations
+- PascalCase is reserved exclusively for React components (functions that return JSX)
+
+Global static constants are not checked by this rule. Use `enforce-constant-case` for those.
+
+### Why?
+
+Consistent naming conventions reduce cognitive load. When PascalCase is reserved for components and camelCase is used for everything else, the name alone tells you what something is.
+
+## Examples
+
+### Incorrect
+
+```ts
+// snake_case variables
+let current_index = 0;
+const first_name = "John";
+
+// snake_case functions
+function calculate_total() {
+  return 0;
+}
+
+// PascalCase for non-component functions
+const CalculateTotal = () => 0;
+const FormatDate = (date: string) => date;
+```
+
+### Correct
+
+```ts
+// camelCase variables
+let currentIndex = 0;
+const firstName = "John";
+
+// camelCase functions
+function calculateTotal() { return 0; }
+const formatDate = (date: string) => date;
+
+// PascalCase for React components
+const ArticleCard = () => <div />;
+const WrappedComponent = memo(() => <div />);
+const LazyPage = lazy(() => import("./Page"));
+```
+
+## Exceptions
+
+- Global static constants (handled by `enforce-constant-case`)
+- SCREAMING_SNAKE_CASE variables (handled by `no-misleading-constant-case`)
+- React components wrapped with `memo`, `forwardRef`, or `lazy`
+
+## When Not To Use It
+
+If your project does not follow the convention that PascalCase is reserved for React components.
+
+## Related Rules
+
+- [enforce-constant-case](ENFORCE_CONSTANT_CASE.md) - Enforces SCREAMING_SNAKE_CASE for global static constants
+- [no-misleading-constant-case](NO_MISLEADING_CONSTANT_CASE.md) - Disallows SCREAMING_SNAKE_CASE in local scope

package/docs/rules/ENFORCE_CONSTANT_CASE.md

@@ -1,10 +1,12 @@
 # enforce-constant-case
 
-Enforce SCREAMING_SNAKE_CASE for constant primitive values.
+Enforce SCREAMING_SNAKE_CASE for global constant static values.
 
 ## Rule Details
 
-This rule ensures that `const` declarations with primitive values (strings, numbers, booleans, template literals) use SCREAMING_SNAKE_CASE naming convention. Objects, arrays, and functions are not checked. Only `const` declarations are checked; `let` and `var` are ignored.
+This rule ensures that global-scope `const` declarations with static values use SCREAMING_SNAKE_CASE naming convention. Static values include: string/number/boolean literals, RegExp, static template literals, `as const` assertions, and objects/arrays containing only literal values.
+
+Only global scope (top-level of a file) is checked. Local scope constants inside functions are not checked by this rule.
 
 ## Examples
 
@@ -13,9 +15,11 @@ This rule ensures that `const` declarations with primitive values (strings, numb
 ```ts
 const defaultCover = "/images/default.jpg";
 const pageLimit = 10;
-const isEnabled = true;
 const apiBaseUrl = "https://api.example.com";
 const template = `hello world`;
+const phoneRegex = /^[0-9]{10}$/;
+const default_theme = "dark";
+export const categories = [{ id: "1" }] as const;
 ```
 
 ### Correct
@@ -23,21 +27,39 @@ const template = `hello world`;
 ```ts
 const DEFAULT_COVER = "/images/default.jpg";
 const PAGE_LIMIT = 10;
-const IS_ENABLED = true;
 const API_BASE_URL = "https://api.example.com";
 const TEMPLATE = `hello world`;
+const PHONE_REGEX = /^[0-9]{10}$/;
+const DEFAULT_THEME = "dark";
+export const CATEGORIES = [{ id: "1" }] as const;
+
+const SKELETON_ITEMS = [1, 2, 3, 4, 5];
+const MAP_STYLE = { height: "320px", width: "100%" };
+const STATUS_MAP = { ACTIVE: "active" } as const;
+
+// Booleans with standard prefixes (is, has, should, etc.) are exempt
+const isProduction = true;
+const hasAccess = false;
 
-// Objects, arrays, and functions can use camelCase
-const config = { key: "value" };
-const items = [1, 2, 3];
+// Template literals with expressions are dynamic, camelCase is fine
+const pendingHref = `/branch/${branch.branchNumber}`;
+
+// Functions and components are not checked
 const handleClick = () => {};
+const MyComponent = () => {};
 
-// Let and var declarations are not checked
-let defaultCover = "/images/default.jpg";
-var pageLimit = 10;
+// Local scope is not checked
+function foo() {
+  const maxRetry = 3;
+}
 ```
 
 ## When Not To Use It
 
 - If your project uses different naming conventions for constants
 - If you prefer camelCase for all variable declarations
+
+## Related Rules
+
+- [no-misleading-constant-case](NO_MISLEADING_CONSTANT_CASE.md) - Disallows SCREAMING_SNAKE_CASE in local scope and for dynamic values
+- [enforce-camel-case](ENFORCE_CAMEL_CASE.md) - Enforces camelCase for variables and functions

package/docs/rules/ENFORCE_PROPERTY_CASE.md

@@ -0,0 +1,63 @@
+# enforce-property-case
+
+Enforce camelCase for unquoted object property keys.
+
+## Rule Details
+
+This rule bans snake_case and SCREAMING_SNAKE_CASE for unquoted object property keys. Quoted keys (string literals) are allowed for API boundaries where external systems require different conventions.
+
+### Why?
+
+Object properties should follow the same camelCase convention as variables. When an external API requires snake_case keys, wrapping them in quotes makes it explicit that the naming is intentional and driven by an external contract.
+
+## Examples
+
+### Incorrect
+
+```ts
+const userPayload = {
+  first_name: "John",
+  last_name: "Doe",
+};
+
+const item = {
+  ITEM_ID: 1,
+};
+```
+
+### Correct
+
+```ts
+// camelCase properties
+const userPayload = {
+  firstName: "John",
+  lastName: "Doe",
+};
+
+// Quoted keys for API boundaries
+const apiPayload = {
+  first_name: "John",
+  last_name: "Doe",
+};
+
+// as const objects are exempt (enum-like pattern)
+const STATUS_MAP = {
+  ACTIVE: "active",
+  INACTIVE: "inactive",
+} as const;
+```
+
+## Exceptions
+
+- Quoted property keys (`"first_name"`) are always allowed
+- Computed property keys (`[key]`) are not checked
+- Properties inside `as const` objects and arrays are exempt
+
+## When Not To Use It
+
+If your project frequently uses snake_case or SCREAMING_SNAKE_CASE for object properties without quoting.
+
+## Related Rules
+
+- [enforce-camel-case](ENFORCE_CAMEL_CASE.md) - Enforces camelCase for variables and functions
+- [enforce-constant-case](ENFORCE_CONSTANT_CASE.md) - Enforces SCREAMING_SNAKE_CASE for global constants

package/docs/rules/JSX_NEWLINE_BETWEEN_ELEMENTS.md

@@ -1,10 +1,10 @@
 # jsx-newline-between-elements
 
-Require empty lines between sibling JSX elements when at least one spans multiple lines.
+Require empty lines between sibling JSX elements and expression containers when at least one spans multiple lines.
 
 ## Rule Details
 
-This rule enforces empty lines between sibling JSX elements when either element spans multiple lines. This improves visual separation and readability of complex component structures. Single-line elements do not require empty lines between them.
+This rule enforces empty lines between sibling JSX elements, fragments, and expression containers (e.g., `{condition && (...)}`) when either sibling spans multiple lines. This improves visual separation and readability of complex component structures. Single-line siblings do not require empty lines between them.
 
 ## Examples
 
@@ -70,6 +70,28 @@ function UserProfile() {
 }
 ```
 
+Expression containers also need empty lines:
+
+```tsx
+function StudentInfo({ studentId, name }) {
+  return (
+    <div>
+      {studentId && (
+        <div className="flex items-center gap-x-1">
+          <Text size="lg">{studentId}</Text>
+        </div>
+      )}
+
+      {name && (
+        <div className="flex items-center gap-x-1">
+          <Text size="lg">{name}</Text>
+        </div>
+      )}
+    </div>
+  );
+}
+```
+
 Single-line elements do not require empty lines:
 
 ```jsx

package/docs/rules/NO_INLINE_RETURN_PROPERTIES.md

@@ -0,0 +1,83 @@
+# no-inline-return-properties
+
+Require return object properties to use shorthand notation by extracting non-shorthand values to const variables.
+
+## Rule Details
+
+This rule enforces that all properties in a returned object literal use shorthand notation. When a return statement contains an object with renamed or computed properties, the values should be extracted into const variables before the return statement.
+
+### Why?
+
+Return objects with a mix of shorthand and non-shorthand properties are harder to scan. Extracting values into named constants before returning keeps the return statement clean and makes the data flow easier to follow.
+
+## Examples
+
+### Incorrect
+
+```ts
+function useBranch() {
+  return {
+    admins,
+    branch,
+    coursesCurrentPage: coursePage,
+    coursesTotalPages: Math.ceil(sortedLearning.length / COURSES_PER_PAGE) || 1,
+    members,
+    membersHref: `/branch/${branchNumber}/members`,
+    news,
+    newsCurrentPage: newsData?.currentPage ?? 1,
+    newsTotalPages: newsData?.pages ?? 1,
+    stats,
+  };
+}
+```
+
+```ts
+function useJoin() {
+  return {
+    error,
+    isSubmitting,
+    onJoin: handleJoin,
+  };
+}
+```
+
+### Correct
+
+```ts
+function useBranch() {
+  const coursesCurrentPage = coursePage;
+  const coursesTotalPages = Math.ceil(sortedLearning.length / COURSES_PER_PAGE) || 1;
+  const membersHref = `/branch/${branchNumber}/members`;
+  const newsCurrentPage = newsData?.currentPage ?? 1;
+  const newsTotalPages = newsData?.pages ?? 1;
+
+  return {
+    admins,
+    branch,
+    coursesCurrentPage,
+    coursesTotalPages,
+    members,
+    membersHref,
+    news,
+    newsCurrentPage,
+    newsTotalPages,
+    stats,
+  };
+}
+```
+
+```ts
+function useJoin() {
+  const onJoin = handleJoin;
+
+  return {
+    error,
+    isSubmitting,
+    onJoin,
+  };
+}
+```
+
+## When Not To Use It
+
+If your project prefers inline property values in return statements for brevity.

package/docs/rules/NO_LAZY_IDENTIFIERS.md

@@ -60,10 +60,12 @@ The rule detects two types of lazy patterns:
 
 ### Repeated Characters (3+)
 
-Variables with 3 or more consecutive identical characters:
+Variables with 3 or more consecutive identical characters (case-sensitive):
 
 - `xxx`, `aaa`, `zzz`, `qqqq`, `aaaa`
 
+Compound names where repeated characters span word boundaries are not flagged (e.g., `ProfileProgressSkeleton` is allowed because `ss` and `S` are different cases).
+
 ### Keyboard Sequences (4+)
 
 Variables containing 4 or more consecutive keyboard row characters:

package/docs/rules/NO_MISLEADING_CONSTANT_CASE.md

@@ -0,0 +1,76 @@
+# no-misleading-constant-case
+
+Disallow SCREAMING_SNAKE_CASE for non-constant or non-static values.
+
+## Rule Details
+
+SCREAMING_SNAKE_CASE is reserved for global static constants. This rule flags it when used incorrectly:
+
+- **Mutable bindings**: `let` or `var` with SCREAMING_SNAKE_CASE
+- **Dynamic values**: `const` with function calls, await, dynamic templates, objects with dynamic values
+- **Local scope**: SCREAMING_SNAKE_CASE inside functions, even for static values
+
+### Why?
+
+SCREAMING_SNAKE_CASE signals a compile-time constant at the module level. Using it for local variables or dynamic values is misleading. Local constants should use camelCase regardless of whether the value is static.
+
+## Examples
+
+### Incorrect
+
+```ts
+// Mutable bindings
+let API_URL = "https://api.example.com";
+var MAX_COUNT = 10;
+
+// Dynamic values at global scope
+const API_URL = getUrl();
+const USER_ID = await fetchId();
+const PATHNAME = `/news/${slug}`;
+const CONFIG = { key: getValue() };
+
+// SCREAMING_SNAKE_CASE in local scope (even static values)
+function foo() {
+  const MAX_RETRY = 3;
+  const TOTAL_COUNT = items.length;
+}
+
+const MyComponent = () => {
+  const ACTIVE_ITEMS = ITEMS.filter((i) => i.active);
+};
+```
+
+### Correct
+
+```ts
+// Global static constants use SCREAMING_SNAKE_CASE
+const API_URL = "https://api.example.com";
+const MAX_COUNT = 10;
+const ITEMS = [1, 2, 3];
+const CONFIG = { key: "value" };
+const VARIANTS = ["a", "b"] as const;
+
+// Dynamic values use camelCase
+const apiUrl = getUrl();
+const userId = await fetchId();
+const pathname = `/news/${slug}`;
+
+// Local scope uses camelCase
+function foo() {
+  const maxRetry = 3;
+  const totalCount = items.length;
+}
+
+// Mutable bindings use camelCase
+let count = 10;
+var name = "foo";
+```
+
+## When Not To Use It
+
+If your project does not follow the convention that SCREAMING_SNAKE_CASE is reserved for global static constants.
+
+## Related Rules
+
+- [enforce-constant-case](ENFORCE_CONSTANT_CASE.md) - The complementary rule that enforces SCREAMING_SNAKE_CASE for global static constants
+- [enforce-camel-case](ENFORCE_CAMEL_CASE.md) - Enforces camelCase for variables and functions

package/docs/rules/PREFER_INLINE_TYPE_EXPORT.md

@@ -0,0 +1,64 @@
+# prefer-inline-type-export
+
+Require type and interface declarations to be exported inline rather than via a separate export statement.
+
+> This rule is auto-fixable using `--fix`.
+
+## Rule Details
+
+This rule enforces that `interface` and `type` declarations are exported directly at the declaration site using the `export` keyword, rather than being exported separately via `export type { ... }` or `export { ... }` at the bottom of the file.
+
+### Why?
+
+Inline exports make it immediately clear at the declaration site that a type is part of the module's public API. Separate export statements create a disconnect between the declaration and its visibility, making it harder to understand the module's surface area at a glance.
+
+## Examples
+
+### Incorrect
+
+```ts
+interface ButtonProps {
+  label: string;
+  disabled: boolean;
+}
+
+type Theme = "light" | "dark";
+
+export type { ButtonProps, Theme };
+```
+
+```ts
+interface Config {
+  port: number;
+}
+
+export { Config };
+```
+
+### Correct
+
+```ts
+export interface ButtonProps {
+  label: string;
+  disabled: boolean;
+}
+
+export type Theme = "light" | "dark";
+```
+
+```ts
+export interface Config {
+  port: number;
+}
+```
+
+## Exceptions
+
+This rule only applies to `interface` and `type` declarations defined in the same file. It does not flag:
+
+- Re-exports from other modules (`export type { Foo } from './types'`)
+- Separate exports of non-type declarations (variables, functions, classes)
+
+## When Not To Use It
+
+If your project prefers grouping all exports at the bottom of the file for consistency.