eslint-plugin-nextfriday 1.18.0 → 1.20.0

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # eslint-plugin-nextfriday
 
+## 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
+
+- [#83](https://github.com/next-friday/eslint-plugin-nextfriday/pull/83) [`b7143d2`](https://github.com/next-friday/eslint-plugin-nextfriday/commit/b7143d2f779ca1ca34f6562d09c1a6168b74c338) Thanks [@joetakara](https://github.com/joetakara)! - Add jsx-no-ternary-null rule to enforce logical AND over ternary with null/undefined in JSX
+
 ## 1.18.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",
@@ -126,6 +127,7 @@ export default [
       "nextfriday/jsx-no-inline-object-prop": "error",
       "nextfriday/jsx-no-newline-single-line-elements": "error",
       "nextfriday/jsx-no-non-component-function": "error",
+      "nextfriday/jsx-no-ternary-null": "error",
       "nextfriday/jsx-no-variable-in-callback": "error",
       "nextfriday/jsx-require-suspense": "error",
       "nextfriday/jsx-simple-props": "error",
@@ -148,12 +150,13 @@ 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-constant-case](docs/rules/ENFORCE_CONSTANT_CASE.md)             | Enforce SCREAMING_SNAKE_CASE for static constant primitive values     | ❌      |
+| [no-misleading-constant-case](docs/rules/NO_MISLEADING_CONSTANT_CASE.md) | Disallow SCREAMING_SNAKE_CASE for non-constant or non-static values   | ❌      |
 
 ### File Naming Rules
 
@@ -205,6 +208,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  | ✅      |
@@ -213,10 +217,11 @@ 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      | ❌      |
+| [jsx-no-ternary-null](docs/rules/JSX_NO_TERNARY_NULL.md)                                 | Enforce logical AND over ternary with null/undefined in JSX           | ✅      |
 | [jsx-no-variable-in-callback](docs/rules/JSX_NO_VARIABLE_IN_CALLBACK.md)                 | Disallow variable declarations inside callback functions in JSX       | ❌      |
 | [jsx-require-suspense](docs/rules/JSX_REQUIRE_SUSPENSE.md)                               | Require lazy-loaded components to be wrapped in Suspense              | ❌      |
 | [jsx-simple-props](docs/rules/JSX_SIMPLE_PROPS.md)                                       | Enforce simple prop values (strings, variables, callbacks, ReactNode) | ❌      |
@@ -238,14 +243,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         | 14        | 0             | 50          |
-| `react/recommended`  | error    | 36         | 14        | 0             | 50          |
-| `nextjs`             | warn     | 36         | 14        | 1             | 51          |
-| `nextjs/recommended` | error    | 36         | 14        | 1             | 51          |
+| `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:
 
@@ -278,6 +283,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`
@@ -286,7 +292,7 @@ Included in `base`, `base/recommended`, and all other presets:
 - `nextfriday/sort-type-alphabetically`
 - `nextfriday/sort-type-required-first`
 
-### JSX Rules (14 rules)
+### JSX Rules (15 rules)
 
 Additionally included in `react`, `react/recommended`, `nextjs`, `nextjs/recommended`:
 
@@ -296,6 +302,7 @@ Additionally included in `react`, `react/recommended`, `nextjs`, `nextjs/recomme
 - `nextfriday/jsx-no-inline-object-prop`
 - `nextfriday/jsx-no-newline-single-line-elements`
 - `nextfriday/jsx-no-non-component-function`
+- `nextfriday/jsx-no-ternary-null`
 - `nextfriday/jsx-no-variable-in-callback`
 - `nextfriday/jsx-pascal-case`
 - `nextfriday/jsx-require-suspense`
@@ -329,7 +336,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 51 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_CONSTANT_CASE.md

@@ -4,7 +4,7 @@ Enforce SCREAMING_SNAKE_CASE for constant primitive 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 `const` declarations with static primitive values (strings, numbers, booleans, static template literals) use SCREAMING_SNAKE_CASE naming convention. Template literals with expressions (e.g., `` `${variable}` ``) are considered dynamic and are not checked. Objects, arrays, and functions are not checked. Only `const` declarations are checked; `let` and `var` are ignored.
 
 ## Examples
 
@@ -13,7 +13,6 @@ 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`;
 ```
@@ -23,10 +22,18 @@ 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`;
 
+// Booleans with standard prefixes (is, has, should, can, etc.) are exempt
+const isEnabled = true;
+const hasAccess = false;
+const shouldRender = true;
+
+// Template literals with expressions are dynamic, camelCase is fine
+const pendingHref = `/branch/${branch.branchNumber}`;
+const greeting = `Hello, ${user.name}!`;
+
 // Objects, arrays, and functions can use camelCase
 const config = { key: "value" };
 const items = [1, 2, 3];

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/JSX_NO_TERNARY_NULL.md

@@ -0,0 +1,42 @@
+# jsx-no-ternary-null
+
+Enforce logical AND over ternary with null/undefined in JSX expressions.
+
+> This rule is auto-fixable using `--fix`.
+
+## Rule Details
+
+This rule flags ternary expressions inside JSX where one branch is `null` or `undefined`. These patterns are better expressed using the logical AND (`&&`) operator, which is more concise and idiomatic in React.
+
+### Why?
+
+- **Readability**: `{condition && <Component />}` is cleaner than `{condition ? <Component /> : null}`
+- **Consistency**: Encourages a single pattern for conditional rendering
+- **Conciseness**: Removes unnecessary null/undefined branches
+
+## Examples
+
+### Incorrect
+
+```tsx
+<div>{condition ? <span>Hello</span> : null}</div>
+<div>{condition ? <Component /> : undefined}</div>
+<div>{condition ? null : <span>Fallback</span>}</div>
+```
+
+### Correct
+
+```tsx
+<div>{condition && <span>Hello</span>}</div>
+<div>{condition && <Component />}</div>
+<div>{!condition && <span>Fallback</span>}</div>
+<div>{condition ? <A /> : <B />}</div>
+```
+
+## When Not To Use It
+
+If your team prefers explicit ternary expressions for conditional rendering, even when one branch is null or undefined.
+
+## Related Rules
+
+- [no-nested-ternary](JSX_NO_TERNARY_NULL.md)

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,60 @@
+# no-misleading-constant-case
+
+Disallow SCREAMING_SNAKE_CASE for non-constant or non-static values.
+
+## Rule Details
+
+SCREAMING_SNAKE_CASE conventionally signals a compile-time constant with a static, immutable value. Using it for mutable bindings (`let`/`var`) or dynamic values (function calls, objects, arrays, computed expressions) is misleading because the name implies immutability that the value does not have.
+
+### Why?
+
+When reading `const API_URL = getUrl()`, the SCREAMING_SNAKE_CASE name suggests a hardcoded value, but it is actually computed at runtime. This mismatch makes code harder to reason about. Reserving SCREAMING_SNAKE_CASE for true static primitives keeps the convention meaningful.
+
+## Examples
+
+### Incorrect
+
+```ts
+// Mutable bindings should not use SCREAMING_SNAKE_CASE
+let API_URL = "https://api.example.com";
+var MAX_COUNT = 10;
+
+// Dynamic or computed values should use camelCase
+const API_URL = getUrl();
+const USER_ID = await fetchId();
+const PATHNAME = `/news/${slug}`;
+const CONFIG = { key: "value" };
+const ITEMS = [1, 2, 3];
+const RESULT = a + b;
+const ACTIVE_USERS = users.filter((u) => u.active);
+```
+
+### Correct
+
+```ts
+// Static primitive constants use SCREAMING_SNAKE_CASE
+const API_URL = "https://api.example.com";
+const MAX_COUNT = 10;
+const IS_PRODUCTION = true;
+const TEMPLATE = `hello world`;
+
+// Dynamic or computed values use camelCase
+const apiUrl = getUrl();
+const userId = await fetchId();
+const pathname = `/news/${slug}`;
+const config = { key: "value" };
+const items = [1, 2, 3];
+const result = a + b;
+
+// 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 static primitive constants.
+
+## Related Rules
+
+- [enforce-constant-case](ENFORCE_CONSTANT_CASE.md) - The complementary rule that enforces SCREAMING_SNAKE_CASE for static primitive constants

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.