npm - eslint-plugin-nextfriday - Versions diffs - 4.2.0 → 4.3.0 - Mend

eslint-plugin-nextfriday 4.2.0 → 4.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (13) hide show

package/CHANGELOG.md +6 -0
package/README.md +13 -7
package/docs/rules/ENFORCE_HOOK_FILENAME.md +77 -0
package/docs/rules/ENFORCE_TEST_FILENAME.md +61 -0
package/docs/rules/NO_HELPER_FUNCTION_IN_HOOK.md +86 -0
package/docs/rules/NO_HELPER_FUNCTION_IN_TEST.md +69 -0
package/lib/index.cjs +729 -550
package/lib/index.cjs.map +1 -1
package/lib/index.d.cts +168 -0
package/lib/index.d.ts +168 -0
package/lib/index.js +729 -550
package/lib/index.js.map +1 -1
package/package.json +1 -1

package/lib/index.cjs CHANGED Viewed

@@ -40,7 +40,7 @@ module.exports = __toCommonJS(index_exports);
 // package.json
 var package_default = {
   name: "eslint-plugin-nextfriday",
-  version: "4.2.0",
+  version: "4.3.0",
   description: "A comprehensive ESLint plugin providing custom rules and configurations for Next Friday development workflows.",
   keywords: [
     "eslint",
@@ -525,13 +525,64 @@ var enforceConstantCase = createRule3({
 });
 var enforce_constant_case_default = enforceConstantCase;
-// src/rules/enforce-hook-naming.ts
+// src/rules/enforce-hook-filename.ts
 var import_path = __toESM(require("path"), 1);
 var import_utils6 = require("@typescript-eslint/utils");
 var createRule4 = import_utils6.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var enforceHookNaming = createRule4({
+var enforceHookFilename = createRule4({
+  name: "enforce-hook-filename",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Enforce that files exporting custom hooks are named *.hook.ts or *.hooks.ts"
+    },
+    messages: {
+      requireHookFilename: "'{{ name }}' is a custom hook and must be exported from a *.hook.ts or *.hooks.ts file."
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    const basename2 = import_path.default.basename(context.filename);
+    const isHookFile = basename2.endsWith(".hook.ts") || basename2.endsWith(".hooks.ts");
+    if (isHookFile) return {};
+    function reportIfHook(name, node) {
+      if (name.startsWith("use") && name.length > 3 && /^use[A-Z]/.test(name)) {
+        context.report({ node, messageId: "requireHookFilename", data: { name } });
+      }
+    }
+    return {
+      ExportNamedDeclaration(node) {
+        if (node.declaration?.type === import_utils6.AST_NODE_TYPES.FunctionDeclaration && node.declaration.id) {
+          reportIfHook(node.declaration.id.name, node.declaration.id);
+        }
+        if (node.declaration?.type === import_utils6.AST_NODE_TYPES.VariableDeclaration) {
+          for (const declarator of node.declaration.declarations) {
+            if (declarator.id.type === import_utils6.AST_NODE_TYPES.Identifier && declarator.init !== null && (declarator.init.type === import_utils6.AST_NODE_TYPES.ArrowFunctionExpression || declarator.init.type === import_utils6.AST_NODE_TYPES.FunctionExpression)) {
+              reportIfHook(declarator.id.name, declarator.id);
+            }
+          }
+        }
+      },
+      ExportDefaultDeclaration(node) {
+        if (node.declaration.type === import_utils6.AST_NODE_TYPES.FunctionDeclaration && node.declaration.id !== null) {
+          reportIfHook(node.declaration.id.name, node.declaration.id);
+        }
+      }
+    };
+  }
+});
+var enforce_hook_filename_default = enforceHookFilename;
+// src/rules/enforce-hook-naming.ts
+var import_path2 = __toESM(require("path"), 1);
+var import_utils7 = require("@typescript-eslint/utils");
+var createRule5 = import_utils7.ESLintUtils.RuleCreator(
+  (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
+);
+var enforceHookNaming = createRule5({
   name: "enforce-hook-naming",
   meta: {
     type: "suggestion",
@@ -547,7 +598,7 @@ var enforceHookNaming = createRule4({
   defaultOptions: [],
   create(context) {
     const { filename } = context;
-    const basename2 = import_path.default.basename(filename);
+    const basename2 = import_path2.default.basename(filename);
     const isHookFile = basename2.endsWith(".hook.ts") || basename2.endsWith(".hooks.ts");
     if (!isHookFile) {
       return {};
@@ -570,22 +621,22 @@ var enforceHookNaming = createRule4({
     };
     return {
       ExportNamedDeclaration(node) {
-        if (node.declaration?.type === import_utils6.AST_NODE_TYPES.FunctionDeclaration && node.declaration.id) {
+        if (node.declaration?.type === import_utils7.AST_NODE_TYPES.FunctionDeclaration && node.declaration.id) {
           checkFunctionName(node.declaration.id.name, node.declaration.id, "missingUsePrefix");
         }
-        if (node.declaration?.type === import_utils6.AST_NODE_TYPES.VariableDeclaration) {
+        if (node.declaration?.type === import_utils7.AST_NODE_TYPES.VariableDeclaration) {
           node.declaration.declarations.forEach((declarator) => {
-            if (declarator.id.type === import_utils6.AST_NODE_TYPES.Identifier) {
+            if (declarator.id.type === import_utils7.AST_NODE_TYPES.Identifier) {
               checkFunctionName(declarator.id.name, declarator.id, "missingUsePrefix");
             }
           });
         }
       },
       ExportDefaultDeclaration(node) {
-        if (node.declaration.type === import_utils6.AST_NODE_TYPES.Identifier) {
+        if (node.declaration.type === import_utils7.AST_NODE_TYPES.Identifier) {
           checkFunctionName(node.declaration.name, node.declaration, "defaultExportMissingUsePrefix");
         }
-        if (node.declaration.type === import_utils6.AST_NODE_TYPES.FunctionDeclaration && node.declaration.id) {
+        if (node.declaration.type === import_utils7.AST_NODE_TYPES.FunctionDeclaration && node.declaration.id) {
           checkFunctionName(node.declaration.id.name, node.declaration.id, "defaultExportMissingUsePrefix");
         }
       }
@@ -595,26 +646,26 @@ var enforceHookNaming = createRule4({
 var enforce_hook_naming_default = enforceHookNaming;
 // src/rules/enforce-property-case.ts
-var import_utils7 = require("@typescript-eslint/utils");
-var createRule5 = import_utils7.ESLintUtils.RuleCreator(
+var import_utils8 = require("@typescript-eslint/utils");
+var createRule6 = import_utils8.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var SNAKE_CASE_REGEX3 = /^[a-z]+_[a-z0-9_]*$/;
 var SCREAMING_SNAKE_CASE_REGEX2 = /^[A-Z][A-Z0-9]*(?:_[A-Z0-9]+)*$/;
 var isInsideAsConst = (node) => {
   const { parent } = node;
-  if (parent.type === import_utils7.AST_NODE_TYPES.TSAsExpression && parent.typeAnnotation.type === import_utils7.AST_NODE_TYPES.TSTypeReference && parent.typeAnnotation.typeName.type === import_utils7.AST_NODE_TYPES.Identifier && parent.typeAnnotation.typeName.name === "const") {
+  if (parent.type === import_utils8.AST_NODE_TYPES.TSAsExpression && parent.typeAnnotation.type === import_utils8.AST_NODE_TYPES.TSTypeReference && parent.typeAnnotation.typeName.type === import_utils8.AST_NODE_TYPES.Identifier && parent.typeAnnotation.typeName.name === "const") {
     return true;
   }
-  if (parent.type === import_utils7.AST_NODE_TYPES.ArrayExpression) {
+  if (parent.type === import_utils8.AST_NODE_TYPES.ArrayExpression) {
     const grandparent = parent.parent;
-    if (grandparent?.type === import_utils7.AST_NODE_TYPES.TSAsExpression && grandparent.typeAnnotation.type === import_utils7.AST_NODE_TYPES.TSTypeReference && grandparent.typeAnnotation.typeName.type === import_utils7.AST_NODE_TYPES.Identifier && grandparent.typeAnnotation.typeName.name === "const") {
+    if (grandparent?.type === import_utils8.AST_NODE_TYPES.TSAsExpression && grandparent.typeAnnotation.type === import_utils8.AST_NODE_TYPES.TSTypeReference && grandparent.typeAnnotation.typeName.type === import_utils8.AST_NODE_TYPES.Identifier && grandparent.typeAnnotation.typeName.name === "const") {
       return true;
     }
   }
   return false;
 };
-var enforcePropertyCase = createRule5({
+var enforcePropertyCase = createRule6({
   name: "enforce-property-case",
   meta: {
     type: "suggestion",
@@ -630,7 +681,7 @@ var enforcePropertyCase = createRule5({
   create(context) {
     return {
       Property(node) {
-        if (node.parent.type !== import_utils7.AST_NODE_TYPES.ObjectExpression) {
+        if (node.parent.type !== import_utils8.AST_NODE_TYPES.ObjectExpression) {
           return;
         }
         if (isInsideAsConst(node.parent)) {
@@ -639,7 +690,7 @@ var enforcePropertyCase = createRule5({
         if (node.computed) {
           return;
         }
-        if (node.key.type !== import_utils7.AST_NODE_TYPES.Identifier) {
+        if (node.key.type !== import_utils8.AST_NODE_TYPES.Identifier) {
           return;
         }
         const { name } = node.key;
@@ -657,12 +708,12 @@ var enforcePropertyCase = createRule5({
 var enforce_property_case_default = enforcePropertyCase;
 // src/rules/enforce-props-suffix.ts
-var import_path2 = __toESM(require("path"), 1);
-var import_utils8 = require("@typescript-eslint/utils");
-var createRule6 = import_utils8.ESLintUtils.RuleCreator(
+var import_path3 = __toESM(require("path"), 1);
+var import_utils9 = require("@typescript-eslint/utils");
+var createRule7 = import_utils9.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var enforcePropsSuffix = createRule6({
+var enforcePropsSuffix = createRule7({
   name: "enforce-props-suffix",
   meta: {
     type: "suggestion",
@@ -677,7 +728,7 @@ var enforcePropsSuffix = createRule6({
   defaultOptions: [],
   create(context) {
     const { filename } = context;
-    const ext = import_path2.default.extname(filename);
+    const ext = import_path3.default.extname(filename);
     const isComponentFile = ext === ".tsx" || ext === ".jsx";
     if (!isComponentFile) {
       return {};
@@ -696,13 +747,13 @@ var enforcePropsSuffix = createRule6({
     };
     return {
       TSInterfaceDeclaration(node) {
-        if (node.id.type === import_utils8.AST_NODE_TYPES.Identifier) {
+        if (node.id.type === import_utils9.AST_NODE_TYPES.Identifier) {
           checkTypeName(node.id.name, node.id);
         }
       },
       TSTypeAliasDeclaration(node) {
-        if (node.id.type === import_utils8.AST_NODE_TYPES.Identifier) {
-          if (node.typeAnnotation.type === import_utils8.AST_NODE_TYPES.TSTypeLiteral) {
+        if (node.id.type === import_utils9.AST_NODE_TYPES.Identifier) {
+          if (node.typeAnnotation.type === import_utils9.AST_NODE_TYPES.TSTypeLiteral) {
             checkTypeName(node.id.name, node.id);
           }
         }
@@ -713,11 +764,11 @@ var enforcePropsSuffix = createRule6({
 var enforce_props_suffix_default = enforcePropsSuffix;
 // src/rules/enforce-readonly-component-props.ts
-var import_utils9 = require("@typescript-eslint/utils");
-var createRule7 = import_utils9.ESLintUtils.RuleCreator(
+var import_utils10 = require("@typescript-eslint/utils");
+var createRule8 = import_utils10.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var enforceReadonlyComponentProps = createRule7({
+var enforceReadonlyComponentProps = createRule8({
   name: "enforce-readonly-component-props",
   meta: {
     type: "suggestion",
@@ -733,40 +784,40 @@ var enforceReadonlyComponentProps = createRule7({
   defaultOptions: [],
   create(context) {
     function hasJSXInConditional(node) {
-      return node.consequent.type === import_utils9.AST_NODE_TYPES.JSXElement || node.consequent.type === import_utils9.AST_NODE_TYPES.JSXFragment || node.alternate.type === import_utils9.AST_NODE_TYPES.JSXElement || node.alternate.type === import_utils9.AST_NODE_TYPES.JSXFragment;
+      return node.consequent.type === import_utils10.AST_NODE_TYPES.JSXElement || node.consequent.type === import_utils10.AST_NODE_TYPES.JSXFragment || node.alternate.type === import_utils10.AST_NODE_TYPES.JSXElement || node.alternate.type === import_utils10.AST_NODE_TYPES.JSXFragment;
     }
     function hasJSXInLogical(node) {
-      return node.right.type === import_utils9.AST_NODE_TYPES.JSXElement || node.right.type === import_utils9.AST_NODE_TYPES.JSXFragment;
+      return node.right.type === import_utils10.AST_NODE_TYPES.JSXElement || node.right.type === import_utils10.AST_NODE_TYPES.JSXFragment;
     }
     function hasJSXReturn(block) {
       return block.body.some((stmt) => {
-        if (stmt.type === import_utils9.AST_NODE_TYPES.ReturnStatement && stmt.argument) {
-          return stmt.argument.type === import_utils9.AST_NODE_TYPES.JSXElement || stmt.argument.type === import_utils9.AST_NODE_TYPES.JSXFragment || stmt.argument.type === import_utils9.AST_NODE_TYPES.ConditionalExpression && hasJSXInConditional(stmt.argument) || stmt.argument.type === import_utils9.AST_NODE_TYPES.LogicalExpression && hasJSXInLogical(stmt.argument);
+        if (stmt.type === import_utils10.AST_NODE_TYPES.ReturnStatement && stmt.argument) {
+          return stmt.argument.type === import_utils10.AST_NODE_TYPES.JSXElement || stmt.argument.type === import_utils10.AST_NODE_TYPES.JSXFragment || stmt.argument.type === import_utils10.AST_NODE_TYPES.ConditionalExpression && hasJSXInConditional(stmt.argument) || stmt.argument.type === import_utils10.AST_NODE_TYPES.LogicalExpression && hasJSXInLogical(stmt.argument);
         }
         return false;
       });
     }
     function isReactComponent2(node) {
-      if (node.type === import_utils9.AST_NODE_TYPES.ArrowFunctionExpression) {
-        if (node.body.type === import_utils9.AST_NODE_TYPES.JSXElement || node.body.type === import_utils9.AST_NODE_TYPES.JSXFragment) {
+      if (node.type === import_utils10.AST_NODE_TYPES.ArrowFunctionExpression) {
+        if (node.body.type === import_utils10.AST_NODE_TYPES.JSXElement || node.body.type === import_utils10.AST_NODE_TYPES.JSXFragment) {
           return true;
         }
-        if (node.body.type === import_utils9.AST_NODE_TYPES.BlockStatement) {
+        if (node.body.type === import_utils10.AST_NODE_TYPES.BlockStatement) {
           return hasJSXReturn(node.body);
         }
-      } else if (node.type === import_utils9.AST_NODE_TYPES.FunctionExpression || node.type === import_utils9.AST_NODE_TYPES.FunctionDeclaration) {
-        if (node.body && node.body.type === import_utils9.AST_NODE_TYPES.BlockStatement) {
+      } else if (node.type === import_utils10.AST_NODE_TYPES.FunctionExpression || node.type === import_utils10.AST_NODE_TYPES.FunctionDeclaration) {
+        if (node.body && node.body.type === import_utils10.AST_NODE_TYPES.BlockStatement) {
           return hasJSXReturn(node.body);
         }
       }
       return false;
     }
     function isNamedType(node) {
-      return node.type === import_utils9.AST_NODE_TYPES.TSTypeReference;
+      return node.type === import_utils10.AST_NODE_TYPES.TSTypeReference;
     }
     function isAlreadyReadonly(node) {
-      if (node.type === import_utils9.AST_NODE_TYPES.TSTypeReference && node.typeName) {
-        if (node.typeName.type === import_utils9.AST_NODE_TYPES.Identifier && node.typeName.name === "Readonly") {
+      if (node.type === import_utils10.AST_NODE_TYPES.TSTypeReference && node.typeName) {
+        if (node.typeName.type === import_utils10.AST_NODE_TYPES.Identifier && node.typeName.name === "Readonly") {
           return true;
         }
       }
@@ -780,7 +831,7 @@ var enforceReadonlyComponentProps = createRule7({
         return;
       }
       const param = node.params[0];
-      if (param.type === import_utils9.AST_NODE_TYPES.Identifier && param.typeAnnotation) {
+      if (param.type === import_utils10.AST_NODE_TYPES.Identifier && param.typeAnnotation) {
         const { typeAnnotation } = param.typeAnnotation;
         if (isNamedType(typeAnnotation) && !isAlreadyReadonly(typeAnnotation)) {
           const { sourceCode } = context;
@@ -805,8 +856,8 @@ var enforceReadonlyComponentProps = createRule7({
 var enforce_readonly_component_props_default = enforceReadonlyComponentProps;
 // src/rules/enforce-render-naming.ts
-var import_utils10 = require("@typescript-eslint/utils");
-var createRule8 = import_utils10.ESLintUtils.RuleCreator(
+var import_utils11 = require("@typescript-eslint/utils");
+var createRule9 = import_utils11.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var ARRAY_RETURNING_METHODS = /* @__PURE__ */ new Set(["map", "flatMap", "filter"]);
@@ -821,20 +872,20 @@ function hasRenderPrefix(name) {
   return nextChar === nextChar.toUpperCase() && nextChar !== nextChar.toLowerCase();
 }
 function functionBodyReturnsJsx(body) {
-  if (body.type === import_utils10.AST_NODE_TYPES.JSXElement || body.type === import_utils10.AST_NODE_TYPES.JSXFragment) {
+  if (body.type === import_utils11.AST_NODE_TYPES.JSXElement || body.type === import_utils11.AST_NODE_TYPES.JSXFragment) {
     return true;
   }
-  if (body.type === import_utils10.AST_NODE_TYPES.ConditionalExpression) {
+  if (body.type === import_utils11.AST_NODE_TYPES.ConditionalExpression) {
     return isJsxProducingExpression(body.consequent) || isJsxProducingExpression(body.alternate);
   }
-  if (body.type === import_utils10.AST_NODE_TYPES.LogicalExpression) {
+  if (body.type === import_utils11.AST_NODE_TYPES.LogicalExpression) {
     return isJsxProducingExpression(body.right);
   }
-  if (body.type !== import_utils10.AST_NODE_TYPES.BlockStatement) {
+  if (body.type !== import_utils11.AST_NODE_TYPES.BlockStatement) {
     return false;
   }
   for (const statement of body.body) {
-    if (statement.type === import_utils10.AST_NODE_TYPES.ReturnStatement && statement.argument) {
+    if (statement.type === import_utils11.AST_NODE_TYPES.ReturnStatement && statement.argument) {
       if (isJsxProducingExpression(statement.argument)) {
         return true;
       }
@@ -843,35 +894,35 @@ function functionBodyReturnsJsx(body) {
   return false;
 }
 function isJsxProducingExpression(node) {
-  if (node.type === import_utils10.AST_NODE_TYPES.JSXElement || node.type === import_utils10.AST_NODE_TYPES.JSXFragment) {
+  if (node.type === import_utils11.AST_NODE_TYPES.JSXElement || node.type === import_utils11.AST_NODE_TYPES.JSXFragment) {
     return true;
   }
-  if (node.type === import_utils10.AST_NODE_TYPES.ConditionalExpression) {
+  if (node.type === import_utils11.AST_NODE_TYPES.ConditionalExpression) {
     return isJsxProducingExpression(node.consequent) || isJsxProducingExpression(node.alternate);
   }
-  if (node.type === import_utils10.AST_NODE_TYPES.LogicalExpression) {
+  if (node.type === import_utils11.AST_NODE_TYPES.LogicalExpression) {
     return isJsxProducingExpression(node.right);
   }
-  if (node.type === import_utils10.AST_NODE_TYPES.ArrayExpression) {
+  if (node.type === import_utils11.AST_NODE_TYPES.ArrayExpression) {
     return node.elements.some((element) => {
-      if (!element || element.type === import_utils10.AST_NODE_TYPES.SpreadElement) {
+      if (!element || element.type === import_utils11.AST_NODE_TYPES.SpreadElement) {
         return false;
       }
       return isJsxProducingExpression(element);
     });
   }
-  if (node.type === import_utils10.AST_NODE_TYPES.ArrowFunctionExpression || node.type === import_utils10.AST_NODE_TYPES.FunctionExpression) {
+  if (node.type === import_utils11.AST_NODE_TYPES.ArrowFunctionExpression || node.type === import_utils11.AST_NODE_TYPES.FunctionExpression) {
     return functionBodyReturnsJsx(node.body);
   }
-  if (node.type === import_utils10.AST_NODE_TYPES.CallExpression) {
-    if (node.callee.type === import_utils10.AST_NODE_TYPES.MemberExpression && node.callee.property.type === import_utils10.AST_NODE_TYPES.Identifier && ARRAY_RETURNING_METHODS.has(node.callee.property.name)) {
+  if (node.type === import_utils11.AST_NODE_TYPES.CallExpression) {
+    if (node.callee.type === import_utils11.AST_NODE_TYPES.MemberExpression && node.callee.property.type === import_utils11.AST_NODE_TYPES.Identifier && ARRAY_RETURNING_METHODS.has(node.callee.property.name)) {
       const callback = node.arguments[0];
-      if (callback && (callback.type === import_utils10.AST_NODE_TYPES.ArrowFunctionExpression || callback.type === import_utils10.AST_NODE_TYPES.FunctionExpression)) {
+      if (callback && (callback.type === import_utils11.AST_NODE_TYPES.ArrowFunctionExpression || callback.type === import_utils11.AST_NODE_TYPES.FunctionExpression)) {
         return functionBodyReturnsJsx(callback.body);
       }
     }
   }
-  if (node.type === import_utils10.AST_NODE_TYPES.TSAsExpression || node.type === import_utils10.AST_NODE_TYPES.TSSatisfiesExpression) {
+  if (node.type === import_utils11.AST_NODE_TYPES.TSAsExpression || node.type === import_utils11.AST_NODE_TYPES.TSSatisfiesExpression) {
     return isJsxProducingExpression(node.expression);
   }
   return false;
@@ -880,16 +931,16 @@ function isPascalCase(name) {
   return /^[A-Z]/.test(name);
 }
 function isComponentFunction2(node) {
-  if (node.type === import_utils10.AST_NODE_TYPES.FunctionDeclaration && node.id && isPascalCase(node.id.name)) {
+  if (node.type === import_utils11.AST_NODE_TYPES.FunctionDeclaration && node.id && isPascalCase(node.id.name)) {
     return true;
   }
   const parent = node.parent;
-  if (parent?.type === import_utils10.AST_NODE_TYPES.VariableDeclarator && parent.id.type === import_utils10.AST_NODE_TYPES.Identifier && isPascalCase(parent.id.name)) {
+  if (parent?.type === import_utils11.AST_NODE_TYPES.VariableDeclarator && parent.id.type === import_utils11.AST_NODE_TYPES.Identifier && isPascalCase(parent.id.name)) {
     return true;
   }
   return false;
 }
-var enforceRenderNaming = createRule8({
+var enforceRenderNaming = createRule9({
   name: "enforce-render-naming",
   meta: {
     type: "problem",
@@ -929,7 +980,7 @@ var enforceRenderNaming = createRule8({
         if (!isInsideComponent()) {
           return;
         }
-        if (node.id.type !== import_utils10.AST_NODE_TYPES.Identifier) {
+        if (node.id.type !== import_utils11.AST_NODE_TYPES.Identifier) {
           return;
         }
         if (!node.init) {
@@ -955,8 +1006,8 @@ var enforceRenderNaming = createRule8({
 var enforce_render_naming_default = enforceRenderNaming;
 // src/rules/enforce-service-naming.ts
-var import_utils12 = require("@typescript-eslint/utils");
-var createRule9 = import_utils12.ESLintUtils.RuleCreator(
+var import_utils13 = require("@typescript-eslint/utils");
+var createRule10 = import_utils13.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var BANNED_PREFIXES = {
@@ -965,7 +1016,7 @@ var BANNED_PREFIXES = {
   handle: ["create", "verify"],
   set: ["update", "save", "patch"]
 };
-var enforceServiceNaming = createRule9({
+var enforceServiceNaming = createRule10({
   name: "enforce-service-naming",
   meta: {
     type: "suggestion",
@@ -1008,12 +1059,12 @@ var enforceServiceNaming = createRule9({
     };
     return {
       ExportNamedDeclaration(node) {
-        if (node.declaration?.type === import_utils12.AST_NODE_TYPES.FunctionDeclaration && node.declaration.id) {
+        if (node.declaration?.type === import_utils13.AST_NODE_TYPES.FunctionDeclaration && node.declaration.id) {
           checkExportedFunction(node.declaration, node.declaration.id);
         }
-        if (node.declaration?.type === import_utils12.AST_NODE_TYPES.VariableDeclaration) {
+        if (node.declaration?.type === import_utils13.AST_NODE_TYPES.VariableDeclaration) {
           node.declaration.declarations.forEach((declarator) => {
-            if (declarator.id.type === import_utils12.AST_NODE_TYPES.Identifier && declarator.init?.type === import_utils12.AST_NODE_TYPES.ArrowFunctionExpression) {
+            if (declarator.id.type === import_utils13.AST_NODE_TYPES.Identifier && declarator.init?.type === import_utils13.AST_NODE_TYPES.ArrowFunctionExpression) {
               checkExportedFunction(declarator.init, declarator.id);
             }
           });
@@ -1024,12 +1075,52 @@ var enforceServiceNaming = createRule9({
 });
 var enforce_service_naming_default = enforceServiceNaming;
+// src/rules/enforce-test-filename.ts
+var import_path4 = __toESM(require("path"), 1);
+var import_utils14 = require("@typescript-eslint/utils");
+var createRule11 = import_utils14.ESLintUtils.RuleCreator(
+  (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
+);
+var TEST_GLOBALS = /* @__PURE__ */ new Set(["describe", "it", "test", "beforeEach", "beforeAll", "afterEach", "afterAll"]);
+var enforceTestFilename = createRule11({
+  name: "enforce-test-filename",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Enforce that files containing test code are named *.test.ts or *.test.tsx"
+    },
+    messages: {
+      requireTestFilename: "Files containing test code must be named *.test.ts or *.test.tsx."
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    const basename2 = import_path4.default.basename(context.filename);
+    const isTestFile = basename2.endsWith(".test.ts") || basename2.endsWith(".test.tsx");
+    if (isTestFile) return {};
+    function isTestGlobalCall(node) {
+      return node.callee.type === import_utils14.AST_NODE_TYPES.Identifier && TEST_GLOBALS.has(node.callee.name);
+    }
+    let reported = false;
+    return {
+      CallExpression(node) {
+        if (reported) return;
+        if (!isTestGlobalCall(node)) return;
+        reported = true;
+        context.report({ node, messageId: "requireTestFilename" });
+      }
+    };
+  }
+});
+var enforce_test_filename_default = enforceTestFilename;
 // src/rules/enforce-sorted-destructuring.ts
-var import_utils13 = require("@typescript-eslint/utils");
-var createRule10 = import_utils13.ESLintUtils.RuleCreator(
+var import_utils15 = require("@typescript-eslint/utils");
+var createRule12 = import_utils15.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var enforceSortedDestructuring = createRule10({
+var enforceSortedDestructuring = createRule12({
   name: "enforce-sorted-destructuring",
   meta: {
     type: "suggestion",
@@ -1045,19 +1136,19 @@ var enforceSortedDestructuring = createRule10({
   defaultOptions: [],
   create(context) {
     function getPropertyName(property) {
-      if (property.type === import_utils13.AST_NODE_TYPES.RestElement) {
+      if (property.type === import_utils15.AST_NODE_TYPES.RestElement) {
         return null;
       }
-      if (property.key.type === import_utils13.AST_NODE_TYPES.Identifier) {
+      if (property.key.type === import_utils15.AST_NODE_TYPES.Identifier) {
         return property.key.name;
       }
       return null;
     }
     function hasDefaultValue(property) {
-      return property.value.type === import_utils13.AST_NODE_TYPES.AssignmentPattern && Boolean(property.value.right);
+      return property.value.type === import_utils15.AST_NODE_TYPES.AssignmentPattern && Boolean(property.value.right);
     }
     function checkVariableDeclarator(node) {
-      if (node.id.type !== import_utils13.AST_NODE_TYPES.ObjectPattern) {
+      if (node.id.type !== import_utils15.AST_NODE_TYPES.ObjectPattern) {
         return;
       }
       const { properties } = node.id;
@@ -1065,7 +1156,7 @@ var enforceSortedDestructuring = createRule10({
         return;
       }
       const propertyInfo = properties.map((prop) => {
-        if (prop.type === import_utils13.AST_NODE_TYPES.RestElement) {
+        if (prop.type === import_utils15.AST_NODE_TYPES.RestElement) {
           return null;
         }
         return {
@@ -1104,20 +1195,20 @@ var enforceSortedDestructuring = createRule10({
 var enforce_sorted_destructuring_default = enforceSortedDestructuring;
 // src/rules/enforce-type-declaration-order.ts
-var import_utils14 = require("@typescript-eslint/utils");
-var createRule11 = import_utils14.ESLintUtils.RuleCreator(
+var import_utils16 = require("@typescript-eslint/utils");
+var createRule13 = import_utils16.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 function getTypeDeclarationName(node) {
-  if (node.type === import_utils14.AST_NODE_TYPES.TSInterfaceDeclaration && node.id.type === import_utils14.AST_NODE_TYPES.Identifier) {
+  if (node.type === import_utils16.AST_NODE_TYPES.TSInterfaceDeclaration && node.id.type === import_utils16.AST_NODE_TYPES.Identifier) {
     return { name: node.id.name, position: node.range[0] };
   }
-  if (node.type === import_utils14.AST_NODE_TYPES.TSTypeAliasDeclaration && node.id.type === import_utils14.AST_NODE_TYPES.Identifier) {
+  if (node.type === import_utils16.AST_NODE_TYPES.TSTypeAliasDeclaration && node.id.type === import_utils16.AST_NODE_TYPES.Identifier) {
     return { name: node.id.name, position: node.range[0] };
   }
   return null;
 }
-var enforceTypeDeclarationOrder = createRule11({
+var enforceTypeDeclarationOrder = createRule13({
   name: "enforce-type-declaration-order",
   meta: {
     type: "suggestion",
@@ -1148,7 +1239,7 @@ var enforceTypeDeclarationOrder = createRule11({
         }
       },
       "TSPropertySignature TSTypeReference": function checkTypeReference(node) {
-        if (node.typeName.type !== import_utils14.AST_NODE_TYPES.Identifier) {
+        if (node.typeName.type !== import_utils16.AST_NODE_TYPES.Identifier) {
           return;
         }
         const referencedName = node.typeName.name;
@@ -1185,8 +1276,8 @@ var enforceTypeDeclarationOrder = createRule11({
 var enforce_type_declaration_order_default = enforceTypeDeclarationOrder;
 // src/rules/index-export-only.ts
-var import_utils15 = require("@typescript-eslint/utils");
-var createRule12 = import_utils15.ESLintUtils.RuleCreator(
+var import_utils17 = require("@typescript-eslint/utils");
+var createRule14 = import_utils17.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var isIndexFile = (filename) => getBaseName(filename) === "index";
@@ -1194,26 +1285,26 @@ var isAllowedExportNamed = (node) => {
   if (!node.declaration) {
     return true;
   }
-  return node.declaration.type === import_utils15.AST_NODE_TYPES.TSTypeAliasDeclaration || node.declaration.type === import_utils15.AST_NODE_TYPES.TSInterfaceDeclaration;
+  return node.declaration.type === import_utils17.AST_NODE_TYPES.TSTypeAliasDeclaration || node.declaration.type === import_utils17.AST_NODE_TYPES.TSInterfaceDeclaration;
 };
-var isAllowedExportDefault = (node) => node.declaration.type === import_utils15.AST_NODE_TYPES.Identifier;
+var isAllowedExportDefault = (node) => node.declaration.type === import_utils17.AST_NODE_TYPES.Identifier;
 var isAllowedTopLevel = (node) => {
   switch (node.type) {
-    case import_utils15.AST_NODE_TYPES.ImportDeclaration:
-    case import_utils15.AST_NODE_TYPES.ExportAllDeclaration:
-    case import_utils15.AST_NODE_TYPES.TSTypeAliasDeclaration:
-    case import_utils15.AST_NODE_TYPES.TSInterfaceDeclaration:
-    case import_utils15.AST_NODE_TYPES.TSImportEqualsDeclaration:
+    case import_utils17.AST_NODE_TYPES.ImportDeclaration:
+    case import_utils17.AST_NODE_TYPES.ExportAllDeclaration:
+    case import_utils17.AST_NODE_TYPES.TSTypeAliasDeclaration:
+    case import_utils17.AST_NODE_TYPES.TSInterfaceDeclaration:
+    case import_utils17.AST_NODE_TYPES.TSImportEqualsDeclaration:
       return true;
-    case import_utils15.AST_NODE_TYPES.ExportNamedDeclaration:
+    case import_utils17.AST_NODE_TYPES.ExportNamedDeclaration:
       return isAllowedExportNamed(node);
-    case import_utils15.AST_NODE_TYPES.ExportDefaultDeclaration:
+    case import_utils17.AST_NODE_TYPES.ExportDefaultDeclaration:
       return isAllowedExportDefault(node);
     default:
       return false;
   }
 };
-var indexExportOnly = createRule12({
+var indexExportOnly = createRule14({
   name: "index-export-only",
   meta: {
     type: "suggestion",
@@ -1247,11 +1338,11 @@ var indexExportOnly = createRule12({
 var index_export_only_default = indexExportOnly;
 // src/rules/jsx-newline-between-elements.ts
-var import_utils17 = require("@typescript-eslint/utils");
-var createRule13 = import_utils17.ESLintUtils.RuleCreator(
+var import_utils19 = require("@typescript-eslint/utils");
+var createRule15 = import_utils19.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var jsxNewlineBetweenElements = createRule13({
+var jsxNewlineBetweenElements = createRule15({
   name: "jsx-newline-between-elements",
   meta: {
     type: "layout",
@@ -1269,7 +1360,7 @@ var jsxNewlineBetweenElements = createRule13({
   create(context) {
     const { sourceCode } = context;
     function isSignificantJSXChild(node) {
-      return node.type === import_utils17.AST_NODE_TYPES.JSXElement || node.type === import_utils17.AST_NODE_TYPES.JSXFragment || node.type === import_utils17.AST_NODE_TYPES.JSXExpressionContainer;
+      return node.type === import_utils19.AST_NODE_TYPES.JSXElement || node.type === import_utils19.AST_NODE_TYPES.JSXFragment || node.type === import_utils19.AST_NODE_TYPES.JSXExpressionContainer;
     }
     function isMultiLine(node) {
       return node.loc.start.line !== node.loc.end.line;
@@ -1319,18 +1410,18 @@ var jsxNewlineBetweenElements = createRule13({
 var jsx_newline_between_elements_default = jsxNewlineBetweenElements;
 // src/rules/jsx-no-data-array.ts
-var import_utils18 = require("@typescript-eslint/utils");
-var createRule14 = import_utils18.ESLintUtils.RuleCreator(
+var import_utils20 = require("@typescript-eslint/utils");
+var createRule16 = import_utils20.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 function isObjectLikeElement(node) {
   if (!node) {
     return false;
   }
-  if (node.type === import_utils18.AST_NODE_TYPES.ObjectExpression) {
+  if (node.type === import_utils20.AST_NODE_TYPES.ObjectExpression) {
     return true;
   }
-  if (node.type === import_utils18.AST_NODE_TYPES.TSAsExpression || node.type === import_utils18.AST_NODE_TYPES.TSSatisfiesExpression) {
+  if (node.type === import_utils20.AST_NODE_TYPES.TSAsExpression || node.type === import_utils20.AST_NODE_TYPES.TSSatisfiesExpression) {
     return isObjectLikeElement(node.expression);
   }
   return false;
@@ -1339,15 +1430,15 @@ function getArrayInitializer(init) {
   if (!init) {
     return null;
   }
-  if (init.type === import_utils18.AST_NODE_TYPES.ArrayExpression) {
+  if (init.type === import_utils20.AST_NODE_TYPES.ArrayExpression) {
     return init;
   }
-  if (init.type === import_utils18.AST_NODE_TYPES.TSAsExpression || init.type === import_utils18.AST_NODE_TYPES.TSSatisfiesExpression) {
+  if (init.type === import_utils20.AST_NODE_TYPES.TSAsExpression || init.type === import_utils20.AST_NODE_TYPES.TSSatisfiesExpression) {
     return getArrayInitializer(init.expression);
   }
   return null;
 }
-var jsxNoDataArray = createRule14({
+var jsxNoDataArray = createRule16({
   name: "jsx-no-data-array",
   meta: {
     type: "problem",
@@ -1376,7 +1467,7 @@ var jsxNoDataArray = createRule14({
         if (!hasObjectElement) {
           return;
         }
-        const name = node.id.type === import_utils18.AST_NODE_TYPES.Identifier ? node.id.name : "<destructured>";
+        const name = node.id.type === import_utils20.AST_NODE_TYPES.Identifier ? node.id.name : "<destructured>";
         context.report({
           node,
           messageId: "noDataArray",
@@ -1392,7 +1483,7 @@ var jsxNoDataArray = createRule14({
         if (!hasObjectElement) {
           return;
         }
-        const name = node.id.type === import_utils18.AST_NODE_TYPES.Identifier ? node.id.name : "<destructured>";
+        const name = node.id.type === import_utils20.AST_NODE_TYPES.Identifier ? node.id.name : "<destructured>";
         context.report({
           node,
           messageId: "noDataArray",
@@ -1405,15 +1496,15 @@ var jsxNoDataArray = createRule14({
 var jsx_no_data_array_default = jsxNoDataArray;
 // src/rules/jsx-no-data-object.ts
-var import_utils20 = require("@typescript-eslint/utils");
-var createRule15 = import_utils20.ESLintUtils.RuleCreator(
+var import_utils22 = require("@typescript-eslint/utils");
+var createRule17 = import_utils22.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 function unwrapAssertion(node) {
   if (!node) {
     return null;
   }
-  if (node.type === import_utils20.AST_NODE_TYPES.TSAsExpression || node.type === import_utils20.AST_NODE_TYPES.TSSatisfiesExpression) {
+  if (node.type === import_utils22.AST_NODE_TYPES.TSAsExpression || node.type === import_utils22.AST_NODE_TYPES.TSSatisfiesExpression) {
     return unwrapAssertion(node.expression);
   }
   return node;
@@ -1423,26 +1514,26 @@ function isNestedValue(value) {
   if (!unwrapped) {
     return false;
   }
-  if (unwrapped.type === import_utils20.AST_NODE_TYPES.ObjectExpression) {
+  if (unwrapped.type === import_utils22.AST_NODE_TYPES.ObjectExpression) {
     return true;
   }
-  if (unwrapped.type === import_utils20.AST_NODE_TYPES.ArrayExpression) {
+  if (unwrapped.type === import_utils22.AST_NODE_TYPES.ArrayExpression) {
     return unwrapped.elements.some((element) => {
-      if (!element || element.type === import_utils20.AST_NODE_TYPES.SpreadElement) {
+      if (!element || element.type === import_utils22.AST_NODE_TYPES.SpreadElement) {
         return false;
       }
       const inner = unwrapAssertion(element);
-      return inner?.type === import_utils20.AST_NODE_TYPES.ObjectExpression || inner?.type === import_utils20.AST_NODE_TYPES.ArrayExpression;
+      return inner?.type === import_utils22.AST_NODE_TYPES.ObjectExpression || inner?.type === import_utils22.AST_NODE_TYPES.ArrayExpression;
     });
   }
   return false;
 }
 function hasNestedProperty(object) {
   return object.properties.some((property) => {
-    if (property.type !== import_utils20.AST_NODE_TYPES.Property) {
+    if (property.type !== import_utils22.AST_NODE_TYPES.Property) {
       return false;
     }
-    if (property.value.type === import_utils20.AST_NODE_TYPES.AssignmentPattern) {
+    if (property.value.type === import_utils22.AST_NODE_TYPES.AssignmentPattern) {
       return false;
     }
     return isNestedValue(property.value);
@@ -1453,12 +1544,12 @@ function getObjectInitializer(init) {
   if (!unwrapped) {
     return null;
   }
-  if (unwrapped.type === import_utils20.AST_NODE_TYPES.ObjectExpression) {
+  if (unwrapped.type === import_utils22.AST_NODE_TYPES.ObjectExpression) {
     return unwrapped;
   }
   return null;
 }
-var jsxNoDataObject = createRule15({
+var jsxNoDataObject = createRule17({
   name: "jsx-no-data-object",
   meta: {
     type: "problem",
@@ -1485,7 +1576,7 @@ var jsxNoDataObject = createRule15({
       if (!hasNestedProperty(objectInit)) {
         return;
       }
-      const name = node.id.type === import_utils20.AST_NODE_TYPES.Identifier ? node.id.name : "<destructured>";
+      const name = node.id.type === import_utils22.AST_NODE_TYPES.Identifier ? node.id.name : "<destructured>";
       context.report({
         node,
         messageId: "noDataObject",
@@ -1501,11 +1592,11 @@ var jsxNoDataObject = createRule15({
 var jsx_no_data_object_default = jsxNoDataObject;
 // src/rules/jsx-no-inline-object-prop.ts
-var import_utils22 = require("@typescript-eslint/utils");
-var createRule16 = import_utils22.ESLintUtils.RuleCreator(
+var import_utils24 = require("@typescript-eslint/utils");
+var createRule18 = import_utils24.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var jsxNoInlineObjectProp = createRule16({
+var jsxNoInlineObjectProp = createRule18({
   name: "jsx-no-inline-object-prop",
   meta: {
     type: "suggestion",
@@ -1521,7 +1612,7 @@ var jsxNoInlineObjectProp = createRule16({
   create(context) {
     return {
       JSXAttribute(node) {
-        if (node.value?.type === import_utils22.AST_NODE_TYPES.JSXExpressionContainer && node.value.expression.type === import_utils22.AST_NODE_TYPES.ObjectExpression) {
+        if (node.value?.type === import_utils24.AST_NODE_TYPES.JSXExpressionContainer && node.value.expression.type === import_utils24.AST_NODE_TYPES.ObjectExpression) {
           context.report({
             node: node.value,
             messageId: "noInlineObject"
@@ -1534,17 +1625,17 @@ var jsxNoInlineObjectProp = createRule16({
 var jsx_no_inline_object_prop_default = jsxNoInlineObjectProp;
 // src/rules/jsx-no-newline-single-line-elements.ts
-var import_utils23 = require("@typescript-eslint/utils");
-var createRule17 = import_utils23.ESLintUtils.RuleCreator(
+var import_utils25 = require("@typescript-eslint/utils");
+var createRule19 = import_utils25.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 function isJSXElementOrFragment(node) {
-  return node.type === import_utils23.AST_NODE_TYPES.JSXElement || node.type === import_utils23.AST_NODE_TYPES.JSXFragment;
+  return node.type === import_utils25.AST_NODE_TYPES.JSXElement || node.type === import_utils25.AST_NODE_TYPES.JSXFragment;
 }
 function isSingleLine(node) {
   return node.loc.start.line === node.loc.end.line;
 }
-var jsxNoNewlineSingleLineElements = createRule17({
+var jsxNoNewlineSingleLineElements = createRule19({
   name: "jsx-no-newline-single-line-elements",
   meta: {
     type: "layout",
@@ -1562,7 +1653,7 @@ var jsxNoNewlineSingleLineElements = createRule17({
     const { sourceCode } = context;
     function checkSiblings(children) {
       const nonWhitespace = children.filter(
-        (child) => !(child.type === import_utils23.AST_NODE_TYPES.JSXText && child.value.trim() === "")
+        (child) => !(child.type === import_utils25.AST_NODE_TYPES.JSXText && child.value.trim() === "")
       );
       nonWhitespace.forEach((next, index) => {
         if (index === 0) {
@@ -1613,11 +1704,11 @@ ${indent}`);
 var jsx_no_newline_single_line_elements_default = jsxNoNewlineSingleLineElements;
 // src/rules/jsx-no-non-component-function.ts
-var import_utils24 = require("@typescript-eslint/utils");
-var createRule18 = import_utils24.ESLintUtils.RuleCreator(
+var import_utils26 = require("@typescript-eslint/utils");
+var createRule20 = import_utils26.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var jsxNoNonComponentFunction = createRule18({
+var jsxNoNonComponentFunction = createRule20({
   name: "jsx-no-non-component-function",
   meta: {
     type: "problem",
@@ -1637,13 +1728,13 @@ var jsxNoNonComponentFunction = createRule18({
       return {};
     }
     function isReactComponent2(node) {
-      const functionName = node.type === import_utils24.AST_NODE_TYPES.FunctionDeclaration && node.id ? node.id.name : null;
+      const functionName = node.type === import_utils26.AST_NODE_TYPES.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 === import_utils24.AST_NODE_TYPES.TSTypeReference && returnTypeNode.typeName.type === import_utils24.AST_NODE_TYPES.Identifier) {
+        if (returnTypeNode.type === import_utils26.AST_NODE_TYPES.TSTypeReference && returnTypeNode.typeName.type === import_utils26.AST_NODE_TYPES.Identifier) {
           const typeName = returnTypeNode.typeName.name;
           if (typeName === "JSX" || typeName === "ReactElement" || typeName === "ReactNode") {
             return true;
@@ -1660,13 +1751,13 @@ var jsxNoNonComponentFunction = createRule18({
       if (!parent) {
         return;
       }
-      if (parent.type === import_utils24.AST_NODE_TYPES.ExportDefaultDeclaration || parent.type === import_utils24.AST_NODE_TYPES.ExportNamedDeclaration) {
+      if (parent.type === import_utils26.AST_NODE_TYPES.ExportDefaultDeclaration || parent.type === import_utils26.AST_NODE_TYPES.ExportNamedDeclaration) {
         return;
       }
-      if (declaratorNode?.parent?.parent?.type === import_utils24.AST_NODE_TYPES.ExportNamedDeclaration) {
+      if (declaratorNode?.parent?.parent?.type === import_utils26.AST_NODE_TYPES.ExportNamedDeclaration) {
         return;
       }
-      if (declaratorNode?.id.type === import_utils24.AST_NODE_TYPES.Identifier) {
+      if (declaratorNode?.id.type === import_utils26.AST_NODE_TYPES.Identifier) {
         const varName = declaratorNode.id.name;
         if (/^[A-Z]/.test(varName)) {
           return;
@@ -1691,13 +1782,13 @@ var jsxNoNonComponentFunction = createRule18({
 var jsx_no_non_component_function_default = jsxNoNonComponentFunction;
 // src/rules/jsx-no-sub-interface.ts
-var import_utils26 = require("@typescript-eslint/utils");
-var createRule19 = import_utils26.ESLintUtils.RuleCreator(
+var import_utils28 = require("@typescript-eslint/utils");
+var createRule21 = import_utils28.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var PROPS_WRAPPER_NAMES = /* @__PURE__ */ new Set(["Readonly", "Required", "Partial", "PropsWithChildren", "NoInfer"]);
 function unwrapWrapperType(node) {
-  if (node.type === import_utils26.AST_NODE_TYPES.TSTypeReference && node.typeName.type === import_utils26.AST_NODE_TYPES.Identifier && PROPS_WRAPPER_NAMES.has(node.typeName.name) && node.typeArguments && node.typeArguments.params.length > 0) {
+  if (node.type === import_utils28.AST_NODE_TYPES.TSTypeReference && node.typeName.type === import_utils28.AST_NODE_TYPES.Identifier && PROPS_WRAPPER_NAMES.has(node.typeName.name) && node.typeArguments && node.typeArguments.params.length > 0) {
     return unwrapWrapperType(node.typeArguments.params[0]);
   }
   return node;
@@ -1707,7 +1798,7 @@ function getMainTypeName(typeNode) {
     return null;
   }
   const unwrapped = unwrapWrapperType(typeNode);
-  if (unwrapped.type === import_utils26.AST_NODE_TYPES.TSTypeReference && unwrapped.typeName.type === import_utils26.AST_NODE_TYPES.Identifier) {
+  if (unwrapped.type === import_utils28.AST_NODE_TYPES.TSTypeReference && unwrapped.typeName.type === import_utils28.AST_NODE_TYPES.Identifier) {
     return unwrapped.typeName.name;
   }
   return null;
@@ -1726,15 +1817,15 @@ function isPascalCase2(name) {
   return /^[A-Z]/.test(name);
 }
 function getDeclarationFromExportWrapper(node) {
-  if (node.type === import_utils26.AST_NODE_TYPES.ExportNamedDeclaration && node.declaration) {
+  if (node.type === import_utils28.AST_NODE_TYPES.ExportNamedDeclaration && node.declaration) {
     return node.declaration;
   }
-  if (node.type === import_utils26.AST_NODE_TYPES.ExportDefaultDeclaration) {
+  if (node.type === import_utils28.AST_NODE_TYPES.ExportDefaultDeclaration) {
     return node.declaration;
   }
   return node;
 }
-var jsxNoSubInterface = createRule19({
+var jsxNoSubInterface = createRule21({
   name: "jsx-no-sub-interface",
   meta: {
     type: "problem",
@@ -1760,7 +1851,7 @@ var jsxNoSubInterface = createRule19({
         let componentCount = 0;
         for (const statement of programNode.body) {
           const declaration = getDeclarationFromExportWrapper(statement);
-          if (declaration.type === import_utils26.AST_NODE_TYPES.FunctionDeclaration && declaration.id && isPascalCase2(declaration.id.name)) {
+          if (declaration.type === import_utils28.AST_NODE_TYPES.FunctionDeclaration && declaration.id && isPascalCase2(declaration.id.name)) {
             componentCount += 1;
             const mainType = getComponentMainTypeName(declaration);
             if (mainType) {
@@ -1768,16 +1859,16 @@ var jsxNoSubInterface = createRule19({
             }
             continue;
           }
-          if (declaration.type === import_utils26.AST_NODE_TYPES.VariableDeclaration) {
+          if (declaration.type === import_utils28.AST_NODE_TYPES.VariableDeclaration) {
             for (const declarator of declaration.declarations) {
-              if (declarator.id.type !== import_utils26.AST_NODE_TYPES.Identifier) {
+              if (declarator.id.type !== import_utils28.AST_NODE_TYPES.Identifier) {
                 continue;
               }
               if (!isPascalCase2(declarator.id.name)) {
                 continue;
               }
               const init = declarator.init;
-              if (init && (init.type === import_utils26.AST_NODE_TYPES.ArrowFunctionExpression || init.type === import_utils26.AST_NODE_TYPES.FunctionExpression)) {
+              if (init && (init.type === import_utils28.AST_NODE_TYPES.ArrowFunctionExpression || init.type === import_utils28.AST_NODE_TYPES.FunctionExpression)) {
                 componentCount += 1;
                 const mainType = getComponentMainTypeName(init);
                 if (mainType) {
@@ -1787,11 +1878,11 @@ var jsxNoSubInterface = createRule19({
             }
             continue;
           }
-          if (declaration.type === import_utils26.AST_NODE_TYPES.TSInterfaceDeclaration) {
+          if (declaration.type === import_utils28.AST_NODE_TYPES.TSInterfaceDeclaration) {
             typeDeclarations.push({ name: declaration.id.name, node: declaration });
             continue;
           }
-          if (declaration.type === import_utils26.AST_NODE_TYPES.TSTypeAliasDeclaration) {
+          if (declaration.type === import_utils28.AST_NODE_TYPES.TSTypeAliasDeclaration) {
             typeDeclarations.push({ name: declaration.id.name, node: declaration });
             continue;
           }
@@ -1816,20 +1907,20 @@ var jsxNoSubInterface = createRule19({
 var jsx_no_sub_interface_default = jsxNoSubInterface;
 // src/rules/jsx-no-ternary-null.ts
-var import_utils28 = require("@typescript-eslint/utils");
-var createRule20 = import_utils28.ESLintUtils.RuleCreator(
+var import_utils30 = require("@typescript-eslint/utils");
+var createRule22 = import_utils30.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 function isNullOrUndefined(node) {
-  if (node.type === import_utils28.AST_NODE_TYPES.Literal && node.value === null) {
+  if (node.type === import_utils30.AST_NODE_TYPES.Literal && node.value === null) {
     return true;
   }
-  if (node.type === import_utils28.AST_NODE_TYPES.Identifier && node.name === "undefined") {
+  if (node.type === import_utils30.AST_NODE_TYPES.Identifier && node.name === "undefined") {
     return true;
   }
   return false;
 }
-var jsxNoTernaryNull = createRule20({
+var jsxNoTernaryNull = createRule22({
   name: "jsx-no-ternary-null",
   meta: {
     type: "suggestion",
@@ -1847,7 +1938,7 @@ var jsxNoTernaryNull = createRule20({
     return {
       JSXExpressionContainer(node) {
         const { expression } = node;
-        if (expression.type !== import_utils28.AST_NODE_TYPES.ConditionalExpression) {
+        if (expression.type !== import_utils30.AST_NODE_TYPES.ConditionalExpression) {
           return;
         }
         const { test, consequent, alternate } = expression;
@@ -1879,11 +1970,11 @@ var jsxNoTernaryNull = createRule20({
 var jsx_no_ternary_null_default = jsxNoTernaryNull;
 // src/rules/jsx-no-variable-in-callback.ts
-var import_utils29 = require("@typescript-eslint/utils");
-var createRule21 = import_utils29.ESLintUtils.RuleCreator(
+var import_utils31 = require("@typescript-eslint/utils");
+var createRule23 = import_utils31.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var jsxNoVariableInCallback = createRule21({
+var jsxNoVariableInCallback = createRule23({
   name: "jsx-no-variable-in-callback",
   meta: {
     type: "suggestion",
@@ -1900,7 +1991,7 @@ var jsxNoVariableInCallback = createRule21({
     function isInsideJSX(node) {
       let current = node.parent;
       while (current) {
-        if (current.type === import_utils29.AST_NODE_TYPES.JSXElement || current.type === import_utils29.AST_NODE_TYPES.JSXFragment) {
+        if (current.type === import_utils31.AST_NODE_TYPES.JSXElement || current.type === import_utils31.AST_NODE_TYPES.JSXFragment) {
           return true;
         }
         current = current.parent;
@@ -1914,11 +2005,11 @@ var jsxNoVariableInCallback = createRule21({
       if (!isInsideJSX(node)) {
         return false;
       }
-      if (node.parent.type === import_utils29.AST_NODE_TYPES.CallExpression || node.parent.type === import_utils29.AST_NODE_TYPES.JSXExpressionContainer) {
+      if (node.parent.type === import_utils31.AST_NODE_TYPES.CallExpression || node.parent.type === import_utils31.AST_NODE_TYPES.JSXExpressionContainer) {
         return true;
       }
-      if (node.parent.type === import_utils29.AST_NODE_TYPES.ArrayExpression && node.parent.parent) {
-        if (node.parent.parent.type === import_utils29.AST_NODE_TYPES.CallExpression || node.parent.parent.type === import_utils29.AST_NODE_TYPES.JSXExpressionContainer) {
+      if (node.parent.type === import_utils31.AST_NODE_TYPES.ArrayExpression && node.parent.parent) {
+        if (node.parent.parent.type === import_utils31.AST_NODE_TYPES.CallExpression || node.parent.parent.type === import_utils31.AST_NODE_TYPES.JSXExpressionContainer) {
           return true;
         }
       }
@@ -1929,11 +2020,11 @@ var jsxNoVariableInCallback = createRule21({
         return;
       }
       const { body } = node;
-      if (body.type !== import_utils29.AST_NODE_TYPES.BlockStatement) {
+      if (body.type !== import_utils31.AST_NODE_TYPES.BlockStatement) {
         return;
       }
       body.body.forEach((statement) => {
-        if (statement.type === import_utils29.AST_NODE_TYPES.VariableDeclaration) {
+        if (statement.type === import_utils31.AST_NODE_TYPES.VariableDeclaration) {
           context.report({
             node: statement,
             messageId: "noVariableInCallback"
@@ -1950,11 +2041,11 @@ var jsxNoVariableInCallback = createRule21({
 var jsx_no_variable_in_callback_default = jsxNoVariableInCallback;
 // src/rules/jsx-require-suspense.ts
-var import_utils30 = require("@typescript-eslint/utils");
-var createRule22 = import_utils30.ESLintUtils.RuleCreator(
+var import_utils32 = require("@typescript-eslint/utils");
+var createRule24 = import_utils32.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var jsxRequireSuspense = createRule22({
+var jsxRequireSuspense = createRule24({
   name: "jsx-require-suspense",
   meta: {
     type: "problem",
@@ -1972,7 +2063,7 @@ var jsxRequireSuspense = createRule22({
     const isInsideSuspense = (node) => {
       let current = node.parent;
       while (current) {
-        if (current.type === import_utils30.AST_NODE_TYPES.JSXElement && current.openingElement.name.type === import_utils30.AST_NODE_TYPES.JSXIdentifier && current.openingElement.name.name === "Suspense") {
+        if (current.type === import_utils32.AST_NODE_TYPES.JSXElement && current.openingElement.name.type === import_utils32.AST_NODE_TYPES.JSXIdentifier && current.openingElement.name.name === "Suspense") {
           return true;
         }
         current = current.parent;
@@ -1981,16 +2072,16 @@ var jsxRequireSuspense = createRule22({
     };
     return {
       VariableDeclarator(node) {
-        if (node.id.type === import_utils30.AST_NODE_TYPES.Identifier && node.init?.type === import_utils30.AST_NODE_TYPES.CallExpression) {
+        if (node.id.type === import_utils32.AST_NODE_TYPES.Identifier && node.init?.type === import_utils32.AST_NODE_TYPES.CallExpression) {
           const { callee } = node.init;
-          const isLazyCall = callee.type === import_utils30.AST_NODE_TYPES.Identifier && callee.name === "lazy" || callee.type === import_utils30.AST_NODE_TYPES.MemberExpression && callee.object.type === import_utils30.AST_NODE_TYPES.Identifier && callee.object.name === "React" && callee.property.type === import_utils30.AST_NODE_TYPES.Identifier && callee.property.name === "lazy";
+          const isLazyCall = callee.type === import_utils32.AST_NODE_TYPES.Identifier && callee.name === "lazy" || callee.type === import_utils32.AST_NODE_TYPES.MemberExpression && callee.object.type === import_utils32.AST_NODE_TYPES.Identifier && callee.object.name === "React" && callee.property.type === import_utils32.AST_NODE_TYPES.Identifier && callee.property.name === "lazy";
           if (isLazyCall) {
             lazyComponents.add(node.id.name);
           }
         }
       },
       JSXOpeningElement(node) {
-        if (node.name.type === import_utils30.AST_NODE_TYPES.JSXIdentifier) {
+        if (node.name.type === import_utils32.AST_NODE_TYPES.JSXIdentifier) {
           const componentName = node.name.name;
           if (lazyComponents.has(componentName) && !isInsideSuspense(node)) {
             context.report({
@@ -2009,11 +2100,11 @@ var jsxRequireSuspense = createRule22({
 var jsx_require_suspense_default = jsxRequireSuspense;
 // src/rules/jsx-simple-props.ts
-var import_utils31 = require("@typescript-eslint/utils");
-var createRule23 = import_utils31.ESLintUtils.RuleCreator(
+var import_utils33 = require("@typescript-eslint/utils");
+var createRule25 = import_utils33.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var jsxSimpleProps = createRule23({
+var jsxSimpleProps = createRule25({
   name: "jsx-simple-props",
   meta: {
     type: "suggestion",
@@ -2028,25 +2119,25 @@ var jsxSimpleProps = createRule23({
   defaultOptions: [],
   create(context) {
     const allowedExpressionTypes = /* @__PURE__ */ new Set([
-      import_utils31.AST_NODE_TYPES.Identifier,
-      import_utils31.AST_NODE_TYPES.Literal,
-      import_utils31.AST_NODE_TYPES.JSXElement,
-      import_utils31.AST_NODE_TYPES.JSXFragment,
-      import_utils31.AST_NODE_TYPES.MemberExpression,
-      import_utils31.AST_NODE_TYPES.ArrowFunctionExpression,
-      import_utils31.AST_NODE_TYPES.FunctionExpression
+      import_utils33.AST_NODE_TYPES.Identifier,
+      import_utils33.AST_NODE_TYPES.Literal,
+      import_utils33.AST_NODE_TYPES.JSXElement,
+      import_utils33.AST_NODE_TYPES.JSXFragment,
+      import_utils33.AST_NODE_TYPES.MemberExpression,
+      import_utils33.AST_NODE_TYPES.ArrowFunctionExpression,
+      import_utils33.AST_NODE_TYPES.FunctionExpression
     ]);
     return {
       JSXAttribute(node) {
         if (!node.value) {
           return;
         }
-        if (node.value.type === import_utils31.AST_NODE_TYPES.Literal) {
+        if (node.value.type === import_utils33.AST_NODE_TYPES.Literal) {
           return;
         }
-        if (node.value.type === import_utils31.AST_NODE_TYPES.JSXExpressionContainer) {
+        if (node.value.type === import_utils33.AST_NODE_TYPES.JSXExpressionContainer) {
           const { expression } = node.value;
-          if (expression.type === import_utils31.AST_NODE_TYPES.JSXEmptyExpression) {
+          if (expression.type === import_utils33.AST_NODE_TYPES.JSXEmptyExpression) {
             return;
           }
           if (!allowedExpressionTypes.has(expression.type)) {
@@ -2063,8 +2154,8 @@ var jsxSimpleProps = createRule23({
 var jsx_simple_props_default = jsxSimpleProps;
 // src/rules/jsx-sort-props.ts
-var import_utils32 = require("@typescript-eslint/utils");
-var createRule24 = import_utils32.ESLintUtils.RuleCreator(
+var import_utils34 = require("@typescript-eslint/utils");
+var createRule26 = import_utils34.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var TYPE_GROUP = {
@@ -2078,15 +2169,15 @@ var TYPE_GROUP = {
   SHORTHAND: 8
 };
 var EXPRESSION_TYPE_TO_GROUP = /* @__PURE__ */ new Map([
-  [import_utils32.AST_NODE_TYPES.ObjectExpression, TYPE_GROUP.OBJECT_ARRAY],
-  [import_utils32.AST_NODE_TYPES.ArrayExpression, TYPE_GROUP.OBJECT_ARRAY],
-  [import_utils32.AST_NODE_TYPES.ArrowFunctionExpression, TYPE_GROUP.FUNCTION],
-  [import_utils32.AST_NODE_TYPES.FunctionExpression, TYPE_GROUP.FUNCTION],
-  [import_utils32.AST_NODE_TYPES.JSXElement, TYPE_GROUP.JSX],
-  [import_utils32.AST_NODE_TYPES.JSXFragment, TYPE_GROUP.JSX]
+  [import_utils34.AST_NODE_TYPES.ObjectExpression, TYPE_GROUP.OBJECT_ARRAY],
+  [import_utils34.AST_NODE_TYPES.ArrayExpression, TYPE_GROUP.OBJECT_ARRAY],
+  [import_utils34.AST_NODE_TYPES.ArrowFunctionExpression, TYPE_GROUP.FUNCTION],
+  [import_utils34.AST_NODE_TYPES.FunctionExpression, TYPE_GROUP.FUNCTION],
+  [import_utils34.AST_NODE_TYPES.JSXElement, TYPE_GROUP.JSX],
+  [import_utils34.AST_NODE_TYPES.JSXFragment, TYPE_GROUP.JSX]
 ]);
 function isHyphenatedName(node) {
-  return node.name.type === import_utils32.AST_NODE_TYPES.JSXIdentifier && node.name.name.includes("-");
+  return node.name.type === import_utils34.AST_NODE_TYPES.JSXIdentifier && node.name.name.includes("-");
 }
 function getStringGroup(node) {
   return isHyphenatedName(node) ? TYPE_GROUP.HYPHENATED_STRING : TYPE_GROUP.STRING;
@@ -2098,13 +2189,13 @@ function getLiteralValueGroup(value) {
   return TYPE_GROUP.NUMBER_BOOLEAN_NULL;
 }
 function getExpressionGroup(expression) {
-  if (expression.type === import_utils32.AST_NODE_TYPES.Literal) {
+  if (expression.type === import_utils34.AST_NODE_TYPES.Literal) {
     return getLiteralValueGroup(expression.value);
   }
-  if (expression.type === import_utils32.AST_NODE_TYPES.TemplateLiteral) {
+  if (expression.type === import_utils34.AST_NODE_TYPES.TemplateLiteral) {
     return null;
   }
-  if (expression.type === import_utils32.AST_NODE_TYPES.Identifier && expression.name === "undefined") {
+  if (expression.type === import_utils34.AST_NODE_TYPES.Identifier && expression.name === "undefined") {
     return TYPE_GROUP.NUMBER_BOOLEAN_NULL;
   }
   return EXPRESSION_TYPE_TO_GROUP.get(expression.type) ?? TYPE_GROUP.EXPRESSION;
@@ -2113,17 +2204,17 @@ function getTypeGroup(node) {
   if (node.value === null) {
     return TYPE_GROUP.SHORTHAND;
   }
-  if (node.value.type === import_utils32.AST_NODE_TYPES.Literal) {
+  if (node.value.type === import_utils34.AST_NODE_TYPES.Literal) {
     if (typeof node.value.value === "string") {
       return getStringGroup(node);
     }
     return TYPE_GROUP.NUMBER_BOOLEAN_NULL;
   }
-  if (node.value.type !== import_utils32.AST_NODE_TYPES.JSXExpressionContainer) {
+  if (node.value.type !== import_utils34.AST_NODE_TYPES.JSXExpressionContainer) {
     return null;
   }
   const { expression } = node.value;
-  if (expression.type === import_utils32.AST_NODE_TYPES.JSXEmptyExpression) {
+  if (expression.type === import_utils34.AST_NODE_TYPES.JSXEmptyExpression) {
     return null;
   }
   const group = getExpressionGroup(expression);
@@ -2135,7 +2226,7 @@ function getTypeGroup(node) {
 function hasUnsortedProps(attributes) {
   let lastGroup = 0;
   return attributes.some((attribute) => {
-    if (attribute.type === import_utils32.AST_NODE_TYPES.JSXSpreadAttribute) {
+    if (attribute.type === import_utils34.AST_NODE_TYPES.JSXSpreadAttribute) {
       lastGroup = 0;
       return false;
     }
@@ -2159,7 +2250,7 @@ function getSegments(attributes) {
   const result = [];
   let current = [];
   attributes.forEach((attr) => {
-    if (attr.type === import_utils32.AST_NODE_TYPES.JSXSpreadAttribute) {
+    if (attr.type === import_utils34.AST_NODE_TYPES.JSXSpreadAttribute) {
       if (current.length > 0) {
         result.push(current);
         current = [];
@@ -2173,7 +2264,7 @@ function getSegments(attributes) {
   }
   return result;
 }
-var jsxSortProps = createRule24({
+var jsxSortProps = createRule26({
   name: "jsx-sort-props",
   meta: {
     type: "suggestion",
@@ -2208,11 +2299,11 @@ var jsxSortProps = createRule24({
 var jsx_sort_props_default = jsxSortProps;
 // src/rules/jsx-spread-props-last.ts
-var import_utils33 = require("@typescript-eslint/utils");
-var createRule25 = import_utils33.ESLintUtils.RuleCreator(
+var import_utils35 = require("@typescript-eslint/utils");
+var createRule27 = import_utils35.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var jsxSpreadPropsLast = createRule25({
+var jsxSpreadPropsLast = createRule27({
   name: "jsx-spread-props-last",
   meta: {
     type: "suggestion",
@@ -2231,12 +2322,12 @@ var jsxSpreadPropsLast = createRule25({
         const { attributes } = node;
         let lastNonSpreadIndex = -1;
         attributes.forEach((attribute, index) => {
-          if (attribute.type !== import_utils33.AST_NODE_TYPES.JSXSpreadAttribute) {
+          if (attribute.type !== import_utils35.AST_NODE_TYPES.JSXSpreadAttribute) {
             lastNonSpreadIndex = index;
           }
         });
         attributes.forEach((attribute, index) => {
-          if (attribute.type === import_utils33.AST_NODE_TYPES.JSXSpreadAttribute && index < lastNonSpreadIndex) {
+          if (attribute.type === import_utils35.AST_NODE_TYPES.JSXSpreadAttribute && index < lastNonSpreadIndex) {
             context.report({
               node: attribute,
               messageId: "spreadNotLast"
@@ -2250,12 +2341,12 @@ var jsxSpreadPropsLast = createRule25({
 var jsx_spread_props_last_default = jsxSpreadPropsLast;
 // src/rules/newline-after-multiline-block.ts
-var import_utils34 = require("@typescript-eslint/utils");
-var createRule26 = import_utils34.ESLintUtils.RuleCreator(
+var import_utils36 = require("@typescript-eslint/utils");
+var createRule28 = import_utils36.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 function isImportDeclaration(node) {
-  return node.type === import_utils34.AST_NODE_TYPES.ImportDeclaration;
+  return node.type === import_utils36.AST_NODE_TYPES.ImportDeclaration;
 }
 function checkStatements(statements, context) {
   const { sourceCode } = context;
@@ -2290,7 +2381,7 @@ function checkStatements(statements, context) {
     }
   });
 }
-var newlineAfterMultilineBlock = createRule26({
+var newlineAfterMultilineBlock = createRule28({
   name: "newline-after-multiline-block",
   meta: {
     type: "layout",
@@ -2318,11 +2409,11 @@ var newlineAfterMultilineBlock = createRule26({
 var newline_after_multiline_block_default = newlineAfterMultilineBlock;
 // src/rules/newline-before-return.ts
-var import_utils35 = require("@typescript-eslint/utils");
-var createRule27 = import_utils35.ESLintUtils.RuleCreator(
+var import_utils37 = require("@typescript-eslint/utils");
+var createRule29 = import_utils37.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var newlineBeforeReturn = createRule27({
+var newlineBeforeReturn = createRule29({
   name: "newline-before-return",
   meta: {
     type: "layout",
@@ -2340,7 +2431,7 @@ var newlineBeforeReturn = createRule27({
     const { sourceCode } = context;
     function checkReturnStatement(node) {
       const { parent } = node;
-      if (!parent || parent.type !== import_utils35.AST_NODE_TYPES.BlockStatement) {
+      if (!parent || parent.type !== import_utils37.AST_NODE_TYPES.BlockStatement) {
         return;
       }
       const { body: statements } = parent;
@@ -2377,11 +2468,11 @@ var newlineBeforeReturn = createRule27({
 var newline_before_return_default = newlineBeforeReturn;
 // src/rules/no-complex-inline-return.ts
-var import_utils36 = require("@typescript-eslint/utils");
-var createRule28 = import_utils36.ESLintUtils.RuleCreator(
+var import_utils38 = require("@typescript-eslint/utils");
+var createRule30 = import_utils38.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var noComplexInlineReturn = createRule28({
+var noComplexInlineReturn = createRule30({
   name: "no-complex-inline-return",
   meta: {
     type: "suggestion",
@@ -2397,13 +2488,13 @@ var noComplexInlineReturn = createRule28({
   create(context) {
     const isComplexExpression = (node) => {
       if (!node) return false;
-      if (node.type === import_utils36.AST_NODE_TYPES.ConditionalExpression) {
+      if (node.type === import_utils38.AST_NODE_TYPES.ConditionalExpression) {
         return true;
       }
-      if (node.type === import_utils36.AST_NODE_TYPES.LogicalExpression) {
+      if (node.type === import_utils38.AST_NODE_TYPES.LogicalExpression) {
         return true;
       }
-      if (node.type === import_utils36.AST_NODE_TYPES.NewExpression) {
+      if (node.type === import_utils38.AST_NODE_TYPES.NewExpression) {
         return true;
       }
       return false;
@@ -2423,11 +2514,11 @@ var noComplexInlineReturn = createRule28({
 var no_complex_inline_return_default = noComplexInlineReturn;
 // src/rules/no-direct-date.ts
-var import_utils37 = require("@typescript-eslint/utils");
-var createRule29 = import_utils37.ESLintUtils.RuleCreator(
+var import_utils39 = require("@typescript-eslint/utils");
+var createRule31 = import_utils39.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var noDirectDate = createRule29({
+var noDirectDate = createRule31({
   name: "no-direct-date",
   meta: {
     type: "problem",
@@ -2445,7 +2536,7 @@ var noDirectDate = createRule29({
   create(context) {
     return {
       NewExpression(node) {
-        if (node.callee.type === import_utils37.AST_NODE_TYPES.Identifier && node.callee.name === "Date") {
+        if (node.callee.type === import_utils39.AST_NODE_TYPES.Identifier && node.callee.name === "Date") {
           context.report({
             node,
             messageId: "noNewDate"
@@ -2453,7 +2544,7 @@ var noDirectDate = createRule29({
         }
       },
       CallExpression(node) {
-        if (node.callee.type === import_utils37.AST_NODE_TYPES.MemberExpression && node.callee.object.type === import_utils37.AST_NODE_TYPES.Identifier && node.callee.object.name === "Date" && node.callee.property.type === import_utils37.AST_NODE_TYPES.Identifier) {
+        if (node.callee.type === import_utils39.AST_NODE_TYPES.MemberExpression && node.callee.object.type === import_utils39.AST_NODE_TYPES.Identifier && node.callee.object.name === "Date" && node.callee.property.type === import_utils39.AST_NODE_TYPES.Identifier) {
           const methodName = node.callee.property.name;
           if (methodName === "now") {
             context.report({
@@ -2476,11 +2567,11 @@ var no_direct_date_default = noDirectDate;
 // src/rules/no-emoji.ts
 var import_emoji_regex = __toESM(require("emoji-regex"), 1);
-var import_utils38 = require("@typescript-eslint/utils");
-var createRule30 = import_utils38.ESLintUtils.RuleCreator(
+var import_utils40 = require("@typescript-eslint/utils");
+var createRule32 = import_utils40.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var noEmoji = createRule30({
+var noEmoji = createRule32({
   name: "no-emoji",
   meta: {
     type: "problem",
@@ -2514,11 +2605,11 @@ var noEmoji = createRule30({
 var no_emoji_default = noEmoji;
 // src/rules/no-env-fallback.ts
-var import_utils39 = require("@typescript-eslint/utils");
-var createRule31 = import_utils39.ESLintUtils.RuleCreator(
+var import_utils41 = require("@typescript-eslint/utils");
+var createRule33 = import_utils41.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var noEnvFallback = createRule31({
+var noEnvFallback = createRule33({
   name: "no-env-fallback",
   meta: {
     type: "problem",
@@ -2533,16 +2624,16 @@ var noEnvFallback = createRule31({
   defaultOptions: [],
   create(context) {
     const isProcessEnvAccess = (node) => {
-      if (node.type !== import_utils39.AST_NODE_TYPES.MemberExpression) {
+      if (node.type !== import_utils41.AST_NODE_TYPES.MemberExpression) {
         return false;
       }
       const { object } = node;
-      if (object.type !== import_utils39.AST_NODE_TYPES.MemberExpression) {
+      if (object.type !== import_utils41.AST_NODE_TYPES.MemberExpression) {
         return false;
       }
       const processNode = object.object;
       const envNode = object.property;
-      return processNode.type === import_utils39.AST_NODE_TYPES.Identifier && processNode.name === "process" && envNode.type === import_utils39.AST_NODE_TYPES.Identifier && envNode.name === "env";
+      return processNode.type === import_utils41.AST_NODE_TYPES.Identifier && processNode.name === "process" && envNode.type === import_utils41.AST_NODE_TYPES.Identifier && envNode.name === "env";
     };
     return {
       LogicalExpression(node) {
@@ -2567,15 +2658,15 @@ var noEnvFallback = createRule31({
 var no_env_fallback_default = noEnvFallback;
 // src/rules/no-ghost-wrapper.ts
-var import_utils40 = require("@typescript-eslint/utils");
-var createRule32 = import_utils40.ESLintUtils.RuleCreator(
+var import_utils42 = require("@typescript-eslint/utils");
+var createRule34 = import_utils42.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var GHOST_TAGS = /* @__PURE__ */ new Set(["div", "span"]);
 function isKeyAttribute(attribute) {
-  return attribute.type === import_utils40.AST_NODE_TYPES.JSXAttribute && attribute.name.type === import_utils40.AST_NODE_TYPES.JSXIdentifier && attribute.name.name === "key";
+  return attribute.type === import_utils42.AST_NODE_TYPES.JSXAttribute && attribute.name.type === import_utils42.AST_NODE_TYPES.JSXIdentifier && attribute.name.name === "key";
 }
-var noGhostWrapper = createRule32({
+var noGhostWrapper = createRule34({
   name: "no-ghost-wrapper",
   meta: {
     type: "problem",
@@ -2591,7 +2682,7 @@ var noGhostWrapper = createRule32({
   create(context) {
     return {
       JSXOpeningElement(node) {
-        if (node.name.type !== import_utils40.AST_NODE_TYPES.JSXIdentifier) {
+        if (node.name.type !== import_utils42.AST_NODE_TYPES.JSXIdentifier) {
           return;
         }
         const tagName = node.name.name;
@@ -2612,12 +2703,92 @@ var noGhostWrapper = createRule32({
 });
 var no_ghost_wrapper_default = noGhostWrapper;
+// src/rules/no-helper-function-in-hook.ts
+var import_utils43 = require("@typescript-eslint/utils");
+var createRule35 = import_utils43.ESLintUtils.RuleCreator(
+  (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
+);
+var noHelperFunctionInHook = createRule35({
+  name: "no-helper-function-in-hook",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Disallow non-hook helper function definitions in hook files"
+    },
+    messages: {
+      noHelperFunction: "Helper functions must not be defined in hook files. Extract to a separate utility file."
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    function isAtProgramLevel(node) {
+      const { parent } = node;
+      if (parent === void 0) return false;
+      if (parent.type === import_utils43.AST_NODE_TYPES.Program) return true;
+      if (parent.type !== import_utils43.AST_NODE_TYPES.ExportNamedDeclaration) return false;
+      return parent.parent?.type === import_utils43.AST_NODE_TYPES.Program;
+    }
+    return {
+      FunctionDeclaration(node) {
+        if (!isAtProgramLevel(node)) return;
+        if (node.id !== null && node.id.name.startsWith("use")) return;
+        context.report({ node, messageId: "noHelperFunction" });
+      },
+      VariableDeclarator(node) {
+        if (node.parent.type !== import_utils43.AST_NODE_TYPES.VariableDeclaration) return;
+        if (!isAtProgramLevel(node.parent)) return;
+        if (node.init === null || node.init.type !== import_utils43.AST_NODE_TYPES.ArrowFunctionExpression && node.init.type !== import_utils43.AST_NODE_TYPES.FunctionExpression)
+          return;
+        if (node.id.type === import_utils43.AST_NODE_TYPES.Identifier && node.id.name.startsWith("use")) return;
+        context.report({ node, messageId: "noHelperFunction" });
+      }
+    };
+  }
+});
+var no_helper_function_in_hook_default = noHelperFunctionInHook;
+// src/rules/no-helper-function-in-test.ts
+var import_utils44 = require("@typescript-eslint/utils");
+var createRule36 = import_utils44.ESLintUtils.RuleCreator(
+  (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
+);
+var noHelperFunctionInTest = createRule36({
+  name: "no-helper-function-in-test",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Disallow helper function definitions in test files"
+    },
+    messages: {
+      noHelperFunction: "Helper functions must not be defined in test files. Extract to a separate utility file."
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      FunctionDeclaration(node) {
+        if (node.parent.type === import_utils44.AST_NODE_TYPES.Program) {
+          context.report({ node, messageId: "noHelperFunction" });
+        }
+      },
+      VariableDeclarator(node) {
+        if (node.parent.type === import_utils44.AST_NODE_TYPES.VariableDeclaration && node.parent.parent.type === import_utils44.AST_NODE_TYPES.Program && node.init !== null && (node.init.type === import_utils44.AST_NODE_TYPES.ArrowFunctionExpression || node.init.type === import_utils44.AST_NODE_TYPES.FunctionExpression)) {
+          context.report({ node, messageId: "noHelperFunction" });
+        }
+      }
+    };
+  }
+});
+var no_helper_function_in_test_default = noHelperFunctionInTest;
 // src/rules/no-inline-default-export.ts
-var import_utils41 = require("@typescript-eslint/utils");
-var createRule33 = import_utils41.ESLintUtils.RuleCreator(
+var import_utils45 = require("@typescript-eslint/utils");
+var createRule37 = import_utils45.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var noInlineDefaultExport = createRule33({
+var noInlineDefaultExport = createRule37({
   name: "no-inline-default-export",
   meta: {
     type: "suggestion",
@@ -2636,7 +2807,7 @@ var noInlineDefaultExport = createRule33({
     return {
       ExportDefaultDeclaration(node) {
         const { declaration } = node;
-        if (declaration.type === import_utils41.AST_NODE_TYPES.FunctionDeclaration) {
+        if (declaration.type === import_utils45.AST_NODE_TYPES.FunctionDeclaration) {
           if (declaration.id) {
             context.report({
               node,
@@ -2651,7 +2822,7 @@ var noInlineDefaultExport = createRule33({
             });
           }
         }
-        if (declaration.type === import_utils41.AST_NODE_TYPES.ClassDeclaration) {
+        if (declaration.type === import_utils45.AST_NODE_TYPES.ClassDeclaration) {
           if (declaration.id) {
             context.report({
               node,
@@ -2666,7 +2837,7 @@ var noInlineDefaultExport = createRule33({
             });
           }
         }
-        if (declaration.type === import_utils41.AST_NODE_TYPES.ArrowFunctionExpression || declaration.type === import_utils41.AST_NODE_TYPES.FunctionExpression) {
+        if (declaration.type === import_utils45.AST_NODE_TYPES.ArrowFunctionExpression || declaration.type === import_utils45.AST_NODE_TYPES.FunctionExpression) {
           context.report({
             node,
             messageId: "noAnonymousDefaultExport",
@@ -2679,14 +2850,14 @@ var noInlineDefaultExport = createRule33({
         if (!declaration) {
           return;
         }
-        if (declaration.type === import_utils41.AST_NODE_TYPES.FunctionDeclaration && declaration.id) {
+        if (declaration.type === import_utils45.AST_NODE_TYPES.FunctionDeclaration && declaration.id) {
           context.report({
             node,
             messageId: "noInlineNamedExport",
             data: { type: "function", name: declaration.id.name }
           });
         }
-        if (declaration.type === import_utils41.AST_NODE_TYPES.ClassDeclaration && declaration.id) {
+        if (declaration.type === import_utils45.AST_NODE_TYPES.ClassDeclaration && declaration.id) {
           context.report({
             node,
             messageId: "noInlineNamedExport",
@@ -2700,27 +2871,27 @@ var noInlineDefaultExport = createRule33({
 var no_inline_default_export_default = noInlineDefaultExport;
 // src/rules/no-inline-nested-object.ts
-var import_utils42 = require("@typescript-eslint/utils");
-var createRule34 = import_utils42.ESLintUtils.RuleCreator(
+var import_utils46 = require("@typescript-eslint/utils");
+var createRule38 = import_utils46.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 function isObjectOrArray(node) {
-  return node.type === import_utils42.AST_NODE_TYPES.ObjectExpression || node.type === import_utils42.AST_NODE_TYPES.ArrayExpression || node.type === import_utils42.AST_NODE_TYPES.TSAsExpression;
+  return node.type === import_utils46.AST_NODE_TYPES.ObjectExpression || node.type === import_utils46.AST_NODE_TYPES.ArrayExpression || node.type === import_utils46.AST_NODE_TYPES.TSAsExpression;
 }
 function getInnerExpression(node) {
-  if (node.type === import_utils42.AST_NODE_TYPES.TSAsExpression) {
+  if (node.type === import_utils46.AST_NODE_TYPES.TSAsExpression) {
     return getInnerExpression(node.expression);
   }
   return node;
 }
 function isNestedStructure(node) {
   const inner = getInnerExpression(node);
-  return inner.type === import_utils42.AST_NODE_TYPES.ObjectExpression || inner.type === import_utils42.AST_NODE_TYPES.ArrayExpression;
+  return inner.type === import_utils46.AST_NODE_TYPES.ObjectExpression || inner.type === import_utils46.AST_NODE_TYPES.ArrayExpression;
 }
 function containsNestedStructure(node) {
-  if (node.type === import_utils42.AST_NODE_TYPES.ObjectExpression) {
+  if (node.type === import_utils46.AST_NODE_TYPES.ObjectExpression) {
     return node.properties.some((prop) => {
-      if (prop.type !== import_utils42.AST_NODE_TYPES.Property) return false;
+      if (prop.type !== import_utils46.AST_NODE_TYPES.Property) return false;
       return isNestedStructure(prop.value);
     });
   }
@@ -2729,7 +2900,7 @@ function containsNestedStructure(node) {
     return isNestedStructure(el);
   });
 }
-var noInlineNestedObject = createRule34({
+var noInlineNestedObject = createRule38({
   name: "no-inline-nested-object",
   meta: {
     type: "layout",
@@ -2751,7 +2922,7 @@ var noInlineNestedObject = createRule34({
           return;
         }
         const valueNode = getInnerExpression(node.value);
-        if (valueNode.type !== import_utils42.AST_NODE_TYPES.ObjectExpression && valueNode.type !== import_utils42.AST_NODE_TYPES.ArrayExpression) {
+        if (valueNode.type !== import_utils46.AST_NODE_TYPES.ObjectExpression && valueNode.type !== import_utils46.AST_NODE_TYPES.ArrayExpression) {
           return;
         }
         if (!valueNode.loc) {
@@ -2764,7 +2935,7 @@ var noInlineNestedObject = createRule34({
         if (!containsNestedStructure(valueNode)) {
           return;
         }
-        const elements = valueNode.type === import_utils42.AST_NODE_TYPES.ObjectExpression ? valueNode.properties : valueNode.elements;
+        const elements = valueNode.type === import_utils46.AST_NODE_TYPES.ObjectExpression ? valueNode.properties : valueNode.elements;
         context.report({
           node: valueNode,
           messageId: "requireMultiline",
@@ -2777,7 +2948,7 @@ var noInlineNestedObject = createRule34({
             const indent = " ".repeat(node.loc?.start.column ?? 0);
             const innerIndent = `${indent}  `;
             const elementTexts = elements.filter((el) => el !== null).map((el) => sourceCode.getText(el));
-            const isObject = valueNode.type === import_utils42.AST_NODE_TYPES.ObjectExpression;
+            const isObject = valueNode.type === import_utils46.AST_NODE_TYPES.ObjectExpression;
             const openChar = isObject ? "{" : "[";
             const closeChar = isObject ? "}" : "]";
             const formattedElements = elementTexts.map((text) => `${innerIndent}${text},`).join("\n");
@@ -2794,20 +2965,20 @@ ${indent}${closeChar}`;
 var no_inline_nested_object_default = noInlineNestedObject;
 // src/rules/no-inline-return-properties.ts
-var import_utils43 = require("@typescript-eslint/utils");
-var createRule35 = import_utils43.ESLintUtils.RuleCreator(
+var import_utils47 = require("@typescript-eslint/utils");
+var createRule39 = import_utils47.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var isShorthandProperty = (property) => {
-  if (property.type === import_utils43.AST_NODE_TYPES.SpreadElement) {
+  if (property.type === import_utils47.AST_NODE_TYPES.SpreadElement) {
     return true;
   }
-  if (property.type !== import_utils43.AST_NODE_TYPES.Property) {
+  if (property.type !== import_utils47.AST_NODE_TYPES.Property) {
     return false;
   }
   return property.shorthand;
 };
-var noInlineReturnProperties = createRule35({
+var noInlineReturnProperties = createRule39({
   name: "no-inline-return-properties",
   meta: {
     type: "suggestion",
@@ -2823,20 +2994,20 @@ var noInlineReturnProperties = createRule35({
   create(context) {
     return {
       ReturnStatement(node) {
-        if (!node.argument || node.argument.type !== import_utils43.AST_NODE_TYPES.ObjectExpression) {
+        if (!node.argument || node.argument.type !== import_utils47.AST_NODE_TYPES.ObjectExpression) {
           return;
         }
         node.argument.properties.forEach((property) => {
           if (isShorthandProperty(property)) {
             return;
           }
-          if (property.type !== import_utils43.AST_NODE_TYPES.Property) {
+          if (property.type !== import_utils47.AST_NODE_TYPES.Property) {
             return;
           }
           let keyName = null;
-          if (property.key.type === import_utils43.AST_NODE_TYPES.Identifier) {
+          if (property.key.type === import_utils47.AST_NODE_TYPES.Identifier) {
             keyName = property.key.name;
-          } else if (property.key.type === import_utils43.AST_NODE_TYPES.Literal) {
+          } else if (property.key.type === import_utils47.AST_NODE_TYPES.Literal) {
             keyName = String(property.key.value);
           }
           context.report({
@@ -2852,12 +3023,12 @@ var noInlineReturnProperties = createRule35({
 var no_inline_return_properties_default = noInlineReturnProperties;
 // src/rules/no-inline-type-import.ts
-var import_utils44 = require("@typescript-eslint/utils");
-var createRule36 = import_utils44.ESLintUtils.RuleCreator(
+var import_utils48 = require("@typescript-eslint/utils");
+var createRule40 = import_utils48.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var isInlineTypeSpecifier = (specifier) => specifier.type === import_utils44.AST_NODE_TYPES.ImportSpecifier && specifier.importKind === "type";
-var noInlineTypeImport = createRule36({
+var isInlineTypeSpecifier = (specifier) => specifier.type === import_utils48.AST_NODE_TYPES.ImportSpecifier && specifier.importKind === "type";
+var noInlineTypeImport = createRule40({
   name: "no-inline-type-import",
   meta: {
     type: "suggestion",
@@ -2894,7 +3065,7 @@ var noInlineTypeImport = createRule36({
             );
             const typeImport = `import type { ${typeSpecifierTexts.join(", ")} } from ${sourceText};`;
             const valueSpecifiers = node.specifiers.filter(
-              (specifier) => !(specifier.type === import_utils44.AST_NODE_TYPES.ImportSpecifier && specifier.importKind === "type")
+              (specifier) => !(specifier.type === import_utils48.AST_NODE_TYPES.ImportSpecifier && specifier.importKind === "type")
             );
             if (valueSpecifiers.length === 0) {
               return fixer.replaceText(node, typeImport);
@@ -2902,11 +3073,11 @@ var noInlineTypeImport = createRule36({
             const parts = [];
             const namedValueSpecifiers = [];
             for (const specifier of valueSpecifiers) {
-              if (specifier.type === import_utils44.AST_NODE_TYPES.ImportDefaultSpecifier) {
+              if (specifier.type === import_utils48.AST_NODE_TYPES.ImportDefaultSpecifier) {
                 parts.push(specifier.local.name);
-              } else if (specifier.type === import_utils44.AST_NODE_TYPES.ImportNamespaceSpecifier) {
+              } else if (specifier.type === import_utils48.AST_NODE_TYPES.ImportNamespaceSpecifier) {
                 parts.push(`* as ${specifier.local.name}`);
-              } else if (specifier.type === import_utils44.AST_NODE_TYPES.ImportSpecifier) {
+              } else if (specifier.type === import_utils48.AST_NODE_TYPES.ImportSpecifier) {
                 namedValueSpecifiers.push(specifier);
               }
             }
@@ -2926,8 +3097,8 @@ ${typeImport}`);
 var no_inline_type_import_default = noInlineTypeImport;
 // src/rules/no-lazy-identifiers.ts
-var import_utils45 = require("@typescript-eslint/utils");
-var createRule37 = import_utils45.ESLintUtils.RuleCreator(
+var import_utils49 = require("@typescript-eslint/utils");
+var createRule41 = import_utils49.ESLintUtils.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"];
@@ -2968,7 +3139,7 @@ var isLazyIdentifier = (name) => {
   }
   return false;
 };
-var noLazyIdentifiers = createRule37({
+var noLazyIdentifiers = createRule41({
   name: "no-lazy-identifiers",
   meta: {
     type: "problem",
@@ -2994,27 +3165,27 @@ var noLazyIdentifiers = createRule37({
       });
     };
     const checkPattern = (pattern) => {
-      if (pattern.type === import_utils45.AST_NODE_TYPES.Identifier) {
+      if (pattern.type === import_utils49.AST_NODE_TYPES.Identifier) {
         checkIdentifier(pattern);
-      } else if (pattern.type === import_utils45.AST_NODE_TYPES.ObjectPattern) {
+      } else if (pattern.type === import_utils49.AST_NODE_TYPES.ObjectPattern) {
         pattern.properties.forEach((prop) => {
-          if (prop.type === import_utils45.AST_NODE_TYPES.Property && prop.value.type === import_utils45.AST_NODE_TYPES.Identifier) {
+          if (prop.type === import_utils49.AST_NODE_TYPES.Property && prop.value.type === import_utils49.AST_NODE_TYPES.Identifier) {
             checkIdentifier(prop.value);
-          } else if (prop.type === import_utils45.AST_NODE_TYPES.RestElement && prop.argument.type === import_utils45.AST_NODE_TYPES.Identifier) {
+          } else if (prop.type === import_utils49.AST_NODE_TYPES.RestElement && prop.argument.type === import_utils49.AST_NODE_TYPES.Identifier) {
             checkIdentifier(prop.argument);
           }
         });
-      } else if (pattern.type === import_utils45.AST_NODE_TYPES.ArrayPattern) {
+      } else if (pattern.type === import_utils49.AST_NODE_TYPES.ArrayPattern) {
         pattern.elements.forEach((element) => {
-          if (element?.type === import_utils45.AST_NODE_TYPES.Identifier) {
+          if (element?.type === import_utils49.AST_NODE_TYPES.Identifier) {
             checkIdentifier(element);
-          } else if (element?.type === import_utils45.AST_NODE_TYPES.RestElement && element.argument.type === import_utils45.AST_NODE_TYPES.Identifier) {
+          } else if (element?.type === import_utils49.AST_NODE_TYPES.RestElement && element.argument.type === import_utils49.AST_NODE_TYPES.Identifier) {
             checkIdentifier(element.argument);
           }
         });
-      } else if (pattern.type === import_utils45.AST_NODE_TYPES.AssignmentPattern && pattern.left.type === import_utils45.AST_NODE_TYPES.Identifier) {
+      } else if (pattern.type === import_utils49.AST_NODE_TYPES.AssignmentPattern && pattern.left.type === import_utils49.AST_NODE_TYPES.Identifier) {
         checkIdentifier(pattern.left);
-      } else if (pattern.type === import_utils45.AST_NODE_TYPES.RestElement && pattern.argument.type === import_utils45.AST_NODE_TYPES.Identifier) {
+      } else if (pattern.type === import_utils49.AST_NODE_TYPES.RestElement && pattern.argument.type === import_utils49.AST_NODE_TYPES.Identifier) {
         checkIdentifier(pattern.argument);
       }
     };
@@ -3059,11 +3230,11 @@ var noLazyIdentifiers = createRule37({
 var no_lazy_identifiers_default = noLazyIdentifiers;
 // src/rules/no-logic-in-params.ts
-var import_utils46 = require("@typescript-eslint/utils");
-var createRule38 = import_utils46.ESLintUtils.RuleCreator(
+var import_utils50 = require("@typescript-eslint/utils");
+var createRule42 = import_utils50.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var noLogicInParams = createRule38({
+var noLogicInParams = createRule42({
   name: "no-logic-in-params",
   meta: {
     type: "suggestion",
@@ -3078,20 +3249,20 @@ var noLogicInParams = createRule38({
   defaultOptions: [],
   create(context) {
     const isComplexExpression = (node) => {
-      if (node.type === import_utils46.AST_NODE_TYPES.SpreadElement) {
+      if (node.type === import_utils50.AST_NODE_TYPES.SpreadElement) {
         return false;
       }
-      if (node.type === import_utils46.AST_NODE_TYPES.ConditionalExpression) {
+      if (node.type === import_utils50.AST_NODE_TYPES.ConditionalExpression) {
         return true;
       }
-      if (node.type === import_utils46.AST_NODE_TYPES.LogicalExpression) {
+      if (node.type === import_utils50.AST_NODE_TYPES.LogicalExpression) {
         return true;
       }
-      if (node.type === import_utils46.AST_NODE_TYPES.BinaryExpression) {
+      if (node.type === import_utils50.AST_NODE_TYPES.BinaryExpression) {
         const logicalOperators = ["==", "===", "!=", "!==", "<", ">", "<=", ">=", "in", "instanceof"];
         return logicalOperators.includes(node.operator);
       }
-      if (node.type === import_utils46.AST_NODE_TYPES.UnaryExpression) {
+      if (node.type === import_utils50.AST_NODE_TYPES.UnaryExpression) {
         return node.operator === "!";
       }
       return false;
@@ -3104,7 +3275,7 @@ var noLogicInParams = createRule38({
             messageId: "noLogicInParams"
           });
         }
-        if (arg.type === import_utils46.AST_NODE_TYPES.ArrayExpression) {
+        if (arg.type === import_utils50.AST_NODE_TYPES.ArrayExpression) {
           arg.elements.forEach((element) => {
             if (element && isComplexExpression(element)) {
               context.report({
@@ -3129,46 +3300,46 @@ var noLogicInParams = createRule38({
 var no_logic_in_params_default = noLogicInParams;
 // src/rules/no-misleading-constant-case.ts
-var import_utils47 = require("@typescript-eslint/utils");
-var createRule39 = import_utils47.ESLintUtils.RuleCreator(
+var import_utils51 = require("@typescript-eslint/utils");
+var createRule43 = import_utils51.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var SCREAMING_SNAKE_CASE_REGEX3 = /^[A-Z][A-Z0-9]*(?:_[A-Z0-9]+)*$/;
-var isAsConstAssertion = (node) => node.type === import_utils47.AST_NODE_TYPES.TSAsExpression && node.typeAnnotation.type === import_utils47.AST_NODE_TYPES.TSTypeReference && node.typeAnnotation.typeName.type === import_utils47.AST_NODE_TYPES.Identifier && node.typeAnnotation.typeName.name === "const";
+var isAsConstAssertion = (node) => node.type === import_utils51.AST_NODE_TYPES.TSAsExpression && node.typeAnnotation.type === import_utils51.AST_NODE_TYPES.TSTypeReference && node.typeAnnotation.typeName.type === import_utils51.AST_NODE_TYPES.Identifier && node.typeAnnotation.typeName.name === "const";
 var isStaticValue2 = (init) => {
   if (isAsConstAssertion(init)) {
     return true;
   }
-  if (init.type === import_utils47.AST_NODE_TYPES.Literal) {
+  if (init.type === import_utils51.AST_NODE_TYPES.Literal) {
     return true;
   }
-  if (init.type === import_utils47.AST_NODE_TYPES.UnaryExpression && init.argument.type === import_utils47.AST_NODE_TYPES.Literal) {
+  if (init.type === import_utils51.AST_NODE_TYPES.UnaryExpression && init.argument.type === import_utils51.AST_NODE_TYPES.Literal) {
     return true;
   }
-  if (init.type === import_utils47.AST_NODE_TYPES.TemplateLiteral && init.expressions.length === 0) {
+  if (init.type === import_utils51.AST_NODE_TYPES.TemplateLiteral && init.expressions.length === 0) {
     return true;
   }
-  if (init.type === import_utils47.AST_NODE_TYPES.ArrayExpression) {
-    return init.elements.every((el) => el !== null && el.type !== import_utils47.AST_NODE_TYPES.SpreadElement && isStaticValue2(el));
+  if (init.type === import_utils51.AST_NODE_TYPES.ArrayExpression) {
+    return init.elements.every((el) => el !== null && el.type !== import_utils51.AST_NODE_TYPES.SpreadElement && isStaticValue2(el));
   }
-  if (init.type === import_utils47.AST_NODE_TYPES.ObjectExpression) {
+  if (init.type === import_utils51.AST_NODE_TYPES.ObjectExpression) {
     return init.properties.every(
-      (prop) => prop.type === import_utils47.AST_NODE_TYPES.Property && isStaticValue2(prop.value)
+      (prop) => prop.type === import_utils51.AST_NODE_TYPES.Property && isStaticValue2(prop.value)
     );
   }
   return false;
 };
 var isGlobalScope3 = (node) => {
   const { parent } = node;
-  if (parent.type === import_utils47.AST_NODE_TYPES.Program) {
+  if (parent.type === import_utils51.AST_NODE_TYPES.Program) {
     return true;
   }
-  if (parent.type === import_utils47.AST_NODE_TYPES.ExportNamedDeclaration && parent.parent?.type === import_utils47.AST_NODE_TYPES.Program) {
+  if (parent.type === import_utils51.AST_NODE_TYPES.ExportNamedDeclaration && parent.parent?.type === import_utils51.AST_NODE_TYPES.Program) {
     return true;
   }
   return false;
 };
-var noMisleadingConstantCase = createRule39({
+var noMisleadingConstantCase = createRule43({
   name: "no-misleading-constant-case",
   meta: {
     type: "suggestion",
@@ -3187,7 +3358,7 @@ var noMisleadingConstantCase = createRule39({
     return {
       VariableDeclaration(node) {
         node.declarations.forEach((declarator) => {
-          if (declarator.id.type !== import_utils47.AST_NODE_TYPES.Identifier) {
+          if (declarator.id.type !== import_utils51.AST_NODE_TYPES.Identifier) {
             return;
           }
           const { name } = declarator.id;
@@ -3228,11 +3399,11 @@ var noMisleadingConstantCase = createRule39({
 var no_misleading_constant_case_default = noMisleadingConstantCase;
 // src/rules/no-nested-interface-declaration.ts
-var import_utils48 = require("@typescript-eslint/utils");
-var createRule40 = import_utils48.ESLintUtils.RuleCreator(
+var import_utils52 = require("@typescript-eslint/utils");
+var createRule44 = import_utils52.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var noNestedInterfaceDeclaration = createRule40({
+var noNestedInterfaceDeclaration = createRule44({
   name: "no-nested-interface-declaration",
   meta: {
     type: "suggestion",
@@ -3253,15 +3424,15 @@ var noNestedInterfaceDeclaration = createRule40({
           return;
         }
         const { typeAnnotation } = node.typeAnnotation;
-        if (typeAnnotation.type === import_utils48.AST_NODE_TYPES.TSTypeLiteral) {
+        if (typeAnnotation.type === import_utils52.AST_NODE_TYPES.TSTypeLiteral) {
           context.report({
             node: typeAnnotation,
             messageId: "noNestedInterface"
           });
           return;
         }
-        if (typeAnnotation.type === import_utils48.AST_NODE_TYPES.TSArrayType) {
-          if (typeAnnotation.elementType.type === import_utils48.AST_NODE_TYPES.TSTypeLiteral) {
+        if (typeAnnotation.type === import_utils52.AST_NODE_TYPES.TSArrayType) {
+          if (typeAnnotation.elementType.type === import_utils52.AST_NODE_TYPES.TSTypeLiteral) {
             context.report({
               node: typeAnnotation.elementType,
               messageId: "noNestedInterface"
@@ -3269,9 +3440,9 @@ var noNestedInterfaceDeclaration = createRule40({
           }
           return;
         }
-        if (typeAnnotation.type === import_utils48.AST_NODE_TYPES.TSTypeReference && typeAnnotation.typeArguments) {
+        if (typeAnnotation.type === import_utils52.AST_NODE_TYPES.TSTypeReference && typeAnnotation.typeArguments) {
           typeAnnotation.typeArguments.params.forEach((param) => {
-            if (param.type === import_utils48.AST_NODE_TYPES.TSTypeLiteral) {
+            if (param.type === import_utils52.AST_NODE_TYPES.TSTypeLiteral) {
               context.report({
                 node: param,
                 messageId: "noNestedInterface"
@@ -3286,11 +3457,11 @@ var noNestedInterfaceDeclaration = createRule40({
 var no_nested_interface_declaration_default = noNestedInterfaceDeclaration;
 // src/rules/no-nested-ternary.ts
-var import_utils49 = require("@typescript-eslint/utils");
-var createRule41 = import_utils49.ESLintUtils.RuleCreator(
+var import_utils53 = require("@typescript-eslint/utils");
+var createRule45 = import_utils53.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var noNestedTernary = createRule41({
+var noNestedTernary = createRule45({
   name: "no-nested-ternary",
   meta: {
     type: "suggestion",
@@ -3307,13 +3478,13 @@ var noNestedTernary = createRule41({
     return {
       ConditionalExpression(node) {
         const { consequent, alternate } = node;
-        if (consequent.type === import_utils49.AST_NODE_TYPES.ConditionalExpression) {
+        if (consequent.type === import_utils53.AST_NODE_TYPES.ConditionalExpression) {
           context.report({
             node: consequent,
             messageId: "noNestedTernary"
           });
         }
-        if (alternate.type === import_utils49.AST_NODE_TYPES.ConditionalExpression) {
+        if (alternate.type === import_utils53.AST_NODE_TYPES.ConditionalExpression) {
           context.report({
             node: alternate,
             messageId: "noNestedTernary"
@@ -3326,33 +3497,33 @@ var noNestedTernary = createRule41({
 var no_nested_ternary_default = noNestedTernary;
 // src/rules/no-redundant-fragment.ts
-var import_utils50 = require("@typescript-eslint/utils");
-var createRule42 = import_utils50.ESLintUtils.RuleCreator(
+var import_utils54 = require("@typescript-eslint/utils");
+var createRule46 = import_utils54.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 function isFragmentName(name) {
-  if (name.type === import_utils50.AST_NODE_TYPES.JSXIdentifier && name.name === "Fragment") {
+  if (name.type === import_utils54.AST_NODE_TYPES.JSXIdentifier && name.name === "Fragment") {
     return true;
   }
-  if (name.type === import_utils50.AST_NODE_TYPES.JSXMemberExpression && name.object.type === import_utils50.AST_NODE_TYPES.JSXIdentifier && name.object.name === "React" && name.property.type === import_utils50.AST_NODE_TYPES.JSXIdentifier && name.property.name === "Fragment") {
+  if (name.type === import_utils54.AST_NODE_TYPES.JSXMemberExpression && name.object.type === import_utils54.AST_NODE_TYPES.JSXIdentifier && name.object.name === "React" && name.property.type === import_utils54.AST_NODE_TYPES.JSXIdentifier && name.property.name === "Fragment") {
     return true;
   }
   return false;
 }
 function hasKeyAttribute(attributes) {
   return attributes.some(
-    (attribute) => attribute.type === import_utils50.AST_NODE_TYPES.JSXAttribute && attribute.name.type === import_utils50.AST_NODE_TYPES.JSXIdentifier && attribute.name.name === "key"
+    (attribute) => attribute.type === import_utils54.AST_NODE_TYPES.JSXAttribute && attribute.name.type === import_utils54.AST_NODE_TYPES.JSXIdentifier && attribute.name.name === "key"
   );
 }
 function countMeaningfulChildren(children) {
   return children.filter((child) => {
-    if (child.type === import_utils50.AST_NODE_TYPES.JSXText) {
+    if (child.type === import_utils54.AST_NODE_TYPES.JSXText) {
       return child.value.trim() !== "";
     }
     return true;
   }).length;
 }
-var noRedundantFragment = createRule42({
+var noRedundantFragment = createRule46({
   name: "no-redundant-fragment",
   meta: {
     type: "problem",
@@ -3400,11 +3571,11 @@ var noRedundantFragment = createRule42({
 var no_redundant_fragment_default = noRedundantFragment;
 // src/rules/no-relative-imports.ts
-var import_utils51 = require("@typescript-eslint/utils");
-var createRule43 = import_utils51.ESLintUtils.RuleCreator(
+var import_utils55 = require("@typescript-eslint/utils");
+var createRule47 = import_utils55.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var noRelativeImports = createRule43({
+var noRelativeImports = createRule47({
   name: "no-relative-imports",
   meta: {
     type: "suggestion",
@@ -3428,22 +3599,22 @@ var noRelativeImports = createRule43({
     };
     return {
       ImportDeclaration(node) {
-        if (node.source.type === import_utils51.AST_NODE_TYPES.Literal && typeof node.source.value === "string") {
+        if (node.source.type === import_utils55.AST_NODE_TYPES.Literal && typeof node.source.value === "string") {
           checkImportPath(node.source.value, node);
         }
       },
       ImportExpression(node) {
-        if (node.source.type === import_utils51.AST_NODE_TYPES.Literal && typeof node.source.value === "string") {
+        if (node.source.type === import_utils55.AST_NODE_TYPES.Literal && typeof node.source.value === "string") {
           checkImportPath(node.source.value, node);
         }
       },
       ExportNamedDeclaration(node) {
-        if (node.source?.type === import_utils51.AST_NODE_TYPES.Literal && typeof node.source.value === "string") {
+        if (node.source?.type === import_utils55.AST_NODE_TYPES.Literal && typeof node.source.value === "string") {
           checkImportPath(node.source.value, node);
         }
       },
       ExportAllDeclaration(node) {
-        if (node.source.type === import_utils51.AST_NODE_TYPES.Literal && typeof node.source.value === "string") {
+        if (node.source.type === import_utils55.AST_NODE_TYPES.Literal && typeof node.source.value === "string") {
           checkImportPath(node.source.value, node);
         }
       }
@@ -3453,8 +3624,8 @@ var noRelativeImports = createRule43({
 var no_relative_imports_default = noRelativeImports;
 // src/rules/no-single-char-variables.ts
-var import_utils52 = require("@typescript-eslint/utils");
-var createRule44 = import_utils52.ESLintUtils.RuleCreator(
+var import_utils56 = require("@typescript-eslint/utils");
+var createRule48 = import_utils56.ESLintUtils.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"]);
@@ -3466,7 +3637,7 @@ var isForLoopInit = (node) => {
     if (!parentNode) {
       return false;
     }
-    if (parentNode.type === import_utils52.AST_NODE_TYPES.ForStatement) {
+    if (parentNode.type === import_utils56.AST_NODE_TYPES.ForStatement) {
       const { init } = parentNode;
       if (init && init === current) {
         return true;
@@ -3485,7 +3656,7 @@ var isAllowedInContext = (name, node) => {
   }
   return false;
 };
-var noSingleCharVariables = createRule44({
+var noSingleCharVariables = createRule48({
   name: "no-single-char-variables",
   meta: {
     type: "suggestion",
@@ -3514,27 +3685,27 @@ var noSingleCharVariables = createRule44({
       });
     };
     const checkPattern = (pattern, declarationNode) => {
-      if (pattern.type === import_utils52.AST_NODE_TYPES.Identifier) {
+      if (pattern.type === import_utils56.AST_NODE_TYPES.Identifier) {
         checkIdentifier(pattern, declarationNode);
-      } else if (pattern.type === import_utils52.AST_NODE_TYPES.ObjectPattern) {
+      } else if (pattern.type === import_utils56.AST_NODE_TYPES.ObjectPattern) {
         pattern.properties.forEach((prop) => {
-          if (prop.type === import_utils52.AST_NODE_TYPES.Property && prop.value.type === import_utils52.AST_NODE_TYPES.Identifier) {
+          if (prop.type === import_utils56.AST_NODE_TYPES.Property && prop.value.type === import_utils56.AST_NODE_TYPES.Identifier) {
             checkIdentifier(prop.value, declarationNode);
-          } else if (prop.type === import_utils52.AST_NODE_TYPES.RestElement && prop.argument.type === import_utils52.AST_NODE_TYPES.Identifier) {
+          } else if (prop.type === import_utils56.AST_NODE_TYPES.RestElement && prop.argument.type === import_utils56.AST_NODE_TYPES.Identifier) {
             checkIdentifier(prop.argument, declarationNode);
           }
         });
-      } else if (pattern.type === import_utils52.AST_NODE_TYPES.ArrayPattern) {
+      } else if (pattern.type === import_utils56.AST_NODE_TYPES.ArrayPattern) {
         pattern.elements.forEach((element) => {
-          if (element?.type === import_utils52.AST_NODE_TYPES.Identifier) {
+          if (element?.type === import_utils56.AST_NODE_TYPES.Identifier) {
             checkIdentifier(element, declarationNode);
-          } else if (element?.type === import_utils52.AST_NODE_TYPES.RestElement && element.argument.type === import_utils52.AST_NODE_TYPES.Identifier) {
+          } else if (element?.type === import_utils56.AST_NODE_TYPES.RestElement && element.argument.type === import_utils56.AST_NODE_TYPES.Identifier) {
             checkIdentifier(element.argument, declarationNode);
           }
         });
-      } else if (pattern.type === import_utils52.AST_NODE_TYPES.AssignmentPattern && pattern.left.type === import_utils52.AST_NODE_TYPES.Identifier) {
+      } else if (pattern.type === import_utils56.AST_NODE_TYPES.AssignmentPattern && pattern.left.type === import_utils56.AST_NODE_TYPES.Identifier) {
         checkIdentifier(pattern.left, declarationNode);
-      } else if (pattern.type === import_utils52.AST_NODE_TYPES.RestElement && pattern.argument.type === import_utils52.AST_NODE_TYPES.Identifier) {
+      } else if (pattern.type === import_utils56.AST_NODE_TYPES.RestElement && pattern.argument.type === import_utils56.AST_NODE_TYPES.Identifier) {
         checkIdentifier(pattern.argument, declarationNode);
       }
     };
@@ -3568,11 +3739,11 @@ var noSingleCharVariables = createRule44({
 var no_single_char_variables_default = noSingleCharVariables;
 // src/rules/prefer-async-await.ts
-var import_utils53 = require("@typescript-eslint/utils");
-var createRule45 = import_utils53.ESLintUtils.RuleCreator(
+var import_utils57 = require("@typescript-eslint/utils");
+var createRule49 = import_utils57.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var preferAsyncAwait = createRule45({
+var preferAsyncAwait = createRule49({
   name: "prefer-async-await",
   meta: {
     type: "suggestion",
@@ -3588,7 +3759,7 @@ var preferAsyncAwait = createRule45({
   create(context) {
     return {
       CallExpression(node) {
-        if (node.callee.type === import_utils53.AST_NODE_TYPES.MemberExpression && node.callee.property.type === import_utils53.AST_NODE_TYPES.Identifier && node.callee.property.name === "then") {
+        if (node.callee.type === import_utils57.AST_NODE_TYPES.MemberExpression && node.callee.property.type === import_utils57.AST_NODE_TYPES.Identifier && node.callee.property.name === "then") {
           context.report({
             node: node.callee.property,
             messageId: "preferAsyncAwait"
@@ -3601,11 +3772,11 @@ var preferAsyncAwait = createRule45({
 var prefer_async_await_default = preferAsyncAwait;
 // src/rules/prefer-destructuring-params.ts
-var import_utils54 = require("@typescript-eslint/utils");
-var createRule46 = import_utils54.ESLintUtils.RuleCreator(
+var import_utils58 = require("@typescript-eslint/utils");
+var createRule50 = import_utils58.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var preferDestructuringParams = createRule46({
+var preferDestructuringParams = createRule50({
   name: "prefer-destructuring-params",
   meta: {
     type: "suggestion",
@@ -3621,18 +3792,18 @@ var preferDestructuringParams = createRule46({
   create(context) {
     const isCallbackFunction2 = (node) => {
       const { parent } = node;
-      return parent?.type === import_utils54.AST_NODE_TYPES.CallExpression;
+      return parent?.type === import_utils58.AST_NODE_TYPES.CallExpression;
     };
     const isDeveloperFunction = (node) => {
-      if (node.type === import_utils54.AST_NODE_TYPES.FunctionDeclaration) {
+      if (node.type === import_utils58.AST_NODE_TYPES.FunctionDeclaration) {
         return true;
       }
-      if (node.type === import_utils54.AST_NODE_TYPES.FunctionExpression || node.type === import_utils54.AST_NODE_TYPES.ArrowFunctionExpression) {
+      if (node.type === import_utils58.AST_NODE_TYPES.FunctionExpression || node.type === import_utils58.AST_NODE_TYPES.ArrowFunctionExpression) {
         if (isCallbackFunction2(node)) {
           return false;
         }
         const { parent } = node;
-        return parent?.type === import_utils54.AST_NODE_TYPES.VariableDeclarator || parent?.type === import_utils54.AST_NODE_TYPES.AssignmentExpression || parent?.type === import_utils54.AST_NODE_TYPES.Property || parent?.type === import_utils54.AST_NODE_TYPES.MethodDefinition;
+        return parent?.type === import_utils58.AST_NODE_TYPES.VariableDeclarator || parent?.type === import_utils58.AST_NODE_TYPES.AssignmentExpression || parent?.type === import_utils58.AST_NODE_TYPES.Property || parent?.type === import_utils58.AST_NODE_TYPES.MethodDefinition;
       }
       return false;
     };
@@ -3644,7 +3815,7 @@ var preferDestructuringParams = createRule46({
       if (!isDeveloperFunction(node)) {
         return;
       }
-      if (node.type === import_utils54.AST_NODE_TYPES.FunctionDeclaration && node.id) {
+      if (node.type === import_utils58.AST_NODE_TYPES.FunctionDeclaration && node.id) {
         const functionName = node.id.name;
         if (functionName.startsWith("_") || functionName.includes("$") || /^[A-Z][a-zA-Z]*$/.test(functionName)) {
           return;
@@ -3654,7 +3825,7 @@ var preferDestructuringParams = createRule46({
         return;
       }
       const hasNonDestructuredParams = node.params.some(
-        (param) => param.type !== import_utils54.AST_NODE_TYPES.ObjectPattern && param.type !== import_utils54.AST_NODE_TYPES.RestElement
+        (param) => param.type !== import_utils58.AST_NODE_TYPES.ObjectPattern && param.type !== import_utils58.AST_NODE_TYPES.RestElement
       );
       if (hasNonDestructuredParams) {
         context.report({
@@ -3673,8 +3844,8 @@ var preferDestructuringParams = createRule46({
 var prefer_destructuring_params_default = preferDestructuringParams;
 // src/rules/prefer-function-declaration.ts
-var import_utils55 = require("@typescript-eslint/utils");
-var createRule47 = import_utils55.ESLintUtils.RuleCreator(
+var import_utils59 = require("@typescript-eslint/utils");
+var createRule51 = import_utils59.ESLintUtils.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");
@@ -3683,33 +3854,33 @@ var isCallbackContext = (node) => {
   if (!parent) {
     return false;
   }
-  if (parent.type === import_utils55.AST_NODE_TYPES.CallExpression && parent.arguments.includes(node)) {
+  if (parent.type === import_utils59.AST_NODE_TYPES.CallExpression && parent.arguments.includes(node)) {
     return true;
   }
-  if (parent.type === import_utils55.AST_NODE_TYPES.NewExpression && parent.arguments.includes(node)) {
+  if (parent.type === import_utils59.AST_NODE_TYPES.NewExpression && parent.arguments.includes(node)) {
     return true;
   }
-  if (parent.type === import_utils55.AST_NODE_TYPES.ReturnStatement) {
+  if (parent.type === import_utils59.AST_NODE_TYPES.ReturnStatement) {
     return true;
   }
-  if (parent.type === import_utils55.AST_NODE_TYPES.Property) {
+  if (parent.type === import_utils59.AST_NODE_TYPES.Property) {
     return true;
   }
-  if (parent.type === import_utils55.AST_NODE_TYPES.ArrayExpression) {
+  if (parent.type === import_utils59.AST_NODE_TYPES.ArrayExpression) {
     return true;
   }
-  if (parent.type === import_utils55.AST_NODE_TYPES.ConditionalExpression) {
+  if (parent.type === import_utils59.AST_NODE_TYPES.ConditionalExpression) {
     return true;
   }
-  if (parent.type === import_utils55.AST_NODE_TYPES.LogicalExpression) {
+  if (parent.type === import_utils59.AST_NODE_TYPES.LogicalExpression) {
     return true;
   }
-  if (parent.type === import_utils55.AST_NODE_TYPES.AssignmentExpression && parent.left !== node) {
+  if (parent.type === import_utils59.AST_NODE_TYPES.AssignmentExpression && parent.left !== node) {
     return true;
   }
   return false;
 };
-var preferFunctionDeclaration = createRule47({
+var preferFunctionDeclaration = createRule51({
   name: "prefer-function-declaration",
   meta: {
     type: "suggestion",
@@ -3730,14 +3901,14 @@ var preferFunctionDeclaration = createRule47({
     }
     return {
       VariableDeclarator(node) {
-        if (node.id.type !== import_utils55.AST_NODE_TYPES.Identifier) {
+        if (node.id.type !== import_utils59.AST_NODE_TYPES.Identifier) {
           return;
         }
         const { init } = node;
         if (!init) {
           return;
         }
-        if (init.type === import_utils55.AST_NODE_TYPES.ArrowFunctionExpression) {
+        if (init.type === import_utils59.AST_NODE_TYPES.ArrowFunctionExpression) {
           if (isCallbackContext(init)) {
             return;
           }
@@ -3747,7 +3918,7 @@ var preferFunctionDeclaration = createRule47({
             data: { name: node.id.name }
           });
         }
-        if (init.type === import_utils55.AST_NODE_TYPES.FunctionExpression) {
+        if (init.type === import_utils59.AST_NODE_TYPES.FunctionExpression) {
           if (isCallbackContext(init)) {
             return;
           }
@@ -3764,11 +3935,11 @@ var preferFunctionDeclaration = createRule47({
 var prefer_function_declaration_default = preferFunctionDeclaration;
 // src/rules/prefer-guard-clause.ts
-var import_utils56 = require("@typescript-eslint/utils");
-var createRule48 = import_utils56.ESLintUtils.RuleCreator(
+var import_utils60 = require("@typescript-eslint/utils");
+var createRule52 = import_utils60.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var preferGuardClause = createRule48({
+var preferGuardClause = createRule52({
   name: "prefer-guard-clause",
   meta: {
     type: "suggestion",
@@ -3785,8 +3956,8 @@ var preferGuardClause = createRule48({
     return {
       IfStatement(node) {
         const { consequent } = node;
-        if (consequent.type === import_utils56.AST_NODE_TYPES.BlockStatement) {
-          const hasNestedIf = consequent.body.some((statement) => statement.type === import_utils56.AST_NODE_TYPES.IfStatement);
+        if (consequent.type === import_utils60.AST_NODE_TYPES.BlockStatement) {
+          const hasNestedIf = consequent.body.some((statement) => statement.type === import_utils60.AST_NODE_TYPES.IfStatement);
           if (hasNestedIf && consequent.body.length === 1) {
             context.report({
               node,
@@ -3794,7 +3965,7 @@ var preferGuardClause = createRule48({
             });
           }
         }
-        if (consequent.type === import_utils56.AST_NODE_TYPES.IfStatement) {
+        if (consequent.type === import_utils60.AST_NODE_TYPES.IfStatement) {
           context.report({
             node,
             messageId: "preferGuardClause"
@@ -3807,11 +3978,11 @@ var preferGuardClause = createRule48({
 var prefer_guard_clause_default = preferGuardClause;
 // src/rules/prefer-import-type.ts
-var import_utils57 = require("@typescript-eslint/utils");
-var createRule49 = import_utils57.ESLintUtils.RuleCreator(
+var import_utils61 = require("@typescript-eslint/utils");
+var createRule53 = import_utils61.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var preferImportType = createRule49({
+var preferImportType = createRule53({
   name: "prefer-import-type",
   meta: {
     type: "suggestion",
@@ -3830,22 +4001,22 @@ var preferImportType = createRule49({
       let current = node;
       while (current) {
         switch (current.type) {
-          case import_utils57.AST_NODE_TYPES.TSTypeReference:
-          case import_utils57.AST_NODE_TYPES.TSTypeAnnotation:
-          case import_utils57.AST_NODE_TYPES.TSTypeParameterInstantiation:
-          case import_utils57.AST_NODE_TYPES.TSInterfaceHeritage:
-          case import_utils57.AST_NODE_TYPES.TSClassImplements:
-          case import_utils57.AST_NODE_TYPES.TSTypeQuery:
-          case import_utils57.AST_NODE_TYPES.TSTypeAssertion:
-          case import_utils57.AST_NODE_TYPES.TSAsExpression:
-          case import_utils57.AST_NODE_TYPES.TSSatisfiesExpression:
-          case import_utils57.AST_NODE_TYPES.TSTypeAliasDeclaration:
-          case import_utils57.AST_NODE_TYPES.TSInterfaceDeclaration:
-          case import_utils57.AST_NODE_TYPES.TSTypeParameter:
-          case import_utils57.AST_NODE_TYPES.TSQualifiedName:
+          case import_utils61.AST_NODE_TYPES.TSTypeReference:
+          case import_utils61.AST_NODE_TYPES.TSTypeAnnotation:
+          case import_utils61.AST_NODE_TYPES.TSTypeParameterInstantiation:
+          case import_utils61.AST_NODE_TYPES.TSInterfaceHeritage:
+          case import_utils61.AST_NODE_TYPES.TSClassImplements:
+          case import_utils61.AST_NODE_TYPES.TSTypeQuery:
+          case import_utils61.AST_NODE_TYPES.TSTypeAssertion:
+          case import_utils61.AST_NODE_TYPES.TSAsExpression:
+          case import_utils61.AST_NODE_TYPES.TSSatisfiesExpression:
+          case import_utils61.AST_NODE_TYPES.TSTypeAliasDeclaration:
+          case import_utils61.AST_NODE_TYPES.TSInterfaceDeclaration:
+          case import_utils61.AST_NODE_TYPES.TSTypeParameter:
+          case import_utils61.AST_NODE_TYPES.TSQualifiedName:
             return true;
-          case import_utils57.AST_NODE_TYPES.MemberExpression:
-          case import_utils57.AST_NODE_TYPES.Identifier:
+          case import_utils61.AST_NODE_TYPES.MemberExpression:
+          case import_utils61.AST_NODE_TYPES.Identifier:
             current = current.parent;
             break;
           default:
@@ -3875,27 +4046,27 @@ var preferImportType = createRule49({
           return false;
         }
         switch (parent.type) {
-          case import_utils57.AST_NODE_TYPES.CallExpression:
-          case import_utils57.AST_NODE_TYPES.NewExpression:
-          case import_utils57.AST_NODE_TYPES.JSXOpeningElement:
-          case import_utils57.AST_NODE_TYPES.JSXClosingElement:
-          case import_utils57.AST_NODE_TYPES.MemberExpression:
-          case import_utils57.AST_NODE_TYPES.VariableDeclarator:
-          case import_utils57.AST_NODE_TYPES.TaggedTemplateExpression:
-          case import_utils57.AST_NODE_TYPES.SpreadElement:
-          case import_utils57.AST_NODE_TYPES.ExportSpecifier:
-          case import_utils57.AST_NODE_TYPES.ArrayExpression:
-          case import_utils57.AST_NODE_TYPES.ObjectExpression:
-          case import_utils57.AST_NODE_TYPES.BinaryExpression:
-          case import_utils57.AST_NODE_TYPES.LogicalExpression:
-          case import_utils57.AST_NODE_TYPES.UnaryExpression:
-          case import_utils57.AST_NODE_TYPES.ReturnStatement:
-          case import_utils57.AST_NODE_TYPES.ArrowFunctionExpression:
-          case import_utils57.AST_NODE_TYPES.ConditionalExpression:
-          case import_utils57.AST_NODE_TYPES.AwaitExpression:
-          case import_utils57.AST_NODE_TYPES.YieldExpression:
-          case import_utils57.AST_NODE_TYPES.Property:
-          case import_utils57.AST_NODE_TYPES.JSXExpressionContainer:
+          case import_utils61.AST_NODE_TYPES.CallExpression:
+          case import_utils61.AST_NODE_TYPES.NewExpression:
+          case import_utils61.AST_NODE_TYPES.JSXOpeningElement:
+          case import_utils61.AST_NODE_TYPES.JSXClosingElement:
+          case import_utils61.AST_NODE_TYPES.MemberExpression:
+          case import_utils61.AST_NODE_TYPES.VariableDeclarator:
+          case import_utils61.AST_NODE_TYPES.TaggedTemplateExpression:
+          case import_utils61.AST_NODE_TYPES.SpreadElement:
+          case import_utils61.AST_NODE_TYPES.ExportSpecifier:
+          case import_utils61.AST_NODE_TYPES.ArrayExpression:
+          case import_utils61.AST_NODE_TYPES.ObjectExpression:
+          case import_utils61.AST_NODE_TYPES.BinaryExpression:
+          case import_utils61.AST_NODE_TYPES.LogicalExpression:
+          case import_utils61.AST_NODE_TYPES.UnaryExpression:
+          case import_utils61.AST_NODE_TYPES.ReturnStatement:
+          case import_utils61.AST_NODE_TYPES.ArrowFunctionExpression:
+          case import_utils61.AST_NODE_TYPES.ConditionalExpression:
+          case import_utils61.AST_NODE_TYPES.AwaitExpression:
+          case import_utils61.AST_NODE_TYPES.YieldExpression:
+          case import_utils61.AST_NODE_TYPES.Property:
+          case import_utils61.AST_NODE_TYPES.JSXExpressionContainer:
             return true;
           default:
             return false;
@@ -3907,7 +4078,7 @@ var preferImportType = createRule49({
         return;
       }
       const hasInlineTypeSpecifier = node.specifiers.some(
-        (specifier) => specifier.type === import_utils57.AST_NODE_TYPES.ImportSpecifier && specifier.importKind === "type"
+        (specifier) => specifier.type === import_utils61.AST_NODE_TYPES.ImportSpecifier && specifier.importKind === "type"
       );
       if (hasInlineTypeSpecifier) {
         return;
@@ -3925,13 +4096,13 @@ var preferImportType = createRule49({
       }
       const scope = context.sourceCode.getScope(node);
       const isTypeOnlyImport2 = node.specifiers.every((specifier) => {
-        if (specifier.type === import_utils57.AST_NODE_TYPES.ImportDefaultSpecifier) {
+        if (specifier.type === import_utils61.AST_NODE_TYPES.ImportDefaultSpecifier) {
           return false;
         }
-        if (specifier.type === import_utils57.AST_NODE_TYPES.ImportNamespaceSpecifier) {
+        if (specifier.type === import_utils61.AST_NODE_TYPES.ImportNamespaceSpecifier) {
           return false;
         }
-        if (specifier.type === import_utils57.AST_NODE_TYPES.ImportSpecifier) {
+        if (specifier.type === import_utils61.AST_NODE_TYPES.ImportSpecifier) {
           const localName = specifier.local.name;
           return !isUsedAsValue(localName, scope);
         }
@@ -3957,19 +4128,19 @@ var preferImportType = createRule49({
 var prefer_import_type_default = preferImportType;
 // src/rules/prefer-inline-literal-union.ts
-var import_utils58 = require("@typescript-eslint/utils");
-var createRule50 = import_utils58.ESLintUtils.RuleCreator(
+var import_utils62 = require("@typescript-eslint/utils");
+var createRule54 = import_utils62.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 function isLiteralUnionType(node) {
-  if (node.type !== import_utils58.AST_NODE_TYPES.TSUnionType) {
+  if (node.type !== import_utils62.AST_NODE_TYPES.TSUnionType) {
     return false;
   }
   return node.types.every(
-    (member) => member.type === import_utils58.AST_NODE_TYPES.TSLiteralType || member.type === import_utils58.AST_NODE_TYPES.TSNullKeyword || member.type === import_utils58.AST_NODE_TYPES.TSUndefinedKeyword
+    (member) => member.type === import_utils62.AST_NODE_TYPES.TSLiteralType || member.type === import_utils62.AST_NODE_TYPES.TSNullKeyword || member.type === import_utils62.AST_NODE_TYPES.TSUndefinedKeyword
   );
 }
-var preferInlineLiteralUnion = createRule50({
+var preferInlineLiteralUnion = createRule54({
   name: "prefer-inline-literal-union",
   meta: {
     type: "suggestion",
@@ -3996,10 +4167,10 @@ var preferInlineLiteralUnion = createRule50({
           return;
         }
         const { typeAnnotation } = node.typeAnnotation;
-        if (typeAnnotation.type !== import_utils58.AST_NODE_TYPES.TSTypeReference) {
+        if (typeAnnotation.type !== import_utils62.AST_NODE_TYPES.TSTypeReference) {
           return;
         }
-        if (typeAnnotation.typeName.type !== import_utils58.AST_NODE_TYPES.Identifier) {
+        if (typeAnnotation.typeName.type !== import_utils62.AST_NODE_TYPES.Identifier) {
           return;
         }
         const aliasName = typeAnnotation.typeName.name;
@@ -4023,12 +4194,12 @@ var preferInlineLiteralUnion = createRule50({
 var prefer_inline_literal_union_default = preferInlineLiteralUnion;
 // src/rules/prefer-inline-type-export.ts
-var import_utils59 = require("@typescript-eslint/utils");
-var createRule51 = import_utils59.ESLintUtils.RuleCreator(
+var import_utils63 = require("@typescript-eslint/utils");
+var createRule55 = import_utils63.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var isTypeDeclaration = (node) => node.type === import_utils59.AST_NODE_TYPES.TSInterfaceDeclaration || node.type === import_utils59.AST_NODE_TYPES.TSTypeAliasDeclaration;
-var preferInlineTypeExport = createRule51({
+var isTypeDeclaration = (node) => node.type === import_utils63.AST_NODE_TYPES.TSInterfaceDeclaration || node.type === import_utils63.AST_NODE_TYPES.TSTypeAliasDeclaration;
+var preferInlineTypeExport = createRule55({
   name: "prefer-inline-type-export",
   meta: {
     type: "suggestion",
@@ -4045,12 +4216,12 @@ var preferInlineTypeExport = createRule51({
   create(context) {
     const typeDeclarations = /* @__PURE__ */ new Map();
     function collectDeclaration(node) {
-      if (node.parent.type !== import_utils59.AST_NODE_TYPES.ExportNamedDeclaration) {
+      if (node.parent.type !== import_utils63.AST_NODE_TYPES.ExportNamedDeclaration) {
         typeDeclarations.set(node.id.name, node);
       }
     }
     function reportSpecifier(specifier, statement, declarationNode) {
-      if (specifier.local.type !== import_utils59.AST_NODE_TYPES.Identifier) {
+      if (specifier.local.type !== import_utils63.AST_NODE_TYPES.Identifier) {
         return;
       }
       const { name } = specifier.local;
@@ -4083,16 +4254,16 @@ var preferInlineTypeExport = createRule51({
     return {
       Program(node) {
         node.body.forEach((statement) => {
-          if (statement.type === import_utils59.AST_NODE_TYPES.TSInterfaceDeclaration || statement.type === import_utils59.AST_NODE_TYPES.TSTypeAliasDeclaration) {
+          if (statement.type === import_utils63.AST_NODE_TYPES.TSInterfaceDeclaration || statement.type === import_utils63.AST_NODE_TYPES.TSTypeAliasDeclaration) {
             collectDeclaration(statement);
           }
         });
         node.body.forEach((statement) => {
-          if (statement.type !== import_utils59.AST_NODE_TYPES.ExportNamedDeclaration || statement.declaration !== null) {
+          if (statement.type !== import_utils63.AST_NODE_TYPES.ExportNamedDeclaration || statement.declaration !== null) {
             return;
           }
           statement.specifiers.forEach((specifier) => {
-            if (specifier.local.type !== import_utils59.AST_NODE_TYPES.Identifier) {
+            if (specifier.local.type !== import_utils63.AST_NODE_TYPES.Identifier) {
               return;
             }
             const declarationNode = typeDeclarations.get(specifier.local.name);
@@ -4109,11 +4280,11 @@ var preferInlineTypeExport = createRule51({
 var prefer_inline_type_export_default = preferInlineTypeExport;
 // src/rules/prefer-interface-for-component-props.ts
-var import_utils60 = require("@typescript-eslint/utils");
-var createRule52 = import_utils60.ESLintUtils.RuleCreator(
+var import_utils64 = require("@typescript-eslint/utils");
+var createRule56 = import_utils64.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var preferInterfaceForComponentProps = createRule52({
+var preferInterfaceForComponentProps = createRule56({
   name: "prefer-interface-for-component-props",
   meta: {
     type: "suggestion",
@@ -4133,13 +4304,13 @@ var preferInterfaceForComponentProps = createRule52({
     }
     return {
       TSTypeAliasDeclaration(node) {
-        if (node.id.type !== import_utils60.AST_NODE_TYPES.Identifier) {
+        if (node.id.type !== import_utils64.AST_NODE_TYPES.Identifier) {
           return;
         }
         if (!node.id.name.endsWith("Props")) {
           return;
         }
-        if (node.typeAnnotation.type !== import_utils60.AST_NODE_TYPES.TSTypeLiteral) {
+        if (node.typeAnnotation.type !== import_utils64.AST_NODE_TYPES.TSTypeLiteral) {
           return;
         }
         const { name } = node.id;
@@ -4166,11 +4337,11 @@ var preferInterfaceForComponentProps = createRule52({
 var prefer_interface_for_component_props_default = preferInterfaceForComponentProps;
 // src/rules/prefer-interface-over-inline-types.ts
-var import_utils62 = require("@typescript-eslint/utils");
-var createRule53 = import_utils62.ESLintUtils.RuleCreator(
+var import_utils66 = require("@typescript-eslint/utils");
+var createRule57 = import_utils66.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var preferInterfaceOverInlineTypes = createRule53({
+var preferInterfaceOverInlineTypes = createRule57({
   name: "prefer-interface-over-inline-types",
   meta: {
     type: "suggestion",
@@ -4186,54 +4357,54 @@ var preferInterfaceOverInlineTypes = createRule53({
   defaultOptions: [],
   create(context) {
     function hasJSXInConditional(node) {
-      return node.consequent.type === import_utils62.AST_NODE_TYPES.JSXElement || node.consequent.type === import_utils62.AST_NODE_TYPES.JSXFragment || node.alternate.type === import_utils62.AST_NODE_TYPES.JSXElement || node.alternate.type === import_utils62.AST_NODE_TYPES.JSXFragment;
+      return node.consequent.type === import_utils66.AST_NODE_TYPES.JSXElement || node.consequent.type === import_utils66.AST_NODE_TYPES.JSXFragment || node.alternate.type === import_utils66.AST_NODE_TYPES.JSXElement || node.alternate.type === import_utils66.AST_NODE_TYPES.JSXFragment;
     }
     function hasJSXInLogical(node) {
-      return node.right.type === import_utils62.AST_NODE_TYPES.JSXElement || node.right.type === import_utils62.AST_NODE_TYPES.JSXFragment;
+      return node.right.type === import_utils66.AST_NODE_TYPES.JSXElement || node.right.type === import_utils66.AST_NODE_TYPES.JSXFragment;
     }
     function hasJSXReturn(block) {
       return block.body.some((stmt) => {
-        if (stmt.type === import_utils62.AST_NODE_TYPES.ReturnStatement && stmt.argument) {
-          return stmt.argument.type === import_utils62.AST_NODE_TYPES.JSXElement || stmt.argument.type === import_utils62.AST_NODE_TYPES.JSXFragment || stmt.argument.type === import_utils62.AST_NODE_TYPES.ConditionalExpression && hasJSXInConditional(stmt.argument) || stmt.argument.type === import_utils62.AST_NODE_TYPES.LogicalExpression && hasJSXInLogical(stmt.argument);
+        if (stmt.type === import_utils66.AST_NODE_TYPES.ReturnStatement && stmt.argument) {
+          return stmt.argument.type === import_utils66.AST_NODE_TYPES.JSXElement || stmt.argument.type === import_utils66.AST_NODE_TYPES.JSXFragment || stmt.argument.type === import_utils66.AST_NODE_TYPES.ConditionalExpression && hasJSXInConditional(stmt.argument) || stmt.argument.type === import_utils66.AST_NODE_TYPES.LogicalExpression && hasJSXInLogical(stmt.argument);
         }
         return false;
       });
     }
     function isReactComponent2(node) {
-      if (node.type === import_utils62.AST_NODE_TYPES.ArrowFunctionExpression) {
-        if (node.body.type === import_utils62.AST_NODE_TYPES.JSXElement || node.body.type === import_utils62.AST_NODE_TYPES.JSXFragment) {
+      if (node.type === import_utils66.AST_NODE_TYPES.ArrowFunctionExpression) {
+        if (node.body.type === import_utils66.AST_NODE_TYPES.JSXElement || node.body.type === import_utils66.AST_NODE_TYPES.JSXFragment) {
           return true;
         }
-        if (node.body.type === import_utils62.AST_NODE_TYPES.BlockStatement) {
+        if (node.body.type === import_utils66.AST_NODE_TYPES.BlockStatement) {
           return hasJSXReturn(node.body);
         }
-      } else if (node.type === import_utils62.AST_NODE_TYPES.FunctionExpression || node.type === import_utils62.AST_NODE_TYPES.FunctionDeclaration) {
-        if (node.body && node.body.type === import_utils62.AST_NODE_TYPES.BlockStatement) {
+      } else if (node.type === import_utils66.AST_NODE_TYPES.FunctionExpression || node.type === import_utils66.AST_NODE_TYPES.FunctionDeclaration) {
+        if (node.body && node.body.type === import_utils66.AST_NODE_TYPES.BlockStatement) {
           return hasJSXReturn(node.body);
         }
       }
       return false;
     }
     function isInlineTypeAnnotation(node) {
-      if (node.type === import_utils62.AST_NODE_TYPES.TSTypeLiteral) {
+      if (node.type === import_utils66.AST_NODE_TYPES.TSTypeLiteral) {
         return true;
       }
-      if (node.type === import_utils62.AST_NODE_TYPES.TSTypeReference && node.typeArguments) {
-        return node.typeArguments.params.some((param) => param.type === import_utils62.AST_NODE_TYPES.TSTypeLiteral);
+      if (node.type === import_utils66.AST_NODE_TYPES.TSTypeReference && node.typeArguments) {
+        return node.typeArguments.params.some((param) => param.type === import_utils66.AST_NODE_TYPES.TSTypeLiteral);
       }
-      if (node.type === import_utils62.AST_NODE_TYPES.TSUnionType) {
+      if (node.type === import_utils66.AST_NODE_TYPES.TSUnionType) {
         return node.types.some((type) => isInlineTypeAnnotation(type));
       }
       return false;
     }
     function hasInlineObjectType(node) {
-      if (node.type === import_utils62.AST_NODE_TYPES.TSTypeLiteral) {
+      if (node.type === import_utils66.AST_NODE_TYPES.TSTypeLiteral) {
         return true;
       }
-      if (node.type === import_utils62.AST_NODE_TYPES.TSTypeReference && node.typeArguments) {
-        return node.typeArguments.params.some((param) => param.type === import_utils62.AST_NODE_TYPES.TSTypeLiteral);
+      if (node.type === import_utils66.AST_NODE_TYPES.TSTypeReference && node.typeArguments) {
+        return node.typeArguments.params.some((param) => param.type === import_utils66.AST_NODE_TYPES.TSTypeLiteral);
       }
-      if (node.type === import_utils62.AST_NODE_TYPES.TSUnionType) {
+      if (node.type === import_utils66.AST_NODE_TYPES.TSUnionType) {
         return node.types.some((type) => hasInlineObjectType(type));
       }
       return false;
@@ -4246,7 +4417,7 @@ var preferInterfaceOverInlineTypes = createRule53({
         return;
       }
       const param = node.params[0];
-      if (param.type === import_utils62.AST_NODE_TYPES.Identifier && param.typeAnnotation) {
+      if (param.type === import_utils66.AST_NODE_TYPES.Identifier && param.typeAnnotation) {
         const { typeAnnotation } = param.typeAnnotation;
         if (isInlineTypeAnnotation(typeAnnotation) && hasInlineObjectType(typeAnnotation)) {
           context.report({
@@ -4266,11 +4437,11 @@ var preferInterfaceOverInlineTypes = createRule53({
 var prefer_interface_over_inline_types_default = preferInterfaceOverInlineTypes;
 // src/rules/prefer-jsx-template-literals.ts
-var import_utils63 = require("@typescript-eslint/utils");
-var createRule54 = import_utils63.ESLintUtils.RuleCreator(
+var import_utils67 = require("@typescript-eslint/utils");
+var createRule58 = import_utils67.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var preferJSXTemplateLiterals = createRule54({
+var preferJSXTemplateLiterals = createRule58({
   name: "prefer-jsx-template-literals",
   meta: {
     type: "suggestion",
@@ -4339,9 +4510,9 @@ var preferJSXTemplateLiterals = createRule54({
         if (!child || !nextChild) {
           return;
         }
-        if (child.type === import_utils63.AST_NODE_TYPES.JSXText && nextChild.type === import_utils63.AST_NODE_TYPES.JSXExpressionContainer) {
+        if (child.type === import_utils67.AST_NODE_TYPES.JSXText && nextChild.type === import_utils67.AST_NODE_TYPES.JSXExpressionContainer) {
           handleTextBeforeExpression(child, nextChild);
-        } else if (child.type === import_utils63.AST_NODE_TYPES.JSXExpressionContainer && nextChild.type === import_utils63.AST_NODE_TYPES.JSXText) {
+        } else if (child.type === import_utils67.AST_NODE_TYPES.JSXExpressionContainer && nextChild.type === import_utils67.AST_NODE_TYPES.JSXText) {
           handleExpressionBeforeText(child, nextChild);
         }
       }
@@ -4354,32 +4525,32 @@ var preferJSXTemplateLiterals = createRule54({
 var prefer_jsx_template_literals_default = preferJSXTemplateLiterals;
 // src/rules/prefer-named-param-types.ts
-var import_utils64 = require("@typescript-eslint/utils");
-var createRule55 = import_utils64.ESLintUtils.RuleCreator(
+var import_utils68 = require("@typescript-eslint/utils");
+var createRule59 = import_utils68.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var returnsJsx2 = (node) => {
-  if (node.type === import_utils64.AST_NODE_TYPES.JSXElement || node.type === import_utils64.AST_NODE_TYPES.JSXFragment) {
+  if (node.type === import_utils68.AST_NODE_TYPES.JSXElement || node.type === import_utils68.AST_NODE_TYPES.JSXFragment) {
     return true;
   }
-  if (node.type === import_utils64.AST_NODE_TYPES.ConditionalExpression) {
+  if (node.type === import_utils68.AST_NODE_TYPES.ConditionalExpression) {
     return returnsJsx2(node.consequent) || returnsJsx2(node.alternate);
   }
-  if (node.type === import_utils64.AST_NODE_TYPES.LogicalExpression) {
+  if (node.type === import_utils68.AST_NODE_TYPES.LogicalExpression) {
     return returnsJsx2(node.left) || returnsJsx2(node.right);
   }
   return false;
 };
 var bodyReturnsJsx2 = (body) => {
-  if (body.type !== import_utils64.AST_NODE_TYPES.BlockStatement) {
+  if (body.type !== import_utils68.AST_NODE_TYPES.BlockStatement) {
     return returnsJsx2(body);
   }
   return body.body.some(
-    (stmt) => stmt.type === import_utils64.AST_NODE_TYPES.ReturnStatement && stmt.argument !== null && returnsJsx2(stmt.argument)
+    (stmt) => stmt.type === import_utils68.AST_NODE_TYPES.ReturnStatement && stmt.argument !== null && returnsJsx2(stmt.argument)
   );
 };
 var isReactComponentFunction = (node) => bodyReturnsJsx2(node.body);
-var preferNamedParamTypes = createRule55({
+var preferNamedParamTypes = createRule59({
   name: "prefer-named-param-types",
   meta: {
     type: "suggestion",
@@ -4394,16 +4565,16 @@ var preferNamedParamTypes = createRule55({
   defaultOptions: [],
   create(context) {
     function hasInlineObjectType(param) {
-      if (param.type === import_utils64.AST_NODE_TYPES.AssignmentPattern) {
+      if (param.type === import_utils68.AST_NODE_TYPES.AssignmentPattern) {
         return hasInlineObjectType(param.left);
       }
-      if (param.type === import_utils64.AST_NODE_TYPES.ObjectPattern) {
-        if (param.typeAnnotation?.typeAnnotation.type === import_utils64.AST_NODE_TYPES.TSTypeLiteral) {
+      if (param.type === import_utils68.AST_NODE_TYPES.ObjectPattern) {
+        if (param.typeAnnotation?.typeAnnotation.type === import_utils68.AST_NODE_TYPES.TSTypeLiteral) {
           return true;
         }
       }
-      if (param.type === import_utils64.AST_NODE_TYPES.Identifier) {
-        if (param.typeAnnotation?.typeAnnotation.type === import_utils64.AST_NODE_TYPES.TSTypeLiteral) {
+      if (param.type === import_utils68.AST_NODE_TYPES.Identifier) {
+        if (param.typeAnnotation?.typeAnnotation.type === import_utils68.AST_NODE_TYPES.TSTypeLiteral) {
           return true;
         }
       }
@@ -4416,7 +4587,7 @@ var preferNamedParamTypes = createRule55({
       } else if ("value" in node && node.value) {
         params = node.value.params;
       }
-      if ((node.type === import_utils64.AST_NODE_TYPES.FunctionDeclaration || node.type === import_utils64.AST_NODE_TYPES.FunctionExpression || node.type === import_utils64.AST_NODE_TYPES.ArrowFunctionExpression) && params.length === 1 && params[0].type === import_utils64.AST_NODE_TYPES.Identifier && isReactComponentFunction(node)) {
+      if ((node.type === import_utils68.AST_NODE_TYPES.FunctionDeclaration || node.type === import_utils68.AST_NODE_TYPES.FunctionExpression || node.type === import_utils68.AST_NODE_TYPES.ArrowFunctionExpression) && params.length === 1 && params[0].type === import_utils68.AST_NODE_TYPES.Identifier && isReactComponentFunction(node)) {
         return;
       }
       params.forEach((param) => {
@@ -4440,11 +4611,11 @@ var preferNamedParamTypes = createRule55({
 var prefer_named_param_types_default = preferNamedParamTypes;
 // src/rules/prefer-props-with-children.ts
-var import_utils65 = require("@typescript-eslint/utils");
-var createRule56 = import_utils65.ESLintUtils.RuleCreator(
+var import_utils69 = require("@typescript-eslint/utils");
+var createRule60 = import_utils69.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var preferPropsWithChildren = createRule56({
+var preferPropsWithChildren = createRule60({
   name: "prefer-props-with-children",
   meta: {
     type: "suggestion",
@@ -4462,24 +4633,24 @@ var preferPropsWithChildren = createRule56({
       if (!typeNode) {
         return false;
       }
-      if (typeNode.type !== import_utils65.AST_NODE_TYPES.TSTypeReference) {
+      if (typeNode.type !== import_utils69.AST_NODE_TYPES.TSTypeReference) {
         return false;
       }
       const { typeName } = typeNode;
-      if (typeName.type === import_utils65.AST_NODE_TYPES.Identifier) {
+      if (typeName.type === import_utils69.AST_NODE_TYPES.Identifier) {
         return typeName.name === "ReactNode";
       }
-      if (typeName.type === import_utils65.AST_NODE_TYPES.TSQualifiedName && typeName.left.type === import_utils65.AST_NODE_TYPES.Identifier && typeName.left.name === "React" && typeName.right.type === import_utils65.AST_NODE_TYPES.Identifier && typeName.right.name === "ReactNode") {
+      if (typeName.type === import_utils69.AST_NODE_TYPES.TSQualifiedName && typeName.left.type === import_utils69.AST_NODE_TYPES.Identifier && typeName.left.name === "React" && typeName.right.type === import_utils69.AST_NODE_TYPES.Identifier && typeName.right.name === "ReactNode") {
         return true;
       }
       return false;
     }
     function findChildrenReactNode(members) {
       for (const member of members) {
-        if (member.type !== import_utils65.AST_NODE_TYPES.TSPropertySignature) {
+        if (member.type !== import_utils69.AST_NODE_TYPES.TSPropertySignature) {
           continue;
         }
-        if (member.key.type !== import_utils65.AST_NODE_TYPES.Identifier) {
+        if (member.key.type !== import_utils69.AST_NODE_TYPES.Identifier) {
           continue;
         }
         if (member.key.name !== "children") {
@@ -4519,11 +4690,11 @@ var preferPropsWithChildren = createRule56({
 var prefer_props_with_children_default = preferPropsWithChildren;
 // src/rules/prefer-react-import-types.ts
-var import_utils66 = require("@typescript-eslint/utils");
-var createRule57 = import_utils66.ESLintUtils.RuleCreator(
+var import_utils70 = require("@typescript-eslint/utils");
+var createRule61 = import_utils70.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var preferReactImportTypes = createRule57({
+var preferReactImportTypes = createRule61({
   name: "prefer-react-import-types",
   meta: {
     type: "suggestion",
@@ -4599,7 +4770,7 @@ var preferReactImportTypes = createRule57({
     ]);
     const allReactExports = /* @__PURE__ */ new Set([...reactTypes, ...reactRuntimeExports]);
     function checkMemberExpression(node) {
-      if (node.object.type === import_utils66.AST_NODE_TYPES.Identifier && node.object.name === "React" && node.property.type === import_utils66.AST_NODE_TYPES.Identifier && allReactExports.has(node.property.name)) {
+      if (node.object.type === import_utils70.AST_NODE_TYPES.Identifier && node.object.name === "React" && node.property.type === import_utils70.AST_NODE_TYPES.Identifier && allReactExports.has(node.property.name)) {
         const typeName = node.property.name;
         const isType = reactTypes.has(typeName);
         const importStatement = isType ? `import type { ${typeName} } from "react"` : `import { ${typeName} } from "react"`;
@@ -4616,7 +4787,7 @@ var preferReactImportTypes = createRule57({
     return {
       MemberExpression: checkMemberExpression,
       "TSTypeReference > TSQualifiedName": (node) => {
-        if (node.left.type === import_utils66.AST_NODE_TYPES.Identifier && node.left.name === "React" && node.right.type === import_utils66.AST_NODE_TYPES.Identifier && allReactExports.has(node.right.name)) {
+        if (node.left.type === import_utils70.AST_NODE_TYPES.Identifier && node.left.name === "React" && node.right.type === import_utils70.AST_NODE_TYPES.Identifier && allReactExports.has(node.right.name)) {
           const typeName = node.right.name;
           const isType = reactTypes.has(typeName);
           const importStatement = isType ? `import type { ${typeName} } from "react"` : `import { ${typeName} } from "react"`;
@@ -4636,11 +4807,11 @@ var preferReactImportTypes = createRule57({
 var prefer_react_import_types_default = preferReactImportTypes;
 // src/rules/react-props-destructure.ts
-var import_utils67 = require("@typescript-eslint/utils");
-var createRule58 = import_utils67.ESLintUtils.RuleCreator(
+var import_utils71 = require("@typescript-eslint/utils");
+var createRule62 = import_utils71.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var reactPropsDestructure = createRule58({
+var reactPropsDestructure = createRule62({
   name: "react-props-destructure",
   meta: {
     type: "suggestion",
@@ -4656,29 +4827,29 @@ var reactPropsDestructure = createRule58({
   defaultOptions: [],
   create(context) {
     function hasJSXInConditional(node) {
-      return node.consequent.type === import_utils67.AST_NODE_TYPES.JSXElement || node.consequent.type === import_utils67.AST_NODE_TYPES.JSXFragment || node.alternate.type === import_utils67.AST_NODE_TYPES.JSXElement || node.alternate.type === import_utils67.AST_NODE_TYPES.JSXFragment;
+      return node.consequent.type === import_utils71.AST_NODE_TYPES.JSXElement || node.consequent.type === import_utils71.AST_NODE_TYPES.JSXFragment || node.alternate.type === import_utils71.AST_NODE_TYPES.JSXElement || node.alternate.type === import_utils71.AST_NODE_TYPES.JSXFragment;
     }
     function hasJSXInLogical(node) {
-      return node.right.type === import_utils67.AST_NODE_TYPES.JSXElement || node.right.type === import_utils67.AST_NODE_TYPES.JSXFragment;
+      return node.right.type === import_utils71.AST_NODE_TYPES.JSXElement || node.right.type === import_utils71.AST_NODE_TYPES.JSXFragment;
     }
     function hasJSXReturn(block) {
       return block.body.some((stmt) => {
-        if (stmt.type === import_utils67.AST_NODE_TYPES.ReturnStatement && stmt.argument) {
-          return stmt.argument.type === import_utils67.AST_NODE_TYPES.JSXElement || stmt.argument.type === import_utils67.AST_NODE_TYPES.JSXFragment || stmt.argument.type === import_utils67.AST_NODE_TYPES.ConditionalExpression && hasJSXInConditional(stmt.argument) || stmt.argument.type === import_utils67.AST_NODE_TYPES.LogicalExpression && hasJSXInLogical(stmt.argument);
+        if (stmt.type === import_utils71.AST_NODE_TYPES.ReturnStatement && stmt.argument) {
+          return stmt.argument.type === import_utils71.AST_NODE_TYPES.JSXElement || stmt.argument.type === import_utils71.AST_NODE_TYPES.JSXFragment || stmt.argument.type === import_utils71.AST_NODE_TYPES.ConditionalExpression && hasJSXInConditional(stmt.argument) || stmt.argument.type === import_utils71.AST_NODE_TYPES.LogicalExpression && hasJSXInLogical(stmt.argument);
         }
         return false;
       });
     }
     function isReactComponent2(node) {
-      if (node.type === import_utils67.AST_NODE_TYPES.ArrowFunctionExpression) {
-        if (node.body.type === import_utils67.AST_NODE_TYPES.JSXElement || node.body.type === import_utils67.AST_NODE_TYPES.JSXFragment) {
+      if (node.type === import_utils71.AST_NODE_TYPES.ArrowFunctionExpression) {
+        if (node.body.type === import_utils71.AST_NODE_TYPES.JSXElement || node.body.type === import_utils71.AST_NODE_TYPES.JSXFragment) {
           return true;
         }
-        if (node.body.type === import_utils67.AST_NODE_TYPES.BlockStatement) {
+        if (node.body.type === import_utils71.AST_NODE_TYPES.BlockStatement) {
           return hasJSXReturn(node.body);
         }
-      } else if (node.type === import_utils67.AST_NODE_TYPES.FunctionExpression || node.type === import_utils67.AST_NODE_TYPES.FunctionDeclaration) {
-        if (node.body && node.body.type === import_utils67.AST_NODE_TYPES.BlockStatement) {
+      } else if (node.type === import_utils71.AST_NODE_TYPES.FunctionExpression || node.type === import_utils71.AST_NODE_TYPES.FunctionDeclaration) {
+        if (node.body && node.body.type === import_utils71.AST_NODE_TYPES.BlockStatement) {
           return hasJSXReturn(node.body);
         }
       }
@@ -4692,9 +4863,9 @@ var reactPropsDestructure = createRule58({
         return;
       }
       const param = node.params[0];
-      if (param.type === import_utils67.AST_NODE_TYPES.ObjectPattern) {
-        const properties = param.properties.filter((prop) => prop.type === import_utils67.AST_NODE_TYPES.Property).map((prop) => {
-          if (prop.key.type === import_utils67.AST_NODE_TYPES.Identifier) {
+      if (param.type === import_utils71.AST_NODE_TYPES.ObjectPattern) {
+        const properties = param.properties.filter((prop) => prop.type === import_utils71.AST_NODE_TYPES.Property).map((prop) => {
+          if (prop.key.type === import_utils71.AST_NODE_TYPES.Identifier) {
             return prop.key.name;
           }
           return null;
@@ -4721,57 +4892,57 @@ var reactPropsDestructure = createRule58({
 var react_props_destructure_default = reactPropsDestructure;
 // src/rules/require-explicit-return-type.ts
-var import_utils68 = require("@typescript-eslint/utils");
-var createRule59 = import_utils68.ESLintUtils.RuleCreator(
+var import_utils72 = require("@typescript-eslint/utils");
+var createRule63 = import_utils72.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var isReactComponent = (node) => {
-  if (node.type === import_utils68.AST_NODE_TYPES.ArrowFunctionExpression) {
+  if (node.type === import_utils72.AST_NODE_TYPES.ArrowFunctionExpression) {
     const { parent } = node;
-    if (parent?.type === import_utils68.AST_NODE_TYPES.VariableDeclarator) {
+    if (parent?.type === import_utils72.AST_NODE_TYPES.VariableDeclarator) {
       const { id } = parent;
-      if (id.type === import_utils68.AST_NODE_TYPES.Identifier) {
+      if (id.type === import_utils72.AST_NODE_TYPES.Identifier) {
         return /^[A-Z]/.test(id.name);
       }
     }
   }
-  if (node.type === import_utils68.AST_NODE_TYPES.FunctionDeclaration && node.id) {
+  if (node.type === import_utils72.AST_NODE_TYPES.FunctionDeclaration && node.id) {
     return /^[A-Z]/.test(node.id.name);
   }
   return false;
 };
 var isCallbackFunction = (node) => {
-  if (node.type === import_utils68.AST_NODE_TYPES.FunctionDeclaration) {
+  if (node.type === import_utils72.AST_NODE_TYPES.FunctionDeclaration) {
     return false;
   }
   const { parent } = node;
   if (!parent) {
     return false;
   }
-  if (parent.type === import_utils68.AST_NODE_TYPES.CallExpression && parent.arguments.includes(node)) {
+  if (parent.type === import_utils72.AST_NODE_TYPES.CallExpression && parent.arguments.includes(node)) {
     return true;
   }
-  if (parent.type === import_utils68.AST_NODE_TYPES.Property) {
+  if (parent.type === import_utils72.AST_NODE_TYPES.Property) {
     return true;
   }
-  if (parent.type === import_utils68.AST_NODE_TYPES.ArrayExpression) {
+  if (parent.type === import_utils72.AST_NODE_TYPES.ArrayExpression) {
     return true;
   }
   return false;
 };
 var getFunctionName = (node) => {
-  if (node.type === import_utils68.AST_NODE_TYPES.FunctionDeclaration && node.id) {
+  if (node.type === import_utils72.AST_NODE_TYPES.FunctionDeclaration && node.id) {
     return node.id.name;
   }
-  if (node.type === import_utils68.AST_NODE_TYPES.FunctionExpression && node.id) {
+  if (node.type === import_utils72.AST_NODE_TYPES.FunctionExpression && node.id) {
     return node.id.name;
   }
-  if ((node.type === import_utils68.AST_NODE_TYPES.ArrowFunctionExpression || node.type === import_utils68.AST_NODE_TYPES.FunctionExpression) && node.parent?.type === import_utils68.AST_NODE_TYPES.VariableDeclarator && node.parent.id.type === import_utils68.AST_NODE_TYPES.Identifier) {
+  if ((node.type === import_utils72.AST_NODE_TYPES.ArrowFunctionExpression || node.type === import_utils72.AST_NODE_TYPES.FunctionExpression) && node.parent?.type === import_utils72.AST_NODE_TYPES.VariableDeclarator && node.parent.id.type === import_utils72.AST_NODE_TYPES.Identifier) {
     return node.parent.id.name;
   }
   return null;
 };
-var requireExplicitReturnType = createRule59({
+var requireExplicitReturnType = createRule63({
   name: "require-explicit-return-type",
   meta: {
     type: "suggestion",
@@ -4820,8 +4991,8 @@ var requireExplicitReturnType = createRule59({
 var require_explicit_return_type_default = requireExplicitReturnType;
 // src/rules/sort-exports.ts
-var import_utils69 = require("@typescript-eslint/utils");
-var createRule60 = import_utils69.ESLintUtils.RuleCreator(
+var import_utils73 = require("@typescript-eslint/utils");
+var createRule64 = import_utils73.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var GROUP_NAMES = ["", "external/alias re-export", "relative re-export", "local export"];
@@ -4835,7 +5006,7 @@ function getExportGroup(node) {
   }
   return 1;
 }
-var sortExports = createRule60({
+var sortExports = createRule64({
   name: "sort-exports",
   meta: {
     type: "suggestion",
@@ -4875,7 +5046,7 @@ var sortExports = createRule60({
       Program(node) {
         const exportGroups = [];
         node.body.forEach((statement) => {
-          if (statement.type !== import_utils69.AST_NODE_TYPES.ExportNamedDeclaration || statement.declaration !== null) {
+          if (statement.type !== import_utils73.AST_NODE_TYPES.ExportNamedDeclaration || statement.declaration !== null) {
             if (exportGroups.length > 0) {
               checkOrder(exportGroups);
               exportGroups.length = 0;
@@ -4894,8 +5065,8 @@ var sortExports = createRule60({
 var sort_exports_default = sortExports;
 // src/rules/sort-imports.ts
-var import_utils70 = require("@typescript-eslint/utils");
-var createRule61 = import_utils70.ESLintUtils.RuleCreator(
+var import_utils74 = require("@typescript-eslint/utils");
+var createRule65 = import_utils74.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var NODE_BUILTINS = /* @__PURE__ */ new Set([
@@ -4962,7 +5133,7 @@ function getImportGroup(node) {
 function isTypeOnlyImport(node) {
   return node.importKind === "type" && node.specifiers.length > 0;
 }
-var sortImports = createRule61({
+var sortImports = createRule65({
   name: "sort-imports",
   meta: {
     type: "suggestion",
@@ -5006,7 +5177,7 @@ var sortImports = createRule61({
       Program(node) {
         const importGroups = [];
         node.body.forEach((statement) => {
-          if (statement.type !== import_utils70.AST_NODE_TYPES.ImportDeclaration) {
+          if (statement.type !== import_utils74.AST_NODE_TYPES.ImportDeclaration) {
             if (importGroups.length > 0) {
               checkOrder(importGroups);
               importGroups.length = 0;
@@ -5028,13 +5199,13 @@ var sortImports = createRule61({
 var sort_imports_default = sortImports;
 // src/rules/sort-type-alphabetically.ts
-var import_utils71 = require("@typescript-eslint/utils");
-var createRule62 = import_utils71.ESLintUtils.RuleCreator(
+var import_utils75 = require("@typescript-eslint/utils");
+var createRule66 = import_utils75.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 function isAlphabeticallySortedWithinGroups(members) {
   const properties = members.filter(
-    (member) => member.type === import_utils71.AST_NODE_TYPES.TSPropertySignature && member.key.type === import_utils71.AST_NODE_TYPES.Identifier
+    (member) => member.type === import_utils75.AST_NODE_TYPES.TSPropertySignature && member.key.type === import_utils75.AST_NODE_TYPES.Identifier
   );
   if (properties.length < 2) {
     return true;
@@ -5045,7 +5216,7 @@ function isAlphabeticallySortedWithinGroups(members) {
   const isOptionalSorted = optional.every((name, index) => index === 0 || optional[index - 1].localeCompare(name) <= 0);
   return isRequiredSorted && isOptionalSorted;
 }
-var sortTypeAlphabetically = createRule62({
+var sortTypeAlphabetically = createRule66({
   name: "sort-type-alphabetically",
   meta: {
     type: "suggestion",
@@ -5063,7 +5234,7 @@ var sortTypeAlphabetically = createRule62({
     function fixMembers(fixer, members) {
       const { sourceCode } = context;
       const properties = members.filter(
-        (member) => member.type === import_utils71.AST_NODE_TYPES.TSPropertySignature && member.key.type === import_utils71.AST_NODE_TYPES.Identifier
+        (member) => member.type === import_utils75.AST_NODE_TYPES.TSPropertySignature && member.key.type === import_utils75.AST_NODE_TYPES.Identifier
       );
       const required = properties.filter((prop) => !prop.optional);
       const optional = properties.filter((prop) => prop.optional);
@@ -5100,7 +5271,7 @@ var sortTypeAlphabetically = createRule62({
         }
       },
       TSTypeAliasDeclaration(node) {
-        if (node.typeAnnotation.type !== import_utils71.AST_NODE_TYPES.TSTypeLiteral) {
+        if (node.typeAnnotation.type !== import_utils75.AST_NODE_TYPES.TSTypeLiteral) {
           return;
         }
         const { members } = node.typeAnnotation;
@@ -5120,13 +5291,13 @@ var sortTypeAlphabetically = createRule62({
 var sort_type_alphabetically_default = sortTypeAlphabetically;
 // src/rules/sort-type-required-first.ts
-var import_utils72 = require("@typescript-eslint/utils");
-var createRule63 = import_utils72.ESLintUtils.RuleCreator(
+var import_utils76 = require("@typescript-eslint/utils");
+var createRule67 = import_utils76.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 function isRequiredBeforeOptional(members) {
   const properties = members.filter(
-    (member) => member.type === import_utils72.AST_NODE_TYPES.TSPropertySignature && member.key.type === import_utils72.AST_NODE_TYPES.Identifier
+    (member) => member.type === import_utils76.AST_NODE_TYPES.TSPropertySignature && member.key.type === import_utils76.AST_NODE_TYPES.Identifier
   );
   if (properties.length < 2) {
     return true;
@@ -5137,7 +5308,7 @@ function isRequiredBeforeOptional(members) {
   }
   return properties.slice(firstOptionalIndex).every((prop) => prop.optional);
 }
-var sortTypeRequiredFirst = createRule63({
+var sortTypeRequiredFirst = createRule67({
   name: "sort-type-required-first",
   meta: {
     type: "suggestion",
@@ -5155,7 +5326,7 @@ var sortTypeRequiredFirst = createRule63({
     function fixMembers(fixer, members) {
       const { sourceCode } = context;
       const properties = members.filter(
-        (member) => member.type === import_utils72.AST_NODE_TYPES.TSPropertySignature && member.key.type === import_utils72.AST_NODE_TYPES.Identifier
+        (member) => member.type === import_utils76.AST_NODE_TYPES.TSPropertySignature && member.key.type === import_utils76.AST_NODE_TYPES.Identifier
       );
       const required = properties.filter((prop) => !prop.optional);
       const optional = properties.filter((prop) => prop.optional);
@@ -5176,7 +5347,7 @@ var sortTypeRequiredFirst = createRule63({
         }
       },
       TSTypeAliasDeclaration(node) {
-        if (node.typeAnnotation.type !== import_utils72.AST_NODE_TYPES.TSTypeLiteral) {
+        if (node.typeAnnotation.type !== import_utils76.AST_NODE_TYPES.TSTypeLiteral) {
           return;
         }
         const { members } = node.typeAnnotation;
@@ -5204,12 +5375,14 @@ var rules = {
   "boolean-naming-prefix": boolean_naming_prefix_default,
   "enforce-camel-case": enforce_camel_case_default,
   "enforce-constant-case": enforce_constant_case_default,
+  "enforce-hook-filename": enforce_hook_filename_default,
   "enforce-hook-naming": enforce_hook_naming_default,
   "enforce-property-case": enforce_property_case_default,
   "enforce-props-suffix": enforce_props_suffix_default,
   "enforce-readonly-component-props": enforce_readonly_component_props_default,
   "enforce-render-naming": enforce_render_naming_default,
   "enforce-service-naming": enforce_service_naming_default,
+  "enforce-test-filename": enforce_test_filename_default,
   "enforce-sorted-destructuring": enforce_sorted_destructuring_default,
   "enforce-type-declaration-order": enforce_type_declaration_order_default,
   "index-export-only": index_export_only_default,
@@ -5233,6 +5406,8 @@ var rules = {
   "no-emoji": no_emoji_default,
   "no-env-fallback": no_env_fallback_default,
   "no-ghost-wrapper": no_ghost_wrapper_default,
+  "no-helper-function-in-hook": no_helper_function_in_hook_default,
+  "no-helper-function-in-test": no_helper_function_in_test_default,
   "no-inline-default-export": no_inline_default_export_default,
   "no-inline-nested-object": no_inline_nested_object_default,
   "no-inline-return-properties": no_inline_return_properties_default,
@@ -5273,9 +5448,11 @@ var baseRules = {
   "nextfriday/boolean-naming-prefix": "warn",
   "nextfriday/enforce-camel-case": "warn",
   "nextfriday/enforce-constant-case": "warn",
+  "nextfriday/enforce-hook-filename": "warn",
   "nextfriday/enforce-hook-naming": "warn",
   "nextfriday/enforce-property-case": "warn",
   "nextfriday/enforce-service-naming": "warn",
+  "nextfriday/enforce-test-filename": "warn",
   "nextfriday/enforce-sorted-destructuring": "warn",
   "nextfriday/enforce-type-declaration-order": "warn",
   "nextfriday/index-export-only": "warn",
@@ -5315,9 +5492,11 @@ var baseRecommendedRules = {
   "nextfriday/boolean-naming-prefix": "error",
   "nextfriday/enforce-camel-case": "error",
   "nextfriday/enforce-constant-case": "error",
+  "nextfriday/enforce-hook-filename": "error",
   "nextfriday/enforce-hook-naming": "error",
   "nextfriday/enforce-property-case": "error",
   "nextfriday/enforce-service-naming": "error",
+  "nextfriday/enforce-test-filename": "error",
   "nextfriday/enforce-sorted-destructuring": "error",
   "nextfriday/enforce-type-declaration-order": "error",
   "nextfriday/index-export-only": "error",