eslint-plugin-nextfriday 3.1.0 → 3.2.1

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # eslint-plugin-nextfriday
 
+## 3.2.1
+
+### Patch Changes
+
+- [#120](https://github.com/next-friday/eslint-plugin-nextfriday/pull/120) [`6f56995`](https://github.com/next-friday/eslint-plugin-nextfriday/commit/6f569958e538f23b699fa3ac1cb4743b87e4ab60) Thanks [@joetakara](https://github.com/joetakara)! - `enforce-constant-case` now only flags global `const` declarations bound to a magic number or magic text literal. Object literals, array literals, RegExp, template literals (static or dynamic), `as const` assertions, booleans, and any non-literal initializer are no longer checked. This unblocks Next.js App Router files where reserved exports like `metadata`, `viewport`, `dynamic`, `revalidate`, `runtime`, `fetchCache`, `dynamicParams`, `preferredRegion`, and `maxDuration` are framework-owned and must keep their exact names. The rule scope now matches the documented intent of the plugin's naming convention skill ("top-level constant primitive values") instead of every static-shaped initializer.
+
+## 3.2.0
+
+### Minor Changes
+
+- [#118](https://github.com/next-friday/eslint-plugin-nextfriday/pull/118) [`143eee9`](https://github.com/next-friday/eslint-plugin-nextfriday/commit/143eee9fd0c6aed00e10677a6cad448dbdc9136e) Thanks [@joetakara](https://github.com/joetakara)! - Add `index-export-only` rule. Restricts `index.{js,jsx,ts,tsx}` files to imports, re-exports, and type/interface declarations only — flagging local function/class/variable declarations, inline `export const`/`export function`/`export class`, top-level expressions, and control flow. Type aliases, interfaces, and `export type` are allowed since they have no runtime cost. Included in `base`, `react`, and `nextjs` presets.
+
+- [#118](https://github.com/next-friday/eslint-plugin-nextfriday/pull/118) [`143eee9`](https://github.com/next-friday/eslint-plugin-nextfriday/commit/143eee9fd0c6aed00e10677a6cad448dbdc9136e) Thanks [@joetakara](https://github.com/joetakara)! - Add `no-inline-type-import` rule. Disallows inline `type` markers on import specifiers (`import { type Foo }` and `import { value, type Foo }`); auto-fix hoists single inline-type imports to `import type { ... }` and splits mixed value/type imports into two separate statements while preserving aliases, default specifiers, and quote style. Also strips redundant inline markers from existing `import type { ... }` statements. Included in `base`, `react`, and `nextjs` presets.
+
 ## 3.1.0
 
 ### Minor Changes

package/README.md

@@ -434,6 +434,7 @@ In practice: turn the high tier on as `"error"` first, leave the medium tier as
 | [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-inline-default-export](docs/rules/NO_INLINE_DEFAULT_EXPORT.md)           | Disallow inline default exports - declare first, then export           | ❌      |
+| [index-export-only](docs/rules/INDEX_EXPORT_ONLY.md)                         | Restrict index files to imports, re-exports, and type declarations     | ❌      |
 | [no-direct-date](docs/rules/NO_DIRECT_DATE.md)                               | Disallow direct usage of Date constructor and methods                  | ❌      |
 | [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                          | ✅      |
@@ -449,6 +450,7 @@ In practice: turn the high tier on as `"error"` first, leave the medium tier as
 | Rule                                                                 | Description                                               | Fixable |
 | -------------------------------------------------------------------- | --------------------------------------------------------- | ------- |
 | [no-relative-imports](docs/rules/NO_RELATIVE_IMPORTS.md)             | Disallow relative imports with ../ - use absolute imports | ❌      |
+| [no-inline-type-import](docs/rules/NO_INLINE_TYPE_IMPORT.md)         | Disallow inline 'type' markers - hoist or split imports   | ✅      |
 | [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    | ✅      |
 | [sort-exports](docs/rules/SORT_EXPORTS.md)                           | Enforce a consistent ordering of export groups            | ✅      |
@@ -498,16 +500,16 @@ In practice: turn the high tier on as `"error"` first, leave the medium tier as
 
 | Preset               | Severity | Base Rules | JSX Rules | Next.js Rules | Total Rules |
 | -------------------- | -------- | ---------- | --------- | ------------- | ----------- |
-| `base`               | warn     | 40         | 0         | 0             | 40          |
-| `base/recommended`   | error    | 40         | 0         | 0             | 40          |
-| `react`              | warn     | 40         | 16        | 0             | 56          |
-| `react/recommended`  | error    | 40         | 16        | 0             | 56          |
-| `nextjs`             | warn     | 40         | 16        | 1             | 57          |
-| `nextjs/recommended` | error    | 40         | 16        | 1             | 57          |
+| `base`               | warn     | 42         | 0         | 0             | 42          |
+| `base/recommended`   | error    | 42         | 0         | 0             | 42          |
+| `react`              | warn     | 42         | 16        | 0             | 58          |
+| `react/recommended`  | error    | 42         | 16        | 0             | 58          |
+| `nextjs`             | warn     | 42         | 16        | 1             | 59          |
+| `nextjs/recommended` | error    | 42         | 16        | 1             | 59          |
 
 The `nextjs` and `nextjs/recommended` presets ship as an array of two flat-config objects: the rule set above, plus a routing override that disables `nextfriday/file-kebab-case` and `nextfriday/jsx-pascal-case` for files matching `app/**/*.{js,jsx,ts,tsx}`, `src/app/**/*.{js,jsx,ts,tsx}`, `pages/**/*.{js,jsx,ts,tsx}`, and `src/pages/**/*.{js,jsx,ts,tsx}`. Next.js owns the filenames in those directories (`page.tsx`, `layout.tsx`, `route.ts`, `middleware.ts`, etc.), so the plugin steps out of the way. ESLint 9+ flattens nested config arrays automatically, so spreading the preset works as expected.
 
-### Base Configuration Rules (40 rules)
+### Base Configuration Rules (42 rules)
 
 Included in `base`, `base/recommended`, and all other presets:
 
@@ -521,6 +523,7 @@ Included in `base`, `base/recommended`, and all other presets:
 - `nextfriday/enforce-sorted-destructuring`
 - `nextfriday/enforce-type-declaration-order`
 - `nextfriday/file-kebab-case`
+- `nextfriday/index-export-only`
 - `nextfriday/newline-after-multiline-block`
 - `nextfriday/newline-before-return`
 - `nextfriday/no-complex-inline-return`
@@ -530,6 +533,7 @@ Included in `base`, `base/recommended`, and all other presets:
 - `nextfriday/no-inline-default-export`
 - `nextfriday/no-inline-nested-object`
 - `nextfriday/no-inline-return-properties`
+- `nextfriday/no-inline-type-import`
 - `nextfriday/no-lazy-identifiers`
 - `nextfriday/no-logic-in-params`
 - `nextfriday/no-misleading-constant-case`

package/docs/rules/ENFORCE_CONSTANT_CASE.md

@@ -1,15 +1,24 @@
 # enforce-constant-case
 
-Enforce SCREAMING_SNAKE_CASE for global constant static values.
+Enforce SCREAMING_SNAKE_CASE for global magic-number and magic-text constants.
 
 ## Rule Details
 
-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.
+This rule ensures that global-scope `const` declarations bound to a **magic number** or **magic text** literal use SCREAMING_SNAKE_CASE. The rule scope is intentionally narrow:
+
+- A magic text constant is a string literal: `const API_URL = "https://api.example.com"`
+- A magic number constant is a number literal (including a unary `-`/`+` over a numeric literal): `const PAGE_LIMIT = 10`, `const OFFSET = -1`
+
+Anything else is **not** checked: booleans, RegExp, template literals (static or dynamic), arrays, objects, `as const` assertions, function calls, identifiers, member expressions, JSX. Use whatever name fits the value (`metadata`, `viewport`, `statusMap`, `phoneRegex`, `isEnabled`, etc.) — the rule will not flag it.
 
 Only global scope (top-level of a file) is checked. Local scope constants inside functions are not checked by this rule.
 
 **Config files are exempt.** Files matching `*.config.{ts,mjs,cjs,js}`, `*.rc.*`, `*.setup.*`, `*.spec.*`, `*.test.*`, `.eslintrc*`, `.babelrc*`, and `.prettierrc*` skip this rule entirely. This avoids conflicts with framework conventions that require specific identifier names — e.g. Next.js expects `nextConfig` (not `NEXT_CONFIG`) in `next.config.ts`, Vite expects `config`, Tailwind expects `config`, etc.
 
+### Why magic numbers and magic text only?
+
+Reserved framework export names commonly bind to objects (Next.js App Router exports `metadata`, `viewport`, `generateStaticParams`, `dynamic`, `revalidate`, `runtime`, `fetchCache`, `dynamicParams`, `preferredRegion`, `maxDuration`; React Server Components and others have similar patterns). Forcing SCREAMING_SNAKE_CASE on any static-shaped initializer would rename those exports and break framework integration. Restricting the rule to bare number and string literals keeps the convention where it adds value (avoiding magic constants scattered through code) without colliding with framework-owned names.
+
 ## Examples
 
 ### Incorrect
@@ -18,10 +27,8 @@ Only global scope (top-level of a file) is checked. Local scope constants inside
 const defaultCover = "/images/default.jpg";
 const pageLimit = 10;
 const apiBaseUrl = "https://api.example.com";
-const template = `hello world`;
-const phoneRegex = /^[0-9]{10}$/;
+const negativeOne = -1;
 const default_theme = "dark";
-export const categories = [{ id: "1" }] as const;
 ```
 
 ### Correct
@@ -30,35 +37,39 @@ export const categories = [{ id: "1" }] as const;
 const DEFAULT_COVER = "/images/default.jpg";
 const PAGE_LIMIT = 10;
 const API_BASE_URL = "https://api.example.com";
-const TEMPLATE = `hello world`;
-const PHONE_REGEX = /^[0-9]{10}$/;
+const NEGATIVE_ONE = -1;
 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;
+const featureEnabled = true;
+
+const phoneRegex = /^[0-9]{10}$/;
+const template = `hello world`;
+const skeletonItems = [1, 2, 3, 4, 5];
+const mapStyle = { height: "320px", width: "100%" };
+const statusMap = { ACTIVE: "active" } as const;
+const categories = [{ id: "1" }] as const;
+
+export const metadata: Metadata = { title: "404 - Page Not Found" };
+export const viewport: Viewport = { themeColor: "#fff" };
+export const generateStaticParams = async () => [];
 
-// Template literals with expressions are dynamic, camelCase is fine
 const pendingHref = `/branch/${branch.branchNumber}`;
 
-// Functions and components are not checked
 const handleClick = () => {};
 const MyComponent = () => {};
 
-// Local scope is not checked
 function foo() {
   const maxRetry = 3;
 }
 ```
 
+> Note: Next.js App Router has a few string-valued reserved exports — `dynamic = "force-dynamic"`, `runtime = "edge"`, `fetchCache = "default-cache"`, etc. — and one number-valued one (`revalidate = 60`, `maxDuration = 30`). These remain in scope for this rule because their initializers are bare literals. Disable `nextfriday/enforce-constant-case` for `app/**` and `pages/**` in your own flat config if you use those exports.
+
 ## Configuration
 
-This rule has no options — only severity is configurable (`"error"`, `"warn"`, `"off"`). It pairs with [`no-misleading-constant-case`](./NO_MISLEADING_CONSTANT_CASE.md) so that static globals use `SCREAMING_SNAKE_CASE` while local scopes and dynamic values keep `camelCase`.
+This rule has no options — only severity is configurable (`"error"`, `"warn"`, `"off"`). It pairs with [`no-misleading-constant-case`](./NO_MISLEADING_CONSTANT_CASE.md) so that magic-literal globals use `SCREAMING_SNAKE_CASE` while local scopes and dynamic values keep `camelCase`.
 
 ### Install
 

package/docs/rules/INDEX_EXPORT_ONLY.md

@@ -0,0 +1,88 @@
+# index-export-only
+
+Restrict `index` files to imports, re-exports, and type declarations only.
+
+## Rule Details
+
+This rule enforces that `index.{js,jsx,ts,tsx}` files act purely as barrel files. Any runtime declaration — functions, classes, variables, top-level expressions, or inline `export const`/`export function`/`export class` — must live in its own module and be re-exported from the index.
+
+The rule applies only when the basename of the file is `index`. Files like `index.test.ts`, `index.spec.ts`, or `index.d.ts` are not affected.
+
+### Why?
+
+Index files are entry points. Mixing implementation into them obscures where behavior lives, breaks file-based code navigation, and makes the import surface harder to refactor. A barrel file should describe the public API of a directory — nothing more.
+
+## Examples
+
+### Incorrect
+
+```ts
+import { clsx, type ClassValue } from "clsx";
+import { twMerge } from "tailwind-merge";
+
+function cn(...inputs: ClassValue[]): string {
+  return twMerge(clsx(inputs));
+}
+
+export { cn };
+```
+
+```ts
+export const VERSION = "1.0.0";
+
+export function helper() {
+  return 1;
+}
+
+export class Service {}
+```
+
+```ts
+console.log("loaded");
+```
+
+### Correct
+
+```ts
+export { cn } from "./cn";
+export * from "./types";
+export type { Props } from "./props";
+export { default as Button } from "./button";
+```
+
+```ts
+import button from "./button";
+
+export default button;
+```
+
+```ts
+export type Foo = string;
+export interface Bar {
+  id: string;
+}
+```
+
+## What This Rule Allows
+
+- `import` statements (including side-effect imports like `import "./styles.css"`)
+- Specifier-only `export` and `export ... from` re-exports
+- `export *` and `export * as ns` re-exports
+- `export default identifier` where the identifier comes from an import
+- Top-level `type` aliases and `interface` declarations (they have no runtime cost)
+- `export type` and `export interface` declarations
+
+## What This Rule Disallows
+
+- `function`, `class`, and `const`/`let`/`var` declarations at the top level
+- Inline `export function`, `export class`, `export const`, `export let`, `export var`
+- `export default` of a function/class/literal/object expression
+- Top-level expression statements and control flow (`console.log(...)`, `if`, `for`, etc.)
+
+## When Not To Use It
+
+If your project intentionally mixes implementation and re-exports in index files — for example, a single-file utility library where `index.ts` is the only source file — disable this rule.
+
+## Related Rules
+
+- [no-inline-default-export](./NO_INLINE_DEFAULT_EXPORT.md) - Disallow inline default and named exports across all files

package/docs/rules/NO_INLINE_TYPE_IMPORT.md

@@ -0,0 +1,86 @@
+# no-inline-type-import
+
+Disallow inline `type` markers on import specifiers. Use `import type` or split into a separate type-only import statement.
+
+> This rule is auto-fixable using `--fix`.
+
+## Rule Details
+
+This rule forbids the inline-`type` form `import { type Foo }` and the mixed form `import { value, type Foo }`. Type-only imports must be expressed at the statement level with `import type { ... }`. When value and type imports come from the same module, the rule splits them into two separate statements.
+
+### Why?
+
+Statement-level `import type` makes the runtime cost of every import unambiguous at a glance, simplifies tooling that distinguishes erased imports from real ones (bundlers, type-only emit, transpilers), and removes the need for readers to scan each specifier for an inline keyword.
+
+## Examples
+
+### Incorrect
+
+```ts
+import { type foo } from "bar";
+
+import { baz, type moo } from "mee";
+
+import Default, { value, type Foo } from "src";
+```
+
+### Correct
+
+```ts
+import type { foo } from "bar";
+
+import { baz } from "mee";
+import type { moo } from "mee";
+
+import Default, { value } from "src";
+import type { Foo } from "src";
+```
+
+## Auto-fixing
+
+The rule's `--fix` produces these transformations:
+
+```ts
+// Single inline type → hoisted
+import { type foo } from "bar";
+// becomes
+import type { foo } from "bar";
+
+// All inline types → hoisted
+import { type foo, type bar } from "src";
+// becomes
+import type { foo, bar } from "src";
+
+// Mixed value + inline type → split
+import { baz, type moo } from "mee";
+// becomes
+import { baz } from "mee";
+import type { moo } from "mee";
+
+// Default + inline type → split
+import Default, { type Foo } from "src";
+// becomes
+import Default from "src";
+import type { Foo } from "src";
+
+// Aliases are preserved
+import { foo as bar, type baz as qux } from "src";
+// becomes
+import { foo as bar } from "src";
+import type { baz as qux } from "src";
+
+// Redundant inline markers inside `import type` are stripped
+import type { foo, type bar } from "src";
+// becomes
+import type { foo, bar } from "src";
+```
+
+After auto-fix, other import-ordering rules (such as `sort-imports`) may re-order the resulting statements according to their own grouping rules.
+
+## When Not To Use It
+
+If your codebase intentionally uses the inline `type` form to keep value and type imports adjacent in a single statement, disable this rule.
+
+## Related Rules
+
+- [prefer-import-type](./PREFER_IMPORT_TYPE.md) - Hoists imports that are used only as types to `import type`. Complements this rule for usage-based detection.