eslint-plugin-nextfriday 4.0.0 → 4.2.0

package/lib/index.js

@@ -1,7 +1,7 @@
 // package.json
 var package_default = {
   name: "eslint-plugin-nextfriday",
-  version: "4.0.0",
+  version: "4.2.0",
   description: "A comprehensive ESLint plugin providing custom rules and configurations for Next Friday development workflows.",
   keywords: [
     "eslint",
@@ -765,18 +765,168 @@ var enforceReadonlyComponentProps = createRule7({
 });
 var enforce_readonly_component_props_default = enforceReadonlyComponentProps;
 
-// src/rules/enforce-service-naming.ts
+// src/rules/enforce-render-naming.ts
 import { AST_NODE_TYPES as AST_NODE_TYPES9, ESLintUtils as ESLintUtils8 } from "@typescript-eslint/utils";
 var createRule8 = ESLintUtils8.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
+var ARRAY_RETURNING_METHODS = /* @__PURE__ */ new Set(["map", "flatMap", "filter"]);
+function hasRenderPrefix(name) {
+  if (!name.startsWith("render")) {
+    return false;
+  }
+  if (name.length === "render".length) {
+    return true;
+  }
+  const nextChar = name["render".length];
+  return nextChar === nextChar.toUpperCase() && nextChar !== nextChar.toLowerCase();
+}
+function functionBodyReturnsJsx(body) {
+  if (body.type === AST_NODE_TYPES9.JSXElement || body.type === AST_NODE_TYPES9.JSXFragment) {
+    return true;
+  }
+  if (body.type === AST_NODE_TYPES9.ConditionalExpression) {
+    return isJsxProducingExpression(body.consequent) || isJsxProducingExpression(body.alternate);
+  }
+  if (body.type === AST_NODE_TYPES9.LogicalExpression) {
+    return isJsxProducingExpression(body.right);
+  }
+  if (body.type !== AST_NODE_TYPES9.BlockStatement) {
+    return false;
+  }
+  for (const statement of body.body) {
+    if (statement.type === AST_NODE_TYPES9.ReturnStatement && statement.argument) {
+      if (isJsxProducingExpression(statement.argument)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function isJsxProducingExpression(node) {
+  if (node.type === AST_NODE_TYPES9.JSXElement || node.type === AST_NODE_TYPES9.JSXFragment) {
+    return true;
+  }
+  if (node.type === AST_NODE_TYPES9.ConditionalExpression) {
+    return isJsxProducingExpression(node.consequent) || isJsxProducingExpression(node.alternate);
+  }
+  if (node.type === AST_NODE_TYPES9.LogicalExpression) {
+    return isJsxProducingExpression(node.right);
+  }
+  if (node.type === AST_NODE_TYPES9.ArrayExpression) {
+    return node.elements.some((element) => {
+      if (!element || element.type === AST_NODE_TYPES9.SpreadElement) {
+        return false;
+      }
+      return isJsxProducingExpression(element);
+    });
+  }
+  if (node.type === AST_NODE_TYPES9.ArrowFunctionExpression || node.type === AST_NODE_TYPES9.FunctionExpression) {
+    return functionBodyReturnsJsx(node.body);
+  }
+  if (node.type === AST_NODE_TYPES9.CallExpression) {
+    if (node.callee.type === AST_NODE_TYPES9.MemberExpression && node.callee.property.type === AST_NODE_TYPES9.Identifier && ARRAY_RETURNING_METHODS.has(node.callee.property.name)) {
+      const callback = node.arguments[0];
+      if (callback && (callback.type === AST_NODE_TYPES9.ArrowFunctionExpression || callback.type === AST_NODE_TYPES9.FunctionExpression)) {
+        return functionBodyReturnsJsx(callback.body);
+      }
+    }
+  }
+  if (node.type === AST_NODE_TYPES9.TSAsExpression || node.type === AST_NODE_TYPES9.TSSatisfiesExpression) {
+    return isJsxProducingExpression(node.expression);
+  }
+  return false;
+}
+function isPascalCase(name) {
+  return /^[A-Z]/.test(name);
+}
+function isComponentFunction2(node) {
+  if (node.type === AST_NODE_TYPES9.FunctionDeclaration && node.id && isPascalCase(node.id.name)) {
+    return true;
+  }
+  const parent = node.parent;
+  if (parent?.type === AST_NODE_TYPES9.VariableDeclarator && parent.id.type === AST_NODE_TYPES9.Identifier && isPascalCase(parent.id.name)) {
+    return true;
+  }
+  return false;
+}
+var enforceRenderNaming = createRule8({
+  name: "enforce-render-naming",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Enforce 'render' prefix for variables that hold or return JSX inside React components"
+    },
+    schema: [],
+    messages: {
+      missingRenderPrefix: "Variable '{{ name }}' holds JSX-producing content inside a component. Rename it to 'render{{ pascalName }}' so the intent is explicit."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    const { filename } = context;
+    const extension = getFileExtension(filename);
+    if (extension !== "tsx" && extension !== "jsx") {
+      return {};
+    }
+    const componentStack = [];
+    function isInsideComponent() {
+      return componentStack.some((value) => value);
+    }
+    function pushFunction(node) {
+      componentStack.push(isComponentFunction2(node));
+    }
+    function popFunction() {
+      componentStack.pop();
+    }
+    return {
+      ArrowFunctionExpression: pushFunction,
+      FunctionDeclaration: pushFunction,
+      FunctionExpression: pushFunction,
+      "ArrowFunctionExpression:exit": popFunction,
+      "FunctionDeclaration:exit": popFunction,
+      "FunctionExpression:exit": popFunction,
+      VariableDeclarator(node) {
+        if (!isInsideComponent()) {
+          return;
+        }
+        if (node.id.type !== AST_NODE_TYPES9.Identifier) {
+          return;
+        }
+        if (!node.init) {
+          return;
+        }
+        if (!isJsxProducingExpression(node.init)) {
+          return;
+        }
+        const name = node.id.name;
+        if (hasRenderPrefix(name)) {
+          return;
+        }
+        const pascalName = name.charAt(0).toUpperCase() + name.slice(1);
+        context.report({
+          node: node.id,
+          messageId: "missingRenderPrefix",
+          data: { name, pascalName }
+        });
+      }
+    };
+  }
+});
+var enforce_render_naming_default = enforceRenderNaming;
+
+// src/rules/enforce-service-naming.ts
+import { AST_NODE_TYPES as AST_NODE_TYPES10, ESLintUtils as ESLintUtils9 } from "@typescript-eslint/utils";
+var createRule9 = ESLintUtils9.RuleCreator(
+  (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
+);
 var BANNED_PREFIXES = {
   delete: ["remove", "archive"],
   do: ["submit", "process"],
   handle: ["create", "verify"],
   set: ["update", "save", "patch"]
 };
-var enforceServiceNaming = createRule8({
+var enforceServiceNaming = createRule9({
   name: "enforce-service-naming",
   meta: {
     type: "suggestion",
@@ -819,12 +969,12 @@ var enforceServiceNaming = createRule8({
     };
     return {
       ExportNamedDeclaration(node) {
-        if (node.declaration?.type === AST_NODE_TYPES9.FunctionDeclaration && node.declaration.id) {
+        if (node.declaration?.type === AST_NODE_TYPES10.FunctionDeclaration && node.declaration.id) {
           checkExportedFunction(node.declaration, node.declaration.id);
         }
-        if (node.declaration?.type === AST_NODE_TYPES9.VariableDeclaration) {
+        if (node.declaration?.type === AST_NODE_TYPES10.VariableDeclaration) {
           node.declaration.declarations.forEach((declarator) => {
-            if (declarator.id.type === AST_NODE_TYPES9.Identifier && declarator.init?.type === AST_NODE_TYPES9.ArrowFunctionExpression) {
+            if (declarator.id.type === AST_NODE_TYPES10.Identifier && declarator.init?.type === AST_NODE_TYPES10.ArrowFunctionExpression) {
               checkExportedFunction(declarator.init, declarator.id);
             }
           });
@@ -836,11 +986,11 @@ var enforceServiceNaming = createRule8({
 var enforce_service_naming_default = enforceServiceNaming;
 
 // src/rules/enforce-sorted-destructuring.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES10, ESLintUtils as ESLintUtils9 } from "@typescript-eslint/utils";
-var createRule9 = ESLintUtils9.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES11, ESLintUtils as ESLintUtils10 } from "@typescript-eslint/utils";
+var createRule10 = ESLintUtils10.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var enforceSortedDestructuring = createRule9({
+var enforceSortedDestructuring = createRule10({
   name: "enforce-sorted-destructuring",
   meta: {
     type: "suggestion",
@@ -856,19 +1006,19 @@ var enforceSortedDestructuring = createRule9({
   defaultOptions: [],
   create(context) {
     function getPropertyName(property) {
-      if (property.type === AST_NODE_TYPES10.RestElement) {
+      if (property.type === AST_NODE_TYPES11.RestElement) {
         return null;
       }
-      if (property.key.type === AST_NODE_TYPES10.Identifier) {
+      if (property.key.type === AST_NODE_TYPES11.Identifier) {
         return property.key.name;
       }
       return null;
     }
     function hasDefaultValue(property) {
-      return property.value.type === AST_NODE_TYPES10.AssignmentPattern && Boolean(property.value.right);
+      return property.value.type === AST_NODE_TYPES11.AssignmentPattern && Boolean(property.value.right);
     }
     function checkVariableDeclarator(node) {
-      if (node.id.type !== AST_NODE_TYPES10.ObjectPattern) {
+      if (node.id.type !== AST_NODE_TYPES11.ObjectPattern) {
         return;
       }
       const { properties } = node.id;
@@ -876,7 +1026,7 @@ var enforceSortedDestructuring = createRule9({
         return;
       }
       const propertyInfo = properties.map((prop) => {
-        if (prop.type === AST_NODE_TYPES10.RestElement) {
+        if (prop.type === AST_NODE_TYPES11.RestElement) {
           return null;
         }
         return {
@@ -915,20 +1065,20 @@ var enforceSortedDestructuring = createRule9({
 var enforce_sorted_destructuring_default = enforceSortedDestructuring;
 
 // src/rules/enforce-type-declaration-order.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES11, ESLintUtils as ESLintUtils10 } from "@typescript-eslint/utils";
-var createRule10 = ESLintUtils10.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES12, ESLintUtils as ESLintUtils11 } from "@typescript-eslint/utils";
+var createRule11 = ESLintUtils11.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 function getTypeDeclarationName(node) {
-  if (node.type === AST_NODE_TYPES11.TSInterfaceDeclaration && node.id.type === AST_NODE_TYPES11.Identifier) {
+  if (node.type === AST_NODE_TYPES12.TSInterfaceDeclaration && node.id.type === AST_NODE_TYPES12.Identifier) {
     return { name: node.id.name, position: node.range[0] };
   }
-  if (node.type === AST_NODE_TYPES11.TSTypeAliasDeclaration && node.id.type === AST_NODE_TYPES11.Identifier) {
+  if (node.type === AST_NODE_TYPES12.TSTypeAliasDeclaration && node.id.type === AST_NODE_TYPES12.Identifier) {
     return { name: node.id.name, position: node.range[0] };
   }
   return null;
 }
-var enforceTypeDeclarationOrder = createRule10({
+var enforceTypeDeclarationOrder = createRule11({
   name: "enforce-type-declaration-order",
   meta: {
     type: "suggestion",
@@ -959,7 +1109,7 @@ var enforceTypeDeclarationOrder = createRule10({
         }
       },
       "TSPropertySignature TSTypeReference": function checkTypeReference(node) {
-        if (node.typeName.type !== AST_NODE_TYPES11.Identifier) {
+        if (node.typeName.type !== AST_NODE_TYPES12.Identifier) {
           return;
         }
         const referencedName = node.typeName.name;
@@ -996,8 +1146,8 @@ var enforceTypeDeclarationOrder = createRule10({
 var enforce_type_declaration_order_default = enforceTypeDeclarationOrder;
 
 // src/rules/index-export-only.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES12, ESLintUtils as ESLintUtils11 } from "@typescript-eslint/utils";
-var createRule11 = ESLintUtils11.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES13, ESLintUtils as ESLintUtils12 } from "@typescript-eslint/utils";
+var createRule12 = ESLintUtils12.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var isIndexFile = (filename) => getBaseName(filename) === "index";
@@ -1005,26 +1155,26 @@ var isAllowedExportNamed = (node) => {
   if (!node.declaration) {
     return true;
   }
-  return node.declaration.type === AST_NODE_TYPES12.TSTypeAliasDeclaration || node.declaration.type === AST_NODE_TYPES12.TSInterfaceDeclaration;
+  return node.declaration.type === AST_NODE_TYPES13.TSTypeAliasDeclaration || node.declaration.type === AST_NODE_TYPES13.TSInterfaceDeclaration;
 };
-var isAllowedExportDefault = (node) => node.declaration.type === AST_NODE_TYPES12.Identifier;
+var isAllowedExportDefault = (node) => node.declaration.type === AST_NODE_TYPES13.Identifier;
 var isAllowedTopLevel = (node) => {
   switch (node.type) {
-    case AST_NODE_TYPES12.ImportDeclaration:
-    case AST_NODE_TYPES12.ExportAllDeclaration:
-    case AST_NODE_TYPES12.TSTypeAliasDeclaration:
-    case AST_NODE_TYPES12.TSInterfaceDeclaration:
-    case AST_NODE_TYPES12.TSImportEqualsDeclaration:
+    case AST_NODE_TYPES13.ImportDeclaration:
+    case AST_NODE_TYPES13.ExportAllDeclaration:
+    case AST_NODE_TYPES13.TSTypeAliasDeclaration:
+    case AST_NODE_TYPES13.TSInterfaceDeclaration:
+    case AST_NODE_TYPES13.TSImportEqualsDeclaration:
       return true;
-    case AST_NODE_TYPES12.ExportNamedDeclaration:
+    case AST_NODE_TYPES13.ExportNamedDeclaration:
       return isAllowedExportNamed(node);
-    case AST_NODE_TYPES12.ExportDefaultDeclaration:
+    case AST_NODE_TYPES13.ExportDefaultDeclaration:
       return isAllowedExportDefault(node);
     default:
       return false;
   }
 };
-var indexExportOnly = createRule11({
+var indexExportOnly = createRule12({
   name: "index-export-only",
   meta: {
     type: "suggestion",
@@ -1058,11 +1208,11 @@ var indexExportOnly = createRule11({
 var index_export_only_default = indexExportOnly;
 
 // src/rules/jsx-newline-between-elements.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES13, ESLintUtils as ESLintUtils12 } from "@typescript-eslint/utils";
-var createRule12 = ESLintUtils12.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES14, ESLintUtils as ESLintUtils13 } from "@typescript-eslint/utils";
+var createRule13 = ESLintUtils13.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var jsxNewlineBetweenElements = createRule12({
+var jsxNewlineBetweenElements = createRule13({
   name: "jsx-newline-between-elements",
   meta: {
     type: "layout",
@@ -1080,7 +1230,7 @@ var jsxNewlineBetweenElements = createRule12({
   create(context) {
     const { sourceCode } = context;
     function isSignificantJSXChild(node) {
-      return node.type === AST_NODE_TYPES13.JSXElement || node.type === AST_NODE_TYPES13.JSXFragment || node.type === AST_NODE_TYPES13.JSXExpressionContainer;
+      return node.type === AST_NODE_TYPES14.JSXElement || node.type === AST_NODE_TYPES14.JSXFragment || node.type === AST_NODE_TYPES14.JSXExpressionContainer;
     }
     function isMultiLine(node) {
       return node.loc.start.line !== node.loc.end.line;
@@ -1129,12 +1279,194 @@ var jsxNewlineBetweenElements = createRule12({
 });
 var jsx_newline_between_elements_default = jsxNewlineBetweenElements;
 
+// src/rules/jsx-no-data-array.ts
+import { AST_NODE_TYPES as AST_NODE_TYPES15, ESLintUtils as ESLintUtils14 } from "@typescript-eslint/utils";
+var createRule14 = ESLintUtils14.RuleCreator(
+  (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
+);
+function isObjectLikeElement(node) {
+  if (!node) {
+    return false;
+  }
+  if (node.type === AST_NODE_TYPES15.ObjectExpression) {
+    return true;
+  }
+  if (node.type === AST_NODE_TYPES15.TSAsExpression || node.type === AST_NODE_TYPES15.TSSatisfiesExpression) {
+    return isObjectLikeElement(node.expression);
+  }
+  return false;
+}
+function getArrayInitializer(init) {
+  if (!init) {
+    return null;
+  }
+  if (init.type === AST_NODE_TYPES15.ArrayExpression) {
+    return init;
+  }
+  if (init.type === AST_NODE_TYPES15.TSAsExpression || init.type === AST_NODE_TYPES15.TSSatisfiesExpression) {
+    return getArrayInitializer(init.expression);
+  }
+  return null;
+}
+var jsxNoDataArray = createRule14({
+  name: "jsx-no-data-array",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow top-level arrays of object literals in .tsx/.jsx files (extract to a data file)"
+    },
+    schema: [],
+    messages: {
+      noDataArray: "Top-level array of object literals belongs in a data file (e.g. *.data.ts), not a .tsx/.jsx component file. Extract '{{ name }}' to a sibling data module."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    const { filename } = context;
+    const extension = getFileExtension(filename);
+    if (extension !== "tsx" && extension !== "jsx") {
+      return {};
+    }
+    return {
+      "Program > VariableDeclaration > VariableDeclarator": function checkDeclarator(node) {
+        const arrayInit = getArrayInitializer(node.init);
+        if (!arrayInit) {
+          return;
+        }
+        const hasObjectElement = arrayInit.elements.some((element) => isObjectLikeElement(element));
+        if (!hasObjectElement) {
+          return;
+        }
+        const name = node.id.type === AST_NODE_TYPES15.Identifier ? node.id.name : "<destructured>";
+        context.report({
+          node,
+          messageId: "noDataArray",
+          data: { name }
+        });
+      },
+      "Program > ExportNamedDeclaration > VariableDeclaration > VariableDeclarator": function checkExportedDeclarator(node) {
+        const arrayInit = getArrayInitializer(node.init);
+        if (!arrayInit) {
+          return;
+        }
+        const hasObjectElement = arrayInit.elements.some((element) => isObjectLikeElement(element));
+        if (!hasObjectElement) {
+          return;
+        }
+        const name = node.id.type === AST_NODE_TYPES15.Identifier ? node.id.name : "<destructured>";
+        context.report({
+          node,
+          messageId: "noDataArray",
+          data: { name }
+        });
+      }
+    };
+  }
+});
+var jsx_no_data_array_default = jsxNoDataArray;
+
+// src/rules/jsx-no-data-object.ts
+import { AST_NODE_TYPES as AST_NODE_TYPES16, ESLintUtils as ESLintUtils15 } from "@typescript-eslint/utils";
+var createRule15 = ESLintUtils15.RuleCreator(
+  (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
+);
+function unwrapAssertion(node) {
+  if (!node) {
+    return null;
+  }
+  if (node.type === AST_NODE_TYPES16.TSAsExpression || node.type === AST_NODE_TYPES16.TSSatisfiesExpression) {
+    return unwrapAssertion(node.expression);
+  }
+  return node;
+}
+function isNestedValue(value) {
+  const unwrapped = unwrapAssertion(value);
+  if (!unwrapped) {
+    return false;
+  }
+  if (unwrapped.type === AST_NODE_TYPES16.ObjectExpression) {
+    return true;
+  }
+  if (unwrapped.type === AST_NODE_TYPES16.ArrayExpression) {
+    return unwrapped.elements.some((element) => {
+      if (!element || element.type === AST_NODE_TYPES16.SpreadElement) {
+        return false;
+      }
+      const inner = unwrapAssertion(element);
+      return inner?.type === AST_NODE_TYPES16.ObjectExpression || inner?.type === AST_NODE_TYPES16.ArrayExpression;
+    });
+  }
+  return false;
+}
+function hasNestedProperty(object) {
+  return object.properties.some((property) => {
+    if (property.type !== AST_NODE_TYPES16.Property) {
+      return false;
+    }
+    if (property.value.type === AST_NODE_TYPES16.AssignmentPattern) {
+      return false;
+    }
+    return isNestedValue(property.value);
+  });
+}
+function getObjectInitializer(init) {
+  const unwrapped = unwrapAssertion(init);
+  if (!unwrapped) {
+    return null;
+  }
+  if (unwrapped.type === AST_NODE_TYPES16.ObjectExpression) {
+    return unwrapped;
+  }
+  return null;
+}
+var jsxNoDataObject = createRule15({
+  name: "jsx-no-data-object",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow top-level nested object literals in .tsx/.jsx files (extract to a data file)"
+    },
+    schema: [],
+    messages: {
+      noDataObject: "Top-level nested object literal belongs in a data file (e.g. *.data.ts), not a .tsx/.jsx component file. Extract '{{ name }}' to a sibling data module."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    const { filename } = context;
+    const extension = getFileExtension(filename);
+    if (extension !== "tsx" && extension !== "jsx") {
+      return {};
+    }
+    function checkDeclarator(node) {
+      const objectInit = getObjectInitializer(node.init);
+      if (!objectInit) {
+        return;
+      }
+      if (!hasNestedProperty(objectInit)) {
+        return;
+      }
+      const name = node.id.type === AST_NODE_TYPES16.Identifier ? node.id.name : "<destructured>";
+      context.report({
+        node,
+        messageId: "noDataObject",
+        data: { name }
+      });
+    }
+    return {
+      "Program > VariableDeclaration > VariableDeclarator": checkDeclarator,
+      "Program > ExportNamedDeclaration > VariableDeclaration > VariableDeclarator": checkDeclarator
+    };
+  }
+});
+var jsx_no_data_object_default = jsxNoDataObject;
+
 // src/rules/jsx-no-inline-object-prop.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES14, ESLintUtils as ESLintUtils13 } from "@typescript-eslint/utils";
-var createRule13 = ESLintUtils13.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES17, ESLintUtils as ESLintUtils16 } from "@typescript-eslint/utils";
+var createRule16 = ESLintUtils16.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var jsxNoInlineObjectProp = createRule13({
+var jsxNoInlineObjectProp = createRule16({
   name: "jsx-no-inline-object-prop",
   meta: {
     type: "suggestion",
@@ -1150,7 +1482,7 @@ var jsxNoInlineObjectProp = createRule13({
   create(context) {
     return {
       JSXAttribute(node) {
-        if (node.value?.type === AST_NODE_TYPES14.JSXExpressionContainer && node.value.expression.type === AST_NODE_TYPES14.ObjectExpression) {
+        if (node.value?.type === AST_NODE_TYPES17.JSXExpressionContainer && node.value.expression.type === AST_NODE_TYPES17.ObjectExpression) {
           context.report({
             node: node.value,
             messageId: "noInlineObject"
@@ -1163,17 +1495,17 @@ var jsxNoInlineObjectProp = createRule13({
 var jsx_no_inline_object_prop_default = jsxNoInlineObjectProp;
 
 // src/rules/jsx-no-newline-single-line-elements.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES15, ESLintUtils as ESLintUtils14 } from "@typescript-eslint/utils";
-var createRule14 = ESLintUtils14.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES18, ESLintUtils as ESLintUtils17 } from "@typescript-eslint/utils";
+var createRule17 = ESLintUtils17.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 function isJSXElementOrFragment(node) {
-  return node.type === AST_NODE_TYPES15.JSXElement || node.type === AST_NODE_TYPES15.JSXFragment;
+  return node.type === AST_NODE_TYPES18.JSXElement || node.type === AST_NODE_TYPES18.JSXFragment;
 }
 function isSingleLine(node) {
   return node.loc.start.line === node.loc.end.line;
 }
-var jsxNoNewlineSingleLineElements = createRule14({
+var jsxNoNewlineSingleLineElements = createRule17({
   name: "jsx-no-newline-single-line-elements",
   meta: {
     type: "layout",
@@ -1191,7 +1523,7 @@ var jsxNoNewlineSingleLineElements = createRule14({
     const { sourceCode } = context;
     function checkSiblings(children) {
       const nonWhitespace = children.filter(
-        (child) => !(child.type === AST_NODE_TYPES15.JSXText && child.value.trim() === "")
+        (child) => !(child.type === AST_NODE_TYPES18.JSXText && child.value.trim() === "")
       );
       nonWhitespace.forEach((next, index) => {
         if (index === 0) {
@@ -1242,11 +1574,11 @@ ${indent}`);
 var jsx_no_newline_single_line_elements_default = jsxNoNewlineSingleLineElements;
 
 // src/rules/jsx-no-non-component-function.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES16, ESLintUtils as ESLintUtils15 } from "@typescript-eslint/utils";
-var createRule15 = ESLintUtils15.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES19, ESLintUtils as ESLintUtils18 } from "@typescript-eslint/utils";
+var createRule18 = ESLintUtils18.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var jsxNoNonComponentFunction = createRule15({
+var jsxNoNonComponentFunction = createRule18({
   name: "jsx-no-non-component-function",
   meta: {
     type: "problem",
@@ -1266,13 +1598,13 @@ var jsxNoNonComponentFunction = createRule15({
       return {};
     }
     function isReactComponent2(node) {
-      const functionName = node.type === AST_NODE_TYPES16.FunctionDeclaration && node.id ? node.id.name : null;
+      const functionName = node.type === AST_NODE_TYPES19.FunctionDeclaration && node.id ? node.id.name : null;
       if (functionName && /^[A-Z]/.test(functionName)) {
         return true;
       }
       if (node.returnType?.typeAnnotation) {
         const returnTypeNode = node.returnType.typeAnnotation;
-        if (returnTypeNode.type === AST_NODE_TYPES16.TSTypeReference && returnTypeNode.typeName.type === AST_NODE_TYPES16.Identifier) {
+        if (returnTypeNode.type === AST_NODE_TYPES19.TSTypeReference && returnTypeNode.typeName.type === AST_NODE_TYPES19.Identifier) {
           const typeName = returnTypeNode.typeName.name;
           if (typeName === "JSX" || typeName === "ReactElement" || typeName === "ReactNode") {
             return true;
@@ -1289,13 +1621,13 @@ var jsxNoNonComponentFunction = createRule15({
       if (!parent) {
         return;
       }
-      if (parent.type === AST_NODE_TYPES16.ExportDefaultDeclaration || parent.type === AST_NODE_TYPES16.ExportNamedDeclaration) {
+      if (parent.type === AST_NODE_TYPES19.ExportDefaultDeclaration || parent.type === AST_NODE_TYPES19.ExportNamedDeclaration) {
         return;
       }
-      if (declaratorNode?.parent?.parent?.type === AST_NODE_TYPES16.ExportNamedDeclaration) {
+      if (declaratorNode?.parent?.parent?.type === AST_NODE_TYPES19.ExportNamedDeclaration) {
         return;
       }
-      if (declaratorNode?.id.type === AST_NODE_TYPES16.Identifier) {
+      if (declaratorNode?.id.type === AST_NODE_TYPES19.Identifier) {
         const varName = declaratorNode.id.name;
         if (/^[A-Z]/.test(varName)) {
           return;
@@ -1319,21 +1651,146 @@ var jsxNoNonComponentFunction = createRule15({
 });
 var jsx_no_non_component_function_default = jsxNoNonComponentFunction;
 
+// src/rules/jsx-no-sub-interface.ts
+import { AST_NODE_TYPES as AST_NODE_TYPES20, ESLintUtils as ESLintUtils19 } from "@typescript-eslint/utils";
+var createRule19 = ESLintUtils19.RuleCreator(
+  (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
+);
+var PROPS_WRAPPER_NAMES = /* @__PURE__ */ new Set(["Readonly", "Required", "Partial", "PropsWithChildren", "NoInfer"]);
+function unwrapWrapperType(node) {
+  if (node.type === AST_NODE_TYPES20.TSTypeReference && node.typeName.type === AST_NODE_TYPES20.Identifier && PROPS_WRAPPER_NAMES.has(node.typeName.name) && node.typeArguments && node.typeArguments.params.length > 0) {
+    return unwrapWrapperType(node.typeArguments.params[0]);
+  }
+  return node;
+}
+function getMainTypeName(typeNode) {
+  if (!typeNode) {
+    return null;
+  }
+  const unwrapped = unwrapWrapperType(typeNode);
+  if (unwrapped.type === AST_NODE_TYPES20.TSTypeReference && unwrapped.typeName.type === AST_NODE_TYPES20.Identifier) {
+    return unwrapped.typeName.name;
+  }
+  return null;
+}
+function getComponentMainTypeName(node) {
+  const firstParam = node.params[0];
+  if (!firstParam) {
+    return null;
+  }
+  if ("typeAnnotation" in firstParam && firstParam.typeAnnotation) {
+    return getMainTypeName(firstParam.typeAnnotation.typeAnnotation);
+  }
+  return null;
+}
+function isPascalCase2(name) {
+  return /^[A-Z]/.test(name);
+}
+function getDeclarationFromExportWrapper(node) {
+  if (node.type === AST_NODE_TYPES20.ExportNamedDeclaration && node.declaration) {
+    return node.declaration;
+  }
+  if (node.type === AST_NODE_TYPES20.ExportDefaultDeclaration) {
+    return node.declaration;
+  }
+  return node;
+}
+var jsxNoSubInterface = createRule19({
+  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 === AST_NODE_TYPES20.FunctionDeclaration && declaration.id && isPascalCase2(declaration.id.name)) {
+            componentCount += 1;
+            const mainType = getComponentMainTypeName(declaration);
+            if (mainType) {
+              mainTypes.add(mainType);
+            }
+            continue;
+          }
+          if (declaration.type === AST_NODE_TYPES20.VariableDeclaration) {
+            for (const declarator of declaration.declarations) {
+              if (declarator.id.type !== AST_NODE_TYPES20.Identifier) {
+                continue;
+              }
+              if (!isPascalCase2(declarator.id.name)) {
+                continue;
+              }
+              const init = declarator.init;
+              if (init && (init.type === AST_NODE_TYPES20.ArrowFunctionExpression || init.type === AST_NODE_TYPES20.FunctionExpression)) {
+                componentCount += 1;
+                const mainType = getComponentMainTypeName(init);
+                if (mainType) {
+                  mainTypes.add(mainType);
+                }
+              }
+            }
+            continue;
+          }
+          if (declaration.type === AST_NODE_TYPES20.TSInterfaceDeclaration) {
+            typeDeclarations.push({ name: declaration.id.name, node: declaration });
+            continue;
+          }
+          if (declaration.type === AST_NODE_TYPES20.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
-import { AST_NODE_TYPES as AST_NODE_TYPES17, ESLintUtils as ESLintUtils16 } from "@typescript-eslint/utils";
-var createRule16 = ESLintUtils16.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES21, ESLintUtils as ESLintUtils20 } from "@typescript-eslint/utils";
+var createRule20 = ESLintUtils20.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 function isNullOrUndefined(node) {
-  if (node.type === AST_NODE_TYPES17.Literal && node.value === null) {
+  if (node.type === AST_NODE_TYPES21.Literal && node.value === null) {
     return true;
   }
-  if (node.type === AST_NODE_TYPES17.Identifier && node.name === "undefined") {
+  if (node.type === AST_NODE_TYPES21.Identifier && node.name === "undefined") {
     return true;
   }
   return false;
 }
-var jsxNoTernaryNull = createRule16({
+var jsxNoTernaryNull = createRule20({
   name: "jsx-no-ternary-null",
   meta: {
     type: "suggestion",
@@ -1351,7 +1808,7 @@ var jsxNoTernaryNull = createRule16({
     return {
       JSXExpressionContainer(node) {
         const { expression } = node;
-        if (expression.type !== AST_NODE_TYPES17.ConditionalExpression) {
+        if (expression.type !== AST_NODE_TYPES21.ConditionalExpression) {
           return;
         }
         const { test, consequent, alternate } = expression;
@@ -1383,11 +1840,11 @@ var jsxNoTernaryNull = createRule16({
 var jsx_no_ternary_null_default = jsxNoTernaryNull;
 
 // src/rules/jsx-no-variable-in-callback.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES18, ESLintUtils as ESLintUtils17 } from "@typescript-eslint/utils";
-var createRule17 = ESLintUtils17.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES22, ESLintUtils as ESLintUtils21 } from "@typescript-eslint/utils";
+var createRule21 = ESLintUtils21.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var jsxNoVariableInCallback = createRule17({
+var jsxNoVariableInCallback = createRule21({
   name: "jsx-no-variable-in-callback",
   meta: {
     type: "suggestion",
@@ -1404,7 +1861,7 @@ var jsxNoVariableInCallback = createRule17({
     function isInsideJSX(node) {
       let current = node.parent;
       while (current) {
-        if (current.type === AST_NODE_TYPES18.JSXElement || current.type === AST_NODE_TYPES18.JSXFragment) {
+        if (current.type === AST_NODE_TYPES22.JSXElement || current.type === AST_NODE_TYPES22.JSXFragment) {
           return true;
         }
         current = current.parent;
@@ -1418,11 +1875,11 @@ var jsxNoVariableInCallback = createRule17({
       if (!isInsideJSX(node)) {
         return false;
       }
-      if (node.parent.type === AST_NODE_TYPES18.CallExpression || node.parent.type === AST_NODE_TYPES18.JSXExpressionContainer) {
+      if (node.parent.type === AST_NODE_TYPES22.CallExpression || node.parent.type === AST_NODE_TYPES22.JSXExpressionContainer) {
         return true;
       }
-      if (node.parent.type === AST_NODE_TYPES18.ArrayExpression && node.parent.parent) {
-        if (node.parent.parent.type === AST_NODE_TYPES18.CallExpression || node.parent.parent.type === AST_NODE_TYPES18.JSXExpressionContainer) {
+      if (node.parent.type === AST_NODE_TYPES22.ArrayExpression && node.parent.parent) {
+        if (node.parent.parent.type === AST_NODE_TYPES22.CallExpression || node.parent.parent.type === AST_NODE_TYPES22.JSXExpressionContainer) {
           return true;
         }
       }
@@ -1433,11 +1890,11 @@ var jsxNoVariableInCallback = createRule17({
         return;
       }
       const { body } = node;
-      if (body.type !== AST_NODE_TYPES18.BlockStatement) {
+      if (body.type !== AST_NODE_TYPES22.BlockStatement) {
         return;
       }
       body.body.forEach((statement) => {
-        if (statement.type === AST_NODE_TYPES18.VariableDeclaration) {
+        if (statement.type === AST_NODE_TYPES22.VariableDeclaration) {
           context.report({
             node: statement,
             messageId: "noVariableInCallback"
@@ -1454,11 +1911,11 @@ var jsxNoVariableInCallback = createRule17({
 var jsx_no_variable_in_callback_default = jsxNoVariableInCallback;
 
 // src/rules/jsx-require-suspense.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES19, ESLintUtils as ESLintUtils18 } from "@typescript-eslint/utils";
-var createRule18 = ESLintUtils18.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES23, ESLintUtils as ESLintUtils22 } from "@typescript-eslint/utils";
+var createRule22 = ESLintUtils22.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var jsxRequireSuspense = createRule18({
+var jsxRequireSuspense = createRule22({
   name: "jsx-require-suspense",
   meta: {
     type: "problem",
@@ -1476,7 +1933,7 @@ var jsxRequireSuspense = createRule18({
     const isInsideSuspense = (node) => {
       let current = node.parent;
       while (current) {
-        if (current.type === AST_NODE_TYPES19.JSXElement && current.openingElement.name.type === AST_NODE_TYPES19.JSXIdentifier && current.openingElement.name.name === "Suspense") {
+        if (current.type === AST_NODE_TYPES23.JSXElement && current.openingElement.name.type === AST_NODE_TYPES23.JSXIdentifier && current.openingElement.name.name === "Suspense") {
           return true;
         }
         current = current.parent;
@@ -1485,16 +1942,16 @@ var jsxRequireSuspense = createRule18({
     };
     return {
       VariableDeclarator(node) {
-        if (node.id.type === AST_NODE_TYPES19.Identifier && node.init?.type === AST_NODE_TYPES19.CallExpression) {
+        if (node.id.type === AST_NODE_TYPES23.Identifier && node.init?.type === AST_NODE_TYPES23.CallExpression) {
           const { callee } = node.init;
-          const isLazyCall = callee.type === AST_NODE_TYPES19.Identifier && callee.name === "lazy" || callee.type === AST_NODE_TYPES19.MemberExpression && callee.object.type === AST_NODE_TYPES19.Identifier && callee.object.name === "React" && callee.property.type === AST_NODE_TYPES19.Identifier && callee.property.name === "lazy";
+          const isLazyCall = callee.type === AST_NODE_TYPES23.Identifier && callee.name === "lazy" || callee.type === AST_NODE_TYPES23.MemberExpression && callee.object.type === AST_NODE_TYPES23.Identifier && callee.object.name === "React" && callee.property.type === AST_NODE_TYPES23.Identifier && callee.property.name === "lazy";
           if (isLazyCall) {
             lazyComponents.add(node.id.name);
           }
         }
       },
       JSXOpeningElement(node) {
-        if (node.name.type === AST_NODE_TYPES19.JSXIdentifier) {
+        if (node.name.type === AST_NODE_TYPES23.JSXIdentifier) {
           const componentName = node.name.name;
           if (lazyComponents.has(componentName) && !isInsideSuspense(node)) {
             context.report({
@@ -1513,11 +1970,11 @@ var jsxRequireSuspense = createRule18({
 var jsx_require_suspense_default = jsxRequireSuspense;
 
 // src/rules/jsx-simple-props.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES20, ESLintUtils as ESLintUtils19 } from "@typescript-eslint/utils";
-var createRule19 = ESLintUtils19.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES24, ESLintUtils as ESLintUtils23 } from "@typescript-eslint/utils";
+var createRule23 = ESLintUtils23.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var jsxSimpleProps = createRule19({
+var jsxSimpleProps = createRule23({
   name: "jsx-simple-props",
   meta: {
     type: "suggestion",
@@ -1532,25 +1989,25 @@ var jsxSimpleProps = createRule19({
   defaultOptions: [],
   create(context) {
     const allowedExpressionTypes = /* @__PURE__ */ new Set([
-      AST_NODE_TYPES20.Identifier,
-      AST_NODE_TYPES20.Literal,
-      AST_NODE_TYPES20.JSXElement,
-      AST_NODE_TYPES20.JSXFragment,
-      AST_NODE_TYPES20.MemberExpression,
-      AST_NODE_TYPES20.ArrowFunctionExpression,
-      AST_NODE_TYPES20.FunctionExpression
+      AST_NODE_TYPES24.Identifier,
+      AST_NODE_TYPES24.Literal,
+      AST_NODE_TYPES24.JSXElement,
+      AST_NODE_TYPES24.JSXFragment,
+      AST_NODE_TYPES24.MemberExpression,
+      AST_NODE_TYPES24.ArrowFunctionExpression,
+      AST_NODE_TYPES24.FunctionExpression
     ]);
     return {
       JSXAttribute(node) {
         if (!node.value) {
           return;
         }
-        if (node.value.type === AST_NODE_TYPES20.Literal) {
+        if (node.value.type === AST_NODE_TYPES24.Literal) {
           return;
         }
-        if (node.value.type === AST_NODE_TYPES20.JSXExpressionContainer) {
+        if (node.value.type === AST_NODE_TYPES24.JSXExpressionContainer) {
           const { expression } = node.value;
-          if (expression.type === AST_NODE_TYPES20.JSXEmptyExpression) {
+          if (expression.type === AST_NODE_TYPES24.JSXEmptyExpression) {
             return;
           }
           if (!allowedExpressionTypes.has(expression.type)) {
@@ -1567,8 +2024,8 @@ var jsxSimpleProps = createRule19({
 var jsx_simple_props_default = jsxSimpleProps;
 
 // src/rules/jsx-sort-props.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES21, ESLintUtils as ESLintUtils20 } from "@typescript-eslint/utils";
-var createRule20 = ESLintUtils20.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES25, ESLintUtils as ESLintUtils24 } from "@typescript-eslint/utils";
+var createRule24 = ESLintUtils24.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var TYPE_GROUP = {
@@ -1582,15 +2039,15 @@ var TYPE_GROUP = {
   SHORTHAND: 8
 };
 var EXPRESSION_TYPE_TO_GROUP = /* @__PURE__ */ new Map([
-  [AST_NODE_TYPES21.ObjectExpression, TYPE_GROUP.OBJECT_ARRAY],
-  [AST_NODE_TYPES21.ArrayExpression, TYPE_GROUP.OBJECT_ARRAY],
-  [AST_NODE_TYPES21.ArrowFunctionExpression, TYPE_GROUP.FUNCTION],
-  [AST_NODE_TYPES21.FunctionExpression, TYPE_GROUP.FUNCTION],
-  [AST_NODE_TYPES21.JSXElement, TYPE_GROUP.JSX],
-  [AST_NODE_TYPES21.JSXFragment, TYPE_GROUP.JSX]
+  [AST_NODE_TYPES25.ObjectExpression, TYPE_GROUP.OBJECT_ARRAY],
+  [AST_NODE_TYPES25.ArrayExpression, TYPE_GROUP.OBJECT_ARRAY],
+  [AST_NODE_TYPES25.ArrowFunctionExpression, TYPE_GROUP.FUNCTION],
+  [AST_NODE_TYPES25.FunctionExpression, TYPE_GROUP.FUNCTION],
+  [AST_NODE_TYPES25.JSXElement, TYPE_GROUP.JSX],
+  [AST_NODE_TYPES25.JSXFragment, TYPE_GROUP.JSX]
 ]);
 function isHyphenatedName(node) {
-  return node.name.type === AST_NODE_TYPES21.JSXIdentifier && node.name.name.includes("-");
+  return node.name.type === AST_NODE_TYPES25.JSXIdentifier && node.name.name.includes("-");
 }
 function getStringGroup(node) {
   return isHyphenatedName(node) ? TYPE_GROUP.HYPHENATED_STRING : TYPE_GROUP.STRING;
@@ -1602,13 +2059,13 @@ function getLiteralValueGroup(value) {
   return TYPE_GROUP.NUMBER_BOOLEAN_NULL;
 }
 function getExpressionGroup(expression) {
-  if (expression.type === AST_NODE_TYPES21.Literal) {
+  if (expression.type === AST_NODE_TYPES25.Literal) {
     return getLiteralValueGroup(expression.value);
   }
-  if (expression.type === AST_NODE_TYPES21.TemplateLiteral) {
+  if (expression.type === AST_NODE_TYPES25.TemplateLiteral) {
     return null;
   }
-  if (expression.type === AST_NODE_TYPES21.Identifier && expression.name === "undefined") {
+  if (expression.type === AST_NODE_TYPES25.Identifier && expression.name === "undefined") {
     return TYPE_GROUP.NUMBER_BOOLEAN_NULL;
   }
   return EXPRESSION_TYPE_TO_GROUP.get(expression.type) ?? TYPE_GROUP.EXPRESSION;
@@ -1617,17 +2074,17 @@ function getTypeGroup(node) {
   if (node.value === null) {
     return TYPE_GROUP.SHORTHAND;
   }
-  if (node.value.type === AST_NODE_TYPES21.Literal) {
+  if (node.value.type === AST_NODE_TYPES25.Literal) {
     if (typeof node.value.value === "string") {
       return getStringGroup(node);
     }
     return TYPE_GROUP.NUMBER_BOOLEAN_NULL;
   }
-  if (node.value.type !== AST_NODE_TYPES21.JSXExpressionContainer) {
+  if (node.value.type !== AST_NODE_TYPES25.JSXExpressionContainer) {
     return null;
   }
   const { expression } = node.value;
-  if (expression.type === AST_NODE_TYPES21.JSXEmptyExpression) {
+  if (expression.type === AST_NODE_TYPES25.JSXEmptyExpression) {
     return null;
   }
   const group = getExpressionGroup(expression);
@@ -1639,7 +2096,7 @@ function getTypeGroup(node) {
 function hasUnsortedProps(attributes) {
   let lastGroup = 0;
   return attributes.some((attribute) => {
-    if (attribute.type === AST_NODE_TYPES21.JSXSpreadAttribute) {
+    if (attribute.type === AST_NODE_TYPES25.JSXSpreadAttribute) {
       lastGroup = 0;
       return false;
     }
@@ -1663,7 +2120,7 @@ function getSegments(attributes) {
   const result = [];
   let current = [];
   attributes.forEach((attr) => {
-    if (attr.type === AST_NODE_TYPES21.JSXSpreadAttribute) {
+    if (attr.type === AST_NODE_TYPES25.JSXSpreadAttribute) {
       if (current.length > 0) {
         result.push(current);
         current = [];
@@ -1677,7 +2134,7 @@ function getSegments(attributes) {
   }
   return result;
 }
-var jsxSortProps = createRule20({
+var jsxSortProps = createRule24({
   name: "jsx-sort-props",
   meta: {
     type: "suggestion",
@@ -1712,11 +2169,11 @@ var jsxSortProps = createRule20({
 var jsx_sort_props_default = jsxSortProps;
 
 // src/rules/jsx-spread-props-last.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES22, ESLintUtils as ESLintUtils21 } from "@typescript-eslint/utils";
-var createRule21 = ESLintUtils21.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES26, ESLintUtils as ESLintUtils25 } from "@typescript-eslint/utils";
+var createRule25 = ESLintUtils25.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var jsxSpreadPropsLast = createRule21({
+var jsxSpreadPropsLast = createRule25({
   name: "jsx-spread-props-last",
   meta: {
     type: "suggestion",
@@ -1735,12 +2192,12 @@ var jsxSpreadPropsLast = createRule21({
         const { attributes } = node;
         let lastNonSpreadIndex = -1;
         attributes.forEach((attribute, index) => {
-          if (attribute.type !== AST_NODE_TYPES22.JSXSpreadAttribute) {
+          if (attribute.type !== AST_NODE_TYPES26.JSXSpreadAttribute) {
             lastNonSpreadIndex = index;
           }
         });
         attributes.forEach((attribute, index) => {
-          if (attribute.type === AST_NODE_TYPES22.JSXSpreadAttribute && index < lastNonSpreadIndex) {
+          if (attribute.type === AST_NODE_TYPES26.JSXSpreadAttribute && index < lastNonSpreadIndex) {
             context.report({
               node: attribute,
               messageId: "spreadNotLast"
@@ -1754,12 +2211,12 @@ var jsxSpreadPropsLast = createRule21({
 var jsx_spread_props_last_default = jsxSpreadPropsLast;
 
 // src/rules/newline-after-multiline-block.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES23, ESLintUtils as ESLintUtils22 } from "@typescript-eslint/utils";
-var createRule22 = ESLintUtils22.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES27, ESLintUtils as ESLintUtils26 } from "@typescript-eslint/utils";
+var createRule26 = ESLintUtils26.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 function isImportDeclaration(node) {
-  return node.type === AST_NODE_TYPES23.ImportDeclaration;
+  return node.type === AST_NODE_TYPES27.ImportDeclaration;
 }
 function checkStatements(statements, context) {
   const { sourceCode } = context;
@@ -1794,7 +2251,7 @@ function checkStatements(statements, context) {
     }
   });
 }
-var newlineAfterMultilineBlock = createRule22({
+var newlineAfterMultilineBlock = createRule26({
   name: "newline-after-multiline-block",
   meta: {
     type: "layout",
@@ -1822,11 +2279,11 @@ var newlineAfterMultilineBlock = createRule22({
 var newline_after_multiline_block_default = newlineAfterMultilineBlock;
 
 // src/rules/newline-before-return.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES24, ESLintUtils as ESLintUtils23 } from "@typescript-eslint/utils";
-var createRule23 = ESLintUtils23.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES28, ESLintUtils as ESLintUtils27 } from "@typescript-eslint/utils";
+var createRule27 = ESLintUtils27.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var newlineBeforeReturn = createRule23({
+var newlineBeforeReturn = createRule27({
   name: "newline-before-return",
   meta: {
     type: "layout",
@@ -1844,7 +2301,7 @@ var newlineBeforeReturn = createRule23({
     const { sourceCode } = context;
     function checkReturnStatement(node) {
       const { parent } = node;
-      if (!parent || parent.type !== AST_NODE_TYPES24.BlockStatement) {
+      if (!parent || parent.type !== AST_NODE_TYPES28.BlockStatement) {
         return;
       }
       const { body: statements } = parent;
@@ -1881,11 +2338,11 @@ var newlineBeforeReturn = createRule23({
 var newline_before_return_default = newlineBeforeReturn;
 
 // src/rules/no-complex-inline-return.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES25, ESLintUtils as ESLintUtils24 } from "@typescript-eslint/utils";
-var createRule24 = ESLintUtils24.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES29, ESLintUtils as ESLintUtils28 } from "@typescript-eslint/utils";
+var createRule28 = ESLintUtils28.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var noComplexInlineReturn = createRule24({
+var noComplexInlineReturn = createRule28({
   name: "no-complex-inline-return",
   meta: {
     type: "suggestion",
@@ -1901,13 +2358,13 @@ var noComplexInlineReturn = createRule24({
   create(context) {
     const isComplexExpression = (node) => {
       if (!node) return false;
-      if (node.type === AST_NODE_TYPES25.ConditionalExpression) {
+      if (node.type === AST_NODE_TYPES29.ConditionalExpression) {
         return true;
       }
-      if (node.type === AST_NODE_TYPES25.LogicalExpression) {
+      if (node.type === AST_NODE_TYPES29.LogicalExpression) {
         return true;
       }
-      if (node.type === AST_NODE_TYPES25.NewExpression) {
+      if (node.type === AST_NODE_TYPES29.NewExpression) {
         return true;
       }
       return false;
@@ -1927,11 +2384,11 @@ var noComplexInlineReturn = createRule24({
 var no_complex_inline_return_default = noComplexInlineReturn;
 
 // src/rules/no-direct-date.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES26, ESLintUtils as ESLintUtils25 } from "@typescript-eslint/utils";
-var createRule25 = ESLintUtils25.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES30, ESLintUtils as ESLintUtils29 } from "@typescript-eslint/utils";
+var createRule29 = ESLintUtils29.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var noDirectDate = createRule25({
+var noDirectDate = createRule29({
   name: "no-direct-date",
   meta: {
     type: "problem",
@@ -1949,7 +2406,7 @@ var noDirectDate = createRule25({
   create(context) {
     return {
       NewExpression(node) {
-        if (node.callee.type === AST_NODE_TYPES26.Identifier && node.callee.name === "Date") {
+        if (node.callee.type === AST_NODE_TYPES30.Identifier && node.callee.name === "Date") {
           context.report({
             node,
             messageId: "noNewDate"
@@ -1957,7 +2414,7 @@ var noDirectDate = createRule25({
         }
       },
       CallExpression(node) {
-        if (node.callee.type === AST_NODE_TYPES26.MemberExpression && node.callee.object.type === AST_NODE_TYPES26.Identifier && node.callee.object.name === "Date" && node.callee.property.type === AST_NODE_TYPES26.Identifier) {
+        if (node.callee.type === AST_NODE_TYPES30.MemberExpression && node.callee.object.type === AST_NODE_TYPES30.Identifier && node.callee.object.name === "Date" && node.callee.property.type === AST_NODE_TYPES30.Identifier) {
           const methodName = node.callee.property.name;
           if (methodName === "now") {
             context.report({
@@ -1980,11 +2437,11 @@ var no_direct_date_default = noDirectDate;
 
 // src/rules/no-emoji.ts
 import emojiRegex from "emoji-regex";
-import { ESLintUtils as ESLintUtils26 } from "@typescript-eslint/utils";
-var createRule26 = ESLintUtils26.RuleCreator(
+import { ESLintUtils as ESLintUtils30 } from "@typescript-eslint/utils";
+var createRule30 = ESLintUtils30.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var noEmoji = createRule26({
+var noEmoji = createRule30({
   name: "no-emoji",
   meta: {
     type: "problem",
@@ -2018,11 +2475,11 @@ var noEmoji = createRule26({
 var no_emoji_default = noEmoji;
 
 // src/rules/no-env-fallback.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES27, ESLintUtils as ESLintUtils27 } from "@typescript-eslint/utils";
-var createRule27 = ESLintUtils27.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES31, ESLintUtils as ESLintUtils31 } from "@typescript-eslint/utils";
+var createRule31 = ESLintUtils31.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var noEnvFallback = createRule27({
+var noEnvFallback = createRule31({
   name: "no-env-fallback",
   meta: {
     type: "problem",
@@ -2037,16 +2494,16 @@ var noEnvFallback = createRule27({
   defaultOptions: [],
   create(context) {
     const isProcessEnvAccess = (node) => {
-      if (node.type !== AST_NODE_TYPES27.MemberExpression) {
+      if (node.type !== AST_NODE_TYPES31.MemberExpression) {
         return false;
       }
       const { object } = node;
-      if (object.type !== AST_NODE_TYPES27.MemberExpression) {
+      if (object.type !== AST_NODE_TYPES31.MemberExpression) {
         return false;
       }
       const processNode = object.object;
       const envNode = object.property;
-      return processNode.type === AST_NODE_TYPES27.Identifier && processNode.name === "process" && envNode.type === AST_NODE_TYPES27.Identifier && envNode.name === "env";
+      return processNode.type === AST_NODE_TYPES31.Identifier && processNode.name === "process" && envNode.type === AST_NODE_TYPES31.Identifier && envNode.name === "env";
     };
     return {
       LogicalExpression(node) {
@@ -2070,12 +2527,58 @@ var noEnvFallback = createRule27({
 });
 var no_env_fallback_default = noEnvFallback;
 
+// src/rules/no-ghost-wrapper.ts
+import { AST_NODE_TYPES as AST_NODE_TYPES32, ESLintUtils as ESLintUtils32 } from "@typescript-eslint/utils";
+var createRule32 = ESLintUtils32.RuleCreator(
+  (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
+);
+var GHOST_TAGS = /* @__PURE__ */ new Set(["div", "span"]);
+function isKeyAttribute(attribute) {
+  return attribute.type === AST_NODE_TYPES32.JSXAttribute && attribute.name.type === AST_NODE_TYPES32.JSXIdentifier && attribute.name.name === "key";
+}
+var noGhostWrapper = createRule32({
+  name: "no-ghost-wrapper",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow bare <div> and <span> elements that have no meaningful attributes (Divitis / ghost wrappers)"
+    },
+    schema: [],
+    messages: {
+      noGhostWrapper: "Ghost <{{ tag }}> has no meaningful attributes. Use a Fragment (<>...</>), a semantic element (section, article, header, etc.), or add a meaningful attribute (className, role, data-*, ref, etc.). Note: 'key' alone does not count as meaningful."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      JSXOpeningElement(node) {
+        if (node.name.type !== AST_NODE_TYPES32.JSXIdentifier) {
+          return;
+        }
+        const tagName = node.name.name;
+        if (!GHOST_TAGS.has(tagName)) {
+          return;
+        }
+        const meaningfulAttributes = node.attributes.filter((attribute) => !isKeyAttribute(attribute));
+        if (meaningfulAttributes.length === 0) {
+          context.report({
+            node,
+            messageId: "noGhostWrapper",
+            data: { tag: tagName }
+          });
+        }
+      }
+    };
+  }
+});
+var no_ghost_wrapper_default = noGhostWrapper;
+
 // src/rules/no-inline-default-export.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES28, ESLintUtils as ESLintUtils28 } from "@typescript-eslint/utils";
-var createRule28 = ESLintUtils28.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES33, ESLintUtils as ESLintUtils33 } from "@typescript-eslint/utils";
+var createRule33 = ESLintUtils33.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var noInlineDefaultExport = createRule28({
+var noInlineDefaultExport = createRule33({
   name: "no-inline-default-export",
   meta: {
     type: "suggestion",
@@ -2094,7 +2597,7 @@ var noInlineDefaultExport = createRule28({
     return {
       ExportDefaultDeclaration(node) {
         const { declaration } = node;
-        if (declaration.type === AST_NODE_TYPES28.FunctionDeclaration) {
+        if (declaration.type === AST_NODE_TYPES33.FunctionDeclaration) {
           if (declaration.id) {
             context.report({
               node,
@@ -2109,7 +2612,7 @@ var noInlineDefaultExport = createRule28({
             });
           }
         }
-        if (declaration.type === AST_NODE_TYPES28.ClassDeclaration) {
+        if (declaration.type === AST_NODE_TYPES33.ClassDeclaration) {
           if (declaration.id) {
             context.report({
               node,
@@ -2124,7 +2627,7 @@ var noInlineDefaultExport = createRule28({
             });
           }
         }
-        if (declaration.type === AST_NODE_TYPES28.ArrowFunctionExpression || declaration.type === AST_NODE_TYPES28.FunctionExpression) {
+        if (declaration.type === AST_NODE_TYPES33.ArrowFunctionExpression || declaration.type === AST_NODE_TYPES33.FunctionExpression) {
           context.report({
             node,
             messageId: "noAnonymousDefaultExport",
@@ -2137,14 +2640,14 @@ var noInlineDefaultExport = createRule28({
         if (!declaration) {
           return;
         }
-        if (declaration.type === AST_NODE_TYPES28.FunctionDeclaration && declaration.id) {
+        if (declaration.type === AST_NODE_TYPES33.FunctionDeclaration && declaration.id) {
           context.report({
             node,
             messageId: "noInlineNamedExport",
             data: { type: "function", name: declaration.id.name }
           });
         }
-        if (declaration.type === AST_NODE_TYPES28.ClassDeclaration && declaration.id) {
+        if (declaration.type === AST_NODE_TYPES33.ClassDeclaration && declaration.id) {
           context.report({
             node,
             messageId: "noInlineNamedExport",
@@ -2158,27 +2661,27 @@ var noInlineDefaultExport = createRule28({
 var no_inline_default_export_default = noInlineDefaultExport;
 
 // src/rules/no-inline-nested-object.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES29, ESLintUtils as ESLintUtils29 } from "@typescript-eslint/utils";
-var createRule29 = ESLintUtils29.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES34, ESLintUtils as ESLintUtils34 } from "@typescript-eslint/utils";
+var createRule34 = ESLintUtils34.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 function isObjectOrArray(node) {
-  return node.type === AST_NODE_TYPES29.ObjectExpression || node.type === AST_NODE_TYPES29.ArrayExpression || node.type === AST_NODE_TYPES29.TSAsExpression;
+  return node.type === AST_NODE_TYPES34.ObjectExpression || node.type === AST_NODE_TYPES34.ArrayExpression || node.type === AST_NODE_TYPES34.TSAsExpression;
 }
 function getInnerExpression(node) {
-  if (node.type === AST_NODE_TYPES29.TSAsExpression) {
+  if (node.type === AST_NODE_TYPES34.TSAsExpression) {
     return getInnerExpression(node.expression);
   }
   return node;
 }
 function isNestedStructure(node) {
   const inner = getInnerExpression(node);
-  return inner.type === AST_NODE_TYPES29.ObjectExpression || inner.type === AST_NODE_TYPES29.ArrayExpression;
+  return inner.type === AST_NODE_TYPES34.ObjectExpression || inner.type === AST_NODE_TYPES34.ArrayExpression;
 }
 function containsNestedStructure(node) {
-  if (node.type === AST_NODE_TYPES29.ObjectExpression) {
+  if (node.type === AST_NODE_TYPES34.ObjectExpression) {
     return node.properties.some((prop) => {
-      if (prop.type !== AST_NODE_TYPES29.Property) return false;
+      if (prop.type !== AST_NODE_TYPES34.Property) return false;
       return isNestedStructure(prop.value);
     });
   }
@@ -2187,7 +2690,7 @@ function containsNestedStructure(node) {
     return isNestedStructure(el);
   });
 }
-var noInlineNestedObject = createRule29({
+var noInlineNestedObject = createRule34({
   name: "no-inline-nested-object",
   meta: {
     type: "layout",
@@ -2209,7 +2712,7 @@ var noInlineNestedObject = createRule29({
           return;
         }
         const valueNode = getInnerExpression(node.value);
-        if (valueNode.type !== AST_NODE_TYPES29.ObjectExpression && valueNode.type !== AST_NODE_TYPES29.ArrayExpression) {
+        if (valueNode.type !== AST_NODE_TYPES34.ObjectExpression && valueNode.type !== AST_NODE_TYPES34.ArrayExpression) {
           return;
         }
         if (!valueNode.loc) {
@@ -2222,7 +2725,7 @@ var noInlineNestedObject = createRule29({
         if (!containsNestedStructure(valueNode)) {
           return;
         }
-        const elements = valueNode.type === AST_NODE_TYPES29.ObjectExpression ? valueNode.properties : valueNode.elements;
+        const elements = valueNode.type === AST_NODE_TYPES34.ObjectExpression ? valueNode.properties : valueNode.elements;
         context.report({
           node: valueNode,
           messageId: "requireMultiline",
@@ -2235,7 +2738,7 @@ var noInlineNestedObject = createRule29({
             const indent = " ".repeat(node.loc?.start.column ?? 0);
             const innerIndent = `${indent}  `;
             const elementTexts = elements.filter((el) => el !== null).map((el) => sourceCode.getText(el));
-            const isObject = valueNode.type === AST_NODE_TYPES29.ObjectExpression;
+            const isObject = valueNode.type === AST_NODE_TYPES34.ObjectExpression;
             const openChar = isObject ? "{" : "[";
             const closeChar = isObject ? "}" : "]";
             const formattedElements = elementTexts.map((text) => `${innerIndent}${text},`).join("\n");
@@ -2252,20 +2755,20 @@ ${indent}${closeChar}`;
 var no_inline_nested_object_default = noInlineNestedObject;
 
 // src/rules/no-inline-return-properties.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES30, ESLintUtils as ESLintUtils30 } from "@typescript-eslint/utils";
-var createRule30 = ESLintUtils30.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES35, ESLintUtils as ESLintUtils35 } from "@typescript-eslint/utils";
+var createRule35 = ESLintUtils35.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var isShorthandProperty = (property) => {
-  if (property.type === AST_NODE_TYPES30.SpreadElement) {
+  if (property.type === AST_NODE_TYPES35.SpreadElement) {
     return true;
   }
-  if (property.type !== AST_NODE_TYPES30.Property) {
+  if (property.type !== AST_NODE_TYPES35.Property) {
     return false;
   }
   return property.shorthand;
 };
-var noInlineReturnProperties = createRule30({
+var noInlineReturnProperties = createRule35({
   name: "no-inline-return-properties",
   meta: {
     type: "suggestion",
@@ -2281,20 +2784,20 @@ var noInlineReturnProperties = createRule30({
   create(context) {
     return {
       ReturnStatement(node) {
-        if (!node.argument || node.argument.type !== AST_NODE_TYPES30.ObjectExpression) {
+        if (!node.argument || node.argument.type !== AST_NODE_TYPES35.ObjectExpression) {
           return;
         }
         node.argument.properties.forEach((property) => {
           if (isShorthandProperty(property)) {
             return;
           }
-          if (property.type !== AST_NODE_TYPES30.Property) {
+          if (property.type !== AST_NODE_TYPES35.Property) {
             return;
           }
           let keyName = null;
-          if (property.key.type === AST_NODE_TYPES30.Identifier) {
+          if (property.key.type === AST_NODE_TYPES35.Identifier) {
             keyName = property.key.name;
-          } else if (property.key.type === AST_NODE_TYPES30.Literal) {
+          } else if (property.key.type === AST_NODE_TYPES35.Literal) {
             keyName = String(property.key.value);
           }
           context.report({
@@ -2310,12 +2813,12 @@ var noInlineReturnProperties = createRule30({
 var no_inline_return_properties_default = noInlineReturnProperties;
 
 // src/rules/no-inline-type-import.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES31, ESLintUtils as ESLintUtils31 } from "@typescript-eslint/utils";
-var createRule31 = ESLintUtils31.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES36, ESLintUtils as ESLintUtils36 } from "@typescript-eslint/utils";
+var createRule36 = ESLintUtils36.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var isInlineTypeSpecifier = (specifier) => specifier.type === AST_NODE_TYPES31.ImportSpecifier && specifier.importKind === "type";
-var noInlineTypeImport = createRule31({
+var isInlineTypeSpecifier = (specifier) => specifier.type === AST_NODE_TYPES36.ImportSpecifier && specifier.importKind === "type";
+var noInlineTypeImport = createRule36({
   name: "no-inline-type-import",
   meta: {
     type: "suggestion",
@@ -2352,7 +2855,7 @@ var noInlineTypeImport = createRule31({
             );
             const typeImport = `import type { ${typeSpecifierTexts.join(", ")} } from ${sourceText};`;
             const valueSpecifiers = node.specifiers.filter(
-              (specifier) => !(specifier.type === AST_NODE_TYPES31.ImportSpecifier && specifier.importKind === "type")
+              (specifier) => !(specifier.type === AST_NODE_TYPES36.ImportSpecifier && specifier.importKind === "type")
             );
             if (valueSpecifiers.length === 0) {
               return fixer.replaceText(node, typeImport);
@@ -2360,11 +2863,11 @@ var noInlineTypeImport = createRule31({
             const parts = [];
             const namedValueSpecifiers = [];
             for (const specifier of valueSpecifiers) {
-              if (specifier.type === AST_NODE_TYPES31.ImportDefaultSpecifier) {
+              if (specifier.type === AST_NODE_TYPES36.ImportDefaultSpecifier) {
                 parts.push(specifier.local.name);
-              } else if (specifier.type === AST_NODE_TYPES31.ImportNamespaceSpecifier) {
+              } else if (specifier.type === AST_NODE_TYPES36.ImportNamespaceSpecifier) {
                 parts.push(`* as ${specifier.local.name}`);
-              } else if (specifier.type === AST_NODE_TYPES31.ImportSpecifier) {
+              } else if (specifier.type === AST_NODE_TYPES36.ImportSpecifier) {
                 namedValueSpecifiers.push(specifier);
               }
             }
@@ -2384,8 +2887,8 @@ ${typeImport}`);
 var no_inline_type_import_default = noInlineTypeImport;
 
 // src/rules/no-lazy-identifiers.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES32, ESLintUtils as ESLintUtils32 } from "@typescript-eslint/utils";
-var createRule32 = ESLintUtils32.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES37, ESLintUtils as ESLintUtils37 } from "@typescript-eslint/utils";
+var createRule37 = ESLintUtils37.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var KEYBOARD_ROWS = ["qwertyuiop", "asdfghjkl", "zxcvbnm", "1234567890"];
@@ -2426,7 +2929,7 @@ var isLazyIdentifier = (name) => {
   }
   return false;
 };
-var noLazyIdentifiers = createRule32({
+var noLazyIdentifiers = createRule37({
   name: "no-lazy-identifiers",
   meta: {
     type: "problem",
@@ -2452,27 +2955,27 @@ var noLazyIdentifiers = createRule32({
       });
     };
     const checkPattern = (pattern) => {
-      if (pattern.type === AST_NODE_TYPES32.Identifier) {
+      if (pattern.type === AST_NODE_TYPES37.Identifier) {
         checkIdentifier(pattern);
-      } else if (pattern.type === AST_NODE_TYPES32.ObjectPattern) {
+      } else if (pattern.type === AST_NODE_TYPES37.ObjectPattern) {
         pattern.properties.forEach((prop) => {
-          if (prop.type === AST_NODE_TYPES32.Property && prop.value.type === AST_NODE_TYPES32.Identifier) {
+          if (prop.type === AST_NODE_TYPES37.Property && prop.value.type === AST_NODE_TYPES37.Identifier) {
             checkIdentifier(prop.value);
-          } else if (prop.type === AST_NODE_TYPES32.RestElement && prop.argument.type === AST_NODE_TYPES32.Identifier) {
+          } else if (prop.type === AST_NODE_TYPES37.RestElement && prop.argument.type === AST_NODE_TYPES37.Identifier) {
             checkIdentifier(prop.argument);
           }
         });
-      } else if (pattern.type === AST_NODE_TYPES32.ArrayPattern) {
+      } else if (pattern.type === AST_NODE_TYPES37.ArrayPattern) {
         pattern.elements.forEach((element) => {
-          if (element?.type === AST_NODE_TYPES32.Identifier) {
+          if (element?.type === AST_NODE_TYPES37.Identifier) {
             checkIdentifier(element);
-          } else if (element?.type === AST_NODE_TYPES32.RestElement && element.argument.type === AST_NODE_TYPES32.Identifier) {
+          } else if (element?.type === AST_NODE_TYPES37.RestElement && element.argument.type === AST_NODE_TYPES37.Identifier) {
             checkIdentifier(element.argument);
           }
         });
-      } else if (pattern.type === AST_NODE_TYPES32.AssignmentPattern && pattern.left.type === AST_NODE_TYPES32.Identifier) {
+      } else if (pattern.type === AST_NODE_TYPES37.AssignmentPattern && pattern.left.type === AST_NODE_TYPES37.Identifier) {
         checkIdentifier(pattern.left);
-      } else if (pattern.type === AST_NODE_TYPES32.RestElement && pattern.argument.type === AST_NODE_TYPES32.Identifier) {
+      } else if (pattern.type === AST_NODE_TYPES37.RestElement && pattern.argument.type === AST_NODE_TYPES37.Identifier) {
         checkIdentifier(pattern.argument);
       }
     };
@@ -2517,11 +3020,11 @@ var noLazyIdentifiers = createRule32({
 var no_lazy_identifiers_default = noLazyIdentifiers;
 
 // src/rules/no-logic-in-params.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES33, ESLintUtils as ESLintUtils33 } from "@typescript-eslint/utils";
-var createRule33 = ESLintUtils33.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES38, ESLintUtils as ESLintUtils38 } from "@typescript-eslint/utils";
+var createRule38 = ESLintUtils38.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var noLogicInParams = createRule33({
+var noLogicInParams = createRule38({
   name: "no-logic-in-params",
   meta: {
     type: "suggestion",
@@ -2536,20 +3039,20 @@ var noLogicInParams = createRule33({
   defaultOptions: [],
   create(context) {
     const isComplexExpression = (node) => {
-      if (node.type === AST_NODE_TYPES33.SpreadElement) {
+      if (node.type === AST_NODE_TYPES38.SpreadElement) {
         return false;
       }
-      if (node.type === AST_NODE_TYPES33.ConditionalExpression) {
+      if (node.type === AST_NODE_TYPES38.ConditionalExpression) {
         return true;
       }
-      if (node.type === AST_NODE_TYPES33.LogicalExpression) {
+      if (node.type === AST_NODE_TYPES38.LogicalExpression) {
         return true;
       }
-      if (node.type === AST_NODE_TYPES33.BinaryExpression) {
+      if (node.type === AST_NODE_TYPES38.BinaryExpression) {
         const logicalOperators = ["==", "===", "!=", "!==", "<", ">", "<=", ">=", "in", "instanceof"];
         return logicalOperators.includes(node.operator);
       }
-      if (node.type === AST_NODE_TYPES33.UnaryExpression) {
+      if (node.type === AST_NODE_TYPES38.UnaryExpression) {
         return node.operator === "!";
       }
       return false;
@@ -2562,7 +3065,7 @@ var noLogicInParams = createRule33({
             messageId: "noLogicInParams"
           });
         }
-        if (arg.type === AST_NODE_TYPES33.ArrayExpression) {
+        if (arg.type === AST_NODE_TYPES38.ArrayExpression) {
           arg.elements.forEach((element) => {
             if (element && isComplexExpression(element)) {
               context.report({
@@ -2587,46 +3090,46 @@ var noLogicInParams = createRule33({
 var no_logic_in_params_default = noLogicInParams;
 
 // src/rules/no-misleading-constant-case.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES34, ESLintUtils as ESLintUtils34 } from "@typescript-eslint/utils";
-var createRule34 = ESLintUtils34.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES39, ESLintUtils as ESLintUtils39 } from "@typescript-eslint/utils";
+var createRule39 = ESLintUtils39.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var SCREAMING_SNAKE_CASE_REGEX3 = /^[A-Z][A-Z0-9]*(?:_[A-Z0-9]+)*$/;
-var isAsConstAssertion = (node) => node.type === AST_NODE_TYPES34.TSAsExpression && node.typeAnnotation.type === AST_NODE_TYPES34.TSTypeReference && node.typeAnnotation.typeName.type === AST_NODE_TYPES34.Identifier && node.typeAnnotation.typeName.name === "const";
+var isAsConstAssertion = (node) => node.type === AST_NODE_TYPES39.TSAsExpression && node.typeAnnotation.type === AST_NODE_TYPES39.TSTypeReference && node.typeAnnotation.typeName.type === AST_NODE_TYPES39.Identifier && node.typeAnnotation.typeName.name === "const";
 var isStaticValue2 = (init) => {
   if (isAsConstAssertion(init)) {
     return true;
   }
-  if (init.type === AST_NODE_TYPES34.Literal) {
+  if (init.type === AST_NODE_TYPES39.Literal) {
     return true;
   }
-  if (init.type === AST_NODE_TYPES34.UnaryExpression && init.argument.type === AST_NODE_TYPES34.Literal) {
+  if (init.type === AST_NODE_TYPES39.UnaryExpression && init.argument.type === AST_NODE_TYPES39.Literal) {
     return true;
   }
-  if (init.type === AST_NODE_TYPES34.TemplateLiteral && init.expressions.length === 0) {
+  if (init.type === AST_NODE_TYPES39.TemplateLiteral && init.expressions.length === 0) {
     return true;
   }
-  if (init.type === AST_NODE_TYPES34.ArrayExpression) {
-    return init.elements.every((el) => el !== null && el.type !== AST_NODE_TYPES34.SpreadElement && isStaticValue2(el));
+  if (init.type === AST_NODE_TYPES39.ArrayExpression) {
+    return init.elements.every((el) => el !== null && el.type !== AST_NODE_TYPES39.SpreadElement && isStaticValue2(el));
   }
-  if (init.type === AST_NODE_TYPES34.ObjectExpression) {
+  if (init.type === AST_NODE_TYPES39.ObjectExpression) {
     return init.properties.every(
-      (prop) => prop.type === AST_NODE_TYPES34.Property && isStaticValue2(prop.value)
+      (prop) => prop.type === AST_NODE_TYPES39.Property && isStaticValue2(prop.value)
     );
   }
   return false;
 };
 var isGlobalScope3 = (node) => {
   const { parent } = node;
-  if (parent.type === AST_NODE_TYPES34.Program) {
+  if (parent.type === AST_NODE_TYPES39.Program) {
     return true;
   }
-  if (parent.type === AST_NODE_TYPES34.ExportNamedDeclaration && parent.parent?.type === AST_NODE_TYPES34.Program) {
+  if (parent.type === AST_NODE_TYPES39.ExportNamedDeclaration && parent.parent?.type === AST_NODE_TYPES39.Program) {
     return true;
   }
   return false;
 };
-var noMisleadingConstantCase = createRule34({
+var noMisleadingConstantCase = createRule39({
   name: "no-misleading-constant-case",
   meta: {
     type: "suggestion",
@@ -2645,7 +3148,7 @@ var noMisleadingConstantCase = createRule34({
     return {
       VariableDeclaration(node) {
         node.declarations.forEach((declarator) => {
-          if (declarator.id.type !== AST_NODE_TYPES34.Identifier) {
+          if (declarator.id.type !== AST_NODE_TYPES39.Identifier) {
             return;
           }
           const { name } = declarator.id;
@@ -2686,11 +3189,11 @@ var noMisleadingConstantCase = createRule34({
 var no_misleading_constant_case_default = noMisleadingConstantCase;
 
 // src/rules/no-nested-interface-declaration.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES35, ESLintUtils as ESLintUtils35 } from "@typescript-eslint/utils";
-var createRule35 = ESLintUtils35.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES40, ESLintUtils as ESLintUtils40 } from "@typescript-eslint/utils";
+var createRule40 = ESLintUtils40.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var noNestedInterfaceDeclaration = createRule35({
+var noNestedInterfaceDeclaration = createRule40({
   name: "no-nested-interface-declaration",
   meta: {
     type: "suggestion",
@@ -2711,15 +3214,15 @@ var noNestedInterfaceDeclaration = createRule35({
           return;
         }
         const { typeAnnotation } = node.typeAnnotation;
-        if (typeAnnotation.type === AST_NODE_TYPES35.TSTypeLiteral) {
+        if (typeAnnotation.type === AST_NODE_TYPES40.TSTypeLiteral) {
           context.report({
             node: typeAnnotation,
             messageId: "noNestedInterface"
           });
           return;
         }
-        if (typeAnnotation.type === AST_NODE_TYPES35.TSArrayType) {
-          if (typeAnnotation.elementType.type === AST_NODE_TYPES35.TSTypeLiteral) {
+        if (typeAnnotation.type === AST_NODE_TYPES40.TSArrayType) {
+          if (typeAnnotation.elementType.type === AST_NODE_TYPES40.TSTypeLiteral) {
             context.report({
               node: typeAnnotation.elementType,
               messageId: "noNestedInterface"
@@ -2727,9 +3230,9 @@ var noNestedInterfaceDeclaration = createRule35({
           }
           return;
         }
-        if (typeAnnotation.type === AST_NODE_TYPES35.TSTypeReference && typeAnnotation.typeArguments) {
+        if (typeAnnotation.type === AST_NODE_TYPES40.TSTypeReference && typeAnnotation.typeArguments) {
           typeAnnotation.typeArguments.params.forEach((param) => {
-            if (param.type === AST_NODE_TYPES35.TSTypeLiteral) {
+            if (param.type === AST_NODE_TYPES40.TSTypeLiteral) {
               context.report({
                 node: param,
                 messageId: "noNestedInterface"
@@ -2744,11 +3247,11 @@ var noNestedInterfaceDeclaration = createRule35({
 var no_nested_interface_declaration_default = noNestedInterfaceDeclaration;
 
 // src/rules/no-nested-ternary.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES36, ESLintUtils as ESLintUtils36 } from "@typescript-eslint/utils";
-var createRule36 = ESLintUtils36.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES41, ESLintUtils as ESLintUtils41 } from "@typescript-eslint/utils";
+var createRule41 = ESLintUtils41.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var noNestedTernary = createRule36({
+var noNestedTernary = createRule41({
   name: "no-nested-ternary",
   meta: {
     type: "suggestion",
@@ -2765,13 +3268,13 @@ var noNestedTernary = createRule36({
     return {
       ConditionalExpression(node) {
         const { consequent, alternate } = node;
-        if (consequent.type === AST_NODE_TYPES36.ConditionalExpression) {
+        if (consequent.type === AST_NODE_TYPES41.ConditionalExpression) {
           context.report({
             node: consequent,
             messageId: "noNestedTernary"
           });
         }
-        if (alternate.type === AST_NODE_TYPES36.ConditionalExpression) {
+        if (alternate.type === AST_NODE_TYPES41.ConditionalExpression) {
           context.report({
             node: alternate,
             messageId: "noNestedTernary"
@@ -2783,12 +3286,86 @@ var noNestedTernary = createRule36({
 });
 var no_nested_ternary_default = noNestedTernary;
 
+// src/rules/no-redundant-fragment.ts
+import { AST_NODE_TYPES as AST_NODE_TYPES42, ESLintUtils as ESLintUtils42 } from "@typescript-eslint/utils";
+var createRule42 = ESLintUtils42.RuleCreator(
+  (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
+);
+function isFragmentName(name) {
+  if (name.type === AST_NODE_TYPES42.JSXIdentifier && name.name === "Fragment") {
+    return true;
+  }
+  if (name.type === AST_NODE_TYPES42.JSXMemberExpression && name.object.type === AST_NODE_TYPES42.JSXIdentifier && name.object.name === "React" && name.property.type === AST_NODE_TYPES42.JSXIdentifier && name.property.name === "Fragment") {
+    return true;
+  }
+  return false;
+}
+function hasKeyAttribute(attributes) {
+  return attributes.some(
+    (attribute) => attribute.type === AST_NODE_TYPES42.JSXAttribute && attribute.name.type === AST_NODE_TYPES42.JSXIdentifier && attribute.name.name === "key"
+  );
+}
+function countMeaningfulChildren(children) {
+  return children.filter((child) => {
+    if (child.type === AST_NODE_TYPES42.JSXText) {
+      return child.value.trim() !== "";
+    }
+    return true;
+  }).length;
+}
+var noRedundantFragment = createRule42({
+  name: "no-redundant-fragment",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow Fragments that wrap zero or one child (unless a key prop is needed)"
+    },
+    schema: [],
+    messages: {
+      redundantFragment: "Fragment is redundant when wrapping {{ count }} child. Remove the Fragment or replace it with the child directly."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      JSXFragment(node) {
+        const count = countMeaningfulChildren(node.children);
+        if (count <= 1) {
+          context.report({
+            node,
+            messageId: "redundantFragment",
+            data: { count: String(count) }
+          });
+        }
+      },
+      JSXElement(node) {
+        const opening = node.openingElement;
+        if (!isFragmentName(opening.name)) {
+          return;
+        }
+        if (hasKeyAttribute(opening.attributes)) {
+          return;
+        }
+        const count = countMeaningfulChildren(node.children);
+        if (count <= 1) {
+          context.report({
+            node,
+            messageId: "redundantFragment",
+            data: { count: String(count) }
+          });
+        }
+      }
+    };
+  }
+});
+var no_redundant_fragment_default = noRedundantFragment;
+
 // src/rules/no-relative-imports.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES37, ESLintUtils as ESLintUtils37 } from "@typescript-eslint/utils";
-var createRule37 = ESLintUtils37.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES43, ESLintUtils as ESLintUtils43 } from "@typescript-eslint/utils";
+var createRule43 = ESLintUtils43.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var noRelativeImports = createRule37({
+var noRelativeImports = createRule43({
   name: "no-relative-imports",
   meta: {
     type: "suggestion",
@@ -2812,22 +3389,22 @@ var noRelativeImports = createRule37({
     };
     return {
       ImportDeclaration(node) {
-        if (node.source.type === AST_NODE_TYPES37.Literal && typeof node.source.value === "string") {
+        if (node.source.type === AST_NODE_TYPES43.Literal && typeof node.source.value === "string") {
           checkImportPath(node.source.value, node);
         }
       },
       ImportExpression(node) {
-        if (node.source.type === AST_NODE_TYPES37.Literal && typeof node.source.value === "string") {
+        if (node.source.type === AST_NODE_TYPES43.Literal && typeof node.source.value === "string") {
           checkImportPath(node.source.value, node);
         }
       },
       ExportNamedDeclaration(node) {
-        if (node.source?.type === AST_NODE_TYPES37.Literal && typeof node.source.value === "string") {
+        if (node.source?.type === AST_NODE_TYPES43.Literal && typeof node.source.value === "string") {
           checkImportPath(node.source.value, node);
         }
       },
       ExportAllDeclaration(node) {
-        if (node.source.type === AST_NODE_TYPES37.Literal && typeof node.source.value === "string") {
+        if (node.source.type === AST_NODE_TYPES43.Literal && typeof node.source.value === "string") {
           checkImportPath(node.source.value, node);
         }
       }
@@ -2837,8 +3414,8 @@ var noRelativeImports = createRule37({
 var no_relative_imports_default = noRelativeImports;
 
 // src/rules/no-single-char-variables.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES38, ESLintUtils as ESLintUtils38 } from "@typescript-eslint/utils";
-var createRule38 = ESLintUtils38.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES44, ESLintUtils as ESLintUtils44 } from "@typescript-eslint/utils";
+var createRule44 = ESLintUtils44.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var ALLOWED_IN_FOR_LOOPS = /* @__PURE__ */ new Set(["i", "j", "k", "n"]);
@@ -2850,7 +3427,7 @@ var isForLoopInit = (node) => {
     if (!parentNode) {
       return false;
     }
-    if (parentNode.type === AST_NODE_TYPES38.ForStatement) {
+    if (parentNode.type === AST_NODE_TYPES44.ForStatement) {
       const { init } = parentNode;
       if (init && init === current) {
         return true;
@@ -2869,7 +3446,7 @@ var isAllowedInContext = (name, node) => {
   }
   return false;
 };
-var noSingleCharVariables = createRule38({
+var noSingleCharVariables = createRule44({
   name: "no-single-char-variables",
   meta: {
     type: "suggestion",
@@ -2898,27 +3475,27 @@ var noSingleCharVariables = createRule38({
       });
     };
     const checkPattern = (pattern, declarationNode) => {
-      if (pattern.type === AST_NODE_TYPES38.Identifier) {
+      if (pattern.type === AST_NODE_TYPES44.Identifier) {
         checkIdentifier(pattern, declarationNode);
-      } else if (pattern.type === AST_NODE_TYPES38.ObjectPattern) {
+      } else if (pattern.type === AST_NODE_TYPES44.ObjectPattern) {
         pattern.properties.forEach((prop) => {
-          if (prop.type === AST_NODE_TYPES38.Property && prop.value.type === AST_NODE_TYPES38.Identifier) {
+          if (prop.type === AST_NODE_TYPES44.Property && prop.value.type === AST_NODE_TYPES44.Identifier) {
             checkIdentifier(prop.value, declarationNode);
-          } else if (prop.type === AST_NODE_TYPES38.RestElement && prop.argument.type === AST_NODE_TYPES38.Identifier) {
+          } else if (prop.type === AST_NODE_TYPES44.RestElement && prop.argument.type === AST_NODE_TYPES44.Identifier) {
             checkIdentifier(prop.argument, declarationNode);
           }
         });
-      } else if (pattern.type === AST_NODE_TYPES38.ArrayPattern) {
+      } else if (pattern.type === AST_NODE_TYPES44.ArrayPattern) {
         pattern.elements.forEach((element) => {
-          if (element?.type === AST_NODE_TYPES38.Identifier) {
+          if (element?.type === AST_NODE_TYPES44.Identifier) {
             checkIdentifier(element, declarationNode);
-          } else if (element?.type === AST_NODE_TYPES38.RestElement && element.argument.type === AST_NODE_TYPES38.Identifier) {
+          } else if (element?.type === AST_NODE_TYPES44.RestElement && element.argument.type === AST_NODE_TYPES44.Identifier) {
             checkIdentifier(element.argument, declarationNode);
           }
         });
-      } else if (pattern.type === AST_NODE_TYPES38.AssignmentPattern && pattern.left.type === AST_NODE_TYPES38.Identifier) {
+      } else if (pattern.type === AST_NODE_TYPES44.AssignmentPattern && pattern.left.type === AST_NODE_TYPES44.Identifier) {
         checkIdentifier(pattern.left, declarationNode);
-      } else if (pattern.type === AST_NODE_TYPES38.RestElement && pattern.argument.type === AST_NODE_TYPES38.Identifier) {
+      } else if (pattern.type === AST_NODE_TYPES44.RestElement && pattern.argument.type === AST_NODE_TYPES44.Identifier) {
         checkIdentifier(pattern.argument, declarationNode);
       }
     };
@@ -2952,11 +3529,11 @@ var noSingleCharVariables = createRule38({
 var no_single_char_variables_default = noSingleCharVariables;
 
 // src/rules/prefer-async-await.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES39, ESLintUtils as ESLintUtils39 } from "@typescript-eslint/utils";
-var createRule39 = ESLintUtils39.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES45, ESLintUtils as ESLintUtils45 } from "@typescript-eslint/utils";
+var createRule45 = ESLintUtils45.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var preferAsyncAwait = createRule39({
+var preferAsyncAwait = createRule45({
   name: "prefer-async-await",
   meta: {
     type: "suggestion",
@@ -2972,7 +3549,7 @@ var preferAsyncAwait = createRule39({
   create(context) {
     return {
       CallExpression(node) {
-        if (node.callee.type === AST_NODE_TYPES39.MemberExpression && node.callee.property.type === AST_NODE_TYPES39.Identifier && node.callee.property.name === "then") {
+        if (node.callee.type === AST_NODE_TYPES45.MemberExpression && node.callee.property.type === AST_NODE_TYPES45.Identifier && node.callee.property.name === "then") {
           context.report({
             node: node.callee.property,
             messageId: "preferAsyncAwait"
@@ -2985,11 +3562,11 @@ var preferAsyncAwait = createRule39({
 var prefer_async_await_default = preferAsyncAwait;
 
 // src/rules/prefer-destructuring-params.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES40, ESLintUtils as ESLintUtils40 } from "@typescript-eslint/utils";
-var createRule40 = ESLintUtils40.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES46, ESLintUtils as ESLintUtils46 } from "@typescript-eslint/utils";
+var createRule46 = ESLintUtils46.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var preferDestructuringParams = createRule40({
+var preferDestructuringParams = createRule46({
   name: "prefer-destructuring-params",
   meta: {
     type: "suggestion",
@@ -3005,18 +3582,18 @@ var preferDestructuringParams = createRule40({
   create(context) {
     const isCallbackFunction2 = (node) => {
       const { parent } = node;
-      return parent?.type === AST_NODE_TYPES40.CallExpression;
+      return parent?.type === AST_NODE_TYPES46.CallExpression;
     };
     const isDeveloperFunction = (node) => {
-      if (node.type === AST_NODE_TYPES40.FunctionDeclaration) {
+      if (node.type === AST_NODE_TYPES46.FunctionDeclaration) {
         return true;
       }
-      if (node.type === AST_NODE_TYPES40.FunctionExpression || node.type === AST_NODE_TYPES40.ArrowFunctionExpression) {
+      if (node.type === AST_NODE_TYPES46.FunctionExpression || node.type === AST_NODE_TYPES46.ArrowFunctionExpression) {
         if (isCallbackFunction2(node)) {
           return false;
         }
         const { parent } = node;
-        return parent?.type === AST_NODE_TYPES40.VariableDeclarator || parent?.type === AST_NODE_TYPES40.AssignmentExpression || parent?.type === AST_NODE_TYPES40.Property || parent?.type === AST_NODE_TYPES40.MethodDefinition;
+        return parent?.type === AST_NODE_TYPES46.VariableDeclarator || parent?.type === AST_NODE_TYPES46.AssignmentExpression || parent?.type === AST_NODE_TYPES46.Property || parent?.type === AST_NODE_TYPES46.MethodDefinition;
       }
       return false;
     };
@@ -3028,7 +3605,7 @@ var preferDestructuringParams = createRule40({
       if (!isDeveloperFunction(node)) {
         return;
       }
-      if (node.type === AST_NODE_TYPES40.FunctionDeclaration && node.id) {
+      if (node.type === AST_NODE_TYPES46.FunctionDeclaration && node.id) {
         const functionName = node.id.name;
         if (functionName.startsWith("_") || functionName.includes("$") || /^[A-Z][a-zA-Z]*$/.test(functionName)) {
           return;
@@ -3038,7 +3615,7 @@ var preferDestructuringParams = createRule40({
         return;
       }
       const hasNonDestructuredParams = node.params.some(
-        (param) => param.type !== AST_NODE_TYPES40.ObjectPattern && param.type !== AST_NODE_TYPES40.RestElement
+        (param) => param.type !== AST_NODE_TYPES46.ObjectPattern && param.type !== AST_NODE_TYPES46.RestElement
       );
       if (hasNonDestructuredParams) {
         context.report({
@@ -3057,8 +3634,8 @@ var preferDestructuringParams = createRule40({
 var prefer_destructuring_params_default = preferDestructuringParams;
 
 // src/rules/prefer-function-declaration.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES41, ESLintUtils as ESLintUtils41 } from "@typescript-eslint/utils";
-var createRule41 = ESLintUtils41.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES47, ESLintUtils as ESLintUtils47 } from "@typescript-eslint/utils";
+var createRule47 = ESLintUtils47.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var isTsFile = (filename) => filename.endsWith(".ts") && !filename.endsWith(".d.ts");
@@ -3067,33 +3644,33 @@ var isCallbackContext = (node) => {
   if (!parent) {
     return false;
   }
-  if (parent.type === AST_NODE_TYPES41.CallExpression && parent.arguments.includes(node)) {
+  if (parent.type === AST_NODE_TYPES47.CallExpression && parent.arguments.includes(node)) {
     return true;
   }
-  if (parent.type === AST_NODE_TYPES41.NewExpression && parent.arguments.includes(node)) {
+  if (parent.type === AST_NODE_TYPES47.NewExpression && parent.arguments.includes(node)) {
     return true;
   }
-  if (parent.type === AST_NODE_TYPES41.ReturnStatement) {
+  if (parent.type === AST_NODE_TYPES47.ReturnStatement) {
     return true;
   }
-  if (parent.type === AST_NODE_TYPES41.Property) {
+  if (parent.type === AST_NODE_TYPES47.Property) {
     return true;
   }
-  if (parent.type === AST_NODE_TYPES41.ArrayExpression) {
+  if (parent.type === AST_NODE_TYPES47.ArrayExpression) {
     return true;
   }
-  if (parent.type === AST_NODE_TYPES41.ConditionalExpression) {
+  if (parent.type === AST_NODE_TYPES47.ConditionalExpression) {
     return true;
   }
-  if (parent.type === AST_NODE_TYPES41.LogicalExpression) {
+  if (parent.type === AST_NODE_TYPES47.LogicalExpression) {
     return true;
   }
-  if (parent.type === AST_NODE_TYPES41.AssignmentExpression && parent.left !== node) {
+  if (parent.type === AST_NODE_TYPES47.AssignmentExpression && parent.left !== node) {
     return true;
   }
   return false;
 };
-var preferFunctionDeclaration = createRule41({
+var preferFunctionDeclaration = createRule47({
   name: "prefer-function-declaration",
   meta: {
     type: "suggestion",
@@ -3114,14 +3691,14 @@ var preferFunctionDeclaration = createRule41({
     }
     return {
       VariableDeclarator(node) {
-        if (node.id.type !== AST_NODE_TYPES41.Identifier) {
+        if (node.id.type !== AST_NODE_TYPES47.Identifier) {
           return;
         }
         const { init } = node;
         if (!init) {
           return;
         }
-        if (init.type === AST_NODE_TYPES41.ArrowFunctionExpression) {
+        if (init.type === AST_NODE_TYPES47.ArrowFunctionExpression) {
           if (isCallbackContext(init)) {
             return;
           }
@@ -3131,7 +3708,7 @@ var preferFunctionDeclaration = createRule41({
             data: { name: node.id.name }
           });
         }
-        if (init.type === AST_NODE_TYPES41.FunctionExpression) {
+        if (init.type === AST_NODE_TYPES47.FunctionExpression) {
           if (isCallbackContext(init)) {
             return;
           }
@@ -3148,11 +3725,11 @@ var preferFunctionDeclaration = createRule41({
 var prefer_function_declaration_default = preferFunctionDeclaration;
 
 // src/rules/prefer-guard-clause.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES42, ESLintUtils as ESLintUtils42 } from "@typescript-eslint/utils";
-var createRule42 = ESLintUtils42.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES48, ESLintUtils as ESLintUtils48 } from "@typescript-eslint/utils";
+var createRule48 = ESLintUtils48.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var preferGuardClause = createRule42({
+var preferGuardClause = createRule48({
   name: "prefer-guard-clause",
   meta: {
     type: "suggestion",
@@ -3169,8 +3746,8 @@ var preferGuardClause = createRule42({
     return {
       IfStatement(node) {
         const { consequent } = node;
-        if (consequent.type === AST_NODE_TYPES42.BlockStatement) {
-          const hasNestedIf = consequent.body.some((statement) => statement.type === AST_NODE_TYPES42.IfStatement);
+        if (consequent.type === AST_NODE_TYPES48.BlockStatement) {
+          const hasNestedIf = consequent.body.some((statement) => statement.type === AST_NODE_TYPES48.IfStatement);
           if (hasNestedIf && consequent.body.length === 1) {
             context.report({
               node,
@@ -3178,7 +3755,7 @@ var preferGuardClause = createRule42({
             });
           }
         }
-        if (consequent.type === AST_NODE_TYPES42.IfStatement) {
+        if (consequent.type === AST_NODE_TYPES48.IfStatement) {
           context.report({
             node,
             messageId: "preferGuardClause"
@@ -3191,11 +3768,11 @@ var preferGuardClause = createRule42({
 var prefer_guard_clause_default = preferGuardClause;
 
 // src/rules/prefer-import-type.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES43, ESLintUtils as ESLintUtils43 } from "@typescript-eslint/utils";
-var createRule43 = ESLintUtils43.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES49, ESLintUtils as ESLintUtils49 } from "@typescript-eslint/utils";
+var createRule49 = ESLintUtils49.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var preferImportType = createRule43({
+var preferImportType = createRule49({
   name: "prefer-import-type",
   meta: {
     type: "suggestion",
@@ -3214,22 +3791,22 @@ var preferImportType = createRule43({
       let current = node;
       while (current) {
         switch (current.type) {
-          case AST_NODE_TYPES43.TSTypeReference:
-          case AST_NODE_TYPES43.TSTypeAnnotation:
-          case AST_NODE_TYPES43.TSTypeParameterInstantiation:
-          case AST_NODE_TYPES43.TSInterfaceHeritage:
-          case AST_NODE_TYPES43.TSClassImplements:
-          case AST_NODE_TYPES43.TSTypeQuery:
-          case AST_NODE_TYPES43.TSTypeAssertion:
-          case AST_NODE_TYPES43.TSAsExpression:
-          case AST_NODE_TYPES43.TSSatisfiesExpression:
-          case AST_NODE_TYPES43.TSTypeAliasDeclaration:
-          case AST_NODE_TYPES43.TSInterfaceDeclaration:
-          case AST_NODE_TYPES43.TSTypeParameter:
-          case AST_NODE_TYPES43.TSQualifiedName:
+          case AST_NODE_TYPES49.TSTypeReference:
+          case AST_NODE_TYPES49.TSTypeAnnotation:
+          case AST_NODE_TYPES49.TSTypeParameterInstantiation:
+          case AST_NODE_TYPES49.TSInterfaceHeritage:
+          case AST_NODE_TYPES49.TSClassImplements:
+          case AST_NODE_TYPES49.TSTypeQuery:
+          case AST_NODE_TYPES49.TSTypeAssertion:
+          case AST_NODE_TYPES49.TSAsExpression:
+          case AST_NODE_TYPES49.TSSatisfiesExpression:
+          case AST_NODE_TYPES49.TSTypeAliasDeclaration:
+          case AST_NODE_TYPES49.TSInterfaceDeclaration:
+          case AST_NODE_TYPES49.TSTypeParameter:
+          case AST_NODE_TYPES49.TSQualifiedName:
             return true;
-          case AST_NODE_TYPES43.MemberExpression:
-          case AST_NODE_TYPES43.Identifier:
+          case AST_NODE_TYPES49.MemberExpression:
+          case AST_NODE_TYPES49.Identifier:
             current = current.parent;
             break;
           default:
@@ -3259,27 +3836,27 @@ var preferImportType = createRule43({
           return false;
         }
         switch (parent.type) {
-          case AST_NODE_TYPES43.CallExpression:
-          case AST_NODE_TYPES43.NewExpression:
-          case AST_NODE_TYPES43.JSXOpeningElement:
-          case AST_NODE_TYPES43.JSXClosingElement:
-          case AST_NODE_TYPES43.MemberExpression:
-          case AST_NODE_TYPES43.VariableDeclarator:
-          case AST_NODE_TYPES43.TaggedTemplateExpression:
-          case AST_NODE_TYPES43.SpreadElement:
-          case AST_NODE_TYPES43.ExportSpecifier:
-          case AST_NODE_TYPES43.ArrayExpression:
-          case AST_NODE_TYPES43.ObjectExpression:
-          case AST_NODE_TYPES43.BinaryExpression:
-          case AST_NODE_TYPES43.LogicalExpression:
-          case AST_NODE_TYPES43.UnaryExpression:
-          case AST_NODE_TYPES43.ReturnStatement:
-          case AST_NODE_TYPES43.ArrowFunctionExpression:
-          case AST_NODE_TYPES43.ConditionalExpression:
-          case AST_NODE_TYPES43.AwaitExpression:
-          case AST_NODE_TYPES43.YieldExpression:
-          case AST_NODE_TYPES43.Property:
-          case AST_NODE_TYPES43.JSXExpressionContainer:
+          case AST_NODE_TYPES49.CallExpression:
+          case AST_NODE_TYPES49.NewExpression:
+          case AST_NODE_TYPES49.JSXOpeningElement:
+          case AST_NODE_TYPES49.JSXClosingElement:
+          case AST_NODE_TYPES49.MemberExpression:
+          case AST_NODE_TYPES49.VariableDeclarator:
+          case AST_NODE_TYPES49.TaggedTemplateExpression:
+          case AST_NODE_TYPES49.SpreadElement:
+          case AST_NODE_TYPES49.ExportSpecifier:
+          case AST_NODE_TYPES49.ArrayExpression:
+          case AST_NODE_TYPES49.ObjectExpression:
+          case AST_NODE_TYPES49.BinaryExpression:
+          case AST_NODE_TYPES49.LogicalExpression:
+          case AST_NODE_TYPES49.UnaryExpression:
+          case AST_NODE_TYPES49.ReturnStatement:
+          case AST_NODE_TYPES49.ArrowFunctionExpression:
+          case AST_NODE_TYPES49.ConditionalExpression:
+          case AST_NODE_TYPES49.AwaitExpression:
+          case AST_NODE_TYPES49.YieldExpression:
+          case AST_NODE_TYPES49.Property:
+          case AST_NODE_TYPES49.JSXExpressionContainer:
             return true;
           default:
             return false;
@@ -3291,7 +3868,7 @@ var preferImportType = createRule43({
         return;
       }
       const hasInlineTypeSpecifier = node.specifiers.some(
-        (specifier) => specifier.type === AST_NODE_TYPES43.ImportSpecifier && specifier.importKind === "type"
+        (specifier) => specifier.type === AST_NODE_TYPES49.ImportSpecifier && specifier.importKind === "type"
       );
       if (hasInlineTypeSpecifier) {
         return;
@@ -3309,13 +3886,13 @@ var preferImportType = createRule43({
       }
       const scope = context.sourceCode.getScope(node);
       const isTypeOnlyImport2 = node.specifiers.every((specifier) => {
-        if (specifier.type === AST_NODE_TYPES43.ImportDefaultSpecifier) {
+        if (specifier.type === AST_NODE_TYPES49.ImportDefaultSpecifier) {
           return false;
         }
-        if (specifier.type === AST_NODE_TYPES43.ImportNamespaceSpecifier) {
+        if (specifier.type === AST_NODE_TYPES49.ImportNamespaceSpecifier) {
           return false;
         }
-        if (specifier.type === AST_NODE_TYPES43.ImportSpecifier) {
+        if (specifier.type === AST_NODE_TYPES49.ImportSpecifier) {
           const localName = specifier.local.name;
           return !isUsedAsValue(localName, scope);
         }
@@ -3341,19 +3918,19 @@ var preferImportType = createRule43({
 var prefer_import_type_default = preferImportType;
 
 // src/rules/prefer-inline-literal-union.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES44, ESLintUtils as ESLintUtils44 } from "@typescript-eslint/utils";
-var createRule44 = ESLintUtils44.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES50, ESLintUtils as ESLintUtils50 } from "@typescript-eslint/utils";
+var createRule50 = ESLintUtils50.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 function isLiteralUnionType(node) {
-  if (node.type !== AST_NODE_TYPES44.TSUnionType) {
+  if (node.type !== AST_NODE_TYPES50.TSUnionType) {
     return false;
   }
   return node.types.every(
-    (member) => member.type === AST_NODE_TYPES44.TSLiteralType || member.type === AST_NODE_TYPES44.TSNullKeyword || member.type === AST_NODE_TYPES44.TSUndefinedKeyword
+    (member) => member.type === AST_NODE_TYPES50.TSLiteralType || member.type === AST_NODE_TYPES50.TSNullKeyword || member.type === AST_NODE_TYPES50.TSUndefinedKeyword
   );
 }
-var preferInlineLiteralUnion = createRule44({
+var preferInlineLiteralUnion = createRule50({
   name: "prefer-inline-literal-union",
   meta: {
     type: "suggestion",
@@ -3380,10 +3957,10 @@ var preferInlineLiteralUnion = createRule44({
           return;
         }
         const { typeAnnotation } = node.typeAnnotation;
-        if (typeAnnotation.type !== AST_NODE_TYPES44.TSTypeReference) {
+        if (typeAnnotation.type !== AST_NODE_TYPES50.TSTypeReference) {
           return;
         }
-        if (typeAnnotation.typeName.type !== AST_NODE_TYPES44.Identifier) {
+        if (typeAnnotation.typeName.type !== AST_NODE_TYPES50.Identifier) {
           return;
         }
         const aliasName = typeAnnotation.typeName.name;
@@ -3407,12 +3984,12 @@ var preferInlineLiteralUnion = createRule44({
 var prefer_inline_literal_union_default = preferInlineLiteralUnion;
 
 // src/rules/prefer-inline-type-export.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES45, ESLintUtils as ESLintUtils45 } from "@typescript-eslint/utils";
-var createRule45 = ESLintUtils45.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES51, ESLintUtils as ESLintUtils51 } from "@typescript-eslint/utils";
+var createRule51 = ESLintUtils51.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var isTypeDeclaration = (node) => node.type === AST_NODE_TYPES45.TSInterfaceDeclaration || node.type === AST_NODE_TYPES45.TSTypeAliasDeclaration;
-var preferInlineTypeExport = createRule45({
+var isTypeDeclaration = (node) => node.type === AST_NODE_TYPES51.TSInterfaceDeclaration || node.type === AST_NODE_TYPES51.TSTypeAliasDeclaration;
+var preferInlineTypeExport = createRule51({
   name: "prefer-inline-type-export",
   meta: {
     type: "suggestion",
@@ -3429,12 +4006,12 @@ var preferInlineTypeExport = createRule45({
   create(context) {
     const typeDeclarations = /* @__PURE__ */ new Map();
     function collectDeclaration(node) {
-      if (node.parent.type !== AST_NODE_TYPES45.ExportNamedDeclaration) {
+      if (node.parent.type !== AST_NODE_TYPES51.ExportNamedDeclaration) {
         typeDeclarations.set(node.id.name, node);
       }
     }
     function reportSpecifier(specifier, statement, declarationNode) {
-      if (specifier.local.type !== AST_NODE_TYPES45.Identifier) {
+      if (specifier.local.type !== AST_NODE_TYPES51.Identifier) {
         return;
       }
       const { name } = specifier.local;
@@ -3467,16 +4044,16 @@ var preferInlineTypeExport = createRule45({
     return {
       Program(node) {
         node.body.forEach((statement) => {
-          if (statement.type === AST_NODE_TYPES45.TSInterfaceDeclaration || statement.type === AST_NODE_TYPES45.TSTypeAliasDeclaration) {
+          if (statement.type === AST_NODE_TYPES51.TSInterfaceDeclaration || statement.type === AST_NODE_TYPES51.TSTypeAliasDeclaration) {
             collectDeclaration(statement);
           }
         });
         node.body.forEach((statement) => {
-          if (statement.type !== AST_NODE_TYPES45.ExportNamedDeclaration || statement.declaration !== null) {
+          if (statement.type !== AST_NODE_TYPES51.ExportNamedDeclaration || statement.declaration !== null) {
             return;
           }
           statement.specifiers.forEach((specifier) => {
-            if (specifier.local.type !== AST_NODE_TYPES45.Identifier) {
+            if (specifier.local.type !== AST_NODE_TYPES51.Identifier) {
               return;
             }
             const declarationNode = typeDeclarations.get(specifier.local.name);
@@ -3493,11 +4070,11 @@ var preferInlineTypeExport = createRule45({
 var prefer_inline_type_export_default = preferInlineTypeExport;
 
 // src/rules/prefer-interface-for-component-props.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES46, ESLintUtils as ESLintUtils46 } from "@typescript-eslint/utils";
-var createRule46 = ESLintUtils46.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES52, ESLintUtils as ESLintUtils52 } from "@typescript-eslint/utils";
+var createRule52 = ESLintUtils52.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var preferInterfaceForComponentProps = createRule46({
+var preferInterfaceForComponentProps = createRule52({
   name: "prefer-interface-for-component-props",
   meta: {
     type: "suggestion",
@@ -3517,13 +4094,13 @@ var preferInterfaceForComponentProps = createRule46({
     }
     return {
       TSTypeAliasDeclaration(node) {
-        if (node.id.type !== AST_NODE_TYPES46.Identifier) {
+        if (node.id.type !== AST_NODE_TYPES52.Identifier) {
           return;
         }
         if (!node.id.name.endsWith("Props")) {
           return;
         }
-        if (node.typeAnnotation.type !== AST_NODE_TYPES46.TSTypeLiteral) {
+        if (node.typeAnnotation.type !== AST_NODE_TYPES52.TSTypeLiteral) {
           return;
         }
         const { name } = node.id;
@@ -3550,11 +4127,11 @@ var preferInterfaceForComponentProps = createRule46({
 var prefer_interface_for_component_props_default = preferInterfaceForComponentProps;
 
 // src/rules/prefer-interface-over-inline-types.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES47, ESLintUtils as ESLintUtils47 } from "@typescript-eslint/utils";
-var createRule47 = ESLintUtils47.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES53, ESLintUtils as ESLintUtils53 } from "@typescript-eslint/utils";
+var createRule53 = ESLintUtils53.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var preferInterfaceOverInlineTypes = createRule47({
+var preferInterfaceOverInlineTypes = createRule53({
   name: "prefer-interface-over-inline-types",
   meta: {
     type: "suggestion",
@@ -3570,54 +4147,54 @@ var preferInterfaceOverInlineTypes = createRule47({
   defaultOptions: [],
   create(context) {
     function hasJSXInConditional(node) {
-      return node.consequent.type === AST_NODE_TYPES47.JSXElement || node.consequent.type === AST_NODE_TYPES47.JSXFragment || node.alternate.type === AST_NODE_TYPES47.JSXElement || node.alternate.type === AST_NODE_TYPES47.JSXFragment;
+      return node.consequent.type === AST_NODE_TYPES53.JSXElement || node.consequent.type === AST_NODE_TYPES53.JSXFragment || node.alternate.type === AST_NODE_TYPES53.JSXElement || node.alternate.type === AST_NODE_TYPES53.JSXFragment;
     }
     function hasJSXInLogical(node) {
-      return node.right.type === AST_NODE_TYPES47.JSXElement || node.right.type === AST_NODE_TYPES47.JSXFragment;
+      return node.right.type === AST_NODE_TYPES53.JSXElement || node.right.type === AST_NODE_TYPES53.JSXFragment;
     }
     function hasJSXReturn(block) {
       return block.body.some((stmt) => {
-        if (stmt.type === AST_NODE_TYPES47.ReturnStatement && stmt.argument) {
-          return stmt.argument.type === AST_NODE_TYPES47.JSXElement || stmt.argument.type === AST_NODE_TYPES47.JSXFragment || stmt.argument.type === AST_NODE_TYPES47.ConditionalExpression && hasJSXInConditional(stmt.argument) || stmt.argument.type === AST_NODE_TYPES47.LogicalExpression && hasJSXInLogical(stmt.argument);
+        if (stmt.type === AST_NODE_TYPES53.ReturnStatement && stmt.argument) {
+          return stmt.argument.type === AST_NODE_TYPES53.JSXElement || stmt.argument.type === AST_NODE_TYPES53.JSXFragment || stmt.argument.type === AST_NODE_TYPES53.ConditionalExpression && hasJSXInConditional(stmt.argument) || stmt.argument.type === AST_NODE_TYPES53.LogicalExpression && hasJSXInLogical(stmt.argument);
         }
         return false;
       });
     }
     function isReactComponent2(node) {
-      if (node.type === AST_NODE_TYPES47.ArrowFunctionExpression) {
-        if (node.body.type === AST_NODE_TYPES47.JSXElement || node.body.type === AST_NODE_TYPES47.JSXFragment) {
+      if (node.type === AST_NODE_TYPES53.ArrowFunctionExpression) {
+        if (node.body.type === AST_NODE_TYPES53.JSXElement || node.body.type === AST_NODE_TYPES53.JSXFragment) {
           return true;
         }
-        if (node.body.type === AST_NODE_TYPES47.BlockStatement) {
+        if (node.body.type === AST_NODE_TYPES53.BlockStatement) {
           return hasJSXReturn(node.body);
         }
-      } else if (node.type === AST_NODE_TYPES47.FunctionExpression || node.type === AST_NODE_TYPES47.FunctionDeclaration) {
-        if (node.body && node.body.type === AST_NODE_TYPES47.BlockStatement) {
+      } else if (node.type === AST_NODE_TYPES53.FunctionExpression || node.type === AST_NODE_TYPES53.FunctionDeclaration) {
+        if (node.body && node.body.type === AST_NODE_TYPES53.BlockStatement) {
           return hasJSXReturn(node.body);
         }
       }
       return false;
     }
     function isInlineTypeAnnotation(node) {
-      if (node.type === AST_NODE_TYPES47.TSTypeLiteral) {
+      if (node.type === AST_NODE_TYPES53.TSTypeLiteral) {
         return true;
       }
-      if (node.type === AST_NODE_TYPES47.TSTypeReference && node.typeArguments) {
-        return node.typeArguments.params.some((param) => param.type === AST_NODE_TYPES47.TSTypeLiteral);
+      if (node.type === AST_NODE_TYPES53.TSTypeReference && node.typeArguments) {
+        return node.typeArguments.params.some((param) => param.type === AST_NODE_TYPES53.TSTypeLiteral);
       }
-      if (node.type === AST_NODE_TYPES47.TSUnionType) {
+      if (node.type === AST_NODE_TYPES53.TSUnionType) {
         return node.types.some((type) => isInlineTypeAnnotation(type));
       }
       return false;
     }
     function hasInlineObjectType(node) {
-      if (node.type === AST_NODE_TYPES47.TSTypeLiteral) {
+      if (node.type === AST_NODE_TYPES53.TSTypeLiteral) {
         return true;
       }
-      if (node.type === AST_NODE_TYPES47.TSTypeReference && node.typeArguments) {
-        return node.typeArguments.params.some((param) => param.type === AST_NODE_TYPES47.TSTypeLiteral);
+      if (node.type === AST_NODE_TYPES53.TSTypeReference && node.typeArguments) {
+        return node.typeArguments.params.some((param) => param.type === AST_NODE_TYPES53.TSTypeLiteral);
       }
-      if (node.type === AST_NODE_TYPES47.TSUnionType) {
+      if (node.type === AST_NODE_TYPES53.TSUnionType) {
         return node.types.some((type) => hasInlineObjectType(type));
       }
       return false;
@@ -3630,7 +4207,7 @@ var preferInterfaceOverInlineTypes = createRule47({
         return;
       }
       const param = node.params[0];
-      if (param.type === AST_NODE_TYPES47.Identifier && param.typeAnnotation) {
+      if (param.type === AST_NODE_TYPES53.Identifier && param.typeAnnotation) {
         const { typeAnnotation } = param.typeAnnotation;
         if (isInlineTypeAnnotation(typeAnnotation) && hasInlineObjectType(typeAnnotation)) {
           context.report({
@@ -3650,11 +4227,11 @@ var preferInterfaceOverInlineTypes = createRule47({
 var prefer_interface_over_inline_types_default = preferInterfaceOverInlineTypes;
 
 // src/rules/prefer-jsx-template-literals.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES48, ESLintUtils as ESLintUtils48 } from "@typescript-eslint/utils";
-var createRule48 = ESLintUtils48.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES54, ESLintUtils as ESLintUtils54 } from "@typescript-eslint/utils";
+var createRule54 = ESLintUtils54.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var preferJSXTemplateLiterals = createRule48({
+var preferJSXTemplateLiterals = createRule54({
   name: "prefer-jsx-template-literals",
   meta: {
     type: "suggestion",
@@ -3723,9 +4300,9 @@ var preferJSXTemplateLiterals = createRule48({
         if (!child || !nextChild) {
           return;
         }
-        if (child.type === AST_NODE_TYPES48.JSXText && nextChild.type === AST_NODE_TYPES48.JSXExpressionContainer) {
+        if (child.type === AST_NODE_TYPES54.JSXText && nextChild.type === AST_NODE_TYPES54.JSXExpressionContainer) {
           handleTextBeforeExpression(child, nextChild);
-        } else if (child.type === AST_NODE_TYPES48.JSXExpressionContainer && nextChild.type === AST_NODE_TYPES48.JSXText) {
+        } else if (child.type === AST_NODE_TYPES54.JSXExpressionContainer && nextChild.type === AST_NODE_TYPES54.JSXText) {
           handleExpressionBeforeText(child, nextChild);
         }
       }
@@ -3738,32 +4315,32 @@ var preferJSXTemplateLiterals = createRule48({
 var prefer_jsx_template_literals_default = preferJSXTemplateLiterals;
 
 // src/rules/prefer-named-param-types.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES49, ESLintUtils as ESLintUtils49 } from "@typescript-eslint/utils";
-var createRule49 = ESLintUtils49.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES55, ESLintUtils as ESLintUtils55 } from "@typescript-eslint/utils";
+var createRule55 = ESLintUtils55.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var returnsJsx2 = (node) => {
-  if (node.type === AST_NODE_TYPES49.JSXElement || node.type === AST_NODE_TYPES49.JSXFragment) {
+  if (node.type === AST_NODE_TYPES55.JSXElement || node.type === AST_NODE_TYPES55.JSXFragment) {
     return true;
   }
-  if (node.type === AST_NODE_TYPES49.ConditionalExpression) {
+  if (node.type === AST_NODE_TYPES55.ConditionalExpression) {
     return returnsJsx2(node.consequent) || returnsJsx2(node.alternate);
   }
-  if (node.type === AST_NODE_TYPES49.LogicalExpression) {
+  if (node.type === AST_NODE_TYPES55.LogicalExpression) {
     return returnsJsx2(node.left) || returnsJsx2(node.right);
   }
   return false;
 };
 var bodyReturnsJsx2 = (body) => {
-  if (body.type !== AST_NODE_TYPES49.BlockStatement) {
+  if (body.type !== AST_NODE_TYPES55.BlockStatement) {
     return returnsJsx2(body);
   }
   return body.body.some(
-    (stmt) => stmt.type === AST_NODE_TYPES49.ReturnStatement && stmt.argument !== null && returnsJsx2(stmt.argument)
+    (stmt) => stmt.type === AST_NODE_TYPES55.ReturnStatement && stmt.argument !== null && returnsJsx2(stmt.argument)
   );
 };
 var isReactComponentFunction = (node) => bodyReturnsJsx2(node.body);
-var preferNamedParamTypes = createRule49({
+var preferNamedParamTypes = createRule55({
   name: "prefer-named-param-types",
   meta: {
     type: "suggestion",
@@ -3778,16 +4355,16 @@ var preferNamedParamTypes = createRule49({
   defaultOptions: [],
   create(context) {
     function hasInlineObjectType(param) {
-      if (param.type === AST_NODE_TYPES49.AssignmentPattern) {
+      if (param.type === AST_NODE_TYPES55.AssignmentPattern) {
         return hasInlineObjectType(param.left);
       }
-      if (param.type === AST_NODE_TYPES49.ObjectPattern) {
-        if (param.typeAnnotation?.typeAnnotation.type === AST_NODE_TYPES49.TSTypeLiteral) {
+      if (param.type === AST_NODE_TYPES55.ObjectPattern) {
+        if (param.typeAnnotation?.typeAnnotation.type === AST_NODE_TYPES55.TSTypeLiteral) {
           return true;
         }
       }
-      if (param.type === AST_NODE_TYPES49.Identifier) {
-        if (param.typeAnnotation?.typeAnnotation.type === AST_NODE_TYPES49.TSTypeLiteral) {
+      if (param.type === AST_NODE_TYPES55.Identifier) {
+        if (param.typeAnnotation?.typeAnnotation.type === AST_NODE_TYPES55.TSTypeLiteral) {
           return true;
         }
       }
@@ -3800,7 +4377,7 @@ var preferNamedParamTypes = createRule49({
       } else if ("value" in node && node.value) {
         params = node.value.params;
       }
-      if ((node.type === AST_NODE_TYPES49.FunctionDeclaration || node.type === AST_NODE_TYPES49.FunctionExpression || node.type === AST_NODE_TYPES49.ArrowFunctionExpression) && params.length === 1 && params[0].type === AST_NODE_TYPES49.Identifier && isReactComponentFunction(node)) {
+      if ((node.type === AST_NODE_TYPES55.FunctionDeclaration || node.type === AST_NODE_TYPES55.FunctionExpression || node.type === AST_NODE_TYPES55.ArrowFunctionExpression) && params.length === 1 && params[0].type === AST_NODE_TYPES55.Identifier && isReactComponentFunction(node)) {
         return;
       }
       params.forEach((param) => {
@@ -3824,11 +4401,11 @@ var preferNamedParamTypes = createRule49({
 var prefer_named_param_types_default = preferNamedParamTypes;
 
 // src/rules/prefer-props-with-children.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES50, ESLintUtils as ESLintUtils50 } from "@typescript-eslint/utils";
-var createRule50 = ESLintUtils50.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES56, ESLintUtils as ESLintUtils56 } from "@typescript-eslint/utils";
+var createRule56 = ESLintUtils56.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var preferPropsWithChildren = createRule50({
+var preferPropsWithChildren = createRule56({
   name: "prefer-props-with-children",
   meta: {
     type: "suggestion",
@@ -3846,24 +4423,24 @@ var preferPropsWithChildren = createRule50({
       if (!typeNode) {
         return false;
       }
-      if (typeNode.type !== AST_NODE_TYPES50.TSTypeReference) {
+      if (typeNode.type !== AST_NODE_TYPES56.TSTypeReference) {
         return false;
       }
       const { typeName } = typeNode;
-      if (typeName.type === AST_NODE_TYPES50.Identifier) {
+      if (typeName.type === AST_NODE_TYPES56.Identifier) {
         return typeName.name === "ReactNode";
       }
-      if (typeName.type === AST_NODE_TYPES50.TSQualifiedName && typeName.left.type === AST_NODE_TYPES50.Identifier && typeName.left.name === "React" && typeName.right.type === AST_NODE_TYPES50.Identifier && typeName.right.name === "ReactNode") {
+      if (typeName.type === AST_NODE_TYPES56.TSQualifiedName && typeName.left.type === AST_NODE_TYPES56.Identifier && typeName.left.name === "React" && typeName.right.type === AST_NODE_TYPES56.Identifier && typeName.right.name === "ReactNode") {
         return true;
       }
       return false;
     }
     function findChildrenReactNode(members) {
       for (const member of members) {
-        if (member.type !== AST_NODE_TYPES50.TSPropertySignature) {
+        if (member.type !== AST_NODE_TYPES56.TSPropertySignature) {
           continue;
         }
-        if (member.key.type !== AST_NODE_TYPES50.Identifier) {
+        if (member.key.type !== AST_NODE_TYPES56.Identifier) {
           continue;
         }
         if (member.key.name !== "children") {
@@ -3903,11 +4480,11 @@ var preferPropsWithChildren = createRule50({
 var prefer_props_with_children_default = preferPropsWithChildren;
 
 // src/rules/prefer-react-import-types.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES51, ESLintUtils as ESLintUtils51 } from "@typescript-eslint/utils";
-var createRule51 = ESLintUtils51.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES57, ESLintUtils as ESLintUtils57 } from "@typescript-eslint/utils";
+var createRule57 = ESLintUtils57.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var preferReactImportTypes = createRule51({
+var preferReactImportTypes = createRule57({
   name: "prefer-react-import-types",
   meta: {
     type: "suggestion",
@@ -3983,7 +4560,7 @@ var preferReactImportTypes = createRule51({
     ]);
     const allReactExports = /* @__PURE__ */ new Set([...reactTypes, ...reactRuntimeExports]);
     function checkMemberExpression(node) {
-      if (node.object.type === AST_NODE_TYPES51.Identifier && node.object.name === "React" && node.property.type === AST_NODE_TYPES51.Identifier && allReactExports.has(node.property.name)) {
+      if (node.object.type === AST_NODE_TYPES57.Identifier && node.object.name === "React" && node.property.type === AST_NODE_TYPES57.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"`;
@@ -4000,7 +4577,7 @@ var preferReactImportTypes = createRule51({
     return {
       MemberExpression: checkMemberExpression,
       "TSTypeReference > TSQualifiedName": (node) => {
-        if (node.left.type === AST_NODE_TYPES51.Identifier && node.left.name === "React" && node.right.type === AST_NODE_TYPES51.Identifier && allReactExports.has(node.right.name)) {
+        if (node.left.type === AST_NODE_TYPES57.Identifier && node.left.name === "React" && node.right.type === AST_NODE_TYPES57.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"`;
@@ -4020,11 +4597,11 @@ var preferReactImportTypes = createRule51({
 var prefer_react_import_types_default = preferReactImportTypes;
 
 // src/rules/react-props-destructure.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES52, ESLintUtils as ESLintUtils52 } from "@typescript-eslint/utils";
-var createRule52 = ESLintUtils52.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES58, ESLintUtils as ESLintUtils58 } from "@typescript-eslint/utils";
+var createRule58 = ESLintUtils58.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var reactPropsDestructure = createRule52({
+var reactPropsDestructure = createRule58({
   name: "react-props-destructure",
   meta: {
     type: "suggestion",
@@ -4040,29 +4617,29 @@ var reactPropsDestructure = createRule52({
   defaultOptions: [],
   create(context) {
     function hasJSXInConditional(node) {
-      return node.consequent.type === AST_NODE_TYPES52.JSXElement || node.consequent.type === AST_NODE_TYPES52.JSXFragment || node.alternate.type === AST_NODE_TYPES52.JSXElement || node.alternate.type === AST_NODE_TYPES52.JSXFragment;
+      return node.consequent.type === AST_NODE_TYPES58.JSXElement || node.consequent.type === AST_NODE_TYPES58.JSXFragment || node.alternate.type === AST_NODE_TYPES58.JSXElement || node.alternate.type === AST_NODE_TYPES58.JSXFragment;
     }
     function hasJSXInLogical(node) {
-      return node.right.type === AST_NODE_TYPES52.JSXElement || node.right.type === AST_NODE_TYPES52.JSXFragment;
+      return node.right.type === AST_NODE_TYPES58.JSXElement || node.right.type === AST_NODE_TYPES58.JSXFragment;
     }
     function hasJSXReturn(block) {
       return block.body.some((stmt) => {
-        if (stmt.type === AST_NODE_TYPES52.ReturnStatement && stmt.argument) {
-          return stmt.argument.type === AST_NODE_TYPES52.JSXElement || stmt.argument.type === AST_NODE_TYPES52.JSXFragment || stmt.argument.type === AST_NODE_TYPES52.ConditionalExpression && hasJSXInConditional(stmt.argument) || stmt.argument.type === AST_NODE_TYPES52.LogicalExpression && hasJSXInLogical(stmt.argument);
+        if (stmt.type === AST_NODE_TYPES58.ReturnStatement && stmt.argument) {
+          return stmt.argument.type === AST_NODE_TYPES58.JSXElement || stmt.argument.type === AST_NODE_TYPES58.JSXFragment || stmt.argument.type === AST_NODE_TYPES58.ConditionalExpression && hasJSXInConditional(stmt.argument) || stmt.argument.type === AST_NODE_TYPES58.LogicalExpression && hasJSXInLogical(stmt.argument);
         }
         return false;
       });
     }
     function isReactComponent2(node) {
-      if (node.type === AST_NODE_TYPES52.ArrowFunctionExpression) {
-        if (node.body.type === AST_NODE_TYPES52.JSXElement || node.body.type === AST_NODE_TYPES52.JSXFragment) {
+      if (node.type === AST_NODE_TYPES58.ArrowFunctionExpression) {
+        if (node.body.type === AST_NODE_TYPES58.JSXElement || node.body.type === AST_NODE_TYPES58.JSXFragment) {
           return true;
         }
-        if (node.body.type === AST_NODE_TYPES52.BlockStatement) {
+        if (node.body.type === AST_NODE_TYPES58.BlockStatement) {
           return hasJSXReturn(node.body);
         }
-      } else if (node.type === AST_NODE_TYPES52.FunctionExpression || node.type === AST_NODE_TYPES52.FunctionDeclaration) {
-        if (node.body && node.body.type === AST_NODE_TYPES52.BlockStatement) {
+      } else if (node.type === AST_NODE_TYPES58.FunctionExpression || node.type === AST_NODE_TYPES58.FunctionDeclaration) {
+        if (node.body && node.body.type === AST_NODE_TYPES58.BlockStatement) {
           return hasJSXReturn(node.body);
         }
       }
@@ -4076,9 +4653,9 @@ var reactPropsDestructure = createRule52({
         return;
       }
       const param = node.params[0];
-      if (param.type === AST_NODE_TYPES52.ObjectPattern) {
-        const properties = param.properties.filter((prop) => prop.type === AST_NODE_TYPES52.Property).map((prop) => {
-          if (prop.key.type === AST_NODE_TYPES52.Identifier) {
+      if (param.type === AST_NODE_TYPES58.ObjectPattern) {
+        const properties = param.properties.filter((prop) => prop.type === AST_NODE_TYPES58.Property).map((prop) => {
+          if (prop.key.type === AST_NODE_TYPES58.Identifier) {
             return prop.key.name;
           }
           return null;
@@ -4105,57 +4682,57 @@ var reactPropsDestructure = createRule52({
 var react_props_destructure_default = reactPropsDestructure;
 
 // src/rules/require-explicit-return-type.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES53, ESLintUtils as ESLintUtils53 } from "@typescript-eslint/utils";
-var createRule53 = ESLintUtils53.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES59, ESLintUtils as ESLintUtils59 } from "@typescript-eslint/utils";
+var createRule59 = ESLintUtils59.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var isReactComponent = (node) => {
-  if (node.type === AST_NODE_TYPES53.ArrowFunctionExpression) {
+  if (node.type === AST_NODE_TYPES59.ArrowFunctionExpression) {
     const { parent } = node;
-    if (parent?.type === AST_NODE_TYPES53.VariableDeclarator) {
+    if (parent?.type === AST_NODE_TYPES59.VariableDeclarator) {
       const { id } = parent;
-      if (id.type === AST_NODE_TYPES53.Identifier) {
+      if (id.type === AST_NODE_TYPES59.Identifier) {
         return /^[A-Z]/.test(id.name);
       }
     }
   }
-  if (node.type === AST_NODE_TYPES53.FunctionDeclaration && node.id) {
+  if (node.type === AST_NODE_TYPES59.FunctionDeclaration && node.id) {
     return /^[A-Z]/.test(node.id.name);
   }
   return false;
 };
 var isCallbackFunction = (node) => {
-  if (node.type === AST_NODE_TYPES53.FunctionDeclaration) {
+  if (node.type === AST_NODE_TYPES59.FunctionDeclaration) {
     return false;
   }
   const { parent } = node;
   if (!parent) {
     return false;
   }
-  if (parent.type === AST_NODE_TYPES53.CallExpression && parent.arguments.includes(node)) {
+  if (parent.type === AST_NODE_TYPES59.CallExpression && parent.arguments.includes(node)) {
     return true;
   }
-  if (parent.type === AST_NODE_TYPES53.Property) {
+  if (parent.type === AST_NODE_TYPES59.Property) {
     return true;
   }
-  if (parent.type === AST_NODE_TYPES53.ArrayExpression) {
+  if (parent.type === AST_NODE_TYPES59.ArrayExpression) {
     return true;
   }
   return false;
 };
 var getFunctionName = (node) => {
-  if (node.type === AST_NODE_TYPES53.FunctionDeclaration && node.id) {
+  if (node.type === AST_NODE_TYPES59.FunctionDeclaration && node.id) {
     return node.id.name;
   }
-  if (node.type === AST_NODE_TYPES53.FunctionExpression && node.id) {
+  if (node.type === AST_NODE_TYPES59.FunctionExpression && node.id) {
     return node.id.name;
   }
-  if ((node.type === AST_NODE_TYPES53.ArrowFunctionExpression || node.type === AST_NODE_TYPES53.FunctionExpression) && node.parent?.type === AST_NODE_TYPES53.VariableDeclarator && node.parent.id.type === AST_NODE_TYPES53.Identifier) {
+  if ((node.type === AST_NODE_TYPES59.ArrowFunctionExpression || node.type === AST_NODE_TYPES59.FunctionExpression) && node.parent?.type === AST_NODE_TYPES59.VariableDeclarator && node.parent.id.type === AST_NODE_TYPES59.Identifier) {
     return node.parent.id.name;
   }
   return null;
 };
-var requireExplicitReturnType = createRule53({
+var requireExplicitReturnType = createRule59({
   name: "require-explicit-return-type",
   meta: {
     type: "suggestion",
@@ -4204,8 +4781,8 @@ var requireExplicitReturnType = createRule53({
 var require_explicit_return_type_default = requireExplicitReturnType;
 
 // src/rules/sort-exports.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES54, ESLintUtils as ESLintUtils54 } from "@typescript-eslint/utils";
-var createRule54 = ESLintUtils54.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES60, ESLintUtils as ESLintUtils60 } from "@typescript-eslint/utils";
+var createRule60 = ESLintUtils60.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var GROUP_NAMES = ["", "external/alias re-export", "relative re-export", "local export"];
@@ -4219,7 +4796,7 @@ function getExportGroup(node) {
   }
   return 1;
 }
-var sortExports = createRule54({
+var sortExports = createRule60({
   name: "sort-exports",
   meta: {
     type: "suggestion",
@@ -4259,7 +4836,7 @@ var sortExports = createRule54({
       Program(node) {
         const exportGroups = [];
         node.body.forEach((statement) => {
-          if (statement.type !== AST_NODE_TYPES54.ExportNamedDeclaration || statement.declaration !== null) {
+          if (statement.type !== AST_NODE_TYPES60.ExportNamedDeclaration || statement.declaration !== null) {
             if (exportGroups.length > 0) {
               checkOrder(exportGroups);
               exportGroups.length = 0;
@@ -4278,8 +4855,8 @@ var sortExports = createRule54({
 var sort_exports_default = sortExports;
 
 // src/rules/sort-imports.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES55, ESLintUtils as ESLintUtils55 } from "@typescript-eslint/utils";
-var createRule55 = ESLintUtils55.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES61, ESLintUtils as ESLintUtils61 } from "@typescript-eslint/utils";
+var createRule61 = ESLintUtils61.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var NODE_BUILTINS = /* @__PURE__ */ new Set([
@@ -4346,7 +4923,7 @@ function getImportGroup(node) {
 function isTypeOnlyImport(node) {
   return node.importKind === "type" && node.specifiers.length > 0;
 }
-var sortImports = createRule55({
+var sortImports = createRule61({
   name: "sort-imports",
   meta: {
     type: "suggestion",
@@ -4390,7 +4967,7 @@ var sortImports = createRule55({
       Program(node) {
         const importGroups = [];
         node.body.forEach((statement) => {
-          if (statement.type !== AST_NODE_TYPES55.ImportDeclaration) {
+          if (statement.type !== AST_NODE_TYPES61.ImportDeclaration) {
             if (importGroups.length > 0) {
               checkOrder(importGroups);
               importGroups.length = 0;
@@ -4412,13 +4989,13 @@ var sortImports = createRule55({
 var sort_imports_default = sortImports;
 
 // src/rules/sort-type-alphabetically.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES56, ESLintUtils as ESLintUtils56 } from "@typescript-eslint/utils";
-var createRule56 = ESLintUtils56.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES62, ESLintUtils as ESLintUtils62 } from "@typescript-eslint/utils";
+var createRule62 = ESLintUtils62.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 function isAlphabeticallySortedWithinGroups(members) {
   const properties = members.filter(
-    (member) => member.type === AST_NODE_TYPES56.TSPropertySignature && member.key.type === AST_NODE_TYPES56.Identifier
+    (member) => member.type === AST_NODE_TYPES62.TSPropertySignature && member.key.type === AST_NODE_TYPES62.Identifier
   );
   if (properties.length < 2) {
     return true;
@@ -4429,7 +5006,7 @@ function isAlphabeticallySortedWithinGroups(members) {
   const isOptionalSorted = optional.every((name, index) => index === 0 || optional[index - 1].localeCompare(name) <= 0);
   return isRequiredSorted && isOptionalSorted;
 }
-var sortTypeAlphabetically = createRule56({
+var sortTypeAlphabetically = createRule62({
   name: "sort-type-alphabetically",
   meta: {
     type: "suggestion",
@@ -4447,7 +5024,7 @@ var sortTypeAlphabetically = createRule56({
     function fixMembers(fixer, members) {
       const { sourceCode } = context;
       const properties = members.filter(
-        (member) => member.type === AST_NODE_TYPES56.TSPropertySignature && member.key.type === AST_NODE_TYPES56.Identifier
+        (member) => member.type === AST_NODE_TYPES62.TSPropertySignature && member.key.type === AST_NODE_TYPES62.Identifier
       );
       const required = properties.filter((prop) => !prop.optional);
       const optional = properties.filter((prop) => prop.optional);
@@ -4484,7 +5061,7 @@ var sortTypeAlphabetically = createRule56({
         }
       },
       TSTypeAliasDeclaration(node) {
-        if (node.typeAnnotation.type !== AST_NODE_TYPES56.TSTypeLiteral) {
+        if (node.typeAnnotation.type !== AST_NODE_TYPES62.TSTypeLiteral) {
           return;
         }
         const { members } = node.typeAnnotation;
@@ -4504,13 +5081,13 @@ var sortTypeAlphabetically = createRule56({
 var sort_type_alphabetically_default = sortTypeAlphabetically;
 
 // src/rules/sort-type-required-first.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES57, ESLintUtils as ESLintUtils57 } from "@typescript-eslint/utils";
-var createRule57 = ESLintUtils57.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES63, ESLintUtils as ESLintUtils63 } from "@typescript-eslint/utils";
+var createRule63 = ESLintUtils63.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 function isRequiredBeforeOptional(members) {
   const properties = members.filter(
-    (member) => member.type === AST_NODE_TYPES57.TSPropertySignature && member.key.type === AST_NODE_TYPES57.Identifier
+    (member) => member.type === AST_NODE_TYPES63.TSPropertySignature && member.key.type === AST_NODE_TYPES63.Identifier
   );
   if (properties.length < 2) {
     return true;
@@ -4521,7 +5098,7 @@ function isRequiredBeforeOptional(members) {
   }
   return properties.slice(firstOptionalIndex).every((prop) => prop.optional);
 }
-var sortTypeRequiredFirst = createRule57({
+var sortTypeRequiredFirst = createRule63({
   name: "sort-type-required-first",
   meta: {
     type: "suggestion",
@@ -4539,7 +5116,7 @@ var sortTypeRequiredFirst = createRule57({
     function fixMembers(fixer, members) {
       const { sourceCode } = context;
       const properties = members.filter(
-        (member) => member.type === AST_NODE_TYPES57.TSPropertySignature && member.key.type === AST_NODE_TYPES57.Identifier
+        (member) => member.type === AST_NODE_TYPES63.TSPropertySignature && member.key.type === AST_NODE_TYPES63.Identifier
       );
       const required = properties.filter((prop) => !prop.optional);
       const optional = properties.filter((prop) => prop.optional);
@@ -4560,7 +5137,7 @@ var sortTypeRequiredFirst = createRule57({
         }
       },
       TSTypeAliasDeclaration(node) {
-        if (node.typeAnnotation.type !== AST_NODE_TYPES57.TSTypeLiteral) {
+        if (node.typeAnnotation.type !== AST_NODE_TYPES63.TSTypeLiteral) {
           return;
         }
         const { members } = node.typeAnnotation;
@@ -4592,14 +5169,18 @@ var rules = {
   "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-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,
@@ -4612,6 +5193,7 @@ var rules = {
   "no-direct-date": no_direct_date_default,
   "no-emoji": no_emoji_default,
   "no-env-fallback": no_env_fallback_default,
+  "no-ghost-wrapper": no_ghost_wrapper_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,
@@ -4621,6 +5203,7 @@ var rules = {
   "no-misleading-constant-case": no_misleading_constant_case_default,
   "no-nested-interface-declaration": no_nested_interface_declaration_default,
   "no-nested-ternary": no_nested_ternary_default,
+  "no-redundant-fragment": no_redundant_fragment_default,
   "no-relative-imports": no_relative_imports_default,
   "no-single-char-variables": no_single_char_variables_default,
   "prefer-async-await": prefer_async_await_default,
@@ -4734,16 +5317,22 @@ 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",
   "nextfriday/jsx-simple-props": "warn",
   "nextfriday/jsx-sort-props": "warn",
   "nextfriday/jsx-spread-props-last": "warn",
+  "nextfriday/no-ghost-wrapper": "warn",
+  "nextfriday/no-redundant-fragment": "warn",
   "nextfriday/prefer-interface-for-component-props": "warn",
   "nextfriday/prefer-interface-over-inline-types": "warn",
   "nextfriday/prefer-jsx-template-literals": "warn",
@@ -4753,16 +5342,22 @@ 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",
   "nextfriday/jsx-simple-props": "error",
   "nextfriday/jsx-sort-props": "error",
   "nextfriday/jsx-spread-props-last": "error",
+  "nextfriday/no-ghost-wrapper": "error",
+  "nextfriday/no-redundant-fragment": "error",
   "nextfriday/prefer-interface-for-component-props": "error",
   "nextfriday/prefer-interface-over-inline-types": "error",
   "nextfriday/prefer-jsx-template-literals": "error",