eslint-plugin-nextfriday 1.2.3 → 1.3.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # eslint-plugin-nextfriday
 
+## 1.3.0
+
+### Minor Changes
+
+- [#24](https://github.com/next-friday/eslint-plugin-nextfriday/pull/24) [`59d1932`](https://github.com/next-friday/eslint-plugin-nextfriday/commit/59d193258d6ffd19d6fd90515626d826732e30b3) Thanks [@nextfridaydeveloper](https://github.com/nextfridaydeveloper)! - Add new prefer-named-param-types rule that enforces using named interfaces or type aliases instead of inline object type literals for function
+
 ## 1.2.3
 
 ### Patch Changes

package/README.md

@@ -65,6 +65,7 @@ export default [
       "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/jsx-pascal-case": "error",
       "nextfriday/prefer-interface-over-inline-types": "error",
@@ -115,6 +116,7 @@ module.exports = {
 | [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                      | ✅      |
 | [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-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          | ❌      |
@@ -134,6 +136,7 @@ Basic configuration without JSX-specific rules:
 - `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"`
 
 #### `base/recommended`

package/docs/rules/PREFER_NAMED_PARAM_TYPES.md

@@ -0,0 +1,172 @@
+# prefer-named-param-types
+
+Enforce named interfaces or types instead of inline object types for function parameters.
+
+## Rule Details
+
+This rule enforces extracting inline object type annotations for function parameters into named interfaces or type aliases. This promotes better code organization, reusability, and readability across your codebase.
+
+Examples of **incorrect** code for this rule:
+
+```typescript
+// Destructured parameter with inline type
+const foo = ({ bar, baz }: { bar: string; baz: number }) => {
+  console.log(bar, baz);
+};
+
+// Regular parameter with inline type
+const foo = (params: { bar: string; baz: number }) => {
+  const { bar, baz } = params;
+  console.log(bar, baz);
+};
+
+// Function declaration
+function createUser(data: { name: string; email: string; role: "admin" | "user" }) {
+  return { ...data, createdAt: Date.now() };
+}
+
+// Function expression
+const handler = function (data: { id: number; name: string }) {
+  return data.id;
+};
+
+// Multiple parameters with inline types
+const foo = (first: { a: string; b: number }, second: { x: boolean; y: string }) => {
+  return { first, second };
+};
+```
+
+Examples of **correct** code for this rule:
+
+```typescript
+// Using interface
+interface Params {
+  bar: string;
+  baz: number;
+}
+
+const foo = (params: Params) => {
+  const { bar, baz } = params;
+  console.log(bar, baz);
+};
+
+// Using type alias
+type UserData = {
+  name: string;
+  email: string;
+  role: "admin" | "user";
+};
+
+const createUser = (data: UserData) => {
+  return { ...data, createdAt: Date.now() };
+};
+
+// Primitive types are allowed
+const foo = (value: string) => {
+  return value;
+};
+
+const bar = (count: number, enabled: boolean) => {
+  return count > 0 && enabled;
+};
+
+// Functions with no parameters
+const baz = () => {
+  return "no params";
+};
+
+// Named types with destructuring
+interface Config {
+  theme: string;
+  locale: string;
+}
+
+const setup = (config: Config) => {
+  const { theme, locale } = config;
+  console.log(theme, locale);
+};
+```
+
+## Why?
+
+### Benefits of named parameter types:
+
+1. **Reusability**: Named types can be reused across multiple functions
+2. **Better organization**: Separates type definitions from function logic
+3. **Improved readability**: Makes function signatures cleaner and easier to understand
+4. **Better IDE support**: Enhanced autocomplete, refactoring, and navigation
+5. **Documentation**: Named types serve as clear documentation of function APIs
+6. **Extensibility**: Types and interfaces can be extended and composed more easily
+7. **Type inference**: Named types can improve TypeScript's type inference in complex scenarios
+
+## Rule Scope
+
+This rule applies to:
+
+- All function types: arrow functions, function expressions, and function declarations
+- Function parameters with inline object type literals
+- Method definitions with inline object type parameters
+- TypeScript method signatures
+
+The rule triggers when:
+
+- A parameter has an inline object type literal (e.g., `{ bar: string; baz: number }`)
+- The parameter is destructured with an inline type (e.g., `({ bar, baz }: { bar: string; baz: number })`)
+
+The rule allows:
+
+- Primitive type annotations (string, number, boolean, etc.)
+- Named types and interfaces
+- Type aliases
+- Functions with no parameters
+- Array types (e.g., `string[]`)
+- Union/intersection types without object literals
+
+## When Not To Use It
+
+This rule should not be used if you:
+
+- Prefer inline types for simple, one-off function parameters
+- Are working with very simple functions that don't benefit from type extraction
+- Have specific code style requirements that favor inline types
+- Are maintaining legacy code with established patterns
+
+## Configuration
+
+This rule is included in the following configurations:
+
+- `nextfriday/base`
+- `nextfriday/base/recommended`
+- `nextfriday/react`
+- `nextfriday/react/recommended`
+- `nextfriday/nextjs`
+- `nextfriday/nextjs/recommended`
+
+To enable this rule manually:
+
+```json
+{
+  "rules": {
+    "nextfriday/prefer-named-param-types": "error"
+  }
+}
+```
+
+## Relationship to Other Rules
+
+This rule complements but differs from `prefer-interface-over-inline-types`:
+
+- `prefer-interface-over-inline-types`: Focuses on React component props with complexity criteria
+- `prefer-named-param-types`: Applies to ALL functions with inline object types, regardless of complexity
+
+Both rules can be used together for comprehensive type organization.
+
+## Compatibility
+
+- TypeScript 3.0+ (interface and type alias declarations)
+- ESLint 9+ with flat config
+- Works with all function types in JavaScript/TypeScript
+
+## Version
+
+This rule was introduced in eslint-plugin-nextfriday v1.2.3.

package/lib/index.cjs

@@ -40,7 +40,7 @@ module.exports = __toCommonJS(index_exports);
 // package.json
 var package_default = {
   name: "eslint-plugin-nextfriday",
-  version: "1.2.3",
+  version: "1.3.0",
   description: "A comprehensive ESLint plugin providing custom rules and configurations for Next Friday development workflows.",
   keywords: [
     "eslint",
@@ -705,12 +705,74 @@ var preferInterfaceOverInlineTypes = createRule9({
 });
 var prefer_interface_over_inline_types_default = preferInterfaceOverInlineTypes;
 
-// src/rules/prefer-react-import-types.ts
+// src/rules/prefer-named-param-types.ts
 var import_utils10 = require("@typescript-eslint/utils");
 var createRule10 = import_utils10.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replace(/-/g, "_").toUpperCase()}.md`
 );
-var preferReactImportTypes = createRule10({
+var preferNamedParamTypes = createRule10({
+  name: "prefer-named-param-types",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Enforce named interfaces/types instead of inline object types for function parameters"
+    },
+    messages: {
+      preferNamedParamTypes: "Use a named interface or type for object parameter types instead of inline type annotations"
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    function hasInlineObjectType(param) {
+      if (param.type === import_utils10.AST_NODE_TYPES.AssignmentPattern) {
+        return hasInlineObjectType(param.left);
+      }
+      if (param.type === import_utils10.AST_NODE_TYPES.ObjectPattern) {
+        if (param.typeAnnotation?.typeAnnotation.type === import_utils10.AST_NODE_TYPES.TSTypeLiteral) {
+          return true;
+        }
+      }
+      if (param.type === import_utils10.AST_NODE_TYPES.Identifier) {
+        if (param.typeAnnotation?.typeAnnotation.type === import_utils10.AST_NODE_TYPES.TSTypeLiteral) {
+          return true;
+        }
+      }
+      return false;
+    }
+    function checkFunction(node) {
+      let params = [];
+      if ("params" in node) {
+        params = node.params;
+      } else if ("value" in node && node.value) {
+        params = node.value.params;
+      }
+      params.forEach((param) => {
+        if (hasInlineObjectType(param)) {
+          context.report({
+            node: param,
+            messageId: "preferNamedParamTypes"
+          });
+        }
+      });
+    }
+    return {
+      FunctionDeclaration: checkFunction,
+      FunctionExpression: checkFunction,
+      ArrowFunctionExpression: checkFunction,
+      TSMethodSignature: checkFunction,
+      MethodDefinition: checkFunction
+    };
+  }
+});
+var prefer_named_param_types_default = preferNamedParamTypes;
+
+// src/rules/prefer-react-import-types.ts
+var import_utils11 = require("@typescript-eslint/utils");
+var createRule11 = import_utils11.ESLintUtils.RuleCreator(
+  (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replace(/-/g, "_").toUpperCase()}.md`
+);
+var preferReactImportTypes = createRule11({
   name: "prefer-react-import-types",
   meta: {
     type: "suggestion",
@@ -786,7 +848,7 @@ var preferReactImportTypes = createRule10({
     ]);
     const allReactExports = /* @__PURE__ */ new Set([...reactTypes, ...reactRuntimeExports]);
     function checkMemberExpression(node) {
-      if (node.object.type === import_utils10.AST_NODE_TYPES.Identifier && node.object.name === "React" && node.property.type === import_utils10.AST_NODE_TYPES.Identifier && allReactExports.has(node.property.name)) {
+      if (node.object.type === import_utils11.AST_NODE_TYPES.Identifier && node.object.name === "React" && node.property.type === import_utils11.AST_NODE_TYPES.Identifier && allReactExports.has(node.property.name)) {
         const typeName = node.property.name;
         const isType = reactTypes.has(typeName);
         const importStatement = isType ? `import type { ${typeName} } from "react"` : `import { ${typeName} } from "react"`;
@@ -803,7 +865,7 @@ var preferReactImportTypes = createRule10({
     return {
       MemberExpression: checkMemberExpression,
       "TSTypeReference > TSQualifiedName": (node) => {
-        if (node.left.type === import_utils10.AST_NODE_TYPES.Identifier && node.left.name === "React" && node.right.type === import_utils10.AST_NODE_TYPES.Identifier && allReactExports.has(node.right.name)) {
+        if (node.left.type === import_utils11.AST_NODE_TYPES.Identifier && node.left.name === "React" && node.right.type === import_utils11.AST_NODE_TYPES.Identifier && allReactExports.has(node.right.name)) {
           const typeName = node.right.name;
           const isType = reactTypes.has(typeName);
           const importStatement = isType ? `import type { ${typeName} } from "react"` : `import { ${typeName} } from "react"`;
@@ -823,11 +885,11 @@ var preferReactImportTypes = createRule10({
 var prefer_react_import_types_default = preferReactImportTypes;
 
 // src/rules/react-props-destructure.ts
-var import_utils11 = require("@typescript-eslint/utils");
-var createRule11 = import_utils11.ESLintUtils.RuleCreator(
+var import_utils12 = require("@typescript-eslint/utils");
+var createRule12 = import_utils12.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replace(/-/g, "_").toUpperCase()}.md`
 );
-var reactPropsDestructure = createRule11({
+var reactPropsDestructure = createRule12({
   name: "react-props-destructure",
   meta: {
     type: "suggestion",
@@ -843,29 +905,29 @@ var reactPropsDestructure = createRule11({
   defaultOptions: [],
   create(context) {
     function hasJSXInConditional(node) {
-      return node.consequent.type === import_utils11.AST_NODE_TYPES.JSXElement || node.consequent.type === import_utils11.AST_NODE_TYPES.JSXFragment || node.alternate.type === import_utils11.AST_NODE_TYPES.JSXElement || node.alternate.type === import_utils11.AST_NODE_TYPES.JSXFragment;
+      return node.consequent.type === import_utils12.AST_NODE_TYPES.JSXElement || node.consequent.type === import_utils12.AST_NODE_TYPES.JSXFragment || node.alternate.type === import_utils12.AST_NODE_TYPES.JSXElement || node.alternate.type === import_utils12.AST_NODE_TYPES.JSXFragment;
     }
     function hasJSXInLogical(node) {
-      return node.right.type === import_utils11.AST_NODE_TYPES.JSXElement || node.right.type === import_utils11.AST_NODE_TYPES.JSXFragment;
+      return node.right.type === import_utils12.AST_NODE_TYPES.JSXElement || node.right.type === import_utils12.AST_NODE_TYPES.JSXFragment;
     }
     function hasJSXReturn(block) {
       return block.body.some((stmt) => {
-        if (stmt.type === import_utils11.AST_NODE_TYPES.ReturnStatement && stmt.argument) {
-          return stmt.argument.type === import_utils11.AST_NODE_TYPES.JSXElement || stmt.argument.type === import_utils11.AST_NODE_TYPES.JSXFragment || stmt.argument.type === import_utils11.AST_NODE_TYPES.ConditionalExpression && hasJSXInConditional(stmt.argument) || stmt.argument.type === import_utils11.AST_NODE_TYPES.LogicalExpression && hasJSXInLogical(stmt.argument);
+        if (stmt.type === import_utils12.AST_NODE_TYPES.ReturnStatement && stmt.argument) {
+          return stmt.argument.type === import_utils12.AST_NODE_TYPES.JSXElement || stmt.argument.type === import_utils12.AST_NODE_TYPES.JSXFragment || stmt.argument.type === import_utils12.AST_NODE_TYPES.ConditionalExpression && hasJSXInConditional(stmt.argument) || stmt.argument.type === import_utils12.AST_NODE_TYPES.LogicalExpression && hasJSXInLogical(stmt.argument);
         }
         return false;
       });
     }
     function isReactComponent(node) {
-      if (node.type === import_utils11.AST_NODE_TYPES.ArrowFunctionExpression) {
-        if (node.body.type === import_utils11.AST_NODE_TYPES.JSXElement || node.body.type === import_utils11.AST_NODE_TYPES.JSXFragment) {
+      if (node.type === import_utils12.AST_NODE_TYPES.ArrowFunctionExpression) {
+        if (node.body.type === import_utils12.AST_NODE_TYPES.JSXElement || node.body.type === import_utils12.AST_NODE_TYPES.JSXFragment) {
           return true;
         }
-        if (node.body.type === import_utils11.AST_NODE_TYPES.BlockStatement) {
+        if (node.body.type === import_utils12.AST_NODE_TYPES.BlockStatement) {
           return hasJSXReturn(node.body);
         }
-      } else if (node.type === import_utils11.AST_NODE_TYPES.FunctionExpression || node.type === import_utils11.AST_NODE_TYPES.FunctionDeclaration) {
-        if (node.body && node.body.type === import_utils11.AST_NODE_TYPES.BlockStatement) {
+      } else if (node.type === import_utils12.AST_NODE_TYPES.FunctionExpression || node.type === import_utils12.AST_NODE_TYPES.FunctionDeclaration) {
+        if (node.body && node.body.type === import_utils12.AST_NODE_TYPES.BlockStatement) {
           return hasJSXReturn(node.body);
         }
       }
@@ -879,9 +941,9 @@ var reactPropsDestructure = createRule11({
         return;
       }
       const param = node.params[0];
-      if (param.type === import_utils11.AST_NODE_TYPES.ObjectPattern) {
-        const properties = param.properties.filter((prop) => prop.type === import_utils11.AST_NODE_TYPES.Property).map((prop) => {
-          if (prop.key.type === import_utils11.AST_NODE_TYPES.Identifier) {
+      if (param.type === import_utils12.AST_NODE_TYPES.ObjectPattern) {
+        const properties = param.properties.filter((prop) => prop.type === import_utils12.AST_NODE_TYPES.Property).map((prop) => {
+          if (prop.key.type === import_utils12.AST_NODE_TYPES.Identifier) {
             return prop.key.name;
           }
           return null;
@@ -922,6 +984,7 @@ var rules = {
   "prefer-destructuring-params": prefer_destructuring_params_default,
   "prefer-import-type": prefer_import_type_default,
   "prefer-interface-over-inline-types": prefer_interface_over_inline_types_default,
+  "prefer-named-param-types": prefer_named_param_types_default,
   "prefer-react-import-types": prefer_react_import_types_default,
   "react-props-destructure": react_props_destructure_default
 };
@@ -936,6 +999,7 @@ var baseRules = {
   "nextfriday/prefer-destructuring-params": "warn",
   "nextfriday/no-explicit-return-type": "warn",
   "nextfriday/prefer-import-type": "warn",
+  "nextfriday/prefer-named-param-types": "warn",
   "nextfriday/prefer-react-import-types": "warn"
 };
 var baseRecommendedRules = {
@@ -945,6 +1009,7 @@ var baseRecommendedRules = {
   "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"
 };
 var jsxRules = {