eslint-plugin-nextfriday 1.6.0 → 1.8.0

package/lib/index.js

@@ -1,7 +1,7 @@
 // package.json
 var package_default = {
   name: "eslint-plugin-nextfriday",
-  version: "1.6.0",
+  version: "1.8.0",
   description: "A comprehensive ESLint plugin providing custom rules and configurations for Next Friday development workflows.",
   keywords: [
     "eslint",
@@ -115,12 +115,143 @@ var package_default = {
   }
 };
 
-// src/rules/enforce-readonly-component-props.ts
-import { AST_NODE_TYPES, ESLintUtils } from "@typescript-eslint/utils";
+// src/rules/boolean-naming-prefix.ts
+import { ESLintUtils, AST_NODE_TYPES } from "@typescript-eslint/utils";
 var createRule = ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var enforceReadonlyComponentProps = createRule({
+var BOOLEAN_PREFIXES = ["is", "has", "should", "can", "did", "will", "was", "are", "does", "had"];
+var startsWithBooleanPrefix = (name) => {
+  const lowerName = name.toLowerCase();
+  return BOOLEAN_PREFIXES.some((prefix) => {
+    if (!lowerName.startsWith(prefix)) {
+      return false;
+    }
+    if (name.length === prefix.length) {
+      return true;
+    }
+    const nextChar = name.charAt(prefix.length);
+    return nextChar === nextChar.toUpperCase();
+  });
+};
+var isBooleanLiteral = (node) => node.type === AST_NODE_TYPES.Literal && typeof node.value === "boolean";
+var isBooleanExpression = (node) => {
+  if (isBooleanLiteral(node)) {
+    return true;
+  }
+  if (node.type === AST_NODE_TYPES.UnaryExpression && node.operator === "!") {
+    return true;
+  }
+  if (node.type === AST_NODE_TYPES.BinaryExpression) {
+    const comparisonOperators = ["===", "!==", "==", "!=", "<", ">", "<=", ">=", "in", "instanceof"];
+    return comparisonOperators.includes(node.operator);
+  }
+  if (node.type === AST_NODE_TYPES.LogicalExpression) {
+    return node.operator === "&&" || node.operator === "||";
+  }
+  return false;
+};
+var hasBooleanTypeAnnotation = (node) => {
+  if (node.type === AST_NODE_TYPES.Identifier) {
+    const { typeAnnotation } = node;
+    if (typeAnnotation?.typeAnnotation.type === AST_NODE_TYPES.TSBooleanKeyword) {
+      return true;
+    }
+  }
+  if ("id" in node && node.id.type === AST_NODE_TYPES.Identifier) {
+    const { typeAnnotation } = node.id;
+    if (typeAnnotation?.typeAnnotation.type === AST_NODE_TYPES.TSBooleanKeyword) {
+      return true;
+    }
+  }
+  return false;
+};
+var booleanNamingPrefix = createRule({
+  name: "boolean-naming-prefix",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Enforce boolean variables and parameters to have a prefix like is, has, should, can, did, will for better readability"
+    },
+    messages: {
+      missingPrefix: "Boolean variable '{{name}}' should have a prefix like is, has, should, can, did, or will. Example: 'is{{suggestedName}}' or 'has{{suggestedName}}'."
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    const checkBooleanNaming = (name, node) => {
+      if (startsWithBooleanPrefix(name)) {
+        return;
+      }
+      const suggestedName = name.charAt(0).toUpperCase() + name.slice(1);
+      context.report({
+        node,
+        messageId: "missingPrefix",
+        data: { name, suggestedName }
+      });
+    };
+    return {
+      VariableDeclarator(node) {
+        if (node.id.type !== AST_NODE_TYPES.Identifier) {
+          return;
+        }
+        const { name } = node.id;
+        if (hasBooleanTypeAnnotation(node)) {
+          checkBooleanNaming(name, node.id);
+          return;
+        }
+        if (node.init && isBooleanExpression(node.init)) {
+          checkBooleanNaming(name, node.id);
+        }
+      },
+      FunctionDeclaration(node) {
+        node.params.forEach((param) => {
+          if (param.type === AST_NODE_TYPES.Identifier && hasBooleanTypeAnnotation(param)) {
+            checkBooleanNaming(param.name, param);
+          }
+          if (param.type === AST_NODE_TYPES.AssignmentPattern) {
+            if (param.left.type === AST_NODE_TYPES.Identifier && param.right && isBooleanLiteral(param.right)) {
+              checkBooleanNaming(param.left.name, param.left);
+            }
+          }
+        });
+      },
+      FunctionExpression(node) {
+        node.params.forEach((param) => {
+          if (param.type === AST_NODE_TYPES.Identifier && hasBooleanTypeAnnotation(param)) {
+            checkBooleanNaming(param.name, param);
+          }
+          if (param.type === AST_NODE_TYPES.AssignmentPattern) {
+            if (param.left.type === AST_NODE_TYPES.Identifier && param.right && isBooleanLiteral(param.right)) {
+              checkBooleanNaming(param.left.name, param.left);
+            }
+          }
+        });
+      },
+      ArrowFunctionExpression(node) {
+        node.params.forEach((param) => {
+          if (param.type === AST_NODE_TYPES.Identifier && hasBooleanTypeAnnotation(param)) {
+            checkBooleanNaming(param.name, param);
+          }
+          if (param.type === AST_NODE_TYPES.AssignmentPattern) {
+            if (param.left.type === AST_NODE_TYPES.Identifier && param.right && isBooleanLiteral(param.right)) {
+              checkBooleanNaming(param.left.name, param.left);
+            }
+          }
+        });
+      }
+    };
+  }
+});
+var boolean_naming_prefix_default = booleanNamingPrefix;
+
+// src/rules/enforce-readonly-component-props.ts
+import { AST_NODE_TYPES as AST_NODE_TYPES2, ESLintUtils as ESLintUtils2 } from "@typescript-eslint/utils";
+var createRule2 = ESLintUtils2.RuleCreator(
+  (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
+);
+var enforceReadonlyComponentProps = createRule2({
   name: "enforce-readonly-component-props",
   meta: {
     type: "suggestion",
@@ -136,54 +267,54 @@ var enforceReadonlyComponentProps = createRule({
   defaultOptions: [],
   create(context) {
     function hasJSXInConditional(node) {
-      return node.consequent.type === AST_NODE_TYPES.JSXElement || node.consequent.type === AST_NODE_TYPES.JSXFragment || node.alternate.type === AST_NODE_TYPES.JSXElement || node.alternate.type === AST_NODE_TYPES.JSXFragment;
+      return node.consequent.type === AST_NODE_TYPES2.JSXElement || node.consequent.type === AST_NODE_TYPES2.JSXFragment || node.alternate.type === AST_NODE_TYPES2.JSXElement || node.alternate.type === AST_NODE_TYPES2.JSXFragment;
     }
     function hasJSXInLogical(node) {
-      return node.right.type === AST_NODE_TYPES.JSXElement || node.right.type === AST_NODE_TYPES.JSXFragment;
+      return node.right.type === AST_NODE_TYPES2.JSXElement || node.right.type === AST_NODE_TYPES2.JSXFragment;
     }
     function hasJSXReturn(block) {
       return block.body.some((stmt) => {
-        if (stmt.type === AST_NODE_TYPES.ReturnStatement && stmt.argument) {
-          return stmt.argument.type === AST_NODE_TYPES.JSXElement || stmt.argument.type === AST_NODE_TYPES.JSXFragment || stmt.argument.type === AST_NODE_TYPES.ConditionalExpression && hasJSXInConditional(stmt.argument) || stmt.argument.type === AST_NODE_TYPES.LogicalExpression && hasJSXInLogical(stmt.argument);
+        if (stmt.type === AST_NODE_TYPES2.ReturnStatement && stmt.argument) {
+          return stmt.argument.type === AST_NODE_TYPES2.JSXElement || stmt.argument.type === AST_NODE_TYPES2.JSXFragment || stmt.argument.type === AST_NODE_TYPES2.ConditionalExpression && hasJSXInConditional(stmt.argument) || stmt.argument.type === AST_NODE_TYPES2.LogicalExpression && hasJSXInLogical(stmt.argument);
         }
         return false;
       });
     }
-    function isReactComponent(node) {
-      if (node.type === AST_NODE_TYPES.ArrowFunctionExpression) {
-        if (node.body.type === AST_NODE_TYPES.JSXElement || node.body.type === AST_NODE_TYPES.JSXFragment) {
+    function isReactComponent2(node) {
+      if (node.type === AST_NODE_TYPES2.ArrowFunctionExpression) {
+        if (node.body.type === AST_NODE_TYPES2.JSXElement || node.body.type === AST_NODE_TYPES2.JSXFragment) {
           return true;
         }
-        if (node.body.type === AST_NODE_TYPES.BlockStatement) {
+        if (node.body.type === AST_NODE_TYPES2.BlockStatement) {
           return hasJSXReturn(node.body);
         }
-      } else if (node.type === AST_NODE_TYPES.FunctionExpression || node.type === AST_NODE_TYPES.FunctionDeclaration) {
-        if (node.body && node.body.type === AST_NODE_TYPES.BlockStatement) {
+      } else if (node.type === AST_NODE_TYPES2.FunctionExpression || node.type === AST_NODE_TYPES2.FunctionDeclaration) {
+        if (node.body && node.body.type === AST_NODE_TYPES2.BlockStatement) {
           return hasJSXReturn(node.body);
         }
       }
       return false;
     }
     function isNamedType(node) {
-      return node.type === AST_NODE_TYPES.TSTypeReference;
+      return node.type === AST_NODE_TYPES2.TSTypeReference;
     }
     function isAlreadyReadonly(node) {
-      if (node.type === AST_NODE_TYPES.TSTypeReference && node.typeName) {
-        if (node.typeName.type === AST_NODE_TYPES.Identifier && node.typeName.name === "Readonly") {
+      if (node.type === AST_NODE_TYPES2.TSTypeReference && node.typeName) {
+        if (node.typeName.type === AST_NODE_TYPES2.Identifier && node.typeName.name === "Readonly") {
           return true;
         }
       }
       return false;
     }
     function checkFunction(node) {
-      if (!isReactComponent(node)) {
+      if (!isReactComponent2(node)) {
         return;
       }
       if (node.params.length !== 1) {
         return;
       }
       const param = node.params[0];
-      if (param.type === AST_NODE_TYPES.Identifier && param.typeAnnotation) {
+      if (param.type === AST_NODE_TYPES2.Identifier && param.typeAnnotation) {
         const { typeAnnotation } = param.typeAnnotation;
         if (isNamedType(typeAnnotation) && !isAlreadyReadonly(typeAnnotation)) {
           const { sourceCode } = context;
@@ -208,11 +339,11 @@ var enforceReadonlyComponentProps = createRule({
 var enforce_readonly_component_props_default = enforceReadonlyComponentProps;
 
 // src/rules/enforce-sorted-destructuring.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES2, ESLintUtils as ESLintUtils2 } from "@typescript-eslint/utils";
-var createRule2 = ESLintUtils2.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES3, ESLintUtils as ESLintUtils3 } from "@typescript-eslint/utils";
+var createRule3 = ESLintUtils3.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var enforceSortedDestructuring = createRule2({
+var enforceSortedDestructuring = createRule3({
   name: "enforce-sorted-destructuring",
   meta: {
     type: "suggestion",
@@ -227,16 +358,16 @@ var enforceSortedDestructuring = createRule2({
   defaultOptions: [],
   create(context) {
     function getPropertyName(property) {
-      if (property.type === AST_NODE_TYPES2.RestElement) {
+      if (property.type === AST_NODE_TYPES3.RestElement) {
         return null;
       }
-      if (property.key.type === AST_NODE_TYPES2.Identifier) {
+      if (property.key.type === AST_NODE_TYPES3.Identifier) {
         return property.key.name;
       }
       return null;
     }
     function hasDefaultValue(property) {
-      return property.value.type === AST_NODE_TYPES2.AssignmentPattern && Boolean(property.value.right);
+      return property.value.type === AST_NODE_TYPES3.AssignmentPattern && Boolean(property.value.right);
     }
     function getDefaultValueType(property) {
       if (!hasDefaultValue(property)) {
@@ -248,7 +379,7 @@ var enforceSortedDestructuring = createRule2({
         return "none";
       }
       switch (right.type) {
-        case AST_NODE_TYPES2.Literal:
+        case AST_NODE_TYPES3.Literal:
           if (typeof right.value === "string") {
             return "string";
           }
@@ -259,10 +390,10 @@ var enforceSortedDestructuring = createRule2({
             return "boolean";
           }
           return "other";
-        case AST_NODE_TYPES2.TemplateLiteral:
+        case AST_NODE_TYPES3.TemplateLiteral:
           return "string";
-        case AST_NODE_TYPES2.ObjectExpression:
-        case AST_NODE_TYPES2.ArrayExpression:
+        case AST_NODE_TYPES3.ObjectExpression:
+        case AST_NODE_TYPES3.ArrayExpression:
           return "object";
         default:
           return "other";
@@ -280,7 +411,7 @@ var enforceSortedDestructuring = createRule2({
       return order[type] ?? 5;
     }
     function checkVariableDeclarator(node) {
-      if (node.id.type !== AST_NODE_TYPES2.ObjectPattern) {
+      if (node.id.type !== AST_NODE_TYPES3.ObjectPattern) {
         return;
       }
       const { properties } = node.id;
@@ -288,7 +419,7 @@ var enforceSortedDestructuring = createRule2({
         return;
       }
       const propertyInfo = properties.map((prop) => {
-        if (prop.type === AST_NODE_TYPES2.RestElement) {
+        if (prop.type === AST_NODE_TYPES3.RestElement) {
           return null;
         }
         return {
@@ -330,8 +461,8 @@ var enforce_sorted_destructuring_default = enforceSortedDestructuring;
 
 // src/rules/file-kebab-case.ts
 import path from "path";
-import { ESLintUtils as ESLintUtils3 } from "@typescript-eslint/utils";
-var createRule3 = ESLintUtils3.RuleCreator(
+import { ESLintUtils as ESLintUtils4 } from "@typescript-eslint/utils";
+var createRule4 = ESLintUtils4.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var isKebabCase = (str) => {
@@ -340,7 +471,7 @@ var isKebabCase = (str) => {
   }
   return /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(str);
 };
-var fileKebabCase = createRule3({
+var fileKebabCase = createRule4({
   name: "file-kebab-case",
   meta: {
     type: "problem",
@@ -376,12 +507,12 @@ var file_kebab_case_default = fileKebabCase;
 
 // src/rules/jsx-pascal-case.ts
 import path2 from "path";
-import { ESLintUtils as ESLintUtils4 } from "@typescript-eslint/utils";
-var createRule4 = ESLintUtils4.RuleCreator(
+import { ESLintUtils as ESLintUtils5 } from "@typescript-eslint/utils";
+var createRule5 = ESLintUtils5.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var isPascalCase = (str) => /^[A-Z][a-zA-Z0-9]*$/.test(str) && !/^[A-Z]+$/.test(str);
-var jsxPascalCase = createRule4({
+var jsxPascalCase = createRule5({
   name: "jsx-pascal-case",
   meta: {
     type: "problem",
@@ -415,12 +546,64 @@ var jsxPascalCase = createRule4({
 });
 var jsx_pascal_case_default = jsxPascalCase;
 
+// src/rules/no-direct-date.ts
+import { ESLintUtils as ESLintUtils6, AST_NODE_TYPES as AST_NODE_TYPES4 } from "@typescript-eslint/utils";
+var createRule6 = ESLintUtils6.RuleCreator(
+  (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
+);
+var noDirectDate = createRule6({
+  name: "no-direct-date",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow direct usage of Date constructor and methods to enforce centralized date utilities"
+    },
+    messages: {
+      noNewDate: "Avoid using 'new Date()'. Use a centralized date utility like dayjs instead.",
+      noDateNow: "Avoid using 'Date.now()'. Use a centralized date utility like dayjs instead.",
+      noDateParse: "Avoid using 'Date.parse()'. Use a centralized date utility like dayjs instead."
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      NewExpression(node) {
+        if (node.callee.type === AST_NODE_TYPES4.Identifier && node.callee.name === "Date") {
+          context.report({
+            node,
+            messageId: "noNewDate"
+          });
+        }
+      },
+      CallExpression(node) {
+        if (node.callee.type === AST_NODE_TYPES4.MemberExpression && node.callee.object.type === AST_NODE_TYPES4.Identifier && node.callee.object.name === "Date" && node.callee.property.type === AST_NODE_TYPES4.Identifier) {
+          const methodName = node.callee.property.name;
+          if (methodName === "now") {
+            context.report({
+              node,
+              messageId: "noDateNow"
+            });
+          }
+          if (methodName === "parse") {
+            context.report({
+              node,
+              messageId: "noDateParse"
+            });
+          }
+        }
+      }
+    };
+  }
+});
+var no_direct_date_default = noDirectDate;
+
 // src/rules/jsx-no-variable-in-callback.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES3, ESLintUtils as ESLintUtils5 } from "@typescript-eslint/utils";
-var createRule5 = ESLintUtils5.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES5, ESLintUtils as ESLintUtils7 } from "@typescript-eslint/utils";
+var createRule7 = ESLintUtils7.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var jsxNoVariableInCallback = createRule5({
+var jsxNoVariableInCallback = createRule7({
   name: "jsx-no-variable-in-callback",
   meta: {
     type: "suggestion",
@@ -437,7 +620,7 @@ var jsxNoVariableInCallback = createRule5({
     function isInsideJSX(node) {
       let current = node.parent;
       while (current) {
-        if (current.type === AST_NODE_TYPES3.JSXElement || current.type === AST_NODE_TYPES3.JSXFragment) {
+        if (current.type === AST_NODE_TYPES5.JSXElement || current.type === AST_NODE_TYPES5.JSXFragment) {
           return true;
         }
         current = current.parent;
@@ -451,11 +634,11 @@ var jsxNoVariableInCallback = createRule5({
       if (!isInsideJSX(node)) {
         return false;
       }
-      if (node.parent.type === AST_NODE_TYPES3.CallExpression || node.parent.type === AST_NODE_TYPES3.JSXExpressionContainer) {
+      if (node.parent.type === AST_NODE_TYPES5.CallExpression || node.parent.type === AST_NODE_TYPES5.JSXExpressionContainer) {
         return true;
       }
-      if (node.parent.type === AST_NODE_TYPES3.ArrayExpression && node.parent.parent) {
-        if (node.parent.parent.type === AST_NODE_TYPES3.CallExpression || node.parent.parent.type === AST_NODE_TYPES3.JSXExpressionContainer) {
+      if (node.parent.type === AST_NODE_TYPES5.ArrayExpression && node.parent.parent) {
+        if (node.parent.parent.type === AST_NODE_TYPES5.CallExpression || node.parent.parent.type === AST_NODE_TYPES5.JSXExpressionContainer) {
           return true;
         }
       }
@@ -466,11 +649,11 @@ var jsxNoVariableInCallback = createRule5({
         return;
       }
       const { body } = node;
-      if (body.type !== AST_NODE_TYPES3.BlockStatement) {
+      if (body.type !== AST_NODE_TYPES5.BlockStatement) {
         return;
       }
       body.body.forEach((statement) => {
-        if (statement.type === AST_NODE_TYPES3.VariableDeclaration) {
+        if (statement.type === AST_NODE_TYPES5.VariableDeclaration) {
           context.report({
             node: statement,
             messageId: "noVariableInCallback"
@@ -488,11 +671,11 @@ var jsx_no_variable_in_callback_default = jsxNoVariableInCallback;
 
 // src/rules/md-filename-case-restriction.ts
 import path3 from "path";
-import { ESLintUtils as ESLintUtils6 } from "@typescript-eslint/utils";
-var createRule6 = ESLintUtils6.RuleCreator(
+import { ESLintUtils as ESLintUtils8 } from "@typescript-eslint/utils";
+var createRule8 = ESLintUtils8.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var mdFilenameCaseRestriction = createRule6({
+var mdFilenameCaseRestriction = createRule8({
   name: "md-filename-case-restriction",
   meta: {
     type: "problem",
@@ -533,11 +716,11 @@ var mdFilenameCaseRestriction = createRule6({
 var md_filename_case_restriction_default = mdFilenameCaseRestriction;
 
 // src/rules/no-complex-inline-return.ts
-import { ESLintUtils as ESLintUtils7, AST_NODE_TYPES as AST_NODE_TYPES4 } from "@typescript-eslint/utils";
-var createRule7 = ESLintUtils7.RuleCreator(
+import { ESLintUtils as ESLintUtils9, AST_NODE_TYPES as AST_NODE_TYPES6 } from "@typescript-eslint/utils";
+var createRule9 = ESLintUtils9.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var noComplexInlineReturn = createRule7({
+var noComplexInlineReturn = createRule9({
   name: "no-complex-inline-return",
   meta: {
     type: "suggestion",
@@ -553,13 +736,13 @@ var noComplexInlineReturn = createRule7({
   create(context) {
     const isComplexExpression = (node) => {
       if (!node) return false;
-      if (node.type === AST_NODE_TYPES4.ConditionalExpression) {
+      if (node.type === AST_NODE_TYPES6.ConditionalExpression) {
         return true;
       }
-      if (node.type === AST_NODE_TYPES4.LogicalExpression) {
+      if (node.type === AST_NODE_TYPES6.LogicalExpression) {
         return true;
       }
-      if (node.type === AST_NODE_TYPES4.NewExpression) {
+      if (node.type === AST_NODE_TYPES6.NewExpression) {
         return true;
       }
       return false;
@@ -580,11 +763,11 @@ var no_complex_inline_return_default = noComplexInlineReturn;
 
 // src/rules/no-emoji.ts
 import emojiRegex from "emoji-regex";
-import { ESLintUtils as ESLintUtils8 } from "@typescript-eslint/utils";
-var createRule8 = ESLintUtils8.RuleCreator(
+import { ESLintUtils as ESLintUtils10 } from "@typescript-eslint/utils";
+var createRule10 = ESLintUtils10.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var noEmoji = createRule8({
+var noEmoji = createRule10({
   name: "no-emoji",
   meta: {
     type: "problem",
@@ -618,11 +801,11 @@ var noEmoji = createRule8({
 var no_emoji_default = noEmoji;
 
 // src/rules/no-env-fallback.ts
-import { ESLintUtils as ESLintUtils9, AST_NODE_TYPES as AST_NODE_TYPES5 } from "@typescript-eslint/utils";
-var createRule9 = ESLintUtils9.RuleCreator(
+import { ESLintUtils as ESLintUtils11, AST_NODE_TYPES as AST_NODE_TYPES7 } from "@typescript-eslint/utils";
+var createRule11 = ESLintUtils11.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var noEnvFallback = createRule9({
+var noEnvFallback = createRule11({
   name: "no-env-fallback",
   meta: {
     type: "problem",
@@ -637,16 +820,16 @@ var noEnvFallback = createRule9({
   defaultOptions: [],
   create(context) {
     const isProcessEnvAccess = (node) => {
-      if (node.type !== AST_NODE_TYPES5.MemberExpression) {
+      if (node.type !== AST_NODE_TYPES7.MemberExpression) {
         return false;
       }
       const { object } = node;
-      if (object.type !== AST_NODE_TYPES5.MemberExpression) {
+      if (object.type !== AST_NODE_TYPES7.MemberExpression) {
         return false;
       }
       const processNode = object.object;
       const envNode = object.property;
-      return processNode.type === AST_NODE_TYPES5.Identifier && processNode.name === "process" && envNode.type === AST_NODE_TYPES5.Identifier && envNode.name === "env";
+      return processNode.type === AST_NODE_TYPES7.Identifier && processNode.name === "process" && envNode.type === AST_NODE_TYPES7.Identifier && envNode.name === "env";
     };
     return {
       LogicalExpression(node) {
@@ -670,38 +853,93 @@ var noEnvFallback = createRule9({
 });
 var no_env_fallback_default = noEnvFallback;
 
-// src/rules/no-explicit-return-type.ts
-import { ESLintUtils as ESLintUtils10 } from "@typescript-eslint/utils";
-var createRule10 = ESLintUtils10.RuleCreator(
+// src/rules/require-explicit-return-type.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 noExplicitReturnType = createRule10({
-  name: "no-explicit-return-type",
+var isReactComponent = (node) => {
+  if (node.type === AST_NODE_TYPES8.ArrowFunctionExpression) {
+    const { parent } = node;
+    if (parent?.type === AST_NODE_TYPES8.VariableDeclarator) {
+      const { id } = parent;
+      if (id.type === AST_NODE_TYPES8.Identifier) {
+        return /^[A-Z]/.test(id.name);
+      }
+    }
+  }
+  if (node.type === AST_NODE_TYPES8.FunctionDeclaration && node.id) {
+    return /^[A-Z]/.test(node.id.name);
+  }
+  return false;
+};
+var isCallbackFunction = (node) => {
+  if (node.type === AST_NODE_TYPES8.FunctionDeclaration) {
+    return false;
+  }
+  const { parent } = node;
+  if (!parent) {
+    return false;
+  }
+  if (parent.type === AST_NODE_TYPES8.CallExpression && parent.arguments.includes(node)) {
+    return true;
+  }
+  if (parent.type === AST_NODE_TYPES8.Property) {
+    return true;
+  }
+  if (parent.type === AST_NODE_TYPES8.ArrayExpression) {
+    return true;
+  }
+  return false;
+};
+var getFunctionName = (node) => {
+  if (node.type === AST_NODE_TYPES8.FunctionDeclaration && node.id) {
+    return node.id.name;
+  }
+  if (node.type === AST_NODE_TYPES8.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) {
+    return node.parent.id.name;
+  }
+  return null;
+};
+var requireExplicitReturnType = createRule12({
+  name: "require-explicit-return-type",
   meta: {
     type: "suggestion",
     docs: {
-      description: "Disallow explicit return types on functions"
+      description: "Require explicit return types on functions for better code documentation and type safety"
     },
-    fixable: "code",
-    schema: [],
     messages: {
-      noExplicitReturnType: "Remove explicit return type '{{returnType}}' - TypeScript can infer it automatically"
-    }
+      missingReturnType: "Function '{{name}}' is missing an explicit return type. Add a return type annotation for better documentation.",
+      missingReturnTypeAnonymous: "Function is missing an explicit return type. Add a return type annotation for better documentation."
+    },
+    schema: []
   },
   defaultOptions: [],
   create(context) {
     const checkFunction = (node) => {
       if (node.returnType) {
-        const returnTypeText = context.sourceCode.getText(node.returnType);
+        return;
+      }
+      if (isCallbackFunction(node)) {
+        return;
+      }
+      if (isReactComponent(node)) {
+        return;
+      }
+      const functionName = getFunctionName(node);
+      if (functionName) {
         context.report({
-          node: node.returnType,
-          messageId: "noExplicitReturnType",
-          data: {
-            returnType: returnTypeText
-          },
-          fix(fixer) {
-            return fixer.remove(node.returnType);
-          }
+          node,
+          messageId: "missingReturnType",
+          data: { name: functionName }
+        });
+      } else {
+        context.report({
+          node,
+          messageId: "missingReturnTypeAnonymous"
         });
       }
     };
@@ -712,21 +950,21 @@ var noExplicitReturnType = createRule10({
     };
   }
 });
-var no_explicit_return_type_default = noExplicitReturnType;
+var require_explicit_return_type_default = requireExplicitReturnType;
 
 // src/rules/jsx-no-non-component-function.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES7, ESLintUtils as ESLintUtils11 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES10, ESLintUtils as ESLintUtils13 } from "@typescript-eslint/utils";
 
 // src/utils.ts
 import { basename, extname } from "path";
-import { AST_NODE_TYPES as AST_NODE_TYPES6 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES9 } from "@typescript-eslint/utils";
 var getFileExtension = (filename) => extname(filename).slice(1);
 
 // src/rules/jsx-no-non-component-function.ts
-var createRule11 = ESLintUtils11.RuleCreator(
+var createRule13 = ESLintUtils13.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var jsxNoNonComponentFunction = createRule11({
+var jsxNoNonComponentFunction = createRule13({
   name: "jsx-no-non-component-function",
   meta: {
     type: "problem",
@@ -745,14 +983,14 @@ var jsxNoNonComponentFunction = createRule11({
     if (extension !== "tsx" && extension !== "jsx") {
       return {};
     }
-    function isReactComponent(node) {
-      const functionName = node.type === AST_NODE_TYPES7.FunctionDeclaration && node.id ? node.id.name : null;
+    function isReactComponent2(node) {
+      const functionName = node.type === AST_NODE_TYPES10.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_TYPES7.TSTypeReference && returnTypeNode.typeName.type === AST_NODE_TYPES7.Identifier) {
+        if (returnTypeNode.type === AST_NODE_TYPES10.TSTypeReference && returnTypeNode.typeName.type === AST_NODE_TYPES10.Identifier) {
           const typeName = returnTypeNode.typeName.name;
           if (typeName === "JSX" || typeName === "ReactElement" || typeName === "ReactNode") {
             return true;
@@ -762,20 +1000,20 @@ var jsxNoNonComponentFunction = createRule11({
       return false;
     }
     function checkTopLevelFunction(node, declaratorNode) {
-      if (isReactComponent(node)) {
+      if (isReactComponent2(node)) {
         return;
       }
       const { parent } = node;
       if (!parent) {
         return;
       }
-      if (parent.type === AST_NODE_TYPES7.ExportDefaultDeclaration || parent.type === AST_NODE_TYPES7.ExportNamedDeclaration) {
+      if (parent.type === AST_NODE_TYPES10.ExportDefaultDeclaration || parent.type === AST_NODE_TYPES10.ExportNamedDeclaration) {
         return;
       }
-      if (declaratorNode?.parent?.parent?.type === AST_NODE_TYPES7.ExportNamedDeclaration) {
+      if (declaratorNode?.parent?.parent?.type === AST_NODE_TYPES10.ExportNamedDeclaration) {
         return;
       }
-      if (declaratorNode?.id.type === AST_NODE_TYPES7.Identifier) {
+      if (declaratorNode?.id.type === AST_NODE_TYPES10.Identifier) {
         const varName = declaratorNode.id.name;
         if (/^[A-Z]/.test(varName)) {
           return;
@@ -800,11 +1038,11 @@ var jsxNoNonComponentFunction = createRule11({
 var jsx_no_non_component_function_default = jsxNoNonComponentFunction;
 
 // src/rules/no-logic-in-params.ts
-import { ESLintUtils as ESLintUtils12, AST_NODE_TYPES as AST_NODE_TYPES8 } from "@typescript-eslint/utils";
-var createRule12 = ESLintUtils12.RuleCreator(
+import { ESLintUtils as ESLintUtils14, AST_NODE_TYPES as AST_NODE_TYPES11 } from "@typescript-eslint/utils";
+var createRule14 = ESLintUtils14.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var noLogicInParams = createRule12({
+var noLogicInParams = createRule14({
   name: "no-logic-in-params",
   meta: {
     type: "suggestion",
@@ -819,20 +1057,20 @@ var noLogicInParams = createRule12({
   defaultOptions: [],
   create(context) {
     const isComplexExpression = (node) => {
-      if (node.type === AST_NODE_TYPES8.SpreadElement) {
+      if (node.type === AST_NODE_TYPES11.SpreadElement) {
         return false;
       }
-      if (node.type === AST_NODE_TYPES8.ConditionalExpression) {
+      if (node.type === AST_NODE_TYPES11.ConditionalExpression) {
         return true;
       }
-      if (node.type === AST_NODE_TYPES8.LogicalExpression) {
+      if (node.type === AST_NODE_TYPES11.LogicalExpression) {
         return true;
       }
-      if (node.type === AST_NODE_TYPES8.BinaryExpression) {
+      if (node.type === AST_NODE_TYPES11.BinaryExpression) {
         const logicalOperators = ["==", "===", "!=", "!==", "<", ">", "<=", ">=", "in", "instanceof"];
         return logicalOperators.includes(node.operator);
       }
-      if (node.type === AST_NODE_TYPES8.UnaryExpression) {
+      if (node.type === AST_NODE_TYPES11.UnaryExpression) {
         return node.operator === "!";
       }
       return false;
@@ -863,12 +1101,263 @@ var noLogicInParams = createRule12({
 });
 var no_logic_in_params_default = noLogicInParams;
 
+// src/rules/no-lazy-identifiers.ts
+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 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 = createRule15({
+  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_TYPES12.Identifier) {
+        checkIdentifier(pattern);
+      } else if (pattern.type === AST_NODE_TYPES12.ObjectPattern) {
+        pattern.properties.forEach((prop) => {
+          if (prop.type === AST_NODE_TYPES12.Property && prop.value.type === AST_NODE_TYPES12.Identifier) {
+            checkIdentifier(prop.value);
+          } else if (prop.type === AST_NODE_TYPES12.RestElement && prop.argument.type === AST_NODE_TYPES12.Identifier) {
+            checkIdentifier(prop.argument);
+          }
+        });
+      } else if (pattern.type === AST_NODE_TYPES12.ArrayPattern) {
+        pattern.elements.forEach((element) => {
+          if (element?.type === AST_NODE_TYPES12.Identifier) {
+            checkIdentifier(element);
+          } else if (element?.type === AST_NODE_TYPES12.RestElement && element.argument.type === AST_NODE_TYPES12.Identifier) {
+            checkIdentifier(element.argument);
+          }
+        });
+      } else if (pattern.type === AST_NODE_TYPES12.AssignmentPattern && pattern.left.type === AST_NODE_TYPES12.Identifier) {
+        checkIdentifier(pattern.left);
+      } else if (pattern.type === AST_NODE_TYPES12.RestElement && pattern.argument.type === AST_NODE_TYPES12.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 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 ALLOWED_IN_FOR_LOOPS = /* @__PURE__ */ new Set(["i", "j", "k", "n"]);
+var ALLOWED_UNDERSCORE = "_";
+var isForLoopInit = (node) => {
+  let current = node;
+  while (current) {
+    const parentNode = current.parent;
+    if (!parentNode) {
+      return false;
+    }
+    if (parentNode.type === AST_NODE_TYPES13.ForStatement) {
+      const { init } = parentNode;
+      if (init && init === current) {
+        return true;
+      }
+    }
+    current = parentNode;
+  }
+  return false;
+};
+var isAllowedInContext = (name, node) => {
+  if (name === ALLOWED_UNDERSCORE) {
+    return true;
+  }
+  if (ALLOWED_IN_FOR_LOOPS.has(name) && isForLoopInit(node)) {
+    return true;
+  }
+  return false;
+};
+var noSingleCharVariables = createRule16({
+  name: "no-single-char-variables",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Disallow single character variable and parameter names for better code readability"
+    },
+    messages: {
+      noSingleChar: "Avoid single character variable name '{{name}}'. Use a descriptive name that clearly indicates the purpose."
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    const checkIdentifier = (node, declarationNode) => {
+      const { name } = node;
+      if (name.length !== 1) {
+        return;
+      }
+      if (isAllowedInContext(name, declarationNode)) {
+        return;
+      }
+      context.report({
+        node,
+        messageId: "noSingleChar",
+        data: { name }
+      });
+    };
+    const checkPattern = (pattern, declarationNode) => {
+      if (pattern.type === AST_NODE_TYPES13.Identifier) {
+        checkIdentifier(pattern, declarationNode);
+      } 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, declarationNode);
+          } else if (prop.type === AST_NODE_TYPES13.RestElement && prop.argument.type === AST_NODE_TYPES13.Identifier) {
+            checkIdentifier(prop.argument, declarationNode);
+          }
+        });
+      } else if (pattern.type === AST_NODE_TYPES13.ArrayPattern) {
+        pattern.elements.forEach((element) => {
+          if (element?.type === AST_NODE_TYPES13.Identifier) {
+            checkIdentifier(element, declarationNode);
+          } else if (element?.type === AST_NODE_TYPES13.RestElement && element.argument.type === AST_NODE_TYPES13.Identifier) {
+            checkIdentifier(element.argument, declarationNode);
+          }
+        });
+      } else if (pattern.type === AST_NODE_TYPES13.AssignmentPattern && pattern.left.type === AST_NODE_TYPES13.Identifier) {
+        checkIdentifier(pattern.left, declarationNode);
+      } else if (pattern.type === AST_NODE_TYPES13.RestElement && pattern.argument.type === AST_NODE_TYPES13.Identifier) {
+        checkIdentifier(pattern.argument, declarationNode);
+      }
+    };
+    return {
+      VariableDeclarator(node) {
+        checkPattern(node.id, node);
+      },
+      FunctionDeclaration(node) {
+        if (node.id) {
+          checkIdentifier(node.id, node);
+        }
+        node.params.forEach((param) => checkPattern(param, node));
+      },
+      FunctionExpression(node) {
+        if (node.id) {
+          checkIdentifier(node.id, node);
+        }
+        node.params.forEach((param) => checkPattern(param, node));
+      },
+      ArrowFunctionExpression(node) {
+        node.params.forEach((param) => checkPattern(param, node));
+      },
+      CatchClause(node) {
+        if (node.param) {
+          checkPattern(node.param, node);
+        }
+      }
+    };
+  }
+});
+var no_single_char_variables_default = noSingleCharVariables;
+
 // src/rules/prefer-destructuring-params.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES9, ESLintUtils as ESLintUtils13 } from "@typescript-eslint/utils";
-var createRule13 = ESLintUtils13.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES14, ESLintUtils as ESLintUtils17 } 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 preferDestructuringParams = createRule13({
+var preferDestructuringParams = createRule17({
   name: "prefer-destructuring-params",
   meta: {
     type: "suggestion",
@@ -882,20 +1371,20 @@ var preferDestructuringParams = createRule13({
   },
   defaultOptions: [],
   create(context) {
-    const isCallbackFunction = (node) => {
+    const isCallbackFunction2 = (node) => {
       const { parent } = node;
-      return parent?.type === AST_NODE_TYPES9.CallExpression;
+      return parent?.type === AST_NODE_TYPES14.CallExpression;
     };
     const isDeveloperFunction = (node) => {
-      if (node.type === AST_NODE_TYPES9.FunctionDeclaration) {
+      if (node.type === AST_NODE_TYPES14.FunctionDeclaration) {
         return true;
       }
-      if (node.type === AST_NODE_TYPES9.FunctionExpression || node.type === AST_NODE_TYPES9.ArrowFunctionExpression) {
-        if (isCallbackFunction(node)) {
+      if (node.type === AST_NODE_TYPES14.FunctionExpression || node.type === AST_NODE_TYPES14.ArrowFunctionExpression) {
+        if (isCallbackFunction2(node)) {
           return false;
         }
         const { parent } = node;
-        return parent?.type === AST_NODE_TYPES9.VariableDeclarator || parent?.type === AST_NODE_TYPES9.AssignmentExpression || parent?.type === AST_NODE_TYPES9.Property || parent?.type === AST_NODE_TYPES9.MethodDefinition;
+        return parent?.type === AST_NODE_TYPES14.VariableDeclarator || parent?.type === AST_NODE_TYPES14.AssignmentExpression || parent?.type === AST_NODE_TYPES14.Property || parent?.type === AST_NODE_TYPES14.MethodDefinition;
       }
       return false;
     };
@@ -907,7 +1396,7 @@ var preferDestructuringParams = createRule13({
       if (!isDeveloperFunction(node)) {
         return;
       }
-      if (node.type === AST_NODE_TYPES9.FunctionDeclaration && node.id) {
+      if (node.type === AST_NODE_TYPES14.FunctionDeclaration && node.id) {
         const functionName = node.id.name;
         if (functionName.startsWith("_") || functionName.includes("$") || /^[A-Z][a-zA-Z]*$/.test(functionName)) {
           return;
@@ -917,7 +1406,7 @@ var preferDestructuringParams = createRule13({
         return;
       }
       const hasNonDestructuredParams = node.params.some(
-        (param) => param.type !== AST_NODE_TYPES9.ObjectPattern && param.type !== AST_NODE_TYPES9.RestElement
+        (param) => param.type !== AST_NODE_TYPES14.ObjectPattern && param.type !== AST_NODE_TYPES14.RestElement
       );
       if (hasNonDestructuredParams) {
         context.report({
@@ -935,12 +1424,103 @@ var preferDestructuringParams = createRule13({
 });
 var prefer_destructuring_params_default = preferDestructuringParams;
 
+// src/rules/prefer-function-declaration.ts
+import { ESLintUtils as ESLintUtils18, AST_NODE_TYPES as AST_NODE_TYPES15 } 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 isTsFile = (filename) => filename.endsWith(".ts") && !filename.endsWith(".d.ts");
+var isCallbackContext = (node) => {
+  const { parent } = node;
+  if (!parent) {
+    return false;
+  }
+  if (parent.type === AST_NODE_TYPES15.CallExpression && parent.arguments.includes(node)) {
+    return true;
+  }
+  if (parent.type === AST_NODE_TYPES15.NewExpression && parent.arguments.includes(node)) {
+    return true;
+  }
+  if (parent.type === AST_NODE_TYPES15.ReturnStatement) {
+    return true;
+  }
+  if (parent.type === AST_NODE_TYPES15.Property) {
+    return true;
+  }
+  if (parent.type === AST_NODE_TYPES15.ArrayExpression) {
+    return true;
+  }
+  if (parent.type === AST_NODE_TYPES15.ConditionalExpression) {
+    return true;
+  }
+  if (parent.type === AST_NODE_TYPES15.LogicalExpression) {
+    return true;
+  }
+  if (parent.type === AST_NODE_TYPES15.AssignmentExpression && parent.left !== node) {
+    return true;
+  }
+  return false;
+};
+var preferFunctionDeclaration = createRule18({
+  name: "prefer-function-declaration",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Enforce function declarations over arrow functions assigned to variables in .ts files for better readability and hoisting"
+    },
+    messages: {
+      preferDeclaration: "Use function declaration instead of arrow function. Replace 'const {{name}} = () => ...' with 'function {{name}}() ...'",
+      preferDeclarationExpr: "Use function declaration instead of function expression. Replace 'const {{name}} = function() ...' with 'function {{name}}() ...'"
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    const { filename } = context;
+    if (!isTsFile(filename)) {
+      return {};
+    }
+    return {
+      VariableDeclarator(node) {
+        if (node.id.type !== AST_NODE_TYPES15.Identifier) {
+          return;
+        }
+        const { init } = node;
+        if (!init) {
+          return;
+        }
+        if (init.type === AST_NODE_TYPES15.ArrowFunctionExpression) {
+          if (isCallbackContext(init)) {
+            return;
+          }
+          context.report({
+            node: init,
+            messageId: "preferDeclaration",
+            data: { name: node.id.name }
+          });
+        }
+        if (init.type === AST_NODE_TYPES15.FunctionExpression) {
+          if (isCallbackContext(init)) {
+            return;
+          }
+          context.report({
+            node: init,
+            messageId: "preferDeclarationExpr",
+            data: { name: node.id.name }
+          });
+        }
+      }
+    };
+  }
+});
+var prefer_function_declaration_default = preferFunctionDeclaration;
+
 // src/rules/prefer-import-type.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES10, ESLintUtils as ESLintUtils14 } from "@typescript-eslint/utils";
-var createRule14 = ESLintUtils14.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES16, ESLintUtils as ESLintUtils19 } 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 preferImportType = createRule14({
+var preferImportType = createRule19({
   name: "prefer-import-type",
   meta: {
     type: "suggestion",
@@ -959,22 +1539,22 @@ var preferImportType = createRule14({
       let current = node;
       while (current) {
         switch (current.type) {
-          case AST_NODE_TYPES10.TSTypeReference:
-          case AST_NODE_TYPES10.TSTypeAnnotation:
-          case AST_NODE_TYPES10.TSTypeParameterInstantiation:
-          case AST_NODE_TYPES10.TSInterfaceHeritage:
-          case AST_NODE_TYPES10.TSClassImplements:
-          case AST_NODE_TYPES10.TSTypeQuery:
-          case AST_NODE_TYPES10.TSTypeAssertion:
-          case AST_NODE_TYPES10.TSAsExpression:
-          case AST_NODE_TYPES10.TSSatisfiesExpression:
-          case AST_NODE_TYPES10.TSTypeAliasDeclaration:
-          case AST_NODE_TYPES10.TSInterfaceDeclaration:
-          case AST_NODE_TYPES10.TSTypeParameter:
-          case AST_NODE_TYPES10.TSQualifiedName:
+          case AST_NODE_TYPES16.TSTypeReference:
+          case AST_NODE_TYPES16.TSTypeAnnotation:
+          case AST_NODE_TYPES16.TSTypeParameterInstantiation:
+          case AST_NODE_TYPES16.TSInterfaceHeritage:
+          case AST_NODE_TYPES16.TSClassImplements:
+          case AST_NODE_TYPES16.TSTypeQuery:
+          case AST_NODE_TYPES16.TSTypeAssertion:
+          case AST_NODE_TYPES16.TSAsExpression:
+          case AST_NODE_TYPES16.TSSatisfiesExpression:
+          case AST_NODE_TYPES16.TSTypeAliasDeclaration:
+          case AST_NODE_TYPES16.TSInterfaceDeclaration:
+          case AST_NODE_TYPES16.TSTypeParameter:
+          case AST_NODE_TYPES16.TSQualifiedName:
             return true;
-          case AST_NODE_TYPES10.MemberExpression:
-          case AST_NODE_TYPES10.Identifier:
+          case AST_NODE_TYPES16.MemberExpression:
+          case AST_NODE_TYPES16.Identifier:
             current = current.parent;
             break;
           default:
@@ -1004,26 +1584,26 @@ var preferImportType = createRule14({
           return false;
         }
         switch (parent.type) {
-          case AST_NODE_TYPES10.CallExpression:
-          case AST_NODE_TYPES10.NewExpression:
-          case AST_NODE_TYPES10.JSXOpeningElement:
-          case AST_NODE_TYPES10.JSXClosingElement:
-          case AST_NODE_TYPES10.MemberExpression:
-          case AST_NODE_TYPES10.VariableDeclarator:
-          case AST_NODE_TYPES10.TaggedTemplateExpression:
-          case AST_NODE_TYPES10.SpreadElement:
-          case AST_NODE_TYPES10.ExportSpecifier:
-          case AST_NODE_TYPES10.ArrayExpression:
-          case AST_NODE_TYPES10.ObjectExpression:
-          case AST_NODE_TYPES10.BinaryExpression:
-          case AST_NODE_TYPES10.LogicalExpression:
-          case AST_NODE_TYPES10.UnaryExpression:
-          case AST_NODE_TYPES10.ReturnStatement:
-          case AST_NODE_TYPES10.ArrowFunctionExpression:
-          case AST_NODE_TYPES10.ConditionalExpression:
-          case AST_NODE_TYPES10.AwaitExpression:
-          case AST_NODE_TYPES10.YieldExpression:
-          case AST_NODE_TYPES10.Property:
+          case AST_NODE_TYPES16.CallExpression:
+          case AST_NODE_TYPES16.NewExpression:
+          case AST_NODE_TYPES16.JSXOpeningElement:
+          case AST_NODE_TYPES16.JSXClosingElement:
+          case AST_NODE_TYPES16.MemberExpression:
+          case AST_NODE_TYPES16.VariableDeclarator:
+          case AST_NODE_TYPES16.TaggedTemplateExpression:
+          case AST_NODE_TYPES16.SpreadElement:
+          case AST_NODE_TYPES16.ExportSpecifier:
+          case AST_NODE_TYPES16.ArrayExpression:
+          case AST_NODE_TYPES16.ObjectExpression:
+          case AST_NODE_TYPES16.BinaryExpression:
+          case AST_NODE_TYPES16.LogicalExpression:
+          case AST_NODE_TYPES16.UnaryExpression:
+          case AST_NODE_TYPES16.ReturnStatement:
+          case AST_NODE_TYPES16.ArrowFunctionExpression:
+          case AST_NODE_TYPES16.ConditionalExpression:
+          case AST_NODE_TYPES16.AwaitExpression:
+          case AST_NODE_TYPES16.YieldExpression:
+          case AST_NODE_TYPES16.Property:
             return true;
           default:
             return false;
@@ -1047,13 +1627,13 @@ var preferImportType = createRule14({
       }
       const scope = context.sourceCode.getScope(node);
       const isTypeOnlyImport = node.specifiers.every((specifier) => {
-        if (specifier.type === AST_NODE_TYPES10.ImportDefaultSpecifier) {
+        if (specifier.type === AST_NODE_TYPES16.ImportDefaultSpecifier) {
           return false;
         }
-        if (specifier.type === AST_NODE_TYPES10.ImportNamespaceSpecifier) {
+        if (specifier.type === AST_NODE_TYPES16.ImportNamespaceSpecifier) {
           return false;
         }
-        if (specifier.type === AST_NODE_TYPES10.ImportSpecifier) {
+        if (specifier.type === AST_NODE_TYPES16.ImportSpecifier) {
           const localName = specifier.local.name;
           return !isUsedAsValue(localName, scope);
         }
@@ -1079,11 +1659,11 @@ var preferImportType = createRule14({
 var prefer_import_type_default = preferImportType;
 
 // src/rules/prefer-interface-over-inline-types.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES11, ESLintUtils as ESLintUtils15 } from "@typescript-eslint/utils";
-var createRule15 = ESLintUtils15.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 preferInterfaceOverInlineTypes = createRule15({
+var preferInterfaceOverInlineTypes = createRule20({
   name: "prefer-interface-over-inline-types",
   meta: {
     type: "suggestion",
@@ -1099,67 +1679,67 @@ var preferInterfaceOverInlineTypes = createRule15({
   defaultOptions: [],
   create(context) {
     function hasJSXInConditional(node) {
-      return node.consequent.type === AST_NODE_TYPES11.JSXElement || node.consequent.type === AST_NODE_TYPES11.JSXFragment || node.alternate.type === AST_NODE_TYPES11.JSXElement || node.alternate.type === AST_NODE_TYPES11.JSXFragment;
+      return node.consequent.type === AST_NODE_TYPES17.JSXElement || node.consequent.type === AST_NODE_TYPES17.JSXFragment || node.alternate.type === AST_NODE_TYPES17.JSXElement || node.alternate.type === AST_NODE_TYPES17.JSXFragment;
     }
     function hasJSXInLogical(node) {
-      return node.right.type === AST_NODE_TYPES11.JSXElement || node.right.type === AST_NODE_TYPES11.JSXFragment;
+      return node.right.type === AST_NODE_TYPES17.JSXElement || node.right.type === AST_NODE_TYPES17.JSXFragment;
     }
     function hasJSXReturn(block) {
       return block.body.some((stmt) => {
-        if (stmt.type === AST_NODE_TYPES11.ReturnStatement && stmt.argument) {
-          return stmt.argument.type === AST_NODE_TYPES11.JSXElement || stmt.argument.type === AST_NODE_TYPES11.JSXFragment || stmt.argument.type === AST_NODE_TYPES11.ConditionalExpression && hasJSXInConditional(stmt.argument) || stmt.argument.type === AST_NODE_TYPES11.LogicalExpression && hasJSXInLogical(stmt.argument);
+        if (stmt.type === AST_NODE_TYPES17.ReturnStatement && stmt.argument) {
+          return stmt.argument.type === AST_NODE_TYPES17.JSXElement || stmt.argument.type === AST_NODE_TYPES17.JSXFragment || stmt.argument.type === AST_NODE_TYPES17.ConditionalExpression && hasJSXInConditional(stmt.argument) || stmt.argument.type === AST_NODE_TYPES17.LogicalExpression && hasJSXInLogical(stmt.argument);
         }
         return false;
       });
     }
-    function isReactComponent(node) {
-      if (node.type === AST_NODE_TYPES11.ArrowFunctionExpression) {
-        if (node.body.type === AST_NODE_TYPES11.JSXElement || node.body.type === AST_NODE_TYPES11.JSXFragment) {
+    function isReactComponent2(node) {
+      if (node.type === AST_NODE_TYPES17.ArrowFunctionExpression) {
+        if (node.body.type === AST_NODE_TYPES17.JSXElement || node.body.type === AST_NODE_TYPES17.JSXFragment) {
           return true;
         }
-        if (node.body.type === AST_NODE_TYPES11.BlockStatement) {
+        if (node.body.type === AST_NODE_TYPES17.BlockStatement) {
           return hasJSXReturn(node.body);
         }
-      } else if (node.type === AST_NODE_TYPES11.FunctionExpression || node.type === AST_NODE_TYPES11.FunctionDeclaration) {
-        if (node.body && node.body.type === AST_NODE_TYPES11.BlockStatement) {
+      } else if (node.type === AST_NODE_TYPES17.FunctionExpression || node.type === AST_NODE_TYPES17.FunctionDeclaration) {
+        if (node.body && node.body.type === AST_NODE_TYPES17.BlockStatement) {
           return hasJSXReturn(node.body);
         }
       }
       return false;
     }
     function isInlineTypeAnnotation(node) {
-      if (node.type === AST_NODE_TYPES11.TSTypeLiteral) {
+      if (node.type === AST_NODE_TYPES17.TSTypeLiteral) {
         return true;
       }
-      if (node.type === AST_NODE_TYPES11.TSTypeReference && node.typeArguments) {
-        return node.typeArguments.params.some((param) => param.type === AST_NODE_TYPES11.TSTypeLiteral);
+      if (node.type === AST_NODE_TYPES17.TSTypeReference && node.typeArguments) {
+        return node.typeArguments.params.some((param) => param.type === AST_NODE_TYPES17.TSTypeLiteral);
       }
-      if (node.type === AST_NODE_TYPES11.TSUnionType) {
+      if (node.type === AST_NODE_TYPES17.TSUnionType) {
         return node.types.some((type) => isInlineTypeAnnotation(type));
       }
       return false;
     }
     function hasInlineObjectType(node) {
-      if (node.type === AST_NODE_TYPES11.TSTypeLiteral) {
+      if (node.type === AST_NODE_TYPES17.TSTypeLiteral) {
         return true;
       }
-      if (node.type === AST_NODE_TYPES11.TSTypeReference && node.typeArguments) {
-        return node.typeArguments.params.some((param) => param.type === AST_NODE_TYPES11.TSTypeLiteral);
+      if (node.type === AST_NODE_TYPES17.TSTypeReference && node.typeArguments) {
+        return node.typeArguments.params.some((param) => param.type === AST_NODE_TYPES17.TSTypeLiteral);
       }
-      if (node.type === AST_NODE_TYPES11.TSUnionType) {
+      if (node.type === AST_NODE_TYPES17.TSUnionType) {
         return node.types.some((type) => hasInlineObjectType(type));
       }
       return false;
     }
     function checkFunction(node) {
-      if (!isReactComponent(node)) {
+      if (!isReactComponent2(node)) {
         return;
       }
       if (node.params.length !== 1) {
         return;
       }
       const param = node.params[0];
-      if (param.type === AST_NODE_TYPES11.Identifier && param.typeAnnotation) {
+      if (param.type === AST_NODE_TYPES17.Identifier && param.typeAnnotation) {
         const { typeAnnotation } = param.typeAnnotation;
         if (isInlineTypeAnnotation(typeAnnotation) && hasInlineObjectType(typeAnnotation)) {
           context.report({
@@ -1179,11 +1759,11 @@ var preferInterfaceOverInlineTypes = createRule15({
 var prefer_interface_over_inline_types_default = preferInterfaceOverInlineTypes;
 
 // src/rules/prefer-jsx-template-literals.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES12, ESLintUtils as ESLintUtils16 } from "@typescript-eslint/utils";
-var createRule16 = ESLintUtils16.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 preferJSXTemplateLiterals = createRule16({
+var preferJSXTemplateLiterals = createRule21({
   name: "prefer-jsx-template-literals",
   meta: {
     type: "suggestion",
@@ -1252,9 +1832,9 @@ var preferJSXTemplateLiterals = createRule16({
         if (!child || !nextChild) {
           return;
         }
-        if (child.type === AST_NODE_TYPES12.JSXText && nextChild.type === AST_NODE_TYPES12.JSXExpressionContainer) {
+        if (child.type === AST_NODE_TYPES18.JSXText && nextChild.type === AST_NODE_TYPES18.JSXExpressionContainer) {
           handleTextBeforeExpression(child, nextChild);
-        } else if (child.type === AST_NODE_TYPES12.JSXExpressionContainer && nextChild.type === AST_NODE_TYPES12.JSXText) {
+        } else if (child.type === AST_NODE_TYPES18.JSXExpressionContainer && nextChild.type === AST_NODE_TYPES18.JSXText) {
           handleExpressionBeforeText(child, nextChild);
         }
       }
@@ -1267,11 +1847,11 @@ var preferJSXTemplateLiterals = createRule16({
 var prefer_jsx_template_literals_default = preferJSXTemplateLiterals;
 
 // src/rules/prefer-named-param-types.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES13, ESLintUtils as ESLintUtils17 } from "@typescript-eslint/utils";
-var createRule17 = ESLintUtils17.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 preferNamedParamTypes = createRule17({
+var preferNamedParamTypes = createRule22({
   name: "prefer-named-param-types",
   meta: {
     type: "suggestion",
@@ -1286,16 +1866,16 @@ var preferNamedParamTypes = createRule17({
   defaultOptions: [],
   create(context) {
     function hasInlineObjectType(param) {
-      if (param.type === AST_NODE_TYPES13.AssignmentPattern) {
+      if (param.type === AST_NODE_TYPES19.AssignmentPattern) {
         return hasInlineObjectType(param.left);
       }
-      if (param.type === AST_NODE_TYPES13.ObjectPattern) {
-        if (param.typeAnnotation?.typeAnnotation.type === AST_NODE_TYPES13.TSTypeLiteral) {
+      if (param.type === AST_NODE_TYPES19.ObjectPattern) {
+        if (param.typeAnnotation?.typeAnnotation.type === AST_NODE_TYPES19.TSTypeLiteral) {
           return true;
         }
       }
-      if (param.type === AST_NODE_TYPES13.Identifier) {
-        if (param.typeAnnotation?.typeAnnotation.type === AST_NODE_TYPES13.TSTypeLiteral) {
+      if (param.type === AST_NODE_TYPES19.Identifier) {
+        if (param.typeAnnotation?.typeAnnotation.type === AST_NODE_TYPES19.TSTypeLiteral) {
           return true;
         }
       }
@@ -1329,11 +1909,11 @@ var preferNamedParamTypes = createRule17({
 var prefer_named_param_types_default = preferNamedParamTypes;
 
 // src/rules/prefer-react-import-types.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES14, ESLintUtils as ESLintUtils18 } from "@typescript-eslint/utils";
-var createRule18 = ESLintUtils18.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 preferReactImportTypes = createRule18({
+var preferReactImportTypes = createRule23({
   name: "prefer-react-import-types",
   meta: {
     type: "suggestion",
@@ -1409,7 +1989,7 @@ var preferReactImportTypes = createRule18({
     ]);
     const allReactExports = /* @__PURE__ */ new Set([...reactTypes, ...reactRuntimeExports]);
     function checkMemberExpression(node) {
-      if (node.object.type === AST_NODE_TYPES14.Identifier && node.object.name === "React" && node.property.type === AST_NODE_TYPES14.Identifier && allReactExports.has(node.property.name)) {
+      if (node.object.type === AST_NODE_TYPES20.Identifier && node.object.name === "React" && node.property.type === AST_NODE_TYPES20.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"`;
@@ -1426,7 +2006,7 @@ var preferReactImportTypes = createRule18({
     return {
       MemberExpression: checkMemberExpression,
       "TSTypeReference > TSQualifiedName": (node) => {
-        if (node.left.type === AST_NODE_TYPES14.Identifier && node.left.name === "React" && node.right.type === AST_NODE_TYPES14.Identifier && allReactExports.has(node.right.name)) {
+        if (node.left.type === AST_NODE_TYPES20.Identifier && node.left.name === "React" && node.right.type === AST_NODE_TYPES20.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"`;
@@ -1446,11 +2026,11 @@ var preferReactImportTypes = createRule18({
 var prefer_react_import_types_default = preferReactImportTypes;
 
 // src/rules/react-props-destructure.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES15, ESLintUtils as ESLintUtils19 } from "@typescript-eslint/utils";
-var createRule19 = ESLintUtils19.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 reactPropsDestructure = createRule19({
+var reactPropsDestructure = createRule24({
   name: "react-props-destructure",
   meta: {
     type: "suggestion",
@@ -1466,45 +2046,45 @@ var reactPropsDestructure = createRule19({
   defaultOptions: [],
   create(context) {
     function hasJSXInConditional(node) {
-      return node.consequent.type === AST_NODE_TYPES15.JSXElement || node.consequent.type === AST_NODE_TYPES15.JSXFragment || node.alternate.type === AST_NODE_TYPES15.JSXElement || node.alternate.type === AST_NODE_TYPES15.JSXFragment;
+      return node.consequent.type === AST_NODE_TYPES21.JSXElement || node.consequent.type === AST_NODE_TYPES21.JSXFragment || node.alternate.type === AST_NODE_TYPES21.JSXElement || node.alternate.type === AST_NODE_TYPES21.JSXFragment;
     }
     function hasJSXInLogical(node) {
-      return node.right.type === AST_NODE_TYPES15.JSXElement || node.right.type === AST_NODE_TYPES15.JSXFragment;
+      return node.right.type === AST_NODE_TYPES21.JSXElement || node.right.type === AST_NODE_TYPES21.JSXFragment;
     }
     function hasJSXReturn(block) {
       return block.body.some((stmt) => {
-        if (stmt.type === AST_NODE_TYPES15.ReturnStatement && stmt.argument) {
-          return stmt.argument.type === AST_NODE_TYPES15.JSXElement || stmt.argument.type === AST_NODE_TYPES15.JSXFragment || stmt.argument.type === AST_NODE_TYPES15.ConditionalExpression && hasJSXInConditional(stmt.argument) || stmt.argument.type === AST_NODE_TYPES15.LogicalExpression && hasJSXInLogical(stmt.argument);
+        if (stmt.type === AST_NODE_TYPES21.ReturnStatement && stmt.argument) {
+          return stmt.argument.type === AST_NODE_TYPES21.JSXElement || stmt.argument.type === AST_NODE_TYPES21.JSXFragment || stmt.argument.type === AST_NODE_TYPES21.ConditionalExpression && hasJSXInConditional(stmt.argument) || stmt.argument.type === AST_NODE_TYPES21.LogicalExpression && hasJSXInLogical(stmt.argument);
         }
         return false;
       });
     }
-    function isReactComponent(node) {
-      if (node.type === AST_NODE_TYPES15.ArrowFunctionExpression) {
-        if (node.body.type === AST_NODE_TYPES15.JSXElement || node.body.type === AST_NODE_TYPES15.JSXFragment) {
+    function isReactComponent2(node) {
+      if (node.type === AST_NODE_TYPES21.ArrowFunctionExpression) {
+        if (node.body.type === AST_NODE_TYPES21.JSXElement || node.body.type === AST_NODE_TYPES21.JSXFragment) {
           return true;
         }
-        if (node.body.type === AST_NODE_TYPES15.BlockStatement) {
+        if (node.body.type === AST_NODE_TYPES21.BlockStatement) {
           return hasJSXReturn(node.body);
         }
-      } else if (node.type === AST_NODE_TYPES15.FunctionExpression || node.type === AST_NODE_TYPES15.FunctionDeclaration) {
-        if (node.body && node.body.type === AST_NODE_TYPES15.BlockStatement) {
+      } else if (node.type === AST_NODE_TYPES21.FunctionExpression || node.type === AST_NODE_TYPES21.FunctionDeclaration) {
+        if (node.body && node.body.type === AST_NODE_TYPES21.BlockStatement) {
           return hasJSXReturn(node.body);
         }
       }
       return false;
     }
     function checkFunction(node) {
-      if (!isReactComponent(node)) {
+      if (!isReactComponent2(node)) {
         return;
       }
       if (node.params.length !== 1) {
         return;
       }
       const param = node.params[0];
-      if (param.type === AST_NODE_TYPES15.ObjectPattern) {
-        const properties = param.properties.filter((prop) => prop.type === AST_NODE_TYPES15.Property).map((prop) => {
-          if (prop.key.type === AST_NODE_TYPES15.Identifier) {
+      if (param.type === AST_NODE_TYPES21.ObjectPattern) {
+        const properties = param.properties.filter((prop) => prop.type === AST_NODE_TYPES21.Property).map((prop) => {
+          if (prop.key.type === AST_NODE_TYPES21.Identifier) {
             return prop.key.name;
           }
           return null;
@@ -1536,6 +2116,7 @@ var meta = {
   version: package_default.version
 };
 var rules = {
+  "boolean-naming-prefix": boolean_naming_prefix_default,
   "enforce-readonly-component-props": enforce_readonly_component_props_default,
   "enforce-sorted-destructuring": enforce_sorted_destructuring_default,
   "file-kebab-case": file_kebab_case_default,
@@ -1544,11 +2125,15 @@ var rules = {
   "jsx-no-variable-in-callback": jsx_no_variable_in_callback_default,
   "md-filename-case-restriction": md_filename_case_restriction_default,
   "no-complex-inline-return": no_complex_inline_return_default,
+  "no-direct-date": no_direct_date_default,
   "no-emoji": no_emoji_default,
   "no-env-fallback": no_env_fallback_default,
-  "no-explicit-return-type": no_explicit_return_type_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,
+  "prefer-function-declaration": prefer_function_declaration_default,
   "prefer-import-type": prefer_import_type_default,
   "prefer-interface-over-inline-types": prefer_interface_over_inline_types_default,
   "prefer-jsx-template-literals": prefer_jsx_template_literals_default,
@@ -1561,32 +2146,42 @@ var plugin = {
   rules
 };
 var baseRules = {
+  "nextfriday/boolean-naming-prefix": "warn",
   "nextfriday/no-emoji": "warn",
   "nextfriday/enforce-sorted-destructuring": "warn",
   "nextfriday/file-kebab-case": "warn",
   "nextfriday/md-filename-case-restriction": "warn",
   "nextfriday/prefer-destructuring-params": "warn",
-  "nextfriday/no-explicit-return-type": "warn",
+  "nextfriday/prefer-function-declaration": "warn",
+  "nextfriday/require-explicit-return-type": "warn",
   "nextfriday/prefer-import-type": "warn",
   "nextfriday/prefer-named-param-types": "warn",
   "nextfriday/prefer-react-import-types": "warn",
   "nextfriday/no-complex-inline-return": "warn",
+  "nextfriday/no-direct-date": "warn",
   "nextfriday/no-logic-in-params": "warn",
-  "nextfriday/no-env-fallback": "warn"
+  "nextfriday/no-env-fallback": "warn",
+  "nextfriday/no-lazy-identifiers": "warn",
+  "nextfriday/no-single-char-variables": "warn"
 };
 var baseRecommendedRules = {
+  "nextfriday/boolean-naming-prefix": "error",
   "nextfriday/no-emoji": "error",
   "nextfriday/enforce-sorted-destructuring": "error",
   "nextfriday/file-kebab-case": "error",
   "nextfriday/md-filename-case-restriction": "error",
   "nextfriday/prefer-destructuring-params": "error",
-  "nextfriday/no-explicit-return-type": "error",
+  "nextfriday/prefer-function-declaration": "error",
+  "nextfriday/require-explicit-return-type": "error",
   "nextfriday/prefer-import-type": "error",
   "nextfriday/prefer-named-param-types": "error",
   "nextfriday/prefer-react-import-types": "error",
   "nextfriday/no-complex-inline-return": "error",
+  "nextfriday/no-direct-date": "error",
   "nextfriday/no-logic-in-params": "error",
-  "nextfriday/no-env-fallback": "error"
+  "nextfriday/no-env-fallback": "error",
+  "nextfriday/no-lazy-identifiers": "error",
+  "nextfriday/no-single-char-variables": "error"
 };
 var jsxRules = {
   "nextfriday/jsx-pascal-case": "warn",