eslint-plugin-nextfriday 1.10.2 → 1.11.0

package/CHANGELOG.md

@@ -1,5 +1,36 @@
 # eslint-plugin-nextfriday
 
+## 1.11.0
+
+### Minor Changes
+
+- [#53](https://github.com/next-friday/eslint-plugin-nextfriday/pull/53) [`732db65`](https://github.com/next-friday/eslint-plugin-nextfriday/commit/732db659671cb6363b40af16c9c40400a10225ab) Thanks [@nextfridaydeveloper](https://github.com/nextfridaydeveloper)! - feat(no-inline-default-export): extend rule to also flag inline named exports
+
+  The `no-inline-default-export` rule now also flags inline named exports like `export function xxx()` and `export class Xxx`. These should be declared first, then exported separately using `export { xxx };`.
+
+  ### New behavior
+
+  **Incorrect:**
+
+  ```typescript
+  export function fetchData() { ... }
+  export async function fetchHighlight() { ... }
+  export class UserService { ... }
+  ```
+
+  **Correct:**
+
+  ```typescript
+  function fetchData() { ... }
+  export { fetchData };
+
+  async function fetchHighlight() { ... }
+  export default fetchHighlight;
+
+  class UserService { ... }
+  export { UserService };
+  ```
+
 ## 1.10.2
 
 ### Patch Changes

package/docs/rules/FILE_KEBAB_CASE.md

@@ -34,16 +34,20 @@ The content of the file doesn't matter - only the filename is checked:
 
 ```typescript
 // INCORRECT: File: MyFile.ts (incorrect filename)
-export const myFunction = () => {
+function myFunction() {
   return "Hello World";
-};
+}
+
+export { myFunction };
 ```
 
 ```typescript
 // CORRECT: File: my-file.ts (correct filename)
-export const myFunction = () => {
+function myFunction() {
   return "Hello World";
-};
+}
+
+export { myFunction };
 ```
 
 ```javascript
@@ -53,6 +57,8 @@ class UserService {
     return {};
   }
 }
+
+export { UserService };
 ```
 
 ```javascript
@@ -62,6 +68,8 @@ class UserService {
     return {};
   }
 }
+
+export { UserService };
 ```
 
 ## When Not To Use It

package/docs/rules/JSX_NO_NON_COMPONENT_FUNCTION.md

@@ -55,9 +55,11 @@ const calculateTotal = (items: number[]) => {
   return items.reduce((sum, item) => sum + item, 0);
 };
 
-export const OrderSummary = () => {
+const OrderSummary = () => {
   return <div>Total</div>;
 };
+
+export { OrderSummary };
 ```
 
 ### ✅ Correct
@@ -89,19 +91,23 @@ const Component = () => {
 };
 ```
 
-```tsx
+```typescript
 // Good: Functions in .ts or .js files are allowed
 // utils.ts
-export const helper = (name: string) => {
+function helper(name: string) {
   return name.toUpperCase();
-};
+}
+
+export { helper };
 ```
 
 ```tsx
 // Good: Exported component functions are allowed
-export const Component = () => {
+const Component = () => {
   return <div>Hello</div>;
 };
+
+export { Component };
 ```
 
 ## When Not To Use It

package/docs/rules/JSX_PASCAL_CASE.md

@@ -34,30 +34,38 @@ The content of the file doesn't matter - only the filename is checked:
 
 ```jsx
 // INCORRECT: File: my-component.jsx (incorrect filename)
-export default function MyComponent() {
+function MyComponent() {
   return <div>Hello</div>;
 }
+
+export default MyComponent;
 ```
 
 ```jsx
 // CORRECT: File: MyComponent.jsx (correct filename)
-export default function MyComponent() {
+function MyComponent() {
   return <div>Hello</div>;
 }
+
+export default MyComponent;
 ```
 
 ```tsx
 // INCORRECT: File: user-profile.tsx (incorrect filename)
-export default function UserProfile() {
+function UserProfile() {
   return <div>Profile</div>;
 }
+
+export default UserProfile;
 ```
 
 ```tsx
 // CORRECT: File: UserProfile.tsx (correct filename)
-export default function UserProfile() {
+function UserProfile() {
   return <div>Profile</div>;
 }
+
+export default UserProfile;
 ```
 
 ## When Not To Use

package/docs/rules/NO_INLINE_DEFAULT_EXPORT.md

@@ -1,78 +1,101 @@
 # no-inline-default-export
 
-Disallow inline default exports. Prefer declaring first, then exporting separately.
+Disallow inline exports. Declare first, then export separately.
 
 ## Rule Details
 
-This rule enforces separating function/class declarations from their default exports. Instead of combining declaration and export in a single statement, declare the function or class first, then export it by reference.
+This rule enforces separating declarations from exports. Instead of `export function`, declare the function first, then export it.
 
-This pattern improves code readability and makes it easier to identify what a module exports at a glance.
+**Incorrect** code for this rule:
 
-## Examples
+```typescript
+// Inline named export
+export function fetchData() {
+  return fetch("/api");
+}
 
-### Incorrect
+// Inline async named export
+export async function fetchHighlight(id: string) {
+  return await api.get(`/highlights/${id}`);
+}
 
-```typescript
-// Inline function default export
-export default function generator(plop: PlopTypes.NodePlopAPI): void {
+// Inline class export
+export class UserService {
+  // ...
+}
+
+// Inline default export
+export default function generator() {
   // ...
 }
 
-// Inline class default export
+// Inline default class export
 export default class MyService {
   // ...
 }
 
-// Anonymous function default export
+// Anonymous exports
 export default function () {
   return "anonymous";
 }
 
-// Arrow function default export
 export default () => "arrow";
-
-// Anonymous class default export
-export default class {
-  // ...
-}
 ```
 
-### Correct
+**Correct** code for this rule:
 
 ```typescript
-// Separate function declaration and export
-function generator(plop: PlopTypes.NodePlopAPI): void {
-  // ...
+// Declare function, then export
+function fetchData() {
+  return fetch("/api");
 }
 
-export default generator;
+export { fetchData };
 
-// Separate class declaration and export
-class MyService {
+// Declare async function, then export
+async function fetchHighlight(id: string) {
+  return await api.get(`/highlights/${id}`);
+}
+
+export { fetchHighlight };
+
+// Or use default export
+export default fetchHighlight;
+
+// Declare class, then export
+class UserService {
   // ...
 }
 
-export default MyService;
+export { UserService };
 
-// Separate const arrow function and export
-const processData = (data: Data): Result => {
+// Declare function, then default export
+function generator() {
   // ...
-};
+}
+
+export default generator;
 
-export default processData;
+// Re-exports are allowed
+export { foo } from "./foo";
+export { bar as default } from "./bar";
+export type { Baz } from "./baz";
 
-// Exporting literals and objects is allowed
+// Literals and objects are allowed
 export default "literal";
 export default { key: "value" };
-
-// Re-exports are allowed
-export { foo as default } from "./foo";
 ```
 
+## Benefits
+
+- **Readability**: Easy to see what a module exports at a glance
+- **Consistency**: All exports follow the same pattern
+- **Refactoring**: Easier to rename or move declarations
+
 ## When Not To Use
 
-If your project prefers inline default exports for brevity, or if you're working with frameworks that expect specific export patterns, you may want to disable this rule.
+If your project prefers inline exports for brevity, you may want to disable this rule.
 
 ## Related Rules
 
-- [prefer-function-declaration](./PREFER_FUNCTION_DECLARATION.md) - Prefer function declarations over expressions
+- [prefer-function-declaration](./PREFER_FUNCTION_DECLARATION.md) - Prefer function declarations over arrow functions

package/docs/rules/PREFER_FUNCTION_DECLARATION.md

@@ -1,29 +1,30 @@
 # prefer-function-declaration
 
-Enforce function declarations over arrow functions assigned to variables in `.ts` files for better readability and hoisting.
+Enforce function declarations over arrow functions assigned to variables in `.ts` files.
 
 ## Rule Details
 
-This rule requires using function declarations instead of arrow functions or function expressions when defining named functions in TypeScript utility files. Arrow functions used as callbacks (in `.map()`, `.filter()`, etc.) are still allowed.
+This rule requires using function declarations instead of arrow functions or function expressions when defining named functions. Arrow functions used as callbacks are still allowed.
 
 **Target:** `.ts` files only (not `.tsx`, `.js`, or `.d.ts`)
 
 **Incorrect** code for this rule:
 
 ```typescript
-// utils/date.ts
-const formatThaiDate = (date: Date) => {
+// Arrow function assigned to variable
+const formatDate = (date: Date) => {
   return date.toLocaleDateString("th-TH");
 };
 
-const formatDate = (date: Date) => date.toISOString();
-
-export const add = (a: number, b: number) => a + b;
+// Arrow function with implicit return
+const add = (a: number, b: number) => a + b;
 
+// Function expression assigned to variable
 const greet = function (name: string) {
   return `Hello ${name}`;
 };
 
+// Async arrow function
 const fetchUser = async (id: string) => {
   return await api.get(`/users/${id}`);
 };
@@ -32,23 +33,22 @@ const fetchUser = async (id: string) => {
 **Correct** code for this rule:
 
 ```typescript
-// utils/date.ts
-function formatThaiDate(date: Date) {
-  return date.toLocaleDateString("th-TH");
-}
-
+// Function declaration
 function formatDate(date: Date) {
-  return date.toISOString();
+  return date.toLocaleDateString("th-TH");
 }
 
-export function add(a: number, b: number) {
+// Function declaration
+function add(a: number, b: number) {
   return a + b;
 }
 
+// Function declaration
 function greet(name: string) {
   return `Hello ${name}`;
 }
 
+// Async function declaration
 async function fetchUser(id: string) {
   return await api.get(`/users/${id}`);
 }
@@ -61,14 +61,11 @@ Arrow functions are still allowed in the following contexts:
 ### Callbacks
 
 ```typescript
-// All of these are allowed
 const years = dates.map((date) => date.getFullYear());
 const active = items.filter((item) => item.active);
 const sorted = items.sort((a, b) => a.name.localeCompare(b.name));
 items.forEach((item) => console.log(item));
-const total = items.reduce((sum, item) => sum + item.price, 0);
 setTimeout(() => console.log("done"), 1000);
-promise.then((result) => result.data);
 ```
 
 ### Object Properties
@@ -106,20 +103,18 @@ const handler = defaultFn || (() => fallback);
 ```typescript
 // components/Button.tsx - Arrow functions allowed
 const Button = () => <button>Click me</button>;
-const handleClick = () => console.log("clicked");
 ```
 
 ## Benefits
 
-- **Hoisting**: Function declarations are hoisted, allowing you to call functions before they're defined
-- **Better readability**: Function declarations are more explicit about intent
-- **Clearer stack traces**: Named function declarations provide better debugging information
-- **Consistent style**: Enforces uniform function definition patterns in utility files
+- **Hoisting**: Function declarations are hoisted
+- **Better readability**: Function declarations are more explicit
+- **Clearer stack traces**: Named function declarations provide better debugging
 - **Self-documenting**: `function formatDate()` is clearer than `const formatDate = () =>`
 
 ## Why Only `.ts` Files?
 
-- **`.tsx` files**: Arrow functions are commonly used for React components and event handlers
+- **`.tsx` files**: Arrow functions are commonly used for React components
 - **`.js` files**: JavaScript projects may have different conventions
 - **`.d.ts` files**: Declaration files don't contain implementations
 
@@ -127,13 +122,8 @@ const handleClick = () => console.log("clicked");
 
 - When you prefer arrow functions for all function definitions
 - In projects where arrow function style is established
-- When you need lexical `this` binding (arrow functions don't have their own `this`)
-
-## Configuration
-
-This rule has no configuration options.
+- When you need lexical `this` binding
 
 ## Related Rules
 
-- [func-style](https://eslint.org/docs/rules/func-style) - Built-in ESLint rule for function style
-- [arrow-body-style](https://eslint.org/docs/rules/arrow-body-style) - Enforce arrow function body style
+- [no-inline-default-export](./NO_INLINE_DEFAULT_EXPORT.md) - Disallow inline exports

package/docs/rules/REQUIRE_EXPLICIT_RETURN_TYPE.md

@@ -13,23 +13,23 @@ function getName() {
   return "John Doe";
 }
 
-const getAge = () => {
+function getAge() {
   return 25;
-};
+}
 
 function processUser() {
   console.log("Processing user");
 }
 
-const calculateTotal = (items: Item[]) => {
+function calculateTotal(items: Item[]) {
   return items.reduce((sum, item) => sum + item.price, 0);
-};
+}
 
 async function fetchData() {
   return await api.get("/data");
 }
 
-export function validateEmail(email: string) {
+function validateEmail(email: string) {
   return email.includes("@");
 }
 ```
@@ -41,23 +41,23 @@ function getName(): string {
   return "John Doe";
 }
 
-const getAge = (): number => {
+function getAge(): number {
   return 25;
-};
+}
 
 function processUser(): void {
   console.log("Processing user");
 }
 
-const calculateTotal = (items: Item[]): number => {
+function calculateTotal(items: Item[]): number {
   return items.reduce((sum, item) => sum + item.price, 0);
-};
+}
 
 async function fetchData(): Promise<Data> {
   return await api.get("/data");
 }
 
-export function validateEmail(email: string): boolean {
+function validateEmail(email: string): boolean {
   return email.includes("@");
 }
 ```

package/lib/index.cjs

@@ -40,7 +40,7 @@ module.exports = __toCommonJS(index_exports);
 // package.json
 var package_default = {
   name: "eslint-plugin-nextfriday",
-  version: "1.10.2",
+  version: "1.11.0",
   description: "A comprehensive ESLint plugin providing custom rules and configurations for Next Friday development workflows.",
   keywords: [
     "eslint",
@@ -979,11 +979,12 @@ var noInlineDefaultExport = createRule13({
   meta: {
     type: "suggestion",
     docs: {
-      description: "Disallow inline default exports. Prefer declaring first, then exporting separately."
+      description: "Disallow inline exports. Prefer declaring first, then exporting separately."
     },
     messages: {
       noInlineDefaultExport: "Avoid inline default export. Declare the {{type}} first, then export it separately: `export default {{name}};`",
-      noAnonymousDefaultExport: "Avoid anonymous default export. Declare a named {{type}} first, then export it separately."
+      noAnonymousDefaultExport: "Avoid anonymous default export. Declare a named {{type}} first, then export it separately.",
+      noInlineNamedExport: "Avoid inline named export. Declare the {{type}} first, then export it separately: `export { {{name}} };`"
     },
     schema: []
   },
@@ -1029,6 +1030,26 @@ var noInlineDefaultExport = createRule13({
             data: { type: "function" }
           });
         }
+      },
+      ExportNamedDeclaration(node) {
+        const { declaration } = node;
+        if (!declaration) {
+          return;
+        }
+        if (declaration.type === import_utils13.AST_NODE_TYPES.FunctionDeclaration && declaration.id) {
+          context.report({
+            node,
+            messageId: "noInlineNamedExport",
+            data: { type: "function", name: declaration.id.name }
+          });
+        }
+        if (declaration.type === import_utils13.AST_NODE_TYPES.ClassDeclaration && declaration.id) {
+          context.report({
+            node,
+            messageId: "noInlineNamedExport",
+            data: { type: "class", name: declaration.id.name }
+          });
+        }
       }
     };
   }