.github/FUNDING.yml

@@ -1,2 +1 @@
-open_collective: fold_left
-custom: ['https://www.paypal.me/foldleft']
+github: JamieMason

CHANGELOG.md

@@ -1,3 +1,12 @@
+## [3.2.4](https://github.com/JamieMason/eslint-plugin-prefer-arrow-functions/compare/3.1.4...3.2.4) (2023-10-23)
+
+
+### Features
+
+* **config:** add support for allowNamedFunctions ([50fb3b6](https://github.com/JamieMason/eslint-plugin-prefer-arrow-functions/commit/50fb3b68d9b2eaf48617404bec8f9ed1b4e6a511))
+
+
+
 ## [3.1.4](https://github.com/JamieMason/eslint-plugin-prefer-arrow-functions/compare/3.1.3...3.1.4) (2021-11-13)
 
 

README.md

@@ -34,6 +34,7 @@ Add the plugin to the `plugins` section and the rule to the `rules` section in y
     "prefer-arrow-functions/prefer-arrow-functions": [
       "warn",
       {
+        "allowNamedFunctions": false,
         "classPropertiesAllowed": false,
         "disallowPrototype": false,
         "returnStyle": "unchanged",
@@ -46,6 +47,10 @@ Add the plugin to the `plugins` section and the rule to the `rules` section in y
 
 ## 🤔 Options
 
+### `allowNamedFunctions`
+
+If set to true, the rule won't report named functions such as `function foo() {}`. Anonymous function such as `const foo = function() {}` will still be reported.
+
 ### `classPropertiesAllowed`
 
 When `true`, functions defined as [class instance fields](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes#Field_declarations) will be converted to arrow functions when doing so would not alter or break their behaviour.

package.json

@@ -1,7 +1,7 @@
 {
   "name": "eslint-plugin-prefer-arrow-functions",
   "description": "Convert functions to arrow functions",
-  "version": "3.1.4",
+  "version": "3.2.4",
   "author": "Jamie Mason (https://github.com/JamieMason)",
   "bugs": "https://github.com/JamieMason/eslint-plugin-prefer-arrow-functions/issues",
   "contributors": [

src/config.ts

@@ -1,4 +1,5 @@
 export const DEFAULT_OPTIONS = {
+  allowNamedFunctions: false,
   classPropertiesAllowed: false,
   disallowPrototype: false,
   returnStyle: 'unchanged',

src/prefer-arrow-functions.spec.ts

@@ -691,6 +691,81 @@ const invalidWhenReturnStyleIsExplicit = [
   },
 ];
 
+const validWhenAllowNamedFunctions = [
+  { code: '() => { function foo() { return "bar"; } }' },
+  { code: '() => { function * fooGen() { return yield "bar"; } }' },
+  { code: '() => { async function foo() { return await "bar"; } }' },
+  { code: '() => { function foo() { return () => "bar"; } }' },
+  { code: 'class FooClass { foo() { return "bar" }}' },
+  {
+    code: 'export default () => { function foo() { return "bar"; } }',
+  },
+  {
+    // Make sure "allowNamedFunctions" works with typescript
+    code: '() => { function foo(a: string): string { return `bar ${a}`;} }',
+    parser: require.resolve('@typescript-eslint/parser'),
+  },
+];
+
+const invalidWhenAllowNamedFunctions = [
+  // Invalid tests for "allowNamedFunctions" option
+  {
+    code: '() => { var foo = function() { return "bar"; }; }',
+    output: '() => { var foo = () => "bar"; }',
+  },
+  {
+    code: '() => { var foo = async function() { return await "bar"; }; }',
+    output: '() => { var foo = async () => await "bar"; }',
+  },
+  {
+    code: '() => { var foo = function() { return () => "bar"; }; }',
+    output: '() => { var foo = () => () => "bar"; }',
+  },
+  {
+    code: '() => { var foo = function() { return "bar"; }; }',
+    output: '() => { var foo = () => "bar"; }',
+  },
+  {
+    code: 'module.exports = () => { var foo = function() { return "bar"; }; }',
+    output: 'module.exports = () => { var foo = () => "bar"; }',
+  },
+  {
+    code: 'module.exports.foo = () => { var bar = function() { return "baz"; }; }',
+    output: 'module.exports.foo = () => { var bar = () => "baz"; }',
+  },
+  {
+    code: '() => { exports.foo = function() { return "bar"; }; }',
+    output: '() => { exports.foo = () => "bar"; }',
+  },
+  {
+    code: 'exports = function() { return "bar"; };',
+    output: 'exports = () => "bar";',
+  },
+  {
+    code: 'export default () => { var foo = function() { return "bar"; }; }',
+    output: 'export default () => { var foo = () => "bar"; }',
+  },
+  {
+    // Using multiple lines to check that it only errors on the inner function
+    code: `function top() {
+      return function() { return "bar"; };
+    }`,
+    output: `function top() {
+      return () => "bar";
+    }`,
+  },
+  {
+    // Make sure "allowNamedFunctions" works with typescript
+    code: `function foo(a: string): () => string {
+      return function() { return \`bar \${a}\`; };
+    }`,
+    output: `function foo(a: string): () => string {
+      return () => \`bar \${a}\`;
+    }`,
+    parser: require.resolve('@typescript-eslint/parser'),
+  },
+];
+
 const ruleTester = new RuleTester({
   parser: require.resolve('@typescript-eslint/parser'),
   parserOptions: {
@@ -862,3 +937,16 @@ describe('when returnStyle is "explicit"', () => {
     });
   });
 });
+
+describe('when allowNamedFunctions is true', () => {
+  describe("it doesn't report named functions", () => {
+    ruleTester.run('lib/rules/prefer-arrow-functions', rule, {
+      valid: validWhenAllowNamedFunctions.map(
+        withOptions({ allowNamedFunctions: true }),
+      ),
+      invalid: invalidWhenAllowNamedFunctions
+        .map(withOptions({ allowNamedFunctions: true }))
+        .map(withErrors([USE_ARROW_WHEN_FUNCTION])),
+    });
+  });
+});

src/prefer-arrow-functions.ts

@@ -18,6 +18,7 @@ export default {
       {
         additionalProperties: false,
         properties: {
+          allowNamedFunctions: { type: 'boolean' },
           classPropertiesAllowed: { type: 'boolean' },
           disallowPrototype: { type: 'boolean' },
           returnStyle: {
@@ -37,6 +38,7 @@ export default {
       typeof options[name] !== 'undefined'
         ? options[name]
         : DEFAULT_OPTIONS[name];
+    const allowNamedFunctions = getOption('allowNamedFunctions');
     const singleReturnOnly = getOption('singleReturnOnly');
     const classPropertiesAllowed = getOption('classPropertiesAllowed');
     const disallowPrototype = getOption('disallowPrototype');
@@ -195,10 +197,10 @@ export default {
         });
     };
 
+    const isNamed = (node) => node.id && node.id.name;
+
     const isNamedDefaultExport = (node) =>
-      node.id &&
-      node.id.name &&
-      node.parent.type === 'ExportDefaultDeclaration';
+      isNamed(node) && node.parent.type === 'ExportDefaultDeclaration';
 
     const isSafeTransformation = (node) => {
       return (
@@ -207,6 +209,7 @@ export default {
         !containsSuper(node) &&
         !containsArguments(node) &&
         !containsNewDotTarget(node) &&
+        (!isNamed(node) || !allowNamedFunctions) &&
         (!isPrototypeAssignment(node) || disallowPrototype) &&
         (!singleReturnOnly ||
           (returnsImmediately(node) && !isNamedDefaultExport(node)))