eslint-plugin-nextfriday 1.5.2 → 1.5.3

package/lib/index.js

@@ -0,0 +1,1197 @@
+// package.json
+var package_default = {
+  name: "eslint-plugin-nextfriday",
+  version: "1.5.3",
+  description: "A comprehensive ESLint plugin providing custom rules and configurations for Next Friday development workflows.",
+  keywords: [
+    "eslint",
+    "eslintplugin",
+    "eslint-plugin",
+    "nextfriday",
+    "next-friday",
+    "linting",
+    "code-quality",
+    "javascript",
+    "typescript",
+    "development-tools"
+  ],
+  homepage: "https://github.com/next-friday/eslint-plugin-nextfriday",
+  bugs: {
+    url: "https://github.com/next-friday/eslint-plugin-nextfriday/issues"
+  },
+  repository: {
+    type: "git",
+    url: "https://github.com/next-friday/eslint-plugin-nextfriday.git"
+  },
+  license: "MIT",
+  author: "Next Friday <nextfriday.developer@gmail.com>",
+  contributors: [
+    "@joetakara"
+  ],
+  type: "module",
+  exports: {
+    ".": {
+      types: "./lib/index.d.ts",
+      import: "./lib/index.js",
+      require: "./lib/index.cjs"
+    }
+  },
+  main: "lib/index.js",
+  types: "lib/index.d.ts",
+  files: [
+    "LICENSE",
+    "README.md",
+    "CHANGELOG.md",
+    "docs",
+    "lib"
+  ],
+  scripts: {
+    build: "tsup",
+    changeset: "changeset",
+    "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 --fix",
+    "eslint:check": "eslint src --ext .js,.ts",
+    prepare: "husky",
+    prepublishOnly: "pnpm build",
+    prettier: "prettier --write .",
+    "prettier:check": "prettier --check .",
+    "sort-package-json": "pnpm exec sort-package-json",
+    "sort-package-json:check": "pnpm exec sort-package-json --check",
+    test: "jest",
+    "test:coverage": "jest --coverage",
+    "test:watch": "jest --watch",
+    typecheck: "tsc --noEmit"
+  },
+  dependencies: {
+    "@typescript-eslint/utils": "^8.42.0",
+    "emoji-regex": "^10.5.0",
+    tsup: "^8.5.0"
+  },
+  devDependencies: {
+    "@changesets/changelog-github": "^0.5.1",
+    "@changesets/cli": "^2.29.6",
+    "@commitlint/cli": "^19.8.1",
+    "@commitlint/config-conventional": "^19.8.1",
+    "@eslint/js": "^9.35.0",
+    "@jest/globals": "^30.1.2",
+    "@stylistic/eslint-plugin": "^3.1.0",
+    "@swc/core": "^1.13.5",
+    "@types/eslint": "^9.6.1",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^22.5.4",
+    "@types/ramda": "^0.31.0",
+    "@typescript-eslint/parser": "^8.42.0",
+    "@typescript-eslint/rule-tester": "^8.42.0",
+    eslint: "^9.35.0",
+    "eslint-config-airbnb-extended": "^2.2.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-import-resolver-typescript": "^4.4.4",
+    "eslint-plugin-import-x": "^4.16.1",
+    "eslint-plugin-jest": "^29.0.1",
+    "eslint-plugin-prettier": "^5.5.4",
+    "eslint-plugin-sonarjs": "^3.0.5",
+    husky: "^9.1.7",
+    jest: "^29.7.0",
+    "lint-staged": "^16.1.6",
+    prettier: "^3.6.2",
+    "sort-package-json": "^3.4.0",
+    "ts-jest": "^29.4.1",
+    "ts-node": "^10.9.2",
+    typescript: "^5.6.2",
+    "typescript-eslint": "^8.42.0"
+  },
+  peerDependencies: {
+    eslint: "^9.0.0"
+  },
+  packageManager: "pnpm@9.12.0",
+  engines: {
+    node: ">=22.0.0",
+    pnpm: ">=9.0.0"
+  },
+  publishConfig: {
+    access: "public"
+  }
+};
+
+// 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`
+);
+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 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`
+);
+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)) {
+    return /^[a-z0-9]+(?:-[a-z0-9]+)*(?:\.[a-z0-9]+(?:-[a-z0-9]+)*)*$/.test(str);
+  }
+  return /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(str);
+};
+var fileKebabCase = createRule2({
+  name: "file-kebab-case",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Enforce kebab-case filenames for .ts and .js files"
+    },
+    messages: {
+      fileKebabCase: "File names must be kebab-case"
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      Program() {
+        const { filename } = context;
+        const ext = path.extname(filename);
+        if (ext !== ".ts" && ext !== ".js") {
+          return;
+        }
+        const basename = path.basename(filename, ext);
+        if (!isKebabCase(basename)) {
+          context.report({
+            loc: { line: 1, column: 0 },
+            messageId: "fileKebabCase"
+          });
+        }
+      }
+    };
+  }
+});
+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`
+);
+var isPascalCase = (str) => /^[A-Z][a-zA-Z0-9]*$/.test(str) && !/^[A-Z]+$/.test(str);
+var jsxPascalCase = createRule3({
+  name: "jsx-pascal-case",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Enforce PascalCase filenames for .jsx and .tsx files"
+    },
+    messages: {
+      jsxPascalCase: "JSX/TSX file names must be PascalCase"
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      Program() {
+        const { filename } = context;
+        const ext = path2.extname(filename);
+        if (ext !== ".jsx" && ext !== ".tsx") {
+          return;
+        }
+        const basename = path2.basename(filename, ext);
+        if (!isPascalCase(basename)) {
+          context.report({
+            loc: { line: 1, column: 0 },
+            messageId: "jsxPascalCase"
+          });
+        }
+      }
+    };
+  }
+});
+var jsx_pascal_case_default = jsxPascalCase;
+
+// 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`
+);
+var mdFilenameCaseRestriction = createRule4({
+  name: "md-filename-case-restriction",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Enforce .md filenames to be SNAKE_CASE only"
+    },
+    messages: {
+      invalidFilenameCase: "Markdown filename must be SNAKE_CASE (UPPERCASE with underscores). Found: '{{ filename }}'"
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      Program() {
+        const { filename } = context;
+        if (!filename.endsWith(".md")) {
+          return;
+        }
+        const basename = path3.basename(filename, ".md");
+        function isSnakeCase(text) {
+          return /^[A-Z][A-Z0-9_]*$/.test(text);
+        }
+        function isValidCase(text) {
+          return isSnakeCase(text);
+        }
+        if (!isValidCase(basename)) {
+          context.report({
+            node: context.sourceCode.ast,
+            messageId: "invalidFilenameCase",
+            data: { filename: basename }
+          });
+        }
+      }
+    };
+  }
+});
+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`
+);
+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 === AST_NODE_TYPES2.ConditionalExpression) {
+        return true;
+      }
+      if (node.type === AST_NODE_TYPES2.LogicalExpression) {
+        return true;
+      }
+      if (node.type === AST_NODE_TYPES2.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
+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`
+);
+var noEmoji = createRule6({
+  name: "no-emoji",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow emoji characters in source code"
+    },
+    messages: {
+      noEmoji: "Emoji are not allowed in source code"
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    const { sourceCode } = context;
+    return {
+      Program() {
+        const text = sourceCode.getText();
+        const regex = emojiRegex();
+        const matches = Array.from(text.matchAll(regex));
+        matches.forEach((match) => {
+          const loc = sourceCode.getLocFromIndex(match.index);
+          context.report({
+            loc,
+            messageId: "noEmoji"
+          });
+        });
+      }
+    };
+  }
+});
+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`
+);
+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 !== AST_NODE_TYPES3.MemberExpression) {
+        return false;
+      }
+      const { object } = node;
+      if (object.type !== AST_NODE_TYPES3.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 {
+      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
+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`
+);
+var noExplicitReturnType = createRule8({
+  name: "no-explicit-return-type",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Disallow explicit return types on functions"
+    },
+    fixable: "code",
+    schema: [],
+    messages: {
+      noExplicitReturnType: "Remove explicit return type '{{returnType}}' - TypeScript can infer it automatically"
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    const checkFunction = (node) => {
+      if (node.returnType) {
+        const returnTypeText = context.sourceCode.getText(node.returnType);
+        context.report({
+          node: node.returnType,
+          messageId: "noExplicitReturnType",
+          data: {
+            returnType: returnTypeText
+          },
+          fix(fixer) {
+            return fixer.remove(node.returnType);
+          }
+        });
+      }
+    };
+    return {
+      FunctionDeclaration: checkFunction,
+      FunctionExpression: checkFunction,
+      ArrowFunctionExpression: checkFunction
+    };
+  }
+});
+var no_explicit_return_type_default = noExplicitReturnType;
+
+// 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`
+);
+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 === AST_NODE_TYPES4.SpreadElement) {
+        return false;
+      }
+      if (node.type === AST_NODE_TYPES4.ConditionalExpression) {
+        return true;
+      }
+      if (node.type === AST_NODE_TYPES4.LogicalExpression) {
+        return true;
+      }
+      if (node.type === AST_NODE_TYPES4.BinaryExpression) {
+        const logicalOperators = ["==", "===", "!=", "!==", "<", ">", "<=", ">=", "in", "instanceof"];
+        return logicalOperators.includes(node.operator);
+      }
+      if (node.type === AST_NODE_TYPES4.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
+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`
+);
+var preferDestructuringParams = createRule10({
+  name: "prefer-destructuring-params",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Enforce destructuring for functions with multiple parameters"
+    },
+    messages: {
+      preferDestructuring: "Functions with multiple parameters should use destructuring"
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    const isCallbackFunction = (node) => {
+      const { parent } = node;
+      return parent?.type === AST_NODE_TYPES5.CallExpression;
+    };
+    const isDeveloperFunction = (node) => {
+      if (node.type === AST_NODE_TYPES5.FunctionDeclaration) {
+        return true;
+      }
+      if (node.type === AST_NODE_TYPES5.FunctionExpression || node.type === AST_NODE_TYPES5.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 false;
+    };
+    const checkFunction = (node) => {
+      const { filename } = context;
+      if (filename.includes("node_modules") || filename.includes(".d.ts")) {
+        return;
+      }
+      if (!isDeveloperFunction(node)) {
+        return;
+      }
+      if (node.type === AST_NODE_TYPES5.FunctionDeclaration && node.id) {
+        const functionName = node.id.name;
+        if (functionName.startsWith("_") || functionName.includes("$") || /^[A-Z][a-zA-Z]*$/.test(functionName)) {
+          return;
+        }
+      }
+      if (node.params.length <= 1) {
+        return;
+      }
+      const hasNonDestructuredParams = node.params.some(
+        (param) => param.type !== AST_NODE_TYPES5.ObjectPattern && param.type !== AST_NODE_TYPES5.RestElement
+      );
+      if (hasNonDestructuredParams) {
+        context.report({
+          node,
+          messageId: "preferDestructuring"
+        });
+      }
+    };
+    return {
+      FunctionDeclaration: checkFunction,
+      FunctionExpression: checkFunction,
+      ArrowFunctionExpression: checkFunction
+    };
+  }
+});
+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`
+);
+var preferImportType = createRule11({
+  name: "prefer-import-type",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Enforce using 'import type' for type-only imports"
+    },
+    fixable: "code",
+    schema: [],
+    messages: {
+      preferImportType: "Use 'import type' for type-only imports"
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    function checkImportDeclaration(node) {
+      if (node.importKind === "type") {
+        return;
+      }
+      if (context.filename.includes(".test.") || context.filename.includes(".spec.") || context.filename.includes("__tests__")) {
+        return;
+      }
+      if (node.specifiers.length === 0) {
+        return;
+      }
+      const source = node.source.value;
+      const isRuntimeImport = /\.(css|scss|sass|less|styl)(\?.*)?$/.test(source) || /\.(png|jpg|jpeg|gif|svg|webp|ico|bmp)(\?.*)?$/.test(source) || /\.(woff|woff2|ttf|eot|otf)(\?.*)?$/.test(source) || /\.(mp4|webm|ogg|mp3|wav|flac|aac)(\?.*)?$/.test(source) || /\.(json|txt|md|xml|yml|yaml)(\?.*)?$/.test(source) || /^next\/(font|image|link|head|script|dynamic|router)/.test(source) || source.includes("/font/") || source === "react-dom" || source === "react-dom/client" || source === "react-dom/server" || source.startsWith("@emotion/") || source.startsWith("styled-components") || source.includes("polyfill") || source.includes("shim") || source === "styled-jsx/css" || source.startsWith("webpack/");
+      if (isRuntimeImport) {
+        return;
+      }
+      const isTypeOnlyImport = node.specifiers.every((specifier) => {
+        if (specifier.type === AST_NODE_TYPES6.ImportDefaultSpecifier) {
+          return false;
+        }
+        if (specifier.type === AST_NODE_TYPES6.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;
+        }
+        return false;
+      });
+      if (isTypeOnlyImport) {
+        context.report({
+          node,
+          messageId: "preferImportType",
+          fix(fixer) {
+            const sourceText = context.sourceCode.getText(node);
+            const fixedSource = sourceText.replace(/^import\s+/, "import type ");
+            return fixer.replaceText(node, fixedSource);
+          }
+        });
+      }
+    }
+    return {
+      ImportDeclaration: checkImportDeclaration
+    };
+  }
+});
+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`
+);
+var preferInterfaceOverInlineTypes = createRule12({
+  name: "prefer-interface-over-inline-types",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Enforce interface declarations over inline type annotations for React component props"
+    },
+    fixable: void 0,
+    schema: [],
+    messages: {
+      useInterface: "Use interface declaration for component props instead of inline type annotation"
+    }
+  },
+  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;
+    }
+    function hasJSXInLogical(node) {
+      return node.right.type === AST_NODE_TYPES7.JSXElement || node.right.type === AST_NODE_TYPES7.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);
+        }
+        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) {
+          return true;
+        }
+        if (node.body.type === AST_NODE_TYPES7.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) {
+          return hasJSXReturn(node.body);
+        }
+      }
+      return false;
+    }
+    function isInlineTypeAnnotation(node) {
+      if (node.type === AST_NODE_TYPES7.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_TYPES7.TSUnionType) {
+        return node.types.some((type) => isInlineTypeAnnotation(type));
+      }
+      return false;
+    }
+    function hasInlineObjectType(node) {
+      if (node.type === AST_NODE_TYPES7.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_TYPES7.TSUnionType) {
+        return node.types.some((type) => hasInlineObjectType(type));
+      }
+      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_TYPES7.Identifier && param.typeAnnotation) {
+        const { typeAnnotation } = param.typeAnnotation;
+        if (isInlineTypeAnnotation(typeAnnotation) && hasInlineObjectType(typeAnnotation)) {
+          context.report({
+            node: param.typeAnnotation,
+            messageId: "useInterface"
+          });
+        }
+      }
+    }
+    return {
+      ArrowFunctionExpression: checkFunction,
+      FunctionExpression: checkFunction,
+      FunctionDeclaration: checkFunction
+    };
+  }
+});
+var prefer_interface_over_inline_types_default = preferInterfaceOverInlineTypes;
+
+// 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`
+);
+var preferNamedParamTypes = createRule13({
+  name: "prefer-named-param-types",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Enforce named interfaces/types instead of inline object types for function parameters"
+    },
+    messages: {
+      preferNamedParamTypes: "Use a named interface or type for object parameter types instead of inline type annotations"
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    function hasInlineObjectType(param) {
+      if (param.type === AST_NODE_TYPES8.AssignmentPattern) {
+        return hasInlineObjectType(param.left);
+      }
+      if (param.type === AST_NODE_TYPES8.ObjectPattern) {
+        if (param.typeAnnotation?.typeAnnotation.type === AST_NODE_TYPES8.TSTypeLiteral) {
+          return true;
+        }
+      }
+      if (param.type === AST_NODE_TYPES8.Identifier) {
+        if (param.typeAnnotation?.typeAnnotation.type === AST_NODE_TYPES8.TSTypeLiteral) {
+          return true;
+        }
+      }
+      return false;
+    }
+    function checkFunction(node) {
+      let params = [];
+      if ("params" in node) {
+        params = node.params;
+      } else if ("value" in node && node.value) {
+        params = node.value.params;
+      }
+      params.forEach((param) => {
+        if (hasInlineObjectType(param)) {
+          context.report({
+            node: param,
+            messageId: "preferNamedParamTypes"
+          });
+        }
+      });
+    }
+    return {
+      FunctionDeclaration: checkFunction,
+      FunctionExpression: checkFunction,
+      ArrowFunctionExpression: checkFunction,
+      TSMethodSignature: checkFunction,
+      MethodDefinition: checkFunction
+    };
+  }
+});
+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`
+);
+var preferReactImportTypes = createRule14({
+  name: "prefer-react-import-types",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Enforce importing React types and utilities from 'react' instead of using React.X"
+    },
+    fixable: "code",
+    schema: [],
+    messages: {
+      preferDirectImport: "Use direct import '{{importStatement}}' instead of 'React.{{typeName}}'"
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    const reactTypes = /* @__PURE__ */ new Set([
+      "ReactNode",
+      "ReactElement",
+      "ReactChildren",
+      "ReactChild",
+      "ComponentType",
+      "FC",
+      "FunctionComponent",
+      "Component",
+      "PureComponent",
+      "ReactEventHandler",
+      "MouseEventHandler",
+      "ChangeEventHandler",
+      "FormEventHandler",
+      "KeyboardEventHandler",
+      "TouchEventHandler",
+      "PointerEventHandler",
+      "FocusEventHandler",
+      "UIEventHandler",
+      "WheelEventHandler",
+      "AnimationEventHandler",
+      "TransitionEventHandler",
+      "RefObject",
+      "MutableRefObject",
+      "Ref",
+      "ForwardedRef",
+      "HTMLProps",
+      "ComponentProps",
+      "JSXElementConstructor"
+    ]);
+    const reactRuntimeExports = /* @__PURE__ */ new Set([
+      "useState",
+      "useEffect",
+      "useContext",
+      "useReducer",
+      "useCallback",
+      "useMemo",
+      "useRef",
+      "useImperativeHandle",
+      "useLayoutEffect",
+      "useDebugValue",
+      "useDeferredValue",
+      "useTransition",
+      "useId",
+      "useSyncExternalStore",
+      "useInsertionEffect",
+      "createElement",
+      "createContext",
+      "forwardRef",
+      "memo",
+      "lazy",
+      "Suspense",
+      "Fragment",
+      "StrictMode",
+      "createRef",
+      "isValidElement",
+      "cloneElement",
+      "Children"
+    ]);
+    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)) {
+        const typeName = node.property.name;
+        const isType = reactTypes.has(typeName);
+        const importStatement = isType ? `import type { ${typeName} } from "react"` : `import { ${typeName} } from "react"`;
+        context.report({
+          node,
+          messageId: "preferDirectImport",
+          data: { typeName, importStatement },
+          fix(fixer) {
+            return fixer.replaceText(node, typeName);
+          }
+        });
+      }
+    }
+    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)) {
+          const typeName = node.right.name;
+          const isType = reactTypes.has(typeName);
+          const importStatement = isType ? `import type { ${typeName} } from "react"` : `import { ${typeName} } from "react"`;
+          context.report({
+            node,
+            messageId: "preferDirectImport",
+            data: { typeName, importStatement },
+            fix(fixer) {
+              return fixer.replaceText(node, typeName);
+            }
+          });
+        }
+      }
+    };
+  }
+});
+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`
+);
+var reactPropsDestructure = createRule15({
+  name: "react-props-destructure",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Enforce destructuring props inside React component body instead of parameters"
+    },
+    fixable: void 0,
+    schema: [],
+    messages: {
+      noParameterDestructuring: "Destructure props inside component body instead of parameters. Use 'const { {{properties}} } = props;'"
+    }
+  },
+  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;
+    }
+    function hasJSXInLogical(node) {
+      return node.right.type === AST_NODE_TYPES10.JSXElement || node.right.type === AST_NODE_TYPES10.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);
+        }
+        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) {
+          return true;
+        }
+        if (node.body.type === AST_NODE_TYPES10.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) {
+          return hasJSXReturn(node.body);
+        }
+      }
+      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_TYPES10.ObjectPattern) {
+        const properties = param.properties.filter((prop) => prop.type === AST_NODE_TYPES10.Property).map((prop) => {
+          if (prop.key.type === AST_NODE_TYPES10.Identifier) {
+            return prop.key.name;
+          }
+          return null;
+        }).filter((name) => name !== null);
+        if (properties.length === 0) {
+          return;
+        }
+        context.report({
+          node: param,
+          messageId: "noParameterDestructuring",
+          data: {
+            properties: properties.join(", ")
+          }
+        });
+      }
+    }
+    return {
+      ArrowFunctionExpression: checkFunction,
+      FunctionExpression: checkFunction,
+      FunctionDeclaration: checkFunction
+    };
+  }
+});
+var react_props_destructure_default = reactPropsDestructure;
+
+// src/index.ts
+var meta = {
+  name: package_default.name,
+  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,
+  "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,
+  "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
+};
+var plugin = {
+  meta,
+  rules
+};
+var baseRules = {
+  "nextfriday/no-emoji": "warn",
+  "nextfriday/file-kebab-case": "warn",
+  "nextfriday/md-filename-case-restriction": "warn",
+  "nextfriday/prefer-destructuring-params": "warn",
+  "nextfriday/no-explicit-return-type": "warn",
+  "nextfriday/prefer-import-type": "warn",
+  "nextfriday/prefer-named-param-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",
+  "nextfriday/file-kebab-case": "error",
+  "nextfriday/md-filename-case-restriction": "error",
+  "nextfriday/prefer-destructuring-params": "error",
+  "nextfriday/no-explicit-return-type": "error",
+  "nextfriday/prefer-import-type": "error",
+  "nextfriday/prefer-named-param-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",
+  "nextfriday/prefer-interface-over-inline-types": "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/enforce-readonly-component-props": "error"
+};
+var createConfig = (configRules) => ({
+  plugins: {
+    nextfriday: plugin
+  },
+  rules: configRules
+});
+var configs = {
+  base: createConfig(baseRules),
+  "base/recommended": createConfig(baseRecommendedRules),
+  react: createConfig({
+    ...baseRules,
+    ...jsxRules
+  }),
+  "react/recommended": createConfig({
+    ...baseRecommendedRules,
+    ...jsxRecommendedRules
+  }),
+  nextjs: createConfig({
+    ...baseRules,
+    ...jsxRules
+  }),
+  "nextjs/recommended": createConfig({
+    ...baseRecommendedRules,
+    ...jsxRecommendedRules
+  })
+};
+var nextfridayPlugin = {
+  meta,
+  configs,
+  rules
+};
+var index_default = nextfridayPlugin;
+export {
+  configs,
+  index_default as default,
+  meta,
+  rules
+};
+//# sourceMappingURL=index.js.map