eslint-plugin-nextfriday 1.7.0 → 1.9.0

package/lib/index.js

@@ -1,7 +1,7 @@
 // package.json
 var package_default = {
   name: "eslint-plugin-nextfriday",
-  version: "1.7.0",
+  version: "1.9.0",
   description: "A comprehensive ESLint plugin providing custom rules and configurations for Next Friday development workflows.",
   keywords: [
     "eslint",
@@ -853,58 +853,124 @@ var noEnvFallback = createRule11({
 });
 var no_env_fallback_default = noEnvFallback;
 
-// src/rules/require-explicit-return-type.ts
+// src/rules/no-inline-default-export.ts
 import { ESLintUtils as ESLintUtils12, AST_NODE_TYPES as AST_NODE_TYPES8 } from "@typescript-eslint/utils";
 var createRule12 = ESLintUtils12.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
+var noInlineDefaultExport = createRule12({
+  name: "no-inline-default-export",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Disallow inline default 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."
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      ExportDefaultDeclaration(node) {
+        const { declaration } = node;
+        if (declaration.type === AST_NODE_TYPES8.FunctionDeclaration) {
+          if (declaration.id) {
+            context.report({
+              node,
+              messageId: "noInlineDefaultExport",
+              data: { type: "function", name: declaration.id.name }
+            });
+          } else {
+            context.report({
+              node,
+              messageId: "noAnonymousDefaultExport",
+              data: { type: "function" }
+            });
+          }
+        }
+        if (declaration.type === AST_NODE_TYPES8.ClassDeclaration) {
+          if (declaration.id) {
+            context.report({
+              node,
+              messageId: "noInlineDefaultExport",
+              data: { type: "class", name: declaration.id.name }
+            });
+          } else {
+            context.report({
+              node,
+              messageId: "noAnonymousDefaultExport",
+              data: { type: "class" }
+            });
+          }
+        }
+        if (declaration.type === AST_NODE_TYPES8.ArrowFunctionExpression || declaration.type === AST_NODE_TYPES8.FunctionExpression) {
+          context.report({
+            node,
+            messageId: "noAnonymousDefaultExport",
+            data: { type: "function" }
+          });
+        }
+      }
+    };
+  }
+});
+var no_inline_default_export_default = noInlineDefaultExport;
+
+// src/rules/require-explicit-return-type.ts
+import { ESLintUtils as ESLintUtils13, AST_NODE_TYPES as AST_NODE_TYPES9 } from "@typescript-eslint/utils";
+var createRule13 = ESLintUtils13.RuleCreator(
+  (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
+);
 var isReactComponent = (node) => {
-  if (node.type === AST_NODE_TYPES8.ArrowFunctionExpression) {
+  if (node.type === AST_NODE_TYPES9.ArrowFunctionExpression) {
     const { parent } = node;
-    if (parent?.type === AST_NODE_TYPES8.VariableDeclarator) {
+    if (parent?.type === AST_NODE_TYPES9.VariableDeclarator) {
       const { id } = parent;
-      if (id.type === AST_NODE_TYPES8.Identifier) {
+      if (id.type === AST_NODE_TYPES9.Identifier) {
         return /^[A-Z]/.test(id.name);
       }
     }
   }
-  if (node.type === AST_NODE_TYPES8.FunctionDeclaration && node.id) {
+  if (node.type === AST_NODE_TYPES9.FunctionDeclaration && node.id) {
     return /^[A-Z]/.test(node.id.name);
   }
   return false;
 };
 var isCallbackFunction = (node) => {
-  if (node.type === AST_NODE_TYPES8.FunctionDeclaration) {
+  if (node.type === AST_NODE_TYPES9.FunctionDeclaration) {
     return false;
   }
   const { parent } = node;
   if (!parent) {
     return false;
   }
-  if (parent.type === AST_NODE_TYPES8.CallExpression && parent.arguments.includes(node)) {
+  if (parent.type === AST_NODE_TYPES9.CallExpression && parent.arguments.includes(node)) {
     return true;
   }
-  if (parent.type === AST_NODE_TYPES8.Property) {
+  if (parent.type === AST_NODE_TYPES9.Property) {
     return true;
   }
-  if (parent.type === AST_NODE_TYPES8.ArrayExpression) {
+  if (parent.type === AST_NODE_TYPES9.ArrayExpression) {
     return true;
   }
   return false;
 };
 var getFunctionName = (node) => {
-  if (node.type === AST_NODE_TYPES8.FunctionDeclaration && node.id) {
+  if (node.type === AST_NODE_TYPES9.FunctionDeclaration && node.id) {
     return node.id.name;
   }
-  if (node.type === AST_NODE_TYPES8.FunctionExpression && node.id) {
+  if (node.type === AST_NODE_TYPES9.FunctionExpression && node.id) {
     return node.id.name;
   }
-  if ((node.type === AST_NODE_TYPES8.ArrowFunctionExpression || node.type === AST_NODE_TYPES8.FunctionExpression) && node.parent?.type === AST_NODE_TYPES8.VariableDeclarator && node.parent.id.type === AST_NODE_TYPES8.Identifier) {
+  if ((node.type === AST_NODE_TYPES9.ArrowFunctionExpression || node.type === AST_NODE_TYPES9.FunctionExpression) && node.parent?.type === AST_NODE_TYPES9.VariableDeclarator && node.parent.id.type === AST_NODE_TYPES9.Identifier) {
     return node.parent.id.name;
   }
   return null;
 };
-var requireExplicitReturnType = createRule12({
+var requireExplicitReturnType = createRule13({
   name: "require-explicit-return-type",
   meta: {
     type: "suggestion",
@@ -953,18 +1019,18 @@ var requireExplicitReturnType = createRule12({
 var require_explicit_return_type_default = requireExplicitReturnType;
 
 // src/rules/jsx-no-non-component-function.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES10, ESLintUtils as ESLintUtils13 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES11, ESLintUtils as ESLintUtils14 } from "@typescript-eslint/utils";
 
 // src/utils.ts
 import { basename, extname } from "path";
-import { AST_NODE_TYPES as AST_NODE_TYPES9 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES10 } from "@typescript-eslint/utils";
 var getFileExtension = (filename) => extname(filename).slice(1);
 
 // src/rules/jsx-no-non-component-function.ts
-var createRule13 = ESLintUtils13.RuleCreator(
+var createRule14 = ESLintUtils14.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var jsxNoNonComponentFunction = createRule13({
+var jsxNoNonComponentFunction = createRule14({
   name: "jsx-no-non-component-function",
   meta: {
     type: "problem",
@@ -984,13 +1050,13 @@ var jsxNoNonComponentFunction = createRule13({
       return {};
     }
     function isReactComponent2(node) {
-      const functionName = node.type === AST_NODE_TYPES10.FunctionDeclaration && node.id ? node.id.name : null;
+      const functionName = node.type === AST_NODE_TYPES11.FunctionDeclaration && node.id ? node.id.name : null;
       if (functionName && /^[A-Z]/.test(functionName)) {
         return true;
       }
       if (node.returnType?.typeAnnotation) {
         const returnTypeNode = node.returnType.typeAnnotation;
-        if (returnTypeNode.type === AST_NODE_TYPES10.TSTypeReference && returnTypeNode.typeName.type === AST_NODE_TYPES10.Identifier) {
+        if (returnTypeNode.type === AST_NODE_TYPES11.TSTypeReference && returnTypeNode.typeName.type === AST_NODE_TYPES11.Identifier) {
           const typeName = returnTypeNode.typeName.name;
           if (typeName === "JSX" || typeName === "ReactElement" || typeName === "ReactNode") {
             return true;
@@ -1007,13 +1073,13 @@ var jsxNoNonComponentFunction = createRule13({
       if (!parent) {
         return;
       }
-      if (parent.type === AST_NODE_TYPES10.ExportDefaultDeclaration || parent.type === AST_NODE_TYPES10.ExportNamedDeclaration) {
+      if (parent.type === AST_NODE_TYPES11.ExportDefaultDeclaration || parent.type === AST_NODE_TYPES11.ExportNamedDeclaration) {
         return;
       }
-      if (declaratorNode?.parent?.parent?.type === AST_NODE_TYPES10.ExportNamedDeclaration) {
+      if (declaratorNode?.parent?.parent?.type === AST_NODE_TYPES11.ExportNamedDeclaration) {
         return;
       }
-      if (declaratorNode?.id.type === AST_NODE_TYPES10.Identifier) {
+      if (declaratorNode?.id.type === AST_NODE_TYPES11.Identifier) {
         const varName = declaratorNode.id.name;
         if (/^[A-Z]/.test(varName)) {
           return;
@@ -1038,11 +1104,11 @@ var jsxNoNonComponentFunction = createRule13({
 var jsx_no_non_component_function_default = jsxNoNonComponentFunction;
 
 // src/rules/no-logic-in-params.ts
-import { ESLintUtils as ESLintUtils14, AST_NODE_TYPES as AST_NODE_TYPES11 } from "@typescript-eslint/utils";
-var createRule14 = ESLintUtils14.RuleCreator(
+import { ESLintUtils as ESLintUtils15, AST_NODE_TYPES as AST_NODE_TYPES12 } from "@typescript-eslint/utils";
+var createRule15 = ESLintUtils15.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var noLogicInParams = createRule14({
+var noLogicInParams = createRule15({
   name: "no-logic-in-params",
   meta: {
     type: "suggestion",
@@ -1057,20 +1123,20 @@ var noLogicInParams = createRule14({
   defaultOptions: [],
   create(context) {
     const isComplexExpression = (node) => {
-      if (node.type === AST_NODE_TYPES11.SpreadElement) {
+      if (node.type === AST_NODE_TYPES12.SpreadElement) {
         return false;
       }
-      if (node.type === AST_NODE_TYPES11.ConditionalExpression) {
+      if (node.type === AST_NODE_TYPES12.ConditionalExpression) {
         return true;
       }
-      if (node.type === AST_NODE_TYPES11.LogicalExpression) {
+      if (node.type === AST_NODE_TYPES12.LogicalExpression) {
         return true;
       }
-      if (node.type === AST_NODE_TYPES11.BinaryExpression) {
+      if (node.type === AST_NODE_TYPES12.BinaryExpression) {
         const logicalOperators = ["==", "===", "!=", "!==", "<", ">", "<=", ">=", "in", "instanceof"];
         return logicalOperators.includes(node.operator);
       }
-      if (node.type === AST_NODE_TYPES11.UnaryExpression) {
+      if (node.type === AST_NODE_TYPES12.UnaryExpression) {
         return node.operator === "!";
       }
       return false;
@@ -1101,9 +1167,145 @@ var noLogicInParams = createRule14({
 });
 var no_logic_in_params_default = noLogicInParams;
 
+// src/rules/no-lazy-identifiers.ts
+import { ESLintUtils as ESLintUtils16, AST_NODE_TYPES as AST_NODE_TYPES13 } from "@typescript-eslint/utils";
+var createRule16 = ESLintUtils16.RuleCreator(
+  (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
+);
+var KEYBOARD_ROWS = ["qwertyuiop", "asdfghjkl", "zxcvbnm", "1234567890"];
+var MIN_LENGTH = 3;
+var MIN_SEQUENCE_LENGTH = 4;
+var hasRepeatedChars = (name) => {
+  const lowerName = name.toLowerCase();
+  return lowerName.split("").some((char, index) => {
+    if (index > lowerName.length - 3) {
+      return false;
+    }
+    return char === lowerName[index + 1] && char === lowerName[index + 2];
+  });
+};
+var hasKeyboardSequence = (name) => {
+  const lowerName = name.toLowerCase();
+  if (lowerName.length < MIN_SEQUENCE_LENGTH) {
+    return false;
+  }
+  return KEYBOARD_ROWS.some((row) => {
+    const positions = Array.from({ length: row.length - MIN_SEQUENCE_LENGTH + 1 }, (_, i) => i);
+    return positions.some((start) => {
+      const sequence = row.slice(start, start + MIN_SEQUENCE_LENGTH);
+      const reverseSequence = sequence.split("").reverse().join("");
+      return lowerName.includes(sequence) || lowerName.includes(reverseSequence);
+    });
+  });
+};
+var isLazyIdentifier = (name) => {
+  if (name.length < MIN_LENGTH) {
+    return false;
+  }
+  if (name.startsWith("_")) {
+    return false;
+  }
+  if (hasRepeatedChars(name)) {
+    return true;
+  }
+  if (hasKeyboardSequence(name)) {
+    return true;
+  }
+  return false;
+};
+var noLazyIdentifiers = createRule16({
+  name: "no-lazy-identifiers",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow lazy, meaningless variable names that hurt code readability"
+    },
+    messages: {
+      noLazyIdentifier: "Avoid lazy identifier '{{name}}'. Use a descriptive name that clearly indicates the purpose."
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    const checkIdentifier = (node) => {
+      const { name } = node;
+      if (!isLazyIdentifier(name)) {
+        return;
+      }
+      context.report({
+        node,
+        messageId: "noLazyIdentifier",
+        data: { name }
+      });
+    };
+    const checkPattern = (pattern) => {
+      if (pattern.type === AST_NODE_TYPES13.Identifier) {
+        checkIdentifier(pattern);
+      } else if (pattern.type === AST_NODE_TYPES13.ObjectPattern) {
+        pattern.properties.forEach((prop) => {
+          if (prop.type === AST_NODE_TYPES13.Property && prop.value.type === AST_NODE_TYPES13.Identifier) {
+            checkIdentifier(prop.value);
+          } else if (prop.type === AST_NODE_TYPES13.RestElement && prop.argument.type === AST_NODE_TYPES13.Identifier) {
+            checkIdentifier(prop.argument);
+          }
+        });
+      } else if (pattern.type === AST_NODE_TYPES13.ArrayPattern) {
+        pattern.elements.forEach((element) => {
+          if (element?.type === AST_NODE_TYPES13.Identifier) {
+            checkIdentifier(element);
+          } else if (element?.type === AST_NODE_TYPES13.RestElement && element.argument.type === AST_NODE_TYPES13.Identifier) {
+            checkIdentifier(element.argument);
+          }
+        });
+      } else if (pattern.type === AST_NODE_TYPES13.AssignmentPattern && pattern.left.type === AST_NODE_TYPES13.Identifier) {
+        checkIdentifier(pattern.left);
+      } else if (pattern.type === AST_NODE_TYPES13.RestElement && pattern.argument.type === AST_NODE_TYPES13.Identifier) {
+        checkIdentifier(pattern.argument);
+      }
+    };
+    return {
+      VariableDeclarator(node) {
+        checkPattern(node.id);
+      },
+      FunctionDeclaration(node) {
+        if (node.id) {
+          checkIdentifier(node.id);
+        }
+        node.params.forEach((param) => checkPattern(param));
+      },
+      FunctionExpression(node) {
+        if (node.id) {
+          checkIdentifier(node.id);
+        }
+        node.params.forEach((param) => checkPattern(param));
+      },
+      ArrowFunctionExpression(node) {
+        node.params.forEach((param) => checkPattern(param));
+      },
+      CatchClause(node) {
+        if (node.param) {
+          checkPattern(node.param);
+        }
+      },
+      ClassDeclaration(node) {
+        if (node.id) {
+          checkIdentifier(node.id);
+        }
+      },
+      TSTypeAliasDeclaration(node) {
+        checkIdentifier(node.id);
+      },
+      TSInterfaceDeclaration(node) {
+        checkIdentifier(node.id);
+      }
+    };
+  }
+});
+var no_lazy_identifiers_default = noLazyIdentifiers;
+
 // src/rules/no-single-char-variables.ts
-import { ESLintUtils as ESLintUtils15, AST_NODE_TYPES as AST_NODE_TYPES12 } from "@typescript-eslint/utils";
-var createRule15 = ESLintUtils15.RuleCreator(
+import { ESLintUtils as ESLintUtils17, AST_NODE_TYPES as AST_NODE_TYPES14 } from "@typescript-eslint/utils";
+var createRule17 = ESLintUtils17.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var ALLOWED_IN_FOR_LOOPS = /* @__PURE__ */ new Set(["i", "j", "k", "n"]);
@@ -1115,7 +1317,7 @@ var isForLoopInit = (node) => {
     if (!parentNode) {
       return false;
     }
-    if (parentNode.type === AST_NODE_TYPES12.ForStatement) {
+    if (parentNode.type === AST_NODE_TYPES14.ForStatement) {
       const { init } = parentNode;
       if (init && init === current) {
         return true;
@@ -1134,7 +1336,7 @@ var isAllowedInContext = (name, node) => {
   }
   return false;
 };
-var noSingleCharVariables = createRule15({
+var noSingleCharVariables = createRule17({
   name: "no-single-char-variables",
   meta: {
     type: "suggestion",
@@ -1163,27 +1365,27 @@ var noSingleCharVariables = createRule15({
       });
     };
     const checkPattern = (pattern, declarationNode) => {
-      if (pattern.type === AST_NODE_TYPES12.Identifier) {
+      if (pattern.type === AST_NODE_TYPES14.Identifier) {
         checkIdentifier(pattern, declarationNode);
-      } else if (pattern.type === AST_NODE_TYPES12.ObjectPattern) {
+      } else if (pattern.type === AST_NODE_TYPES14.ObjectPattern) {
         pattern.properties.forEach((prop) => {
-          if (prop.type === AST_NODE_TYPES12.Property && prop.value.type === AST_NODE_TYPES12.Identifier) {
+          if (prop.type === AST_NODE_TYPES14.Property && prop.value.type === AST_NODE_TYPES14.Identifier) {
             checkIdentifier(prop.value, declarationNode);
-          } else if (prop.type === AST_NODE_TYPES12.RestElement && prop.argument.type === AST_NODE_TYPES12.Identifier) {
+          } else if (prop.type === AST_NODE_TYPES14.RestElement && prop.argument.type === AST_NODE_TYPES14.Identifier) {
             checkIdentifier(prop.argument, declarationNode);
           }
         });
-      } else if (pattern.type === AST_NODE_TYPES12.ArrayPattern) {
+      } else if (pattern.type === AST_NODE_TYPES14.ArrayPattern) {
         pattern.elements.forEach((element) => {
-          if (element?.type === AST_NODE_TYPES12.Identifier) {
+          if (element?.type === AST_NODE_TYPES14.Identifier) {
             checkIdentifier(element, declarationNode);
-          } else if (element?.type === AST_NODE_TYPES12.RestElement && element.argument.type === AST_NODE_TYPES12.Identifier) {
+          } else if (element?.type === AST_NODE_TYPES14.RestElement && element.argument.type === AST_NODE_TYPES14.Identifier) {
             checkIdentifier(element.argument, declarationNode);
           }
         });
-      } else if (pattern.type === AST_NODE_TYPES12.AssignmentPattern && pattern.left.type === AST_NODE_TYPES12.Identifier) {
+      } else if (pattern.type === AST_NODE_TYPES14.AssignmentPattern && pattern.left.type === AST_NODE_TYPES14.Identifier) {
         checkIdentifier(pattern.left, declarationNode);
-      } else if (pattern.type === AST_NODE_TYPES12.RestElement && pattern.argument.type === AST_NODE_TYPES12.Identifier) {
+      } else if (pattern.type === AST_NODE_TYPES14.RestElement && pattern.argument.type === AST_NODE_TYPES14.Identifier) {
         checkIdentifier(pattern.argument, declarationNode);
       }
     };
@@ -1217,11 +1419,11 @@ var noSingleCharVariables = createRule15({
 var no_single_char_variables_default = noSingleCharVariables;
 
 // src/rules/prefer-destructuring-params.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES13, ESLintUtils as ESLintUtils16 } from "@typescript-eslint/utils";
-var createRule16 = ESLintUtils16.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES15, ESLintUtils as ESLintUtils18 } from "@typescript-eslint/utils";
+var createRule18 = ESLintUtils18.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var preferDestructuringParams = createRule16({
+var preferDestructuringParams = createRule18({
   name: "prefer-destructuring-params",
   meta: {
     type: "suggestion",
@@ -1237,18 +1439,18 @@ var preferDestructuringParams = createRule16({
   create(context) {
     const isCallbackFunction2 = (node) => {
       const { parent } = node;
-      return parent?.type === AST_NODE_TYPES13.CallExpression;
+      return parent?.type === AST_NODE_TYPES15.CallExpression;
     };
     const isDeveloperFunction = (node) => {
-      if (node.type === AST_NODE_TYPES13.FunctionDeclaration) {
+      if (node.type === AST_NODE_TYPES15.FunctionDeclaration) {
         return true;
       }
-      if (node.type === AST_NODE_TYPES13.FunctionExpression || node.type === AST_NODE_TYPES13.ArrowFunctionExpression) {
+      if (node.type === AST_NODE_TYPES15.FunctionExpression || node.type === AST_NODE_TYPES15.ArrowFunctionExpression) {
         if (isCallbackFunction2(node)) {
           return false;
         }
         const { parent } = node;
-        return parent?.type === AST_NODE_TYPES13.VariableDeclarator || parent?.type === AST_NODE_TYPES13.AssignmentExpression || parent?.type === AST_NODE_TYPES13.Property || parent?.type === AST_NODE_TYPES13.MethodDefinition;
+        return parent?.type === AST_NODE_TYPES15.VariableDeclarator || parent?.type === AST_NODE_TYPES15.AssignmentExpression || parent?.type === AST_NODE_TYPES15.Property || parent?.type === AST_NODE_TYPES15.MethodDefinition;
       }
       return false;
     };
@@ -1260,7 +1462,7 @@ var preferDestructuringParams = createRule16({
       if (!isDeveloperFunction(node)) {
         return;
       }
-      if (node.type === AST_NODE_TYPES13.FunctionDeclaration && node.id) {
+      if (node.type === AST_NODE_TYPES15.FunctionDeclaration && node.id) {
         const functionName = node.id.name;
         if (functionName.startsWith("_") || functionName.includes("$") || /^[A-Z][a-zA-Z]*$/.test(functionName)) {
           return;
@@ -1270,7 +1472,7 @@ var preferDestructuringParams = createRule16({
         return;
       }
       const hasNonDestructuredParams = node.params.some(
-        (param) => param.type !== AST_NODE_TYPES13.ObjectPattern && param.type !== AST_NODE_TYPES13.RestElement
+        (param) => param.type !== AST_NODE_TYPES15.ObjectPattern && param.type !== AST_NODE_TYPES15.RestElement
       );
       if (hasNonDestructuredParams) {
         context.report({
@@ -1289,8 +1491,8 @@ var preferDestructuringParams = createRule16({
 var prefer_destructuring_params_default = preferDestructuringParams;
 
 // src/rules/prefer-function-declaration.ts
-import { ESLintUtils as ESLintUtils17, AST_NODE_TYPES as AST_NODE_TYPES14 } from "@typescript-eslint/utils";
-var createRule17 = ESLintUtils17.RuleCreator(
+import { ESLintUtils as ESLintUtils19, AST_NODE_TYPES as AST_NODE_TYPES16 } from "@typescript-eslint/utils";
+var createRule19 = ESLintUtils19.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var isTsFile = (filename) => filename.endsWith(".ts") && !filename.endsWith(".d.ts");
@@ -1299,33 +1501,33 @@ var isCallbackContext = (node) => {
   if (!parent) {
     return false;
   }
-  if (parent.type === AST_NODE_TYPES14.CallExpression && parent.arguments.includes(node)) {
+  if (parent.type === AST_NODE_TYPES16.CallExpression && parent.arguments.includes(node)) {
     return true;
   }
-  if (parent.type === AST_NODE_TYPES14.NewExpression && parent.arguments.includes(node)) {
+  if (parent.type === AST_NODE_TYPES16.NewExpression && parent.arguments.includes(node)) {
     return true;
   }
-  if (parent.type === AST_NODE_TYPES14.ReturnStatement) {
+  if (parent.type === AST_NODE_TYPES16.ReturnStatement) {
     return true;
   }
-  if (parent.type === AST_NODE_TYPES14.Property) {
+  if (parent.type === AST_NODE_TYPES16.Property) {
     return true;
   }
-  if (parent.type === AST_NODE_TYPES14.ArrayExpression) {
+  if (parent.type === AST_NODE_TYPES16.ArrayExpression) {
     return true;
   }
-  if (parent.type === AST_NODE_TYPES14.ConditionalExpression) {
+  if (parent.type === AST_NODE_TYPES16.ConditionalExpression) {
     return true;
   }
-  if (parent.type === AST_NODE_TYPES14.LogicalExpression) {
+  if (parent.type === AST_NODE_TYPES16.LogicalExpression) {
     return true;
   }
-  if (parent.type === AST_NODE_TYPES14.AssignmentExpression && parent.left !== node) {
+  if (parent.type === AST_NODE_TYPES16.AssignmentExpression && parent.left !== node) {
     return true;
   }
   return false;
 };
-var preferFunctionDeclaration = createRule17({
+var preferFunctionDeclaration = createRule19({
   name: "prefer-function-declaration",
   meta: {
     type: "suggestion",
@@ -1346,14 +1548,14 @@ var preferFunctionDeclaration = createRule17({
     }
     return {
       VariableDeclarator(node) {
-        if (node.id.type !== AST_NODE_TYPES14.Identifier) {
+        if (node.id.type !== AST_NODE_TYPES16.Identifier) {
           return;
         }
         const { init } = node;
         if (!init) {
           return;
         }
-        if (init.type === AST_NODE_TYPES14.ArrowFunctionExpression) {
+        if (init.type === AST_NODE_TYPES16.ArrowFunctionExpression) {
           if (isCallbackContext(init)) {
             return;
           }
@@ -1363,7 +1565,7 @@ var preferFunctionDeclaration = createRule17({
             data: { name: node.id.name }
           });
         }
-        if (init.type === AST_NODE_TYPES14.FunctionExpression) {
+        if (init.type === AST_NODE_TYPES16.FunctionExpression) {
           if (isCallbackContext(init)) {
             return;
           }
@@ -1380,11 +1582,11 @@ var preferFunctionDeclaration = createRule17({
 var prefer_function_declaration_default = preferFunctionDeclaration;
 
 // src/rules/prefer-import-type.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES15, ESLintUtils as ESLintUtils18 } from "@typescript-eslint/utils";
-var createRule18 = ESLintUtils18.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES17, ESLintUtils as ESLintUtils20 } from "@typescript-eslint/utils";
+var createRule20 = ESLintUtils20.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var preferImportType = createRule18({
+var preferImportType = createRule20({
   name: "prefer-import-type",
   meta: {
     type: "suggestion",
@@ -1403,22 +1605,22 @@ var preferImportType = createRule18({
       let current = node;
       while (current) {
         switch (current.type) {
-          case AST_NODE_TYPES15.TSTypeReference:
-          case AST_NODE_TYPES15.TSTypeAnnotation:
-          case AST_NODE_TYPES15.TSTypeParameterInstantiation:
-          case AST_NODE_TYPES15.TSInterfaceHeritage:
-          case AST_NODE_TYPES15.TSClassImplements:
-          case AST_NODE_TYPES15.TSTypeQuery:
-          case AST_NODE_TYPES15.TSTypeAssertion:
-          case AST_NODE_TYPES15.TSAsExpression:
-          case AST_NODE_TYPES15.TSSatisfiesExpression:
-          case AST_NODE_TYPES15.TSTypeAliasDeclaration:
-          case AST_NODE_TYPES15.TSInterfaceDeclaration:
-          case AST_NODE_TYPES15.TSTypeParameter:
-          case AST_NODE_TYPES15.TSQualifiedName:
+          case AST_NODE_TYPES17.TSTypeReference:
+          case AST_NODE_TYPES17.TSTypeAnnotation:
+          case AST_NODE_TYPES17.TSTypeParameterInstantiation:
+          case AST_NODE_TYPES17.TSInterfaceHeritage:
+          case AST_NODE_TYPES17.TSClassImplements:
+          case AST_NODE_TYPES17.TSTypeQuery:
+          case AST_NODE_TYPES17.TSTypeAssertion:
+          case AST_NODE_TYPES17.TSAsExpression:
+          case AST_NODE_TYPES17.TSSatisfiesExpression:
+          case AST_NODE_TYPES17.TSTypeAliasDeclaration:
+          case AST_NODE_TYPES17.TSInterfaceDeclaration:
+          case AST_NODE_TYPES17.TSTypeParameter:
+          case AST_NODE_TYPES17.TSQualifiedName:
             return true;
-          case AST_NODE_TYPES15.MemberExpression:
-          case AST_NODE_TYPES15.Identifier:
+          case AST_NODE_TYPES17.MemberExpression:
+          case AST_NODE_TYPES17.Identifier:
             current = current.parent;
             break;
           default:
@@ -1448,26 +1650,26 @@ var preferImportType = createRule18({
           return false;
         }
         switch (parent.type) {
-          case AST_NODE_TYPES15.CallExpression:
-          case AST_NODE_TYPES15.NewExpression:
-          case AST_NODE_TYPES15.JSXOpeningElement:
-          case AST_NODE_TYPES15.JSXClosingElement:
-          case AST_NODE_TYPES15.MemberExpression:
-          case AST_NODE_TYPES15.VariableDeclarator:
-          case AST_NODE_TYPES15.TaggedTemplateExpression:
-          case AST_NODE_TYPES15.SpreadElement:
-          case AST_NODE_TYPES15.ExportSpecifier:
-          case AST_NODE_TYPES15.ArrayExpression:
-          case AST_NODE_TYPES15.ObjectExpression:
-          case AST_NODE_TYPES15.BinaryExpression:
-          case AST_NODE_TYPES15.LogicalExpression:
-          case AST_NODE_TYPES15.UnaryExpression:
-          case AST_NODE_TYPES15.ReturnStatement:
-          case AST_NODE_TYPES15.ArrowFunctionExpression:
-          case AST_NODE_TYPES15.ConditionalExpression:
-          case AST_NODE_TYPES15.AwaitExpression:
-          case AST_NODE_TYPES15.YieldExpression:
-          case AST_NODE_TYPES15.Property:
+          case AST_NODE_TYPES17.CallExpression:
+          case AST_NODE_TYPES17.NewExpression:
+          case AST_NODE_TYPES17.JSXOpeningElement:
+          case AST_NODE_TYPES17.JSXClosingElement:
+          case AST_NODE_TYPES17.MemberExpression:
+          case AST_NODE_TYPES17.VariableDeclarator:
+          case AST_NODE_TYPES17.TaggedTemplateExpression:
+          case AST_NODE_TYPES17.SpreadElement:
+          case AST_NODE_TYPES17.ExportSpecifier:
+          case AST_NODE_TYPES17.ArrayExpression:
+          case AST_NODE_TYPES17.ObjectExpression:
+          case AST_NODE_TYPES17.BinaryExpression:
+          case AST_NODE_TYPES17.LogicalExpression:
+          case AST_NODE_TYPES17.UnaryExpression:
+          case AST_NODE_TYPES17.ReturnStatement:
+          case AST_NODE_TYPES17.ArrowFunctionExpression:
+          case AST_NODE_TYPES17.ConditionalExpression:
+          case AST_NODE_TYPES17.AwaitExpression:
+          case AST_NODE_TYPES17.YieldExpression:
+          case AST_NODE_TYPES17.Property:
             return true;
           default:
             return false;
@@ -1491,13 +1693,13 @@ var preferImportType = createRule18({
       }
       const scope = context.sourceCode.getScope(node);
       const isTypeOnlyImport = node.specifiers.every((specifier) => {
-        if (specifier.type === AST_NODE_TYPES15.ImportDefaultSpecifier) {
+        if (specifier.type === AST_NODE_TYPES17.ImportDefaultSpecifier) {
           return false;
         }
-        if (specifier.type === AST_NODE_TYPES15.ImportNamespaceSpecifier) {
+        if (specifier.type === AST_NODE_TYPES17.ImportNamespaceSpecifier) {
           return false;
         }
-        if (specifier.type === AST_NODE_TYPES15.ImportSpecifier) {
+        if (specifier.type === AST_NODE_TYPES17.ImportSpecifier) {
           const localName = specifier.local.name;
           return !isUsedAsValue(localName, scope);
         }
@@ -1523,11 +1725,11 @@ var preferImportType = createRule18({
 var prefer_import_type_default = preferImportType;
 
 // src/rules/prefer-interface-over-inline-types.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES16, ESLintUtils as ESLintUtils19 } from "@typescript-eslint/utils";
-var createRule19 = ESLintUtils19.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES18, ESLintUtils as ESLintUtils21 } from "@typescript-eslint/utils";
+var createRule21 = ESLintUtils21.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var preferInterfaceOverInlineTypes = createRule19({
+var preferInterfaceOverInlineTypes = createRule21({
   name: "prefer-interface-over-inline-types",
   meta: {
     type: "suggestion",
@@ -1543,54 +1745,54 @@ var preferInterfaceOverInlineTypes = createRule19({
   defaultOptions: [],
   create(context) {
     function hasJSXInConditional(node) {
-      return node.consequent.type === AST_NODE_TYPES16.JSXElement || node.consequent.type === AST_NODE_TYPES16.JSXFragment || node.alternate.type === AST_NODE_TYPES16.JSXElement || node.alternate.type === AST_NODE_TYPES16.JSXFragment;
+      return node.consequent.type === AST_NODE_TYPES18.JSXElement || node.consequent.type === AST_NODE_TYPES18.JSXFragment || node.alternate.type === AST_NODE_TYPES18.JSXElement || node.alternate.type === AST_NODE_TYPES18.JSXFragment;
     }
     function hasJSXInLogical(node) {
-      return node.right.type === AST_NODE_TYPES16.JSXElement || node.right.type === AST_NODE_TYPES16.JSXFragment;
+      return node.right.type === AST_NODE_TYPES18.JSXElement || node.right.type === AST_NODE_TYPES18.JSXFragment;
     }
     function hasJSXReturn(block) {
       return block.body.some((stmt) => {
-        if (stmt.type === AST_NODE_TYPES16.ReturnStatement && stmt.argument) {
-          return stmt.argument.type === AST_NODE_TYPES16.JSXElement || stmt.argument.type === AST_NODE_TYPES16.JSXFragment || stmt.argument.type === AST_NODE_TYPES16.ConditionalExpression && hasJSXInConditional(stmt.argument) || stmt.argument.type === AST_NODE_TYPES16.LogicalExpression && hasJSXInLogical(stmt.argument);
+        if (stmt.type === AST_NODE_TYPES18.ReturnStatement && stmt.argument) {
+          return stmt.argument.type === AST_NODE_TYPES18.JSXElement || stmt.argument.type === AST_NODE_TYPES18.JSXFragment || stmt.argument.type === AST_NODE_TYPES18.ConditionalExpression && hasJSXInConditional(stmt.argument) || stmt.argument.type === AST_NODE_TYPES18.LogicalExpression && hasJSXInLogical(stmt.argument);
         }
         return false;
       });
     }
     function isReactComponent2(node) {
-      if (node.type === AST_NODE_TYPES16.ArrowFunctionExpression) {
-        if (node.body.type === AST_NODE_TYPES16.JSXElement || node.body.type === AST_NODE_TYPES16.JSXFragment) {
+      if (node.type === AST_NODE_TYPES18.ArrowFunctionExpression) {
+        if (node.body.type === AST_NODE_TYPES18.JSXElement || node.body.type === AST_NODE_TYPES18.JSXFragment) {
           return true;
         }
-        if (node.body.type === AST_NODE_TYPES16.BlockStatement) {
+        if (node.body.type === AST_NODE_TYPES18.BlockStatement) {
           return hasJSXReturn(node.body);
         }
-      } else if (node.type === AST_NODE_TYPES16.FunctionExpression || node.type === AST_NODE_TYPES16.FunctionDeclaration) {
-        if (node.body && node.body.type === AST_NODE_TYPES16.BlockStatement) {
+      } else if (node.type === AST_NODE_TYPES18.FunctionExpression || node.type === AST_NODE_TYPES18.FunctionDeclaration) {
+        if (node.body && node.body.type === AST_NODE_TYPES18.BlockStatement) {
           return hasJSXReturn(node.body);
         }
       }
       return false;
     }
     function isInlineTypeAnnotation(node) {
-      if (node.type === AST_NODE_TYPES16.TSTypeLiteral) {
+      if (node.type === AST_NODE_TYPES18.TSTypeLiteral) {
         return true;
       }
-      if (node.type === AST_NODE_TYPES16.TSTypeReference && node.typeArguments) {
-        return node.typeArguments.params.some((param) => param.type === AST_NODE_TYPES16.TSTypeLiteral);
+      if (node.type === AST_NODE_TYPES18.TSTypeReference && node.typeArguments) {
+        return node.typeArguments.params.some((param) => param.type === AST_NODE_TYPES18.TSTypeLiteral);
       }
-      if (node.type === AST_NODE_TYPES16.TSUnionType) {
+      if (node.type === AST_NODE_TYPES18.TSUnionType) {
         return node.types.some((type) => isInlineTypeAnnotation(type));
       }
       return false;
     }
     function hasInlineObjectType(node) {
-      if (node.type === AST_NODE_TYPES16.TSTypeLiteral) {
+      if (node.type === AST_NODE_TYPES18.TSTypeLiteral) {
         return true;
       }
-      if (node.type === AST_NODE_TYPES16.TSTypeReference && node.typeArguments) {
-        return node.typeArguments.params.some((param) => param.type === AST_NODE_TYPES16.TSTypeLiteral);
+      if (node.type === AST_NODE_TYPES18.TSTypeReference && node.typeArguments) {
+        return node.typeArguments.params.some((param) => param.type === AST_NODE_TYPES18.TSTypeLiteral);
       }
-      if (node.type === AST_NODE_TYPES16.TSUnionType) {
+      if (node.type === AST_NODE_TYPES18.TSUnionType) {
         return node.types.some((type) => hasInlineObjectType(type));
       }
       return false;
@@ -1603,7 +1805,7 @@ var preferInterfaceOverInlineTypes = createRule19({
         return;
       }
       const param = node.params[0];
-      if (param.type === AST_NODE_TYPES16.Identifier && param.typeAnnotation) {
+      if (param.type === AST_NODE_TYPES18.Identifier && param.typeAnnotation) {
         const { typeAnnotation } = param.typeAnnotation;
         if (isInlineTypeAnnotation(typeAnnotation) && hasInlineObjectType(typeAnnotation)) {
           context.report({
@@ -1623,11 +1825,11 @@ var preferInterfaceOverInlineTypes = createRule19({
 var prefer_interface_over_inline_types_default = preferInterfaceOverInlineTypes;
 
 // src/rules/prefer-jsx-template-literals.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES17, ESLintUtils as ESLintUtils20 } from "@typescript-eslint/utils";
-var createRule20 = ESLintUtils20.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES19, ESLintUtils as ESLintUtils22 } from "@typescript-eslint/utils";
+var createRule22 = ESLintUtils22.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var preferJSXTemplateLiterals = createRule20({
+var preferJSXTemplateLiterals = createRule22({
   name: "prefer-jsx-template-literals",
   meta: {
     type: "suggestion",
@@ -1696,9 +1898,9 @@ var preferJSXTemplateLiterals = createRule20({
         if (!child || !nextChild) {
           return;
         }
-        if (child.type === AST_NODE_TYPES17.JSXText && nextChild.type === AST_NODE_TYPES17.JSXExpressionContainer) {
+        if (child.type === AST_NODE_TYPES19.JSXText && nextChild.type === AST_NODE_TYPES19.JSXExpressionContainer) {
           handleTextBeforeExpression(child, nextChild);
-        } else if (child.type === AST_NODE_TYPES17.JSXExpressionContainer && nextChild.type === AST_NODE_TYPES17.JSXText) {
+        } else if (child.type === AST_NODE_TYPES19.JSXExpressionContainer && nextChild.type === AST_NODE_TYPES19.JSXText) {
           handleExpressionBeforeText(child, nextChild);
         }
       }
@@ -1711,11 +1913,11 @@ var preferJSXTemplateLiterals = createRule20({
 var prefer_jsx_template_literals_default = preferJSXTemplateLiterals;
 
 // src/rules/prefer-named-param-types.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES18, ESLintUtils as ESLintUtils21 } from "@typescript-eslint/utils";
-var createRule21 = ESLintUtils21.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES20, ESLintUtils as ESLintUtils23 } from "@typescript-eslint/utils";
+var createRule23 = ESLintUtils23.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var preferNamedParamTypes = createRule21({
+var preferNamedParamTypes = createRule23({
   name: "prefer-named-param-types",
   meta: {
     type: "suggestion",
@@ -1730,16 +1932,16 @@ var preferNamedParamTypes = createRule21({
   defaultOptions: [],
   create(context) {
     function hasInlineObjectType(param) {
-      if (param.type === AST_NODE_TYPES18.AssignmentPattern) {
+      if (param.type === AST_NODE_TYPES20.AssignmentPattern) {
         return hasInlineObjectType(param.left);
       }
-      if (param.type === AST_NODE_TYPES18.ObjectPattern) {
-        if (param.typeAnnotation?.typeAnnotation.type === AST_NODE_TYPES18.TSTypeLiteral) {
+      if (param.type === AST_NODE_TYPES20.ObjectPattern) {
+        if (param.typeAnnotation?.typeAnnotation.type === AST_NODE_TYPES20.TSTypeLiteral) {
           return true;
         }
       }
-      if (param.type === AST_NODE_TYPES18.Identifier) {
-        if (param.typeAnnotation?.typeAnnotation.type === AST_NODE_TYPES18.TSTypeLiteral) {
+      if (param.type === AST_NODE_TYPES20.Identifier) {
+        if (param.typeAnnotation?.typeAnnotation.type === AST_NODE_TYPES20.TSTypeLiteral) {
           return true;
         }
       }
@@ -1773,11 +1975,11 @@ var preferNamedParamTypes = createRule21({
 var prefer_named_param_types_default = preferNamedParamTypes;
 
 // src/rules/prefer-react-import-types.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES19, ESLintUtils as ESLintUtils22 } from "@typescript-eslint/utils";
-var createRule22 = ESLintUtils22.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES21, ESLintUtils as ESLintUtils24 } from "@typescript-eslint/utils";
+var createRule24 = ESLintUtils24.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var preferReactImportTypes = createRule22({
+var preferReactImportTypes = createRule24({
   name: "prefer-react-import-types",
   meta: {
     type: "suggestion",
@@ -1853,7 +2055,7 @@ var preferReactImportTypes = createRule22({
     ]);
     const allReactExports = /* @__PURE__ */ new Set([...reactTypes, ...reactRuntimeExports]);
     function checkMemberExpression(node) {
-      if (node.object.type === AST_NODE_TYPES19.Identifier && node.object.name === "React" && node.property.type === AST_NODE_TYPES19.Identifier && allReactExports.has(node.property.name)) {
+      if (node.object.type === AST_NODE_TYPES21.Identifier && node.object.name === "React" && node.property.type === AST_NODE_TYPES21.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"`;
@@ -1870,7 +2072,7 @@ var preferReactImportTypes = createRule22({
     return {
       MemberExpression: checkMemberExpression,
       "TSTypeReference > TSQualifiedName": (node) => {
-        if (node.left.type === AST_NODE_TYPES19.Identifier && node.left.name === "React" && node.right.type === AST_NODE_TYPES19.Identifier && allReactExports.has(node.right.name)) {
+        if (node.left.type === AST_NODE_TYPES21.Identifier && node.left.name === "React" && node.right.type === AST_NODE_TYPES21.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"`;
@@ -1890,11 +2092,11 @@ var preferReactImportTypes = createRule22({
 var prefer_react_import_types_default = preferReactImportTypes;
 
 // src/rules/react-props-destructure.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES20, ESLintUtils as ESLintUtils23 } from "@typescript-eslint/utils";
-var createRule23 = ESLintUtils23.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES22, ESLintUtils as ESLintUtils25 } from "@typescript-eslint/utils";
+var createRule25 = ESLintUtils25.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var reactPropsDestructure = createRule23({
+var reactPropsDestructure = createRule25({
   name: "react-props-destructure",
   meta: {
     type: "suggestion",
@@ -1910,29 +2112,29 @@ var reactPropsDestructure = createRule23({
   defaultOptions: [],
   create(context) {
     function hasJSXInConditional(node) {
-      return node.consequent.type === AST_NODE_TYPES20.JSXElement || node.consequent.type === AST_NODE_TYPES20.JSXFragment || node.alternate.type === AST_NODE_TYPES20.JSXElement || node.alternate.type === AST_NODE_TYPES20.JSXFragment;
+      return node.consequent.type === AST_NODE_TYPES22.JSXElement || node.consequent.type === AST_NODE_TYPES22.JSXFragment || node.alternate.type === AST_NODE_TYPES22.JSXElement || node.alternate.type === AST_NODE_TYPES22.JSXFragment;
     }
     function hasJSXInLogical(node) {
-      return node.right.type === AST_NODE_TYPES20.JSXElement || node.right.type === AST_NODE_TYPES20.JSXFragment;
+      return node.right.type === AST_NODE_TYPES22.JSXElement || node.right.type === AST_NODE_TYPES22.JSXFragment;
     }
     function hasJSXReturn(block) {
       return block.body.some((stmt) => {
-        if (stmt.type === AST_NODE_TYPES20.ReturnStatement && stmt.argument) {
-          return stmt.argument.type === AST_NODE_TYPES20.JSXElement || stmt.argument.type === AST_NODE_TYPES20.JSXFragment || stmt.argument.type === AST_NODE_TYPES20.ConditionalExpression && hasJSXInConditional(stmt.argument) || stmt.argument.type === AST_NODE_TYPES20.LogicalExpression && hasJSXInLogical(stmt.argument);
+        if (stmt.type === AST_NODE_TYPES22.ReturnStatement && stmt.argument) {
+          return stmt.argument.type === AST_NODE_TYPES22.JSXElement || stmt.argument.type === AST_NODE_TYPES22.JSXFragment || stmt.argument.type === AST_NODE_TYPES22.ConditionalExpression && hasJSXInConditional(stmt.argument) || stmt.argument.type === AST_NODE_TYPES22.LogicalExpression && hasJSXInLogical(stmt.argument);
         }
         return false;
       });
     }
     function isReactComponent2(node) {
-      if (node.type === AST_NODE_TYPES20.ArrowFunctionExpression) {
-        if (node.body.type === AST_NODE_TYPES20.JSXElement || node.body.type === AST_NODE_TYPES20.JSXFragment) {
+      if (node.type === AST_NODE_TYPES22.ArrowFunctionExpression) {
+        if (node.body.type === AST_NODE_TYPES22.JSXElement || node.body.type === AST_NODE_TYPES22.JSXFragment) {
           return true;
         }
-        if (node.body.type === AST_NODE_TYPES20.BlockStatement) {
+        if (node.body.type === AST_NODE_TYPES22.BlockStatement) {
           return hasJSXReturn(node.body);
         }
-      } else if (node.type === AST_NODE_TYPES20.FunctionExpression || node.type === AST_NODE_TYPES20.FunctionDeclaration) {
-        if (node.body && node.body.type === AST_NODE_TYPES20.BlockStatement) {
+      } else if (node.type === AST_NODE_TYPES22.FunctionExpression || node.type === AST_NODE_TYPES22.FunctionDeclaration) {
+        if (node.body && node.body.type === AST_NODE_TYPES22.BlockStatement) {
           return hasJSXReturn(node.body);
         }
       }
@@ -1946,9 +2148,9 @@ var reactPropsDestructure = createRule23({
         return;
       }
       const param = node.params[0];
-      if (param.type === AST_NODE_TYPES20.ObjectPattern) {
-        const properties = param.properties.filter((prop) => prop.type === AST_NODE_TYPES20.Property).map((prop) => {
-          if (prop.key.type === AST_NODE_TYPES20.Identifier) {
+      if (param.type === AST_NODE_TYPES22.ObjectPattern) {
+        const properties = param.properties.filter((prop) => prop.type === AST_NODE_TYPES22.Property).map((prop) => {
+          if (prop.key.type === AST_NODE_TYPES22.Identifier) {
             return prop.key.name;
           }
           return null;
@@ -1992,7 +2194,9 @@ var rules = {
   "no-direct-date": no_direct_date_default,
   "no-emoji": no_emoji_default,
   "no-env-fallback": no_env_fallback_default,
+  "no-inline-default-export": no_inline_default_export_default,
   "require-explicit-return-type": require_explicit_return_type_default,
+  "no-lazy-identifiers": no_lazy_identifiers_default,
   "no-logic-in-params": no_logic_in_params_default,
   "no-single-char-variables": no_single_char_variables_default,
   "prefer-destructuring-params": prefer_destructuring_params_default,
@@ -2024,6 +2228,8 @@ var baseRules = {
   "nextfriday/no-direct-date": "warn",
   "nextfriday/no-logic-in-params": "warn",
   "nextfriday/no-env-fallback": "warn",
+  "nextfriday/no-inline-default-export": "warn",
+  "nextfriday/no-lazy-identifiers": "warn",
   "nextfriday/no-single-char-variables": "warn"
 };
 var baseRecommendedRules = {
@@ -2042,6 +2248,8 @@ var baseRecommendedRules = {
   "nextfriday/no-direct-date": "error",
   "nextfriday/no-logic-in-params": "error",
   "nextfriday/no-env-fallback": "error",
+  "nextfriday/no-inline-default-export": "error",
+  "nextfriday/no-lazy-identifiers": "error",
   "nextfriday/no-single-char-variables": "error"
 };
 var jsxRules = {