eslint-plugin-nextfriday 1.5.3 → 1.6.0

package/lib/index.js

@@ -1,7 +1,7 @@
 // package.json
 var package_default = {
   name: "eslint-plugin-nextfriday",
-  version: "1.5.3",
+  version: "1.6.0",
   description: "A comprehensive ESLint plugin providing custom rules and configurations for Next Friday development workflows.",
   keywords: [
     "eslint",
@@ -118,7 +118,7 @@ var package_default = {
 // src/rules/enforce-readonly-component-props.ts
 import { AST_NODE_TYPES, ESLintUtils } from "@typescript-eslint/utils";
 var createRule = ESLintUtils.RuleCreator(
-  (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replace(/-/g, "_").toUpperCase()}.md`
+  (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var enforceReadonlyComponentProps = createRule({
   name: "enforce-readonly-component-props",
@@ -207,11 +207,132 @@ var enforceReadonlyComponentProps = createRule({
 });
 var enforce_readonly_component_props_default = enforceReadonlyComponentProps;
 
+// src/rules/enforce-sorted-destructuring.ts
+import { AST_NODE_TYPES as AST_NODE_TYPES2, ESLintUtils as ESLintUtils2 } from "@typescript-eslint/utils";
+var createRule2 = ESLintUtils2.RuleCreator(
+  (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
+);
+var enforceSortedDestructuring = createRule2({
+  name: "enforce-sorted-destructuring",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Enforce alphabetical sorting of destructured properties with defaults first"
+    },
+    schema: [],
+    messages: {
+      unsortedDestructuring: "Destructured properties should be sorted alphabetically. Properties with defaults should come first, sorted by type (string, number, boolean, object) then alphabetically."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    function getPropertyName(property) {
+      if (property.type === AST_NODE_TYPES2.RestElement) {
+        return null;
+      }
+      if (property.key.type === AST_NODE_TYPES2.Identifier) {
+        return property.key.name;
+      }
+      return null;
+    }
+    function hasDefaultValue(property) {
+      return property.value.type === AST_NODE_TYPES2.AssignmentPattern && Boolean(property.value.right);
+    }
+    function getDefaultValueType(property) {
+      if (!hasDefaultValue(property)) {
+        return "none";
+      }
+      const assignmentPattern = property.value;
+      const { right } = assignmentPattern;
+      if (!right) {
+        return "none";
+      }
+      switch (right.type) {
+        case AST_NODE_TYPES2.Literal:
+          if (typeof right.value === "string") {
+            return "string";
+          }
+          if (typeof right.value === "number") {
+            return "number";
+          }
+          if (typeof right.value === "boolean") {
+            return "boolean";
+          }
+          return "other";
+        case AST_NODE_TYPES2.TemplateLiteral:
+          return "string";
+        case AST_NODE_TYPES2.ObjectExpression:
+        case AST_NODE_TYPES2.ArrayExpression:
+          return "object";
+        default:
+          return "other";
+      }
+    }
+    function getTypeSortOrder(type) {
+      const order = {
+        string: 0,
+        number: 1,
+        boolean: 2,
+        object: 3,
+        other: 4,
+        none: 5
+      };
+      return order[type] ?? 5;
+    }
+    function checkVariableDeclarator(node) {
+      if (node.id.type !== AST_NODE_TYPES2.ObjectPattern) {
+        return;
+      }
+      const { properties } = node.id;
+      if (properties.length < 2) {
+        return;
+      }
+      const propertyInfo = properties.map((prop) => {
+        if (prop.type === AST_NODE_TYPES2.RestElement) {
+          return null;
+        }
+        return {
+          property: prop,
+          name: getPropertyName(prop),
+          hasDefault: hasDefaultValue(prop),
+          defaultType: getDefaultValueType(prop)
+        };
+      }).filter((info) => info !== null && info.name !== null);
+      const sorted = [...propertyInfo].sort((a, b) => {
+        if (a.hasDefault && !b.hasDefault) {
+          return -1;
+        }
+        if (!a.hasDefault && b.hasDefault) {
+          return 1;
+        }
+        if (a.hasDefault && b.hasDefault) {
+          const typeComparison = getTypeSortOrder(a.defaultType) - getTypeSortOrder(b.defaultType);
+          if (typeComparison !== 0) {
+            return typeComparison;
+          }
+        }
+        return a.name.localeCompare(b.name);
+      });
+      const isSorted = propertyInfo.every((info, index) => info.name === sorted[index].name);
+      if (!isSorted) {
+        context.report({
+          node: node.id,
+          messageId: "unsortedDestructuring"
+        });
+      }
+    }
+    return {
+      VariableDeclarator: checkVariableDeclarator
+    };
+  }
+});
+var enforce_sorted_destructuring_default = enforceSortedDestructuring;
+
 // src/rules/file-kebab-case.ts
 import path from "path";
-import { ESLintUtils as ESLintUtils2 } from "@typescript-eslint/utils";
-var createRule2 = ESLintUtils2.RuleCreator(
-  (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replace(/-/g, "_").toUpperCase()}.md`
+import { ESLintUtils as ESLintUtils3 } from "@typescript-eslint/utils";
+var createRule3 = ESLintUtils3.RuleCreator(
+  (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var isKebabCase = (str) => {
   if (/\.(config|rc|setup|spec|test)$/.test(str) || /^[a-z0-9]+(?:-[a-z0-9]+)*\.[a-z0-9]+(?:-[a-z0-9]+)*$/.test(str)) {
@@ -219,7 +340,7 @@ var isKebabCase = (str) => {
   }
   return /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(str);
 };
-var fileKebabCase = createRule2({
+var fileKebabCase = createRule3({
   name: "file-kebab-case",
   meta: {
     type: "problem",
@@ -240,8 +361,8 @@ var fileKebabCase = createRule2({
         if (ext !== ".ts" && ext !== ".js") {
           return;
         }
-        const basename = path.basename(filename, ext);
-        if (!isKebabCase(basename)) {
+        const basename2 = path.basename(filename, ext);
+        if (!isKebabCase(basename2)) {
           context.report({
             loc: { line: 1, column: 0 },
             messageId: "fileKebabCase"
@@ -255,12 +376,12 @@ var file_kebab_case_default = fileKebabCase;
 
 // src/rules/jsx-pascal-case.ts
 import path2 from "path";
-import { ESLintUtils as ESLintUtils3 } from "@typescript-eslint/utils";
-var createRule3 = ESLintUtils3.RuleCreator(
-  (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replace(/-/g, "_").toUpperCase()}.md`
+import { ESLintUtils as ESLintUtils4 } from "@typescript-eslint/utils";
+var createRule4 = ESLintUtils4.RuleCreator(
+  (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var isPascalCase = (str) => /^[A-Z][a-zA-Z0-9]*$/.test(str) && !/^[A-Z]+$/.test(str);
-var jsxPascalCase = createRule3({
+var jsxPascalCase = createRule4({
   name: "jsx-pascal-case",
   meta: {
     type: "problem",
@@ -281,8 +402,8 @@ var jsxPascalCase = createRule3({
         if (ext !== ".jsx" && ext !== ".tsx") {
           return;
         }
-        const basename = path2.basename(filename, ext);
-        if (!isPascalCase(basename)) {
+        const basename2 = path2.basename(filename, ext);
+        if (!isPascalCase(basename2)) {
           context.report({
             loc: { line: 1, column: 0 },
             messageId: "jsxPascalCase"
@@ -294,13 +415,84 @@ var jsxPascalCase = createRule3({
 });
 var jsx_pascal_case_default = jsxPascalCase;
 
+// src/rules/jsx-no-variable-in-callback.ts
+import { AST_NODE_TYPES as AST_NODE_TYPES3, ESLintUtils as ESLintUtils5 } from "@typescript-eslint/utils";
+var createRule5 = ESLintUtils5.RuleCreator(
+  (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
+);
+var jsxNoVariableInCallback = createRule5({
+  name: "jsx-no-variable-in-callback",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Disallow variable declarations inside callback functions within JSX"
+    },
+    schema: [],
+    messages: {
+      noVariableInCallback: "Variable declarations should not be inside callback functions within JSX. Extract the logic to a separate function outside the JSX."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    function isInsideJSX(node) {
+      let current = node.parent;
+      while (current) {
+        if (current.type === AST_NODE_TYPES3.JSXElement || current.type === AST_NODE_TYPES3.JSXFragment) {
+          return true;
+        }
+        current = current.parent;
+      }
+      return false;
+    }
+    function isCallbackInJSX(node) {
+      if (!node.parent) {
+        return false;
+      }
+      if (!isInsideJSX(node)) {
+        return false;
+      }
+      if (node.parent.type === AST_NODE_TYPES3.CallExpression || node.parent.type === AST_NODE_TYPES3.JSXExpressionContainer) {
+        return true;
+      }
+      if (node.parent.type === AST_NODE_TYPES3.ArrayExpression && node.parent.parent) {
+        if (node.parent.parent.type === AST_NODE_TYPES3.CallExpression || node.parent.parent.type === AST_NODE_TYPES3.JSXExpressionContainer) {
+          return true;
+        }
+      }
+      return false;
+    }
+    function checkFunctionBody(node) {
+      if (!isCallbackInJSX(node)) {
+        return;
+      }
+      const { body } = node;
+      if (body.type !== AST_NODE_TYPES3.BlockStatement) {
+        return;
+      }
+      body.body.forEach((statement) => {
+        if (statement.type === AST_NODE_TYPES3.VariableDeclaration) {
+          context.report({
+            node: statement,
+            messageId: "noVariableInCallback"
+          });
+        }
+      });
+    }
+    return {
+      ArrowFunctionExpression: checkFunctionBody,
+      FunctionExpression: checkFunctionBody
+    };
+  }
+});
+var jsx_no_variable_in_callback_default = jsxNoVariableInCallback;
+
 // src/rules/md-filename-case-restriction.ts
 import path3 from "path";
-import { ESLintUtils as ESLintUtils4 } from "@typescript-eslint/utils";
-var createRule4 = ESLintUtils4.RuleCreator(
-  (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replace(/-/g, "_").toUpperCase()}.md`
+import { ESLintUtils as ESLintUtils6 } from "@typescript-eslint/utils";
+var createRule6 = ESLintUtils6.RuleCreator(
+  (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var mdFilenameCaseRestriction = createRule4({
+var mdFilenameCaseRestriction = createRule6({
   name: "md-filename-case-restriction",
   meta: {
     type: "problem",
@@ -320,18 +512,18 @@ var mdFilenameCaseRestriction = createRule4({
         if (!filename.endsWith(".md")) {
           return;
         }
-        const basename = path3.basename(filename, ".md");
+        const basename2 = path3.basename(filename, ".md");
         function isSnakeCase(text) {
           return /^[A-Z][A-Z0-9_]*$/.test(text);
         }
         function isValidCase(text) {
           return isSnakeCase(text);
         }
-        if (!isValidCase(basename)) {
+        if (!isValidCase(basename2)) {
           context.report({
             node: context.sourceCode.ast,
             messageId: "invalidFilenameCase",
-            data: { filename: basename }
+            data: { filename: basename2 }
           });
         }
       }
@@ -341,11 +533,11 @@ var mdFilenameCaseRestriction = createRule4({
 var md_filename_case_restriction_default = mdFilenameCaseRestriction;
 
 // src/rules/no-complex-inline-return.ts
-import { ESLintUtils as ESLintUtils5, AST_NODE_TYPES as AST_NODE_TYPES2 } from "@typescript-eslint/utils";
-var createRule5 = ESLintUtils5.RuleCreator(
-  (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replace(/-/g, "_").toUpperCase()}.md`
+import { ESLintUtils as ESLintUtils7, AST_NODE_TYPES as AST_NODE_TYPES4 } from "@typescript-eslint/utils";
+var createRule7 = ESLintUtils7.RuleCreator(
+  (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var noComplexInlineReturn = createRule5({
+var noComplexInlineReturn = createRule7({
   name: "no-complex-inline-return",
   meta: {
     type: "suggestion",
@@ -361,13 +553,13 @@ var noComplexInlineReturn = createRule5({
   create(context) {
     const isComplexExpression = (node) => {
       if (!node) return false;
-      if (node.type === AST_NODE_TYPES2.ConditionalExpression) {
+      if (node.type === AST_NODE_TYPES4.ConditionalExpression) {
         return true;
       }
-      if (node.type === AST_NODE_TYPES2.LogicalExpression) {
+      if (node.type === AST_NODE_TYPES4.LogicalExpression) {
         return true;
       }
-      if (node.type === AST_NODE_TYPES2.NewExpression) {
+      if (node.type === AST_NODE_TYPES4.NewExpression) {
         return true;
       }
       return false;
@@ -388,11 +580,11 @@ var no_complex_inline_return_default = noComplexInlineReturn;
 
 // src/rules/no-emoji.ts
 import emojiRegex from "emoji-regex";
-import { ESLintUtils as ESLintUtils6 } from "@typescript-eslint/utils";
-var createRule6 = ESLintUtils6.RuleCreator(
-  (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replace(/-/g, "_").toUpperCase()}.md`
+import { ESLintUtils as ESLintUtils8 } from "@typescript-eslint/utils";
+var createRule8 = ESLintUtils8.RuleCreator(
+  (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var noEmoji = createRule6({
+var noEmoji = createRule8({
   name: "no-emoji",
   meta: {
     type: "problem",
@@ -426,11 +618,11 @@ var noEmoji = createRule6({
 var no_emoji_default = noEmoji;
 
 // src/rules/no-env-fallback.ts
-import { ESLintUtils as ESLintUtils7, AST_NODE_TYPES as AST_NODE_TYPES3 } from "@typescript-eslint/utils";
-var createRule7 = ESLintUtils7.RuleCreator(
-  (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replace(/-/g, "_").toUpperCase()}.md`
+import { ESLintUtils as ESLintUtils9, AST_NODE_TYPES as AST_NODE_TYPES5 } 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 noEnvFallback = createRule7({
+var noEnvFallback = createRule9({
   name: "no-env-fallback",
   meta: {
     type: "problem",
@@ -445,16 +637,16 @@ var noEnvFallback = createRule7({
   defaultOptions: [],
   create(context) {
     const isProcessEnvAccess = (node) => {
-      if (node.type !== AST_NODE_TYPES3.MemberExpression) {
+      if (node.type !== AST_NODE_TYPES5.MemberExpression) {
         return false;
       }
       const { object } = node;
-      if (object.type !== AST_NODE_TYPES3.MemberExpression) {
+      if (object.type !== AST_NODE_TYPES5.MemberExpression) {
         return false;
       }
       const processNode = object.object;
       const envNode = object.property;
-      return processNode.type === AST_NODE_TYPES3.Identifier && processNode.name === "process" && envNode.type === AST_NODE_TYPES3.Identifier && envNode.name === "env";
+      return processNode.type === AST_NODE_TYPES5.Identifier && processNode.name === "process" && envNode.type === AST_NODE_TYPES5.Identifier && envNode.name === "env";
     };
     return {
       LogicalExpression(node) {
@@ -479,11 +671,11 @@ var noEnvFallback = createRule7({
 var no_env_fallback_default = noEnvFallback;
 
 // src/rules/no-explicit-return-type.ts
-import { ESLintUtils as ESLintUtils8 } from "@typescript-eslint/utils";
-var createRule8 = ESLintUtils8.RuleCreator(
-  (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replace(/-/g, "_").toUpperCase()}.md`
+import { ESLintUtils as ESLintUtils10 } from "@typescript-eslint/utils";
+var createRule10 = ESLintUtils10.RuleCreator(
+  (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var noExplicitReturnType = createRule8({
+var noExplicitReturnType = createRule10({
   name: "no-explicit-return-type",
   meta: {
     type: "suggestion",
@@ -522,12 +714,97 @@ var noExplicitReturnType = createRule8({
 });
 var no_explicit_return_type_default = noExplicitReturnType;
 
+// src/rules/jsx-no-non-component-function.ts
+import { AST_NODE_TYPES as AST_NODE_TYPES7, ESLintUtils as ESLintUtils11 } from "@typescript-eslint/utils";
+
+// src/utils.ts
+import { basename, extname } from "path";
+import { AST_NODE_TYPES as AST_NODE_TYPES6 } from "@typescript-eslint/utils";
+var getFileExtension = (filename) => extname(filename).slice(1);
+
+// src/rules/jsx-no-non-component-function.ts
+var createRule11 = ESLintUtils11.RuleCreator(
+  (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
+);
+var jsxNoNonComponentFunction = createRule11({
+  name: "jsx-no-non-component-function",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow non-component functions defined at top level in .tsx and .jsx files"
+    },
+    schema: [],
+    messages: {
+      noTopLevelFunction: "Non-component functions should not be defined at top level in .tsx/.jsx files. Either move it inside the component or extract it to a separate file."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    const { filename } = context;
+    const extension = getFileExtension(filename);
+    if (extension !== "tsx" && extension !== "jsx") {
+      return {};
+    }
+    function isReactComponent(node) {
+      const functionName = node.type === AST_NODE_TYPES7.FunctionDeclaration && node.id ? node.id.name : null;
+      if (functionName && /^[A-Z]/.test(functionName)) {
+        return true;
+      }
+      if (node.returnType?.typeAnnotation) {
+        const returnTypeNode = node.returnType.typeAnnotation;
+        if (returnTypeNode.type === AST_NODE_TYPES7.TSTypeReference && returnTypeNode.typeName.type === AST_NODE_TYPES7.Identifier) {
+          const typeName = returnTypeNode.typeName.name;
+          if (typeName === "JSX" || typeName === "ReactElement" || typeName === "ReactNode") {
+            return true;
+          }
+        }
+      }
+      return false;
+    }
+    function checkTopLevelFunction(node, declaratorNode) {
+      if (isReactComponent(node)) {
+        return;
+      }
+      const { parent } = node;
+      if (!parent) {
+        return;
+      }
+      if (parent.type === AST_NODE_TYPES7.ExportDefaultDeclaration || parent.type === AST_NODE_TYPES7.ExportNamedDeclaration) {
+        return;
+      }
+      if (declaratorNode?.parent?.parent?.type === AST_NODE_TYPES7.ExportNamedDeclaration) {
+        return;
+      }
+      if (declaratorNode?.id.type === AST_NODE_TYPES7.Identifier) {
+        const varName = declaratorNode.id.name;
+        if (/^[A-Z]/.test(varName)) {
+          return;
+        }
+      }
+      context.report({
+        node: declaratorNode || node,
+        messageId: "noTopLevelFunction"
+      });
+    }
+    return {
+      "Program > VariableDeclaration > VariableDeclarator > ArrowFunctionExpression": function checkArrowFunction(node) {
+        const declarator = node.parent;
+        checkTopLevelFunction(node, declarator);
+      },
+      "Program > FunctionDeclaration": function checkFunctionDeclaration(node) {
+        checkTopLevelFunction(node);
+      }
+    };
+  }
+});
+var jsx_no_non_component_function_default = jsxNoNonComponentFunction;
+
 // src/rules/no-logic-in-params.ts
-import { ESLintUtils as ESLintUtils9, AST_NODE_TYPES as AST_NODE_TYPES4 } from "@typescript-eslint/utils";
-var createRule9 = ESLintUtils9.RuleCreator(
-  (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replace(/-/g, "_").toUpperCase()}.md`
+import { ESLintUtils as ESLintUtils12, AST_NODE_TYPES as AST_NODE_TYPES8 } from "@typescript-eslint/utils";
+var createRule12 = ESLintUtils12.RuleCreator(
+  (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var noLogicInParams = createRule9({
+var noLogicInParams = createRule12({
   name: "no-logic-in-params",
   meta: {
     type: "suggestion",
@@ -542,20 +819,20 @@ var noLogicInParams = createRule9({
   defaultOptions: [],
   create(context) {
     const isComplexExpression = (node) => {
-      if (node.type === AST_NODE_TYPES4.SpreadElement) {
+      if (node.type === AST_NODE_TYPES8.SpreadElement) {
         return false;
       }
-      if (node.type === AST_NODE_TYPES4.ConditionalExpression) {
+      if (node.type === AST_NODE_TYPES8.ConditionalExpression) {
         return true;
       }
-      if (node.type === AST_NODE_TYPES4.LogicalExpression) {
+      if (node.type === AST_NODE_TYPES8.LogicalExpression) {
         return true;
       }
-      if (node.type === AST_NODE_TYPES4.BinaryExpression) {
+      if (node.type === AST_NODE_TYPES8.BinaryExpression) {
         const logicalOperators = ["==", "===", "!=", "!==", "<", ">", "<=", ">=", "in", "instanceof"];
         return logicalOperators.includes(node.operator);
       }
-      if (node.type === AST_NODE_TYPES4.UnaryExpression) {
+      if (node.type === AST_NODE_TYPES8.UnaryExpression) {
         return node.operator === "!";
       }
       return false;
@@ -587,11 +864,11 @@ var noLogicInParams = createRule9({
 var no_logic_in_params_default = noLogicInParams;
 
 // src/rules/prefer-destructuring-params.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES5, 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.replace(/-/g, "_").toUpperCase()}.md`
+import { AST_NODE_TYPES as AST_NODE_TYPES9, 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 preferDestructuringParams = createRule10({
+var preferDestructuringParams = createRule13({
   name: "prefer-destructuring-params",
   meta: {
     type: "suggestion",
@@ -607,18 +884,18 @@ var preferDestructuringParams = createRule10({
   create(context) {
     const isCallbackFunction = (node) => {
       const { parent } = node;
-      return parent?.type === AST_NODE_TYPES5.CallExpression;
+      return parent?.type === AST_NODE_TYPES9.CallExpression;
     };
     const isDeveloperFunction = (node) => {
-      if (node.type === AST_NODE_TYPES5.FunctionDeclaration) {
+      if (node.type === AST_NODE_TYPES9.FunctionDeclaration) {
         return true;
       }
-      if (node.type === AST_NODE_TYPES5.FunctionExpression || node.type === AST_NODE_TYPES5.ArrowFunctionExpression) {
+      if (node.type === AST_NODE_TYPES9.FunctionExpression || node.type === AST_NODE_TYPES9.ArrowFunctionExpression) {
         if (isCallbackFunction(node)) {
           return false;
         }
         const { parent } = node;
-        return parent?.type === AST_NODE_TYPES5.VariableDeclarator || parent?.type === AST_NODE_TYPES5.AssignmentExpression || parent?.type === AST_NODE_TYPES5.Property || parent?.type === AST_NODE_TYPES5.MethodDefinition;
+        return parent?.type === AST_NODE_TYPES9.VariableDeclarator || parent?.type === AST_NODE_TYPES9.AssignmentExpression || parent?.type === AST_NODE_TYPES9.Property || parent?.type === AST_NODE_TYPES9.MethodDefinition;
       }
       return false;
     };
@@ -630,7 +907,7 @@ var preferDestructuringParams = createRule10({
       if (!isDeveloperFunction(node)) {
         return;
       }
-      if (node.type === AST_NODE_TYPES5.FunctionDeclaration && node.id) {
+      if (node.type === AST_NODE_TYPES9.FunctionDeclaration && node.id) {
         const functionName = node.id.name;
         if (functionName.startsWith("_") || functionName.includes("$") || /^[A-Z][a-zA-Z]*$/.test(functionName)) {
           return;
@@ -640,7 +917,7 @@ var preferDestructuringParams = createRule10({
         return;
       }
       const hasNonDestructuredParams = node.params.some(
-        (param) => param.type !== AST_NODE_TYPES5.ObjectPattern && param.type !== AST_NODE_TYPES5.RestElement
+        (param) => param.type !== AST_NODE_TYPES9.ObjectPattern && param.type !== AST_NODE_TYPES9.RestElement
       );
       if (hasNonDestructuredParams) {
         context.report({
@@ -659,11 +936,11 @@ var preferDestructuringParams = createRule10({
 var prefer_destructuring_params_default = preferDestructuringParams;
 
 // src/rules/prefer-import-type.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES6, 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.replace(/-/g, "_").toUpperCase()}.md`
+import { AST_NODE_TYPES as AST_NODE_TYPES10, ESLintUtils as ESLintUtils14 } from "@typescript-eslint/utils";
+var createRule14 = ESLintUtils14.RuleCreator(
+  (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var preferImportType = createRule11({
+var preferImportType = createRule14({
   name: "prefer-import-type",
   meta: {
     type: "suggestion",
@@ -678,6 +955,81 @@ var preferImportType = createRule11({
   },
   defaultOptions: [],
   create(context) {
+    function isInTypeContext(node) {
+      let current = node;
+      while (current) {
+        switch (current.type) {
+          case AST_NODE_TYPES10.TSTypeReference:
+          case AST_NODE_TYPES10.TSTypeAnnotation:
+          case AST_NODE_TYPES10.TSTypeParameterInstantiation:
+          case AST_NODE_TYPES10.TSInterfaceHeritage:
+          case AST_NODE_TYPES10.TSClassImplements:
+          case AST_NODE_TYPES10.TSTypeQuery:
+          case AST_NODE_TYPES10.TSTypeAssertion:
+          case AST_NODE_TYPES10.TSAsExpression:
+          case AST_NODE_TYPES10.TSSatisfiesExpression:
+          case AST_NODE_TYPES10.TSTypeAliasDeclaration:
+          case AST_NODE_TYPES10.TSInterfaceDeclaration:
+          case AST_NODE_TYPES10.TSTypeParameter:
+          case AST_NODE_TYPES10.TSQualifiedName:
+            return true;
+          case AST_NODE_TYPES10.MemberExpression:
+          case AST_NODE_TYPES10.Identifier:
+            current = current.parent;
+            break;
+          default:
+            return false;
+        }
+      }
+      return false;
+    }
+    function isUsedAsValue(localName, scope) {
+      const variable = scope.set.get(localName);
+      if (!variable) {
+        return false;
+      }
+      if (variable.references.length === 0) {
+        return false;
+      }
+      return variable.references.some((ref) => {
+        if (ref.isWrite()) {
+          return false;
+        }
+        const { identifier } = ref;
+        const { parent } = identifier;
+        if (!parent) {
+          return false;
+        }
+        if (isInTypeContext(parent)) {
+          return false;
+        }
+        switch (parent.type) {
+          case AST_NODE_TYPES10.CallExpression:
+          case AST_NODE_TYPES10.NewExpression:
+          case AST_NODE_TYPES10.JSXOpeningElement:
+          case AST_NODE_TYPES10.JSXClosingElement:
+          case AST_NODE_TYPES10.MemberExpression:
+          case AST_NODE_TYPES10.VariableDeclarator:
+          case AST_NODE_TYPES10.TaggedTemplateExpression:
+          case AST_NODE_TYPES10.SpreadElement:
+          case AST_NODE_TYPES10.ExportSpecifier:
+          case AST_NODE_TYPES10.ArrayExpression:
+          case AST_NODE_TYPES10.ObjectExpression:
+          case AST_NODE_TYPES10.BinaryExpression:
+          case AST_NODE_TYPES10.LogicalExpression:
+          case AST_NODE_TYPES10.UnaryExpression:
+          case AST_NODE_TYPES10.ReturnStatement:
+          case AST_NODE_TYPES10.ArrowFunctionExpression:
+          case AST_NODE_TYPES10.ConditionalExpression:
+          case AST_NODE_TYPES10.AwaitExpression:
+          case AST_NODE_TYPES10.YieldExpression:
+          case AST_NODE_TYPES10.Property:
+            return true;
+          default:
+            return false;
+        }
+      });
+    }
     function checkImportDeclaration(node) {
       if (node.importKind === "type") {
         return;
@@ -693,19 +1045,17 @@ var preferImportType = createRule11({
       if (isRuntimeImport) {
         return;
       }
+      const scope = context.sourceCode.getScope(node);
       const isTypeOnlyImport = node.specifiers.every((specifier) => {
-        if (specifier.type === AST_NODE_TYPES6.ImportDefaultSpecifier) {
+        if (specifier.type === AST_NODE_TYPES10.ImportDefaultSpecifier) {
           return false;
         }
-        if (specifier.type === AST_NODE_TYPES6.ImportNamespaceSpecifier) {
+        if (specifier.type === AST_NODE_TYPES10.ImportNamespaceSpecifier) {
           return false;
         }
-        if (specifier.type === AST_NODE_TYPES6.ImportSpecifier) {
-          const importedName = specifier.imported.type === AST_NODE_TYPES6.Identifier ? specifier.imported.name : specifier.imported.value;
-          const isKnownTypeOnly = node.source.value === "@typescript-eslint/utils" && ["TSESTree", "RuleContext"].includes(importedName) || node.source.value === "react" && ["Component", "ComponentProps", "ReactNode", "FC", "JSX", "ReactElement", "PropsWithChildren"].includes(
-            importedName
-          ) || importedName.endsWith("Type") || importedName.endsWith("Interface") || importedName.endsWith("Props");
-          return isKnownTypeOnly;
+        if (specifier.type === AST_NODE_TYPES10.ImportSpecifier) {
+          const localName = specifier.local.name;
+          return !isUsedAsValue(localName, scope);
         }
         return false;
       });
@@ -729,11 +1079,11 @@ var preferImportType = createRule11({
 var prefer_import_type_default = preferImportType;
 
 // src/rules/prefer-interface-over-inline-types.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES7, 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.replace(/-/g, "_").toUpperCase()}.md`
+import { AST_NODE_TYPES as AST_NODE_TYPES11, ESLintUtils as ESLintUtils15 } from "@typescript-eslint/utils";
+var createRule15 = ESLintUtils15.RuleCreator(
+  (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var preferInterfaceOverInlineTypes = createRule12({
+var preferInterfaceOverInlineTypes = createRule15({
   name: "prefer-interface-over-inline-types",
   meta: {
     type: "suggestion",
@@ -749,54 +1099,54 @@ var preferInterfaceOverInlineTypes = createRule12({
   defaultOptions: [],
   create(context) {
     function hasJSXInConditional(node) {
-      return node.consequent.type === AST_NODE_TYPES7.JSXElement || node.consequent.type === AST_NODE_TYPES7.JSXFragment || node.alternate.type === AST_NODE_TYPES7.JSXElement || node.alternate.type === AST_NODE_TYPES7.JSXFragment;
+      return node.consequent.type === AST_NODE_TYPES11.JSXElement || node.consequent.type === AST_NODE_TYPES11.JSXFragment || node.alternate.type === AST_NODE_TYPES11.JSXElement || node.alternate.type === AST_NODE_TYPES11.JSXFragment;
     }
     function hasJSXInLogical(node) {
-      return node.right.type === AST_NODE_TYPES7.JSXElement || node.right.type === AST_NODE_TYPES7.JSXFragment;
+      return node.right.type === AST_NODE_TYPES11.JSXElement || node.right.type === AST_NODE_TYPES11.JSXFragment;
     }
     function hasJSXReturn(block) {
       return block.body.some((stmt) => {
-        if (stmt.type === AST_NODE_TYPES7.ReturnStatement && stmt.argument) {
-          return stmt.argument.type === AST_NODE_TYPES7.JSXElement || stmt.argument.type === AST_NODE_TYPES7.JSXFragment || stmt.argument.type === AST_NODE_TYPES7.ConditionalExpression && hasJSXInConditional(stmt.argument) || stmt.argument.type === AST_NODE_TYPES7.LogicalExpression && hasJSXInLogical(stmt.argument);
+        if (stmt.type === AST_NODE_TYPES11.ReturnStatement && stmt.argument) {
+          return stmt.argument.type === AST_NODE_TYPES11.JSXElement || stmt.argument.type === AST_NODE_TYPES11.JSXFragment || stmt.argument.type === AST_NODE_TYPES11.ConditionalExpression && hasJSXInConditional(stmt.argument) || stmt.argument.type === AST_NODE_TYPES11.LogicalExpression && hasJSXInLogical(stmt.argument);
         }
         return false;
       });
     }
     function isReactComponent(node) {
-      if (node.type === AST_NODE_TYPES7.ArrowFunctionExpression) {
-        if (node.body.type === AST_NODE_TYPES7.JSXElement || node.body.type === AST_NODE_TYPES7.JSXFragment) {
+      if (node.type === AST_NODE_TYPES11.ArrowFunctionExpression) {
+        if (node.body.type === AST_NODE_TYPES11.JSXElement || node.body.type === AST_NODE_TYPES11.JSXFragment) {
           return true;
         }
-        if (node.body.type === AST_NODE_TYPES7.BlockStatement) {
+        if (node.body.type === AST_NODE_TYPES11.BlockStatement) {
           return hasJSXReturn(node.body);
         }
-      } else if (node.type === AST_NODE_TYPES7.FunctionExpression || node.type === AST_NODE_TYPES7.FunctionDeclaration) {
-        if (node.body && node.body.type === AST_NODE_TYPES7.BlockStatement) {
+      } else if (node.type === AST_NODE_TYPES11.FunctionExpression || node.type === AST_NODE_TYPES11.FunctionDeclaration) {
+        if (node.body && node.body.type === AST_NODE_TYPES11.BlockStatement) {
           return hasJSXReturn(node.body);
         }
       }
       return false;
     }
     function isInlineTypeAnnotation(node) {
-      if (node.type === AST_NODE_TYPES7.TSTypeLiteral) {
+      if (node.type === AST_NODE_TYPES11.TSTypeLiteral) {
         return true;
       }
-      if (node.type === AST_NODE_TYPES7.TSTypeReference && node.typeArguments) {
-        return node.typeArguments.params.some((param) => param.type === AST_NODE_TYPES7.TSTypeLiteral);
+      if (node.type === AST_NODE_TYPES11.TSTypeReference && node.typeArguments) {
+        return node.typeArguments.params.some((param) => param.type === AST_NODE_TYPES11.TSTypeLiteral);
       }
-      if (node.type === AST_NODE_TYPES7.TSUnionType) {
+      if (node.type === AST_NODE_TYPES11.TSUnionType) {
         return node.types.some((type) => isInlineTypeAnnotation(type));
       }
       return false;
     }
     function hasInlineObjectType(node) {
-      if (node.type === AST_NODE_TYPES7.TSTypeLiteral) {
+      if (node.type === AST_NODE_TYPES11.TSTypeLiteral) {
         return true;
       }
-      if (node.type === AST_NODE_TYPES7.TSTypeReference && node.typeArguments) {
-        return node.typeArguments.params.some((param) => param.type === AST_NODE_TYPES7.TSTypeLiteral);
+      if (node.type === AST_NODE_TYPES11.TSTypeReference && node.typeArguments) {
+        return node.typeArguments.params.some((param) => param.type === AST_NODE_TYPES11.TSTypeLiteral);
       }
-      if (node.type === AST_NODE_TYPES7.TSUnionType) {
+      if (node.type === AST_NODE_TYPES11.TSUnionType) {
         return node.types.some((type) => hasInlineObjectType(type));
       }
       return false;
@@ -809,7 +1159,7 @@ var preferInterfaceOverInlineTypes = createRule12({
         return;
       }
       const param = node.params[0];
-      if (param.type === AST_NODE_TYPES7.Identifier && param.typeAnnotation) {
+      if (param.type === AST_NODE_TYPES11.Identifier && param.typeAnnotation) {
         const { typeAnnotation } = param.typeAnnotation;
         if (isInlineTypeAnnotation(typeAnnotation) && hasInlineObjectType(typeAnnotation)) {
           context.report({
@@ -828,12 +1178,100 @@ var preferInterfaceOverInlineTypes = createRule12({
 });
 var prefer_interface_over_inline_types_default = preferInterfaceOverInlineTypes;
 
+// src/rules/prefer-jsx-template-literals.ts
+import { AST_NODE_TYPES as AST_NODE_TYPES12, ESLintUtils as ESLintUtils16 } from "@typescript-eslint/utils";
+var createRule16 = ESLintUtils16.RuleCreator(
+  (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
+);
+var preferJSXTemplateLiterals = createRule16({
+  name: "prefer-jsx-template-literals",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Enforce using template literals instead of mixing text and JSX expressions"
+    },
+    fixable: "code",
+    schema: [],
+    messages: {
+      preferTemplate: "Use template literal instead of mixing text with JSX expressions"
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    function handleTextBeforeExpression(textNode, exprNode) {
+      const textValue = textNode.value;
+      const trimmedText = textValue.trim();
+      if (!trimmedText) {
+        return;
+      }
+      const hasTextContent = trimmedText.length > 0 && textValue !== trimmedText;
+      const hasNoTrailingSpace = trimmedText.length > 0 && /\S$/.test(textValue);
+      if (!hasTextContent && !hasNoTrailingSpace) {
+        return;
+      }
+      context.report({
+        node: textNode,
+        messageId: "preferTemplate",
+        fix(fixer) {
+          const textPart = textValue.trimEnd();
+          const exprText = context.sourceCode.getText(exprNode.expression);
+          const templateLiteral = `{\`${textPart}\${${exprText}}\`}`;
+          return [fixer.replaceText(textNode, templateLiteral), fixer.remove(exprNode)];
+        }
+      });
+    }
+    function handleExpressionBeforeText(exprNode, textNode) {
+      const textValue = textNode.value;
+      const trimmedText = textValue.trim();
+      if (!trimmedText) {
+        return;
+      }
+      const startsWithNonWhitespace = /^\S/.test(trimmedText);
+      if (!startsWithNonWhitespace) {
+        return;
+      }
+      context.report({
+        node: textNode,
+        messageId: "preferTemplate",
+        fix(fixer) {
+          const exprText = context.sourceCode.getText(exprNode.expression);
+          const textPart = textValue.trim();
+          const templateLiteral = `{\`\${${exprText}}${textPart}\`}`;
+          return [fixer.replaceText(exprNode, templateLiteral), fixer.remove(textNode)];
+        }
+      });
+    }
+    function checkJSXElement(node) {
+      const { children } = node;
+      if (children.length < 2) {
+        return;
+      }
+      for (let i = 0; i < children.length - 1; i += 1) {
+        const child = children[i];
+        const nextChild = children[i + 1];
+        if (!child || !nextChild) {
+          return;
+        }
+        if (child.type === AST_NODE_TYPES12.JSXText && nextChild.type === AST_NODE_TYPES12.JSXExpressionContainer) {
+          handleTextBeforeExpression(child, nextChild);
+        } else if (child.type === AST_NODE_TYPES12.JSXExpressionContainer && nextChild.type === AST_NODE_TYPES12.JSXText) {
+          handleExpressionBeforeText(child, nextChild);
+        }
+      }
+    }
+    return {
+      JSXElement: checkJSXElement
+    };
+  }
+});
+var prefer_jsx_template_literals_default = preferJSXTemplateLiterals;
+
 // src/rules/prefer-named-param-types.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES8, 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.replace(/-/g, "_").toUpperCase()}.md`
+import { AST_NODE_TYPES as AST_NODE_TYPES13, ESLintUtils as ESLintUtils17 } from "@typescript-eslint/utils";
+var createRule17 = ESLintUtils17.RuleCreator(
+  (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var preferNamedParamTypes = createRule13({
+var preferNamedParamTypes = createRule17({
   name: "prefer-named-param-types",
   meta: {
     type: "suggestion",
@@ -848,16 +1286,16 @@ var preferNamedParamTypes = createRule13({
   defaultOptions: [],
   create(context) {
     function hasInlineObjectType(param) {
-      if (param.type === AST_NODE_TYPES8.AssignmentPattern) {
+      if (param.type === AST_NODE_TYPES13.AssignmentPattern) {
         return hasInlineObjectType(param.left);
       }
-      if (param.type === AST_NODE_TYPES8.ObjectPattern) {
-        if (param.typeAnnotation?.typeAnnotation.type === AST_NODE_TYPES8.TSTypeLiteral) {
+      if (param.type === AST_NODE_TYPES13.ObjectPattern) {
+        if (param.typeAnnotation?.typeAnnotation.type === AST_NODE_TYPES13.TSTypeLiteral) {
           return true;
         }
       }
-      if (param.type === AST_NODE_TYPES8.Identifier) {
-        if (param.typeAnnotation?.typeAnnotation.type === AST_NODE_TYPES8.TSTypeLiteral) {
+      if (param.type === AST_NODE_TYPES13.Identifier) {
+        if (param.typeAnnotation?.typeAnnotation.type === AST_NODE_TYPES13.TSTypeLiteral) {
           return true;
         }
       }
@@ -891,11 +1329,11 @@ var preferNamedParamTypes = createRule13({
 var prefer_named_param_types_default = preferNamedParamTypes;
 
 // src/rules/prefer-react-import-types.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES9, 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.replace(/-/g, "_").toUpperCase()}.md`
+import { AST_NODE_TYPES as AST_NODE_TYPES14, 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 preferReactImportTypes = createRule14({
+var preferReactImportTypes = createRule18({
   name: "prefer-react-import-types",
   meta: {
     type: "suggestion",
@@ -971,7 +1409,7 @@ var preferReactImportTypes = createRule14({
     ]);
     const allReactExports = /* @__PURE__ */ new Set([...reactTypes, ...reactRuntimeExports]);
     function checkMemberExpression(node) {
-      if (node.object.type === AST_NODE_TYPES9.Identifier && node.object.name === "React" && node.property.type === AST_NODE_TYPES9.Identifier && allReactExports.has(node.property.name)) {
+      if (node.object.type === AST_NODE_TYPES14.Identifier && node.object.name === "React" && node.property.type === AST_NODE_TYPES14.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"`;
@@ -988,7 +1426,7 @@ var preferReactImportTypes = createRule14({
     return {
       MemberExpression: checkMemberExpression,
       "TSTypeReference > TSQualifiedName": (node) => {
-        if (node.left.type === AST_NODE_TYPES9.Identifier && node.left.name === "React" && node.right.type === AST_NODE_TYPES9.Identifier && allReactExports.has(node.right.name)) {
+        if (node.left.type === AST_NODE_TYPES14.Identifier && node.left.name === "React" && node.right.type === AST_NODE_TYPES14.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"`;
@@ -1008,11 +1446,11 @@ var preferReactImportTypes = createRule14({
 var prefer_react_import_types_default = preferReactImportTypes;
 
 // src/rules/react-props-destructure.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES10, 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.replace(/-/g, "_").toUpperCase()}.md`
+import { AST_NODE_TYPES as AST_NODE_TYPES15, 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 reactPropsDestructure = createRule15({
+var reactPropsDestructure = createRule19({
   name: "react-props-destructure",
   meta: {
     type: "suggestion",
@@ -1028,29 +1466,29 @@ var reactPropsDestructure = createRule15({
   defaultOptions: [],
   create(context) {
     function hasJSXInConditional(node) {
-      return node.consequent.type === AST_NODE_TYPES10.JSXElement || node.consequent.type === AST_NODE_TYPES10.JSXFragment || node.alternate.type === AST_NODE_TYPES10.JSXElement || node.alternate.type === AST_NODE_TYPES10.JSXFragment;
+      return node.consequent.type === AST_NODE_TYPES15.JSXElement || node.consequent.type === AST_NODE_TYPES15.JSXFragment || node.alternate.type === AST_NODE_TYPES15.JSXElement || node.alternate.type === AST_NODE_TYPES15.JSXFragment;
     }
     function hasJSXInLogical(node) {
-      return node.right.type === AST_NODE_TYPES10.JSXElement || node.right.type === AST_NODE_TYPES10.JSXFragment;
+      return node.right.type === AST_NODE_TYPES15.JSXElement || node.right.type === AST_NODE_TYPES15.JSXFragment;
     }
     function hasJSXReturn(block) {
       return block.body.some((stmt) => {
-        if (stmt.type === AST_NODE_TYPES10.ReturnStatement && stmt.argument) {
-          return stmt.argument.type === AST_NODE_TYPES10.JSXElement || stmt.argument.type === AST_NODE_TYPES10.JSXFragment || stmt.argument.type === AST_NODE_TYPES10.ConditionalExpression && hasJSXInConditional(stmt.argument) || stmt.argument.type === AST_NODE_TYPES10.LogicalExpression && hasJSXInLogical(stmt.argument);
+        if (stmt.type === AST_NODE_TYPES15.ReturnStatement && stmt.argument) {
+          return stmt.argument.type === AST_NODE_TYPES15.JSXElement || stmt.argument.type === AST_NODE_TYPES15.JSXFragment || stmt.argument.type === AST_NODE_TYPES15.ConditionalExpression && hasJSXInConditional(stmt.argument) || stmt.argument.type === AST_NODE_TYPES15.LogicalExpression && hasJSXInLogical(stmt.argument);
         }
         return false;
       });
     }
     function isReactComponent(node) {
-      if (node.type === AST_NODE_TYPES10.ArrowFunctionExpression) {
-        if (node.body.type === AST_NODE_TYPES10.JSXElement || node.body.type === AST_NODE_TYPES10.JSXFragment) {
+      if (node.type === AST_NODE_TYPES15.ArrowFunctionExpression) {
+        if (node.body.type === AST_NODE_TYPES15.JSXElement || node.body.type === AST_NODE_TYPES15.JSXFragment) {
           return true;
         }
-        if (node.body.type === AST_NODE_TYPES10.BlockStatement) {
+        if (node.body.type === AST_NODE_TYPES15.BlockStatement) {
           return hasJSXReturn(node.body);
         }
-      } else if (node.type === AST_NODE_TYPES10.FunctionExpression || node.type === AST_NODE_TYPES10.FunctionDeclaration) {
-        if (node.body && node.body.type === AST_NODE_TYPES10.BlockStatement) {
+      } else if (node.type === AST_NODE_TYPES15.FunctionExpression || node.type === AST_NODE_TYPES15.FunctionDeclaration) {
+        if (node.body && node.body.type === AST_NODE_TYPES15.BlockStatement) {
           return hasJSXReturn(node.body);
         }
       }
@@ -1064,9 +1502,9 @@ var reactPropsDestructure = createRule15({
         return;
       }
       const param = node.params[0];
-      if (param.type === AST_NODE_TYPES10.ObjectPattern) {
-        const properties = param.properties.filter((prop) => prop.type === AST_NODE_TYPES10.Property).map((prop) => {
-          if (prop.key.type === AST_NODE_TYPES10.Identifier) {
+      if (param.type === AST_NODE_TYPES15.ObjectPattern) {
+        const properties = param.properties.filter((prop) => prop.type === AST_NODE_TYPES15.Property).map((prop) => {
+          if (prop.key.type === AST_NODE_TYPES15.Identifier) {
             return prop.key.name;
           }
           return null;
@@ -1099,8 +1537,11 @@ var meta = {
 };
 var rules = {
   "enforce-readonly-component-props": enforce_readonly_component_props_default,
+  "enforce-sorted-destructuring": enforce_sorted_destructuring_default,
   "file-kebab-case": file_kebab_case_default,
   "jsx-pascal-case": jsx_pascal_case_default,
+  "jsx-no-non-component-function": jsx_no_non_component_function_default,
+  "jsx-no-variable-in-callback": jsx_no_variable_in_callback_default,
   "md-filename-case-restriction": md_filename_case_restriction_default,
   "no-complex-inline-return": no_complex_inline_return_default,
   "no-emoji": no_emoji_default,
@@ -1110,6 +1551,7 @@ var rules = {
   "prefer-destructuring-params": prefer_destructuring_params_default,
   "prefer-import-type": prefer_import_type_default,
   "prefer-interface-over-inline-types": prefer_interface_over_inline_types_default,
+  "prefer-jsx-template-literals": prefer_jsx_template_literals_default,
   "prefer-named-param-types": prefer_named_param_types_default,
   "prefer-react-import-types": prefer_react_import_types_default,
   "react-props-destructure": react_props_destructure_default
@@ -1120,6 +1562,7 @@ var plugin = {
 };
 var baseRules = {
   "nextfriday/no-emoji": "warn",
+  "nextfriday/enforce-sorted-destructuring": "warn",
   "nextfriday/file-kebab-case": "warn",
   "nextfriday/md-filename-case-restriction": "warn",
   "nextfriday/prefer-destructuring-params": "warn",
@@ -1133,6 +1576,7 @@ var baseRules = {
 };
 var baseRecommendedRules = {
   "nextfriday/no-emoji": "error",
+  "nextfriday/enforce-sorted-destructuring": "error",
   "nextfriday/file-kebab-case": "error",
   "nextfriday/md-filename-case-restriction": "error",
   "nextfriday/prefer-destructuring-params": "error",
@@ -1146,13 +1590,19 @@ var baseRecommendedRules = {
 };
 var jsxRules = {
   "nextfriday/jsx-pascal-case": "warn",
+  "nextfriday/jsx-no-non-component-function": "warn",
+  "nextfriday/jsx-no-variable-in-callback": "warn",
   "nextfriday/prefer-interface-over-inline-types": "warn",
+  "nextfriday/prefer-jsx-template-literals": "warn",
   "nextfriday/react-props-destructure": "warn",
   "nextfriday/enforce-readonly-component-props": "warn"
 };
 var jsxRecommendedRules = {
   "nextfriday/jsx-pascal-case": "error",
+  "nextfriday/jsx-no-non-component-function": "error",
+  "nextfriday/jsx-no-variable-in-callback": "error",
   "nextfriday/prefer-interface-over-inline-types": "error",
+  "nextfriday/prefer-jsx-template-literals": "error",
   "nextfriday/react-props-destructure": "error",
   "nextfriday/enforce-readonly-component-props": "error"
 };