eslint-plugin-nextfriday 4.1.0 → 4.3.0

package/lib/index.cjs

@@ -40,7 +40,7 @@ module.exports = __toCommonJS(index_exports);
 // 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",
@@ -525,13 +525,64 @@ var enforceConstantCase = createRule3({
 });
 var enforce_constant_case_default = enforceConstantCase;
 
-// src/rules/enforce-hook-naming.ts
+// src/rules/enforce-hook-filename.ts
 var import_path = __toESM(require("path"), 1);
 var import_utils6 = require("@typescript-eslint/utils");
 var createRule4 = import_utils6.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var enforceHookNaming = createRule4({
+var enforceHookFilename = createRule4({
+  name: "enforce-hook-filename",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Enforce that files exporting custom hooks are named *.hook.ts or *.hooks.ts"
+    },
+    messages: {
+      requireHookFilename: "'{{ name }}' is a custom hook and must be exported from a *.hook.ts or *.hooks.ts file."
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    const basename2 = import_path.default.basename(context.filename);
+    const isHookFile = basename2.endsWith(".hook.ts") || basename2.endsWith(".hooks.ts");
+    if (isHookFile) return {};
+    function reportIfHook(name, node) {
+      if (name.startsWith("use") && name.length > 3 && /^use[A-Z]/.test(name)) {
+        context.report({ node, messageId: "requireHookFilename", data: { name } });
+      }
+    }
+    return {
+      ExportNamedDeclaration(node) {
+        if (node.declaration?.type === import_utils6.AST_NODE_TYPES.FunctionDeclaration && node.declaration.id) {
+          reportIfHook(node.declaration.id.name, node.declaration.id);
+        }
+        if (node.declaration?.type === import_utils6.AST_NODE_TYPES.VariableDeclaration) {
+          for (const declarator of node.declaration.declarations) {
+            if (declarator.id.type === import_utils6.AST_NODE_TYPES.Identifier && declarator.init !== null && (declarator.init.type === import_utils6.AST_NODE_TYPES.ArrowFunctionExpression || declarator.init.type === import_utils6.AST_NODE_TYPES.FunctionExpression)) {
+              reportIfHook(declarator.id.name, declarator.id);
+            }
+          }
+        }
+      },
+      ExportDefaultDeclaration(node) {
+        if (node.declaration.type === import_utils6.AST_NODE_TYPES.FunctionDeclaration && node.declaration.id !== null) {
+          reportIfHook(node.declaration.id.name, node.declaration.id);
+        }
+      }
+    };
+  }
+});
+var enforce_hook_filename_default = enforceHookFilename;
+
+// src/rules/enforce-hook-naming.ts
+var import_path2 = __toESM(require("path"), 1);
+var import_utils7 = require("@typescript-eslint/utils");
+var createRule5 = import_utils7.ESLintUtils.RuleCreator(
+  (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
+);
+var enforceHookNaming = createRule5({
   name: "enforce-hook-naming",
   meta: {
     type: "suggestion",
@@ -547,7 +598,7 @@ var enforceHookNaming = createRule4({
   defaultOptions: [],
   create(context) {
     const { filename } = context;
-    const basename2 = import_path.default.basename(filename);
+    const basename2 = import_path2.default.basename(filename);
     const isHookFile = basename2.endsWith(".hook.ts") || basename2.endsWith(".hooks.ts");
     if (!isHookFile) {
       return {};
@@ -570,22 +621,22 @@ var enforceHookNaming = createRule4({
     };
     return {
       ExportNamedDeclaration(node) {
-        if (node.declaration?.type === import_utils6.AST_NODE_TYPES.FunctionDeclaration && node.declaration.id) {
+        if (node.declaration?.type === import_utils7.AST_NODE_TYPES.FunctionDeclaration && node.declaration.id) {
           checkFunctionName(node.declaration.id.name, node.declaration.id, "missingUsePrefix");
         }
-        if (node.declaration?.type === import_utils6.AST_NODE_TYPES.VariableDeclaration) {
+        if (node.declaration?.type === import_utils7.AST_NODE_TYPES.VariableDeclaration) {
           node.declaration.declarations.forEach((declarator) => {
-            if (declarator.id.type === import_utils6.AST_NODE_TYPES.Identifier) {
+            if (declarator.id.type === import_utils7.AST_NODE_TYPES.Identifier) {
               checkFunctionName(declarator.id.name, declarator.id, "missingUsePrefix");
             }
           });
         }
       },
       ExportDefaultDeclaration(node) {
-        if (node.declaration.type === import_utils6.AST_NODE_TYPES.Identifier) {
+        if (node.declaration.type === import_utils7.AST_NODE_TYPES.Identifier) {
           checkFunctionName(node.declaration.name, node.declaration, "defaultExportMissingUsePrefix");
         }
-        if (node.declaration.type === import_utils6.AST_NODE_TYPES.FunctionDeclaration && node.declaration.id) {
+        if (node.declaration.type === import_utils7.AST_NODE_TYPES.FunctionDeclaration && node.declaration.id) {
           checkFunctionName(node.declaration.id.name, node.declaration.id, "defaultExportMissingUsePrefix");
         }
       }
@@ -595,26 +646,26 @@ var enforceHookNaming = createRule4({
 var enforce_hook_naming_default = enforceHookNaming;
 
 // src/rules/enforce-property-case.ts
-var import_utils7 = require("@typescript-eslint/utils");
-var createRule5 = import_utils7.ESLintUtils.RuleCreator(
+var import_utils8 = require("@typescript-eslint/utils");
+var createRule6 = import_utils8.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var SNAKE_CASE_REGEX3 = /^[a-z]+_[a-z0-9_]*$/;
 var SCREAMING_SNAKE_CASE_REGEX2 = /^[A-Z][A-Z0-9]*(?:_[A-Z0-9]+)*$/;
 var isInsideAsConst = (node) => {
   const { parent } = node;
-  if (parent.type === import_utils7.AST_NODE_TYPES.TSAsExpression && parent.typeAnnotation.type === import_utils7.AST_NODE_TYPES.TSTypeReference && parent.typeAnnotation.typeName.type === import_utils7.AST_NODE_TYPES.Identifier && parent.typeAnnotation.typeName.name === "const") {
+  if (parent.type === import_utils8.AST_NODE_TYPES.TSAsExpression && parent.typeAnnotation.type === import_utils8.AST_NODE_TYPES.TSTypeReference && parent.typeAnnotation.typeName.type === import_utils8.AST_NODE_TYPES.Identifier && parent.typeAnnotation.typeName.name === "const") {
     return true;
   }
-  if (parent.type === import_utils7.AST_NODE_TYPES.ArrayExpression) {
+  if (parent.type === import_utils8.AST_NODE_TYPES.ArrayExpression) {
     const grandparent = parent.parent;
-    if (grandparent?.type === import_utils7.AST_NODE_TYPES.TSAsExpression && grandparent.typeAnnotation.type === import_utils7.AST_NODE_TYPES.TSTypeReference && grandparent.typeAnnotation.typeName.type === import_utils7.AST_NODE_TYPES.Identifier && grandparent.typeAnnotation.typeName.name === "const") {
+    if (grandparent?.type === import_utils8.AST_NODE_TYPES.TSAsExpression && grandparent.typeAnnotation.type === import_utils8.AST_NODE_TYPES.TSTypeReference && grandparent.typeAnnotation.typeName.type === import_utils8.AST_NODE_TYPES.Identifier && grandparent.typeAnnotation.typeName.name === "const") {
       return true;
     }
   }
   return false;
 };
-var enforcePropertyCase = createRule5({
+var enforcePropertyCase = createRule6({
   name: "enforce-property-case",
   meta: {
     type: "suggestion",
@@ -630,7 +681,7 @@ var enforcePropertyCase = createRule5({
   create(context) {
     return {
       Property(node) {
-        if (node.parent.type !== import_utils7.AST_NODE_TYPES.ObjectExpression) {
+        if (node.parent.type !== import_utils8.AST_NODE_TYPES.ObjectExpression) {
           return;
         }
         if (isInsideAsConst(node.parent)) {
@@ -639,7 +690,7 @@ var enforcePropertyCase = createRule5({
         if (node.computed) {
           return;
         }
-        if (node.key.type !== import_utils7.AST_NODE_TYPES.Identifier) {
+        if (node.key.type !== import_utils8.AST_NODE_TYPES.Identifier) {
           return;
         }
         const { name } = node.key;
@@ -657,12 +708,12 @@ var enforcePropertyCase = createRule5({
 var enforce_property_case_default = enforcePropertyCase;
 
 // src/rules/enforce-props-suffix.ts
-var import_path2 = __toESM(require("path"), 1);
-var import_utils8 = require("@typescript-eslint/utils");
-var createRule6 = import_utils8.ESLintUtils.RuleCreator(
+var import_path3 = __toESM(require("path"), 1);
+var import_utils9 = require("@typescript-eslint/utils");
+var createRule7 = import_utils9.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var enforcePropsSuffix = createRule6({
+var enforcePropsSuffix = createRule7({
   name: "enforce-props-suffix",
   meta: {
     type: "suggestion",
@@ -677,7 +728,7 @@ var enforcePropsSuffix = createRule6({
   defaultOptions: [],
   create(context) {
     const { filename } = context;
-    const ext = import_path2.default.extname(filename);
+    const ext = import_path3.default.extname(filename);
     const isComponentFile = ext === ".tsx" || ext === ".jsx";
     if (!isComponentFile) {
       return {};
@@ -696,13 +747,13 @@ var enforcePropsSuffix = createRule6({
     };
     return {
       TSInterfaceDeclaration(node) {
-        if (node.id.type === import_utils8.AST_NODE_TYPES.Identifier) {
+        if (node.id.type === import_utils9.AST_NODE_TYPES.Identifier) {
           checkTypeName(node.id.name, node.id);
         }
       },
       TSTypeAliasDeclaration(node) {
-        if (node.id.type === import_utils8.AST_NODE_TYPES.Identifier) {
-          if (node.typeAnnotation.type === import_utils8.AST_NODE_TYPES.TSTypeLiteral) {
+        if (node.id.type === import_utils9.AST_NODE_TYPES.Identifier) {
+          if (node.typeAnnotation.type === import_utils9.AST_NODE_TYPES.TSTypeLiteral) {
             checkTypeName(node.id.name, node.id);
           }
         }
@@ -713,11 +764,11 @@ var enforcePropsSuffix = createRule6({
 var enforce_props_suffix_default = enforcePropsSuffix;
 
 // src/rules/enforce-readonly-component-props.ts
-var import_utils9 = require("@typescript-eslint/utils");
-var createRule7 = import_utils9.ESLintUtils.RuleCreator(
+var import_utils10 = require("@typescript-eslint/utils");
+var createRule8 = import_utils10.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var enforceReadonlyComponentProps = createRule7({
+var enforceReadonlyComponentProps = createRule8({
   name: "enforce-readonly-component-props",
   meta: {
     type: "suggestion",
@@ -733,40 +784,40 @@ var enforceReadonlyComponentProps = createRule7({
   defaultOptions: [],
   create(context) {
     function hasJSXInConditional(node) {
-      return node.consequent.type === import_utils9.AST_NODE_TYPES.JSXElement || node.consequent.type === import_utils9.AST_NODE_TYPES.JSXFragment || node.alternate.type === import_utils9.AST_NODE_TYPES.JSXElement || node.alternate.type === import_utils9.AST_NODE_TYPES.JSXFragment;
+      return node.consequent.type === import_utils10.AST_NODE_TYPES.JSXElement || node.consequent.type === import_utils10.AST_NODE_TYPES.JSXFragment || node.alternate.type === import_utils10.AST_NODE_TYPES.JSXElement || node.alternate.type === import_utils10.AST_NODE_TYPES.JSXFragment;
     }
     function hasJSXInLogical(node) {
-      return node.right.type === import_utils9.AST_NODE_TYPES.JSXElement || node.right.type === import_utils9.AST_NODE_TYPES.JSXFragment;
+      return node.right.type === import_utils10.AST_NODE_TYPES.JSXElement || node.right.type === import_utils10.AST_NODE_TYPES.JSXFragment;
     }
     function hasJSXReturn(block) {
       return block.body.some((stmt) => {
-        if (stmt.type === import_utils9.AST_NODE_TYPES.ReturnStatement && stmt.argument) {
-          return stmt.argument.type === import_utils9.AST_NODE_TYPES.JSXElement || stmt.argument.type === import_utils9.AST_NODE_TYPES.JSXFragment || stmt.argument.type === import_utils9.AST_NODE_TYPES.ConditionalExpression && hasJSXInConditional(stmt.argument) || stmt.argument.type === import_utils9.AST_NODE_TYPES.LogicalExpression && hasJSXInLogical(stmt.argument);
+        if (stmt.type === import_utils10.AST_NODE_TYPES.ReturnStatement && stmt.argument) {
+          return stmt.argument.type === import_utils10.AST_NODE_TYPES.JSXElement || stmt.argument.type === import_utils10.AST_NODE_TYPES.JSXFragment || stmt.argument.type === import_utils10.AST_NODE_TYPES.ConditionalExpression && hasJSXInConditional(stmt.argument) || stmt.argument.type === import_utils10.AST_NODE_TYPES.LogicalExpression && hasJSXInLogical(stmt.argument);
         }
         return false;
       });
     }
     function isReactComponent2(node) {
-      if (node.type === import_utils9.AST_NODE_TYPES.ArrowFunctionExpression) {
-        if (node.body.type === import_utils9.AST_NODE_TYPES.JSXElement || node.body.type === import_utils9.AST_NODE_TYPES.JSXFragment) {
+      if (node.type === import_utils10.AST_NODE_TYPES.ArrowFunctionExpression) {
+        if (node.body.type === import_utils10.AST_NODE_TYPES.JSXElement || node.body.type === import_utils10.AST_NODE_TYPES.JSXFragment) {
           return true;
         }
-        if (node.body.type === import_utils9.AST_NODE_TYPES.BlockStatement) {
+        if (node.body.type === import_utils10.AST_NODE_TYPES.BlockStatement) {
           return hasJSXReturn(node.body);
         }
-      } else if (node.type === import_utils9.AST_NODE_TYPES.FunctionExpression || node.type === import_utils9.AST_NODE_TYPES.FunctionDeclaration) {
-        if (node.body && node.body.type === import_utils9.AST_NODE_TYPES.BlockStatement) {
+      } else if (node.type === import_utils10.AST_NODE_TYPES.FunctionExpression || node.type === import_utils10.AST_NODE_TYPES.FunctionDeclaration) {
+        if (node.body && node.body.type === import_utils10.AST_NODE_TYPES.BlockStatement) {
           return hasJSXReturn(node.body);
         }
       }
       return false;
     }
     function isNamedType(node) {
-      return node.type === import_utils9.AST_NODE_TYPES.TSTypeReference;
+      return node.type === import_utils10.AST_NODE_TYPES.TSTypeReference;
     }
     function isAlreadyReadonly(node) {
-      if (node.type === import_utils9.AST_NODE_TYPES.TSTypeReference && node.typeName) {
-        if (node.typeName.type === import_utils9.AST_NODE_TYPES.Identifier && node.typeName.name === "Readonly") {
+      if (node.type === import_utils10.AST_NODE_TYPES.TSTypeReference && node.typeName) {
+        if (node.typeName.type === import_utils10.AST_NODE_TYPES.Identifier && node.typeName.name === "Readonly") {
           return true;
         }
       }
@@ -780,7 +831,7 @@ var enforceReadonlyComponentProps = createRule7({
         return;
       }
       const param = node.params[0];
-      if (param.type === import_utils9.AST_NODE_TYPES.Identifier && param.typeAnnotation) {
+      if (param.type === import_utils10.AST_NODE_TYPES.Identifier && param.typeAnnotation) {
         const { typeAnnotation } = param.typeAnnotation;
         if (isNamedType(typeAnnotation) && !isAlreadyReadonly(typeAnnotation)) {
           const { sourceCode } = context;
@@ -804,9 +855,159 @@ var enforceReadonlyComponentProps = createRule7({
 });
 var enforce_readonly_component_props_default = enforceReadonlyComponentProps;
 
+// src/rules/enforce-render-naming.ts
+var import_utils11 = require("@typescript-eslint/utils");
+var createRule9 = import_utils11.ESLintUtils.RuleCreator(
+  (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
+);
+var ARRAY_RETURNING_METHODS = /* @__PURE__ */ new Set(["map", "flatMap", "filter"]);
+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 === import_utils11.AST_NODE_TYPES.JSXElement || body.type === import_utils11.AST_NODE_TYPES.JSXFragment) {
+    return true;
+  }
+  if (body.type === import_utils11.AST_NODE_TYPES.ConditionalExpression) {
+    return isJsxProducingExpression(body.consequent) || isJsxProducingExpression(body.alternate);
+  }
+  if (body.type === import_utils11.AST_NODE_TYPES.LogicalExpression) {
+    return isJsxProducingExpression(body.right);
+  }
+  if (body.type !== import_utils11.AST_NODE_TYPES.BlockStatement) {
+    return false;
+  }
+  for (const statement of body.body) {
+    if (statement.type === import_utils11.AST_NODE_TYPES.ReturnStatement && statement.argument) {
+      if (isJsxProducingExpression(statement.argument)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function isJsxProducingExpression(node) {
+  if (node.type === import_utils11.AST_NODE_TYPES.JSXElement || node.type === import_utils11.AST_NODE_TYPES.JSXFragment) {
+    return true;
+  }
+  if (node.type === import_utils11.AST_NODE_TYPES.ConditionalExpression) {
+    return isJsxProducingExpression(node.consequent) || isJsxProducingExpression(node.alternate);
+  }
+  if (node.type === import_utils11.AST_NODE_TYPES.LogicalExpression) {
+    return isJsxProducingExpression(node.right);
+  }
+  if (node.type === import_utils11.AST_NODE_TYPES.ArrayExpression) {
+    return node.elements.some((element) => {
+      if (!element || element.type === import_utils11.AST_NODE_TYPES.SpreadElement) {
+        return false;
+      }
+      return isJsxProducingExpression(element);
+    });
+  }
+  if (node.type === import_utils11.AST_NODE_TYPES.ArrowFunctionExpression || node.type === import_utils11.AST_NODE_TYPES.FunctionExpression) {
+    return functionBodyReturnsJsx(node.body);
+  }
+  if (node.type === import_utils11.AST_NODE_TYPES.CallExpression) {
+    if (node.callee.type === import_utils11.AST_NODE_TYPES.MemberExpression && node.callee.property.type === import_utils11.AST_NODE_TYPES.Identifier && ARRAY_RETURNING_METHODS.has(node.callee.property.name)) {
+      const callback = node.arguments[0];
+      if (callback && (callback.type === import_utils11.AST_NODE_TYPES.ArrowFunctionExpression || callback.type === import_utils11.AST_NODE_TYPES.FunctionExpression)) {
+        return functionBodyReturnsJsx(callback.body);
+      }
+    }
+  }
+  if (node.type === import_utils11.AST_NODE_TYPES.TSAsExpression || node.type === import_utils11.AST_NODE_TYPES.TSSatisfiesExpression) {
+    return isJsxProducingExpression(node.expression);
+  }
+  return false;
+}
+function isPascalCase(name) {
+  return /^[A-Z]/.test(name);
+}
+function isComponentFunction2(node) {
+  if (node.type === import_utils11.AST_NODE_TYPES.FunctionDeclaration && node.id && isPascalCase(node.id.name)) {
+    return true;
+  }
+  const parent = node.parent;
+  if (parent?.type === import_utils11.AST_NODE_TYPES.VariableDeclarator && parent.id.type === import_utils11.AST_NODE_TYPES.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 !== import_utils11.AST_NODE_TYPES.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
-var import_utils10 = require("@typescript-eslint/utils");
-var createRule8 = import_utils10.ESLintUtils.RuleCreator(
+var import_utils13 = require("@typescript-eslint/utils");
+var createRule10 = import_utils13.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var BANNED_PREFIXES = {
@@ -815,7 +1016,7 @@ var BANNED_PREFIXES = {
   handle: ["create", "verify"],
   set: ["update", "save", "patch"]
 };
-var enforceServiceNaming = createRule8({
+var enforceServiceNaming = createRule10({
   name: "enforce-service-naming",
   meta: {
     type: "suggestion",
@@ -858,12 +1059,12 @@ var enforceServiceNaming = createRule8({
     };
     return {
       ExportNamedDeclaration(node) {
-        if (node.declaration?.type === import_utils10.AST_NODE_TYPES.FunctionDeclaration && node.declaration.id) {
+        if (node.declaration?.type === import_utils13.AST_NODE_TYPES.FunctionDeclaration && node.declaration.id) {
           checkExportedFunction(node.declaration, node.declaration.id);
         }
-        if (node.declaration?.type === import_utils10.AST_NODE_TYPES.VariableDeclaration) {
+        if (node.declaration?.type === import_utils13.AST_NODE_TYPES.VariableDeclaration) {
           node.declaration.declarations.forEach((declarator) => {
-            if (declarator.id.type === import_utils10.AST_NODE_TYPES.Identifier && declarator.init?.type === import_utils10.AST_NODE_TYPES.ArrowFunctionExpression) {
+            if (declarator.id.type === import_utils13.AST_NODE_TYPES.Identifier && declarator.init?.type === import_utils13.AST_NODE_TYPES.ArrowFunctionExpression) {
               checkExportedFunction(declarator.init, declarator.id);
             }
           });
@@ -874,12 +1075,52 @@ var enforceServiceNaming = createRule8({
 });
 var enforce_service_naming_default = enforceServiceNaming;
 
+// src/rules/enforce-test-filename.ts
+var import_path4 = __toESM(require("path"), 1);
+var import_utils14 = require("@typescript-eslint/utils");
+var createRule11 = import_utils14.ESLintUtils.RuleCreator(
+  (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
+);
+var TEST_GLOBALS = /* @__PURE__ */ new Set(["describe", "it", "test", "beforeEach", "beforeAll", "afterEach", "afterAll"]);
+var enforceTestFilename = createRule11({
+  name: "enforce-test-filename",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Enforce that files containing test code are named *.test.ts or *.test.tsx"
+    },
+    messages: {
+      requireTestFilename: "Files containing test code must be named *.test.ts or *.test.tsx."
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    const basename2 = import_path4.default.basename(context.filename);
+    const isTestFile = basename2.endsWith(".test.ts") || basename2.endsWith(".test.tsx");
+    if (isTestFile) return {};
+    function isTestGlobalCall(node) {
+      return node.callee.type === import_utils14.AST_NODE_TYPES.Identifier && TEST_GLOBALS.has(node.callee.name);
+    }
+    let reported = false;
+    return {
+      CallExpression(node) {
+        if (reported) return;
+        if (!isTestGlobalCall(node)) return;
+        reported = true;
+        context.report({ node, messageId: "requireTestFilename" });
+      }
+    };
+  }
+});
+var enforce_test_filename_default = enforceTestFilename;
+
 // src/rules/enforce-sorted-destructuring.ts
-var import_utils11 = require("@typescript-eslint/utils");
-var createRule9 = import_utils11.ESLintUtils.RuleCreator(
+var import_utils15 = require("@typescript-eslint/utils");
+var createRule12 = import_utils15.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var enforceSortedDestructuring = createRule9({
+var enforceSortedDestructuring = createRule12({
   name: "enforce-sorted-destructuring",
   meta: {
     type: "suggestion",
@@ -895,19 +1136,19 @@ var enforceSortedDestructuring = createRule9({
   defaultOptions: [],
   create(context) {
     function getPropertyName(property) {
-      if (property.type === import_utils11.AST_NODE_TYPES.RestElement) {
+      if (property.type === import_utils15.AST_NODE_TYPES.RestElement) {
         return null;
       }
-      if (property.key.type === import_utils11.AST_NODE_TYPES.Identifier) {
+      if (property.key.type === import_utils15.AST_NODE_TYPES.Identifier) {
         return property.key.name;
       }
       return null;
     }
     function hasDefaultValue(property) {
-      return property.value.type === import_utils11.AST_NODE_TYPES.AssignmentPattern && Boolean(property.value.right);
+      return property.value.type === import_utils15.AST_NODE_TYPES.AssignmentPattern && Boolean(property.value.right);
     }
     function checkVariableDeclarator(node) {
-      if (node.id.type !== import_utils11.AST_NODE_TYPES.ObjectPattern) {
+      if (node.id.type !== import_utils15.AST_NODE_TYPES.ObjectPattern) {
         return;
       }
       const { properties } = node.id;
@@ -915,7 +1156,7 @@ var enforceSortedDestructuring = createRule9({
         return;
       }
       const propertyInfo = properties.map((prop) => {
-        if (prop.type === import_utils11.AST_NODE_TYPES.RestElement) {
+        if (prop.type === import_utils15.AST_NODE_TYPES.RestElement) {
           return null;
         }
         return {
@@ -954,20 +1195,20 @@ var enforceSortedDestructuring = createRule9({
 var enforce_sorted_destructuring_default = enforceSortedDestructuring;
 
 // src/rules/enforce-type-declaration-order.ts
-var import_utils12 = require("@typescript-eslint/utils");
-var createRule10 = import_utils12.ESLintUtils.RuleCreator(
+var import_utils16 = require("@typescript-eslint/utils");
+var createRule13 = import_utils16.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 function getTypeDeclarationName(node) {
-  if (node.type === import_utils12.AST_NODE_TYPES.TSInterfaceDeclaration && node.id.type === import_utils12.AST_NODE_TYPES.Identifier) {
+  if (node.type === import_utils16.AST_NODE_TYPES.TSInterfaceDeclaration && node.id.type === import_utils16.AST_NODE_TYPES.Identifier) {
     return { name: node.id.name, position: node.range[0] };
   }
-  if (node.type === import_utils12.AST_NODE_TYPES.TSTypeAliasDeclaration && node.id.type === import_utils12.AST_NODE_TYPES.Identifier) {
+  if (node.type === import_utils16.AST_NODE_TYPES.TSTypeAliasDeclaration && node.id.type === import_utils16.AST_NODE_TYPES.Identifier) {
     return { name: node.id.name, position: node.range[0] };
   }
   return null;
 }
-var enforceTypeDeclarationOrder = createRule10({
+var enforceTypeDeclarationOrder = createRule13({
   name: "enforce-type-declaration-order",
   meta: {
     type: "suggestion",
@@ -998,7 +1239,7 @@ var enforceTypeDeclarationOrder = createRule10({
         }
       },
       "TSPropertySignature TSTypeReference": function checkTypeReference(node) {
-        if (node.typeName.type !== import_utils12.AST_NODE_TYPES.Identifier) {
+        if (node.typeName.type !== import_utils16.AST_NODE_TYPES.Identifier) {
           return;
         }
         const referencedName = node.typeName.name;
@@ -1035,8 +1276,8 @@ var enforceTypeDeclarationOrder = createRule10({
 var enforce_type_declaration_order_default = enforceTypeDeclarationOrder;
 
 // src/rules/index-export-only.ts
-var import_utils13 = require("@typescript-eslint/utils");
-var createRule11 = import_utils13.ESLintUtils.RuleCreator(
+var import_utils17 = require("@typescript-eslint/utils");
+var createRule14 = import_utils17.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var isIndexFile = (filename) => getBaseName(filename) === "index";
@@ -1044,26 +1285,26 @@ var isAllowedExportNamed = (node) => {
   if (!node.declaration) {
     return true;
   }
-  return node.declaration.type === import_utils13.AST_NODE_TYPES.TSTypeAliasDeclaration || node.declaration.type === import_utils13.AST_NODE_TYPES.TSInterfaceDeclaration;
+  return node.declaration.type === import_utils17.AST_NODE_TYPES.TSTypeAliasDeclaration || node.declaration.type === import_utils17.AST_NODE_TYPES.TSInterfaceDeclaration;
 };
-var isAllowedExportDefault = (node) => node.declaration.type === import_utils13.AST_NODE_TYPES.Identifier;
+var isAllowedExportDefault = (node) => node.declaration.type === import_utils17.AST_NODE_TYPES.Identifier;
 var isAllowedTopLevel = (node) => {
   switch (node.type) {
-    case import_utils13.AST_NODE_TYPES.ImportDeclaration:
-    case import_utils13.AST_NODE_TYPES.ExportAllDeclaration:
-    case import_utils13.AST_NODE_TYPES.TSTypeAliasDeclaration:
-    case import_utils13.AST_NODE_TYPES.TSInterfaceDeclaration:
-    case import_utils13.AST_NODE_TYPES.TSImportEqualsDeclaration:
+    case import_utils17.AST_NODE_TYPES.ImportDeclaration:
+    case import_utils17.AST_NODE_TYPES.ExportAllDeclaration:
+    case import_utils17.AST_NODE_TYPES.TSTypeAliasDeclaration:
+    case import_utils17.AST_NODE_TYPES.TSInterfaceDeclaration:
+    case import_utils17.AST_NODE_TYPES.TSImportEqualsDeclaration:
       return true;
-    case import_utils13.AST_NODE_TYPES.ExportNamedDeclaration:
+    case import_utils17.AST_NODE_TYPES.ExportNamedDeclaration:
       return isAllowedExportNamed(node);
-    case import_utils13.AST_NODE_TYPES.ExportDefaultDeclaration:
+    case import_utils17.AST_NODE_TYPES.ExportDefaultDeclaration:
       return isAllowedExportDefault(node);
     default:
       return false;
   }
 };
-var indexExportOnly = createRule11({
+var indexExportOnly = createRule14({
   name: "index-export-only",
   meta: {
     type: "suggestion",
@@ -1097,11 +1338,11 @@ var indexExportOnly = createRule11({
 var index_export_only_default = indexExportOnly;
 
 // src/rules/jsx-newline-between-elements.ts
-var import_utils15 = require("@typescript-eslint/utils");
-var createRule12 = import_utils15.ESLintUtils.RuleCreator(
+var import_utils19 = require("@typescript-eslint/utils");
+var createRule15 = import_utils19.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var jsxNewlineBetweenElements = createRule12({
+var jsxNewlineBetweenElements = createRule15({
   name: "jsx-newline-between-elements",
   meta: {
     type: "layout",
@@ -1119,7 +1360,7 @@ var jsxNewlineBetweenElements = createRule12({
   create(context) {
     const { sourceCode } = context;
     function isSignificantJSXChild(node) {
-      return node.type === import_utils15.AST_NODE_TYPES.JSXElement || node.type === import_utils15.AST_NODE_TYPES.JSXFragment || node.type === import_utils15.AST_NODE_TYPES.JSXExpressionContainer;
+      return node.type === import_utils19.AST_NODE_TYPES.JSXElement || node.type === import_utils19.AST_NODE_TYPES.JSXFragment || node.type === import_utils19.AST_NODE_TYPES.JSXExpressionContainer;
     }
     function isMultiLine(node) {
       return node.loc.start.line !== node.loc.end.line;
@@ -1168,12 +1409,194 @@ var jsxNewlineBetweenElements = createRule12({
 });
 var jsx_newline_between_elements_default = jsxNewlineBetweenElements;
 
+// src/rules/jsx-no-data-array.ts
+var import_utils20 = require("@typescript-eslint/utils");
+var createRule16 = import_utils20.ESLintUtils.RuleCreator(
+  (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
+);
+function isObjectLikeElement(node) {
+  if (!node) {
+    return false;
+  }
+  if (node.type === import_utils20.AST_NODE_TYPES.ObjectExpression) {
+    return true;
+  }
+  if (node.type === import_utils20.AST_NODE_TYPES.TSAsExpression || node.type === import_utils20.AST_NODE_TYPES.TSSatisfiesExpression) {
+    return isObjectLikeElement(node.expression);
+  }
+  return false;
+}
+function getArrayInitializer(init) {
+  if (!init) {
+    return null;
+  }
+  if (init.type === import_utils20.AST_NODE_TYPES.ArrayExpression) {
+    return init;
+  }
+  if (init.type === import_utils20.AST_NODE_TYPES.TSAsExpression || init.type === import_utils20.AST_NODE_TYPES.TSSatisfiesExpression) {
+    return getArrayInitializer(init.expression);
+  }
+  return null;
+}
+var jsxNoDataArray = 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 === import_utils20.AST_NODE_TYPES.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 === import_utils20.AST_NODE_TYPES.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
+var import_utils22 = require("@typescript-eslint/utils");
+var createRule17 = import_utils22.ESLintUtils.RuleCreator(
+  (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
+);
+function unwrapAssertion(node) {
+  if (!node) {
+    return null;
+  }
+  if (node.type === import_utils22.AST_NODE_TYPES.TSAsExpression || node.type === import_utils22.AST_NODE_TYPES.TSSatisfiesExpression) {
+    return unwrapAssertion(node.expression);
+  }
+  return node;
+}
+function isNestedValue(value) {
+  const unwrapped = unwrapAssertion(value);
+  if (!unwrapped) {
+    return false;
+  }
+  if (unwrapped.type === import_utils22.AST_NODE_TYPES.ObjectExpression) {
+    return true;
+  }
+  if (unwrapped.type === import_utils22.AST_NODE_TYPES.ArrayExpression) {
+    return unwrapped.elements.some((element) => {
+      if (!element || element.type === import_utils22.AST_NODE_TYPES.SpreadElement) {
+        return false;
+      }
+      const inner = unwrapAssertion(element);
+      return inner?.type === import_utils22.AST_NODE_TYPES.ObjectExpression || inner?.type === import_utils22.AST_NODE_TYPES.ArrayExpression;
+    });
+  }
+  return false;
+}
+function hasNestedProperty(object) {
+  return object.properties.some((property) => {
+    if (property.type !== import_utils22.AST_NODE_TYPES.Property) {
+      return false;
+    }
+    if (property.value.type === import_utils22.AST_NODE_TYPES.AssignmentPattern) {
+      return false;
+    }
+    return isNestedValue(property.value);
+  });
+}
+function getObjectInitializer(init) {
+  const unwrapped = unwrapAssertion(init);
+  if (!unwrapped) {
+    return null;
+  }
+  if (unwrapped.type === import_utils22.AST_NODE_TYPES.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 === import_utils22.AST_NODE_TYPES.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
-var import_utils16 = require("@typescript-eslint/utils");
-var createRule13 = import_utils16.ESLintUtils.RuleCreator(
+var import_utils24 = require("@typescript-eslint/utils");
+var createRule18 = import_utils24.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var jsxNoInlineObjectProp = createRule13({
+var jsxNoInlineObjectProp = createRule18({
   name: "jsx-no-inline-object-prop",
   meta: {
     type: "suggestion",
@@ -1189,7 +1612,7 @@ var jsxNoInlineObjectProp = createRule13({
   create(context) {
     return {
       JSXAttribute(node) {
-        if (node.value?.type === import_utils16.AST_NODE_TYPES.JSXExpressionContainer && node.value.expression.type === import_utils16.AST_NODE_TYPES.ObjectExpression) {
+        if (node.value?.type === import_utils24.AST_NODE_TYPES.JSXExpressionContainer && node.value.expression.type === import_utils24.AST_NODE_TYPES.ObjectExpression) {
           context.report({
             node: node.value,
             messageId: "noInlineObject"
@@ -1202,17 +1625,17 @@ var jsxNoInlineObjectProp = createRule13({
 var jsx_no_inline_object_prop_default = jsxNoInlineObjectProp;
 
 // src/rules/jsx-no-newline-single-line-elements.ts
-var import_utils17 = require("@typescript-eslint/utils");
-var createRule14 = import_utils17.ESLintUtils.RuleCreator(
+var import_utils25 = require("@typescript-eslint/utils");
+var createRule19 = import_utils25.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 function isJSXElementOrFragment(node) {
-  return node.type === import_utils17.AST_NODE_TYPES.JSXElement || node.type === import_utils17.AST_NODE_TYPES.JSXFragment;
+  return node.type === import_utils25.AST_NODE_TYPES.JSXElement || node.type === import_utils25.AST_NODE_TYPES.JSXFragment;
 }
 function isSingleLine(node) {
   return node.loc.start.line === node.loc.end.line;
 }
-var jsxNoNewlineSingleLineElements = createRule14({
+var jsxNoNewlineSingleLineElements = createRule19({
   name: "jsx-no-newline-single-line-elements",
   meta: {
     type: "layout",
@@ -1230,7 +1653,7 @@ var jsxNoNewlineSingleLineElements = createRule14({
     const { sourceCode } = context;
     function checkSiblings(children) {
       const nonWhitespace = children.filter(
-        (child) => !(child.type === import_utils17.AST_NODE_TYPES.JSXText && child.value.trim() === "")
+        (child) => !(child.type === import_utils25.AST_NODE_TYPES.JSXText && child.value.trim() === "")
       );
       nonWhitespace.forEach((next, index) => {
         if (index === 0) {
@@ -1281,11 +1704,11 @@ ${indent}`);
 var jsx_no_newline_single_line_elements_default = jsxNoNewlineSingleLineElements;
 
 // src/rules/jsx-no-non-component-function.ts
-var import_utils18 = require("@typescript-eslint/utils");
-var createRule15 = import_utils18.ESLintUtils.RuleCreator(
+var import_utils26 = require("@typescript-eslint/utils");
+var createRule20 = import_utils26.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var jsxNoNonComponentFunction = createRule15({
+var jsxNoNonComponentFunction = createRule20({
   name: "jsx-no-non-component-function",
   meta: {
     type: "problem",
@@ -1305,13 +1728,13 @@ var jsxNoNonComponentFunction = createRule15({
       return {};
     }
     function isReactComponent2(node) {
-      const functionName = node.type === import_utils18.AST_NODE_TYPES.FunctionDeclaration && node.id ? node.id.name : null;
+      const functionName = node.type === import_utils26.AST_NODE_TYPES.FunctionDeclaration && node.id ? node.id.name : null;
       if (functionName && /^[A-Z]/.test(functionName)) {
         return true;
       }
       if (node.returnType?.typeAnnotation) {
         const returnTypeNode = node.returnType.typeAnnotation;
-        if (returnTypeNode.type === import_utils18.AST_NODE_TYPES.TSTypeReference && returnTypeNode.typeName.type === import_utils18.AST_NODE_TYPES.Identifier) {
+        if (returnTypeNode.type === import_utils26.AST_NODE_TYPES.TSTypeReference && returnTypeNode.typeName.type === import_utils26.AST_NODE_TYPES.Identifier) {
           const typeName = returnTypeNode.typeName.name;
           if (typeName === "JSX" || typeName === "ReactElement" || typeName === "ReactNode") {
             return true;
@@ -1328,13 +1751,13 @@ var jsxNoNonComponentFunction = createRule15({
       if (!parent) {
         return;
       }
-      if (parent.type === import_utils18.AST_NODE_TYPES.ExportDefaultDeclaration || parent.type === import_utils18.AST_NODE_TYPES.ExportNamedDeclaration) {
+      if (parent.type === import_utils26.AST_NODE_TYPES.ExportDefaultDeclaration || parent.type === import_utils26.AST_NODE_TYPES.ExportNamedDeclaration) {
         return;
       }
-      if (declaratorNode?.parent?.parent?.type === import_utils18.AST_NODE_TYPES.ExportNamedDeclaration) {
+      if (declaratorNode?.parent?.parent?.type === import_utils26.AST_NODE_TYPES.ExportNamedDeclaration) {
         return;
       }
-      if (declaratorNode?.id.type === import_utils18.AST_NODE_TYPES.Identifier) {
+      if (declaratorNode?.id.type === import_utils26.AST_NODE_TYPES.Identifier) {
         const varName = declaratorNode.id.name;
         if (/^[A-Z]/.test(varName)) {
           return;
@@ -1358,21 +1781,146 @@ var jsxNoNonComponentFunction = createRule15({
 });
 var jsx_no_non_component_function_default = jsxNoNonComponentFunction;
 
+// src/rules/jsx-no-sub-interface.ts
+var import_utils28 = require("@typescript-eslint/utils");
+var createRule21 = import_utils28.ESLintUtils.RuleCreator(
+  (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
+);
+var PROPS_WRAPPER_NAMES = /* @__PURE__ */ new Set(["Readonly", "Required", "Partial", "PropsWithChildren", "NoInfer"]);
+function unwrapWrapperType(node) {
+  if (node.type === import_utils28.AST_NODE_TYPES.TSTypeReference && node.typeName.type === import_utils28.AST_NODE_TYPES.Identifier && PROPS_WRAPPER_NAMES.has(node.typeName.name) && node.typeArguments && node.typeArguments.params.length > 0) {
+    return unwrapWrapperType(node.typeArguments.params[0]);
+  }
+  return node;
+}
+function getMainTypeName(typeNode) {
+  if (!typeNode) {
+    return null;
+  }
+  const unwrapped = unwrapWrapperType(typeNode);
+  if (unwrapped.type === import_utils28.AST_NODE_TYPES.TSTypeReference && unwrapped.typeName.type === import_utils28.AST_NODE_TYPES.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 === import_utils28.AST_NODE_TYPES.ExportNamedDeclaration && node.declaration) {
+    return node.declaration;
+  }
+  if (node.type === import_utils28.AST_NODE_TYPES.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: {
+      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: [],
+  create(context) {
+    const { filename } = context;
+    const extension = getFileExtension(filename);
+    if (extension !== "tsx" && extension !== "jsx") {
+      return {};
+    }
+    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 === import_utils28.AST_NODE_TYPES.FunctionDeclaration && declaration.id && isPascalCase2(declaration.id.name)) {
+            componentCount += 1;
+            const mainType = getComponentMainTypeName(declaration);
+            if (mainType) {
+              mainTypes.add(mainType);
+            }
+            continue;
+          }
+          if (declaration.type === import_utils28.AST_NODE_TYPES.VariableDeclaration) {
+            for (const declarator of declaration.declarations) {
+              if (declarator.id.type !== import_utils28.AST_NODE_TYPES.Identifier) {
+                continue;
+              }
+              if (!isPascalCase2(declarator.id.name)) {
+                continue;
+              }
+              const init = declarator.init;
+              if (init && (init.type === import_utils28.AST_NODE_TYPES.ArrowFunctionExpression || init.type === import_utils28.AST_NODE_TYPES.FunctionExpression)) {
+                componentCount += 1;
+                const mainType = getComponentMainTypeName(init);
+                if (mainType) {
+                  mainTypes.add(mainType);
+                }
+              }
+            }
+            continue;
+          }
+          if (declaration.type === import_utils28.AST_NODE_TYPES.TSInterfaceDeclaration) {
+            typeDeclarations.push({ name: declaration.id.name, node: declaration });
+            continue;
+          }
+          if (declaration.type === import_utils28.AST_NODE_TYPES.TSTypeAliasDeclaration) {
+            typeDeclarations.push({ name: declaration.id.name, node: declaration });
+            continue;
+          }
+        }
+        if (componentCount === 0) {
+          return;
+        }
+        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_sub_interface_default = jsxNoSubInterface;
+
 // src/rules/jsx-no-ternary-null.ts
-var import_utils20 = require("@typescript-eslint/utils");
-var createRule16 = import_utils20.ESLintUtils.RuleCreator(
+var import_utils30 = require("@typescript-eslint/utils");
+var createRule22 = import_utils30.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 function isNullOrUndefined(node) {
-  if (node.type === import_utils20.AST_NODE_TYPES.Literal && node.value === null) {
+  if (node.type === import_utils30.AST_NODE_TYPES.Literal && node.value === null) {
     return true;
   }
-  if (node.type === import_utils20.AST_NODE_TYPES.Identifier && node.name === "undefined") {
+  if (node.type === import_utils30.AST_NODE_TYPES.Identifier && node.name === "undefined") {
     return true;
   }
   return false;
 }
-var jsxNoTernaryNull = createRule16({
+var jsxNoTernaryNull = createRule22({
   name: "jsx-no-ternary-null",
   meta: {
     type: "suggestion",
@@ -1390,7 +1938,7 @@ var jsxNoTernaryNull = createRule16({
     return {
       JSXExpressionContainer(node) {
         const { expression } = node;
-        if (expression.type !== import_utils20.AST_NODE_TYPES.ConditionalExpression) {
+        if (expression.type !== import_utils30.AST_NODE_TYPES.ConditionalExpression) {
           return;
         }
         const { test, consequent, alternate } = expression;
@@ -1422,11 +1970,11 @@ var jsxNoTernaryNull = createRule16({
 var jsx_no_ternary_null_default = jsxNoTernaryNull;
 
 // src/rules/jsx-no-variable-in-callback.ts
-var import_utils21 = require("@typescript-eslint/utils");
-var createRule17 = import_utils21.ESLintUtils.RuleCreator(
+var import_utils31 = require("@typescript-eslint/utils");
+var createRule23 = import_utils31.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var jsxNoVariableInCallback = createRule17({
+var jsxNoVariableInCallback = createRule23({
   name: "jsx-no-variable-in-callback",
   meta: {
     type: "suggestion",
@@ -1443,7 +1991,7 @@ var jsxNoVariableInCallback = createRule17({
     function isInsideJSX(node) {
       let current = node.parent;
       while (current) {
-        if (current.type === import_utils21.AST_NODE_TYPES.JSXElement || current.type === import_utils21.AST_NODE_TYPES.JSXFragment) {
+        if (current.type === import_utils31.AST_NODE_TYPES.JSXElement || current.type === import_utils31.AST_NODE_TYPES.JSXFragment) {
           return true;
         }
         current = current.parent;
@@ -1457,11 +2005,11 @@ var jsxNoVariableInCallback = createRule17({
       if (!isInsideJSX(node)) {
         return false;
       }
-      if (node.parent.type === import_utils21.AST_NODE_TYPES.CallExpression || node.parent.type === import_utils21.AST_NODE_TYPES.JSXExpressionContainer) {
+      if (node.parent.type === import_utils31.AST_NODE_TYPES.CallExpression || node.parent.type === import_utils31.AST_NODE_TYPES.JSXExpressionContainer) {
         return true;
       }
-      if (node.parent.type === import_utils21.AST_NODE_TYPES.ArrayExpression && node.parent.parent) {
-        if (node.parent.parent.type === import_utils21.AST_NODE_TYPES.CallExpression || node.parent.parent.type === import_utils21.AST_NODE_TYPES.JSXExpressionContainer) {
+      if (node.parent.type === import_utils31.AST_NODE_TYPES.ArrayExpression && node.parent.parent) {
+        if (node.parent.parent.type === import_utils31.AST_NODE_TYPES.CallExpression || node.parent.parent.type === import_utils31.AST_NODE_TYPES.JSXExpressionContainer) {
           return true;
         }
       }
@@ -1472,11 +2020,11 @@ var jsxNoVariableInCallback = createRule17({
         return;
       }
       const { body } = node;
-      if (body.type !== import_utils21.AST_NODE_TYPES.BlockStatement) {
+      if (body.type !== import_utils31.AST_NODE_TYPES.BlockStatement) {
         return;
       }
       body.body.forEach((statement) => {
-        if (statement.type === import_utils21.AST_NODE_TYPES.VariableDeclaration) {
+        if (statement.type === import_utils31.AST_NODE_TYPES.VariableDeclaration) {
           context.report({
             node: statement,
             messageId: "noVariableInCallback"
@@ -1493,11 +2041,11 @@ var jsxNoVariableInCallback = createRule17({
 var jsx_no_variable_in_callback_default = jsxNoVariableInCallback;
 
 // src/rules/jsx-require-suspense.ts
-var import_utils22 = require("@typescript-eslint/utils");
-var createRule18 = import_utils22.ESLintUtils.RuleCreator(
+var import_utils32 = require("@typescript-eslint/utils");
+var createRule24 = import_utils32.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var jsxRequireSuspense = createRule18({
+var jsxRequireSuspense = createRule24({
   name: "jsx-require-suspense",
   meta: {
     type: "problem",
@@ -1515,7 +2063,7 @@ var jsxRequireSuspense = createRule18({
     const isInsideSuspense = (node) => {
       let current = node.parent;
       while (current) {
-        if (current.type === import_utils22.AST_NODE_TYPES.JSXElement && current.openingElement.name.type === import_utils22.AST_NODE_TYPES.JSXIdentifier && current.openingElement.name.name === "Suspense") {
+        if (current.type === import_utils32.AST_NODE_TYPES.JSXElement && current.openingElement.name.type === import_utils32.AST_NODE_TYPES.JSXIdentifier && current.openingElement.name.name === "Suspense") {
           return true;
         }
         current = current.parent;
@@ -1524,16 +2072,16 @@ var jsxRequireSuspense = createRule18({
     };
     return {
       VariableDeclarator(node) {
-        if (node.id.type === import_utils22.AST_NODE_TYPES.Identifier && node.init?.type === import_utils22.AST_NODE_TYPES.CallExpression) {
+        if (node.id.type === import_utils32.AST_NODE_TYPES.Identifier && node.init?.type === import_utils32.AST_NODE_TYPES.CallExpression) {
           const { callee } = node.init;
-          const isLazyCall = callee.type === import_utils22.AST_NODE_TYPES.Identifier && callee.name === "lazy" || callee.type === import_utils22.AST_NODE_TYPES.MemberExpression && callee.object.type === import_utils22.AST_NODE_TYPES.Identifier && callee.object.name === "React" && callee.property.type === import_utils22.AST_NODE_TYPES.Identifier && callee.property.name === "lazy";
+          const isLazyCall = callee.type === import_utils32.AST_NODE_TYPES.Identifier && callee.name === "lazy" || callee.type === import_utils32.AST_NODE_TYPES.MemberExpression && callee.object.type === import_utils32.AST_NODE_TYPES.Identifier && callee.object.name === "React" && callee.property.type === import_utils32.AST_NODE_TYPES.Identifier && callee.property.name === "lazy";
           if (isLazyCall) {
             lazyComponents.add(node.id.name);
           }
         }
       },
       JSXOpeningElement(node) {
-        if (node.name.type === import_utils22.AST_NODE_TYPES.JSXIdentifier) {
+        if (node.name.type === import_utils32.AST_NODE_TYPES.JSXIdentifier) {
           const componentName = node.name.name;
           if (lazyComponents.has(componentName) && !isInsideSuspense(node)) {
             context.report({
@@ -1552,11 +2100,11 @@ var jsxRequireSuspense = createRule18({
 var jsx_require_suspense_default = jsxRequireSuspense;
 
 // src/rules/jsx-simple-props.ts
-var import_utils23 = require("@typescript-eslint/utils");
-var createRule19 = import_utils23.ESLintUtils.RuleCreator(
+var import_utils33 = require("@typescript-eslint/utils");
+var createRule25 = import_utils33.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var jsxSimpleProps = createRule19({
+var jsxSimpleProps = createRule25({
   name: "jsx-simple-props",
   meta: {
     type: "suggestion",
@@ -1571,25 +2119,25 @@ var jsxSimpleProps = createRule19({
   defaultOptions: [],
   create(context) {
     const allowedExpressionTypes = /* @__PURE__ */ new Set([
-      import_utils23.AST_NODE_TYPES.Identifier,
-      import_utils23.AST_NODE_TYPES.Literal,
-      import_utils23.AST_NODE_TYPES.JSXElement,
-      import_utils23.AST_NODE_TYPES.JSXFragment,
-      import_utils23.AST_NODE_TYPES.MemberExpression,
-      import_utils23.AST_NODE_TYPES.ArrowFunctionExpression,
-      import_utils23.AST_NODE_TYPES.FunctionExpression
+      import_utils33.AST_NODE_TYPES.Identifier,
+      import_utils33.AST_NODE_TYPES.Literal,
+      import_utils33.AST_NODE_TYPES.JSXElement,
+      import_utils33.AST_NODE_TYPES.JSXFragment,
+      import_utils33.AST_NODE_TYPES.MemberExpression,
+      import_utils33.AST_NODE_TYPES.ArrowFunctionExpression,
+      import_utils33.AST_NODE_TYPES.FunctionExpression
     ]);
     return {
       JSXAttribute(node) {
         if (!node.value) {
           return;
         }
-        if (node.value.type === import_utils23.AST_NODE_TYPES.Literal) {
+        if (node.value.type === import_utils33.AST_NODE_TYPES.Literal) {
           return;
         }
-        if (node.value.type === import_utils23.AST_NODE_TYPES.JSXExpressionContainer) {
+        if (node.value.type === import_utils33.AST_NODE_TYPES.JSXExpressionContainer) {
           const { expression } = node.value;
-          if (expression.type === import_utils23.AST_NODE_TYPES.JSXEmptyExpression) {
+          if (expression.type === import_utils33.AST_NODE_TYPES.JSXEmptyExpression) {
             return;
           }
           if (!allowedExpressionTypes.has(expression.type)) {
@@ -1606,8 +2154,8 @@ var jsxSimpleProps = createRule19({
 var jsx_simple_props_default = jsxSimpleProps;
 
 // src/rules/jsx-sort-props.ts
-var import_utils24 = require("@typescript-eslint/utils");
-var createRule20 = import_utils24.ESLintUtils.RuleCreator(
+var import_utils34 = require("@typescript-eslint/utils");
+var createRule26 = import_utils34.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var TYPE_GROUP = {
@@ -1621,15 +2169,15 @@ var TYPE_GROUP = {
   SHORTHAND: 8
 };
 var EXPRESSION_TYPE_TO_GROUP = /* @__PURE__ */ new Map([
-  [import_utils24.AST_NODE_TYPES.ObjectExpression, TYPE_GROUP.OBJECT_ARRAY],
-  [import_utils24.AST_NODE_TYPES.ArrayExpression, TYPE_GROUP.OBJECT_ARRAY],
-  [import_utils24.AST_NODE_TYPES.ArrowFunctionExpression, TYPE_GROUP.FUNCTION],
-  [import_utils24.AST_NODE_TYPES.FunctionExpression, TYPE_GROUP.FUNCTION],
-  [import_utils24.AST_NODE_TYPES.JSXElement, TYPE_GROUP.JSX],
-  [import_utils24.AST_NODE_TYPES.JSXFragment, TYPE_GROUP.JSX]
+  [import_utils34.AST_NODE_TYPES.ObjectExpression, TYPE_GROUP.OBJECT_ARRAY],
+  [import_utils34.AST_NODE_TYPES.ArrayExpression, TYPE_GROUP.OBJECT_ARRAY],
+  [import_utils34.AST_NODE_TYPES.ArrowFunctionExpression, TYPE_GROUP.FUNCTION],
+  [import_utils34.AST_NODE_TYPES.FunctionExpression, TYPE_GROUP.FUNCTION],
+  [import_utils34.AST_NODE_TYPES.JSXElement, TYPE_GROUP.JSX],
+  [import_utils34.AST_NODE_TYPES.JSXFragment, TYPE_GROUP.JSX]
 ]);
 function isHyphenatedName(node) {
-  return node.name.type === import_utils24.AST_NODE_TYPES.JSXIdentifier && node.name.name.includes("-");
+  return node.name.type === import_utils34.AST_NODE_TYPES.JSXIdentifier && node.name.name.includes("-");
 }
 function getStringGroup(node) {
   return isHyphenatedName(node) ? TYPE_GROUP.HYPHENATED_STRING : TYPE_GROUP.STRING;
@@ -1641,13 +2189,13 @@ function getLiteralValueGroup(value) {
   return TYPE_GROUP.NUMBER_BOOLEAN_NULL;
 }
 function getExpressionGroup(expression) {
-  if (expression.type === import_utils24.AST_NODE_TYPES.Literal) {
+  if (expression.type === import_utils34.AST_NODE_TYPES.Literal) {
     return getLiteralValueGroup(expression.value);
   }
-  if (expression.type === import_utils24.AST_NODE_TYPES.TemplateLiteral) {
+  if (expression.type === import_utils34.AST_NODE_TYPES.TemplateLiteral) {
     return null;
   }
-  if (expression.type === import_utils24.AST_NODE_TYPES.Identifier && expression.name === "undefined") {
+  if (expression.type === import_utils34.AST_NODE_TYPES.Identifier && expression.name === "undefined") {
     return TYPE_GROUP.NUMBER_BOOLEAN_NULL;
   }
   return EXPRESSION_TYPE_TO_GROUP.get(expression.type) ?? TYPE_GROUP.EXPRESSION;
@@ -1656,17 +2204,17 @@ function getTypeGroup(node) {
   if (node.value === null) {
     return TYPE_GROUP.SHORTHAND;
   }
-  if (node.value.type === import_utils24.AST_NODE_TYPES.Literal) {
+  if (node.value.type === import_utils34.AST_NODE_TYPES.Literal) {
     if (typeof node.value.value === "string") {
       return getStringGroup(node);
     }
     return TYPE_GROUP.NUMBER_BOOLEAN_NULL;
   }
-  if (node.value.type !== import_utils24.AST_NODE_TYPES.JSXExpressionContainer) {
+  if (node.value.type !== import_utils34.AST_NODE_TYPES.JSXExpressionContainer) {
     return null;
   }
   const { expression } = node.value;
-  if (expression.type === import_utils24.AST_NODE_TYPES.JSXEmptyExpression) {
+  if (expression.type === import_utils34.AST_NODE_TYPES.JSXEmptyExpression) {
     return null;
   }
   const group = getExpressionGroup(expression);
@@ -1678,7 +2226,7 @@ function getTypeGroup(node) {
 function hasUnsortedProps(attributes) {
   let lastGroup = 0;
   return attributes.some((attribute) => {
-    if (attribute.type === import_utils24.AST_NODE_TYPES.JSXSpreadAttribute) {
+    if (attribute.type === import_utils34.AST_NODE_TYPES.JSXSpreadAttribute) {
       lastGroup = 0;
       return false;
     }
@@ -1702,7 +2250,7 @@ function getSegments(attributes) {
   const result = [];
   let current = [];
   attributes.forEach((attr) => {
-    if (attr.type === import_utils24.AST_NODE_TYPES.JSXSpreadAttribute) {
+    if (attr.type === import_utils34.AST_NODE_TYPES.JSXSpreadAttribute) {
       if (current.length > 0) {
         result.push(current);
         current = [];
@@ -1716,7 +2264,7 @@ function getSegments(attributes) {
   }
   return result;
 }
-var jsxSortProps = createRule20({
+var jsxSortProps = createRule26({
   name: "jsx-sort-props",
   meta: {
     type: "suggestion",
@@ -1751,11 +2299,11 @@ var jsxSortProps = createRule20({
 var jsx_sort_props_default = jsxSortProps;
 
 // src/rules/jsx-spread-props-last.ts
-var import_utils25 = require("@typescript-eslint/utils");
-var createRule21 = import_utils25.ESLintUtils.RuleCreator(
+var import_utils35 = require("@typescript-eslint/utils");
+var createRule27 = import_utils35.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var jsxSpreadPropsLast = createRule21({
+var jsxSpreadPropsLast = createRule27({
   name: "jsx-spread-props-last",
   meta: {
     type: "suggestion",
@@ -1774,12 +2322,12 @@ var jsxSpreadPropsLast = createRule21({
         const { attributes } = node;
         let lastNonSpreadIndex = -1;
         attributes.forEach((attribute, index) => {
-          if (attribute.type !== import_utils25.AST_NODE_TYPES.JSXSpreadAttribute) {
+          if (attribute.type !== import_utils35.AST_NODE_TYPES.JSXSpreadAttribute) {
             lastNonSpreadIndex = index;
           }
         });
         attributes.forEach((attribute, index) => {
-          if (attribute.type === import_utils25.AST_NODE_TYPES.JSXSpreadAttribute && index < lastNonSpreadIndex) {
+          if (attribute.type === import_utils35.AST_NODE_TYPES.JSXSpreadAttribute && index < lastNonSpreadIndex) {
             context.report({
               node: attribute,
               messageId: "spreadNotLast"
@@ -1793,12 +2341,12 @@ var jsxSpreadPropsLast = createRule21({
 var jsx_spread_props_last_default = jsxSpreadPropsLast;
 
 // src/rules/newline-after-multiline-block.ts
-var import_utils26 = require("@typescript-eslint/utils");
-var createRule22 = import_utils26.ESLintUtils.RuleCreator(
+var import_utils36 = require("@typescript-eslint/utils");
+var createRule28 = import_utils36.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 function isImportDeclaration(node) {
-  return node.type === import_utils26.AST_NODE_TYPES.ImportDeclaration;
+  return node.type === import_utils36.AST_NODE_TYPES.ImportDeclaration;
 }
 function checkStatements(statements, context) {
   const { sourceCode } = context;
@@ -1833,7 +2381,7 @@ function checkStatements(statements, context) {
     }
   });
 }
-var newlineAfterMultilineBlock = createRule22({
+var newlineAfterMultilineBlock = createRule28({
   name: "newline-after-multiline-block",
   meta: {
     type: "layout",
@@ -1861,11 +2409,11 @@ var newlineAfterMultilineBlock = createRule22({
 var newline_after_multiline_block_default = newlineAfterMultilineBlock;
 
 // src/rules/newline-before-return.ts
-var import_utils27 = require("@typescript-eslint/utils");
-var createRule23 = import_utils27.ESLintUtils.RuleCreator(
+var import_utils37 = require("@typescript-eslint/utils");
+var createRule29 = import_utils37.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var newlineBeforeReturn = createRule23({
+var newlineBeforeReturn = createRule29({
   name: "newline-before-return",
   meta: {
     type: "layout",
@@ -1883,7 +2431,7 @@ var newlineBeforeReturn = createRule23({
     const { sourceCode } = context;
     function checkReturnStatement(node) {
       const { parent } = node;
-      if (!parent || parent.type !== import_utils27.AST_NODE_TYPES.BlockStatement) {
+      if (!parent || parent.type !== import_utils37.AST_NODE_TYPES.BlockStatement) {
         return;
       }
       const { body: statements } = parent;
@@ -1920,11 +2468,11 @@ var newlineBeforeReturn = createRule23({
 var newline_before_return_default = newlineBeforeReturn;
 
 // src/rules/no-complex-inline-return.ts
-var import_utils28 = require("@typescript-eslint/utils");
-var createRule24 = import_utils28.ESLintUtils.RuleCreator(
+var import_utils38 = require("@typescript-eslint/utils");
+var createRule30 = import_utils38.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var noComplexInlineReturn = createRule24({
+var noComplexInlineReturn = createRule30({
   name: "no-complex-inline-return",
   meta: {
     type: "suggestion",
@@ -1940,13 +2488,13 @@ var noComplexInlineReturn = createRule24({
   create(context) {
     const isComplexExpression = (node) => {
       if (!node) return false;
-      if (node.type === import_utils28.AST_NODE_TYPES.ConditionalExpression) {
+      if (node.type === import_utils38.AST_NODE_TYPES.ConditionalExpression) {
         return true;
       }
-      if (node.type === import_utils28.AST_NODE_TYPES.LogicalExpression) {
+      if (node.type === import_utils38.AST_NODE_TYPES.LogicalExpression) {
         return true;
       }
-      if (node.type === import_utils28.AST_NODE_TYPES.NewExpression) {
+      if (node.type === import_utils38.AST_NODE_TYPES.NewExpression) {
         return true;
       }
       return false;
@@ -1966,11 +2514,11 @@ var noComplexInlineReturn = createRule24({
 var no_complex_inline_return_default = noComplexInlineReturn;
 
 // src/rules/no-direct-date.ts
-var import_utils29 = require("@typescript-eslint/utils");
-var createRule25 = import_utils29.ESLintUtils.RuleCreator(
+var import_utils39 = require("@typescript-eslint/utils");
+var createRule31 = import_utils39.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var noDirectDate = createRule25({
+var noDirectDate = createRule31({
   name: "no-direct-date",
   meta: {
     type: "problem",
@@ -1988,7 +2536,7 @@ var noDirectDate = createRule25({
   create(context) {
     return {
       NewExpression(node) {
-        if (node.callee.type === import_utils29.AST_NODE_TYPES.Identifier && node.callee.name === "Date") {
+        if (node.callee.type === import_utils39.AST_NODE_TYPES.Identifier && node.callee.name === "Date") {
           context.report({
             node,
             messageId: "noNewDate"
@@ -1996,7 +2544,7 @@ var noDirectDate = createRule25({
         }
       },
       CallExpression(node) {
-        if (node.callee.type === import_utils29.AST_NODE_TYPES.MemberExpression && node.callee.object.type === import_utils29.AST_NODE_TYPES.Identifier && node.callee.object.name === "Date" && node.callee.property.type === import_utils29.AST_NODE_TYPES.Identifier) {
+        if (node.callee.type === import_utils39.AST_NODE_TYPES.MemberExpression && node.callee.object.type === import_utils39.AST_NODE_TYPES.Identifier && node.callee.object.name === "Date" && node.callee.property.type === import_utils39.AST_NODE_TYPES.Identifier) {
           const methodName = node.callee.property.name;
           if (methodName === "now") {
             context.report({
@@ -2019,11 +2567,11 @@ var no_direct_date_default = noDirectDate;
 
 // src/rules/no-emoji.ts
 var import_emoji_regex = __toESM(require("emoji-regex"), 1);
-var import_utils30 = require("@typescript-eslint/utils");
-var createRule26 = import_utils30.ESLintUtils.RuleCreator(
+var import_utils40 = require("@typescript-eslint/utils");
+var createRule32 = import_utils40.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var noEmoji = createRule26({
+var noEmoji = createRule32({
   name: "no-emoji",
   meta: {
     type: "problem",
@@ -2057,11 +2605,11 @@ var noEmoji = createRule26({
 var no_emoji_default = noEmoji;
 
 // src/rules/no-env-fallback.ts
-var import_utils31 = require("@typescript-eslint/utils");
-var createRule27 = import_utils31.ESLintUtils.RuleCreator(
+var import_utils41 = require("@typescript-eslint/utils");
+var createRule33 = import_utils41.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var noEnvFallback = createRule27({
+var noEnvFallback = createRule33({
   name: "no-env-fallback",
   meta: {
     type: "problem",
@@ -2076,16 +2624,16 @@ var noEnvFallback = createRule27({
   defaultOptions: [],
   create(context) {
     const isProcessEnvAccess = (node) => {
-      if (node.type !== import_utils31.AST_NODE_TYPES.MemberExpression) {
+      if (node.type !== import_utils41.AST_NODE_TYPES.MemberExpression) {
         return false;
       }
       const { object } = node;
-      if (object.type !== import_utils31.AST_NODE_TYPES.MemberExpression) {
+      if (object.type !== import_utils41.AST_NODE_TYPES.MemberExpression) {
         return false;
       }
       const processNode = object.object;
       const envNode = object.property;
-      return processNode.type === import_utils31.AST_NODE_TYPES.Identifier && processNode.name === "process" && envNode.type === import_utils31.AST_NODE_TYPES.Identifier && envNode.name === "env";
+      return processNode.type === import_utils41.AST_NODE_TYPES.Identifier && processNode.name === "process" && envNode.type === import_utils41.AST_NODE_TYPES.Identifier && envNode.name === "env";
     };
     return {
       LogicalExpression(node) {
@@ -2110,15 +2658,15 @@ var noEnvFallback = createRule27({
 var no_env_fallback_default = noEnvFallback;
 
 // src/rules/no-ghost-wrapper.ts
-var import_utils32 = require("@typescript-eslint/utils");
-var createRule28 = import_utils32.ESLintUtils.RuleCreator(
+var import_utils42 = require("@typescript-eslint/utils");
+var createRule34 = import_utils42.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var GHOST_TAGS = /* @__PURE__ */ new Set(["div", "span"]);
 function isKeyAttribute(attribute) {
-  return attribute.type === import_utils32.AST_NODE_TYPES.JSXAttribute && attribute.name.type === import_utils32.AST_NODE_TYPES.JSXIdentifier && attribute.name.name === "key";
+  return attribute.type === import_utils42.AST_NODE_TYPES.JSXAttribute && attribute.name.type === import_utils42.AST_NODE_TYPES.JSXIdentifier && attribute.name.name === "key";
 }
-var noGhostWrapper = createRule28({
+var noGhostWrapper = createRule34({
   name: "no-ghost-wrapper",
   meta: {
     type: "problem",
@@ -2134,7 +2682,7 @@ var noGhostWrapper = createRule28({
   create(context) {
     return {
       JSXOpeningElement(node) {
-        if (node.name.type !== import_utils32.AST_NODE_TYPES.JSXIdentifier) {
+        if (node.name.type !== import_utils42.AST_NODE_TYPES.JSXIdentifier) {
           return;
         }
         const tagName = node.name.name;
@@ -2155,12 +2703,92 @@ var noGhostWrapper = createRule28({
 });
 var no_ghost_wrapper_default = noGhostWrapper;
 
+// src/rules/no-helper-function-in-hook.ts
+var import_utils43 = require("@typescript-eslint/utils");
+var createRule35 = import_utils43.ESLintUtils.RuleCreator(
+  (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
+);
+var noHelperFunctionInHook = createRule35({
+  name: "no-helper-function-in-hook",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Disallow non-hook helper function definitions in hook files"
+    },
+    messages: {
+      noHelperFunction: "Helper functions must not be defined in hook files. Extract to a separate utility file."
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    function isAtProgramLevel(node) {
+      const { parent } = node;
+      if (parent === void 0) return false;
+      if (parent.type === import_utils43.AST_NODE_TYPES.Program) return true;
+      if (parent.type !== import_utils43.AST_NODE_TYPES.ExportNamedDeclaration) return false;
+      return parent.parent?.type === import_utils43.AST_NODE_TYPES.Program;
+    }
+    return {
+      FunctionDeclaration(node) {
+        if (!isAtProgramLevel(node)) return;
+        if (node.id !== null && node.id.name.startsWith("use")) return;
+        context.report({ node, messageId: "noHelperFunction" });
+      },
+      VariableDeclarator(node) {
+        if (node.parent.type !== import_utils43.AST_NODE_TYPES.VariableDeclaration) return;
+        if (!isAtProgramLevel(node.parent)) return;
+        if (node.init === null || node.init.type !== import_utils43.AST_NODE_TYPES.ArrowFunctionExpression && node.init.type !== import_utils43.AST_NODE_TYPES.FunctionExpression)
+          return;
+        if (node.id.type === import_utils43.AST_NODE_TYPES.Identifier && node.id.name.startsWith("use")) return;
+        context.report({ node, messageId: "noHelperFunction" });
+      }
+    };
+  }
+});
+var no_helper_function_in_hook_default = noHelperFunctionInHook;
+
+// src/rules/no-helper-function-in-test.ts
+var import_utils44 = require("@typescript-eslint/utils");
+var createRule36 = import_utils44.ESLintUtils.RuleCreator(
+  (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
+);
+var noHelperFunctionInTest = createRule36({
+  name: "no-helper-function-in-test",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Disallow helper function definitions in test files"
+    },
+    messages: {
+      noHelperFunction: "Helper functions must not be defined in test files. Extract to a separate utility file."
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      FunctionDeclaration(node) {
+        if (node.parent.type === import_utils44.AST_NODE_TYPES.Program) {
+          context.report({ node, messageId: "noHelperFunction" });
+        }
+      },
+      VariableDeclarator(node) {
+        if (node.parent.type === import_utils44.AST_NODE_TYPES.VariableDeclaration && node.parent.parent.type === import_utils44.AST_NODE_TYPES.Program && node.init !== null && (node.init.type === import_utils44.AST_NODE_TYPES.ArrowFunctionExpression || node.init.type === import_utils44.AST_NODE_TYPES.FunctionExpression)) {
+          context.report({ node, messageId: "noHelperFunction" });
+        }
+      }
+    };
+  }
+});
+var no_helper_function_in_test_default = noHelperFunctionInTest;
+
 // src/rules/no-inline-default-export.ts
-var import_utils33 = require("@typescript-eslint/utils");
-var createRule29 = import_utils33.ESLintUtils.RuleCreator(
+var import_utils45 = require("@typescript-eslint/utils");
+var createRule37 = import_utils45.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var noInlineDefaultExport = createRule29({
+var noInlineDefaultExport = createRule37({
   name: "no-inline-default-export",
   meta: {
     type: "suggestion",
@@ -2179,7 +2807,7 @@ var noInlineDefaultExport = createRule29({
     return {
       ExportDefaultDeclaration(node) {
         const { declaration } = node;
-        if (declaration.type === import_utils33.AST_NODE_TYPES.FunctionDeclaration) {
+        if (declaration.type === import_utils45.AST_NODE_TYPES.FunctionDeclaration) {
           if (declaration.id) {
             context.report({
               node,
@@ -2194,7 +2822,7 @@ var noInlineDefaultExport = createRule29({
             });
           }
         }
-        if (declaration.type === import_utils33.AST_NODE_TYPES.ClassDeclaration) {
+        if (declaration.type === import_utils45.AST_NODE_TYPES.ClassDeclaration) {
           if (declaration.id) {
             context.report({
               node,
@@ -2209,7 +2837,7 @@ var noInlineDefaultExport = createRule29({
             });
           }
         }
-        if (declaration.type === import_utils33.AST_NODE_TYPES.ArrowFunctionExpression || declaration.type === import_utils33.AST_NODE_TYPES.FunctionExpression) {
+        if (declaration.type === import_utils45.AST_NODE_TYPES.ArrowFunctionExpression || declaration.type === import_utils45.AST_NODE_TYPES.FunctionExpression) {
           context.report({
             node,
             messageId: "noAnonymousDefaultExport",
@@ -2222,14 +2850,14 @@ var noInlineDefaultExport = createRule29({
         if (!declaration) {
           return;
         }
-        if (declaration.type === import_utils33.AST_NODE_TYPES.FunctionDeclaration && declaration.id) {
+        if (declaration.type === import_utils45.AST_NODE_TYPES.FunctionDeclaration && declaration.id) {
           context.report({
             node,
             messageId: "noInlineNamedExport",
             data: { type: "function", name: declaration.id.name }
           });
         }
-        if (declaration.type === import_utils33.AST_NODE_TYPES.ClassDeclaration && declaration.id) {
+        if (declaration.type === import_utils45.AST_NODE_TYPES.ClassDeclaration && declaration.id) {
           context.report({
             node,
             messageId: "noInlineNamedExport",
@@ -2243,27 +2871,27 @@ var noInlineDefaultExport = createRule29({
 var no_inline_default_export_default = noInlineDefaultExport;
 
 // src/rules/no-inline-nested-object.ts
-var import_utils34 = require("@typescript-eslint/utils");
-var createRule30 = import_utils34.ESLintUtils.RuleCreator(
+var import_utils46 = require("@typescript-eslint/utils");
+var createRule38 = import_utils46.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 function isObjectOrArray(node) {
-  return node.type === import_utils34.AST_NODE_TYPES.ObjectExpression || node.type === import_utils34.AST_NODE_TYPES.ArrayExpression || node.type === import_utils34.AST_NODE_TYPES.TSAsExpression;
+  return node.type === import_utils46.AST_NODE_TYPES.ObjectExpression || node.type === import_utils46.AST_NODE_TYPES.ArrayExpression || node.type === import_utils46.AST_NODE_TYPES.TSAsExpression;
 }
 function getInnerExpression(node) {
-  if (node.type === import_utils34.AST_NODE_TYPES.TSAsExpression) {
+  if (node.type === import_utils46.AST_NODE_TYPES.TSAsExpression) {
     return getInnerExpression(node.expression);
   }
   return node;
 }
 function isNestedStructure(node) {
   const inner = getInnerExpression(node);
-  return inner.type === import_utils34.AST_NODE_TYPES.ObjectExpression || inner.type === import_utils34.AST_NODE_TYPES.ArrayExpression;
+  return inner.type === import_utils46.AST_NODE_TYPES.ObjectExpression || inner.type === import_utils46.AST_NODE_TYPES.ArrayExpression;
 }
 function containsNestedStructure(node) {
-  if (node.type === import_utils34.AST_NODE_TYPES.ObjectExpression) {
+  if (node.type === import_utils46.AST_NODE_TYPES.ObjectExpression) {
     return node.properties.some((prop) => {
-      if (prop.type !== import_utils34.AST_NODE_TYPES.Property) return false;
+      if (prop.type !== import_utils46.AST_NODE_TYPES.Property) return false;
       return isNestedStructure(prop.value);
     });
   }
@@ -2272,7 +2900,7 @@ function containsNestedStructure(node) {
     return isNestedStructure(el);
   });
 }
-var noInlineNestedObject = createRule30({
+var noInlineNestedObject = createRule38({
   name: "no-inline-nested-object",
   meta: {
     type: "layout",
@@ -2294,7 +2922,7 @@ var noInlineNestedObject = createRule30({
           return;
         }
         const valueNode = getInnerExpression(node.value);
-        if (valueNode.type !== import_utils34.AST_NODE_TYPES.ObjectExpression && valueNode.type !== import_utils34.AST_NODE_TYPES.ArrayExpression) {
+        if (valueNode.type !== import_utils46.AST_NODE_TYPES.ObjectExpression && valueNode.type !== import_utils46.AST_NODE_TYPES.ArrayExpression) {
           return;
         }
         if (!valueNode.loc) {
@@ -2307,7 +2935,7 @@ var noInlineNestedObject = createRule30({
         if (!containsNestedStructure(valueNode)) {
           return;
         }
-        const elements = valueNode.type === import_utils34.AST_NODE_TYPES.ObjectExpression ? valueNode.properties : valueNode.elements;
+        const elements = valueNode.type === import_utils46.AST_NODE_TYPES.ObjectExpression ? valueNode.properties : valueNode.elements;
         context.report({
           node: valueNode,
           messageId: "requireMultiline",
@@ -2320,7 +2948,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 === import_utils34.AST_NODE_TYPES.ObjectExpression;
+            const isObject = valueNode.type === import_utils46.AST_NODE_TYPES.ObjectExpression;
             const openChar = isObject ? "{" : "[";
             const closeChar = isObject ? "}" : "]";
             const formattedElements = elementTexts.map((text) => `${innerIndent}${text},`).join("\n");
@@ -2337,20 +2965,20 @@ ${indent}${closeChar}`;
 var no_inline_nested_object_default = noInlineNestedObject;
 
 // src/rules/no-inline-return-properties.ts
-var import_utils35 = require("@typescript-eslint/utils");
-var createRule31 = import_utils35.ESLintUtils.RuleCreator(
+var import_utils47 = require("@typescript-eslint/utils");
+var createRule39 = import_utils47.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var isShorthandProperty = (property) => {
-  if (property.type === import_utils35.AST_NODE_TYPES.SpreadElement) {
+  if (property.type === import_utils47.AST_NODE_TYPES.SpreadElement) {
     return true;
   }
-  if (property.type !== import_utils35.AST_NODE_TYPES.Property) {
+  if (property.type !== import_utils47.AST_NODE_TYPES.Property) {
     return false;
   }
   return property.shorthand;
 };
-var noInlineReturnProperties = createRule31({
+var noInlineReturnProperties = createRule39({
   name: "no-inline-return-properties",
   meta: {
     type: "suggestion",
@@ -2366,20 +2994,20 @@ var noInlineReturnProperties = createRule31({
   create(context) {
     return {
       ReturnStatement(node) {
-        if (!node.argument || node.argument.type !== import_utils35.AST_NODE_TYPES.ObjectExpression) {
+        if (!node.argument || node.argument.type !== import_utils47.AST_NODE_TYPES.ObjectExpression) {
           return;
         }
         node.argument.properties.forEach((property) => {
           if (isShorthandProperty(property)) {
             return;
           }
-          if (property.type !== import_utils35.AST_NODE_TYPES.Property) {
+          if (property.type !== import_utils47.AST_NODE_TYPES.Property) {
             return;
           }
           let keyName = null;
-          if (property.key.type === import_utils35.AST_NODE_TYPES.Identifier) {
+          if (property.key.type === import_utils47.AST_NODE_TYPES.Identifier) {
             keyName = property.key.name;
-          } else if (property.key.type === import_utils35.AST_NODE_TYPES.Literal) {
+          } else if (property.key.type === import_utils47.AST_NODE_TYPES.Literal) {
             keyName = String(property.key.value);
           }
           context.report({
@@ -2395,12 +3023,12 @@ var noInlineReturnProperties = createRule31({
 var no_inline_return_properties_default = noInlineReturnProperties;
 
 // src/rules/no-inline-type-import.ts
-var import_utils36 = require("@typescript-eslint/utils");
-var createRule32 = import_utils36.ESLintUtils.RuleCreator(
+var import_utils48 = require("@typescript-eslint/utils");
+var createRule40 = import_utils48.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var isInlineTypeSpecifier = (specifier) => specifier.type === import_utils36.AST_NODE_TYPES.ImportSpecifier && specifier.importKind === "type";
-var noInlineTypeImport = createRule32({
+var isInlineTypeSpecifier = (specifier) => specifier.type === import_utils48.AST_NODE_TYPES.ImportSpecifier && specifier.importKind === "type";
+var noInlineTypeImport = createRule40({
   name: "no-inline-type-import",
   meta: {
     type: "suggestion",
@@ -2437,7 +3065,7 @@ var noInlineTypeImport = createRule32({
             );
             const typeImport = `import type { ${typeSpecifierTexts.join(", ")} } from ${sourceText};`;
             const valueSpecifiers = node.specifiers.filter(
-              (specifier) => !(specifier.type === import_utils36.AST_NODE_TYPES.ImportSpecifier && specifier.importKind === "type")
+              (specifier) => !(specifier.type === import_utils48.AST_NODE_TYPES.ImportSpecifier && specifier.importKind === "type")
             );
             if (valueSpecifiers.length === 0) {
               return fixer.replaceText(node, typeImport);
@@ -2445,11 +3073,11 @@ var noInlineTypeImport = createRule32({
             const parts = [];
             const namedValueSpecifiers = [];
             for (const specifier of valueSpecifiers) {
-              if (specifier.type === import_utils36.AST_NODE_TYPES.ImportDefaultSpecifier) {
+              if (specifier.type === import_utils48.AST_NODE_TYPES.ImportDefaultSpecifier) {
                 parts.push(specifier.local.name);
-              } else if (specifier.type === import_utils36.AST_NODE_TYPES.ImportNamespaceSpecifier) {
+              } else if (specifier.type === import_utils48.AST_NODE_TYPES.ImportNamespaceSpecifier) {
                 parts.push(`* as ${specifier.local.name}`);
-              } else if (specifier.type === import_utils36.AST_NODE_TYPES.ImportSpecifier) {
+              } else if (specifier.type === import_utils48.AST_NODE_TYPES.ImportSpecifier) {
                 namedValueSpecifiers.push(specifier);
               }
             }
@@ -2469,8 +3097,8 @@ ${typeImport}`);
 var no_inline_type_import_default = noInlineTypeImport;
 
 // src/rules/no-lazy-identifiers.ts
-var import_utils37 = require("@typescript-eslint/utils");
-var createRule33 = import_utils37.ESLintUtils.RuleCreator(
+var import_utils49 = require("@typescript-eslint/utils");
+var createRule41 = import_utils49.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var KEYBOARD_ROWS = ["qwertyuiop", "asdfghjkl", "zxcvbnm", "1234567890"];
@@ -2511,7 +3139,7 @@ var isLazyIdentifier = (name) => {
   }
   return false;
 };
-var noLazyIdentifiers = createRule33({
+var noLazyIdentifiers = createRule41({
   name: "no-lazy-identifiers",
   meta: {
     type: "problem",
@@ -2537,27 +3165,27 @@ var noLazyIdentifiers = createRule33({
       });
     };
     const checkPattern = (pattern) => {
-      if (pattern.type === import_utils37.AST_NODE_TYPES.Identifier) {
+      if (pattern.type === import_utils49.AST_NODE_TYPES.Identifier) {
         checkIdentifier(pattern);
-      } else if (pattern.type === import_utils37.AST_NODE_TYPES.ObjectPattern) {
+      } else if (pattern.type === import_utils49.AST_NODE_TYPES.ObjectPattern) {
         pattern.properties.forEach((prop) => {
-          if (prop.type === import_utils37.AST_NODE_TYPES.Property && prop.value.type === import_utils37.AST_NODE_TYPES.Identifier) {
+          if (prop.type === import_utils49.AST_NODE_TYPES.Property && prop.value.type === import_utils49.AST_NODE_TYPES.Identifier) {
             checkIdentifier(prop.value);
-          } else if (prop.type === import_utils37.AST_NODE_TYPES.RestElement && prop.argument.type === import_utils37.AST_NODE_TYPES.Identifier) {
+          } else if (prop.type === import_utils49.AST_NODE_TYPES.RestElement && prop.argument.type === import_utils49.AST_NODE_TYPES.Identifier) {
             checkIdentifier(prop.argument);
           }
         });
-      } else if (pattern.type === import_utils37.AST_NODE_TYPES.ArrayPattern) {
+      } else if (pattern.type === import_utils49.AST_NODE_TYPES.ArrayPattern) {
         pattern.elements.forEach((element) => {
-          if (element?.type === import_utils37.AST_NODE_TYPES.Identifier) {
+          if (element?.type === import_utils49.AST_NODE_TYPES.Identifier) {
             checkIdentifier(element);
-          } else if (element?.type === import_utils37.AST_NODE_TYPES.RestElement && element.argument.type === import_utils37.AST_NODE_TYPES.Identifier) {
+          } else if (element?.type === import_utils49.AST_NODE_TYPES.RestElement && element.argument.type === import_utils49.AST_NODE_TYPES.Identifier) {
             checkIdentifier(element.argument);
           }
         });
-      } else if (pattern.type === import_utils37.AST_NODE_TYPES.AssignmentPattern && pattern.left.type === import_utils37.AST_NODE_TYPES.Identifier) {
+      } else if (pattern.type === import_utils49.AST_NODE_TYPES.AssignmentPattern && pattern.left.type === import_utils49.AST_NODE_TYPES.Identifier) {
         checkIdentifier(pattern.left);
-      } else if (pattern.type === import_utils37.AST_NODE_TYPES.RestElement && pattern.argument.type === import_utils37.AST_NODE_TYPES.Identifier) {
+      } else if (pattern.type === import_utils49.AST_NODE_TYPES.RestElement && pattern.argument.type === import_utils49.AST_NODE_TYPES.Identifier) {
         checkIdentifier(pattern.argument);
       }
     };
@@ -2602,11 +3230,11 @@ var noLazyIdentifiers = createRule33({
 var no_lazy_identifiers_default = noLazyIdentifiers;
 
 // src/rules/no-logic-in-params.ts
-var import_utils38 = require("@typescript-eslint/utils");
-var createRule34 = import_utils38.ESLintUtils.RuleCreator(
+var import_utils50 = require("@typescript-eslint/utils");
+var createRule42 = import_utils50.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var noLogicInParams = createRule34({
+var noLogicInParams = createRule42({
   name: "no-logic-in-params",
   meta: {
     type: "suggestion",
@@ -2621,20 +3249,20 @@ var noLogicInParams = createRule34({
   defaultOptions: [],
   create(context) {
     const isComplexExpression = (node) => {
-      if (node.type === import_utils38.AST_NODE_TYPES.SpreadElement) {
+      if (node.type === import_utils50.AST_NODE_TYPES.SpreadElement) {
         return false;
       }
-      if (node.type === import_utils38.AST_NODE_TYPES.ConditionalExpression) {
+      if (node.type === import_utils50.AST_NODE_TYPES.ConditionalExpression) {
         return true;
       }
-      if (node.type === import_utils38.AST_NODE_TYPES.LogicalExpression) {
+      if (node.type === import_utils50.AST_NODE_TYPES.LogicalExpression) {
         return true;
       }
-      if (node.type === import_utils38.AST_NODE_TYPES.BinaryExpression) {
+      if (node.type === import_utils50.AST_NODE_TYPES.BinaryExpression) {
         const logicalOperators = ["==", "===", "!=", "!==", "<", ">", "<=", ">=", "in", "instanceof"];
         return logicalOperators.includes(node.operator);
       }
-      if (node.type === import_utils38.AST_NODE_TYPES.UnaryExpression) {
+      if (node.type === import_utils50.AST_NODE_TYPES.UnaryExpression) {
         return node.operator === "!";
       }
       return false;
@@ -2647,7 +3275,7 @@ var noLogicInParams = createRule34({
             messageId: "noLogicInParams"
           });
         }
-        if (arg.type === import_utils38.AST_NODE_TYPES.ArrayExpression) {
+        if (arg.type === import_utils50.AST_NODE_TYPES.ArrayExpression) {
           arg.elements.forEach((element) => {
             if (element && isComplexExpression(element)) {
               context.report({
@@ -2672,46 +3300,46 @@ var noLogicInParams = createRule34({
 var no_logic_in_params_default = noLogicInParams;
 
 // src/rules/no-misleading-constant-case.ts
-var import_utils39 = require("@typescript-eslint/utils");
-var createRule35 = import_utils39.ESLintUtils.RuleCreator(
+var import_utils51 = require("@typescript-eslint/utils");
+var createRule43 = import_utils51.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var SCREAMING_SNAKE_CASE_REGEX3 = /^[A-Z][A-Z0-9]*(?:_[A-Z0-9]+)*$/;
-var isAsConstAssertion = (node) => node.type === import_utils39.AST_NODE_TYPES.TSAsExpression && node.typeAnnotation.type === import_utils39.AST_NODE_TYPES.TSTypeReference && node.typeAnnotation.typeName.type === import_utils39.AST_NODE_TYPES.Identifier && node.typeAnnotation.typeName.name === "const";
+var isAsConstAssertion = (node) => node.type === import_utils51.AST_NODE_TYPES.TSAsExpression && node.typeAnnotation.type === import_utils51.AST_NODE_TYPES.TSTypeReference && node.typeAnnotation.typeName.type === import_utils51.AST_NODE_TYPES.Identifier && node.typeAnnotation.typeName.name === "const";
 var isStaticValue2 = (init) => {
   if (isAsConstAssertion(init)) {
     return true;
   }
-  if (init.type === import_utils39.AST_NODE_TYPES.Literal) {
+  if (init.type === import_utils51.AST_NODE_TYPES.Literal) {
     return true;
   }
-  if (init.type === import_utils39.AST_NODE_TYPES.UnaryExpression && init.argument.type === import_utils39.AST_NODE_TYPES.Literal) {
+  if (init.type === import_utils51.AST_NODE_TYPES.UnaryExpression && init.argument.type === import_utils51.AST_NODE_TYPES.Literal) {
     return true;
   }
-  if (init.type === import_utils39.AST_NODE_TYPES.TemplateLiteral && init.expressions.length === 0) {
+  if (init.type === import_utils51.AST_NODE_TYPES.TemplateLiteral && init.expressions.length === 0) {
     return true;
   }
-  if (init.type === import_utils39.AST_NODE_TYPES.ArrayExpression) {
-    return init.elements.every((el) => el !== null && el.type !== import_utils39.AST_NODE_TYPES.SpreadElement && isStaticValue2(el));
+  if (init.type === import_utils51.AST_NODE_TYPES.ArrayExpression) {
+    return init.elements.every((el) => el !== null && el.type !== import_utils51.AST_NODE_TYPES.SpreadElement && isStaticValue2(el));
   }
-  if (init.type === import_utils39.AST_NODE_TYPES.ObjectExpression) {
+  if (init.type === import_utils51.AST_NODE_TYPES.ObjectExpression) {
     return init.properties.every(
-      (prop) => prop.type === import_utils39.AST_NODE_TYPES.Property && isStaticValue2(prop.value)
+      (prop) => prop.type === import_utils51.AST_NODE_TYPES.Property && isStaticValue2(prop.value)
     );
   }
   return false;
 };
 var isGlobalScope3 = (node) => {
   const { parent } = node;
-  if (parent.type === import_utils39.AST_NODE_TYPES.Program) {
+  if (parent.type === import_utils51.AST_NODE_TYPES.Program) {
     return true;
   }
-  if (parent.type === import_utils39.AST_NODE_TYPES.ExportNamedDeclaration && parent.parent?.type === import_utils39.AST_NODE_TYPES.Program) {
+  if (parent.type === import_utils51.AST_NODE_TYPES.ExportNamedDeclaration && parent.parent?.type === import_utils51.AST_NODE_TYPES.Program) {
     return true;
   }
   return false;
 };
-var noMisleadingConstantCase = createRule35({
+var noMisleadingConstantCase = createRule43({
   name: "no-misleading-constant-case",
   meta: {
     type: "suggestion",
@@ -2730,7 +3358,7 @@ var noMisleadingConstantCase = createRule35({
     return {
       VariableDeclaration(node) {
         node.declarations.forEach((declarator) => {
-          if (declarator.id.type !== import_utils39.AST_NODE_TYPES.Identifier) {
+          if (declarator.id.type !== import_utils51.AST_NODE_TYPES.Identifier) {
             return;
           }
           const { name } = declarator.id;
@@ -2771,11 +3399,11 @@ var noMisleadingConstantCase = createRule35({
 var no_misleading_constant_case_default = noMisleadingConstantCase;
 
 // src/rules/no-nested-interface-declaration.ts
-var import_utils40 = require("@typescript-eslint/utils");
-var createRule36 = import_utils40.ESLintUtils.RuleCreator(
+var import_utils52 = require("@typescript-eslint/utils");
+var createRule44 = import_utils52.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var noNestedInterfaceDeclaration = createRule36({
+var noNestedInterfaceDeclaration = createRule44({
   name: "no-nested-interface-declaration",
   meta: {
     type: "suggestion",
@@ -2796,15 +3424,15 @@ var noNestedInterfaceDeclaration = createRule36({
           return;
         }
         const { typeAnnotation } = node.typeAnnotation;
-        if (typeAnnotation.type === import_utils40.AST_NODE_TYPES.TSTypeLiteral) {
+        if (typeAnnotation.type === import_utils52.AST_NODE_TYPES.TSTypeLiteral) {
           context.report({
             node: typeAnnotation,
             messageId: "noNestedInterface"
           });
           return;
         }
-        if (typeAnnotation.type === import_utils40.AST_NODE_TYPES.TSArrayType) {
-          if (typeAnnotation.elementType.type === import_utils40.AST_NODE_TYPES.TSTypeLiteral) {
+        if (typeAnnotation.type === import_utils52.AST_NODE_TYPES.TSArrayType) {
+          if (typeAnnotation.elementType.type === import_utils52.AST_NODE_TYPES.TSTypeLiteral) {
             context.report({
               node: typeAnnotation.elementType,
               messageId: "noNestedInterface"
@@ -2812,9 +3440,9 @@ var noNestedInterfaceDeclaration = createRule36({
           }
           return;
         }
-        if (typeAnnotation.type === import_utils40.AST_NODE_TYPES.TSTypeReference && typeAnnotation.typeArguments) {
+        if (typeAnnotation.type === import_utils52.AST_NODE_TYPES.TSTypeReference && typeAnnotation.typeArguments) {
           typeAnnotation.typeArguments.params.forEach((param) => {
-            if (param.type === import_utils40.AST_NODE_TYPES.TSTypeLiteral) {
+            if (param.type === import_utils52.AST_NODE_TYPES.TSTypeLiteral) {
               context.report({
                 node: param,
                 messageId: "noNestedInterface"
@@ -2829,11 +3457,11 @@ var noNestedInterfaceDeclaration = createRule36({
 var no_nested_interface_declaration_default = noNestedInterfaceDeclaration;
 
 // src/rules/no-nested-ternary.ts
-var import_utils41 = require("@typescript-eslint/utils");
-var createRule37 = import_utils41.ESLintUtils.RuleCreator(
+var import_utils53 = require("@typescript-eslint/utils");
+var createRule45 = import_utils53.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var noNestedTernary = createRule37({
+var noNestedTernary = createRule45({
   name: "no-nested-ternary",
   meta: {
     type: "suggestion",
@@ -2850,13 +3478,13 @@ var noNestedTernary = createRule37({
     return {
       ConditionalExpression(node) {
         const { consequent, alternate } = node;
-        if (consequent.type === import_utils41.AST_NODE_TYPES.ConditionalExpression) {
+        if (consequent.type === import_utils53.AST_NODE_TYPES.ConditionalExpression) {
           context.report({
             node: consequent,
             messageId: "noNestedTernary"
           });
         }
-        if (alternate.type === import_utils41.AST_NODE_TYPES.ConditionalExpression) {
+        if (alternate.type === import_utils53.AST_NODE_TYPES.ConditionalExpression) {
           context.report({
             node: alternate,
             messageId: "noNestedTernary"
@@ -2869,33 +3497,33 @@ var noNestedTernary = createRule37({
 var no_nested_ternary_default = noNestedTernary;
 
 // src/rules/no-redundant-fragment.ts
-var import_utils42 = require("@typescript-eslint/utils");
-var createRule38 = import_utils42.ESLintUtils.RuleCreator(
+var import_utils54 = require("@typescript-eslint/utils");
+var createRule46 = import_utils54.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 function isFragmentName(name) {
-  if (name.type === import_utils42.AST_NODE_TYPES.JSXIdentifier && name.name === "Fragment") {
+  if (name.type === import_utils54.AST_NODE_TYPES.JSXIdentifier && name.name === "Fragment") {
     return true;
   }
-  if (name.type === import_utils42.AST_NODE_TYPES.JSXMemberExpression && name.object.type === import_utils42.AST_NODE_TYPES.JSXIdentifier && name.object.name === "React" && name.property.type === import_utils42.AST_NODE_TYPES.JSXIdentifier && name.property.name === "Fragment") {
+  if (name.type === import_utils54.AST_NODE_TYPES.JSXMemberExpression && name.object.type === import_utils54.AST_NODE_TYPES.JSXIdentifier && name.object.name === "React" && name.property.type === import_utils54.AST_NODE_TYPES.JSXIdentifier && name.property.name === "Fragment") {
     return true;
   }
   return false;
 }
 function hasKeyAttribute(attributes) {
   return attributes.some(
-    (attribute) => attribute.type === import_utils42.AST_NODE_TYPES.JSXAttribute && attribute.name.type === import_utils42.AST_NODE_TYPES.JSXIdentifier && attribute.name.name === "key"
+    (attribute) => attribute.type === import_utils54.AST_NODE_TYPES.JSXAttribute && attribute.name.type === import_utils54.AST_NODE_TYPES.JSXIdentifier && attribute.name.name === "key"
   );
 }
 function countMeaningfulChildren(children) {
   return children.filter((child) => {
-    if (child.type === import_utils42.AST_NODE_TYPES.JSXText) {
+    if (child.type === import_utils54.AST_NODE_TYPES.JSXText) {
       return child.value.trim() !== "";
     }
     return true;
   }).length;
 }
-var noRedundantFragment = createRule38({
+var noRedundantFragment = createRule46({
   name: "no-redundant-fragment",
   meta: {
     type: "problem",
@@ -2943,11 +3571,11 @@ var noRedundantFragment = createRule38({
 var no_redundant_fragment_default = noRedundantFragment;
 
 // src/rules/no-relative-imports.ts
-var import_utils43 = require("@typescript-eslint/utils");
-var createRule39 = import_utils43.ESLintUtils.RuleCreator(
+var import_utils55 = require("@typescript-eslint/utils");
+var createRule47 = import_utils55.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var noRelativeImports = createRule39({
+var noRelativeImports = createRule47({
   name: "no-relative-imports",
   meta: {
     type: "suggestion",
@@ -2971,22 +3599,22 @@ var noRelativeImports = createRule39({
     };
     return {
       ImportDeclaration(node) {
-        if (node.source.type === import_utils43.AST_NODE_TYPES.Literal && typeof node.source.value === "string") {
+        if (node.source.type === import_utils55.AST_NODE_TYPES.Literal && typeof node.source.value === "string") {
           checkImportPath(node.source.value, node);
         }
       },
       ImportExpression(node) {
-        if (node.source.type === import_utils43.AST_NODE_TYPES.Literal && typeof node.source.value === "string") {
+        if (node.source.type === import_utils55.AST_NODE_TYPES.Literal && typeof node.source.value === "string") {
           checkImportPath(node.source.value, node);
         }
       },
       ExportNamedDeclaration(node) {
-        if (node.source?.type === import_utils43.AST_NODE_TYPES.Literal && typeof node.source.value === "string") {
+        if (node.source?.type === import_utils55.AST_NODE_TYPES.Literal && typeof node.source.value === "string") {
           checkImportPath(node.source.value, node);
         }
       },
       ExportAllDeclaration(node) {
-        if (node.source.type === import_utils43.AST_NODE_TYPES.Literal && typeof node.source.value === "string") {
+        if (node.source.type === import_utils55.AST_NODE_TYPES.Literal && typeof node.source.value === "string") {
           checkImportPath(node.source.value, node);
         }
       }
@@ -2996,8 +3624,8 @@ var noRelativeImports = createRule39({
 var no_relative_imports_default = noRelativeImports;
 
 // src/rules/no-single-char-variables.ts
-var import_utils44 = require("@typescript-eslint/utils");
-var createRule40 = import_utils44.ESLintUtils.RuleCreator(
+var import_utils56 = require("@typescript-eslint/utils");
+var createRule48 = import_utils56.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var ALLOWED_IN_FOR_LOOPS = /* @__PURE__ */ new Set(["i", "j", "k", "n"]);
@@ -3009,7 +3637,7 @@ var isForLoopInit = (node) => {
     if (!parentNode) {
       return false;
     }
-    if (parentNode.type === import_utils44.AST_NODE_TYPES.ForStatement) {
+    if (parentNode.type === import_utils56.AST_NODE_TYPES.ForStatement) {
       const { init } = parentNode;
       if (init && init === current) {
         return true;
@@ -3028,7 +3656,7 @@ var isAllowedInContext = (name, node) => {
   }
   return false;
 };
-var noSingleCharVariables = createRule40({
+var noSingleCharVariables = createRule48({
   name: "no-single-char-variables",
   meta: {
     type: "suggestion",
@@ -3057,27 +3685,27 @@ var noSingleCharVariables = createRule40({
       });
     };
     const checkPattern = (pattern, declarationNode) => {
-      if (pattern.type === import_utils44.AST_NODE_TYPES.Identifier) {
+      if (pattern.type === import_utils56.AST_NODE_TYPES.Identifier) {
         checkIdentifier(pattern, declarationNode);
-      } else if (pattern.type === import_utils44.AST_NODE_TYPES.ObjectPattern) {
+      } else if (pattern.type === import_utils56.AST_NODE_TYPES.ObjectPattern) {
         pattern.properties.forEach((prop) => {
-          if (prop.type === import_utils44.AST_NODE_TYPES.Property && prop.value.type === import_utils44.AST_NODE_TYPES.Identifier) {
+          if (prop.type === import_utils56.AST_NODE_TYPES.Property && prop.value.type === import_utils56.AST_NODE_TYPES.Identifier) {
             checkIdentifier(prop.value, declarationNode);
-          } else if (prop.type === import_utils44.AST_NODE_TYPES.RestElement && prop.argument.type === import_utils44.AST_NODE_TYPES.Identifier) {
+          } else if (prop.type === import_utils56.AST_NODE_TYPES.RestElement && prop.argument.type === import_utils56.AST_NODE_TYPES.Identifier) {
             checkIdentifier(prop.argument, declarationNode);
           }
         });
-      } else if (pattern.type === import_utils44.AST_NODE_TYPES.ArrayPattern) {
+      } else if (pattern.type === import_utils56.AST_NODE_TYPES.ArrayPattern) {
         pattern.elements.forEach((element) => {
-          if (element?.type === import_utils44.AST_NODE_TYPES.Identifier) {
+          if (element?.type === import_utils56.AST_NODE_TYPES.Identifier) {
             checkIdentifier(element, declarationNode);
-          } else if (element?.type === import_utils44.AST_NODE_TYPES.RestElement && element.argument.type === import_utils44.AST_NODE_TYPES.Identifier) {
+          } else if (element?.type === import_utils56.AST_NODE_TYPES.RestElement && element.argument.type === import_utils56.AST_NODE_TYPES.Identifier) {
             checkIdentifier(element.argument, declarationNode);
           }
         });
-      } else if (pattern.type === import_utils44.AST_NODE_TYPES.AssignmentPattern && pattern.left.type === import_utils44.AST_NODE_TYPES.Identifier) {
+      } else if (pattern.type === import_utils56.AST_NODE_TYPES.AssignmentPattern && pattern.left.type === import_utils56.AST_NODE_TYPES.Identifier) {
         checkIdentifier(pattern.left, declarationNode);
-      } else if (pattern.type === import_utils44.AST_NODE_TYPES.RestElement && pattern.argument.type === import_utils44.AST_NODE_TYPES.Identifier) {
+      } else if (pattern.type === import_utils56.AST_NODE_TYPES.RestElement && pattern.argument.type === import_utils56.AST_NODE_TYPES.Identifier) {
         checkIdentifier(pattern.argument, declarationNode);
       }
     };
@@ -3111,11 +3739,11 @@ var noSingleCharVariables = createRule40({
 var no_single_char_variables_default = noSingleCharVariables;
 
 // src/rules/prefer-async-await.ts
-var import_utils45 = require("@typescript-eslint/utils");
-var createRule41 = import_utils45.ESLintUtils.RuleCreator(
+var import_utils57 = require("@typescript-eslint/utils");
+var createRule49 = import_utils57.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var preferAsyncAwait = createRule41({
+var preferAsyncAwait = createRule49({
   name: "prefer-async-await",
   meta: {
     type: "suggestion",
@@ -3131,7 +3759,7 @@ var preferAsyncAwait = createRule41({
   create(context) {
     return {
       CallExpression(node) {
-        if (node.callee.type === import_utils45.AST_NODE_TYPES.MemberExpression && node.callee.property.type === import_utils45.AST_NODE_TYPES.Identifier && node.callee.property.name === "then") {
+        if (node.callee.type === import_utils57.AST_NODE_TYPES.MemberExpression && node.callee.property.type === import_utils57.AST_NODE_TYPES.Identifier && node.callee.property.name === "then") {
           context.report({
             node: node.callee.property,
             messageId: "preferAsyncAwait"
@@ -3144,11 +3772,11 @@ var preferAsyncAwait = createRule41({
 var prefer_async_await_default = preferAsyncAwait;
 
 // src/rules/prefer-destructuring-params.ts
-var import_utils46 = require("@typescript-eslint/utils");
-var createRule42 = import_utils46.ESLintUtils.RuleCreator(
+var import_utils58 = require("@typescript-eslint/utils");
+var createRule50 = import_utils58.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var preferDestructuringParams = createRule42({
+var preferDestructuringParams = createRule50({
   name: "prefer-destructuring-params",
   meta: {
     type: "suggestion",
@@ -3164,18 +3792,18 @@ var preferDestructuringParams = createRule42({
   create(context) {
     const isCallbackFunction2 = (node) => {
       const { parent } = node;
-      return parent?.type === import_utils46.AST_NODE_TYPES.CallExpression;
+      return parent?.type === import_utils58.AST_NODE_TYPES.CallExpression;
     };
     const isDeveloperFunction = (node) => {
-      if (node.type === import_utils46.AST_NODE_TYPES.FunctionDeclaration) {
+      if (node.type === import_utils58.AST_NODE_TYPES.FunctionDeclaration) {
         return true;
       }
-      if (node.type === import_utils46.AST_NODE_TYPES.FunctionExpression || node.type === import_utils46.AST_NODE_TYPES.ArrowFunctionExpression) {
+      if (node.type === import_utils58.AST_NODE_TYPES.FunctionExpression || node.type === import_utils58.AST_NODE_TYPES.ArrowFunctionExpression) {
         if (isCallbackFunction2(node)) {
           return false;
         }
         const { parent } = node;
-        return parent?.type === import_utils46.AST_NODE_TYPES.VariableDeclarator || parent?.type === import_utils46.AST_NODE_TYPES.AssignmentExpression || parent?.type === import_utils46.AST_NODE_TYPES.Property || parent?.type === import_utils46.AST_NODE_TYPES.MethodDefinition;
+        return parent?.type === import_utils58.AST_NODE_TYPES.VariableDeclarator || parent?.type === import_utils58.AST_NODE_TYPES.AssignmentExpression || parent?.type === import_utils58.AST_NODE_TYPES.Property || parent?.type === import_utils58.AST_NODE_TYPES.MethodDefinition;
       }
       return false;
     };
@@ -3187,7 +3815,7 @@ var preferDestructuringParams = createRule42({
       if (!isDeveloperFunction(node)) {
         return;
       }
-      if (node.type === import_utils46.AST_NODE_TYPES.FunctionDeclaration && node.id) {
+      if (node.type === import_utils58.AST_NODE_TYPES.FunctionDeclaration && node.id) {
         const functionName = node.id.name;
         if (functionName.startsWith("_") || functionName.includes("$") || /^[A-Z][a-zA-Z]*$/.test(functionName)) {
           return;
@@ -3197,7 +3825,7 @@ var preferDestructuringParams = createRule42({
         return;
       }
       const hasNonDestructuredParams = node.params.some(
-        (param) => param.type !== import_utils46.AST_NODE_TYPES.ObjectPattern && param.type !== import_utils46.AST_NODE_TYPES.RestElement
+        (param) => param.type !== import_utils58.AST_NODE_TYPES.ObjectPattern && param.type !== import_utils58.AST_NODE_TYPES.RestElement
       );
       if (hasNonDestructuredParams) {
         context.report({
@@ -3216,8 +3844,8 @@ var preferDestructuringParams = createRule42({
 var prefer_destructuring_params_default = preferDestructuringParams;
 
 // src/rules/prefer-function-declaration.ts
-var import_utils47 = require("@typescript-eslint/utils");
-var createRule43 = import_utils47.ESLintUtils.RuleCreator(
+var import_utils59 = require("@typescript-eslint/utils");
+var createRule51 = import_utils59.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var isTsFile = (filename) => filename.endsWith(".ts") && !filename.endsWith(".d.ts");
@@ -3226,33 +3854,33 @@ var isCallbackContext = (node) => {
   if (!parent) {
     return false;
   }
-  if (parent.type === import_utils47.AST_NODE_TYPES.CallExpression && parent.arguments.includes(node)) {
+  if (parent.type === import_utils59.AST_NODE_TYPES.CallExpression && parent.arguments.includes(node)) {
     return true;
   }
-  if (parent.type === import_utils47.AST_NODE_TYPES.NewExpression && parent.arguments.includes(node)) {
+  if (parent.type === import_utils59.AST_NODE_TYPES.NewExpression && parent.arguments.includes(node)) {
     return true;
   }
-  if (parent.type === import_utils47.AST_NODE_TYPES.ReturnStatement) {
+  if (parent.type === import_utils59.AST_NODE_TYPES.ReturnStatement) {
     return true;
   }
-  if (parent.type === import_utils47.AST_NODE_TYPES.Property) {
+  if (parent.type === import_utils59.AST_NODE_TYPES.Property) {
     return true;
   }
-  if (parent.type === import_utils47.AST_NODE_TYPES.ArrayExpression) {
+  if (parent.type === import_utils59.AST_NODE_TYPES.ArrayExpression) {
     return true;
   }
-  if (parent.type === import_utils47.AST_NODE_TYPES.ConditionalExpression) {
+  if (parent.type === import_utils59.AST_NODE_TYPES.ConditionalExpression) {
     return true;
   }
-  if (parent.type === import_utils47.AST_NODE_TYPES.LogicalExpression) {
+  if (parent.type === import_utils59.AST_NODE_TYPES.LogicalExpression) {
     return true;
   }
-  if (parent.type === import_utils47.AST_NODE_TYPES.AssignmentExpression && parent.left !== node) {
+  if (parent.type === import_utils59.AST_NODE_TYPES.AssignmentExpression && parent.left !== node) {
     return true;
   }
   return false;
 };
-var preferFunctionDeclaration = createRule43({
+var preferFunctionDeclaration = createRule51({
   name: "prefer-function-declaration",
   meta: {
     type: "suggestion",
@@ -3273,14 +3901,14 @@ var preferFunctionDeclaration = createRule43({
     }
     return {
       VariableDeclarator(node) {
-        if (node.id.type !== import_utils47.AST_NODE_TYPES.Identifier) {
+        if (node.id.type !== import_utils59.AST_NODE_TYPES.Identifier) {
           return;
         }
         const { init } = node;
         if (!init) {
           return;
         }
-        if (init.type === import_utils47.AST_NODE_TYPES.ArrowFunctionExpression) {
+        if (init.type === import_utils59.AST_NODE_TYPES.ArrowFunctionExpression) {
           if (isCallbackContext(init)) {
             return;
           }
@@ -3290,7 +3918,7 @@ var preferFunctionDeclaration = createRule43({
             data: { name: node.id.name }
           });
         }
-        if (init.type === import_utils47.AST_NODE_TYPES.FunctionExpression) {
+        if (init.type === import_utils59.AST_NODE_TYPES.FunctionExpression) {
           if (isCallbackContext(init)) {
             return;
           }
@@ -3307,11 +3935,11 @@ var preferFunctionDeclaration = createRule43({
 var prefer_function_declaration_default = preferFunctionDeclaration;
 
 // src/rules/prefer-guard-clause.ts
-var import_utils48 = require("@typescript-eslint/utils");
-var createRule44 = import_utils48.ESLintUtils.RuleCreator(
+var import_utils60 = require("@typescript-eslint/utils");
+var createRule52 = import_utils60.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var preferGuardClause = createRule44({
+var preferGuardClause = createRule52({
   name: "prefer-guard-clause",
   meta: {
     type: "suggestion",
@@ -3328,8 +3956,8 @@ var preferGuardClause = createRule44({
     return {
       IfStatement(node) {
         const { consequent } = node;
-        if (consequent.type === import_utils48.AST_NODE_TYPES.BlockStatement) {
-          const hasNestedIf = consequent.body.some((statement) => statement.type === import_utils48.AST_NODE_TYPES.IfStatement);
+        if (consequent.type === import_utils60.AST_NODE_TYPES.BlockStatement) {
+          const hasNestedIf = consequent.body.some((statement) => statement.type === import_utils60.AST_NODE_TYPES.IfStatement);
           if (hasNestedIf && consequent.body.length === 1) {
             context.report({
               node,
@@ -3337,7 +3965,7 @@ var preferGuardClause = createRule44({
             });
           }
         }
-        if (consequent.type === import_utils48.AST_NODE_TYPES.IfStatement) {
+        if (consequent.type === import_utils60.AST_NODE_TYPES.IfStatement) {
           context.report({
             node,
             messageId: "preferGuardClause"
@@ -3350,11 +3978,11 @@ var preferGuardClause = createRule44({
 var prefer_guard_clause_default = preferGuardClause;
 
 // src/rules/prefer-import-type.ts
-var import_utils49 = require("@typescript-eslint/utils");
-var createRule45 = import_utils49.ESLintUtils.RuleCreator(
+var import_utils61 = require("@typescript-eslint/utils");
+var createRule53 = import_utils61.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var preferImportType = createRule45({
+var preferImportType = createRule53({
   name: "prefer-import-type",
   meta: {
     type: "suggestion",
@@ -3373,22 +4001,22 @@ var preferImportType = createRule45({
       let current = node;
       while (current) {
         switch (current.type) {
-          case import_utils49.AST_NODE_TYPES.TSTypeReference:
-          case import_utils49.AST_NODE_TYPES.TSTypeAnnotation:
-          case import_utils49.AST_NODE_TYPES.TSTypeParameterInstantiation:
-          case import_utils49.AST_NODE_TYPES.TSInterfaceHeritage:
-          case import_utils49.AST_NODE_TYPES.TSClassImplements:
-          case import_utils49.AST_NODE_TYPES.TSTypeQuery:
-          case import_utils49.AST_NODE_TYPES.TSTypeAssertion:
-          case import_utils49.AST_NODE_TYPES.TSAsExpression:
-          case import_utils49.AST_NODE_TYPES.TSSatisfiesExpression:
-          case import_utils49.AST_NODE_TYPES.TSTypeAliasDeclaration:
-          case import_utils49.AST_NODE_TYPES.TSInterfaceDeclaration:
-          case import_utils49.AST_NODE_TYPES.TSTypeParameter:
-          case import_utils49.AST_NODE_TYPES.TSQualifiedName:
+          case import_utils61.AST_NODE_TYPES.TSTypeReference:
+          case import_utils61.AST_NODE_TYPES.TSTypeAnnotation:
+          case import_utils61.AST_NODE_TYPES.TSTypeParameterInstantiation:
+          case import_utils61.AST_NODE_TYPES.TSInterfaceHeritage:
+          case import_utils61.AST_NODE_TYPES.TSClassImplements:
+          case import_utils61.AST_NODE_TYPES.TSTypeQuery:
+          case import_utils61.AST_NODE_TYPES.TSTypeAssertion:
+          case import_utils61.AST_NODE_TYPES.TSAsExpression:
+          case import_utils61.AST_NODE_TYPES.TSSatisfiesExpression:
+          case import_utils61.AST_NODE_TYPES.TSTypeAliasDeclaration:
+          case import_utils61.AST_NODE_TYPES.TSInterfaceDeclaration:
+          case import_utils61.AST_NODE_TYPES.TSTypeParameter:
+          case import_utils61.AST_NODE_TYPES.TSQualifiedName:
             return true;
-          case import_utils49.AST_NODE_TYPES.MemberExpression:
-          case import_utils49.AST_NODE_TYPES.Identifier:
+          case import_utils61.AST_NODE_TYPES.MemberExpression:
+          case import_utils61.AST_NODE_TYPES.Identifier:
             current = current.parent;
             break;
           default:
@@ -3418,27 +4046,27 @@ var preferImportType = createRule45({
           return false;
         }
         switch (parent.type) {
-          case import_utils49.AST_NODE_TYPES.CallExpression:
-          case import_utils49.AST_NODE_TYPES.NewExpression:
-          case import_utils49.AST_NODE_TYPES.JSXOpeningElement:
-          case import_utils49.AST_NODE_TYPES.JSXClosingElement:
-          case import_utils49.AST_NODE_TYPES.MemberExpression:
-          case import_utils49.AST_NODE_TYPES.VariableDeclarator:
-          case import_utils49.AST_NODE_TYPES.TaggedTemplateExpression:
-          case import_utils49.AST_NODE_TYPES.SpreadElement:
-          case import_utils49.AST_NODE_TYPES.ExportSpecifier:
-          case import_utils49.AST_NODE_TYPES.ArrayExpression:
-          case import_utils49.AST_NODE_TYPES.ObjectExpression:
-          case import_utils49.AST_NODE_TYPES.BinaryExpression:
-          case import_utils49.AST_NODE_TYPES.LogicalExpression:
-          case import_utils49.AST_NODE_TYPES.UnaryExpression:
-          case import_utils49.AST_NODE_TYPES.ReturnStatement:
-          case import_utils49.AST_NODE_TYPES.ArrowFunctionExpression:
-          case import_utils49.AST_NODE_TYPES.ConditionalExpression:
-          case import_utils49.AST_NODE_TYPES.AwaitExpression:
-          case import_utils49.AST_NODE_TYPES.YieldExpression:
-          case import_utils49.AST_NODE_TYPES.Property:
-          case import_utils49.AST_NODE_TYPES.JSXExpressionContainer:
+          case import_utils61.AST_NODE_TYPES.CallExpression:
+          case import_utils61.AST_NODE_TYPES.NewExpression:
+          case import_utils61.AST_NODE_TYPES.JSXOpeningElement:
+          case import_utils61.AST_NODE_TYPES.JSXClosingElement:
+          case import_utils61.AST_NODE_TYPES.MemberExpression:
+          case import_utils61.AST_NODE_TYPES.VariableDeclarator:
+          case import_utils61.AST_NODE_TYPES.TaggedTemplateExpression:
+          case import_utils61.AST_NODE_TYPES.SpreadElement:
+          case import_utils61.AST_NODE_TYPES.ExportSpecifier:
+          case import_utils61.AST_NODE_TYPES.ArrayExpression:
+          case import_utils61.AST_NODE_TYPES.ObjectExpression:
+          case import_utils61.AST_NODE_TYPES.BinaryExpression:
+          case import_utils61.AST_NODE_TYPES.LogicalExpression:
+          case import_utils61.AST_NODE_TYPES.UnaryExpression:
+          case import_utils61.AST_NODE_TYPES.ReturnStatement:
+          case import_utils61.AST_NODE_TYPES.ArrowFunctionExpression:
+          case import_utils61.AST_NODE_TYPES.ConditionalExpression:
+          case import_utils61.AST_NODE_TYPES.AwaitExpression:
+          case import_utils61.AST_NODE_TYPES.YieldExpression:
+          case import_utils61.AST_NODE_TYPES.Property:
+          case import_utils61.AST_NODE_TYPES.JSXExpressionContainer:
             return true;
           default:
             return false;
@@ -3450,7 +4078,7 @@ var preferImportType = createRule45({
         return;
       }
       const hasInlineTypeSpecifier = node.specifiers.some(
-        (specifier) => specifier.type === import_utils49.AST_NODE_TYPES.ImportSpecifier && specifier.importKind === "type"
+        (specifier) => specifier.type === import_utils61.AST_NODE_TYPES.ImportSpecifier && specifier.importKind === "type"
       );
       if (hasInlineTypeSpecifier) {
         return;
@@ -3468,13 +4096,13 @@ var preferImportType = createRule45({
       }
       const scope = context.sourceCode.getScope(node);
       const isTypeOnlyImport2 = node.specifiers.every((specifier) => {
-        if (specifier.type === import_utils49.AST_NODE_TYPES.ImportDefaultSpecifier) {
+        if (specifier.type === import_utils61.AST_NODE_TYPES.ImportDefaultSpecifier) {
           return false;
         }
-        if (specifier.type === import_utils49.AST_NODE_TYPES.ImportNamespaceSpecifier) {
+        if (specifier.type === import_utils61.AST_NODE_TYPES.ImportNamespaceSpecifier) {
           return false;
         }
-        if (specifier.type === import_utils49.AST_NODE_TYPES.ImportSpecifier) {
+        if (specifier.type === import_utils61.AST_NODE_TYPES.ImportSpecifier) {
           const localName = specifier.local.name;
           return !isUsedAsValue(localName, scope);
         }
@@ -3500,19 +4128,19 @@ var preferImportType = createRule45({
 var prefer_import_type_default = preferImportType;
 
 // src/rules/prefer-inline-literal-union.ts
-var import_utils50 = require("@typescript-eslint/utils");
-var createRule46 = import_utils50.ESLintUtils.RuleCreator(
+var import_utils62 = require("@typescript-eslint/utils");
+var createRule54 = import_utils62.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 function isLiteralUnionType(node) {
-  if (node.type !== import_utils50.AST_NODE_TYPES.TSUnionType) {
+  if (node.type !== import_utils62.AST_NODE_TYPES.TSUnionType) {
     return false;
   }
   return node.types.every(
-    (member) => member.type === import_utils50.AST_NODE_TYPES.TSLiteralType || member.type === import_utils50.AST_NODE_TYPES.TSNullKeyword || member.type === import_utils50.AST_NODE_TYPES.TSUndefinedKeyword
+    (member) => member.type === import_utils62.AST_NODE_TYPES.TSLiteralType || member.type === import_utils62.AST_NODE_TYPES.TSNullKeyword || member.type === import_utils62.AST_NODE_TYPES.TSUndefinedKeyword
   );
 }
-var preferInlineLiteralUnion = createRule46({
+var preferInlineLiteralUnion = createRule54({
   name: "prefer-inline-literal-union",
   meta: {
     type: "suggestion",
@@ -3539,10 +4167,10 @@ var preferInlineLiteralUnion = createRule46({
           return;
         }
         const { typeAnnotation } = node.typeAnnotation;
-        if (typeAnnotation.type !== import_utils50.AST_NODE_TYPES.TSTypeReference) {
+        if (typeAnnotation.type !== import_utils62.AST_NODE_TYPES.TSTypeReference) {
           return;
         }
-        if (typeAnnotation.typeName.type !== import_utils50.AST_NODE_TYPES.Identifier) {
+        if (typeAnnotation.typeName.type !== import_utils62.AST_NODE_TYPES.Identifier) {
           return;
         }
         const aliasName = typeAnnotation.typeName.name;
@@ -3566,12 +4194,12 @@ var preferInlineLiteralUnion = createRule46({
 var prefer_inline_literal_union_default = preferInlineLiteralUnion;
 
 // src/rules/prefer-inline-type-export.ts
-var import_utils51 = require("@typescript-eslint/utils");
-var createRule47 = import_utils51.ESLintUtils.RuleCreator(
+var import_utils63 = require("@typescript-eslint/utils");
+var createRule55 = import_utils63.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var isTypeDeclaration = (node) => node.type === import_utils51.AST_NODE_TYPES.TSInterfaceDeclaration || node.type === import_utils51.AST_NODE_TYPES.TSTypeAliasDeclaration;
-var preferInlineTypeExport = createRule47({
+var isTypeDeclaration = (node) => node.type === import_utils63.AST_NODE_TYPES.TSInterfaceDeclaration || node.type === import_utils63.AST_NODE_TYPES.TSTypeAliasDeclaration;
+var preferInlineTypeExport = createRule55({
   name: "prefer-inline-type-export",
   meta: {
     type: "suggestion",
@@ -3588,12 +4216,12 @@ var preferInlineTypeExport = createRule47({
   create(context) {
     const typeDeclarations = /* @__PURE__ */ new Map();
     function collectDeclaration(node) {
-      if (node.parent.type !== import_utils51.AST_NODE_TYPES.ExportNamedDeclaration) {
+      if (node.parent.type !== import_utils63.AST_NODE_TYPES.ExportNamedDeclaration) {
         typeDeclarations.set(node.id.name, node);
       }
     }
     function reportSpecifier(specifier, statement, declarationNode) {
-      if (specifier.local.type !== import_utils51.AST_NODE_TYPES.Identifier) {
+      if (specifier.local.type !== import_utils63.AST_NODE_TYPES.Identifier) {
         return;
       }
       const { name } = specifier.local;
@@ -3626,16 +4254,16 @@ var preferInlineTypeExport = createRule47({
     return {
       Program(node) {
         node.body.forEach((statement) => {
-          if (statement.type === import_utils51.AST_NODE_TYPES.TSInterfaceDeclaration || statement.type === import_utils51.AST_NODE_TYPES.TSTypeAliasDeclaration) {
+          if (statement.type === import_utils63.AST_NODE_TYPES.TSInterfaceDeclaration || statement.type === import_utils63.AST_NODE_TYPES.TSTypeAliasDeclaration) {
             collectDeclaration(statement);
           }
         });
         node.body.forEach((statement) => {
-          if (statement.type !== import_utils51.AST_NODE_TYPES.ExportNamedDeclaration || statement.declaration !== null) {
+          if (statement.type !== import_utils63.AST_NODE_TYPES.ExportNamedDeclaration || statement.declaration !== null) {
             return;
           }
           statement.specifiers.forEach((specifier) => {
-            if (specifier.local.type !== import_utils51.AST_NODE_TYPES.Identifier) {
+            if (specifier.local.type !== import_utils63.AST_NODE_TYPES.Identifier) {
               return;
             }
             const declarationNode = typeDeclarations.get(specifier.local.name);
@@ -3652,11 +4280,11 @@ var preferInlineTypeExport = createRule47({
 var prefer_inline_type_export_default = preferInlineTypeExport;
 
 // src/rules/prefer-interface-for-component-props.ts
-var import_utils52 = require("@typescript-eslint/utils");
-var createRule48 = import_utils52.ESLintUtils.RuleCreator(
+var import_utils64 = require("@typescript-eslint/utils");
+var createRule56 = import_utils64.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var preferInterfaceForComponentProps = createRule48({
+var preferInterfaceForComponentProps = createRule56({
   name: "prefer-interface-for-component-props",
   meta: {
     type: "suggestion",
@@ -3676,13 +4304,13 @@ var preferInterfaceForComponentProps = createRule48({
     }
     return {
       TSTypeAliasDeclaration(node) {
-        if (node.id.type !== import_utils52.AST_NODE_TYPES.Identifier) {
+        if (node.id.type !== import_utils64.AST_NODE_TYPES.Identifier) {
           return;
         }
         if (!node.id.name.endsWith("Props")) {
           return;
         }
-        if (node.typeAnnotation.type !== import_utils52.AST_NODE_TYPES.TSTypeLiteral) {
+        if (node.typeAnnotation.type !== import_utils64.AST_NODE_TYPES.TSTypeLiteral) {
           return;
         }
         const { name } = node.id;
@@ -3709,11 +4337,11 @@ var preferInterfaceForComponentProps = createRule48({
 var prefer_interface_for_component_props_default = preferInterfaceForComponentProps;
 
 // src/rules/prefer-interface-over-inline-types.ts
-var import_utils54 = require("@typescript-eslint/utils");
-var createRule49 = import_utils54.ESLintUtils.RuleCreator(
+var import_utils66 = require("@typescript-eslint/utils");
+var createRule57 = import_utils66.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var preferInterfaceOverInlineTypes = createRule49({
+var preferInterfaceOverInlineTypes = createRule57({
   name: "prefer-interface-over-inline-types",
   meta: {
     type: "suggestion",
@@ -3729,54 +4357,54 @@ var preferInterfaceOverInlineTypes = createRule49({
   defaultOptions: [],
   create(context) {
     function hasJSXInConditional(node) {
-      return node.consequent.type === import_utils54.AST_NODE_TYPES.JSXElement || node.consequent.type === import_utils54.AST_NODE_TYPES.JSXFragment || node.alternate.type === import_utils54.AST_NODE_TYPES.JSXElement || node.alternate.type === import_utils54.AST_NODE_TYPES.JSXFragment;
+      return node.consequent.type === import_utils66.AST_NODE_TYPES.JSXElement || node.consequent.type === import_utils66.AST_NODE_TYPES.JSXFragment || node.alternate.type === import_utils66.AST_NODE_TYPES.JSXElement || node.alternate.type === import_utils66.AST_NODE_TYPES.JSXFragment;
     }
     function hasJSXInLogical(node) {
-      return node.right.type === import_utils54.AST_NODE_TYPES.JSXElement || node.right.type === import_utils54.AST_NODE_TYPES.JSXFragment;
+      return node.right.type === import_utils66.AST_NODE_TYPES.JSXElement || node.right.type === import_utils66.AST_NODE_TYPES.JSXFragment;
     }
     function hasJSXReturn(block) {
       return block.body.some((stmt) => {
-        if (stmt.type === import_utils54.AST_NODE_TYPES.ReturnStatement && stmt.argument) {
-          return stmt.argument.type === import_utils54.AST_NODE_TYPES.JSXElement || stmt.argument.type === import_utils54.AST_NODE_TYPES.JSXFragment || stmt.argument.type === import_utils54.AST_NODE_TYPES.ConditionalExpression && hasJSXInConditional(stmt.argument) || stmt.argument.type === import_utils54.AST_NODE_TYPES.LogicalExpression && hasJSXInLogical(stmt.argument);
+        if (stmt.type === import_utils66.AST_NODE_TYPES.ReturnStatement && stmt.argument) {
+          return stmt.argument.type === import_utils66.AST_NODE_TYPES.JSXElement || stmt.argument.type === import_utils66.AST_NODE_TYPES.JSXFragment || stmt.argument.type === import_utils66.AST_NODE_TYPES.ConditionalExpression && hasJSXInConditional(stmt.argument) || stmt.argument.type === import_utils66.AST_NODE_TYPES.LogicalExpression && hasJSXInLogical(stmt.argument);
         }
         return false;
       });
     }
     function isReactComponent2(node) {
-      if (node.type === import_utils54.AST_NODE_TYPES.ArrowFunctionExpression) {
-        if (node.body.type === import_utils54.AST_NODE_TYPES.JSXElement || node.body.type === import_utils54.AST_NODE_TYPES.JSXFragment) {
+      if (node.type === import_utils66.AST_NODE_TYPES.ArrowFunctionExpression) {
+        if (node.body.type === import_utils66.AST_NODE_TYPES.JSXElement || node.body.type === import_utils66.AST_NODE_TYPES.JSXFragment) {
           return true;
         }
-        if (node.body.type === import_utils54.AST_NODE_TYPES.BlockStatement) {
+        if (node.body.type === import_utils66.AST_NODE_TYPES.BlockStatement) {
           return hasJSXReturn(node.body);
         }
-      } else if (node.type === import_utils54.AST_NODE_TYPES.FunctionExpression || node.type === import_utils54.AST_NODE_TYPES.FunctionDeclaration) {
-        if (node.body && node.body.type === import_utils54.AST_NODE_TYPES.BlockStatement) {
+      } else if (node.type === import_utils66.AST_NODE_TYPES.FunctionExpression || node.type === import_utils66.AST_NODE_TYPES.FunctionDeclaration) {
+        if (node.body && node.body.type === import_utils66.AST_NODE_TYPES.BlockStatement) {
           return hasJSXReturn(node.body);
         }
       }
       return false;
     }
     function isInlineTypeAnnotation(node) {
-      if (node.type === import_utils54.AST_NODE_TYPES.TSTypeLiteral) {
+      if (node.type === import_utils66.AST_NODE_TYPES.TSTypeLiteral) {
         return true;
       }
-      if (node.type === import_utils54.AST_NODE_TYPES.TSTypeReference && node.typeArguments) {
-        return node.typeArguments.params.some((param) => param.type === import_utils54.AST_NODE_TYPES.TSTypeLiteral);
+      if (node.type === import_utils66.AST_NODE_TYPES.TSTypeReference && node.typeArguments) {
+        return node.typeArguments.params.some((param) => param.type === import_utils66.AST_NODE_TYPES.TSTypeLiteral);
       }
-      if (node.type === import_utils54.AST_NODE_TYPES.TSUnionType) {
+      if (node.type === import_utils66.AST_NODE_TYPES.TSUnionType) {
         return node.types.some((type) => isInlineTypeAnnotation(type));
       }
       return false;
     }
     function hasInlineObjectType(node) {
-      if (node.type === import_utils54.AST_NODE_TYPES.TSTypeLiteral) {
+      if (node.type === import_utils66.AST_NODE_TYPES.TSTypeLiteral) {
         return true;
       }
-      if (node.type === import_utils54.AST_NODE_TYPES.TSTypeReference && node.typeArguments) {
-        return node.typeArguments.params.some((param) => param.type === import_utils54.AST_NODE_TYPES.TSTypeLiteral);
+      if (node.type === import_utils66.AST_NODE_TYPES.TSTypeReference && node.typeArguments) {
+        return node.typeArguments.params.some((param) => param.type === import_utils66.AST_NODE_TYPES.TSTypeLiteral);
       }
-      if (node.type === import_utils54.AST_NODE_TYPES.TSUnionType) {
+      if (node.type === import_utils66.AST_NODE_TYPES.TSUnionType) {
         return node.types.some((type) => hasInlineObjectType(type));
       }
       return false;
@@ -3789,7 +4417,7 @@ var preferInterfaceOverInlineTypes = createRule49({
         return;
       }
       const param = node.params[0];
-      if (param.type === import_utils54.AST_NODE_TYPES.Identifier && param.typeAnnotation) {
+      if (param.type === import_utils66.AST_NODE_TYPES.Identifier && param.typeAnnotation) {
         const { typeAnnotation } = param.typeAnnotation;
         if (isInlineTypeAnnotation(typeAnnotation) && hasInlineObjectType(typeAnnotation)) {
           context.report({
@@ -3809,11 +4437,11 @@ var preferInterfaceOverInlineTypes = createRule49({
 var prefer_interface_over_inline_types_default = preferInterfaceOverInlineTypes;
 
 // src/rules/prefer-jsx-template-literals.ts
-var import_utils55 = require("@typescript-eslint/utils");
-var createRule50 = import_utils55.ESLintUtils.RuleCreator(
+var import_utils67 = require("@typescript-eslint/utils");
+var createRule58 = import_utils67.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var preferJSXTemplateLiterals = createRule50({
+var preferJSXTemplateLiterals = createRule58({
   name: "prefer-jsx-template-literals",
   meta: {
     type: "suggestion",
@@ -3882,9 +4510,9 @@ var preferJSXTemplateLiterals = createRule50({
         if (!child || !nextChild) {
           return;
         }
-        if (child.type === import_utils55.AST_NODE_TYPES.JSXText && nextChild.type === import_utils55.AST_NODE_TYPES.JSXExpressionContainer) {
+        if (child.type === import_utils67.AST_NODE_TYPES.JSXText && nextChild.type === import_utils67.AST_NODE_TYPES.JSXExpressionContainer) {
           handleTextBeforeExpression(child, nextChild);
-        } else if (child.type === import_utils55.AST_NODE_TYPES.JSXExpressionContainer && nextChild.type === import_utils55.AST_NODE_TYPES.JSXText) {
+        } else if (child.type === import_utils67.AST_NODE_TYPES.JSXExpressionContainer && nextChild.type === import_utils67.AST_NODE_TYPES.JSXText) {
           handleExpressionBeforeText(child, nextChild);
         }
       }
@@ -3897,32 +4525,32 @@ var preferJSXTemplateLiterals = createRule50({
 var prefer_jsx_template_literals_default = preferJSXTemplateLiterals;
 
 // src/rules/prefer-named-param-types.ts
-var import_utils56 = require("@typescript-eslint/utils");
-var createRule51 = import_utils56.ESLintUtils.RuleCreator(
+var import_utils68 = require("@typescript-eslint/utils");
+var createRule59 = import_utils68.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var returnsJsx2 = (node) => {
-  if (node.type === import_utils56.AST_NODE_TYPES.JSXElement || node.type === import_utils56.AST_NODE_TYPES.JSXFragment) {
+  if (node.type === import_utils68.AST_NODE_TYPES.JSXElement || node.type === import_utils68.AST_NODE_TYPES.JSXFragment) {
     return true;
   }
-  if (node.type === import_utils56.AST_NODE_TYPES.ConditionalExpression) {
+  if (node.type === import_utils68.AST_NODE_TYPES.ConditionalExpression) {
     return returnsJsx2(node.consequent) || returnsJsx2(node.alternate);
   }
-  if (node.type === import_utils56.AST_NODE_TYPES.LogicalExpression) {
+  if (node.type === import_utils68.AST_NODE_TYPES.LogicalExpression) {
     return returnsJsx2(node.left) || returnsJsx2(node.right);
   }
   return false;
 };
 var bodyReturnsJsx2 = (body) => {
-  if (body.type !== import_utils56.AST_NODE_TYPES.BlockStatement) {
+  if (body.type !== import_utils68.AST_NODE_TYPES.BlockStatement) {
     return returnsJsx2(body);
   }
   return body.body.some(
-    (stmt) => stmt.type === import_utils56.AST_NODE_TYPES.ReturnStatement && stmt.argument !== null && returnsJsx2(stmt.argument)
+    (stmt) => stmt.type === import_utils68.AST_NODE_TYPES.ReturnStatement && stmt.argument !== null && returnsJsx2(stmt.argument)
   );
 };
 var isReactComponentFunction = (node) => bodyReturnsJsx2(node.body);
-var preferNamedParamTypes = createRule51({
+var preferNamedParamTypes = createRule59({
   name: "prefer-named-param-types",
   meta: {
     type: "suggestion",
@@ -3937,16 +4565,16 @@ var preferNamedParamTypes = createRule51({
   defaultOptions: [],
   create(context) {
     function hasInlineObjectType(param) {
-      if (param.type === import_utils56.AST_NODE_TYPES.AssignmentPattern) {
+      if (param.type === import_utils68.AST_NODE_TYPES.AssignmentPattern) {
         return hasInlineObjectType(param.left);
       }
-      if (param.type === import_utils56.AST_NODE_TYPES.ObjectPattern) {
-        if (param.typeAnnotation?.typeAnnotation.type === import_utils56.AST_NODE_TYPES.TSTypeLiteral) {
+      if (param.type === import_utils68.AST_NODE_TYPES.ObjectPattern) {
+        if (param.typeAnnotation?.typeAnnotation.type === import_utils68.AST_NODE_TYPES.TSTypeLiteral) {
           return true;
         }
       }
-      if (param.type === import_utils56.AST_NODE_TYPES.Identifier) {
-        if (param.typeAnnotation?.typeAnnotation.type === import_utils56.AST_NODE_TYPES.TSTypeLiteral) {
+      if (param.type === import_utils68.AST_NODE_TYPES.Identifier) {
+        if (param.typeAnnotation?.typeAnnotation.type === import_utils68.AST_NODE_TYPES.TSTypeLiteral) {
           return true;
         }
       }
@@ -3959,7 +4587,7 @@ var preferNamedParamTypes = createRule51({
       } else if ("value" in node && node.value) {
         params = node.value.params;
       }
-      if ((node.type === import_utils56.AST_NODE_TYPES.FunctionDeclaration || node.type === import_utils56.AST_NODE_TYPES.FunctionExpression || node.type === import_utils56.AST_NODE_TYPES.ArrowFunctionExpression) && params.length === 1 && params[0].type === import_utils56.AST_NODE_TYPES.Identifier && isReactComponentFunction(node)) {
+      if ((node.type === import_utils68.AST_NODE_TYPES.FunctionDeclaration || node.type === import_utils68.AST_NODE_TYPES.FunctionExpression || node.type === import_utils68.AST_NODE_TYPES.ArrowFunctionExpression) && params.length === 1 && params[0].type === import_utils68.AST_NODE_TYPES.Identifier && isReactComponentFunction(node)) {
         return;
       }
       params.forEach((param) => {
@@ -3983,11 +4611,11 @@ var preferNamedParamTypes = createRule51({
 var prefer_named_param_types_default = preferNamedParamTypes;
 
 // src/rules/prefer-props-with-children.ts
-var import_utils57 = require("@typescript-eslint/utils");
-var createRule52 = import_utils57.ESLintUtils.RuleCreator(
+var import_utils69 = require("@typescript-eslint/utils");
+var createRule60 = import_utils69.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var preferPropsWithChildren = createRule52({
+var preferPropsWithChildren = createRule60({
   name: "prefer-props-with-children",
   meta: {
     type: "suggestion",
@@ -4005,24 +4633,24 @@ var preferPropsWithChildren = createRule52({
       if (!typeNode) {
         return false;
       }
-      if (typeNode.type !== import_utils57.AST_NODE_TYPES.TSTypeReference) {
+      if (typeNode.type !== import_utils69.AST_NODE_TYPES.TSTypeReference) {
         return false;
       }
       const { typeName } = typeNode;
-      if (typeName.type === import_utils57.AST_NODE_TYPES.Identifier) {
+      if (typeName.type === import_utils69.AST_NODE_TYPES.Identifier) {
         return typeName.name === "ReactNode";
       }
-      if (typeName.type === import_utils57.AST_NODE_TYPES.TSQualifiedName && typeName.left.type === import_utils57.AST_NODE_TYPES.Identifier && typeName.left.name === "React" && typeName.right.type === import_utils57.AST_NODE_TYPES.Identifier && typeName.right.name === "ReactNode") {
+      if (typeName.type === import_utils69.AST_NODE_TYPES.TSQualifiedName && typeName.left.type === import_utils69.AST_NODE_TYPES.Identifier && typeName.left.name === "React" && typeName.right.type === import_utils69.AST_NODE_TYPES.Identifier && typeName.right.name === "ReactNode") {
         return true;
       }
       return false;
     }
     function findChildrenReactNode(members) {
       for (const member of members) {
-        if (member.type !== import_utils57.AST_NODE_TYPES.TSPropertySignature) {
+        if (member.type !== import_utils69.AST_NODE_TYPES.TSPropertySignature) {
           continue;
         }
-        if (member.key.type !== import_utils57.AST_NODE_TYPES.Identifier) {
+        if (member.key.type !== import_utils69.AST_NODE_TYPES.Identifier) {
           continue;
         }
         if (member.key.name !== "children") {
@@ -4062,11 +4690,11 @@ var preferPropsWithChildren = createRule52({
 var prefer_props_with_children_default = preferPropsWithChildren;
 
 // src/rules/prefer-react-import-types.ts
-var import_utils58 = require("@typescript-eslint/utils");
-var createRule53 = import_utils58.ESLintUtils.RuleCreator(
+var import_utils70 = require("@typescript-eslint/utils");
+var createRule61 = import_utils70.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var preferReactImportTypes = createRule53({
+var preferReactImportTypes = createRule61({
   name: "prefer-react-import-types",
   meta: {
     type: "suggestion",
@@ -4142,7 +4770,7 @@ var preferReactImportTypes = createRule53({
     ]);
     const allReactExports = /* @__PURE__ */ new Set([...reactTypes, ...reactRuntimeExports]);
     function checkMemberExpression(node) {
-      if (node.object.type === import_utils58.AST_NODE_TYPES.Identifier && node.object.name === "React" && node.property.type === import_utils58.AST_NODE_TYPES.Identifier && allReactExports.has(node.property.name)) {
+      if (node.object.type === import_utils70.AST_NODE_TYPES.Identifier && node.object.name === "React" && node.property.type === import_utils70.AST_NODE_TYPES.Identifier && allReactExports.has(node.property.name)) {
         const typeName = node.property.name;
         const isType = reactTypes.has(typeName);
         const importStatement = isType ? `import type { ${typeName} } from "react"` : `import { ${typeName} } from "react"`;
@@ -4159,7 +4787,7 @@ var preferReactImportTypes = createRule53({
     return {
       MemberExpression: checkMemberExpression,
       "TSTypeReference > TSQualifiedName": (node) => {
-        if (node.left.type === import_utils58.AST_NODE_TYPES.Identifier && node.left.name === "React" && node.right.type === import_utils58.AST_NODE_TYPES.Identifier && allReactExports.has(node.right.name)) {
+        if (node.left.type === import_utils70.AST_NODE_TYPES.Identifier && node.left.name === "React" && node.right.type === import_utils70.AST_NODE_TYPES.Identifier && allReactExports.has(node.right.name)) {
           const typeName = node.right.name;
           const isType = reactTypes.has(typeName);
           const importStatement = isType ? `import type { ${typeName} } from "react"` : `import { ${typeName} } from "react"`;
@@ -4179,11 +4807,11 @@ var preferReactImportTypes = createRule53({
 var prefer_react_import_types_default = preferReactImportTypes;
 
 // src/rules/react-props-destructure.ts
-var import_utils59 = require("@typescript-eslint/utils");
-var createRule54 = import_utils59.ESLintUtils.RuleCreator(
+var import_utils71 = require("@typescript-eslint/utils");
+var createRule62 = import_utils71.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var reactPropsDestructure = createRule54({
+var reactPropsDestructure = createRule62({
   name: "react-props-destructure",
   meta: {
     type: "suggestion",
@@ -4199,29 +4827,29 @@ var reactPropsDestructure = createRule54({
   defaultOptions: [],
   create(context) {
     function hasJSXInConditional(node) {
-      return node.consequent.type === import_utils59.AST_NODE_TYPES.JSXElement || node.consequent.type === import_utils59.AST_NODE_TYPES.JSXFragment || node.alternate.type === import_utils59.AST_NODE_TYPES.JSXElement || node.alternate.type === import_utils59.AST_NODE_TYPES.JSXFragment;
+      return node.consequent.type === import_utils71.AST_NODE_TYPES.JSXElement || node.consequent.type === import_utils71.AST_NODE_TYPES.JSXFragment || node.alternate.type === import_utils71.AST_NODE_TYPES.JSXElement || node.alternate.type === import_utils71.AST_NODE_TYPES.JSXFragment;
     }
     function hasJSXInLogical(node) {
-      return node.right.type === import_utils59.AST_NODE_TYPES.JSXElement || node.right.type === import_utils59.AST_NODE_TYPES.JSXFragment;
+      return node.right.type === import_utils71.AST_NODE_TYPES.JSXElement || node.right.type === import_utils71.AST_NODE_TYPES.JSXFragment;
     }
     function hasJSXReturn(block) {
       return block.body.some((stmt) => {
-        if (stmt.type === import_utils59.AST_NODE_TYPES.ReturnStatement && stmt.argument) {
-          return stmt.argument.type === import_utils59.AST_NODE_TYPES.JSXElement || stmt.argument.type === import_utils59.AST_NODE_TYPES.JSXFragment || stmt.argument.type === import_utils59.AST_NODE_TYPES.ConditionalExpression && hasJSXInConditional(stmt.argument) || stmt.argument.type === import_utils59.AST_NODE_TYPES.LogicalExpression && hasJSXInLogical(stmt.argument);
+        if (stmt.type === import_utils71.AST_NODE_TYPES.ReturnStatement && stmt.argument) {
+          return stmt.argument.type === import_utils71.AST_NODE_TYPES.JSXElement || stmt.argument.type === import_utils71.AST_NODE_TYPES.JSXFragment || stmt.argument.type === import_utils71.AST_NODE_TYPES.ConditionalExpression && hasJSXInConditional(stmt.argument) || stmt.argument.type === import_utils71.AST_NODE_TYPES.LogicalExpression && hasJSXInLogical(stmt.argument);
         }
         return false;
       });
     }
     function isReactComponent2(node) {
-      if (node.type === import_utils59.AST_NODE_TYPES.ArrowFunctionExpression) {
-        if (node.body.type === import_utils59.AST_NODE_TYPES.JSXElement || node.body.type === import_utils59.AST_NODE_TYPES.JSXFragment) {
+      if (node.type === import_utils71.AST_NODE_TYPES.ArrowFunctionExpression) {
+        if (node.body.type === import_utils71.AST_NODE_TYPES.JSXElement || node.body.type === import_utils71.AST_NODE_TYPES.JSXFragment) {
           return true;
         }
-        if (node.body.type === import_utils59.AST_NODE_TYPES.BlockStatement) {
+        if (node.body.type === import_utils71.AST_NODE_TYPES.BlockStatement) {
           return hasJSXReturn(node.body);
         }
-      } else if (node.type === import_utils59.AST_NODE_TYPES.FunctionExpression || node.type === import_utils59.AST_NODE_TYPES.FunctionDeclaration) {
-        if (node.body && node.body.type === import_utils59.AST_NODE_TYPES.BlockStatement) {
+      } else if (node.type === import_utils71.AST_NODE_TYPES.FunctionExpression || node.type === import_utils71.AST_NODE_TYPES.FunctionDeclaration) {
+        if (node.body && node.body.type === import_utils71.AST_NODE_TYPES.BlockStatement) {
           return hasJSXReturn(node.body);
         }
       }
@@ -4235,9 +4863,9 @@ var reactPropsDestructure = createRule54({
         return;
       }
       const param = node.params[0];
-      if (param.type === import_utils59.AST_NODE_TYPES.ObjectPattern) {
-        const properties = param.properties.filter((prop) => prop.type === import_utils59.AST_NODE_TYPES.Property).map((prop) => {
-          if (prop.key.type === import_utils59.AST_NODE_TYPES.Identifier) {
+      if (param.type === import_utils71.AST_NODE_TYPES.ObjectPattern) {
+        const properties = param.properties.filter((prop) => prop.type === import_utils71.AST_NODE_TYPES.Property).map((prop) => {
+          if (prop.key.type === import_utils71.AST_NODE_TYPES.Identifier) {
             return prop.key.name;
           }
           return null;
@@ -4264,57 +4892,57 @@ var reactPropsDestructure = createRule54({
 var react_props_destructure_default = reactPropsDestructure;
 
 // src/rules/require-explicit-return-type.ts
-var import_utils60 = require("@typescript-eslint/utils");
-var createRule55 = import_utils60.ESLintUtils.RuleCreator(
+var import_utils72 = require("@typescript-eslint/utils");
+var createRule63 = import_utils72.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var isReactComponent = (node) => {
-  if (node.type === import_utils60.AST_NODE_TYPES.ArrowFunctionExpression) {
+  if (node.type === import_utils72.AST_NODE_TYPES.ArrowFunctionExpression) {
     const { parent } = node;
-    if (parent?.type === import_utils60.AST_NODE_TYPES.VariableDeclarator) {
+    if (parent?.type === import_utils72.AST_NODE_TYPES.VariableDeclarator) {
       const { id } = parent;
-      if (id.type === import_utils60.AST_NODE_TYPES.Identifier) {
+      if (id.type === import_utils72.AST_NODE_TYPES.Identifier) {
         return /^[A-Z]/.test(id.name);
       }
     }
   }
-  if (node.type === import_utils60.AST_NODE_TYPES.FunctionDeclaration && node.id) {
+  if (node.type === import_utils72.AST_NODE_TYPES.FunctionDeclaration && node.id) {
     return /^[A-Z]/.test(node.id.name);
   }
   return false;
 };
 var isCallbackFunction = (node) => {
-  if (node.type === import_utils60.AST_NODE_TYPES.FunctionDeclaration) {
+  if (node.type === import_utils72.AST_NODE_TYPES.FunctionDeclaration) {
     return false;
   }
   const { parent } = node;
   if (!parent) {
     return false;
   }
-  if (parent.type === import_utils60.AST_NODE_TYPES.CallExpression && parent.arguments.includes(node)) {
+  if (parent.type === import_utils72.AST_NODE_TYPES.CallExpression && parent.arguments.includes(node)) {
     return true;
   }
-  if (parent.type === import_utils60.AST_NODE_TYPES.Property) {
+  if (parent.type === import_utils72.AST_NODE_TYPES.Property) {
     return true;
   }
-  if (parent.type === import_utils60.AST_NODE_TYPES.ArrayExpression) {
+  if (parent.type === import_utils72.AST_NODE_TYPES.ArrayExpression) {
     return true;
   }
   return false;
 };
 var getFunctionName = (node) => {
-  if (node.type === import_utils60.AST_NODE_TYPES.FunctionDeclaration && node.id) {
+  if (node.type === import_utils72.AST_NODE_TYPES.FunctionDeclaration && node.id) {
     return node.id.name;
   }
-  if (node.type === import_utils60.AST_NODE_TYPES.FunctionExpression && node.id) {
+  if (node.type === import_utils72.AST_NODE_TYPES.FunctionExpression && node.id) {
     return node.id.name;
   }
-  if ((node.type === import_utils60.AST_NODE_TYPES.ArrowFunctionExpression || node.type === import_utils60.AST_NODE_TYPES.FunctionExpression) && node.parent?.type === import_utils60.AST_NODE_TYPES.VariableDeclarator && node.parent.id.type === import_utils60.AST_NODE_TYPES.Identifier) {
+  if ((node.type === import_utils72.AST_NODE_TYPES.ArrowFunctionExpression || node.type === import_utils72.AST_NODE_TYPES.FunctionExpression) && node.parent?.type === import_utils72.AST_NODE_TYPES.VariableDeclarator && node.parent.id.type === import_utils72.AST_NODE_TYPES.Identifier) {
     return node.parent.id.name;
   }
   return null;
 };
-var requireExplicitReturnType = createRule55({
+var requireExplicitReturnType = createRule63({
   name: "require-explicit-return-type",
   meta: {
     type: "suggestion",
@@ -4363,8 +4991,8 @@ var requireExplicitReturnType = createRule55({
 var require_explicit_return_type_default = requireExplicitReturnType;
 
 // src/rules/sort-exports.ts
-var import_utils61 = require("@typescript-eslint/utils");
-var createRule56 = import_utils61.ESLintUtils.RuleCreator(
+var import_utils73 = require("@typescript-eslint/utils");
+var createRule64 = import_utils73.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var GROUP_NAMES = ["", "external/alias re-export", "relative re-export", "local export"];
@@ -4378,7 +5006,7 @@ function getExportGroup(node) {
   }
   return 1;
 }
-var sortExports = createRule56({
+var sortExports = createRule64({
   name: "sort-exports",
   meta: {
     type: "suggestion",
@@ -4418,7 +5046,7 @@ var sortExports = createRule56({
       Program(node) {
         const exportGroups = [];
         node.body.forEach((statement) => {
-          if (statement.type !== import_utils61.AST_NODE_TYPES.ExportNamedDeclaration || statement.declaration !== null) {
+          if (statement.type !== import_utils73.AST_NODE_TYPES.ExportNamedDeclaration || statement.declaration !== null) {
             if (exportGroups.length > 0) {
               checkOrder(exportGroups);
               exportGroups.length = 0;
@@ -4437,8 +5065,8 @@ var sortExports = createRule56({
 var sort_exports_default = sortExports;
 
 // src/rules/sort-imports.ts
-var import_utils62 = require("@typescript-eslint/utils");
-var createRule57 = import_utils62.ESLintUtils.RuleCreator(
+var import_utils74 = require("@typescript-eslint/utils");
+var createRule65 = import_utils74.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var NODE_BUILTINS = /* @__PURE__ */ new Set([
@@ -4505,7 +5133,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",
@@ -4549,7 +5177,7 @@ var sortImports = createRule57({
       Program(node) {
         const importGroups = [];
         node.body.forEach((statement) => {
-          if (statement.type !== import_utils62.AST_NODE_TYPES.ImportDeclaration) {
+          if (statement.type !== import_utils74.AST_NODE_TYPES.ImportDeclaration) {
             if (importGroups.length > 0) {
               checkOrder(importGroups);
               importGroups.length = 0;
@@ -4571,13 +5199,13 @@ var sortImports = createRule57({
 var sort_imports_default = sortImports;
 
 // src/rules/sort-type-alphabetically.ts
-var import_utils63 = require("@typescript-eslint/utils");
-var createRule58 = import_utils63.ESLintUtils.RuleCreator(
+var import_utils75 = require("@typescript-eslint/utils");
+var createRule66 = import_utils75.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 function isAlphabeticallySortedWithinGroups(members) {
   const properties = members.filter(
-    (member) => member.type === import_utils63.AST_NODE_TYPES.TSPropertySignature && member.key.type === import_utils63.AST_NODE_TYPES.Identifier
+    (member) => member.type === import_utils75.AST_NODE_TYPES.TSPropertySignature && member.key.type === import_utils75.AST_NODE_TYPES.Identifier
   );
   if (properties.length < 2) {
     return true;
@@ -4588,7 +5216,7 @@ function isAlphabeticallySortedWithinGroups(members) {
   const isOptionalSorted = optional.every((name, index) => index === 0 || optional[index - 1].localeCompare(name) <= 0);
   return isRequiredSorted && isOptionalSorted;
 }
-var sortTypeAlphabetically = createRule58({
+var sortTypeAlphabetically = createRule66({
   name: "sort-type-alphabetically",
   meta: {
     type: "suggestion",
@@ -4606,7 +5234,7 @@ var sortTypeAlphabetically = createRule58({
     function fixMembers(fixer, members) {
       const { sourceCode } = context;
       const properties = members.filter(
-        (member) => member.type === import_utils63.AST_NODE_TYPES.TSPropertySignature && member.key.type === import_utils63.AST_NODE_TYPES.Identifier
+        (member) => member.type === import_utils75.AST_NODE_TYPES.TSPropertySignature && member.key.type === import_utils75.AST_NODE_TYPES.Identifier
       );
       const required = properties.filter((prop) => !prop.optional);
       const optional = properties.filter((prop) => prop.optional);
@@ -4643,7 +5271,7 @@ var sortTypeAlphabetically = createRule58({
         }
       },
       TSTypeAliasDeclaration(node) {
-        if (node.typeAnnotation.type !== import_utils63.AST_NODE_TYPES.TSTypeLiteral) {
+        if (node.typeAnnotation.type !== import_utils75.AST_NODE_TYPES.TSTypeLiteral) {
           return;
         }
         const { members } = node.typeAnnotation;
@@ -4663,13 +5291,13 @@ var sortTypeAlphabetically = createRule58({
 var sort_type_alphabetically_default = sortTypeAlphabetically;
 
 // src/rules/sort-type-required-first.ts
-var import_utils64 = require("@typescript-eslint/utils");
-var createRule59 = import_utils64.ESLintUtils.RuleCreator(
+var import_utils76 = require("@typescript-eslint/utils");
+var createRule67 = import_utils76.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 function isRequiredBeforeOptional(members) {
   const properties = members.filter(
-    (member) => member.type === import_utils64.AST_NODE_TYPES.TSPropertySignature && member.key.type === import_utils64.AST_NODE_TYPES.Identifier
+    (member) => member.type === import_utils76.AST_NODE_TYPES.TSPropertySignature && member.key.type === import_utils76.AST_NODE_TYPES.Identifier
   );
   if (properties.length < 2) {
     return true;
@@ -4680,7 +5308,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",
@@ -4698,7 +5326,7 @@ var sortTypeRequiredFirst = createRule59({
     function fixMembers(fixer, members) {
       const { sourceCode } = context;
       const properties = members.filter(
-        (member) => member.type === import_utils64.AST_NODE_TYPES.TSPropertySignature && member.key.type === import_utils64.AST_NODE_TYPES.Identifier
+        (member) => member.type === import_utils76.AST_NODE_TYPES.TSPropertySignature && member.key.type === import_utils76.AST_NODE_TYPES.Identifier
       );
       const required = properties.filter((prop) => !prop.optional);
       const optional = properties.filter((prop) => prop.optional);
@@ -4719,7 +5347,7 @@ var sortTypeRequiredFirst = createRule59({
         }
       },
       TSTypeAliasDeclaration(node) {
-        if (node.typeAnnotation.type !== import_utils64.AST_NODE_TYPES.TSTypeLiteral) {
+        if (node.typeAnnotation.type !== import_utils76.AST_NODE_TYPES.TSTypeLiteral) {
           return;
         }
         const { members } = node.typeAnnotation;
@@ -4747,18 +5375,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,
@@ -4772,6 +5406,8 @@ var rules = {
   "no-emoji": no_emoji_default,
   "no-env-fallback": no_env_fallback_default,
   "no-ghost-wrapper": no_ghost_wrapper_default,
+  "no-helper-function-in-hook": no_helper_function_in_hook_default,
+  "no-helper-function-in-test": no_helper_function_in_test_default,
   "no-inline-default-export": no_inline_default_export_default,
   "no-inline-nested-object": no_inline_nested_object_default,
   "no-inline-return-properties": no_inline_return_properties_default,
@@ -4812,9 +5448,11 @@ var baseRules = {
   "nextfriday/boolean-naming-prefix": "warn",
   "nextfriday/enforce-camel-case": "warn",
   "nextfriday/enforce-constant-case": "warn",
+  "nextfriday/enforce-hook-filename": "warn",
   "nextfriday/enforce-hook-naming": "warn",
   "nextfriday/enforce-property-case": "warn",
   "nextfriday/enforce-service-naming": "warn",
+  "nextfriday/enforce-test-filename": "warn",
   "nextfriday/enforce-sorted-destructuring": "warn",
   "nextfriday/enforce-type-declaration-order": "warn",
   "nextfriday/index-export-only": "warn",
@@ -4854,9 +5492,11 @@ var baseRecommendedRules = {
   "nextfriday/boolean-naming-prefix": "error",
   "nextfriday/enforce-camel-case": "error",
   "nextfriday/enforce-constant-case": "error",
+  "nextfriday/enforce-hook-filename": "error",
   "nextfriday/enforce-hook-naming": "error",
   "nextfriday/enforce-property-case": "error",
   "nextfriday/enforce-service-naming": "error",
+  "nextfriday/enforce-test-filename": "error",
   "nextfriday/enforce-sorted-destructuring": "error",
   "nextfriday/enforce-type-declaration-order": "error",
   "nextfriday/index-export-only": "error",
@@ -4895,10 +5535,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",
@@ -4916,10 +5560,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",