eslint-plugin-nextfriday 1.20.0 → 1.21.0

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # 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

package/README.md

@@ -155,8 +155,10 @@ export default [
 | [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   | ❌      |
+| [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
 
@@ -185,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                                    | ❌      |

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 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.
+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
 
@@ -15,6 +17,9 @@ const defaultCover = "/images/default.jpg";
 const pageLimit = 10;
 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
@@ -24,27 +29,37 @@ 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 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, can, etc.) are exempt
-const isEnabled = true;
+// Booleans with standard prefixes (is, has, should, etc.) are exempt
+const isProduction = 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];
+// 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/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_MISLEADING_CONSTANT_CASE.md

@@ -4,47 +4,62 @@ 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.
+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?
 
-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.
+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 should not use SCREAMING_SNAKE_CASE
+// Mutable bindings
 let API_URL = "https://api.example.com";
 var MAX_COUNT = 10;
 
-// Dynamic or computed values should use camelCase
+// Dynamic values at global scope
 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);
+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
-// Static primitive constants use SCREAMING_SNAKE_CASE
+// Global static constants use SCREAMING_SNAKE_CASE
 const API_URL = "https://api.example.com";
 const MAX_COUNT = 10;
-const IS_PRODUCTION = true;
-const TEMPLATE = `hello world`;
+const ITEMS = [1, 2, 3];
+const CONFIG = { key: "value" };
+const VARIANTS = ["a", "b"] as const;
 
-// Dynamic or computed values use camelCase
+// Dynamic 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;
+
+// Local scope uses camelCase
+function foo() {
+  const maxRetry = 3;
+  const totalCount = items.length;
+}
 
 // Mutable bindings use camelCase
 let count = 10;
@@ -53,8 +68,9 @@ 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.
+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 static primitive constants
+- [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