eslint-plugin-nextfriday 1.5.0 → 1.5.2

package/lib/index.cjs

@@ -1,1237 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  configs: () => configs,
-  default: () => index_default,
-  meta: () => meta,
-  rules: () => rules
-});
-module.exports = __toCommonJS(index_exports);
-
-// package.json
-var package_default = {
-  name: "eslint-plugin-nextfriday",
-  version: "1.5.0",
-  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",
-    preinstall: "npx only-allow pnpm",
-    prepare: "husky",
-    prepublishOnly: "pnpm run 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
-var import_utils = require("@typescript-eslint/utils");
-var createRule = import_utils.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 === import_utils.AST_NODE_TYPES.JSXElement || node.consequent.type === import_utils.AST_NODE_TYPES.JSXFragment || node.alternate.type === import_utils.AST_NODE_TYPES.JSXElement || node.alternate.type === import_utils.AST_NODE_TYPES.JSXFragment;
-    }
-    function hasJSXInLogical(node) {
-      return node.right.type === import_utils.AST_NODE_TYPES.JSXElement || node.right.type === import_utils.AST_NODE_TYPES.JSXFragment;
-    }
-    function hasJSXReturn(block) {
-      return block.body.some((stmt) => {
-        if (stmt.type === import_utils.AST_NODE_TYPES.ReturnStatement && stmt.argument) {
-          return stmt.argument.type === import_utils.AST_NODE_TYPES.JSXElement || stmt.argument.type === import_utils.AST_NODE_TYPES.JSXFragment || stmt.argument.type === import_utils.AST_NODE_TYPES.ConditionalExpression && hasJSXInConditional(stmt.argument) || stmt.argument.type === import_utils.AST_NODE_TYPES.LogicalExpression && hasJSXInLogical(stmt.argument);
-        }
-        return false;
-      });
-    }
-    function isReactComponent(node) {
-      if (node.type === import_utils.AST_NODE_TYPES.ArrowFunctionExpression) {
-        if (node.body.type === import_utils.AST_NODE_TYPES.JSXElement || node.body.type === import_utils.AST_NODE_TYPES.JSXFragment) {
-          return true;
-        }
-        if (node.body.type === import_utils.AST_NODE_TYPES.BlockStatement) {
-          return hasJSXReturn(node.body);
-        }
-      } else if (node.type === import_utils.AST_NODE_TYPES.FunctionExpression || node.type === import_utils.AST_NODE_TYPES.FunctionDeclaration) {
-        if (node.body && node.body.type === import_utils.AST_NODE_TYPES.BlockStatement) {
-          return hasJSXReturn(node.body);
-        }
-      }
-      return false;
-    }
-    function isNamedType(node) {
-      return node.type === import_utils.AST_NODE_TYPES.TSTypeReference;
-    }
-    function isAlreadyReadonly(node) {
-      if (node.type === import_utils.AST_NODE_TYPES.TSTypeReference && node.typeName) {
-        if (node.typeName.type === import_utils.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 === import_utils.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
-var import_path = __toESM(require("path"), 1);
-var import_utils2 = require("@typescript-eslint/utils");
-var createRule2 = import_utils2.ESLintUtils.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 = import_path.default.extname(filename);
-        if (ext !== ".ts" && ext !== ".js") {
-          return;
-        }
-        const basename = import_path.default.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
-var import_path2 = __toESM(require("path"), 1);
-var import_utils3 = require("@typescript-eslint/utils");
-var createRule3 = import_utils3.ESLintUtils.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 = import_path2.default.extname(filename);
-        if (ext !== ".jsx" && ext !== ".tsx") {
-          return;
-        }
-        const basename = import_path2.default.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
-var import_path3 = __toESM(require("path"), 1);
-var import_utils4 = require("@typescript-eslint/utils");
-var createRule4 = import_utils4.ESLintUtils.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 = import_path3.default.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
-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 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",
-    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 = (0, import_emoji_regex.default)();
-        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
-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_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 = 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
-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_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 = 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 === import_utils10.AST_NODE_TYPES.CallExpression;
-    };
-    const isDeveloperFunction = (node) => {
-      if (node.type === import_utils10.AST_NODE_TYPES.FunctionDeclaration) {
-        return true;
-      }
-      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_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;
-    };
-    const checkFunction = (node) => {
-      const { filename } = context;
-      if (filename.includes("node_modules") || filename.includes(".d.ts")) {
-        return;
-      }
-      if (!isDeveloperFunction(node)) {
-        return;
-      }
-      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;
-        }
-      }
-      if (node.params.length <= 1) {
-        return;
-      }
-      const hasNonDestructuredParams = node.params.some(
-        (param) => param.type !== import_utils10.AST_NODE_TYPES.ObjectPattern && param.type !== import_utils10.AST_NODE_TYPES.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
-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 = 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 === import_utils11.AST_NODE_TYPES.ImportDefaultSpecifier) {
-          return false;
-        }
-        if (specifier.type === import_utils11.AST_NODE_TYPES.ImportNamespaceSpecifier) {
-          return false;
-        }
-        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");
-          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
-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 = 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 === 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_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_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_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_utils12.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) {
-          return hasJSXReturn(node.body);
-        }
-      }
-      return false;
-    }
-    function isInlineTypeAnnotation(node) {
-      if (node.type === import_utils12.AST_NODE_TYPES.TSTypeLiteral) {
-        return true;
-      }
-      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_utils12.AST_NODE_TYPES.TSUnionType) {
-        return node.types.some((type) => isInlineTypeAnnotation(type));
-      }
-      return false;
-    }
-    function hasInlineObjectType(node) {
-      if (node.type === import_utils12.AST_NODE_TYPES.TSTypeLiteral) {
-        return true;
-      }
-      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_utils12.AST_NODE_TYPES.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 === import_utils12.AST_NODE_TYPES.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
-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 = 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 === import_utils13.AST_NODE_TYPES.AssignmentPattern) {
-        return hasInlineObjectType(param.left);
-      }
-      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_utils13.AST_NODE_TYPES.Identifier) {
-        if (param.typeAnnotation?.typeAnnotation.type === import_utils13.AST_NODE_TYPES.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
-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 = 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 === 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"`;
-        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 === 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"`;
-          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
-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 = 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 === 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_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_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_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_utils15.AST_NODE_TYPES.BlockStatement) {
-          return hasJSXReturn(node.body);
-        }
-      } 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);
-        }
-      }
-      return false;
-    }
-    function checkFunction(node) {
-      if (!isReactComponent(node)) {
-        return;
-      }
-      if (node.params.length !== 1) {
-        return;
-      }
-      const param = node.params[0];
-      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;
-        }).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;
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  configs,
-  meta,
-  rules
-});
-//# sourceMappingURL=index.cjs.map