eslint-plugin-nextfriday 4.1.0 → 4.3.0

package/lib/index.js

@@ -1,7 +1,7 @@
 // package.json
 var package_default = {
   name: "eslint-plugin-nextfriday",
-  version: "4.1.0",
+  version: "4.3.0",
   description: "A comprehensive ESLint plugin providing custom rules and configurations for Next Friday development workflows.",
   keywords: [
     "eslint",
@@ -486,13 +486,64 @@ var enforceConstantCase = createRule3({
 });
 var enforce_constant_case_default = enforceConstantCase;
 
-// src/rules/enforce-hook-naming.ts
+// src/rules/enforce-hook-filename.ts
 import path from "path";
 import { AST_NODE_TYPES as AST_NODE_TYPES5, ESLintUtils as ESLintUtils4 } from "@typescript-eslint/utils";
 var createRule4 = ESLintUtils4.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var 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 = path.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 === AST_NODE_TYPES5.FunctionDeclaration && node.declaration.id) {
+          reportIfHook(node.declaration.id.name, node.declaration.id);
+        }
+        if (node.declaration?.type === AST_NODE_TYPES5.VariableDeclaration) {
+          for (const declarator of node.declaration.declarations) {
+            if (declarator.id.type === AST_NODE_TYPES5.Identifier && declarator.init !== null && (declarator.init.type === AST_NODE_TYPES5.ArrowFunctionExpression || declarator.init.type === AST_NODE_TYPES5.FunctionExpression)) {
+              reportIfHook(declarator.id.name, declarator.id);
+            }
+          }
+        }
+      },
+      ExportDefaultDeclaration(node) {
+        if (node.declaration.type === AST_NODE_TYPES5.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
+import path2 from "path";
+import { AST_NODE_TYPES as AST_NODE_TYPES6, ESLintUtils as ESLintUtils5 } from "@typescript-eslint/utils";
+var createRule5 = ESLintUtils5.RuleCreator(
+  (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
+);
+var enforceHookNaming = createRule5({
   name: "enforce-hook-naming",
   meta: {
     type: "suggestion",
@@ -508,7 +559,7 @@ var enforceHookNaming = createRule4({
   defaultOptions: [],
   create(context) {
     const { filename } = context;
-    const basename2 = path.basename(filename);
+    const basename2 = path2.basename(filename);
     const isHookFile = basename2.endsWith(".hook.ts") || basename2.endsWith(".hooks.ts");
     if (!isHookFile) {
       return {};
@@ -531,22 +582,22 @@ var enforceHookNaming = createRule4({
     };
     return {
       ExportNamedDeclaration(node) {
-        if (node.declaration?.type === AST_NODE_TYPES5.FunctionDeclaration && node.declaration.id) {
+        if (node.declaration?.type === AST_NODE_TYPES6.FunctionDeclaration && node.declaration.id) {
           checkFunctionName(node.declaration.id.name, node.declaration.id, "missingUsePrefix");
         }
-        if (node.declaration?.type === AST_NODE_TYPES5.VariableDeclaration) {
+        if (node.declaration?.type === AST_NODE_TYPES6.VariableDeclaration) {
           node.declaration.declarations.forEach((declarator) => {
-            if (declarator.id.type === AST_NODE_TYPES5.Identifier) {
+            if (declarator.id.type === AST_NODE_TYPES6.Identifier) {
               checkFunctionName(declarator.id.name, declarator.id, "missingUsePrefix");
             }
           });
         }
       },
       ExportDefaultDeclaration(node) {
-        if (node.declaration.type === AST_NODE_TYPES5.Identifier) {
+        if (node.declaration.type === AST_NODE_TYPES6.Identifier) {
           checkFunctionName(node.declaration.name, node.declaration, "defaultExportMissingUsePrefix");
         }
-        if (node.declaration.type === AST_NODE_TYPES5.FunctionDeclaration && node.declaration.id) {
+        if (node.declaration.type === AST_NODE_TYPES6.FunctionDeclaration && node.declaration.id) {
           checkFunctionName(node.declaration.id.name, node.declaration.id, "defaultExportMissingUsePrefix");
         }
       }
@@ -556,26 +607,26 @@ var enforceHookNaming = createRule4({
 var enforce_hook_naming_default = enforceHookNaming;
 
 // src/rules/enforce-property-case.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES6, ESLintUtils as ESLintUtils5 } from "@typescript-eslint/utils";
-var createRule5 = ESLintUtils5.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES7, ESLintUtils as ESLintUtils6 } from "@typescript-eslint/utils";
+var createRule6 = ESLintUtils6.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var 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 === AST_NODE_TYPES6.TSAsExpression && parent.typeAnnotation.type === AST_NODE_TYPES6.TSTypeReference && parent.typeAnnotation.typeName.type === AST_NODE_TYPES6.Identifier && parent.typeAnnotation.typeName.name === "const") {
+  if (parent.type === AST_NODE_TYPES7.TSAsExpression && parent.typeAnnotation.type === AST_NODE_TYPES7.TSTypeReference && parent.typeAnnotation.typeName.type === AST_NODE_TYPES7.Identifier && parent.typeAnnotation.typeName.name === "const") {
     return true;
   }
-  if (parent.type === AST_NODE_TYPES6.ArrayExpression) {
+  if (parent.type === AST_NODE_TYPES7.ArrayExpression) {
     const grandparent = parent.parent;
-    if (grandparent?.type === AST_NODE_TYPES6.TSAsExpression && grandparent.typeAnnotation.type === AST_NODE_TYPES6.TSTypeReference && grandparent.typeAnnotation.typeName.type === AST_NODE_TYPES6.Identifier && grandparent.typeAnnotation.typeName.name === "const") {
+    if (grandparent?.type === AST_NODE_TYPES7.TSAsExpression && grandparent.typeAnnotation.type === AST_NODE_TYPES7.TSTypeReference && grandparent.typeAnnotation.typeName.type === AST_NODE_TYPES7.Identifier && grandparent.typeAnnotation.typeName.name === "const") {
       return true;
     }
   }
   return false;
 };
-var enforcePropertyCase = createRule5({
+var enforcePropertyCase = createRule6({
   name: "enforce-property-case",
   meta: {
     type: "suggestion",
@@ -591,7 +642,7 @@ var enforcePropertyCase = createRule5({
   create(context) {
     return {
       Property(node) {
-        if (node.parent.type !== AST_NODE_TYPES6.ObjectExpression) {
+        if (node.parent.type !== AST_NODE_TYPES7.ObjectExpression) {
           return;
         }
         if (isInsideAsConst(node.parent)) {
@@ -600,7 +651,7 @@ var enforcePropertyCase = createRule5({
         if (node.computed) {
           return;
         }
-        if (node.key.type !== AST_NODE_TYPES6.Identifier) {
+        if (node.key.type !== AST_NODE_TYPES7.Identifier) {
           return;
         }
         const { name } = node.key;
@@ -618,12 +669,12 @@ var enforcePropertyCase = createRule5({
 var enforce_property_case_default = enforcePropertyCase;
 
 // src/rules/enforce-props-suffix.ts
-import path2 from "path";
-import { AST_NODE_TYPES as AST_NODE_TYPES7, ESLintUtils as ESLintUtils6 } from "@typescript-eslint/utils";
-var createRule6 = ESLintUtils6.RuleCreator(
+import path3 from "path";
+import { AST_NODE_TYPES as AST_NODE_TYPES8, ESLintUtils as ESLintUtils7 } from "@typescript-eslint/utils";
+var createRule7 = ESLintUtils7.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var enforcePropsSuffix = createRule6({
+var enforcePropsSuffix = createRule7({
   name: "enforce-props-suffix",
   meta: {
     type: "suggestion",
@@ -638,7 +689,7 @@ var enforcePropsSuffix = createRule6({
   defaultOptions: [],
   create(context) {
     const { filename } = context;
-    const ext = path2.extname(filename);
+    const ext = path3.extname(filename);
     const isComponentFile = ext === ".tsx" || ext === ".jsx";
     if (!isComponentFile) {
       return {};
@@ -657,13 +708,13 @@ var enforcePropsSuffix = createRule6({
     };
     return {
       TSInterfaceDeclaration(node) {
-        if (node.id.type === AST_NODE_TYPES7.Identifier) {
+        if (node.id.type === AST_NODE_TYPES8.Identifier) {
           checkTypeName(node.id.name, node.id);
         }
       },
       TSTypeAliasDeclaration(node) {
-        if (node.id.type === AST_NODE_TYPES7.Identifier) {
-          if (node.typeAnnotation.type === AST_NODE_TYPES7.TSTypeLiteral) {
+        if (node.id.type === AST_NODE_TYPES8.Identifier) {
+          if (node.typeAnnotation.type === AST_NODE_TYPES8.TSTypeLiteral) {
             checkTypeName(node.id.name, node.id);
           }
         }
@@ -674,11 +725,11 @@ var enforcePropsSuffix = createRule6({
 var enforce_props_suffix_default = enforcePropsSuffix;
 
 // src/rules/enforce-readonly-component-props.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES8, ESLintUtils as ESLintUtils7 } from "@typescript-eslint/utils";
-var createRule7 = ESLintUtils7.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES9, ESLintUtils as ESLintUtils8 } from "@typescript-eslint/utils";
+var createRule8 = ESLintUtils8.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var enforceReadonlyComponentProps = createRule7({
+var enforceReadonlyComponentProps = createRule8({
   name: "enforce-readonly-component-props",
   meta: {
     type: "suggestion",
@@ -694,40 +745,40 @@ var enforceReadonlyComponentProps = createRule7({
   defaultOptions: [],
   create(context) {
     function hasJSXInConditional(node) {
-      return node.consequent.type === AST_NODE_TYPES8.JSXElement || node.consequent.type === AST_NODE_TYPES8.JSXFragment || node.alternate.type === AST_NODE_TYPES8.JSXElement || node.alternate.type === AST_NODE_TYPES8.JSXFragment;
+      return node.consequent.type === AST_NODE_TYPES9.JSXElement || node.consequent.type === AST_NODE_TYPES9.JSXFragment || node.alternate.type === AST_NODE_TYPES9.JSXElement || node.alternate.type === AST_NODE_TYPES9.JSXFragment;
     }
     function hasJSXInLogical(node) {
-      return node.right.type === AST_NODE_TYPES8.JSXElement || node.right.type === AST_NODE_TYPES8.JSXFragment;
+      return node.right.type === AST_NODE_TYPES9.JSXElement || node.right.type === AST_NODE_TYPES9.JSXFragment;
     }
     function hasJSXReturn(block) {
       return block.body.some((stmt) => {
-        if (stmt.type === AST_NODE_TYPES8.ReturnStatement && stmt.argument) {
-          return stmt.argument.type === AST_NODE_TYPES8.JSXElement || stmt.argument.type === AST_NODE_TYPES8.JSXFragment || stmt.argument.type === AST_NODE_TYPES8.ConditionalExpression && hasJSXInConditional(stmt.argument) || stmt.argument.type === AST_NODE_TYPES8.LogicalExpression && hasJSXInLogical(stmt.argument);
+        if (stmt.type === AST_NODE_TYPES9.ReturnStatement && stmt.argument) {
+          return stmt.argument.type === AST_NODE_TYPES9.JSXElement || stmt.argument.type === AST_NODE_TYPES9.JSXFragment || stmt.argument.type === AST_NODE_TYPES9.ConditionalExpression && hasJSXInConditional(stmt.argument) || stmt.argument.type === AST_NODE_TYPES9.LogicalExpression && hasJSXInLogical(stmt.argument);
         }
         return false;
       });
     }
     function isReactComponent2(node) {
-      if (node.type === AST_NODE_TYPES8.ArrowFunctionExpression) {
-        if (node.body.type === AST_NODE_TYPES8.JSXElement || node.body.type === AST_NODE_TYPES8.JSXFragment) {
+      if (node.type === AST_NODE_TYPES9.ArrowFunctionExpression) {
+        if (node.body.type === AST_NODE_TYPES9.JSXElement || node.body.type === AST_NODE_TYPES9.JSXFragment) {
           return true;
         }
-        if (node.body.type === AST_NODE_TYPES8.BlockStatement) {
+        if (node.body.type === AST_NODE_TYPES9.BlockStatement) {
           return hasJSXReturn(node.body);
         }
-      } else if (node.type === AST_NODE_TYPES8.FunctionExpression || node.type === AST_NODE_TYPES8.FunctionDeclaration) {
-        if (node.body && node.body.type === AST_NODE_TYPES8.BlockStatement) {
+      } else if (node.type === AST_NODE_TYPES9.FunctionExpression || node.type === AST_NODE_TYPES9.FunctionDeclaration) {
+        if (node.body && node.body.type === AST_NODE_TYPES9.BlockStatement) {
           return hasJSXReturn(node.body);
         }
       }
       return false;
     }
     function isNamedType(node) {
-      return node.type === AST_NODE_TYPES8.TSTypeReference;
+      return node.type === AST_NODE_TYPES9.TSTypeReference;
     }
     function isAlreadyReadonly(node) {
-      if (node.type === AST_NODE_TYPES8.TSTypeReference && node.typeName) {
-        if (node.typeName.type === AST_NODE_TYPES8.Identifier && node.typeName.name === "Readonly") {
+      if (node.type === AST_NODE_TYPES9.TSTypeReference && node.typeName) {
+        if (node.typeName.type === AST_NODE_TYPES9.Identifier && node.typeName.name === "Readonly") {
           return true;
         }
       }
@@ -741,7 +792,7 @@ var enforceReadonlyComponentProps = createRule7({
         return;
       }
       const param = node.params[0];
-      if (param.type === AST_NODE_TYPES8.Identifier && param.typeAnnotation) {
+      if (param.type === AST_NODE_TYPES9.Identifier && param.typeAnnotation) {
         const { typeAnnotation } = param.typeAnnotation;
         if (isNamedType(typeAnnotation) && !isAlreadyReadonly(typeAnnotation)) {
           const { sourceCode } = context;
@@ -765,9 +816,159 @@ var enforceReadonlyComponentProps = createRule7({
 });
 var enforce_readonly_component_props_default = enforceReadonlyComponentProps;
 
+// src/rules/enforce-render-naming.ts
+import { AST_NODE_TYPES as AST_NODE_TYPES10, ESLintUtils as ESLintUtils9 } from "@typescript-eslint/utils";
+var createRule9 = ESLintUtils9.RuleCreator(
+  (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
+);
+var ARRAY_RETURNING_METHODS = /* @__PURE__ */ new Set(["map", "flatMap", "filter"]);
+function hasRenderPrefix(name) {
+  if (!name.startsWith("render")) {
+    return false;
+  }
+  if (name.length === "render".length) {
+    return true;
+  }
+  const nextChar = name["render".length];
+  return nextChar === nextChar.toUpperCase() && nextChar !== nextChar.toLowerCase();
+}
+function functionBodyReturnsJsx(body) {
+  if (body.type === AST_NODE_TYPES10.JSXElement || body.type === AST_NODE_TYPES10.JSXFragment) {
+    return true;
+  }
+  if (body.type === AST_NODE_TYPES10.ConditionalExpression) {
+    return isJsxProducingExpression(body.consequent) || isJsxProducingExpression(body.alternate);
+  }
+  if (body.type === AST_NODE_TYPES10.LogicalExpression) {
+    return isJsxProducingExpression(body.right);
+  }
+  if (body.type !== AST_NODE_TYPES10.BlockStatement) {
+    return false;
+  }
+  for (const statement of body.body) {
+    if (statement.type === AST_NODE_TYPES10.ReturnStatement && statement.argument) {
+      if (isJsxProducingExpression(statement.argument)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function isJsxProducingExpression(node) {
+  if (node.type === AST_NODE_TYPES10.JSXElement || node.type === AST_NODE_TYPES10.JSXFragment) {
+    return true;
+  }
+  if (node.type === AST_NODE_TYPES10.ConditionalExpression) {
+    return isJsxProducingExpression(node.consequent) || isJsxProducingExpression(node.alternate);
+  }
+  if (node.type === AST_NODE_TYPES10.LogicalExpression) {
+    return isJsxProducingExpression(node.right);
+  }
+  if (node.type === AST_NODE_TYPES10.ArrayExpression) {
+    return node.elements.some((element) => {
+      if (!element || element.type === AST_NODE_TYPES10.SpreadElement) {
+        return false;
+      }
+      return isJsxProducingExpression(element);
+    });
+  }
+  if (node.type === AST_NODE_TYPES10.ArrowFunctionExpression || node.type === AST_NODE_TYPES10.FunctionExpression) {
+    return functionBodyReturnsJsx(node.body);
+  }
+  if (node.type === AST_NODE_TYPES10.CallExpression) {
+    if (node.callee.type === AST_NODE_TYPES10.MemberExpression && node.callee.property.type === AST_NODE_TYPES10.Identifier && ARRAY_RETURNING_METHODS.has(node.callee.property.name)) {
+      const callback = node.arguments[0];
+      if (callback && (callback.type === AST_NODE_TYPES10.ArrowFunctionExpression || callback.type === AST_NODE_TYPES10.FunctionExpression)) {
+        return functionBodyReturnsJsx(callback.body);
+      }
+    }
+  }
+  if (node.type === AST_NODE_TYPES10.TSAsExpression || node.type === AST_NODE_TYPES10.TSSatisfiesExpression) {
+    return isJsxProducingExpression(node.expression);
+  }
+  return false;
+}
+function isPascalCase(name) {
+  return /^[A-Z]/.test(name);
+}
+function isComponentFunction2(node) {
+  if (node.type === AST_NODE_TYPES10.FunctionDeclaration && node.id && isPascalCase(node.id.name)) {
+    return true;
+  }
+  const parent = node.parent;
+  if (parent?.type === AST_NODE_TYPES10.VariableDeclarator && parent.id.type === AST_NODE_TYPES10.Identifier && isPascalCase(parent.id.name)) {
+    return true;
+  }
+  return false;
+}
+var enforceRenderNaming = createRule9({
+  name: "enforce-render-naming",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Enforce 'render' prefix for variables that hold or return JSX inside React components"
+    },
+    schema: [],
+    messages: {
+      missingRenderPrefix: "Variable '{{ name }}' holds JSX-producing content inside a component. Rename it to 'render{{ pascalName }}' so the intent is explicit."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    const { filename } = context;
+    const extension = getFileExtension(filename);
+    if (extension !== "tsx" && extension !== "jsx") {
+      return {};
+    }
+    const componentStack = [];
+    function isInsideComponent() {
+      return componentStack.some((value) => value);
+    }
+    function pushFunction(node) {
+      componentStack.push(isComponentFunction2(node));
+    }
+    function popFunction() {
+      componentStack.pop();
+    }
+    return {
+      ArrowFunctionExpression: pushFunction,
+      FunctionDeclaration: pushFunction,
+      FunctionExpression: pushFunction,
+      "ArrowFunctionExpression:exit": popFunction,
+      "FunctionDeclaration:exit": popFunction,
+      "FunctionExpression:exit": popFunction,
+      VariableDeclarator(node) {
+        if (!isInsideComponent()) {
+          return;
+        }
+        if (node.id.type !== AST_NODE_TYPES10.Identifier) {
+          return;
+        }
+        if (!node.init) {
+          return;
+        }
+        if (!isJsxProducingExpression(node.init)) {
+          return;
+        }
+        const name = node.id.name;
+        if (hasRenderPrefix(name)) {
+          return;
+        }
+        const pascalName = name.charAt(0).toUpperCase() + name.slice(1);
+        context.report({
+          node: node.id,
+          messageId: "missingRenderPrefix",
+          data: { name, pascalName }
+        });
+      }
+    };
+  }
+});
+var enforce_render_naming_default = enforceRenderNaming;
+
 // src/rules/enforce-service-naming.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES9, ESLintUtils as ESLintUtils8 } from "@typescript-eslint/utils";
-var createRule8 = ESLintUtils8.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES11, ESLintUtils as ESLintUtils10 } from "@typescript-eslint/utils";
+var createRule10 = ESLintUtils10.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var BANNED_PREFIXES = {
@@ -776,7 +977,7 @@ var BANNED_PREFIXES = {
   handle: ["create", "verify"],
   set: ["update", "save", "patch"]
 };
-var enforceServiceNaming = createRule8({
+var enforceServiceNaming = createRule10({
   name: "enforce-service-naming",
   meta: {
     type: "suggestion",
@@ -819,12 +1020,12 @@ var enforceServiceNaming = createRule8({
     };
     return {
       ExportNamedDeclaration(node) {
-        if (node.declaration?.type === AST_NODE_TYPES9.FunctionDeclaration && node.declaration.id) {
+        if (node.declaration?.type === AST_NODE_TYPES11.FunctionDeclaration && node.declaration.id) {
           checkExportedFunction(node.declaration, node.declaration.id);
         }
-        if (node.declaration?.type === AST_NODE_TYPES9.VariableDeclaration) {
+        if (node.declaration?.type === AST_NODE_TYPES11.VariableDeclaration) {
           node.declaration.declarations.forEach((declarator) => {
-            if (declarator.id.type === AST_NODE_TYPES9.Identifier && declarator.init?.type === AST_NODE_TYPES9.ArrowFunctionExpression) {
+            if (declarator.id.type === AST_NODE_TYPES11.Identifier && declarator.init?.type === AST_NODE_TYPES11.ArrowFunctionExpression) {
               checkExportedFunction(declarator.init, declarator.id);
             }
           });
@@ -835,12 +1036,52 @@ var enforceServiceNaming = createRule8({
 });
 var enforce_service_naming_default = enforceServiceNaming;
 
+// src/rules/enforce-test-filename.ts
+import path4 from "path";
+import { AST_NODE_TYPES as AST_NODE_TYPES12, ESLintUtils as ESLintUtils11 } from "@typescript-eslint/utils";
+var createRule11 = ESLintUtils11.RuleCreator(
+  (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
+);
+var 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 = path4.basename(context.filename);
+    const isTestFile = basename2.endsWith(".test.ts") || basename2.endsWith(".test.tsx");
+    if (isTestFile) return {};
+    function isTestGlobalCall(node) {
+      return node.callee.type === AST_NODE_TYPES12.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
-import { AST_NODE_TYPES as AST_NODE_TYPES10, ESLintUtils as ESLintUtils9 } from "@typescript-eslint/utils";
-var createRule9 = ESLintUtils9.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES13, ESLintUtils as ESLintUtils12 } from "@typescript-eslint/utils";
+var createRule12 = ESLintUtils12.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var enforceSortedDestructuring = createRule9({
+var enforceSortedDestructuring = createRule12({
   name: "enforce-sorted-destructuring",
   meta: {
     type: "suggestion",
@@ -856,19 +1097,19 @@ var enforceSortedDestructuring = createRule9({
   defaultOptions: [],
   create(context) {
     function getPropertyName(property) {
-      if (property.type === AST_NODE_TYPES10.RestElement) {
+      if (property.type === AST_NODE_TYPES13.RestElement) {
         return null;
       }
-      if (property.key.type === AST_NODE_TYPES10.Identifier) {
+      if (property.key.type === AST_NODE_TYPES13.Identifier) {
         return property.key.name;
       }
       return null;
     }
     function hasDefaultValue(property) {
-      return property.value.type === AST_NODE_TYPES10.AssignmentPattern && Boolean(property.value.right);
+      return property.value.type === AST_NODE_TYPES13.AssignmentPattern && Boolean(property.value.right);
     }
     function checkVariableDeclarator(node) {
-      if (node.id.type !== AST_NODE_TYPES10.ObjectPattern) {
+      if (node.id.type !== AST_NODE_TYPES13.ObjectPattern) {
         return;
       }
       const { properties } = node.id;
@@ -876,7 +1117,7 @@ var enforceSortedDestructuring = createRule9({
         return;
       }
       const propertyInfo = properties.map((prop) => {
-        if (prop.type === AST_NODE_TYPES10.RestElement) {
+        if (prop.type === AST_NODE_TYPES13.RestElement) {
           return null;
         }
         return {
@@ -915,20 +1156,20 @@ var enforceSortedDestructuring = createRule9({
 var enforce_sorted_destructuring_default = enforceSortedDestructuring;
 
 // src/rules/enforce-type-declaration-order.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES11, ESLintUtils as ESLintUtils10 } from "@typescript-eslint/utils";
-var createRule10 = ESLintUtils10.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES14, ESLintUtils as ESLintUtils13 } from "@typescript-eslint/utils";
+var createRule13 = ESLintUtils13.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 function getTypeDeclarationName(node) {
-  if (node.type === AST_NODE_TYPES11.TSInterfaceDeclaration && node.id.type === AST_NODE_TYPES11.Identifier) {
+  if (node.type === AST_NODE_TYPES14.TSInterfaceDeclaration && node.id.type === AST_NODE_TYPES14.Identifier) {
     return { name: node.id.name, position: node.range[0] };
   }
-  if (node.type === AST_NODE_TYPES11.TSTypeAliasDeclaration && node.id.type === AST_NODE_TYPES11.Identifier) {
+  if (node.type === AST_NODE_TYPES14.TSTypeAliasDeclaration && node.id.type === AST_NODE_TYPES14.Identifier) {
     return { name: node.id.name, position: node.range[0] };
   }
   return null;
 }
-var enforceTypeDeclarationOrder = createRule10({
+var enforceTypeDeclarationOrder = createRule13({
   name: "enforce-type-declaration-order",
   meta: {
     type: "suggestion",
@@ -959,7 +1200,7 @@ var enforceTypeDeclarationOrder = createRule10({
         }
       },
       "TSPropertySignature TSTypeReference": function checkTypeReference(node) {
-        if (node.typeName.type !== AST_NODE_TYPES11.Identifier) {
+        if (node.typeName.type !== AST_NODE_TYPES14.Identifier) {
           return;
         }
         const referencedName = node.typeName.name;
@@ -996,8 +1237,8 @@ var enforceTypeDeclarationOrder = createRule10({
 var enforce_type_declaration_order_default = enforceTypeDeclarationOrder;
 
 // src/rules/index-export-only.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES12, ESLintUtils as ESLintUtils11 } from "@typescript-eslint/utils";
-var createRule11 = ESLintUtils11.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES15, ESLintUtils as ESLintUtils14 } from "@typescript-eslint/utils";
+var createRule14 = ESLintUtils14.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var isIndexFile = (filename) => getBaseName(filename) === "index";
@@ -1005,26 +1246,26 @@ var isAllowedExportNamed = (node) => {
   if (!node.declaration) {
     return true;
   }
-  return node.declaration.type === AST_NODE_TYPES12.TSTypeAliasDeclaration || node.declaration.type === AST_NODE_TYPES12.TSInterfaceDeclaration;
+  return node.declaration.type === AST_NODE_TYPES15.TSTypeAliasDeclaration || node.declaration.type === AST_NODE_TYPES15.TSInterfaceDeclaration;
 };
-var isAllowedExportDefault = (node) => node.declaration.type === AST_NODE_TYPES12.Identifier;
+var isAllowedExportDefault = (node) => node.declaration.type === AST_NODE_TYPES15.Identifier;
 var isAllowedTopLevel = (node) => {
   switch (node.type) {
-    case AST_NODE_TYPES12.ImportDeclaration:
-    case AST_NODE_TYPES12.ExportAllDeclaration:
-    case AST_NODE_TYPES12.TSTypeAliasDeclaration:
-    case AST_NODE_TYPES12.TSInterfaceDeclaration:
-    case AST_NODE_TYPES12.TSImportEqualsDeclaration:
+    case AST_NODE_TYPES15.ImportDeclaration:
+    case AST_NODE_TYPES15.ExportAllDeclaration:
+    case AST_NODE_TYPES15.TSTypeAliasDeclaration:
+    case AST_NODE_TYPES15.TSInterfaceDeclaration:
+    case AST_NODE_TYPES15.TSImportEqualsDeclaration:
       return true;
-    case AST_NODE_TYPES12.ExportNamedDeclaration:
+    case AST_NODE_TYPES15.ExportNamedDeclaration:
       return isAllowedExportNamed(node);
-    case AST_NODE_TYPES12.ExportDefaultDeclaration:
+    case AST_NODE_TYPES15.ExportDefaultDeclaration:
       return isAllowedExportDefault(node);
     default:
       return false;
   }
 };
-var indexExportOnly = createRule11({
+var indexExportOnly = createRule14({
   name: "index-export-only",
   meta: {
     type: "suggestion",
@@ -1058,11 +1299,11 @@ var indexExportOnly = createRule11({
 var index_export_only_default = indexExportOnly;
 
 // src/rules/jsx-newline-between-elements.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES13, ESLintUtils as ESLintUtils12 } from "@typescript-eslint/utils";
-var createRule12 = ESLintUtils12.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES16, ESLintUtils as ESLintUtils15 } from "@typescript-eslint/utils";
+var createRule15 = ESLintUtils15.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var jsxNewlineBetweenElements = createRule12({
+var jsxNewlineBetweenElements = createRule15({
   name: "jsx-newline-between-elements",
   meta: {
     type: "layout",
@@ -1080,7 +1321,7 @@ var jsxNewlineBetweenElements = createRule12({
   create(context) {
     const { sourceCode } = context;
     function isSignificantJSXChild(node) {
-      return node.type === AST_NODE_TYPES13.JSXElement || node.type === AST_NODE_TYPES13.JSXFragment || node.type === AST_NODE_TYPES13.JSXExpressionContainer;
+      return node.type === AST_NODE_TYPES16.JSXElement || node.type === AST_NODE_TYPES16.JSXFragment || node.type === AST_NODE_TYPES16.JSXExpressionContainer;
     }
     function isMultiLine(node) {
       return node.loc.start.line !== node.loc.end.line;
@@ -1129,12 +1370,194 @@ var jsxNewlineBetweenElements = createRule12({
 });
 var jsx_newline_between_elements_default = jsxNewlineBetweenElements;
 
+// src/rules/jsx-no-data-array.ts
+import { AST_NODE_TYPES as AST_NODE_TYPES17, ESLintUtils as ESLintUtils16 } from "@typescript-eslint/utils";
+var createRule16 = ESLintUtils16.RuleCreator(
+  (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
+);
+function isObjectLikeElement(node) {
+  if (!node) {
+    return false;
+  }
+  if (node.type === AST_NODE_TYPES17.ObjectExpression) {
+    return true;
+  }
+  if (node.type === AST_NODE_TYPES17.TSAsExpression || node.type === AST_NODE_TYPES17.TSSatisfiesExpression) {
+    return isObjectLikeElement(node.expression);
+  }
+  return false;
+}
+function getArrayInitializer(init) {
+  if (!init) {
+    return null;
+  }
+  if (init.type === AST_NODE_TYPES17.ArrayExpression) {
+    return init;
+  }
+  if (init.type === AST_NODE_TYPES17.TSAsExpression || init.type === AST_NODE_TYPES17.TSSatisfiesExpression) {
+    return getArrayInitializer(init.expression);
+  }
+  return null;
+}
+var jsxNoDataArray = createRule16({
+  name: "jsx-no-data-array",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow top-level arrays of object literals in .tsx/.jsx files (extract to a data file)"
+    },
+    schema: [],
+    messages: {
+      noDataArray: "Top-level array of object literals belongs in a data file (e.g. *.data.ts), not a .tsx/.jsx component file. Extract '{{ name }}' to a sibling data module."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    const { filename } = context;
+    const extension = getFileExtension(filename);
+    if (extension !== "tsx" && extension !== "jsx") {
+      return {};
+    }
+    return {
+      "Program > VariableDeclaration > VariableDeclarator": function checkDeclarator(node) {
+        const arrayInit = getArrayInitializer(node.init);
+        if (!arrayInit) {
+          return;
+        }
+        const hasObjectElement = arrayInit.elements.some((element) => isObjectLikeElement(element));
+        if (!hasObjectElement) {
+          return;
+        }
+        const name = node.id.type === AST_NODE_TYPES17.Identifier ? node.id.name : "<destructured>";
+        context.report({
+          node,
+          messageId: "noDataArray",
+          data: { name }
+        });
+      },
+      "Program > ExportNamedDeclaration > VariableDeclaration > VariableDeclarator": function checkExportedDeclarator(node) {
+        const arrayInit = getArrayInitializer(node.init);
+        if (!arrayInit) {
+          return;
+        }
+        const hasObjectElement = arrayInit.elements.some((element) => isObjectLikeElement(element));
+        if (!hasObjectElement) {
+          return;
+        }
+        const name = node.id.type === AST_NODE_TYPES17.Identifier ? node.id.name : "<destructured>";
+        context.report({
+          node,
+          messageId: "noDataArray",
+          data: { name }
+        });
+      }
+    };
+  }
+});
+var jsx_no_data_array_default = jsxNoDataArray;
+
+// src/rules/jsx-no-data-object.ts
+import { AST_NODE_TYPES as AST_NODE_TYPES18, ESLintUtils as ESLintUtils17 } from "@typescript-eslint/utils";
+var createRule17 = ESLintUtils17.RuleCreator(
+  (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
+);
+function unwrapAssertion(node) {
+  if (!node) {
+    return null;
+  }
+  if (node.type === AST_NODE_TYPES18.TSAsExpression || node.type === AST_NODE_TYPES18.TSSatisfiesExpression) {
+    return unwrapAssertion(node.expression);
+  }
+  return node;
+}
+function isNestedValue(value) {
+  const unwrapped = unwrapAssertion(value);
+  if (!unwrapped) {
+    return false;
+  }
+  if (unwrapped.type === AST_NODE_TYPES18.ObjectExpression) {
+    return true;
+  }
+  if (unwrapped.type === AST_NODE_TYPES18.ArrayExpression) {
+    return unwrapped.elements.some((element) => {
+      if (!element || element.type === AST_NODE_TYPES18.SpreadElement) {
+        return false;
+      }
+      const inner = unwrapAssertion(element);
+      return inner?.type === AST_NODE_TYPES18.ObjectExpression || inner?.type === AST_NODE_TYPES18.ArrayExpression;
+    });
+  }
+  return false;
+}
+function hasNestedProperty(object) {
+  return object.properties.some((property) => {
+    if (property.type !== AST_NODE_TYPES18.Property) {
+      return false;
+    }
+    if (property.value.type === AST_NODE_TYPES18.AssignmentPattern) {
+      return false;
+    }
+    return isNestedValue(property.value);
+  });
+}
+function getObjectInitializer(init) {
+  const unwrapped = unwrapAssertion(init);
+  if (!unwrapped) {
+    return null;
+  }
+  if (unwrapped.type === AST_NODE_TYPES18.ObjectExpression) {
+    return unwrapped;
+  }
+  return null;
+}
+var jsxNoDataObject = createRule17({
+  name: "jsx-no-data-object",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow top-level nested object literals in .tsx/.jsx files (extract to a data file)"
+    },
+    schema: [],
+    messages: {
+      noDataObject: "Top-level nested object literal belongs in a data file (e.g. *.data.ts), not a .tsx/.jsx component file. Extract '{{ name }}' to a sibling data module."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    const { filename } = context;
+    const extension = getFileExtension(filename);
+    if (extension !== "tsx" && extension !== "jsx") {
+      return {};
+    }
+    function checkDeclarator(node) {
+      const objectInit = getObjectInitializer(node.init);
+      if (!objectInit) {
+        return;
+      }
+      if (!hasNestedProperty(objectInit)) {
+        return;
+      }
+      const name = node.id.type === AST_NODE_TYPES18.Identifier ? node.id.name : "<destructured>";
+      context.report({
+        node,
+        messageId: "noDataObject",
+        data: { name }
+      });
+    }
+    return {
+      "Program > VariableDeclaration > VariableDeclarator": checkDeclarator,
+      "Program > ExportNamedDeclaration > VariableDeclaration > VariableDeclarator": checkDeclarator
+    };
+  }
+});
+var jsx_no_data_object_default = jsxNoDataObject;
+
 // src/rules/jsx-no-inline-object-prop.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES14, ESLintUtils as ESLintUtils13 } from "@typescript-eslint/utils";
-var createRule13 = ESLintUtils13.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES19, ESLintUtils as ESLintUtils18 } from "@typescript-eslint/utils";
+var createRule18 = ESLintUtils18.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var jsxNoInlineObjectProp = createRule13({
+var jsxNoInlineObjectProp = createRule18({
   name: "jsx-no-inline-object-prop",
   meta: {
     type: "suggestion",
@@ -1150,7 +1573,7 @@ var jsxNoInlineObjectProp = createRule13({
   create(context) {
     return {
       JSXAttribute(node) {
-        if (node.value?.type === AST_NODE_TYPES14.JSXExpressionContainer && node.value.expression.type === AST_NODE_TYPES14.ObjectExpression) {
+        if (node.value?.type === AST_NODE_TYPES19.JSXExpressionContainer && node.value.expression.type === AST_NODE_TYPES19.ObjectExpression) {
           context.report({
             node: node.value,
             messageId: "noInlineObject"
@@ -1163,17 +1586,17 @@ var jsxNoInlineObjectProp = createRule13({
 var jsx_no_inline_object_prop_default = jsxNoInlineObjectProp;
 
 // src/rules/jsx-no-newline-single-line-elements.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES15, ESLintUtils as ESLintUtils14 } from "@typescript-eslint/utils";
-var createRule14 = ESLintUtils14.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES20, ESLintUtils as ESLintUtils19 } from "@typescript-eslint/utils";
+var createRule19 = ESLintUtils19.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 function isJSXElementOrFragment(node) {
-  return node.type === AST_NODE_TYPES15.JSXElement || node.type === AST_NODE_TYPES15.JSXFragment;
+  return node.type === AST_NODE_TYPES20.JSXElement || node.type === AST_NODE_TYPES20.JSXFragment;
 }
 function isSingleLine(node) {
   return node.loc.start.line === node.loc.end.line;
 }
-var jsxNoNewlineSingleLineElements = createRule14({
+var jsxNoNewlineSingleLineElements = createRule19({
   name: "jsx-no-newline-single-line-elements",
   meta: {
     type: "layout",
@@ -1191,7 +1614,7 @@ var jsxNoNewlineSingleLineElements = createRule14({
     const { sourceCode } = context;
     function checkSiblings(children) {
       const nonWhitespace = children.filter(
-        (child) => !(child.type === AST_NODE_TYPES15.JSXText && child.value.trim() === "")
+        (child) => !(child.type === AST_NODE_TYPES20.JSXText && child.value.trim() === "")
       );
       nonWhitespace.forEach((next, index) => {
         if (index === 0) {
@@ -1242,20 +1665,137 @@ ${indent}`);
 var jsx_no_newline_single_line_elements_default = jsxNoNewlineSingleLineElements;
 
 // src/rules/jsx-no-non-component-function.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES16, ESLintUtils as ESLintUtils15 } from "@typescript-eslint/utils";
-var createRule15 = ESLintUtils15.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES21, ESLintUtils as ESLintUtils20 } from "@typescript-eslint/utils";
+var createRule20 = ESLintUtils20.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var jsxNoNonComponentFunction = createRule15({
+var jsxNoNonComponentFunction = createRule20({
   name: "jsx-no-non-component-function",
   meta: {
     type: "problem",
     docs: {
-      description: "Disallow non-component functions defined at top level in .tsx and .jsx files"
+      description: "Disallow non-component functions defined at top level in .tsx and .jsx files"
+    },
+    schema: [],
+    messages: {
+      noTopLevelFunction: "Non-component functions should not be defined at top level in .tsx/.jsx files. Either move it inside the component or extract it to a separate file."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    const { filename } = context;
+    const extension = getFileExtension(filename);
+    if (extension !== "tsx" && extension !== "jsx") {
+      return {};
+    }
+    function isReactComponent2(node) {
+      const functionName = node.type === AST_NODE_TYPES21.FunctionDeclaration && node.id ? node.id.name : null;
+      if (functionName && /^[A-Z]/.test(functionName)) {
+        return true;
+      }
+      if (node.returnType?.typeAnnotation) {
+        const returnTypeNode = node.returnType.typeAnnotation;
+        if (returnTypeNode.type === AST_NODE_TYPES21.TSTypeReference && returnTypeNode.typeName.type === AST_NODE_TYPES21.Identifier) {
+          const typeName = returnTypeNode.typeName.name;
+          if (typeName === "JSX" || typeName === "ReactElement" || typeName === "ReactNode") {
+            return true;
+          }
+        }
+      }
+      return false;
+    }
+    function checkTopLevelFunction(node, declaratorNode) {
+      if (isReactComponent2(node)) {
+        return;
+      }
+      const { parent } = node;
+      if (!parent) {
+        return;
+      }
+      if (parent.type === AST_NODE_TYPES21.ExportDefaultDeclaration || parent.type === AST_NODE_TYPES21.ExportNamedDeclaration) {
+        return;
+      }
+      if (declaratorNode?.parent?.parent?.type === AST_NODE_TYPES21.ExportNamedDeclaration) {
+        return;
+      }
+      if (declaratorNode?.id.type === AST_NODE_TYPES21.Identifier) {
+        const varName = declaratorNode.id.name;
+        if (/^[A-Z]/.test(varName)) {
+          return;
+        }
+      }
+      context.report({
+        node: declaratorNode || node,
+        messageId: "noTopLevelFunction"
+      });
+    }
+    return {
+      "Program > VariableDeclaration > VariableDeclarator > ArrowFunctionExpression": function checkArrowFunction(node) {
+        const declarator = node.parent;
+        checkTopLevelFunction(node, declarator);
+      },
+      "Program > FunctionDeclaration": function checkFunctionDeclaration(node) {
+        checkTopLevelFunction(node);
+      }
+    };
+  }
+});
+var jsx_no_non_component_function_default = jsxNoNonComponentFunction;
+
+// src/rules/jsx-no-sub-interface.ts
+import { AST_NODE_TYPES as AST_NODE_TYPES22, ESLintUtils as ESLintUtils21 } from "@typescript-eslint/utils";
+var createRule21 = ESLintUtils21.RuleCreator(
+  (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
+);
+var PROPS_WRAPPER_NAMES = /* @__PURE__ */ new Set(["Readonly", "Required", "Partial", "PropsWithChildren", "NoInfer"]);
+function unwrapWrapperType(node) {
+  if (node.type === AST_NODE_TYPES22.TSTypeReference && node.typeName.type === AST_NODE_TYPES22.Identifier && PROPS_WRAPPER_NAMES.has(node.typeName.name) && node.typeArguments && node.typeArguments.params.length > 0) {
+    return unwrapWrapperType(node.typeArguments.params[0]);
+  }
+  return node;
+}
+function getMainTypeName(typeNode) {
+  if (!typeNode) {
+    return null;
+  }
+  const unwrapped = unwrapWrapperType(typeNode);
+  if (unwrapped.type === AST_NODE_TYPES22.TSTypeReference && unwrapped.typeName.type === AST_NODE_TYPES22.Identifier) {
+    return unwrapped.typeName.name;
+  }
+  return null;
+}
+function getComponentMainTypeName(node) {
+  const firstParam = node.params[0];
+  if (!firstParam) {
+    return null;
+  }
+  if ("typeAnnotation" in firstParam && firstParam.typeAnnotation) {
+    return getMainTypeName(firstParam.typeAnnotation.typeAnnotation);
+  }
+  return null;
+}
+function isPascalCase2(name) {
+  return /^[A-Z]/.test(name);
+}
+function getDeclarationFromExportWrapper(node) {
+  if (node.type === AST_NODE_TYPES22.ExportNamedDeclaration && node.declaration) {
+    return node.declaration;
+  }
+  if (node.type === AST_NODE_TYPES22.ExportDefaultDeclaration) {
+    return node.declaration;
+  }
+  return node;
+}
+var jsxNoSubInterface = createRule21({
+  name: "jsx-no-sub-interface",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow sub-interfaces and helper types in component files; keep only the main component props (extract the rest)"
     },
     schema: [],
     messages: {
-      noTopLevelFunction: "Non-component functions should not be defined at top level in .tsx/.jsx files. Either move it inside the component or extract it to a separate file."
+      noSubInterface: "Sub-interface or helper type '{{ name }}' should not live in a component file. Extract it to a sibling module (e.g., a *.types.ts file or its own component file)."
     }
   },
   defaultOptions: [],
@@ -1265,75 +1805,83 @@ var jsxNoNonComponentFunction = createRule15({
     if (extension !== "tsx" && extension !== "jsx") {
       return {};
     }
-    function isReactComponent2(node) {
-      const functionName = node.type === AST_NODE_TYPES16.FunctionDeclaration && node.id ? node.id.name : null;
-      if (functionName && /^[A-Z]/.test(functionName)) {
-        return true;
-      }
-      if (node.returnType?.typeAnnotation) {
-        const returnTypeNode = node.returnType.typeAnnotation;
-        if (returnTypeNode.type === AST_NODE_TYPES16.TSTypeReference && returnTypeNode.typeName.type === AST_NODE_TYPES16.Identifier) {
-          const typeName = returnTypeNode.typeName.name;
-          if (typeName === "JSX" || typeName === "ReactElement" || typeName === "ReactNode") {
-            return true;
+    return {
+      Program(programNode) {
+        const mainTypes = /* @__PURE__ */ new Set();
+        const typeDeclarations = [];
+        let componentCount = 0;
+        for (const statement of programNode.body) {
+          const declaration = getDeclarationFromExportWrapper(statement);
+          if (declaration.type === AST_NODE_TYPES22.FunctionDeclaration && declaration.id && isPascalCase2(declaration.id.name)) {
+            componentCount += 1;
+            const mainType = getComponentMainTypeName(declaration);
+            if (mainType) {
+              mainTypes.add(mainType);
+            }
+            continue;
+          }
+          if (declaration.type === AST_NODE_TYPES22.VariableDeclaration) {
+            for (const declarator of declaration.declarations) {
+              if (declarator.id.type !== AST_NODE_TYPES22.Identifier) {
+                continue;
+              }
+              if (!isPascalCase2(declarator.id.name)) {
+                continue;
+              }
+              const init = declarator.init;
+              if (init && (init.type === AST_NODE_TYPES22.ArrowFunctionExpression || init.type === AST_NODE_TYPES22.FunctionExpression)) {
+                componentCount += 1;
+                const mainType = getComponentMainTypeName(init);
+                if (mainType) {
+                  mainTypes.add(mainType);
+                }
+              }
+            }
+            continue;
+          }
+          if (declaration.type === AST_NODE_TYPES22.TSInterfaceDeclaration) {
+            typeDeclarations.push({ name: declaration.id.name, node: declaration });
+            continue;
+          }
+          if (declaration.type === AST_NODE_TYPES22.TSTypeAliasDeclaration) {
+            typeDeclarations.push({ name: declaration.id.name, node: declaration });
+            continue;
           }
         }
-      }
-      return false;
-    }
-    function checkTopLevelFunction(node, declaratorNode) {
-      if (isReactComponent2(node)) {
-        return;
-      }
-      const { parent } = node;
-      if (!parent) {
-        return;
-      }
-      if (parent.type === AST_NODE_TYPES16.ExportDefaultDeclaration || parent.type === AST_NODE_TYPES16.ExportNamedDeclaration) {
-        return;
-      }
-      if (declaratorNode?.parent?.parent?.type === AST_NODE_TYPES16.ExportNamedDeclaration) {
-        return;
-      }
-      if (declaratorNode?.id.type === AST_NODE_TYPES16.Identifier) {
-        const varName = declaratorNode.id.name;
-        if (/^[A-Z]/.test(varName)) {
+        if (componentCount === 0) {
           return;
         }
-      }
-      context.report({
-        node: declaratorNode || node,
-        messageId: "noTopLevelFunction"
-      });
-    }
-    return {
-      "Program > VariableDeclaration > VariableDeclarator > ArrowFunctionExpression": function checkArrowFunction(node) {
-        const declarator = node.parent;
-        checkTopLevelFunction(node, declarator);
-      },
-      "Program > FunctionDeclaration": function checkFunctionDeclaration(node) {
-        checkTopLevelFunction(node);
+        for (const declaration of typeDeclarations) {
+          if (mainTypes.has(declaration.name)) {
+            continue;
+          }
+          context.report({
+            node: declaration.node,
+            messageId: "noSubInterface",
+            data: { name: declaration.name }
+          });
+        }
       }
     };
   }
 });
-var jsx_no_non_component_function_default = jsxNoNonComponentFunction;
+var jsx_no_sub_interface_default = jsxNoSubInterface;
 
 // src/rules/jsx-no-ternary-null.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES17, ESLintUtils as ESLintUtils16 } from "@typescript-eslint/utils";
-var createRule16 = ESLintUtils16.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES23, ESLintUtils as ESLintUtils22 } from "@typescript-eslint/utils";
+var createRule22 = ESLintUtils22.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 function isNullOrUndefined(node) {
-  if (node.type === AST_NODE_TYPES17.Literal && node.value === null) {
+  if (node.type === AST_NODE_TYPES23.Literal && node.value === null) {
     return true;
   }
-  if (node.type === AST_NODE_TYPES17.Identifier && node.name === "undefined") {
+  if (node.type === AST_NODE_TYPES23.Identifier && node.name === "undefined") {
     return true;
   }
   return false;
 }
-var jsxNoTernaryNull = createRule16({
+var jsxNoTernaryNull = createRule22({
   name: "jsx-no-ternary-null",
   meta: {
     type: "suggestion",
@@ -1351,7 +1899,7 @@ var jsxNoTernaryNull = createRule16({
     return {
       JSXExpressionContainer(node) {
         const { expression } = node;
-        if (expression.type !== AST_NODE_TYPES17.ConditionalExpression) {
+        if (expression.type !== AST_NODE_TYPES23.ConditionalExpression) {
           return;
         }
         const { test, consequent, alternate } = expression;
@@ -1383,11 +1931,11 @@ var jsxNoTernaryNull = createRule16({
 var jsx_no_ternary_null_default = jsxNoTernaryNull;
 
 // src/rules/jsx-no-variable-in-callback.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES18, ESLintUtils as ESLintUtils17 } from "@typescript-eslint/utils";
-var createRule17 = ESLintUtils17.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES24, ESLintUtils as ESLintUtils23 } from "@typescript-eslint/utils";
+var createRule23 = ESLintUtils23.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var jsxNoVariableInCallback = createRule17({
+var jsxNoVariableInCallback = createRule23({
   name: "jsx-no-variable-in-callback",
   meta: {
     type: "suggestion",
@@ -1404,7 +1952,7 @@ var jsxNoVariableInCallback = createRule17({
     function isInsideJSX(node) {
       let current = node.parent;
       while (current) {
-        if (current.type === AST_NODE_TYPES18.JSXElement || current.type === AST_NODE_TYPES18.JSXFragment) {
+        if (current.type === AST_NODE_TYPES24.JSXElement || current.type === AST_NODE_TYPES24.JSXFragment) {
           return true;
         }
         current = current.parent;
@@ -1418,11 +1966,11 @@ var jsxNoVariableInCallback = createRule17({
       if (!isInsideJSX(node)) {
         return false;
       }
-      if (node.parent.type === AST_NODE_TYPES18.CallExpression || node.parent.type === AST_NODE_TYPES18.JSXExpressionContainer) {
+      if (node.parent.type === AST_NODE_TYPES24.CallExpression || node.parent.type === AST_NODE_TYPES24.JSXExpressionContainer) {
         return true;
       }
-      if (node.parent.type === AST_NODE_TYPES18.ArrayExpression && node.parent.parent) {
-        if (node.parent.parent.type === AST_NODE_TYPES18.CallExpression || node.parent.parent.type === AST_NODE_TYPES18.JSXExpressionContainer) {
+      if (node.parent.type === AST_NODE_TYPES24.ArrayExpression && node.parent.parent) {
+        if (node.parent.parent.type === AST_NODE_TYPES24.CallExpression || node.parent.parent.type === AST_NODE_TYPES24.JSXExpressionContainer) {
           return true;
         }
       }
@@ -1433,11 +1981,11 @@ var jsxNoVariableInCallback = createRule17({
         return;
       }
       const { body } = node;
-      if (body.type !== AST_NODE_TYPES18.BlockStatement) {
+      if (body.type !== AST_NODE_TYPES24.BlockStatement) {
         return;
       }
       body.body.forEach((statement) => {
-        if (statement.type === AST_NODE_TYPES18.VariableDeclaration) {
+        if (statement.type === AST_NODE_TYPES24.VariableDeclaration) {
           context.report({
             node: statement,
             messageId: "noVariableInCallback"
@@ -1454,11 +2002,11 @@ var jsxNoVariableInCallback = createRule17({
 var jsx_no_variable_in_callback_default = jsxNoVariableInCallback;
 
 // src/rules/jsx-require-suspense.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES19, ESLintUtils as ESLintUtils18 } from "@typescript-eslint/utils";
-var createRule18 = ESLintUtils18.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES25, ESLintUtils as ESLintUtils24 } from "@typescript-eslint/utils";
+var createRule24 = ESLintUtils24.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var jsxRequireSuspense = createRule18({
+var jsxRequireSuspense = createRule24({
   name: "jsx-require-suspense",
   meta: {
     type: "problem",
@@ -1476,7 +2024,7 @@ var jsxRequireSuspense = createRule18({
     const isInsideSuspense = (node) => {
       let current = node.parent;
       while (current) {
-        if (current.type === AST_NODE_TYPES19.JSXElement && current.openingElement.name.type === AST_NODE_TYPES19.JSXIdentifier && current.openingElement.name.name === "Suspense") {
+        if (current.type === AST_NODE_TYPES25.JSXElement && current.openingElement.name.type === AST_NODE_TYPES25.JSXIdentifier && current.openingElement.name.name === "Suspense") {
           return true;
         }
         current = current.parent;
@@ -1485,16 +2033,16 @@ var jsxRequireSuspense = createRule18({
     };
     return {
       VariableDeclarator(node) {
-        if (node.id.type === AST_NODE_TYPES19.Identifier && node.init?.type === AST_NODE_TYPES19.CallExpression) {
+        if (node.id.type === AST_NODE_TYPES25.Identifier && node.init?.type === AST_NODE_TYPES25.CallExpression) {
           const { callee } = node.init;
-          const isLazyCall = callee.type === AST_NODE_TYPES19.Identifier && callee.name === "lazy" || callee.type === AST_NODE_TYPES19.MemberExpression && callee.object.type === AST_NODE_TYPES19.Identifier && callee.object.name === "React" && callee.property.type === AST_NODE_TYPES19.Identifier && callee.property.name === "lazy";
+          const isLazyCall = callee.type === AST_NODE_TYPES25.Identifier && callee.name === "lazy" || callee.type === AST_NODE_TYPES25.MemberExpression && callee.object.type === AST_NODE_TYPES25.Identifier && callee.object.name === "React" && callee.property.type === AST_NODE_TYPES25.Identifier && callee.property.name === "lazy";
           if (isLazyCall) {
             lazyComponents.add(node.id.name);
           }
         }
       },
       JSXOpeningElement(node) {
-        if (node.name.type === AST_NODE_TYPES19.JSXIdentifier) {
+        if (node.name.type === AST_NODE_TYPES25.JSXIdentifier) {
           const componentName = node.name.name;
           if (lazyComponents.has(componentName) && !isInsideSuspense(node)) {
             context.report({
@@ -1513,11 +2061,11 @@ var jsxRequireSuspense = createRule18({
 var jsx_require_suspense_default = jsxRequireSuspense;
 
 // src/rules/jsx-simple-props.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES20, ESLintUtils as ESLintUtils19 } from "@typescript-eslint/utils";
-var createRule19 = ESLintUtils19.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES26, ESLintUtils as ESLintUtils25 } from "@typescript-eslint/utils";
+var createRule25 = ESLintUtils25.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var jsxSimpleProps = createRule19({
+var jsxSimpleProps = createRule25({
   name: "jsx-simple-props",
   meta: {
     type: "suggestion",
@@ -1532,25 +2080,25 @@ var jsxSimpleProps = createRule19({
   defaultOptions: [],
   create(context) {
     const allowedExpressionTypes = /* @__PURE__ */ new Set([
-      AST_NODE_TYPES20.Identifier,
-      AST_NODE_TYPES20.Literal,
-      AST_NODE_TYPES20.JSXElement,
-      AST_NODE_TYPES20.JSXFragment,
-      AST_NODE_TYPES20.MemberExpression,
-      AST_NODE_TYPES20.ArrowFunctionExpression,
-      AST_NODE_TYPES20.FunctionExpression
+      AST_NODE_TYPES26.Identifier,
+      AST_NODE_TYPES26.Literal,
+      AST_NODE_TYPES26.JSXElement,
+      AST_NODE_TYPES26.JSXFragment,
+      AST_NODE_TYPES26.MemberExpression,
+      AST_NODE_TYPES26.ArrowFunctionExpression,
+      AST_NODE_TYPES26.FunctionExpression
     ]);
     return {
       JSXAttribute(node) {
         if (!node.value) {
           return;
         }
-        if (node.value.type === AST_NODE_TYPES20.Literal) {
+        if (node.value.type === AST_NODE_TYPES26.Literal) {
           return;
         }
-        if (node.value.type === AST_NODE_TYPES20.JSXExpressionContainer) {
+        if (node.value.type === AST_NODE_TYPES26.JSXExpressionContainer) {
           const { expression } = node.value;
-          if (expression.type === AST_NODE_TYPES20.JSXEmptyExpression) {
+          if (expression.type === AST_NODE_TYPES26.JSXEmptyExpression) {
             return;
           }
           if (!allowedExpressionTypes.has(expression.type)) {
@@ -1567,8 +2115,8 @@ var jsxSimpleProps = createRule19({
 var jsx_simple_props_default = jsxSimpleProps;
 
 // src/rules/jsx-sort-props.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES21, ESLintUtils as ESLintUtils20 } from "@typescript-eslint/utils";
-var createRule20 = ESLintUtils20.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES27, ESLintUtils as ESLintUtils26 } from "@typescript-eslint/utils";
+var createRule26 = ESLintUtils26.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var TYPE_GROUP = {
@@ -1582,15 +2130,15 @@ var TYPE_GROUP = {
   SHORTHAND: 8
 };
 var EXPRESSION_TYPE_TO_GROUP = /* @__PURE__ */ new Map([
-  [AST_NODE_TYPES21.ObjectExpression, TYPE_GROUP.OBJECT_ARRAY],
-  [AST_NODE_TYPES21.ArrayExpression, TYPE_GROUP.OBJECT_ARRAY],
-  [AST_NODE_TYPES21.ArrowFunctionExpression, TYPE_GROUP.FUNCTION],
-  [AST_NODE_TYPES21.FunctionExpression, TYPE_GROUP.FUNCTION],
-  [AST_NODE_TYPES21.JSXElement, TYPE_GROUP.JSX],
-  [AST_NODE_TYPES21.JSXFragment, TYPE_GROUP.JSX]
+  [AST_NODE_TYPES27.ObjectExpression, TYPE_GROUP.OBJECT_ARRAY],
+  [AST_NODE_TYPES27.ArrayExpression, TYPE_GROUP.OBJECT_ARRAY],
+  [AST_NODE_TYPES27.ArrowFunctionExpression, TYPE_GROUP.FUNCTION],
+  [AST_NODE_TYPES27.FunctionExpression, TYPE_GROUP.FUNCTION],
+  [AST_NODE_TYPES27.JSXElement, TYPE_GROUP.JSX],
+  [AST_NODE_TYPES27.JSXFragment, TYPE_GROUP.JSX]
 ]);
 function isHyphenatedName(node) {
-  return node.name.type === AST_NODE_TYPES21.JSXIdentifier && node.name.name.includes("-");
+  return node.name.type === AST_NODE_TYPES27.JSXIdentifier && node.name.name.includes("-");
 }
 function getStringGroup(node) {
   return isHyphenatedName(node) ? TYPE_GROUP.HYPHENATED_STRING : TYPE_GROUP.STRING;
@@ -1602,13 +2150,13 @@ function getLiteralValueGroup(value) {
   return TYPE_GROUP.NUMBER_BOOLEAN_NULL;
 }
 function getExpressionGroup(expression) {
-  if (expression.type === AST_NODE_TYPES21.Literal) {
+  if (expression.type === AST_NODE_TYPES27.Literal) {
     return getLiteralValueGroup(expression.value);
   }
-  if (expression.type === AST_NODE_TYPES21.TemplateLiteral) {
+  if (expression.type === AST_NODE_TYPES27.TemplateLiteral) {
     return null;
   }
-  if (expression.type === AST_NODE_TYPES21.Identifier && expression.name === "undefined") {
+  if (expression.type === AST_NODE_TYPES27.Identifier && expression.name === "undefined") {
     return TYPE_GROUP.NUMBER_BOOLEAN_NULL;
   }
   return EXPRESSION_TYPE_TO_GROUP.get(expression.type) ?? TYPE_GROUP.EXPRESSION;
@@ -1617,17 +2165,17 @@ function getTypeGroup(node) {
   if (node.value === null) {
     return TYPE_GROUP.SHORTHAND;
   }
-  if (node.value.type === AST_NODE_TYPES21.Literal) {
+  if (node.value.type === AST_NODE_TYPES27.Literal) {
     if (typeof node.value.value === "string") {
       return getStringGroup(node);
     }
     return TYPE_GROUP.NUMBER_BOOLEAN_NULL;
   }
-  if (node.value.type !== AST_NODE_TYPES21.JSXExpressionContainer) {
+  if (node.value.type !== AST_NODE_TYPES27.JSXExpressionContainer) {
     return null;
   }
   const { expression } = node.value;
-  if (expression.type === AST_NODE_TYPES21.JSXEmptyExpression) {
+  if (expression.type === AST_NODE_TYPES27.JSXEmptyExpression) {
     return null;
   }
   const group = getExpressionGroup(expression);
@@ -1639,7 +2187,7 @@ function getTypeGroup(node) {
 function hasUnsortedProps(attributes) {
   let lastGroup = 0;
   return attributes.some((attribute) => {
-    if (attribute.type === AST_NODE_TYPES21.JSXSpreadAttribute) {
+    if (attribute.type === AST_NODE_TYPES27.JSXSpreadAttribute) {
       lastGroup = 0;
       return false;
     }
@@ -1663,7 +2211,7 @@ function getSegments(attributes) {
   const result = [];
   let current = [];
   attributes.forEach((attr) => {
-    if (attr.type === AST_NODE_TYPES21.JSXSpreadAttribute) {
+    if (attr.type === AST_NODE_TYPES27.JSXSpreadAttribute) {
       if (current.length > 0) {
         result.push(current);
         current = [];
@@ -1677,7 +2225,7 @@ function getSegments(attributes) {
   }
   return result;
 }
-var jsxSortProps = createRule20({
+var jsxSortProps = createRule26({
   name: "jsx-sort-props",
   meta: {
     type: "suggestion",
@@ -1712,11 +2260,11 @@ var jsxSortProps = createRule20({
 var jsx_sort_props_default = jsxSortProps;
 
 // src/rules/jsx-spread-props-last.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES22, ESLintUtils as ESLintUtils21 } from "@typescript-eslint/utils";
-var createRule21 = ESLintUtils21.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES28, ESLintUtils as ESLintUtils27 } from "@typescript-eslint/utils";
+var createRule27 = ESLintUtils27.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var jsxSpreadPropsLast = createRule21({
+var jsxSpreadPropsLast = createRule27({
   name: "jsx-spread-props-last",
   meta: {
     type: "suggestion",
@@ -1735,12 +2283,12 @@ var jsxSpreadPropsLast = createRule21({
         const { attributes } = node;
         let lastNonSpreadIndex = -1;
         attributes.forEach((attribute, index) => {
-          if (attribute.type !== AST_NODE_TYPES22.JSXSpreadAttribute) {
+          if (attribute.type !== AST_NODE_TYPES28.JSXSpreadAttribute) {
             lastNonSpreadIndex = index;
           }
         });
         attributes.forEach((attribute, index) => {
-          if (attribute.type === AST_NODE_TYPES22.JSXSpreadAttribute && index < lastNonSpreadIndex) {
+          if (attribute.type === AST_NODE_TYPES28.JSXSpreadAttribute && index < lastNonSpreadIndex) {
             context.report({
               node: attribute,
               messageId: "spreadNotLast"
@@ -1754,12 +2302,12 @@ var jsxSpreadPropsLast = createRule21({
 var jsx_spread_props_last_default = jsxSpreadPropsLast;
 
 // src/rules/newline-after-multiline-block.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES23, ESLintUtils as ESLintUtils22 } from "@typescript-eslint/utils";
-var createRule22 = ESLintUtils22.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES29, ESLintUtils as ESLintUtils28 } from "@typescript-eslint/utils";
+var createRule28 = ESLintUtils28.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 function isImportDeclaration(node) {
-  return node.type === AST_NODE_TYPES23.ImportDeclaration;
+  return node.type === AST_NODE_TYPES29.ImportDeclaration;
 }
 function checkStatements(statements, context) {
   const { sourceCode } = context;
@@ -1794,7 +2342,7 @@ function checkStatements(statements, context) {
     }
   });
 }
-var newlineAfterMultilineBlock = createRule22({
+var newlineAfterMultilineBlock = createRule28({
   name: "newline-after-multiline-block",
   meta: {
     type: "layout",
@@ -1822,11 +2370,11 @@ var newlineAfterMultilineBlock = createRule22({
 var newline_after_multiline_block_default = newlineAfterMultilineBlock;
 
 // src/rules/newline-before-return.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES24, ESLintUtils as ESLintUtils23 } from "@typescript-eslint/utils";
-var createRule23 = ESLintUtils23.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES30, ESLintUtils as ESLintUtils29 } from "@typescript-eslint/utils";
+var createRule29 = ESLintUtils29.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var newlineBeforeReturn = createRule23({
+var newlineBeforeReturn = createRule29({
   name: "newline-before-return",
   meta: {
     type: "layout",
@@ -1844,7 +2392,7 @@ var newlineBeforeReturn = createRule23({
     const { sourceCode } = context;
     function checkReturnStatement(node) {
       const { parent } = node;
-      if (!parent || parent.type !== AST_NODE_TYPES24.BlockStatement) {
+      if (!parent || parent.type !== AST_NODE_TYPES30.BlockStatement) {
         return;
       }
       const { body: statements } = parent;
@@ -1881,11 +2429,11 @@ var newlineBeforeReturn = createRule23({
 var newline_before_return_default = newlineBeforeReturn;
 
 // src/rules/no-complex-inline-return.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES25, ESLintUtils as ESLintUtils24 } from "@typescript-eslint/utils";
-var createRule24 = ESLintUtils24.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES31, ESLintUtils as ESLintUtils30 } from "@typescript-eslint/utils";
+var createRule30 = ESLintUtils30.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var noComplexInlineReturn = createRule24({
+var noComplexInlineReturn = createRule30({
   name: "no-complex-inline-return",
   meta: {
     type: "suggestion",
@@ -1901,13 +2449,13 @@ var noComplexInlineReturn = createRule24({
   create(context) {
     const isComplexExpression = (node) => {
       if (!node) return false;
-      if (node.type === AST_NODE_TYPES25.ConditionalExpression) {
+      if (node.type === AST_NODE_TYPES31.ConditionalExpression) {
         return true;
       }
-      if (node.type === AST_NODE_TYPES25.LogicalExpression) {
+      if (node.type === AST_NODE_TYPES31.LogicalExpression) {
         return true;
       }
-      if (node.type === AST_NODE_TYPES25.NewExpression) {
+      if (node.type === AST_NODE_TYPES31.NewExpression) {
         return true;
       }
       return false;
@@ -1927,11 +2475,11 @@ var noComplexInlineReturn = createRule24({
 var no_complex_inline_return_default = noComplexInlineReturn;
 
 // src/rules/no-direct-date.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES26, ESLintUtils as ESLintUtils25 } from "@typescript-eslint/utils";
-var createRule25 = ESLintUtils25.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES32, ESLintUtils as ESLintUtils31 } from "@typescript-eslint/utils";
+var createRule31 = ESLintUtils31.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var noDirectDate = createRule25({
+var noDirectDate = createRule31({
   name: "no-direct-date",
   meta: {
     type: "problem",
@@ -1949,7 +2497,7 @@ var noDirectDate = createRule25({
   create(context) {
     return {
       NewExpression(node) {
-        if (node.callee.type === AST_NODE_TYPES26.Identifier && node.callee.name === "Date") {
+        if (node.callee.type === AST_NODE_TYPES32.Identifier && node.callee.name === "Date") {
           context.report({
             node,
             messageId: "noNewDate"
@@ -1957,7 +2505,7 @@ var noDirectDate = createRule25({
         }
       },
       CallExpression(node) {
-        if (node.callee.type === AST_NODE_TYPES26.MemberExpression && node.callee.object.type === AST_NODE_TYPES26.Identifier && node.callee.object.name === "Date" && node.callee.property.type === AST_NODE_TYPES26.Identifier) {
+        if (node.callee.type === AST_NODE_TYPES32.MemberExpression && node.callee.object.type === AST_NODE_TYPES32.Identifier && node.callee.object.name === "Date" && node.callee.property.type === AST_NODE_TYPES32.Identifier) {
           const methodName = node.callee.property.name;
           if (methodName === "now") {
             context.report({
@@ -1980,11 +2528,11 @@ var no_direct_date_default = noDirectDate;
 
 // src/rules/no-emoji.ts
 import emojiRegex from "emoji-regex";
-import { ESLintUtils as ESLintUtils26 } from "@typescript-eslint/utils";
-var createRule26 = ESLintUtils26.RuleCreator(
+import { ESLintUtils as ESLintUtils32 } from "@typescript-eslint/utils";
+var createRule32 = ESLintUtils32.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var noEmoji = createRule26({
+var noEmoji = createRule32({
   name: "no-emoji",
   meta: {
     type: "problem",
@@ -2018,11 +2566,11 @@ var noEmoji = createRule26({
 var no_emoji_default = noEmoji;
 
 // src/rules/no-env-fallback.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES27, ESLintUtils as ESLintUtils27 } from "@typescript-eslint/utils";
-var createRule27 = ESLintUtils27.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES33, ESLintUtils as ESLintUtils33 } from "@typescript-eslint/utils";
+var createRule33 = ESLintUtils33.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var noEnvFallback = createRule27({
+var noEnvFallback = createRule33({
   name: "no-env-fallback",
   meta: {
     type: "problem",
@@ -2037,16 +2585,16 @@ var noEnvFallback = createRule27({
   defaultOptions: [],
   create(context) {
     const isProcessEnvAccess = (node) => {
-      if (node.type !== AST_NODE_TYPES27.MemberExpression) {
+      if (node.type !== AST_NODE_TYPES33.MemberExpression) {
         return false;
       }
       const { object } = node;
-      if (object.type !== AST_NODE_TYPES27.MemberExpression) {
+      if (object.type !== AST_NODE_TYPES33.MemberExpression) {
         return false;
       }
       const processNode = object.object;
       const envNode = object.property;
-      return processNode.type === AST_NODE_TYPES27.Identifier && processNode.name === "process" && envNode.type === AST_NODE_TYPES27.Identifier && envNode.name === "env";
+      return processNode.type === AST_NODE_TYPES33.Identifier && processNode.name === "process" && envNode.type === AST_NODE_TYPES33.Identifier && envNode.name === "env";
     };
     return {
       LogicalExpression(node) {
@@ -2071,15 +2619,15 @@ var noEnvFallback = createRule27({
 var no_env_fallback_default = noEnvFallback;
 
 // src/rules/no-ghost-wrapper.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES28, ESLintUtils as ESLintUtils28 } from "@typescript-eslint/utils";
-var createRule28 = ESLintUtils28.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES34, ESLintUtils as ESLintUtils34 } from "@typescript-eslint/utils";
+var createRule34 = ESLintUtils34.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 === AST_NODE_TYPES28.JSXAttribute && attribute.name.type === AST_NODE_TYPES28.JSXIdentifier && attribute.name.name === "key";
+  return attribute.type === AST_NODE_TYPES34.JSXAttribute && attribute.name.type === AST_NODE_TYPES34.JSXIdentifier && attribute.name.name === "key";
 }
-var noGhostWrapper = createRule28({
+var noGhostWrapper = createRule34({
   name: "no-ghost-wrapper",
   meta: {
     type: "problem",
@@ -2095,7 +2643,7 @@ var noGhostWrapper = createRule28({
   create(context) {
     return {
       JSXOpeningElement(node) {
-        if (node.name.type !== AST_NODE_TYPES28.JSXIdentifier) {
+        if (node.name.type !== AST_NODE_TYPES34.JSXIdentifier) {
           return;
         }
         const tagName = node.name.name;
@@ -2116,12 +2664,92 @@ var noGhostWrapper = createRule28({
 });
 var no_ghost_wrapper_default = noGhostWrapper;
 
+// src/rules/no-helper-function-in-hook.ts
+import { AST_NODE_TYPES as AST_NODE_TYPES35, ESLintUtils as ESLintUtils35 } from "@typescript-eslint/utils";
+var createRule35 = ESLintUtils35.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 === AST_NODE_TYPES35.Program) return true;
+      if (parent.type !== AST_NODE_TYPES35.ExportNamedDeclaration) return false;
+      return parent.parent?.type === AST_NODE_TYPES35.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 !== AST_NODE_TYPES35.VariableDeclaration) return;
+        if (!isAtProgramLevel(node.parent)) return;
+        if (node.init === null || node.init.type !== AST_NODE_TYPES35.ArrowFunctionExpression && node.init.type !== AST_NODE_TYPES35.FunctionExpression)
+          return;
+        if (node.id.type === AST_NODE_TYPES35.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
+import { AST_NODE_TYPES as AST_NODE_TYPES36, ESLintUtils as ESLintUtils36 } from "@typescript-eslint/utils";
+var createRule36 = ESLintUtils36.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 === AST_NODE_TYPES36.Program) {
+          context.report({ node, messageId: "noHelperFunction" });
+        }
+      },
+      VariableDeclarator(node) {
+        if (node.parent.type === AST_NODE_TYPES36.VariableDeclaration && node.parent.parent.type === AST_NODE_TYPES36.Program && node.init !== null && (node.init.type === AST_NODE_TYPES36.ArrowFunctionExpression || node.init.type === AST_NODE_TYPES36.FunctionExpression)) {
+          context.report({ node, messageId: "noHelperFunction" });
+        }
+      }
+    };
+  }
+});
+var no_helper_function_in_test_default = noHelperFunctionInTest;
+
 // src/rules/no-inline-default-export.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES29, ESLintUtils as ESLintUtils29 } from "@typescript-eslint/utils";
-var createRule29 = ESLintUtils29.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES37, ESLintUtils as ESLintUtils37 } from "@typescript-eslint/utils";
+var createRule37 = ESLintUtils37.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var noInlineDefaultExport = createRule29({
+var noInlineDefaultExport = createRule37({
   name: "no-inline-default-export",
   meta: {
     type: "suggestion",
@@ -2140,7 +2768,7 @@ var noInlineDefaultExport = createRule29({
     return {
       ExportDefaultDeclaration(node) {
         const { declaration } = node;
-        if (declaration.type === AST_NODE_TYPES29.FunctionDeclaration) {
+        if (declaration.type === AST_NODE_TYPES37.FunctionDeclaration) {
           if (declaration.id) {
             context.report({
               node,
@@ -2155,7 +2783,7 @@ var noInlineDefaultExport = createRule29({
             });
           }
         }
-        if (declaration.type === AST_NODE_TYPES29.ClassDeclaration) {
+        if (declaration.type === AST_NODE_TYPES37.ClassDeclaration) {
           if (declaration.id) {
             context.report({
               node,
@@ -2170,7 +2798,7 @@ var noInlineDefaultExport = createRule29({
             });
           }
         }
-        if (declaration.type === AST_NODE_TYPES29.ArrowFunctionExpression || declaration.type === AST_NODE_TYPES29.FunctionExpression) {
+        if (declaration.type === AST_NODE_TYPES37.ArrowFunctionExpression || declaration.type === AST_NODE_TYPES37.FunctionExpression) {
           context.report({
             node,
             messageId: "noAnonymousDefaultExport",
@@ -2183,14 +2811,14 @@ var noInlineDefaultExport = createRule29({
         if (!declaration) {
           return;
         }
-        if (declaration.type === AST_NODE_TYPES29.FunctionDeclaration && declaration.id) {
+        if (declaration.type === AST_NODE_TYPES37.FunctionDeclaration && declaration.id) {
           context.report({
             node,
             messageId: "noInlineNamedExport",
             data: { type: "function", name: declaration.id.name }
           });
         }
-        if (declaration.type === AST_NODE_TYPES29.ClassDeclaration && declaration.id) {
+        if (declaration.type === AST_NODE_TYPES37.ClassDeclaration && declaration.id) {
           context.report({
             node,
             messageId: "noInlineNamedExport",
@@ -2204,27 +2832,27 @@ var noInlineDefaultExport = createRule29({
 var no_inline_default_export_default = noInlineDefaultExport;
 
 // src/rules/no-inline-nested-object.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES30, ESLintUtils as ESLintUtils30 } from "@typescript-eslint/utils";
-var createRule30 = ESLintUtils30.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES38, ESLintUtils as ESLintUtils38 } from "@typescript-eslint/utils";
+var createRule38 = ESLintUtils38.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 function isObjectOrArray(node) {
-  return node.type === AST_NODE_TYPES30.ObjectExpression || node.type === AST_NODE_TYPES30.ArrayExpression || node.type === AST_NODE_TYPES30.TSAsExpression;
+  return node.type === AST_NODE_TYPES38.ObjectExpression || node.type === AST_NODE_TYPES38.ArrayExpression || node.type === AST_NODE_TYPES38.TSAsExpression;
 }
 function getInnerExpression(node) {
-  if (node.type === AST_NODE_TYPES30.TSAsExpression) {
+  if (node.type === AST_NODE_TYPES38.TSAsExpression) {
     return getInnerExpression(node.expression);
   }
   return node;
 }
 function isNestedStructure(node) {
   const inner = getInnerExpression(node);
-  return inner.type === AST_NODE_TYPES30.ObjectExpression || inner.type === AST_NODE_TYPES30.ArrayExpression;
+  return inner.type === AST_NODE_TYPES38.ObjectExpression || inner.type === AST_NODE_TYPES38.ArrayExpression;
 }
 function containsNestedStructure(node) {
-  if (node.type === AST_NODE_TYPES30.ObjectExpression) {
+  if (node.type === AST_NODE_TYPES38.ObjectExpression) {
     return node.properties.some((prop) => {
-      if (prop.type !== AST_NODE_TYPES30.Property) return false;
+      if (prop.type !== AST_NODE_TYPES38.Property) return false;
       return isNestedStructure(prop.value);
     });
   }
@@ -2233,7 +2861,7 @@ function containsNestedStructure(node) {
     return isNestedStructure(el);
   });
 }
-var noInlineNestedObject = createRule30({
+var noInlineNestedObject = createRule38({
   name: "no-inline-nested-object",
   meta: {
     type: "layout",
@@ -2255,7 +2883,7 @@ var noInlineNestedObject = createRule30({
           return;
         }
         const valueNode = getInnerExpression(node.value);
-        if (valueNode.type !== AST_NODE_TYPES30.ObjectExpression && valueNode.type !== AST_NODE_TYPES30.ArrayExpression) {
+        if (valueNode.type !== AST_NODE_TYPES38.ObjectExpression && valueNode.type !== AST_NODE_TYPES38.ArrayExpression) {
           return;
         }
         if (!valueNode.loc) {
@@ -2268,7 +2896,7 @@ var noInlineNestedObject = createRule30({
         if (!containsNestedStructure(valueNode)) {
           return;
         }
-        const elements = valueNode.type === AST_NODE_TYPES30.ObjectExpression ? valueNode.properties : valueNode.elements;
+        const elements = valueNode.type === AST_NODE_TYPES38.ObjectExpression ? valueNode.properties : valueNode.elements;
         context.report({
           node: valueNode,
           messageId: "requireMultiline",
@@ -2281,7 +2909,7 @@ var noInlineNestedObject = createRule30({
             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 === AST_NODE_TYPES30.ObjectExpression;
+            const isObject = valueNode.type === AST_NODE_TYPES38.ObjectExpression;
             const openChar = isObject ? "{" : "[";
             const closeChar = isObject ? "}" : "]";
             const formattedElements = elementTexts.map((text) => `${innerIndent}${text},`).join("\n");
@@ -2298,20 +2926,20 @@ ${indent}${closeChar}`;
 var no_inline_nested_object_default = noInlineNestedObject;
 
 // src/rules/no-inline-return-properties.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES31, ESLintUtils as ESLintUtils31 } from "@typescript-eslint/utils";
-var createRule31 = ESLintUtils31.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES39, ESLintUtils as ESLintUtils39 } from "@typescript-eslint/utils";
+var createRule39 = ESLintUtils39.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var isShorthandProperty = (property) => {
-  if (property.type === AST_NODE_TYPES31.SpreadElement) {
+  if (property.type === AST_NODE_TYPES39.SpreadElement) {
     return true;
   }
-  if (property.type !== AST_NODE_TYPES31.Property) {
+  if (property.type !== AST_NODE_TYPES39.Property) {
     return false;
   }
   return property.shorthand;
 };
-var noInlineReturnProperties = createRule31({
+var noInlineReturnProperties = createRule39({
   name: "no-inline-return-properties",
   meta: {
     type: "suggestion",
@@ -2327,20 +2955,20 @@ var noInlineReturnProperties = createRule31({
   create(context) {
     return {
       ReturnStatement(node) {
-        if (!node.argument || node.argument.type !== AST_NODE_TYPES31.ObjectExpression) {
+        if (!node.argument || node.argument.type !== AST_NODE_TYPES39.ObjectExpression) {
           return;
         }
         node.argument.properties.forEach((property) => {
           if (isShorthandProperty(property)) {
             return;
           }
-          if (property.type !== AST_NODE_TYPES31.Property) {
+          if (property.type !== AST_NODE_TYPES39.Property) {
             return;
           }
           let keyName = null;
-          if (property.key.type === AST_NODE_TYPES31.Identifier) {
+          if (property.key.type === AST_NODE_TYPES39.Identifier) {
             keyName = property.key.name;
-          } else if (property.key.type === AST_NODE_TYPES31.Literal) {
+          } else if (property.key.type === AST_NODE_TYPES39.Literal) {
             keyName = String(property.key.value);
           }
           context.report({
@@ -2356,12 +2984,12 @@ var noInlineReturnProperties = createRule31({
 var no_inline_return_properties_default = noInlineReturnProperties;
 
 // src/rules/no-inline-type-import.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES32, ESLintUtils as ESLintUtils32 } from "@typescript-eslint/utils";
-var createRule32 = ESLintUtils32.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES40, ESLintUtils as ESLintUtils40 } from "@typescript-eslint/utils";
+var createRule40 = ESLintUtils40.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var isInlineTypeSpecifier = (specifier) => specifier.type === AST_NODE_TYPES32.ImportSpecifier && specifier.importKind === "type";
-var noInlineTypeImport = createRule32({
+var isInlineTypeSpecifier = (specifier) => specifier.type === AST_NODE_TYPES40.ImportSpecifier && specifier.importKind === "type";
+var noInlineTypeImport = createRule40({
   name: "no-inline-type-import",
   meta: {
     type: "suggestion",
@@ -2398,7 +3026,7 @@ var noInlineTypeImport = createRule32({
             );
             const typeImport = `import type { ${typeSpecifierTexts.join(", ")} } from ${sourceText};`;
             const valueSpecifiers = node.specifiers.filter(
-              (specifier) => !(specifier.type === AST_NODE_TYPES32.ImportSpecifier && specifier.importKind === "type")
+              (specifier) => !(specifier.type === AST_NODE_TYPES40.ImportSpecifier && specifier.importKind === "type")
             );
             if (valueSpecifiers.length === 0) {
               return fixer.replaceText(node, typeImport);
@@ -2406,11 +3034,11 @@ var noInlineTypeImport = createRule32({
             const parts = [];
             const namedValueSpecifiers = [];
             for (const specifier of valueSpecifiers) {
-              if (specifier.type === AST_NODE_TYPES32.ImportDefaultSpecifier) {
+              if (specifier.type === AST_NODE_TYPES40.ImportDefaultSpecifier) {
                 parts.push(specifier.local.name);
-              } else if (specifier.type === AST_NODE_TYPES32.ImportNamespaceSpecifier) {
+              } else if (specifier.type === AST_NODE_TYPES40.ImportNamespaceSpecifier) {
                 parts.push(`* as ${specifier.local.name}`);
-              } else if (specifier.type === AST_NODE_TYPES32.ImportSpecifier) {
+              } else if (specifier.type === AST_NODE_TYPES40.ImportSpecifier) {
                 namedValueSpecifiers.push(specifier);
               }
             }
@@ -2430,8 +3058,8 @@ ${typeImport}`);
 var no_inline_type_import_default = noInlineTypeImport;
 
 // src/rules/no-lazy-identifiers.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES33, ESLintUtils as ESLintUtils33 } from "@typescript-eslint/utils";
-var createRule33 = ESLintUtils33.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES41, ESLintUtils as ESLintUtils41 } from "@typescript-eslint/utils";
+var createRule41 = ESLintUtils41.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"];
@@ -2472,7 +3100,7 @@ var isLazyIdentifier = (name) => {
   }
   return false;
 };
-var noLazyIdentifiers = createRule33({
+var noLazyIdentifiers = createRule41({
   name: "no-lazy-identifiers",
   meta: {
     type: "problem",
@@ -2498,27 +3126,27 @@ var noLazyIdentifiers = createRule33({
       });
     };
     const checkPattern = (pattern) => {
-      if (pattern.type === AST_NODE_TYPES33.Identifier) {
+      if (pattern.type === AST_NODE_TYPES41.Identifier) {
         checkIdentifier(pattern);
-      } else if (pattern.type === AST_NODE_TYPES33.ObjectPattern) {
+      } else if (pattern.type === AST_NODE_TYPES41.ObjectPattern) {
         pattern.properties.forEach((prop) => {
-          if (prop.type === AST_NODE_TYPES33.Property && prop.value.type === AST_NODE_TYPES33.Identifier) {
+          if (prop.type === AST_NODE_TYPES41.Property && prop.value.type === AST_NODE_TYPES41.Identifier) {
             checkIdentifier(prop.value);
-          } else if (prop.type === AST_NODE_TYPES33.RestElement && prop.argument.type === AST_NODE_TYPES33.Identifier) {
+          } else if (prop.type === AST_NODE_TYPES41.RestElement && prop.argument.type === AST_NODE_TYPES41.Identifier) {
             checkIdentifier(prop.argument);
           }
         });
-      } else if (pattern.type === AST_NODE_TYPES33.ArrayPattern) {
+      } else if (pattern.type === AST_NODE_TYPES41.ArrayPattern) {
         pattern.elements.forEach((element) => {
-          if (element?.type === AST_NODE_TYPES33.Identifier) {
+          if (element?.type === AST_NODE_TYPES41.Identifier) {
             checkIdentifier(element);
-          } else if (element?.type === AST_NODE_TYPES33.RestElement && element.argument.type === AST_NODE_TYPES33.Identifier) {
+          } else if (element?.type === AST_NODE_TYPES41.RestElement && element.argument.type === AST_NODE_TYPES41.Identifier) {
             checkIdentifier(element.argument);
           }
         });
-      } else if (pattern.type === AST_NODE_TYPES33.AssignmentPattern && pattern.left.type === AST_NODE_TYPES33.Identifier) {
+      } else if (pattern.type === AST_NODE_TYPES41.AssignmentPattern && pattern.left.type === AST_NODE_TYPES41.Identifier) {
         checkIdentifier(pattern.left);
-      } else if (pattern.type === AST_NODE_TYPES33.RestElement && pattern.argument.type === AST_NODE_TYPES33.Identifier) {
+      } else if (pattern.type === AST_NODE_TYPES41.RestElement && pattern.argument.type === AST_NODE_TYPES41.Identifier) {
         checkIdentifier(pattern.argument);
       }
     };
@@ -2563,11 +3191,11 @@ var noLazyIdentifiers = createRule33({
 var no_lazy_identifiers_default = noLazyIdentifiers;
 
 // src/rules/no-logic-in-params.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES34, ESLintUtils as ESLintUtils34 } from "@typescript-eslint/utils";
-var createRule34 = ESLintUtils34.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES42, ESLintUtils as ESLintUtils42 } from "@typescript-eslint/utils";
+var createRule42 = ESLintUtils42.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var noLogicInParams = createRule34({
+var noLogicInParams = createRule42({
   name: "no-logic-in-params",
   meta: {
     type: "suggestion",
@@ -2582,20 +3210,20 @@ var noLogicInParams = createRule34({
   defaultOptions: [],
   create(context) {
     const isComplexExpression = (node) => {
-      if (node.type === AST_NODE_TYPES34.SpreadElement) {
+      if (node.type === AST_NODE_TYPES42.SpreadElement) {
         return false;
       }
-      if (node.type === AST_NODE_TYPES34.ConditionalExpression) {
+      if (node.type === AST_NODE_TYPES42.ConditionalExpression) {
         return true;
       }
-      if (node.type === AST_NODE_TYPES34.LogicalExpression) {
+      if (node.type === AST_NODE_TYPES42.LogicalExpression) {
         return true;
       }
-      if (node.type === AST_NODE_TYPES34.BinaryExpression) {
+      if (node.type === AST_NODE_TYPES42.BinaryExpression) {
         const logicalOperators = ["==", "===", "!=", "!==", "<", ">", "<=", ">=", "in", "instanceof"];
         return logicalOperators.includes(node.operator);
       }
-      if (node.type === AST_NODE_TYPES34.UnaryExpression) {
+      if (node.type === AST_NODE_TYPES42.UnaryExpression) {
         return node.operator === "!";
       }
       return false;
@@ -2608,7 +3236,7 @@ var noLogicInParams = createRule34({
             messageId: "noLogicInParams"
           });
         }
-        if (arg.type === AST_NODE_TYPES34.ArrayExpression) {
+        if (arg.type === AST_NODE_TYPES42.ArrayExpression) {
           arg.elements.forEach((element) => {
             if (element && isComplexExpression(element)) {
               context.report({
@@ -2633,46 +3261,46 @@ var noLogicInParams = createRule34({
 var no_logic_in_params_default = noLogicInParams;
 
 // src/rules/no-misleading-constant-case.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES35, ESLintUtils as ESLintUtils35 } from "@typescript-eslint/utils";
-var createRule35 = ESLintUtils35.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES43, ESLintUtils as ESLintUtils43 } from "@typescript-eslint/utils";
+var createRule43 = ESLintUtils43.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 === AST_NODE_TYPES35.TSAsExpression && node.typeAnnotation.type === AST_NODE_TYPES35.TSTypeReference && node.typeAnnotation.typeName.type === AST_NODE_TYPES35.Identifier && node.typeAnnotation.typeName.name === "const";
+var isAsConstAssertion = (node) => node.type === AST_NODE_TYPES43.TSAsExpression && node.typeAnnotation.type === AST_NODE_TYPES43.TSTypeReference && node.typeAnnotation.typeName.type === AST_NODE_TYPES43.Identifier && node.typeAnnotation.typeName.name === "const";
 var isStaticValue2 = (init) => {
   if (isAsConstAssertion(init)) {
     return true;
   }
-  if (init.type === AST_NODE_TYPES35.Literal) {
+  if (init.type === AST_NODE_TYPES43.Literal) {
     return true;
   }
-  if (init.type === AST_NODE_TYPES35.UnaryExpression && init.argument.type === AST_NODE_TYPES35.Literal) {
+  if (init.type === AST_NODE_TYPES43.UnaryExpression && init.argument.type === AST_NODE_TYPES43.Literal) {
     return true;
   }
-  if (init.type === AST_NODE_TYPES35.TemplateLiteral && init.expressions.length === 0) {
+  if (init.type === AST_NODE_TYPES43.TemplateLiteral && init.expressions.length === 0) {
     return true;
   }
-  if (init.type === AST_NODE_TYPES35.ArrayExpression) {
-    return init.elements.every((el) => el !== null && el.type !== AST_NODE_TYPES35.SpreadElement && isStaticValue2(el));
+  if (init.type === AST_NODE_TYPES43.ArrayExpression) {
+    return init.elements.every((el) => el !== null && el.type !== AST_NODE_TYPES43.SpreadElement && isStaticValue2(el));
   }
-  if (init.type === AST_NODE_TYPES35.ObjectExpression) {
+  if (init.type === AST_NODE_TYPES43.ObjectExpression) {
     return init.properties.every(
-      (prop) => prop.type === AST_NODE_TYPES35.Property && isStaticValue2(prop.value)
+      (prop) => prop.type === AST_NODE_TYPES43.Property && isStaticValue2(prop.value)
     );
   }
   return false;
 };
 var isGlobalScope3 = (node) => {
   const { parent } = node;
-  if (parent.type === AST_NODE_TYPES35.Program) {
+  if (parent.type === AST_NODE_TYPES43.Program) {
     return true;
   }
-  if (parent.type === AST_NODE_TYPES35.ExportNamedDeclaration && parent.parent?.type === AST_NODE_TYPES35.Program) {
+  if (parent.type === AST_NODE_TYPES43.ExportNamedDeclaration && parent.parent?.type === AST_NODE_TYPES43.Program) {
     return true;
   }
   return false;
 };
-var noMisleadingConstantCase = createRule35({
+var noMisleadingConstantCase = createRule43({
   name: "no-misleading-constant-case",
   meta: {
     type: "suggestion",
@@ -2691,7 +3319,7 @@ var noMisleadingConstantCase = createRule35({
     return {
       VariableDeclaration(node) {
         node.declarations.forEach((declarator) => {
-          if (declarator.id.type !== AST_NODE_TYPES35.Identifier) {
+          if (declarator.id.type !== AST_NODE_TYPES43.Identifier) {
             return;
           }
           const { name } = declarator.id;
@@ -2732,11 +3360,11 @@ var noMisleadingConstantCase = createRule35({
 var no_misleading_constant_case_default = noMisleadingConstantCase;
 
 // src/rules/no-nested-interface-declaration.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES36, ESLintUtils as ESLintUtils36 } from "@typescript-eslint/utils";
-var createRule36 = ESLintUtils36.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES44, ESLintUtils as ESLintUtils44 } from "@typescript-eslint/utils";
+var createRule44 = ESLintUtils44.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var noNestedInterfaceDeclaration = createRule36({
+var noNestedInterfaceDeclaration = createRule44({
   name: "no-nested-interface-declaration",
   meta: {
     type: "suggestion",
@@ -2757,15 +3385,15 @@ var noNestedInterfaceDeclaration = createRule36({
           return;
         }
         const { typeAnnotation } = node.typeAnnotation;
-        if (typeAnnotation.type === AST_NODE_TYPES36.TSTypeLiteral) {
+        if (typeAnnotation.type === AST_NODE_TYPES44.TSTypeLiteral) {
           context.report({
             node: typeAnnotation,
             messageId: "noNestedInterface"
           });
           return;
         }
-        if (typeAnnotation.type === AST_NODE_TYPES36.TSArrayType) {
-          if (typeAnnotation.elementType.type === AST_NODE_TYPES36.TSTypeLiteral) {
+        if (typeAnnotation.type === AST_NODE_TYPES44.TSArrayType) {
+          if (typeAnnotation.elementType.type === AST_NODE_TYPES44.TSTypeLiteral) {
             context.report({
               node: typeAnnotation.elementType,
               messageId: "noNestedInterface"
@@ -2773,9 +3401,9 @@ var noNestedInterfaceDeclaration = createRule36({
           }
           return;
         }
-        if (typeAnnotation.type === AST_NODE_TYPES36.TSTypeReference && typeAnnotation.typeArguments) {
+        if (typeAnnotation.type === AST_NODE_TYPES44.TSTypeReference && typeAnnotation.typeArguments) {
           typeAnnotation.typeArguments.params.forEach((param) => {
-            if (param.type === AST_NODE_TYPES36.TSTypeLiteral) {
+            if (param.type === AST_NODE_TYPES44.TSTypeLiteral) {
               context.report({
                 node: param,
                 messageId: "noNestedInterface"
@@ -2790,11 +3418,11 @@ var noNestedInterfaceDeclaration = createRule36({
 var no_nested_interface_declaration_default = noNestedInterfaceDeclaration;
 
 // src/rules/no-nested-ternary.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES37, ESLintUtils as ESLintUtils37 } from "@typescript-eslint/utils";
-var createRule37 = ESLintUtils37.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES45, ESLintUtils as ESLintUtils45 } from "@typescript-eslint/utils";
+var createRule45 = ESLintUtils45.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var noNestedTernary = createRule37({
+var noNestedTernary = createRule45({
   name: "no-nested-ternary",
   meta: {
     type: "suggestion",
@@ -2811,13 +3439,13 @@ var noNestedTernary = createRule37({
     return {
       ConditionalExpression(node) {
         const { consequent, alternate } = node;
-        if (consequent.type === AST_NODE_TYPES37.ConditionalExpression) {
+        if (consequent.type === AST_NODE_TYPES45.ConditionalExpression) {
           context.report({
             node: consequent,
             messageId: "noNestedTernary"
           });
         }
-        if (alternate.type === AST_NODE_TYPES37.ConditionalExpression) {
+        if (alternate.type === AST_NODE_TYPES45.ConditionalExpression) {
           context.report({
             node: alternate,
             messageId: "noNestedTernary"
@@ -2830,33 +3458,33 @@ var noNestedTernary = createRule37({
 var no_nested_ternary_default = noNestedTernary;
 
 // src/rules/no-redundant-fragment.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES38, ESLintUtils as ESLintUtils38 } from "@typescript-eslint/utils";
-var createRule38 = ESLintUtils38.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES46, ESLintUtils as ESLintUtils46 } from "@typescript-eslint/utils";
+var createRule46 = ESLintUtils46.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 function isFragmentName(name) {
-  if (name.type === AST_NODE_TYPES38.JSXIdentifier && name.name === "Fragment") {
+  if (name.type === AST_NODE_TYPES46.JSXIdentifier && name.name === "Fragment") {
     return true;
   }
-  if (name.type === AST_NODE_TYPES38.JSXMemberExpression && name.object.type === AST_NODE_TYPES38.JSXIdentifier && name.object.name === "React" && name.property.type === AST_NODE_TYPES38.JSXIdentifier && name.property.name === "Fragment") {
+  if (name.type === AST_NODE_TYPES46.JSXMemberExpression && name.object.type === AST_NODE_TYPES46.JSXIdentifier && name.object.name === "React" && name.property.type === AST_NODE_TYPES46.JSXIdentifier && name.property.name === "Fragment") {
     return true;
   }
   return false;
 }
 function hasKeyAttribute(attributes) {
   return attributes.some(
-    (attribute) => attribute.type === AST_NODE_TYPES38.JSXAttribute && attribute.name.type === AST_NODE_TYPES38.JSXIdentifier && attribute.name.name === "key"
+    (attribute) => attribute.type === AST_NODE_TYPES46.JSXAttribute && attribute.name.type === AST_NODE_TYPES46.JSXIdentifier && attribute.name.name === "key"
   );
 }
 function countMeaningfulChildren(children) {
   return children.filter((child) => {
-    if (child.type === AST_NODE_TYPES38.JSXText) {
+    if (child.type === AST_NODE_TYPES46.JSXText) {
       return child.value.trim() !== "";
     }
     return true;
   }).length;
 }
-var noRedundantFragment = createRule38({
+var noRedundantFragment = createRule46({
   name: "no-redundant-fragment",
   meta: {
     type: "problem",
@@ -2904,11 +3532,11 @@ var noRedundantFragment = createRule38({
 var no_redundant_fragment_default = noRedundantFragment;
 
 // src/rules/no-relative-imports.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES39, ESLintUtils as ESLintUtils39 } from "@typescript-eslint/utils";
-var createRule39 = ESLintUtils39.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES47, ESLintUtils as ESLintUtils47 } from "@typescript-eslint/utils";
+var createRule47 = ESLintUtils47.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var noRelativeImports = createRule39({
+var noRelativeImports = createRule47({
   name: "no-relative-imports",
   meta: {
     type: "suggestion",
@@ -2932,22 +3560,22 @@ var noRelativeImports = createRule39({
     };
     return {
       ImportDeclaration(node) {
-        if (node.source.type === AST_NODE_TYPES39.Literal && typeof node.source.value === "string") {
+        if (node.source.type === AST_NODE_TYPES47.Literal && typeof node.source.value === "string") {
           checkImportPath(node.source.value, node);
         }
       },
       ImportExpression(node) {
-        if (node.source.type === AST_NODE_TYPES39.Literal && typeof node.source.value === "string") {
+        if (node.source.type === AST_NODE_TYPES47.Literal && typeof node.source.value === "string") {
           checkImportPath(node.source.value, node);
         }
       },
       ExportNamedDeclaration(node) {
-        if (node.source?.type === AST_NODE_TYPES39.Literal && typeof node.source.value === "string") {
+        if (node.source?.type === AST_NODE_TYPES47.Literal && typeof node.source.value === "string") {
           checkImportPath(node.source.value, node);
         }
       },
       ExportAllDeclaration(node) {
-        if (node.source.type === AST_NODE_TYPES39.Literal && typeof node.source.value === "string") {
+        if (node.source.type === AST_NODE_TYPES47.Literal && typeof node.source.value === "string") {
           checkImportPath(node.source.value, node);
         }
       }
@@ -2957,8 +3585,8 @@ var noRelativeImports = createRule39({
 var no_relative_imports_default = noRelativeImports;
 
 // src/rules/no-single-char-variables.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES40, ESLintUtils as ESLintUtils40 } from "@typescript-eslint/utils";
-var createRule40 = ESLintUtils40.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES48, ESLintUtils as ESLintUtils48 } from "@typescript-eslint/utils";
+var createRule48 = ESLintUtils48.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"]);
@@ -2970,7 +3598,7 @@ var isForLoopInit = (node) => {
     if (!parentNode) {
       return false;
     }
-    if (parentNode.type === AST_NODE_TYPES40.ForStatement) {
+    if (parentNode.type === AST_NODE_TYPES48.ForStatement) {
       const { init } = parentNode;
       if (init && init === current) {
         return true;
@@ -2989,7 +3617,7 @@ var isAllowedInContext = (name, node) => {
   }
   return false;
 };
-var noSingleCharVariables = createRule40({
+var noSingleCharVariables = createRule48({
   name: "no-single-char-variables",
   meta: {
     type: "suggestion",
@@ -3018,27 +3646,27 @@ var noSingleCharVariables = createRule40({
       });
     };
     const checkPattern = (pattern, declarationNode) => {
-      if (pattern.type === AST_NODE_TYPES40.Identifier) {
+      if (pattern.type === AST_NODE_TYPES48.Identifier) {
         checkIdentifier(pattern, declarationNode);
-      } else if (pattern.type === AST_NODE_TYPES40.ObjectPattern) {
+      } else if (pattern.type === AST_NODE_TYPES48.ObjectPattern) {
         pattern.properties.forEach((prop) => {
-          if (prop.type === AST_NODE_TYPES40.Property && prop.value.type === AST_NODE_TYPES40.Identifier) {
+          if (prop.type === AST_NODE_TYPES48.Property && prop.value.type === AST_NODE_TYPES48.Identifier) {
             checkIdentifier(prop.value, declarationNode);
-          } else if (prop.type === AST_NODE_TYPES40.RestElement && prop.argument.type === AST_NODE_TYPES40.Identifier) {
+          } else if (prop.type === AST_NODE_TYPES48.RestElement && prop.argument.type === AST_NODE_TYPES48.Identifier) {
             checkIdentifier(prop.argument, declarationNode);
           }
         });
-      } else if (pattern.type === AST_NODE_TYPES40.ArrayPattern) {
+      } else if (pattern.type === AST_NODE_TYPES48.ArrayPattern) {
         pattern.elements.forEach((element) => {
-          if (element?.type === AST_NODE_TYPES40.Identifier) {
+          if (element?.type === AST_NODE_TYPES48.Identifier) {
             checkIdentifier(element, declarationNode);
-          } else if (element?.type === AST_NODE_TYPES40.RestElement && element.argument.type === AST_NODE_TYPES40.Identifier) {
+          } else if (element?.type === AST_NODE_TYPES48.RestElement && element.argument.type === AST_NODE_TYPES48.Identifier) {
             checkIdentifier(element.argument, declarationNode);
           }
         });
-      } else if (pattern.type === AST_NODE_TYPES40.AssignmentPattern && pattern.left.type === AST_NODE_TYPES40.Identifier) {
+      } else if (pattern.type === AST_NODE_TYPES48.AssignmentPattern && pattern.left.type === AST_NODE_TYPES48.Identifier) {
         checkIdentifier(pattern.left, declarationNode);
-      } else if (pattern.type === AST_NODE_TYPES40.RestElement && pattern.argument.type === AST_NODE_TYPES40.Identifier) {
+      } else if (pattern.type === AST_NODE_TYPES48.RestElement && pattern.argument.type === AST_NODE_TYPES48.Identifier) {
         checkIdentifier(pattern.argument, declarationNode);
       }
     };
@@ -3072,11 +3700,11 @@ var noSingleCharVariables = createRule40({
 var no_single_char_variables_default = noSingleCharVariables;
 
 // src/rules/prefer-async-await.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES41, ESLintUtils as ESLintUtils41 } from "@typescript-eslint/utils";
-var createRule41 = ESLintUtils41.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES49, ESLintUtils as ESLintUtils49 } from "@typescript-eslint/utils";
+var createRule49 = ESLintUtils49.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var preferAsyncAwait = createRule41({
+var preferAsyncAwait = createRule49({
   name: "prefer-async-await",
   meta: {
     type: "suggestion",
@@ -3092,7 +3720,7 @@ var preferAsyncAwait = createRule41({
   create(context) {
     return {
       CallExpression(node) {
-        if (node.callee.type === AST_NODE_TYPES41.MemberExpression && node.callee.property.type === AST_NODE_TYPES41.Identifier && node.callee.property.name === "then") {
+        if (node.callee.type === AST_NODE_TYPES49.MemberExpression && node.callee.property.type === AST_NODE_TYPES49.Identifier && node.callee.property.name === "then") {
           context.report({
             node: node.callee.property,
             messageId: "preferAsyncAwait"
@@ -3105,11 +3733,11 @@ var preferAsyncAwait = createRule41({
 var prefer_async_await_default = preferAsyncAwait;
 
 // src/rules/prefer-destructuring-params.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES42, ESLintUtils as ESLintUtils42 } from "@typescript-eslint/utils";
-var createRule42 = ESLintUtils42.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES50, ESLintUtils as ESLintUtils50 } from "@typescript-eslint/utils";
+var createRule50 = ESLintUtils50.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var preferDestructuringParams = createRule42({
+var preferDestructuringParams = createRule50({
   name: "prefer-destructuring-params",
   meta: {
     type: "suggestion",
@@ -3125,18 +3753,18 @@ var preferDestructuringParams = createRule42({
   create(context) {
     const isCallbackFunction2 = (node) => {
       const { parent } = node;
-      return parent?.type === AST_NODE_TYPES42.CallExpression;
+      return parent?.type === AST_NODE_TYPES50.CallExpression;
     };
     const isDeveloperFunction = (node) => {
-      if (node.type === AST_NODE_TYPES42.FunctionDeclaration) {
+      if (node.type === AST_NODE_TYPES50.FunctionDeclaration) {
         return true;
       }
-      if (node.type === AST_NODE_TYPES42.FunctionExpression || node.type === AST_NODE_TYPES42.ArrowFunctionExpression) {
+      if (node.type === AST_NODE_TYPES50.FunctionExpression || node.type === AST_NODE_TYPES50.ArrowFunctionExpression) {
         if (isCallbackFunction2(node)) {
           return false;
         }
         const { parent } = node;
-        return parent?.type === AST_NODE_TYPES42.VariableDeclarator || parent?.type === AST_NODE_TYPES42.AssignmentExpression || parent?.type === AST_NODE_TYPES42.Property || parent?.type === AST_NODE_TYPES42.MethodDefinition;
+        return parent?.type === AST_NODE_TYPES50.VariableDeclarator || parent?.type === AST_NODE_TYPES50.AssignmentExpression || parent?.type === AST_NODE_TYPES50.Property || parent?.type === AST_NODE_TYPES50.MethodDefinition;
       }
       return false;
     };
@@ -3148,7 +3776,7 @@ var preferDestructuringParams = createRule42({
       if (!isDeveloperFunction(node)) {
         return;
       }
-      if (node.type === AST_NODE_TYPES42.FunctionDeclaration && node.id) {
+      if (node.type === AST_NODE_TYPES50.FunctionDeclaration && node.id) {
         const functionName = node.id.name;
         if (functionName.startsWith("_") || functionName.includes("$") || /^[A-Z][a-zA-Z]*$/.test(functionName)) {
           return;
@@ -3158,7 +3786,7 @@ var preferDestructuringParams = createRule42({
         return;
       }
       const hasNonDestructuredParams = node.params.some(
-        (param) => param.type !== AST_NODE_TYPES42.ObjectPattern && param.type !== AST_NODE_TYPES42.RestElement
+        (param) => param.type !== AST_NODE_TYPES50.ObjectPattern && param.type !== AST_NODE_TYPES50.RestElement
       );
       if (hasNonDestructuredParams) {
         context.report({
@@ -3177,8 +3805,8 @@ var preferDestructuringParams = createRule42({
 var prefer_destructuring_params_default = preferDestructuringParams;
 
 // src/rules/prefer-function-declaration.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES43, ESLintUtils as ESLintUtils43 } from "@typescript-eslint/utils";
-var createRule43 = ESLintUtils43.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES51, ESLintUtils as ESLintUtils51 } from "@typescript-eslint/utils";
+var createRule51 = ESLintUtils51.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");
@@ -3187,33 +3815,33 @@ var isCallbackContext = (node) => {
   if (!parent) {
     return false;
   }
-  if (parent.type === AST_NODE_TYPES43.CallExpression && parent.arguments.includes(node)) {
+  if (parent.type === AST_NODE_TYPES51.CallExpression && parent.arguments.includes(node)) {
     return true;
   }
-  if (parent.type === AST_NODE_TYPES43.NewExpression && parent.arguments.includes(node)) {
+  if (parent.type === AST_NODE_TYPES51.NewExpression && parent.arguments.includes(node)) {
     return true;
   }
-  if (parent.type === AST_NODE_TYPES43.ReturnStatement) {
+  if (parent.type === AST_NODE_TYPES51.ReturnStatement) {
     return true;
   }
-  if (parent.type === AST_NODE_TYPES43.Property) {
+  if (parent.type === AST_NODE_TYPES51.Property) {
     return true;
   }
-  if (parent.type === AST_NODE_TYPES43.ArrayExpression) {
+  if (parent.type === AST_NODE_TYPES51.ArrayExpression) {
     return true;
   }
-  if (parent.type === AST_NODE_TYPES43.ConditionalExpression) {
+  if (parent.type === AST_NODE_TYPES51.ConditionalExpression) {
     return true;
   }
-  if (parent.type === AST_NODE_TYPES43.LogicalExpression) {
+  if (parent.type === AST_NODE_TYPES51.LogicalExpression) {
     return true;
   }
-  if (parent.type === AST_NODE_TYPES43.AssignmentExpression && parent.left !== node) {
+  if (parent.type === AST_NODE_TYPES51.AssignmentExpression && parent.left !== node) {
     return true;
   }
   return false;
 };
-var preferFunctionDeclaration = createRule43({
+var preferFunctionDeclaration = createRule51({
   name: "prefer-function-declaration",
   meta: {
     type: "suggestion",
@@ -3234,14 +3862,14 @@ var preferFunctionDeclaration = createRule43({
     }
     return {
       VariableDeclarator(node) {
-        if (node.id.type !== AST_NODE_TYPES43.Identifier) {
+        if (node.id.type !== AST_NODE_TYPES51.Identifier) {
           return;
         }
         const { init } = node;
         if (!init) {
           return;
         }
-        if (init.type === AST_NODE_TYPES43.ArrowFunctionExpression) {
+        if (init.type === AST_NODE_TYPES51.ArrowFunctionExpression) {
           if (isCallbackContext(init)) {
             return;
           }
@@ -3251,7 +3879,7 @@ var preferFunctionDeclaration = createRule43({
             data: { name: node.id.name }
           });
         }
-        if (init.type === AST_NODE_TYPES43.FunctionExpression) {
+        if (init.type === AST_NODE_TYPES51.FunctionExpression) {
           if (isCallbackContext(init)) {
             return;
           }
@@ -3268,11 +3896,11 @@ var preferFunctionDeclaration = createRule43({
 var prefer_function_declaration_default = preferFunctionDeclaration;
 
 // src/rules/prefer-guard-clause.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES44, ESLintUtils as ESLintUtils44 } from "@typescript-eslint/utils";
-var createRule44 = ESLintUtils44.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES52, ESLintUtils as ESLintUtils52 } from "@typescript-eslint/utils";
+var createRule52 = ESLintUtils52.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var preferGuardClause = createRule44({
+var preferGuardClause = createRule52({
   name: "prefer-guard-clause",
   meta: {
     type: "suggestion",
@@ -3289,8 +3917,8 @@ var preferGuardClause = createRule44({
     return {
       IfStatement(node) {
         const { consequent } = node;
-        if (consequent.type === AST_NODE_TYPES44.BlockStatement) {
-          const hasNestedIf = consequent.body.some((statement) => statement.type === AST_NODE_TYPES44.IfStatement);
+        if (consequent.type === AST_NODE_TYPES52.BlockStatement) {
+          const hasNestedIf = consequent.body.some((statement) => statement.type === AST_NODE_TYPES52.IfStatement);
           if (hasNestedIf && consequent.body.length === 1) {
             context.report({
               node,
@@ -3298,7 +3926,7 @@ var preferGuardClause = createRule44({
             });
           }
         }
-        if (consequent.type === AST_NODE_TYPES44.IfStatement) {
+        if (consequent.type === AST_NODE_TYPES52.IfStatement) {
           context.report({
             node,
             messageId: "preferGuardClause"
@@ -3311,11 +3939,11 @@ var preferGuardClause = createRule44({
 var prefer_guard_clause_default = preferGuardClause;
 
 // src/rules/prefer-import-type.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES45, ESLintUtils as ESLintUtils45 } from "@typescript-eslint/utils";
-var createRule45 = ESLintUtils45.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES53, ESLintUtils as ESLintUtils53 } from "@typescript-eslint/utils";
+var createRule53 = ESLintUtils53.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var preferImportType = createRule45({
+var preferImportType = createRule53({
   name: "prefer-import-type",
   meta: {
     type: "suggestion",
@@ -3334,22 +3962,22 @@ var preferImportType = createRule45({
       let current = node;
       while (current) {
         switch (current.type) {
-          case AST_NODE_TYPES45.TSTypeReference:
-          case AST_NODE_TYPES45.TSTypeAnnotation:
-          case AST_NODE_TYPES45.TSTypeParameterInstantiation:
-          case AST_NODE_TYPES45.TSInterfaceHeritage:
-          case AST_NODE_TYPES45.TSClassImplements:
-          case AST_NODE_TYPES45.TSTypeQuery:
-          case AST_NODE_TYPES45.TSTypeAssertion:
-          case AST_NODE_TYPES45.TSAsExpression:
-          case AST_NODE_TYPES45.TSSatisfiesExpression:
-          case AST_NODE_TYPES45.TSTypeAliasDeclaration:
-          case AST_NODE_TYPES45.TSInterfaceDeclaration:
-          case AST_NODE_TYPES45.TSTypeParameter:
-          case AST_NODE_TYPES45.TSQualifiedName:
+          case AST_NODE_TYPES53.TSTypeReference:
+          case AST_NODE_TYPES53.TSTypeAnnotation:
+          case AST_NODE_TYPES53.TSTypeParameterInstantiation:
+          case AST_NODE_TYPES53.TSInterfaceHeritage:
+          case AST_NODE_TYPES53.TSClassImplements:
+          case AST_NODE_TYPES53.TSTypeQuery:
+          case AST_NODE_TYPES53.TSTypeAssertion:
+          case AST_NODE_TYPES53.TSAsExpression:
+          case AST_NODE_TYPES53.TSSatisfiesExpression:
+          case AST_NODE_TYPES53.TSTypeAliasDeclaration:
+          case AST_NODE_TYPES53.TSInterfaceDeclaration:
+          case AST_NODE_TYPES53.TSTypeParameter:
+          case AST_NODE_TYPES53.TSQualifiedName:
             return true;
-          case AST_NODE_TYPES45.MemberExpression:
-          case AST_NODE_TYPES45.Identifier:
+          case AST_NODE_TYPES53.MemberExpression:
+          case AST_NODE_TYPES53.Identifier:
             current = current.parent;
             break;
           default:
@@ -3379,27 +4007,27 @@ var preferImportType = createRule45({
           return false;
         }
         switch (parent.type) {
-          case AST_NODE_TYPES45.CallExpression:
-          case AST_NODE_TYPES45.NewExpression:
-          case AST_NODE_TYPES45.JSXOpeningElement:
-          case AST_NODE_TYPES45.JSXClosingElement:
-          case AST_NODE_TYPES45.MemberExpression:
-          case AST_NODE_TYPES45.VariableDeclarator:
-          case AST_NODE_TYPES45.TaggedTemplateExpression:
-          case AST_NODE_TYPES45.SpreadElement:
-          case AST_NODE_TYPES45.ExportSpecifier:
-          case AST_NODE_TYPES45.ArrayExpression:
-          case AST_NODE_TYPES45.ObjectExpression:
-          case AST_NODE_TYPES45.BinaryExpression:
-          case AST_NODE_TYPES45.LogicalExpression:
-          case AST_NODE_TYPES45.UnaryExpression:
-          case AST_NODE_TYPES45.ReturnStatement:
-          case AST_NODE_TYPES45.ArrowFunctionExpression:
-          case AST_NODE_TYPES45.ConditionalExpression:
-          case AST_NODE_TYPES45.AwaitExpression:
-          case AST_NODE_TYPES45.YieldExpression:
-          case AST_NODE_TYPES45.Property:
-          case AST_NODE_TYPES45.JSXExpressionContainer:
+          case AST_NODE_TYPES53.CallExpression:
+          case AST_NODE_TYPES53.NewExpression:
+          case AST_NODE_TYPES53.JSXOpeningElement:
+          case AST_NODE_TYPES53.JSXClosingElement:
+          case AST_NODE_TYPES53.MemberExpression:
+          case AST_NODE_TYPES53.VariableDeclarator:
+          case AST_NODE_TYPES53.TaggedTemplateExpression:
+          case AST_NODE_TYPES53.SpreadElement:
+          case AST_NODE_TYPES53.ExportSpecifier:
+          case AST_NODE_TYPES53.ArrayExpression:
+          case AST_NODE_TYPES53.ObjectExpression:
+          case AST_NODE_TYPES53.BinaryExpression:
+          case AST_NODE_TYPES53.LogicalExpression:
+          case AST_NODE_TYPES53.UnaryExpression:
+          case AST_NODE_TYPES53.ReturnStatement:
+          case AST_NODE_TYPES53.ArrowFunctionExpression:
+          case AST_NODE_TYPES53.ConditionalExpression:
+          case AST_NODE_TYPES53.AwaitExpression:
+          case AST_NODE_TYPES53.YieldExpression:
+          case AST_NODE_TYPES53.Property:
+          case AST_NODE_TYPES53.JSXExpressionContainer:
             return true;
           default:
             return false;
@@ -3411,7 +4039,7 @@ var preferImportType = createRule45({
         return;
       }
       const hasInlineTypeSpecifier = node.specifiers.some(
-        (specifier) => specifier.type === AST_NODE_TYPES45.ImportSpecifier && specifier.importKind === "type"
+        (specifier) => specifier.type === AST_NODE_TYPES53.ImportSpecifier && specifier.importKind === "type"
       );
       if (hasInlineTypeSpecifier) {
         return;
@@ -3429,13 +4057,13 @@ var preferImportType = createRule45({
       }
       const scope = context.sourceCode.getScope(node);
       const isTypeOnlyImport2 = node.specifiers.every((specifier) => {
-        if (specifier.type === AST_NODE_TYPES45.ImportDefaultSpecifier) {
+        if (specifier.type === AST_NODE_TYPES53.ImportDefaultSpecifier) {
           return false;
         }
-        if (specifier.type === AST_NODE_TYPES45.ImportNamespaceSpecifier) {
+        if (specifier.type === AST_NODE_TYPES53.ImportNamespaceSpecifier) {
           return false;
         }
-        if (specifier.type === AST_NODE_TYPES45.ImportSpecifier) {
+        if (specifier.type === AST_NODE_TYPES53.ImportSpecifier) {
           const localName = specifier.local.name;
           return !isUsedAsValue(localName, scope);
         }
@@ -3461,19 +4089,19 @@ var preferImportType = createRule45({
 var prefer_import_type_default = preferImportType;
 
 // src/rules/prefer-inline-literal-union.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES46, ESLintUtils as ESLintUtils46 } from "@typescript-eslint/utils";
-var createRule46 = ESLintUtils46.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES54, ESLintUtils as ESLintUtils54 } from "@typescript-eslint/utils";
+var createRule54 = ESLintUtils54.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 function isLiteralUnionType(node) {
-  if (node.type !== AST_NODE_TYPES46.TSUnionType) {
+  if (node.type !== AST_NODE_TYPES54.TSUnionType) {
     return false;
   }
   return node.types.every(
-    (member) => member.type === AST_NODE_TYPES46.TSLiteralType || member.type === AST_NODE_TYPES46.TSNullKeyword || member.type === AST_NODE_TYPES46.TSUndefinedKeyword
+    (member) => member.type === AST_NODE_TYPES54.TSLiteralType || member.type === AST_NODE_TYPES54.TSNullKeyword || member.type === AST_NODE_TYPES54.TSUndefinedKeyword
   );
 }
-var preferInlineLiteralUnion = createRule46({
+var preferInlineLiteralUnion = createRule54({
   name: "prefer-inline-literal-union",
   meta: {
     type: "suggestion",
@@ -3500,10 +4128,10 @@ var preferInlineLiteralUnion = createRule46({
           return;
         }
         const { typeAnnotation } = node.typeAnnotation;
-        if (typeAnnotation.type !== AST_NODE_TYPES46.TSTypeReference) {
+        if (typeAnnotation.type !== AST_NODE_TYPES54.TSTypeReference) {
           return;
         }
-        if (typeAnnotation.typeName.type !== AST_NODE_TYPES46.Identifier) {
+        if (typeAnnotation.typeName.type !== AST_NODE_TYPES54.Identifier) {
           return;
         }
         const aliasName = typeAnnotation.typeName.name;
@@ -3527,12 +4155,12 @@ var preferInlineLiteralUnion = createRule46({
 var prefer_inline_literal_union_default = preferInlineLiteralUnion;
 
 // src/rules/prefer-inline-type-export.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES47, ESLintUtils as ESLintUtils47 } from "@typescript-eslint/utils";
-var createRule47 = ESLintUtils47.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES55, ESLintUtils as ESLintUtils55 } from "@typescript-eslint/utils";
+var createRule55 = ESLintUtils55.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var isTypeDeclaration = (node) => node.type === AST_NODE_TYPES47.TSInterfaceDeclaration || node.type === AST_NODE_TYPES47.TSTypeAliasDeclaration;
-var preferInlineTypeExport = createRule47({
+var isTypeDeclaration = (node) => node.type === AST_NODE_TYPES55.TSInterfaceDeclaration || node.type === AST_NODE_TYPES55.TSTypeAliasDeclaration;
+var preferInlineTypeExport = createRule55({
   name: "prefer-inline-type-export",
   meta: {
     type: "suggestion",
@@ -3549,12 +4177,12 @@ var preferInlineTypeExport = createRule47({
   create(context) {
     const typeDeclarations = /* @__PURE__ */ new Map();
     function collectDeclaration(node) {
-      if (node.parent.type !== AST_NODE_TYPES47.ExportNamedDeclaration) {
+      if (node.parent.type !== AST_NODE_TYPES55.ExportNamedDeclaration) {
         typeDeclarations.set(node.id.name, node);
       }
     }
     function reportSpecifier(specifier, statement, declarationNode) {
-      if (specifier.local.type !== AST_NODE_TYPES47.Identifier) {
+      if (specifier.local.type !== AST_NODE_TYPES55.Identifier) {
         return;
       }
       const { name } = specifier.local;
@@ -3587,16 +4215,16 @@ var preferInlineTypeExport = createRule47({
     return {
       Program(node) {
         node.body.forEach((statement) => {
-          if (statement.type === AST_NODE_TYPES47.TSInterfaceDeclaration || statement.type === AST_NODE_TYPES47.TSTypeAliasDeclaration) {
+          if (statement.type === AST_NODE_TYPES55.TSInterfaceDeclaration || statement.type === AST_NODE_TYPES55.TSTypeAliasDeclaration) {
             collectDeclaration(statement);
           }
         });
         node.body.forEach((statement) => {
-          if (statement.type !== AST_NODE_TYPES47.ExportNamedDeclaration || statement.declaration !== null) {
+          if (statement.type !== AST_NODE_TYPES55.ExportNamedDeclaration || statement.declaration !== null) {
             return;
           }
           statement.specifiers.forEach((specifier) => {
-            if (specifier.local.type !== AST_NODE_TYPES47.Identifier) {
+            if (specifier.local.type !== AST_NODE_TYPES55.Identifier) {
               return;
             }
             const declarationNode = typeDeclarations.get(specifier.local.name);
@@ -3613,11 +4241,11 @@ var preferInlineTypeExport = createRule47({
 var prefer_inline_type_export_default = preferInlineTypeExport;
 
 // src/rules/prefer-interface-for-component-props.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES48, ESLintUtils as ESLintUtils48 } from "@typescript-eslint/utils";
-var createRule48 = ESLintUtils48.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES56, ESLintUtils as ESLintUtils56 } from "@typescript-eslint/utils";
+var createRule56 = ESLintUtils56.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var preferInterfaceForComponentProps = createRule48({
+var preferInterfaceForComponentProps = createRule56({
   name: "prefer-interface-for-component-props",
   meta: {
     type: "suggestion",
@@ -3637,13 +4265,13 @@ var preferInterfaceForComponentProps = createRule48({
     }
     return {
       TSTypeAliasDeclaration(node) {
-        if (node.id.type !== AST_NODE_TYPES48.Identifier) {
+        if (node.id.type !== AST_NODE_TYPES56.Identifier) {
           return;
         }
         if (!node.id.name.endsWith("Props")) {
           return;
         }
-        if (node.typeAnnotation.type !== AST_NODE_TYPES48.TSTypeLiteral) {
+        if (node.typeAnnotation.type !== AST_NODE_TYPES56.TSTypeLiteral) {
           return;
         }
         const { name } = node.id;
@@ -3670,11 +4298,11 @@ var preferInterfaceForComponentProps = createRule48({
 var prefer_interface_for_component_props_default = preferInterfaceForComponentProps;
 
 // src/rules/prefer-interface-over-inline-types.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES49, ESLintUtils as ESLintUtils49 } from "@typescript-eslint/utils";
-var createRule49 = ESLintUtils49.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES57, ESLintUtils as ESLintUtils57 } from "@typescript-eslint/utils";
+var createRule57 = ESLintUtils57.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var preferInterfaceOverInlineTypes = createRule49({
+var preferInterfaceOverInlineTypes = createRule57({
   name: "prefer-interface-over-inline-types",
   meta: {
     type: "suggestion",
@@ -3690,54 +4318,54 @@ var preferInterfaceOverInlineTypes = createRule49({
   defaultOptions: [],
   create(context) {
     function hasJSXInConditional(node) {
-      return node.consequent.type === AST_NODE_TYPES49.JSXElement || node.consequent.type === AST_NODE_TYPES49.JSXFragment || node.alternate.type === AST_NODE_TYPES49.JSXElement || node.alternate.type === AST_NODE_TYPES49.JSXFragment;
+      return node.consequent.type === AST_NODE_TYPES57.JSXElement || node.consequent.type === AST_NODE_TYPES57.JSXFragment || node.alternate.type === AST_NODE_TYPES57.JSXElement || node.alternate.type === AST_NODE_TYPES57.JSXFragment;
     }
     function hasJSXInLogical(node) {
-      return node.right.type === AST_NODE_TYPES49.JSXElement || node.right.type === AST_NODE_TYPES49.JSXFragment;
+      return node.right.type === AST_NODE_TYPES57.JSXElement || node.right.type === AST_NODE_TYPES57.JSXFragment;
     }
     function hasJSXReturn(block) {
       return block.body.some((stmt) => {
-        if (stmt.type === AST_NODE_TYPES49.ReturnStatement && stmt.argument) {
-          return stmt.argument.type === AST_NODE_TYPES49.JSXElement || stmt.argument.type === AST_NODE_TYPES49.JSXFragment || stmt.argument.type === AST_NODE_TYPES49.ConditionalExpression && hasJSXInConditional(stmt.argument) || stmt.argument.type === AST_NODE_TYPES49.LogicalExpression && hasJSXInLogical(stmt.argument);
+        if (stmt.type === AST_NODE_TYPES57.ReturnStatement && stmt.argument) {
+          return stmt.argument.type === AST_NODE_TYPES57.JSXElement || stmt.argument.type === AST_NODE_TYPES57.JSXFragment || stmt.argument.type === AST_NODE_TYPES57.ConditionalExpression && hasJSXInConditional(stmt.argument) || stmt.argument.type === AST_NODE_TYPES57.LogicalExpression && hasJSXInLogical(stmt.argument);
         }
         return false;
       });
     }
     function isReactComponent2(node) {
-      if (node.type === AST_NODE_TYPES49.ArrowFunctionExpression) {
-        if (node.body.type === AST_NODE_TYPES49.JSXElement || node.body.type === AST_NODE_TYPES49.JSXFragment) {
+      if (node.type === AST_NODE_TYPES57.ArrowFunctionExpression) {
+        if (node.body.type === AST_NODE_TYPES57.JSXElement || node.body.type === AST_NODE_TYPES57.JSXFragment) {
           return true;
         }
-        if (node.body.type === AST_NODE_TYPES49.BlockStatement) {
+        if (node.body.type === AST_NODE_TYPES57.BlockStatement) {
           return hasJSXReturn(node.body);
         }
-      } else if (node.type === AST_NODE_TYPES49.FunctionExpression || node.type === AST_NODE_TYPES49.FunctionDeclaration) {
-        if (node.body && node.body.type === AST_NODE_TYPES49.BlockStatement) {
+      } else if (node.type === AST_NODE_TYPES57.FunctionExpression || node.type === AST_NODE_TYPES57.FunctionDeclaration) {
+        if (node.body && node.body.type === AST_NODE_TYPES57.BlockStatement) {
           return hasJSXReturn(node.body);
         }
       }
       return false;
     }
     function isInlineTypeAnnotation(node) {
-      if (node.type === AST_NODE_TYPES49.TSTypeLiteral) {
+      if (node.type === AST_NODE_TYPES57.TSTypeLiteral) {
         return true;
       }
-      if (node.type === AST_NODE_TYPES49.TSTypeReference && node.typeArguments) {
-        return node.typeArguments.params.some((param) => param.type === AST_NODE_TYPES49.TSTypeLiteral);
+      if (node.type === AST_NODE_TYPES57.TSTypeReference && node.typeArguments) {
+        return node.typeArguments.params.some((param) => param.type === AST_NODE_TYPES57.TSTypeLiteral);
       }
-      if (node.type === AST_NODE_TYPES49.TSUnionType) {
+      if (node.type === AST_NODE_TYPES57.TSUnionType) {
         return node.types.some((type) => isInlineTypeAnnotation(type));
       }
       return false;
     }
     function hasInlineObjectType(node) {
-      if (node.type === AST_NODE_TYPES49.TSTypeLiteral) {
+      if (node.type === AST_NODE_TYPES57.TSTypeLiteral) {
         return true;
       }
-      if (node.type === AST_NODE_TYPES49.TSTypeReference && node.typeArguments) {
-        return node.typeArguments.params.some((param) => param.type === AST_NODE_TYPES49.TSTypeLiteral);
+      if (node.type === AST_NODE_TYPES57.TSTypeReference && node.typeArguments) {
+        return node.typeArguments.params.some((param) => param.type === AST_NODE_TYPES57.TSTypeLiteral);
       }
-      if (node.type === AST_NODE_TYPES49.TSUnionType) {
+      if (node.type === AST_NODE_TYPES57.TSUnionType) {
         return node.types.some((type) => hasInlineObjectType(type));
       }
       return false;
@@ -3750,7 +4378,7 @@ var preferInterfaceOverInlineTypes = createRule49({
         return;
       }
       const param = node.params[0];
-      if (param.type === AST_NODE_TYPES49.Identifier && param.typeAnnotation) {
+      if (param.type === AST_NODE_TYPES57.Identifier && param.typeAnnotation) {
         const { typeAnnotation } = param.typeAnnotation;
         if (isInlineTypeAnnotation(typeAnnotation) && hasInlineObjectType(typeAnnotation)) {
           context.report({
@@ -3770,11 +4398,11 @@ var preferInterfaceOverInlineTypes = createRule49({
 var prefer_interface_over_inline_types_default = preferInterfaceOverInlineTypes;
 
 // src/rules/prefer-jsx-template-literals.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES50, ESLintUtils as ESLintUtils50 } from "@typescript-eslint/utils";
-var createRule50 = ESLintUtils50.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES58, ESLintUtils as ESLintUtils58 } from "@typescript-eslint/utils";
+var createRule58 = ESLintUtils58.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var preferJSXTemplateLiterals = createRule50({
+var preferJSXTemplateLiterals = createRule58({
   name: "prefer-jsx-template-literals",
   meta: {
     type: "suggestion",
@@ -3843,9 +4471,9 @@ var preferJSXTemplateLiterals = createRule50({
         if (!child || !nextChild) {
           return;
         }
-        if (child.type === AST_NODE_TYPES50.JSXText && nextChild.type === AST_NODE_TYPES50.JSXExpressionContainer) {
+        if (child.type === AST_NODE_TYPES58.JSXText && nextChild.type === AST_NODE_TYPES58.JSXExpressionContainer) {
           handleTextBeforeExpression(child, nextChild);
-        } else if (child.type === AST_NODE_TYPES50.JSXExpressionContainer && nextChild.type === AST_NODE_TYPES50.JSXText) {
+        } else if (child.type === AST_NODE_TYPES58.JSXExpressionContainer && nextChild.type === AST_NODE_TYPES58.JSXText) {
           handleExpressionBeforeText(child, nextChild);
         }
       }
@@ -3858,32 +4486,32 @@ var preferJSXTemplateLiterals = createRule50({
 var prefer_jsx_template_literals_default = preferJSXTemplateLiterals;
 
 // src/rules/prefer-named-param-types.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES51, ESLintUtils as ESLintUtils51 } from "@typescript-eslint/utils";
-var createRule51 = ESLintUtils51.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES59, ESLintUtils as ESLintUtils59 } from "@typescript-eslint/utils";
+var createRule59 = ESLintUtils59.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var returnsJsx2 = (node) => {
-  if (node.type === AST_NODE_TYPES51.JSXElement || node.type === AST_NODE_TYPES51.JSXFragment) {
+  if (node.type === AST_NODE_TYPES59.JSXElement || node.type === AST_NODE_TYPES59.JSXFragment) {
     return true;
   }
-  if (node.type === AST_NODE_TYPES51.ConditionalExpression) {
+  if (node.type === AST_NODE_TYPES59.ConditionalExpression) {
     return returnsJsx2(node.consequent) || returnsJsx2(node.alternate);
   }
-  if (node.type === AST_NODE_TYPES51.LogicalExpression) {
+  if (node.type === AST_NODE_TYPES59.LogicalExpression) {
     return returnsJsx2(node.left) || returnsJsx2(node.right);
   }
   return false;
 };
 var bodyReturnsJsx2 = (body) => {
-  if (body.type !== AST_NODE_TYPES51.BlockStatement) {
+  if (body.type !== AST_NODE_TYPES59.BlockStatement) {
     return returnsJsx2(body);
   }
   return body.body.some(
-    (stmt) => stmt.type === AST_NODE_TYPES51.ReturnStatement && stmt.argument !== null && returnsJsx2(stmt.argument)
+    (stmt) => stmt.type === AST_NODE_TYPES59.ReturnStatement && stmt.argument !== null && returnsJsx2(stmt.argument)
   );
 };
 var isReactComponentFunction = (node) => bodyReturnsJsx2(node.body);
-var preferNamedParamTypes = createRule51({
+var preferNamedParamTypes = createRule59({
   name: "prefer-named-param-types",
   meta: {
     type: "suggestion",
@@ -3898,16 +4526,16 @@ var preferNamedParamTypes = createRule51({
   defaultOptions: [],
   create(context) {
     function hasInlineObjectType(param) {
-      if (param.type === AST_NODE_TYPES51.AssignmentPattern) {
+      if (param.type === AST_NODE_TYPES59.AssignmentPattern) {
         return hasInlineObjectType(param.left);
       }
-      if (param.type === AST_NODE_TYPES51.ObjectPattern) {
-        if (param.typeAnnotation?.typeAnnotation.type === AST_NODE_TYPES51.TSTypeLiteral) {
+      if (param.type === AST_NODE_TYPES59.ObjectPattern) {
+        if (param.typeAnnotation?.typeAnnotation.type === AST_NODE_TYPES59.TSTypeLiteral) {
           return true;
         }
       }
-      if (param.type === AST_NODE_TYPES51.Identifier) {
-        if (param.typeAnnotation?.typeAnnotation.type === AST_NODE_TYPES51.TSTypeLiteral) {
+      if (param.type === AST_NODE_TYPES59.Identifier) {
+        if (param.typeAnnotation?.typeAnnotation.type === AST_NODE_TYPES59.TSTypeLiteral) {
           return true;
         }
       }
@@ -3920,7 +4548,7 @@ var preferNamedParamTypes = createRule51({
       } else if ("value" in node && node.value) {
         params = node.value.params;
       }
-      if ((node.type === AST_NODE_TYPES51.FunctionDeclaration || node.type === AST_NODE_TYPES51.FunctionExpression || node.type === AST_NODE_TYPES51.ArrowFunctionExpression) && params.length === 1 && params[0].type === AST_NODE_TYPES51.Identifier && isReactComponentFunction(node)) {
+      if ((node.type === AST_NODE_TYPES59.FunctionDeclaration || node.type === AST_NODE_TYPES59.FunctionExpression || node.type === AST_NODE_TYPES59.ArrowFunctionExpression) && params.length === 1 && params[0].type === AST_NODE_TYPES59.Identifier && isReactComponentFunction(node)) {
         return;
       }
       params.forEach((param) => {
@@ -3944,11 +4572,11 @@ var preferNamedParamTypes = createRule51({
 var prefer_named_param_types_default = preferNamedParamTypes;
 
 // src/rules/prefer-props-with-children.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES52, ESLintUtils as ESLintUtils52 } from "@typescript-eslint/utils";
-var createRule52 = ESLintUtils52.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES60, ESLintUtils as ESLintUtils60 } from "@typescript-eslint/utils";
+var createRule60 = ESLintUtils60.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var preferPropsWithChildren = createRule52({
+var preferPropsWithChildren = createRule60({
   name: "prefer-props-with-children",
   meta: {
     type: "suggestion",
@@ -3966,24 +4594,24 @@ var preferPropsWithChildren = createRule52({
       if (!typeNode) {
         return false;
       }
-      if (typeNode.type !== AST_NODE_TYPES52.TSTypeReference) {
+      if (typeNode.type !== AST_NODE_TYPES60.TSTypeReference) {
         return false;
       }
       const { typeName } = typeNode;
-      if (typeName.type === AST_NODE_TYPES52.Identifier) {
+      if (typeName.type === AST_NODE_TYPES60.Identifier) {
         return typeName.name === "ReactNode";
       }
-      if (typeName.type === AST_NODE_TYPES52.TSQualifiedName && typeName.left.type === AST_NODE_TYPES52.Identifier && typeName.left.name === "React" && typeName.right.type === AST_NODE_TYPES52.Identifier && typeName.right.name === "ReactNode") {
+      if (typeName.type === AST_NODE_TYPES60.TSQualifiedName && typeName.left.type === AST_NODE_TYPES60.Identifier && typeName.left.name === "React" && typeName.right.type === AST_NODE_TYPES60.Identifier && typeName.right.name === "ReactNode") {
         return true;
       }
       return false;
     }
     function findChildrenReactNode(members) {
       for (const member of members) {
-        if (member.type !== AST_NODE_TYPES52.TSPropertySignature) {
+        if (member.type !== AST_NODE_TYPES60.TSPropertySignature) {
           continue;
         }
-        if (member.key.type !== AST_NODE_TYPES52.Identifier) {
+        if (member.key.type !== AST_NODE_TYPES60.Identifier) {
           continue;
         }
         if (member.key.name !== "children") {
@@ -4023,11 +4651,11 @@ var preferPropsWithChildren = createRule52({
 var prefer_props_with_children_default = preferPropsWithChildren;
 
 // src/rules/prefer-react-import-types.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES53, ESLintUtils as ESLintUtils53 } from "@typescript-eslint/utils";
-var createRule53 = ESLintUtils53.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES61, ESLintUtils as ESLintUtils61 } from "@typescript-eslint/utils";
+var createRule61 = ESLintUtils61.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var preferReactImportTypes = createRule53({
+var preferReactImportTypes = createRule61({
   name: "prefer-react-import-types",
   meta: {
     type: "suggestion",
@@ -4103,7 +4731,7 @@ var preferReactImportTypes = createRule53({
     ]);
     const allReactExports = /* @__PURE__ */ new Set([...reactTypes, ...reactRuntimeExports]);
     function checkMemberExpression(node) {
-      if (node.object.type === AST_NODE_TYPES53.Identifier && node.object.name === "React" && node.property.type === AST_NODE_TYPES53.Identifier && allReactExports.has(node.property.name)) {
+      if (node.object.type === AST_NODE_TYPES61.Identifier && node.object.name === "React" && node.property.type === AST_NODE_TYPES61.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"`;
@@ -4120,7 +4748,7 @@ var preferReactImportTypes = createRule53({
     return {
       MemberExpression: checkMemberExpression,
       "TSTypeReference > TSQualifiedName": (node) => {
-        if (node.left.type === AST_NODE_TYPES53.Identifier && node.left.name === "React" && node.right.type === AST_NODE_TYPES53.Identifier && allReactExports.has(node.right.name)) {
+        if (node.left.type === AST_NODE_TYPES61.Identifier && node.left.name === "React" && node.right.type === AST_NODE_TYPES61.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"`;
@@ -4140,11 +4768,11 @@ var preferReactImportTypes = createRule53({
 var prefer_react_import_types_default = preferReactImportTypes;
 
 // src/rules/react-props-destructure.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES54, ESLintUtils as ESLintUtils54 } from "@typescript-eslint/utils";
-var createRule54 = ESLintUtils54.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES62, ESLintUtils as ESLintUtils62 } from "@typescript-eslint/utils";
+var createRule62 = ESLintUtils62.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var reactPropsDestructure = createRule54({
+var reactPropsDestructure = createRule62({
   name: "react-props-destructure",
   meta: {
     type: "suggestion",
@@ -4160,29 +4788,29 @@ var reactPropsDestructure = createRule54({
   defaultOptions: [],
   create(context) {
     function hasJSXInConditional(node) {
-      return node.consequent.type === AST_NODE_TYPES54.JSXElement || node.consequent.type === AST_NODE_TYPES54.JSXFragment || node.alternate.type === AST_NODE_TYPES54.JSXElement || node.alternate.type === AST_NODE_TYPES54.JSXFragment;
+      return node.consequent.type === AST_NODE_TYPES62.JSXElement || node.consequent.type === AST_NODE_TYPES62.JSXFragment || node.alternate.type === AST_NODE_TYPES62.JSXElement || node.alternate.type === AST_NODE_TYPES62.JSXFragment;
     }
     function hasJSXInLogical(node) {
-      return node.right.type === AST_NODE_TYPES54.JSXElement || node.right.type === AST_NODE_TYPES54.JSXFragment;
+      return node.right.type === AST_NODE_TYPES62.JSXElement || node.right.type === AST_NODE_TYPES62.JSXFragment;
     }
     function hasJSXReturn(block) {
       return block.body.some((stmt) => {
-        if (stmt.type === AST_NODE_TYPES54.ReturnStatement && stmt.argument) {
-          return stmt.argument.type === AST_NODE_TYPES54.JSXElement || stmt.argument.type === AST_NODE_TYPES54.JSXFragment || stmt.argument.type === AST_NODE_TYPES54.ConditionalExpression && hasJSXInConditional(stmt.argument) || stmt.argument.type === AST_NODE_TYPES54.LogicalExpression && hasJSXInLogical(stmt.argument);
+        if (stmt.type === AST_NODE_TYPES62.ReturnStatement && stmt.argument) {
+          return stmt.argument.type === AST_NODE_TYPES62.JSXElement || stmt.argument.type === AST_NODE_TYPES62.JSXFragment || stmt.argument.type === AST_NODE_TYPES62.ConditionalExpression && hasJSXInConditional(stmt.argument) || stmt.argument.type === AST_NODE_TYPES62.LogicalExpression && hasJSXInLogical(stmt.argument);
         }
         return false;
       });
     }
     function isReactComponent2(node) {
-      if (node.type === AST_NODE_TYPES54.ArrowFunctionExpression) {
-        if (node.body.type === AST_NODE_TYPES54.JSXElement || node.body.type === AST_NODE_TYPES54.JSXFragment) {
+      if (node.type === AST_NODE_TYPES62.ArrowFunctionExpression) {
+        if (node.body.type === AST_NODE_TYPES62.JSXElement || node.body.type === AST_NODE_TYPES62.JSXFragment) {
           return true;
         }
-        if (node.body.type === AST_NODE_TYPES54.BlockStatement) {
+        if (node.body.type === AST_NODE_TYPES62.BlockStatement) {
           return hasJSXReturn(node.body);
         }
-      } else if (node.type === AST_NODE_TYPES54.FunctionExpression || node.type === AST_NODE_TYPES54.FunctionDeclaration) {
-        if (node.body && node.body.type === AST_NODE_TYPES54.BlockStatement) {
+      } else if (node.type === AST_NODE_TYPES62.FunctionExpression || node.type === AST_NODE_TYPES62.FunctionDeclaration) {
+        if (node.body && node.body.type === AST_NODE_TYPES62.BlockStatement) {
           return hasJSXReturn(node.body);
         }
       }
@@ -4196,9 +4824,9 @@ var reactPropsDestructure = createRule54({
         return;
       }
       const param = node.params[0];
-      if (param.type === AST_NODE_TYPES54.ObjectPattern) {
-        const properties = param.properties.filter((prop) => prop.type === AST_NODE_TYPES54.Property).map((prop) => {
-          if (prop.key.type === AST_NODE_TYPES54.Identifier) {
+      if (param.type === AST_NODE_TYPES62.ObjectPattern) {
+        const properties = param.properties.filter((prop) => prop.type === AST_NODE_TYPES62.Property).map((prop) => {
+          if (prop.key.type === AST_NODE_TYPES62.Identifier) {
             return prop.key.name;
           }
           return null;
@@ -4225,57 +4853,57 @@ var reactPropsDestructure = createRule54({
 var react_props_destructure_default = reactPropsDestructure;
 
 // src/rules/require-explicit-return-type.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES55, ESLintUtils as ESLintUtils55 } from "@typescript-eslint/utils";
-var createRule55 = ESLintUtils55.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES63, ESLintUtils as ESLintUtils63 } from "@typescript-eslint/utils";
+var createRule63 = ESLintUtils63.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var isReactComponent = (node) => {
-  if (node.type === AST_NODE_TYPES55.ArrowFunctionExpression) {
+  if (node.type === AST_NODE_TYPES63.ArrowFunctionExpression) {
     const { parent } = node;
-    if (parent?.type === AST_NODE_TYPES55.VariableDeclarator) {
+    if (parent?.type === AST_NODE_TYPES63.VariableDeclarator) {
       const { id } = parent;
-      if (id.type === AST_NODE_TYPES55.Identifier) {
+      if (id.type === AST_NODE_TYPES63.Identifier) {
         return /^[A-Z]/.test(id.name);
       }
     }
   }
-  if (node.type === AST_NODE_TYPES55.FunctionDeclaration && node.id) {
+  if (node.type === AST_NODE_TYPES63.FunctionDeclaration && node.id) {
     return /^[A-Z]/.test(node.id.name);
   }
   return false;
 };
 var isCallbackFunction = (node) => {
-  if (node.type === AST_NODE_TYPES55.FunctionDeclaration) {
+  if (node.type === AST_NODE_TYPES63.FunctionDeclaration) {
     return false;
   }
   const { parent } = node;
   if (!parent) {
     return false;
   }
-  if (parent.type === AST_NODE_TYPES55.CallExpression && parent.arguments.includes(node)) {
+  if (parent.type === AST_NODE_TYPES63.CallExpression && parent.arguments.includes(node)) {
     return true;
   }
-  if (parent.type === AST_NODE_TYPES55.Property) {
+  if (parent.type === AST_NODE_TYPES63.Property) {
     return true;
   }
-  if (parent.type === AST_NODE_TYPES55.ArrayExpression) {
+  if (parent.type === AST_NODE_TYPES63.ArrayExpression) {
     return true;
   }
   return false;
 };
 var getFunctionName = (node) => {
-  if (node.type === AST_NODE_TYPES55.FunctionDeclaration && node.id) {
+  if (node.type === AST_NODE_TYPES63.FunctionDeclaration && node.id) {
     return node.id.name;
   }
-  if (node.type === AST_NODE_TYPES55.FunctionExpression && node.id) {
+  if (node.type === AST_NODE_TYPES63.FunctionExpression && node.id) {
     return node.id.name;
   }
-  if ((node.type === AST_NODE_TYPES55.ArrowFunctionExpression || node.type === AST_NODE_TYPES55.FunctionExpression) && node.parent?.type === AST_NODE_TYPES55.VariableDeclarator && node.parent.id.type === AST_NODE_TYPES55.Identifier) {
+  if ((node.type === AST_NODE_TYPES63.ArrowFunctionExpression || node.type === AST_NODE_TYPES63.FunctionExpression) && node.parent?.type === AST_NODE_TYPES63.VariableDeclarator && node.parent.id.type === AST_NODE_TYPES63.Identifier) {
     return node.parent.id.name;
   }
   return null;
 };
-var requireExplicitReturnType = createRule55({
+var requireExplicitReturnType = createRule63({
   name: "require-explicit-return-type",
   meta: {
     type: "suggestion",
@@ -4324,8 +4952,8 @@ var requireExplicitReturnType = createRule55({
 var require_explicit_return_type_default = requireExplicitReturnType;
 
 // src/rules/sort-exports.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES56, ESLintUtils as ESLintUtils56 } from "@typescript-eslint/utils";
-var createRule56 = ESLintUtils56.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES64, ESLintUtils as ESLintUtils64 } from "@typescript-eslint/utils";
+var createRule64 = ESLintUtils64.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"];
@@ -4339,7 +4967,7 @@ function getExportGroup(node) {
   }
   return 1;
 }
-var sortExports = createRule56({
+var sortExports = createRule64({
   name: "sort-exports",
   meta: {
     type: "suggestion",
@@ -4379,7 +5007,7 @@ var sortExports = createRule56({
       Program(node) {
         const exportGroups = [];
         node.body.forEach((statement) => {
-          if (statement.type !== AST_NODE_TYPES56.ExportNamedDeclaration || statement.declaration !== null) {
+          if (statement.type !== AST_NODE_TYPES64.ExportNamedDeclaration || statement.declaration !== null) {
             if (exportGroups.length > 0) {
               checkOrder(exportGroups);
               exportGroups.length = 0;
@@ -4398,8 +5026,8 @@ var sortExports = createRule56({
 var sort_exports_default = sortExports;
 
 // src/rules/sort-imports.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES57, ESLintUtils as ESLintUtils57 } from "@typescript-eslint/utils";
-var createRule57 = ESLintUtils57.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES65, ESLintUtils as ESLintUtils65 } from "@typescript-eslint/utils";
+var createRule65 = ESLintUtils65.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var NODE_BUILTINS = /* @__PURE__ */ new Set([
@@ -4466,7 +5094,7 @@ function getImportGroup(node) {
 function isTypeOnlyImport(node) {
   return node.importKind === "type" && node.specifiers.length > 0;
 }
-var sortImports = createRule57({
+var sortImports = createRule65({
   name: "sort-imports",
   meta: {
     type: "suggestion",
@@ -4510,7 +5138,7 @@ var sortImports = createRule57({
       Program(node) {
         const importGroups = [];
         node.body.forEach((statement) => {
-          if (statement.type !== AST_NODE_TYPES57.ImportDeclaration) {
+          if (statement.type !== AST_NODE_TYPES65.ImportDeclaration) {
             if (importGroups.length > 0) {
               checkOrder(importGroups);
               importGroups.length = 0;
@@ -4532,13 +5160,13 @@ var sortImports = createRule57({
 var sort_imports_default = sortImports;
 
 // src/rules/sort-type-alphabetically.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES58, ESLintUtils as ESLintUtils58 } from "@typescript-eslint/utils";
-var createRule58 = ESLintUtils58.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES66, ESLintUtils as ESLintUtils66 } from "@typescript-eslint/utils";
+var createRule66 = ESLintUtils66.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 === AST_NODE_TYPES58.TSPropertySignature && member.key.type === AST_NODE_TYPES58.Identifier
+    (member) => member.type === AST_NODE_TYPES66.TSPropertySignature && member.key.type === AST_NODE_TYPES66.Identifier
   );
   if (properties.length < 2) {
     return true;
@@ -4549,7 +5177,7 @@ function isAlphabeticallySortedWithinGroups(members) {
   const isOptionalSorted = optional.every((name, index) => index === 0 || optional[index - 1].localeCompare(name) <= 0);
   return isRequiredSorted && isOptionalSorted;
 }
-var sortTypeAlphabetically = createRule58({
+var sortTypeAlphabetically = createRule66({
   name: "sort-type-alphabetically",
   meta: {
     type: "suggestion",
@@ -4567,7 +5195,7 @@ var sortTypeAlphabetically = createRule58({
     function fixMembers(fixer, members) {
       const { sourceCode } = context;
       const properties = members.filter(
-        (member) => member.type === AST_NODE_TYPES58.TSPropertySignature && member.key.type === AST_NODE_TYPES58.Identifier
+        (member) => member.type === AST_NODE_TYPES66.TSPropertySignature && member.key.type === AST_NODE_TYPES66.Identifier
       );
       const required = properties.filter((prop) => !prop.optional);
       const optional = properties.filter((prop) => prop.optional);
@@ -4604,7 +5232,7 @@ var sortTypeAlphabetically = createRule58({
         }
       },
       TSTypeAliasDeclaration(node) {
-        if (node.typeAnnotation.type !== AST_NODE_TYPES58.TSTypeLiteral) {
+        if (node.typeAnnotation.type !== AST_NODE_TYPES66.TSTypeLiteral) {
           return;
         }
         const { members } = node.typeAnnotation;
@@ -4624,13 +5252,13 @@ var sortTypeAlphabetically = createRule58({
 var sort_type_alphabetically_default = sortTypeAlphabetically;
 
 // src/rules/sort-type-required-first.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES59, ESLintUtils as ESLintUtils59 } from "@typescript-eslint/utils";
-var createRule59 = ESLintUtils59.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES67, ESLintUtils as ESLintUtils67 } from "@typescript-eslint/utils";
+var createRule67 = ESLintUtils67.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 === AST_NODE_TYPES59.TSPropertySignature && member.key.type === AST_NODE_TYPES59.Identifier
+    (member) => member.type === AST_NODE_TYPES67.TSPropertySignature && member.key.type === AST_NODE_TYPES67.Identifier
   );
   if (properties.length < 2) {
     return true;
@@ -4641,7 +5269,7 @@ function isRequiredBeforeOptional(members) {
   }
   return properties.slice(firstOptionalIndex).every((prop) => prop.optional);
 }
-var sortTypeRequiredFirst = createRule59({
+var sortTypeRequiredFirst = createRule67({
   name: "sort-type-required-first",
   meta: {
     type: "suggestion",
@@ -4659,7 +5287,7 @@ var sortTypeRequiredFirst = createRule59({
     function fixMembers(fixer, members) {
       const { sourceCode } = context;
       const properties = members.filter(
-        (member) => member.type === AST_NODE_TYPES59.TSPropertySignature && member.key.type === AST_NODE_TYPES59.Identifier
+        (member) => member.type === AST_NODE_TYPES67.TSPropertySignature && member.key.type === AST_NODE_TYPES67.Identifier
       );
       const required = properties.filter((prop) => !prop.optional);
       const optional = properties.filter((prop) => prop.optional);
@@ -4680,7 +5308,7 @@ var sortTypeRequiredFirst = createRule59({
         }
       },
       TSTypeAliasDeclaration(node) {
-        if (node.typeAnnotation.type !== AST_NODE_TYPES59.TSTypeLiteral) {
+        if (node.typeAnnotation.type !== AST_NODE_TYPES67.TSTypeLiteral) {
           return;
         }
         const { members } = node.typeAnnotation;
@@ -4708,18 +5336,24 @@ 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,
   "jsx-newline-between-elements": jsx_newline_between_elements_default,
+  "jsx-no-data-array": jsx_no_data_array_default,
+  "jsx-no-data-object": jsx_no_data_object_default,
   "jsx-no-inline-object-prop": jsx_no_inline_object_prop_default,
   "jsx-no-newline-single-line-elements": jsx_no_newline_single_line_elements_default,
   "jsx-no-non-component-function": jsx_no_non_component_function_default,
+  "jsx-no-sub-interface": jsx_no_sub_interface_default,
   "jsx-no-ternary-null": jsx_no_ternary_null_default,
   "jsx-no-variable-in-callback": jsx_no_variable_in_callback_default,
   "jsx-require-suspense": jsx_require_suspense_default,
@@ -4733,6 +5367,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,
@@ -4773,9 +5409,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",
@@ -4815,9 +5453,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",
@@ -4856,10 +5496,14 @@ var baseRecommendedRules = {
 var jsxRules = {
   "nextfriday/enforce-props-suffix": "warn",
   "nextfriday/enforce-readonly-component-props": "warn",
+  "nextfriday/enforce-render-naming": "warn",
   "nextfriday/jsx-newline-between-elements": "warn",
+  "nextfriday/jsx-no-data-array": "warn",
+  "nextfriday/jsx-no-data-object": "warn",
   "nextfriday/jsx-no-inline-object-prop": "warn",
   "nextfriday/jsx-no-newline-single-line-elements": "warn",
   "nextfriday/jsx-no-non-component-function": "warn",
+  "nextfriday/jsx-no-sub-interface": "warn",
   "nextfriday/jsx-no-ternary-null": "warn",
   "nextfriday/jsx-no-variable-in-callback": "warn",
   "nextfriday/jsx-require-suspense": "warn",
@@ -4877,10 +5521,14 @@ var jsxRules = {
 var jsxRecommendedRules = {
   "nextfriday/enforce-props-suffix": "error",
   "nextfriday/enforce-readonly-component-props": "error",
+  "nextfriday/enforce-render-naming": "error",
   "nextfriday/jsx-newline-between-elements": "error",
+  "nextfriday/jsx-no-data-array": "error",
+  "nextfriday/jsx-no-data-object": "error",
   "nextfriday/jsx-no-inline-object-prop": "error",
   "nextfriday/jsx-no-newline-single-line-elements": "error",
   "nextfriday/jsx-no-non-component-function": "error",
+  "nextfriday/jsx-no-sub-interface": "error",
   "nextfriday/jsx-no-ternary-null": "error",
   "nextfriday/jsx-no-variable-in-callback": "error",
   "nextfriday/jsx-require-suspense": "error",