eslint-plugin-nextfriday 1.1.1 → 1.2.0

package/lib/index.js

@@ -1,7 +1,7 @@
 // package.json
 var package_default = {
   name: "eslint-plugin-nextfriday",
-  version: "1.1.1",
+  version: "1.2.0",
   description: "A comprehensive ESLint plugin providing custom rules and configurations for Next Friday development workflows.",
   keywords: [
     "eslint",
@@ -116,10 +116,102 @@ 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}.md`
+);
+var enforceReadonlyComponentProps = createRule({
+  name: "enforce-readonly-component-props",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Enforce Readonly wrapper for React component props when using named types or interfaces"
+    },
+    fixable: "code",
+    schema: [],
+    messages: {
+      useReadonly: "Component props should be wrapped with Readonly<> for immutability"
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    function hasJSXInConditional(node) {
+      return node.consequent.type === AST_NODE_TYPES.JSXElement || node.consequent.type === AST_NODE_TYPES.JSXFragment || node.alternate.type === AST_NODE_TYPES.JSXElement || node.alternate.type === AST_NODE_TYPES.JSXFragment;
+    }
+    function hasJSXInLogical(node) {
+      return node.right.type === AST_NODE_TYPES.JSXElement || node.right.type === AST_NODE_TYPES.JSXFragment;
+    }
+    function hasJSXReturn(block) {
+      return block.body.some((stmt) => {
+        if (stmt.type === AST_NODE_TYPES.ReturnStatement && stmt.argument) {
+          return stmt.argument.type === AST_NODE_TYPES.JSXElement || stmt.argument.type === AST_NODE_TYPES.JSXFragment || stmt.argument.type === AST_NODE_TYPES.ConditionalExpression && hasJSXInConditional(stmt.argument) || stmt.argument.type === AST_NODE_TYPES.LogicalExpression && hasJSXInLogical(stmt.argument);
+        }
+        return false;
+      });
+    }
+    function isReactComponent(node) {
+      if (node.type === AST_NODE_TYPES.ArrowFunctionExpression) {
+        if (node.body.type === AST_NODE_TYPES.JSXElement || node.body.type === AST_NODE_TYPES.JSXFragment) {
+          return true;
+        }
+        if (node.body.type === AST_NODE_TYPES.BlockStatement) {
+          return hasJSXReturn(node.body);
+        }
+      } else if (node.type === AST_NODE_TYPES.FunctionExpression || node.type === AST_NODE_TYPES.FunctionDeclaration) {
+        if (node.body && node.body.type === AST_NODE_TYPES.BlockStatement) {
+          return hasJSXReturn(node.body);
+        }
+      }
+      return false;
+    }
+    function isNamedType(node) {
+      return node.type === AST_NODE_TYPES.TSTypeReference;
+    }
+    function isAlreadyReadonly(node) {
+      if (node.type === AST_NODE_TYPES.TSTypeReference && node.typeName) {
+        if (node.typeName.type === AST_NODE_TYPES.Identifier && node.typeName.name === "Readonly") {
+          return true;
+        }
+      }
+      return false;
+    }
+    function checkFunction(node) {
+      if (!isReactComponent(node)) {
+        return;
+      }
+      if (node.params.length !== 1) {
+        return;
+      }
+      const param = node.params[0];
+      if (param.type === AST_NODE_TYPES.Identifier && param.typeAnnotation) {
+        const { typeAnnotation } = param.typeAnnotation;
+        if (isNamedType(typeAnnotation) && !isAlreadyReadonly(typeAnnotation)) {
+          const { sourceCode } = context;
+          const typeText = sourceCode.getText(typeAnnotation);
+          context.report({
+            node: param.typeAnnotation,
+            messageId: "useReadonly",
+            fix(fixer) {
+              return fixer.replaceText(typeAnnotation, `Readonly<${typeText}>`);
+            }
+          });
+        }
+      }
+    }
+    return {
+      ArrowFunctionExpression: checkFunction,
+      FunctionExpression: checkFunction,
+      FunctionDeclaration: checkFunction
+    };
+  }
+});
+var enforce_readonly_component_props_default = enforceReadonlyComponentProps;
+
 // src/rules/file-kebab-case.ts
 import path from "path";
-import { ESLintUtils } from "@typescript-eslint/utils";
-var createRule = ESLintUtils.RuleCreator(
+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}.md`
 );
 var isKebabCase = (str) => {
@@ -128,7 +220,7 @@ var isKebabCase = (str) => {
   }
   return /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(str);
 };
