eslint-plugin-nextfriday 1.3.0 → 1.5.0

package/lib/index.cjs

@@ -40,7 +40,7 @@ module.exports = __toCommonJS(index_exports);
 // package.json
 var package_default = {
   name: "eslint-plugin-nextfriday",
-  version: "1.3.0",
+  version: "1.5.0",
   description: "A comprehensive ESLint plugin providing custom rules and configurations for Next Friday development workflows.",
   keywords: [
     "eslint",
@@ -90,8 +90,8 @@ var package_default = {
     "changeset:publish": "npm publish --provenance --access public",
     "changeset:version": "changeset version",
     clear: "rm -rf lib node_modules/.cache .eslintcache",
-    eslint: "eslint src --ext .js,.ts,.mjs --fix",
-    "eslint:check": "eslint src --ext .js,.ts,.mjs",
+    eslint: "eslint src --ext .js,.ts --fix",
+    "eslint:check": "eslint src --ext .js,.ts",
     preinstall: "npx only-allow pnpm",
     prepare: "husky",
     prepublishOnly: "pnpm run build",
@@ -380,13 +380,59 @@ var mdFilenameCaseRestriction = createRule4({
 });
 var md_filename_case_restriction_default = mdFilenameCaseRestriction;
 
-// src/rules/no-emoji.ts
-var import_emoji_regex = __toESM(require("emoji-regex"), 1);
+// src/rules/no-complex-inline-return.ts
 var import_utils5 = require("@typescript-eslint/utils");
 var createRule5 = import_utils5.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replace(/-/g, "_").toUpperCase()}.md`
 );
-var noEmoji = createRule5({
+var noComplexInlineReturn = createRule5({
+  name: "no-complex-inline-return",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Disallow complex inline expressions in return statements - prefer extracting to a const first"
+    },
+    messages: {
+      noComplexInlineReturn: "Avoid returning complex expressions directly. Extract to a const variable first for better readability."
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    const isComplexExpression = (node) => {
+      if (!node) return false;
+      if (node.type === import_utils5.AST_NODE_TYPES.ConditionalExpression) {
+        return true;
+      }
+      if (node.type === import_utils5.AST_NODE_TYPES.LogicalExpression) {
+        return true;
+      }
+      if (node.type === import_utils5.AST_NODE_TYPES.NewExpression) {
+        return true;
+      }
+      return false;
+    };
+    return {
+      ReturnStatement(node) {
+        if (node.argument && isComplexExpression(node.argument)) {
+          context.report({
+            node: node.argument,
+            messageId: "noComplexInlineReturn"
+          });
+        }
+      }
+    };
+  }
+});
+var no_complex_inline_return_default = noComplexInlineReturn;
+
+// src/rules/no-emoji.ts
+var import_emoji_regex = __toESM(require("emoji-regex"), 1);
+var import_utils6 = require("@typescript-eslint/utils");
+var createRule6 = import_utils6.ESLintUtils.RuleCreator(
+  (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replace(/-/g, "_").toUpperCase()}.md`
+);
+var noEmoji = createRule6({
   name: "no-emoji",
   meta: {
     type: "problem",
@@ -419,12 +465,65 @@ var noEmoji = createRule5({
 });
 var no_emoji_default = noEmoji;
 
+// src/rules/no-env-fallback.ts
+var import_utils7 = require("@typescript-eslint/utils");
+var createRule7 = import_utils7.ESLintUtils.RuleCreator(
+  (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replace(/-/g, "_").toUpperCase()}.md`
+);
+var noEnvFallback = createRule7({
+  name: "no-env-fallback",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow fallback values for environment variables as they can be dangerous in production"
+    },
+    messages: {
+      noEnvFallback: "Avoid using fallback values with process.env. Environment variables should fail explicitly when missing rather than silently using a default value."
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    const isProcessEnvAccess = (node) => {
+      if (node.type !== import_utils7.AST_NODE_TYPES.MemberExpression) {
+        return false;
+      }
+      const { object } = node;
+      if (object.type !== import_utils7.AST_NODE_TYPES.MemberExpression) {
+        return false;
+      }
+      const processNode = object.object;
+      const envNode = object.property;
+      return processNode.type === import_utils7.AST_NODE_TYPES.Identifier && processNode.name === "process" && envNode.type === import_utils7.AST_NODE_TYPES.Identifier && envNode.name === "env";
+    };
+    return {
+      LogicalExpression(node) {
+        if ((node.operator === "||" || node.operator === "??") && isProcessEnvAccess(node.left)) {
+          context.report({
+            node,
+            messageId: "noEnvFallback"
+          });
+        }
+      },
+      ConditionalExpression(node) {
+        if (isProcessEnvAccess(node.test)) {
+          context.report({
+            node,
+            messageId: "noEnvFallback"
+          });
+        }
+      }
+    };
+  }
+});
+var no_env_fallback_default = noEnvFallback;
+
 // src/rules/no-explicit-return-type.ts
-var import_utils6 = require("@typescript-eslint/utils");
-var createRule6 = import_utils6.ESLintUtils.RuleCreator(
+var import_utils8 = require("@typescript-eslint/utils");
+var createRule8 = import_utils8.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replace(/-/g, "_").toUpperCase()}.md`
 );
-var noExplicitReturnType = createRule6({
+var noExplicitReturnType = createRule8({
   name: "no-explicit-return-type",
   meta: {
     type: "suggestion",
@@ -463,12 +562,76 @@ var noExplicitReturnType = createRule6({
 });
 var no_explicit_return_type_default = noExplicitReturnType;
 
+// src/rules/no-logic-in-params.ts
+var import_utils9 = require("@typescript-eslint/utils");
+var createRule9 = import_utils9.ESLintUtils.RuleCreator(
+  (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replace(/-/g, "_").toUpperCase()}.md`
+);
+var noLogicInParams = createRule9({
+  name: "no-logic-in-params",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Disallow logic or conditions in function parameters - extract to a const variable first"
+    },
+    messages: {
+      noLogicInParams: "Avoid logic or conditions in function parameters. Extract to a const variable first for better readability."
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    const isComplexExpression = (node) => {
+      if (node.type === import_utils9.AST_NODE_TYPES.SpreadElement) {
+        return false;
+      }
+      if (node.type === import_utils9.AST_NODE_TYPES.ConditionalExpression) {
+        return true;
+      }
+      if (node.type === import_utils9.AST_NODE_TYPES.LogicalExpression) {
+        return true;
+      }
+      if (node.type === import_utils9.AST_NODE_TYPES.BinaryExpression) {
+        const logicalOperators = ["==", "===", "!=", "!==", "<", ">", "<=", ">=", "in", "instanceof"];
+        return logicalOperators.includes(node.operator);
+      }
+      if (node.type === import_utils9.AST_NODE_TYPES.UnaryExpression) {
+        return node.operator === "!";
+      }
+      return false;
+    };
+    return {
+      CallExpression(node) {
+        node.arguments.forEach((arg) => {
+          if (isComplexExpression(arg)) {
+            context.report({
+              node: arg,
+              messageId: "noLogicInParams"
+            });
+          }
+        });
+      },
+      NewExpression(node) {
+        node.arguments.forEach((arg) => {
+          if (isComplexExpression(arg)) {
+            context.report({
+              node: arg,
+              messageId: "noLogicInParams"
+            });
+          }
+        });
+      }
+    };
+  }
+});
+var no_logic_in_params_default = noLogicInParams;
+
 // src/rules/prefer-destructuring-params.ts
-var import_utils7 = require("@typescript-eslint/utils");
-var createRule7 = import_utils7.ESLintUtils.RuleCreator(
+var import_utils10 = require("@typescript-eslint/utils");
+var createRule10 = import_utils10.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replace(/-/g, "_").toUpperCase()}.md`
 );
-var preferDestructuringParams = createRule7({
+var preferDestructuringParams = createRule10({
   name: "prefer-destructuring-params",
   meta: {
     type: "suggestion",
@@ -484,18 +647,18 @@ var preferDestructuringParams = createRule7({
   create(context) {
     const isCallbackFunction = (node) => {
       const { parent } = node;
-      return parent?.type === import_utils7.AST_NODE_TYPES.CallExpression;
+      return parent?.type === import_utils10.AST_NODE_TYPES.CallExpression;
     };
     const isDeveloperFunction = (node) => {
-      if (node.type === import_utils7.AST_NODE_TYPES.FunctionDeclaration) {
+      if (node.type === import_utils10.AST_NODE_TYPES.FunctionDeclaration) {
         return true;
       }
-      if (node.type === import_utils7.AST_NODE_TYPES.FunctionExpression || node.type === import_utils7.AST_NODE_TYPES.ArrowFunctionExpression) {
+      if (node.type === import_utils10.AST_NODE_TYPES.FunctionExpression || node.type === import_utils10.AST_NODE_TYPES.ArrowFunctionExpression) {
         if (isCallbackFunction(node)) {
           return false;
         }
         const { parent } = node;
-        return parent?.type === import_utils7.AST_NODE_TYPES.VariableDeclarator || parent?.type === import_utils7.AST_NODE_TYPES.AssignmentExpression || parent?.type === import_utils7.AST_NODE_TYPES.Property || parent?.type === import_utils7.AST_NODE_TYPES.MethodDefinition;
+        return parent?.type === import_utils10.AST_NODE_TYPES.VariableDeclarator || parent?.type === import_utils10.AST_NODE_TYPES.AssignmentExpression || parent?.type === import_utils10.AST_NODE_TYPES.Property || parent?.type === import_utils10.AST_NODE_TYPES.MethodDefinition;
       }
       return false;
     };
@@ -507,7 +670,7 @@ var preferDestructuringParams = createRule7({
       if (!isDeveloperFunction(node)) {
         return;
       }
-      if (node.type === import_utils7.AST_NODE_TYPES.FunctionDeclaration && node.id) {
+      if (node.type === import_utils10.AST_NODE_TYPES.FunctionDeclaration && node.id) {
         const functionName = node.id.name;
         if (functionName.startsWith("_") || functionName.includes("$") || /^[A-Z][a-zA-Z]*$/.test(functionName)) {
           return;
@@ -517,7 +680,7 @@ var preferDestructuringParams = createRule7({
         return;
       }
       const hasNonDestructuredParams = node.params.some(
-        (param) => param.type !== import_utils7.AST_NODE_TYPES.ObjectPattern && param.type !== import_utils7.AST_NODE_TYPES.RestElement
+        (param) => param.type !== import_utils10.AST_NODE_TYPES.ObjectPattern && param.type !== import_utils10.AST_NODE_TYPES.RestElement
       );
       if (hasNonDestructuredParams) {
         context.report({
@@ -536,11 +699,11 @@ var preferDestructuringParams = createRule7({
 var prefer_destructuring_params_default = preferDestructuringParams;
 
 // src/rules/prefer-import-type.ts
-var import_utils8 = require("@typescript-eslint/utils");
-var createRule8 = import_utils8.ESLintUtils.RuleCreator(
+var import_utils11 = require("@typescript-eslint/utils");
+var createRule11 = import_utils11.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replace(/-/g, "_").toUpperCase()}.md`
 );
-var preferImportType = createRule8({
+var preferImportType = createRule11({
   name: "prefer-import-type",
   meta: {
     type: "suggestion",
@@ -571,14 +734,14 @@ var preferImportType = createRule8({
         return;
       }
       const isTypeOnlyImport = node.specifiers.every((specifier) => {
-        if (specifier.type === import_utils8.AST_NODE_TYPES.ImportDefaultSpecifier) {
+        if (specifier.type === import_utils11.AST_NODE_TYPES.ImportDefaultSpecifier) {
           return false;
         }
-        if (specifier.type === import_utils8.AST_NODE_TYPES.ImportNamespaceSpecifier) {
+        if (specifier.type === import_utils11.AST_NODE_TYPES.ImportNamespaceSpecifier) {
           return false;
         }
-        if (specifier.type === import_utils8.AST_NODE_TYPES.ImportSpecifier) {
-          const importedName = specifier.imported.type === import_utils8.AST_NODE_TYPES.Identifier ? specifier.imported.name : specifier.imported.value;
+        if (specifier.type === import_utils11.AST_NODE_TYPES.ImportSpecifier) {
+          const importedName = specifier.imported.type === import_utils11.AST_NODE_TYPES.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");
@@ -606,11 +769,11 @@ var preferImportType = createRule8({
 var prefer_import_type_default = preferImportType;
 
 // src/rules/prefer-interface-over-inline-types.ts
-var import_utils9 = require("@typescript-eslint/utils");
-var createRule9 = import_utils9.ESLintUtils.RuleCreator(
+var import_utils12 = require("@typescript-eslint/utils");
+var createRule12 = import_utils12.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replace(/-/g, "_").toUpperCase()}.md`
 );
-var preferInterfaceOverInlineTypes = createRule9({
+var preferInterfaceOverInlineTypes = createRule12({
   name: "prefer-interface-over-inline-types",
   meta: {
     type: "suggestion",
@@ -626,54 +789,54 @@ var preferInterfaceOverInlineTypes = createRule9({
   defaultOptions: [],
   create(context) {
     function hasJSXInConditional(node) {
-      return node.consequent.type === import_utils9.AST_NODE_TYPES.JSXElement || node.consequent.type === import_utils9.AST_NODE_TYPES.JSXFragment || node.alternate.type === import_utils9.AST_NODE_TYPES.JSXElement || node.alternate.type === import_utils9.AST_NODE_TYPES.JSXFragment;
+      return node.consequent.type === import_utils12.AST_NODE_TYPES.JSXElement || node.consequent.type === import_utils12.AST_NODE_TYPES.JSXFragment || node.alternate.type === import_utils12.AST_NODE_TYPES.JSXElement || node.alternate.type === import_utils12.AST_NODE_TYPES.JSXFragment;
     }
     function hasJSXInLogical(node) {
-      return node.right.type === import_utils9.AST_NODE_TYPES.JSXElement || node.right.type === import_utils9.AST_NODE_TYPES.JSXFragment;
+      return node.right.type === import_utils12.AST_NODE_TYPES.JSXElement || node.right.type === import_utils12.AST_NODE_TYPES.JSXFragment;
     }
     function hasJSXReturn(block) {
       return block.body.some((stmt) => {
-        if (stmt.type === import_utils9.AST_NODE_TYPES.ReturnStatement && stmt.argument) {
-          return stmt.argument.type === import_utils9.AST_NODE_TYPES.JSXElement || stmt.argument.type === import_utils9.AST_NODE_TYPES.JSXFragment || stmt.argument.type === import_utils9.AST_NODE_TYPES.ConditionalExpression && hasJSXInConditional(stmt.argument) || stmt.argument.type === import_utils9.AST_NODE_TYPES.LogicalExpression && hasJSXInLogical(stmt.argument);
+        if (stmt.type === import_utils12.AST_NODE_TYPES.ReturnStatement && stmt.argument) {
+          return stmt.argument.type === import_utils12.AST_NODE_TYPES.JSXElement || stmt.argument.type === import_utils12.AST_NODE_TYPES.JSXFragment || stmt.argument.type === import_utils12.AST_NODE_TYPES.ConditionalExpression && hasJSXInConditional(stmt.argument) || stmt.argument.type === import_utils12.AST_NODE_TYPES.LogicalExpression && hasJSXInLogical(stmt.argument);
         }
         return false;
       });
     }
     function isReactComponent(node) {
-      if (node.type === import_utils9.AST_NODE_TYPES.ArrowFunctionExpression) {
-        if (node.body.type === import_utils9.AST_NODE_TYPES.JSXElement || node.body.type === import_utils9.AST_NODE_TYPES.JSXFragment) {
+      if (node.type === import_utils12.AST_NODE_TYPES.ArrowFunctionExpression) {
+        if (node.body.type === import_utils12.AST_NODE_TYPES.JSXElement || node.body.type === import_utils12.AST_NODE_TYPES.JSXFragment) {
           return true;
         }
-        if (node.body.type === import_utils9.AST_NODE_TYPES.BlockStatement) {
+        if (node.body.type === import_utils12.AST_NODE_TYPES.BlockStatement) {
           return hasJSXReturn(node.body);
         }
-      } else if (node.type === import_utils9.AST_NODE_TYPES.FunctionExpression || node.type === import_utils9.AST_NODE_TYPES.FunctionDeclaration) {
-        if (node.body && node.body.type === import_utils9.AST_NODE_TYPES.BlockStatement) {
+      } else if (node.type === import_utils12.AST_NODE_TYPES.FunctionExpression || node.type === import_utils12.AST_NODE_TYPES.FunctionDeclaration) {
+        if (node.body && node.body.type === import_utils12.AST_NODE_TYPES.BlockStatement) {
           return hasJSXReturn(node.body);
         }
       }
       return false;
     }
     function isInlineTypeAnnotation(node) {
-      if (node.type === import_utils9.AST_NODE_TYPES.TSTypeLiteral) {
+      if (node.type === import_utils12.AST_NODE_TYPES.TSTypeLiteral) {
         return true;
       }
-      if (node.type === import_utils9.AST_NODE_TYPES.TSTypeReference && node.typeArguments) {
-        return node.typeArguments.params.some((param) => param.type === import_utils9.AST_NODE_TYPES.TSTypeLiteral);
+      if (node.type === import_utils12.AST_NODE_TYPES.TSTypeReference && node.typeArguments) {
+        return node.typeArguments.params.some((param) => param.type === import_utils12.AST_NODE_TYPES.TSTypeLiteral);
       }
-      if (node.type === import_utils9.AST_NODE_TYPES.TSUnionType) {
+      if (node.type === import_utils12.AST_NODE_TYPES.TSUnionType) {
         return node.types.some((type) => isInlineTypeAnnotation(type));
       }
       return false;
     }
     function hasInlineObjectType(node) {
-      if (node.type === import_utils9.AST_NODE_TYPES.TSTypeLiteral) {
+      if (node.type === import_utils12.AST_NODE_TYPES.TSTypeLiteral) {
         return true;
       }
-      if (node.type === import_utils9.AST_NODE_TYPES.TSTypeReference && node.typeArguments) {
-        return node.typeArguments.params.some((param) => param.type === import_utils9.AST_NODE_TYPES.TSTypeLiteral);
+      if (node.type === import_utils12.AST_NODE_TYPES.TSTypeReference && node.typeArguments) {
+        return node.typeArguments.params.some((param) => param.type === import_utils12.AST_NODE_TYPES.TSTypeLiteral);
       }
-      if (node.type === import_utils9.AST_NODE_TYPES.TSUnionType) {
+      if (node.type === import_utils12.AST_NODE_TYPES.TSUnionType) {
         return node.types.some((type) => hasInlineObjectType(type));
       }
       return false;
@@ -686,7 +849,7 @@ var preferInterfaceOverInlineTypes = createRule9({
         return;
       }
       const param = node.params[0];
-      if (param.type === import_utils9.AST_NODE_TYPES.Identifier && param.typeAnnotation) {
+      if (param.type === import_utils12.AST_NODE_TYPES.Identifier && param.typeAnnotation) {
         const { typeAnnotation } = param.typeAnnotation;
         if (isInlineTypeAnnotation(typeAnnotation) && hasInlineObjectType(typeAnnotation)) {
           context.report({
@@ -706,11 +869,11 @@ var preferInterfaceOverInlineTypes = createRule9({
 var prefer_interface_over_inline_types_default = preferInterfaceOverInlineTypes;
 
 // src/rules/prefer-named-param-types.ts
-var import_utils10 = require("@typescript-eslint/utils");
-var createRule10 = import_utils10.ESLintUtils.RuleCreator(
+var import_utils13 = require("@typescript-eslint/utils");
+var createRule13 = import_utils13.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replace(/-/g, "_").toUpperCase()}.md`
 );
-var preferNamedParamTypes = createRule10({
+var preferNamedParamTypes = createRule13({
   name: "prefer-named-param-types",
   meta: {
     type: "suggestion",
@@ -725,16 +888,16 @@ var preferNamedParamTypes = createRule10({
   defaultOptions: [],
   create(context) {
     function hasInlineObjectType(param) {
-      if (param.type === import_utils10.AST_NODE_TYPES.AssignmentPattern) {
+      if (param.type === import_utils13.AST_NODE_TYPES.AssignmentPattern) {
         return hasInlineObjectType(param.left);
       }
-      if (param.type === import_utils10.AST_NODE_TYPES.ObjectPattern) {
-        if (param.typeAnnotation?.typeAnnotation.type === import_utils10.AST_NODE_TYPES.TSTypeLiteral) {
+      if (param.type === import_utils13.AST_NODE_TYPES.ObjectPattern) {
+        if (param.typeAnnotation?.typeAnnotation.type === import_utils13.AST_NODE_TYPES.TSTypeLiteral) {
           return true;
         }
       }
-      if (param.type === import_utils10.AST_NODE_TYPES.Identifier) {
-        if (param.typeAnnotation?.typeAnnotation.type === import_utils10.AST_NODE_TYPES.TSTypeLiteral) {
+      if (param.type === import_utils13.AST_NODE_TYPES.Identifier) {
+        if (param.typeAnnotation?.typeAnnotation.type === import_utils13.AST_NODE_TYPES.TSTypeLiteral) {
           return true;
         }
       }
@@ -768,11 +931,11 @@ var preferNamedParamTypes = createRule10({
 var prefer_named_param_types_default = preferNamedParamTypes;
 
 // src/rules/prefer-react-import-types.ts
-var import_utils11 = require("@typescript-eslint/utils");
-var createRule11 = import_utils11.ESLintUtils.RuleCreator(
+var import_utils14 = require("@typescript-eslint/utils");
+var createRule14 = import_utils14.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replace(/-/g, "_").toUpperCase()}.md`
 );
-var preferReactImportTypes = createRule11({
+var preferReactImportTypes = createRule14({
   name: "prefer-react-import-types",
   meta: {
     type: "suggestion",
@@ -848,7 +1011,7 @@ var preferReactImportTypes = createRule11({
     ]);
     const allReactExports = /* @__PURE__ */ new Set([...reactTypes, ...reactRuntimeExports]);
     function checkMemberExpression(node) {
-      if (node.object.type === import_utils11.AST_NODE_TYPES.Identifier && node.object.name === "React" && node.property.type === import_utils11.AST_NODE_TYPES.Identifier && allReactExports.has(node.property.name)) {
+      if (node.object.type === import_utils14.AST_NODE_TYPES.Identifier && node.object.name === "React" && node.property.type === import_utils14.AST_NODE_TYPES.Identifier && allReactExports.has(node.property.name)) {
         const typeName = node.property.name;
         const isType = reactTypes.has(typeName);
         const importStatement = isType ? `import type { ${typeName} } from "react"` : `import { ${typeName} } from "react"`;
@@ -865,7 +1028,7 @@ var preferReactImportTypes = createRule11({
     return {
       MemberExpression: checkMemberExpression,
       "TSTypeReference > TSQualifiedName": (node) => {
-        if (node.left.type === import_utils11.AST_NODE_TYPES.Identifier && node.left.name === "React" && node.right.type === import_utils11.AST_NODE_TYPES.Identifier && allReactExports.has(node.right.name)) {
+        if (node.left.type === import_utils14.AST_NODE_TYPES.Identifier && node.left.name === "React" && node.right.type === import_utils14.AST_NODE_TYPES.Identifier && allReactExports.has(node.right.name)) {
           const typeName = node.right.name;
           const isType = reactTypes.has(typeName);
           const importStatement = isType ? `import type { ${typeName} } from "react"` : `import { ${typeName} } from "react"`;
@@ -885,11 +1048,11 @@ var preferReactImportTypes = createRule11({
 var prefer_react_import_types_default = preferReactImportTypes;
 
 // src/rules/react-props-destructure.ts
-var import_utils12 = require("@typescript-eslint/utils");
-var createRule12 = import_utils12.ESLintUtils.RuleCreator(
+var import_utils15 = require("@typescript-eslint/utils");
+var createRule15 = import_utils15.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replace(/-/g, "_").toUpperCase()}.md`
 );
-var reactPropsDestructure = createRule12({
+var reactPropsDestructure = createRule15({
   name: "react-props-destructure",
   meta: {
     type: "suggestion",
@@ -905,29 +1068,29 @@ var reactPropsDestructure = createRule12({
   defaultOptions: [],
   create(context) {
     function hasJSXInConditional(node) {
-      return node.consequent.type === import_utils12.AST_NODE_TYPES.JSXElement || node.consequent.type === import_utils12.AST_NODE_TYPES.JSXFragment || node.alternate.type === import_utils12.AST_NODE_TYPES.JSXElement || node.alternate.type === import_utils12.AST_NODE_TYPES.JSXFragment;
+      return node.consequent.type === import_utils15.AST_NODE_TYPES.JSXElement || node.consequent.type === import_utils15.AST_NODE_TYPES.JSXFragment || node.alternate.type === import_utils15.AST_NODE_TYPES.JSXElement || node.alternate.type === import_utils15.AST_NODE_TYPES.JSXFragment;
     }
     function hasJSXInLogical(node) {
-      return node.right.type === import_utils12.AST_NODE_TYPES.JSXElement || node.right.type === import_utils12.AST_NODE_TYPES.JSXFragment;
+      return node.right.type === import_utils15.AST_NODE_TYPES.JSXElement || node.right.type === import_utils15.AST_NODE_TYPES.JSXFragment;
     }
     function hasJSXReturn(block) {
       return block.body.some((stmt) => {
-        if (stmt.type === import_utils12.AST_NODE_TYPES.ReturnStatement && stmt.argument) {
-          return stmt.argument.type === import_utils12.AST_NODE_TYPES.JSXElement || stmt.argument.type === import_utils12.AST_NODE_TYPES.JSXFragment || stmt.argument.type === import_utils12.AST_NODE_TYPES.ConditionalExpression && hasJSXInConditional(stmt.argument) || stmt.argument.type === import_utils12.AST_NODE_TYPES.LogicalExpression && hasJSXInLogical(stmt.argument);
+        if (stmt.type === import_utils15.AST_NODE_TYPES.ReturnStatement && stmt.argument) {
+          return stmt.argument.type === import_utils15.AST_NODE_TYPES.JSXElement || stmt.argument.type === import_utils15.AST_NODE_TYPES.JSXFragment || stmt.argument.type === import_utils15.AST_NODE_TYPES.ConditionalExpression && hasJSXInConditional(stmt.argument) || stmt.argument.type === import_utils15.AST_NODE_TYPES.LogicalExpression && hasJSXInLogical(stmt.argument);
         }
         return false;
       });
     }
     function isReactComponent(node) {
-      if (node.type === import_utils12.AST_NODE_TYPES.ArrowFunctionExpression) {
-        if (node.body.type === import_utils12.AST_NODE_TYPES.JSXElement || node.body.type === import_utils12.AST_NODE_TYPES.JSXFragment) {
+      if (node.type === import_utils15.AST_NODE_TYPES.ArrowFunctionExpression) {
+        if (node.body.type === import_utils15.AST_NODE_TYPES.JSXElement || node.body.type === import_utils15.AST_NODE_TYPES.JSXFragment) {
           return true;
         }
-        if (node.body.type === import_utils12.AST_NODE_TYPES.BlockStatement) {
+        if (node.body.type === import_utils15.AST_NODE_TYPES.BlockStatement) {
           return hasJSXReturn(node.body);
         }
-      } else if (node.type === import_utils12.AST_NODE_TYPES.FunctionExpression || node.type === import_utils12.AST_NODE_TYPES.FunctionDeclaration) {
-        if (node.body && node.body.type === import_utils12.AST_NODE_TYPES.BlockStatement) {
+      } else if (node.type === import_utils15.AST_NODE_TYPES.FunctionExpression || node.type === import_utils15.AST_NODE_TYPES.FunctionDeclaration) {
+        if (node.body && node.body.type === import_utils15.AST_NODE_TYPES.BlockStatement) {
           return hasJSXReturn(node.body);
         }
       }
@@ -941,9 +1104,9 @@ var reactPropsDestructure = createRule12({
         return;
       }
       const param = node.params[0];
-      if (param.type === import_utils12.AST_NODE_TYPES.ObjectPattern) {
-        const properties = param.properties.filter((prop) => prop.type === import_utils12.AST_NODE_TYPES.Property).map((prop) => {
-          if (prop.key.type === import_utils12.AST_NODE_TYPES.Identifier) {
+      if (param.type === import_utils15.AST_NODE_TYPES.ObjectPattern) {
+        const properties = param.properties.filter((prop) => prop.type === import_utils15.AST_NODE_TYPES.Property).map((prop) => {
+          if (prop.key.type === import_utils15.AST_NODE_TYPES.Identifier) {
             return prop.key.name;
           }
           return null;
@@ -979,8 +1142,11 @@ var rules = {
   "file-kebab-case": file_kebab_case_default,
   "jsx-pascal-case": jsx_pascal_case_default,
   "md-filename-case-restriction": md_filename_case_restriction_default,
+  "no-complex-inline-return": no_complex_inline_return_default,
   "no-emoji": no_emoji_default,
+  "no-env-fallback": no_env_fallback_default,
   "no-explicit-return-type": no_explicit_return_type_default,
+  "no-logic-in-params": no_logic_in_params_default,
   "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,
@@ -1000,7 +1166,10 @@ var baseRules = {
   "nextfriday/no-explicit-return-type": "warn",
   "nextfriday/prefer-import-type": "warn",
   "nextfriday/prefer-named-param-types": "warn",
-  "nextfriday/prefer-react-import-types": "warn"
+  "nextfriday/prefer-react-import-types": "warn",
+  "nextfriday/no-complex-inline-return": "warn",
+  "nextfriday/no-logic-in-params": "warn",
+  "nextfriday/no-env-fallback": "warn"
 };
 var baseRecommendedRules = {
   "nextfriday/no-emoji": "error",
@@ -1010,7 +1179,10 @@ var baseRecommendedRules = {
   "nextfriday/no-explicit-return-type": "error",
   "nextfriday/prefer-import-type": "error",
   "nextfriday/prefer-named-param-types": "error",
-  "nextfriday/prefer-react-import-types": "error"
+  "nextfriday/prefer-react-import-types": "error",
+  "nextfriday/no-complex-inline-return": "error",
+  "nextfriday/no-logic-in-params": "error",
+  "nextfriday/no-env-fallback": "error"
 };
 var jsxRules = {
   "nextfriday/jsx-pascal-case": "warn",