-var fileKebabCase = createRule({
+var fileKebabCase = createRule2({
   name: "file-kebab-case",
   meta: {
     type: "problem",
@@ -164,12 +256,12 @@ var file_kebab_case_default = fileKebabCase;
 
 // src/rules/jsx-pascal-case.ts
 import path2 from "path";
-import { ESLintUtils as ESLintUtils2 } from "@typescript-eslint/utils";
-var createRule2 = ESLintUtils2.RuleCreator(
+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}.md`
 );
 var isPascalCase = (str) => /^[A-Z][a-zA-Z0-9]*$/.test(str) && !/^[A-Z]+$/.test(str);
-var jsxPascalCase = createRule2({
+var jsxPascalCase = createRule3({
   name: "jsx-pascal-case",
   meta: {
     type: "problem",
@@ -205,11 +297,11 @@ var jsx_pascal_case_default = jsxPascalCase;
 
 // src/rules/md-filename-case-restriction.ts
 import path3 from "path";
-import { ESLintUtils as ESLintUtils3 } from "@typescript-eslint/utils";
-var createRule3 = ESLintUtils3.RuleCreator(
+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}.md`
 );
-var mdFilenameCaseRestriction = createRule3({
+var mdFilenameCaseRestriction = createRule4({
   name: "md-filename-case-restriction",
   meta: {
     type: "problem",
@@ -251,11 +343,11 @@ var md_filename_case_restriction_default = mdFilenameCaseRestriction;
 
 // src/rules/no-emoji.ts
 import emojiRegex from "emoji-regex";
-import { ESLintUtils as ESLintUtils4 } from "@typescript-eslint/utils";
-var createRule4 = ESLintUtils4.RuleCreator(
+import { 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}.md`
 );
-var noEmoji = createRule4({
+var noEmoji = createRule5({
   name: "no-emoji",
   meta: {
     type: "problem",
@@ -289,11 +381,11 @@ var noEmoji = createRule4({
 var no_emoji_default = noEmoji;
 
 // src/rules/no-explicit-return-type.ts
-import { ESLintUtils as ESLintUtils5 } from "@typescript-eslint/utils";
-var createRule5 = ESLintUtils5.RuleCreator(
+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}.md`
 );
-var noExplicitReturnType = createRule5({
+var noExplicitReturnType = createRule6({
   name: "no-explicit-return-type",
   meta: {
     type: "suggestion",
@@ -333,11 +425,11 @@ var noExplicitReturnType = createRule5({
 var no_explicit_return_type_default = noExplicitReturnType;
 
 // src/rules/prefer-destructuring-params.ts
-import { AST_NODE_TYPES, ESLintUtils as ESLintUtils6 } from "@typescript-eslint/utils";
-var createRule6 = ESLintUtils6.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES2, ESLintUtils as ESLintUtils7 } from "@typescript-eslint/utils";
+var createRule7 = ESLintUtils7.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name}.md`
 );
-var preferDestructuringParams = createRule6({
+var preferDestructuringParams = createRule7({
   name: "prefer-destructuring-params",
   meta: {
     type: "suggestion",
@@ -356,7 +448,7 @@ var preferDestructuringParams = createRule6({
         return;
       }
       const hasNonDestructuredParams = node.params.some(
-        (param) => param.type !== AST_NODE_TYPES.ObjectPattern && param.type !== AST_NODE_TYPES.RestElement
+        (param) => param.type !== AST_NODE_TYPES2.ObjectPattern && param.type !== AST_NODE_TYPES2.RestElement
       );
       if (hasNonDestructuredParams) {
         context.report({
@@ -375,11 +467,11 @@ var preferDestructuringParams = createRule6({
 var prefer_destructuring_params_default = preferDestructuringParams;
 
 // src/rules/prefer-import-type.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES2, ESLintUtils as ESLintUtils7 } from "@typescript-eslint/utils";
-var createRule7 = ESLintUtils7.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES3, 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}.md`
 );
-var preferImportType = createRule7({
+var preferImportType = createRule8({
   name: "prefer-import-type",
   meta: {
     type: "suggestion",
@@ -410,14 +502,14 @@ var preferImportType = createRule7({
         return;
       }
       const isTypeOnlyImport = node.specifiers.every((specifier) => {
-        if (specifier.type === AST_NODE_TYPES2.ImportDefaultSpecifier) {
+        if (specifier.type === AST_NODE_TYPES3.ImportDefaultSpecifier) {
           return false;
         }
-        if (specifier.type === AST_NODE_TYPES2.ImportNamespaceSpecifier) {
+        if (specifier.type === AST_NODE_TYPES3.ImportNamespaceSpecifier) {
           return false;
         }
-        if (specifier.type === AST_NODE_TYPES2.ImportSpecifier) {
-          const importedName = specifier.imported.type === AST_NODE_TYPES2.Identifier ? specifier.imported.name : specifier.imported.value;
+        if (specifier.type === AST_NODE_TYPES3.ImportSpecifier) {
+          const importedName = specifier.imported.type === AST_NODE_TYPES3.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");
@@ -445,11 +537,11 @@ var preferImportType = createRule7({
 var prefer_import_type_default = preferImportType;
 
 // src/rules/prefer-interface-over-inline-types.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES3, ESLintUtils as ESLintUtils8 } from "@typescript-eslint/utils";
-var createRule8 = ESLintUtils8.RuleCreator(
+import { AST_NODE_TYPES as AST_NODE_TYPES4, 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}.md`
 );
-var preferInterfaceOverInlineTypes = createRule8({
+var preferInterfaceOverInlineTypes = createRule9({
   name: "prefer-interface-over-inline-types",
   meta: {
     type: "suggestion",
@@ -465,54 +557,54 @@ var preferInterfaceOverInlineTypes = createRule8({
   defaultOptions: [],
   create(context) {
     function hasJSXInConditional(node) {
-      return node.consequent.type === AST_NODE_TYPES3.JSXElement || node.consequent.type === AST_NODE_TYPES3.JSXFragment || node.alternate.type === AST_NODE_TYPES3.JSXElement || node.alternate.type === AST_NODE_TYPES3.JSXFragment;
+      return node.consequent.type === AST_NODE_TYPES4.JSXElement || node.consequent.type === AST_NODE_TYPES4.JSXFragment || node.alternate.type === AST_NODE_TYPES4.JSXElement || node.alternate.type === AST_NODE_TYPES4.JSXFragment;
     }
     function hasJSXInLogical(node) {
-      return node.right.type === AST_NODE_TYPES3.JSXElement || node.right.type === AST_NODE_TYPES3.JSXFragment;
+      return node.right.type === AST_NODE_TYPES4.JSXElement || node.right.type === AST_NODE_TYPES4.JSXFragment;
     }
     function hasJSXReturn(block) {
       return block.body.some((stmt) => {
-        if (stmt.type === AST_NODE_TYPES3.ReturnStatement && stmt.argument) {
-          return stmt.argument.type === AST_NODE_TYPES3.JSXElement || stmt.argument.type === AST_NODE_TYPES3.JSXFragment || stmt.argument.type === AST_NODE_TYPES3.ConditionalExpression && hasJSXInConditional(stmt.argument) || stmt.argument.type === AST_NODE_TYPES3.LogicalExpression && hasJSXInLogical(stmt.argument);
+        if (stmt.type === AST_NODE_TYPES4.ReturnStatement && stmt.argument) {
+          return stmt.argument.type === AST_NODE_TYPES4.JSXElement || stmt.argument.type === AST_NODE_TYPES4.JSXFragment || stmt.argument.type === AST_NODE_TYPES4.ConditionalExpression && hasJSXInConditional(stmt.argument) || stmt.argument.type === AST_NODE_TYPES4.LogicalExpression && hasJSXInLogical(stmt.argument);
         }
         return false;
       });
     }
     function isReactComponent(node) {
-      if (node.type === AST_NODE_TYPES3.ArrowFunctionExpression) {
-        if (node.body.type === AST_NODE_TYPES3.JSXElement || node.body.type === AST_NODE_TYPES3.JSXFragment) {
+      if (node.type === AST_NODE_TYPES4.ArrowFunctionExpression) {
+        if (node.body.type === AST_NODE_TYPES4.JSXElement || node.body.type === AST_NODE_TYPES4.JSXFragment) {
           return true;
         }
-        if (node.body.type === AST_NODE_TYPES3.BlockStatement) {
+        if (node.body.type === AST_NODE_TYPES4.BlockStatement) {
           return hasJSXReturn(node.body);
         }
-      } else if (node.type === AST_NODE_TYPES3.FunctionExpression || node.type === AST_NODE_TYPES3.FunctionDeclaration) {
-        if (node.body && node.body.type === AST_NODE_TYPES3.BlockStatement) {
+      } else if (node.type === AST_NODE_TYPES4.FunctionExpression || node.type === AST_NODE_TYPES4.FunctionDeclaration) {
+        if (node.body && node.body.type === AST_NODE_TYPES4.BlockStatement) {
           return hasJSXReturn(node.body);
         }
       }
       return false;
     }
     function isInlineTypeAnnotation(node) {
-      if (node.type === AST_NODE_TYPES3.TSTypeLiteral) {
+      if (node.type === AST_NODE_TYPES4.TSTypeLiteral) {
         return true;
       }
-      if (node.type === AST_NODE_TYPES3.TSTypeReference && node.typeArguments) {
-        return node.typeArguments.params.some((param) => param.type === AST_NODE_TYPES3.TSTypeLiteral);
+      if (node.type === AST_NODE_TYPES4.TSTypeReference && node.typeArguments) {
+        return node.typeArguments.params.some((param) => param.type === AST_NODE_TYPES4.TSTypeLiteral);
       }
-      if (node.type === AST_NODE_TYPES3.TSUnionType) {
+      if (node.type === AST_NODE_TYPES4.TSUnionType) {
         return node.types.some((type) => isInlineTypeAnnotation(type));
       }
       return false;
     }
     function hasInlineObjectType(node) {
-      if (node.type === AST_NODE_TYPES3.TSTypeLiteral) {
+      if (node.type === AST_NODE_TYPES4.TSTypeLiteral) {
         return true;
       }
-      if (node.type === AST_NODE_TYPES3.TSTypeReference && node.typeArguments) {
-        return node.typeArguments.params.some((param) => param.type === AST_NODE_TYPES3.TSTypeLiteral);
+      if (node.type === AST_NODE_TYPES4.TSTypeReference && node.typeArguments) {
+        return node.typeArguments.params.some((param) => param.type === AST_NODE_TYPES4.TSTypeLiteral);
       }
-      if (node.type === AST_NODE_TYPES3.TSUnionType) {
+      if (node.type === AST_NODE_TYPES4.TSUnionType) {
         return node.types.some((type) => hasInlineObjectType(type));
       }
       return false;
@@ -525,7 +617,7 @@ var preferInterfaceOverInlineTypes = createRule8({
         return;
       }
       const param = node.params[0];
-      if (param.type === AST_NODE_TYPES3.Identifier && param.typeAnnotation) {
+      if (param.type === AST_NODE_TYPES4.Identifier && param.typeAnnotation) {
         const { typeAnnotation } = param.typeAnnotation;
         if (isInlineTypeAnnotation(typeAnnotation) && hasInlineObjectType(typeAnnotation)) {
           context.report({
@@ -545,11 +637,11 @@ var preferInterfaceOverInlineTypes = createRule8({
 var prefer_interface_over_inline_types_default = preferInterfaceOverInlineTypes;
 
 // src/rules/prefer-react-import-types.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES4, ESLintUtils as ESLintUtils9 } from "@typescript-eslint/utils";
-var createRule9 = ESLintUtils9.RuleCreator(
+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}.md`
 );
-var preferReactImportTypes = createRule9({
+var preferReactImportTypes = createRule10({
   name: "prefer-react-import-types",
   meta: {
     type: "suggestion",
@@ -625,7 +717,7 @@ var preferReactImportTypes = createRule9({
     ]);
     const allReactExports = /* @__PURE__ */ new Set([...reactTypes, ...reactRuntimeExports]);
     function checkMemberExpression(node) {
-      if (node.object.type === AST_NODE_TYPES4.Identifier && node.object.name === "React" && node.property.type === AST_NODE_TYPES4.Identifier && allReactExports.has(node.property.name)) {
+      if (node.object.type === AST_NODE_TYPES5.Identifier && node.object.name === "React" && node.property.type === AST_NODE_TYPES5.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"`;
@@ -642,7 +734,7 @@ var preferReactImportTypes = createRule9({
     return {
       MemberExpression: checkMemberExpression,
       "TSTypeReference > TSQualifiedName": (node) => {
-        if (node.left.type === AST_NODE_TYPES4.Identifier && node.left.name === "React" && node.right.type === AST_NODE_TYPES4.Identifier && allReactExports.has(node.right.name)) {
+        if (node.left.type === AST_NODE_TYPES5.Identifier && node.left.name === "React" && node.right.type === AST_NODE_TYPES5.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"`;
@@ -662,11 +754,11 @@ var preferReactImportTypes = createRule9({
 var prefer_react_import_types_default = preferReactImportTypes;
 
 // src/rules/react-props-destructure.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES5, ESLintUtils as ESLintUtils10 } from "@typescript-eslint/utils";
-var createRule10 = ESLintUtils10.RuleCreator(
+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}.md`
 );
-var reactPropsDestructure = createRule10({
+var reactPropsDestructure = createRule11({
   name: "react-props-destructure",
   meta: {
     type: "suggestion",
@@ -682,29 +774,29 @@ var reactPropsDestructure = createRule10({
   defaultOptions: [],
   create(context) {
     function hasJSXInConditional(node) {
-      return node.consequent.type === AST_NODE_TYPES5.JSXElement || node.consequent.type === AST_NODE_TYPES5.JSXFragment || node.alternate.type === AST_NODE_TYPES5.JSXElement || node.alternate.type === AST_NODE_TYPES5.JSXFragment;
+      return node.consequent.type === AST_NODE_TYPES6.JSXElement || node.consequent.type === AST_NODE_TYPES6.JSXFragment || node.alternate.type === AST_NODE_TYPES6.JSXElement || node.alternate.type === AST_NODE_TYPES6.JSXFragment;
     }
     function hasJSXInLogical(node) {
-      return node.right.type === AST_NODE_TYPES5.JSXElement || node.right.type === AST_NODE_TYPES5.JSXFragment;
+      return node.right.type === AST_NODE_TYPES6.JSXElement || node.right.type === AST_NODE_TYPES6.JSXFragment;
     }
     function hasJSXReturn(block) {
       return block.body.some((stmt) => {
-        if (stmt.type === AST_NODE_TYPES5.ReturnStatement && stmt.argument) {
-          return stmt.argument.type === AST_NODE_TYPES5.JSXElement || stmt.argument.type === AST_NODE_TYPES5.JSXFragment || stmt.argument.type === AST_NODE_TYPES5.ConditionalExpression && hasJSXInConditional(stmt.argument) || stmt.argument.type === AST_NODE_TYPES5.LogicalExpression && hasJSXInLogical(stmt.argument);
+        if (stmt.type === AST_NODE_TYPES6.ReturnStatement && stmt.argument) {
+          return stmt.argument.type === AST_NODE_TYPES6.JSXElement || stmt.argument.type === AST_NODE_TYPES6.JSXFragment || stmt.argument.type === AST_NODE_TYPES6.ConditionalExpression && hasJSXInConditional(stmt.argument) || stmt.argument.type === AST_NODE_TYPES6.LogicalExpression && hasJSXInLogical(stmt.argument);
         }
         return false;
       });
     }
     function isReactComponent(node) {
-      if (node.type === AST_NODE_TYPES5.ArrowFunctionExpression) {
-        if (node.body.type === AST_NODE_TYPES5.JSXElement || node.body.type === AST_NODE_TYPES5.JSXFragment) {
+      if (node.type === AST_NODE_TYPES6.ArrowFunctionExpression) {
+        if (node.body.type === AST_NODE_TYPES6.JSXElement || node.body.type === AST_NODE_TYPES6.JSXFragment) {
           return true;
         }
-        if (node.body.type === AST_NODE_TYPES5.BlockStatement) {
+        if (node.body.type === AST_NODE_TYPES6.BlockStatement) {
           return hasJSXReturn(node.body);
         }
-      } else if (node.type === AST_NODE_TYPES5.FunctionExpression || node.type === AST_NODE_TYPES5.FunctionDeclaration) {
-        if (node.body && node.body.type === AST_NODE_TYPES5.BlockStatement) {
+      } else if (node.type === AST_NODE_TYPES6.FunctionExpression || node.type === AST_NODE_TYPES6.FunctionDeclaration) {
+        if (node.body && node.body.type === AST_NODE_TYPES6.BlockStatement) {
           return hasJSXReturn(node.body);
         }
       }
@@ -718,9 +810,9 @@ var reactPropsDestructure = createRule10({
         return;
       }
       const param = node.params[0];
-      if (param.type === AST_NODE_TYPES5.ObjectPattern) {
-        const properties = param.properties.filter((prop) => prop.type === AST_NODE_TYPES5.Property).map((prop) => {
-          if (prop.key.type === AST_NODE_TYPES5.Identifier) {
+      if (param.type === AST_NODE_TYPES6.ObjectPattern) {
+        const properties = param.properties.filter((prop) => prop.type === AST_NODE_TYPES6.Property).map((prop) => {
+          if (prop.key.type === AST_NODE_TYPES6.Identifier) {
             return prop.key.name;
           }
           return null;
@@ -752,6 +844,7 @@ var meta = {
   version: package_default.version
 };
 var rules = {
+  "enforce-readonly-component-props": enforce_readonly_component_props_default,
   "file-kebab-case": file_kebab_case_default,
   "jsx-pascal-case": jsx_pascal_case_default,
   "md-filename-case-restriction": md_filename_case_restriction_default,
@@ -788,12 +881,14 @@ var baseRecommendedRules = {
 var jsxRules = {
   "nextfriday/jsx-pascal-case": "warn",
   "nextfriday/prefer-interface-over-inline-types": "warn",
-  "nextfriday/react-props-destructure": "warn"
+  "nextfriday/react-props-destructure": "warn",
+  "nextfriday/enforce-readonly-component-props": "warn"
 };
 var jsxRecommendedRules = {
   "nextfriday/jsx-pascal-case": "error",
   "nextfriday/prefer-interface-over-inline-types": "error",
-  "nextfriday/react-props-destructure": "error"
+  "nextfriday/react-props-destructure": "error",
+  "nextfriday/enforce-readonly-component-props": "error"
 };
 var createConfig = (configRules) => ({
   plugins: {