eslint-plugin-functype 1.2.0 → 2.0.0

package/dist/index.js

@@ -1,1076 +1,2 @@
-'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 __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
-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.
-  !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-
-// src/utils/functype-detection.ts
-function getFunctypeImports(context) {
-  const imports = /* @__PURE__ */ new Set();
-  const sourceCode = context.sourceCode;
-  const program = sourceCode.ast;
-  for (const node of program.body) {
-    if (node.type === "ImportDeclaration" && node.source.type === "Literal" && node.source.value === "functype") {
-      if (node.specifiers) {
-        for (const spec of node.specifiers) {
-          if (spec.type === "ImportSpecifier" && spec.imported.type === "Identifier") {
-            imports.add(spec.imported.name);
-          } else if (spec.type === "ImportDefaultSpecifier") {
-            imports.add("default");
-          } else if (spec.type === "ImportNamespaceSpecifier") {
-            imports.add("*");
-          }
-        }
-      }
-    }
-  }
-  return imports;
-}
-function isFunctypeType(node, functypeImports) {
-  if (!node) return false;
-  if (node.type === "TSTypeReference" && node.typeName?.type === "Identifier") {
-    const typeName = node.typeName.name;
-    return functypeImports.has(typeName) || ["Option", "Either", "List", "LazyList", "Task"].includes(typeName);
-  }
-  return false;
-}
-function isFunctypeCall(node, functypeImports) {
-  if (!node || node.type !== "CallExpression") return false;
-  const callee = node.callee;
-  if (callee.type === "MemberExpression" && callee.object.type === "Identifier") {
-    const objectName = callee.object.name;
-    const methodName = callee.property?.name;
-    if (functypeImports.has(objectName)) return true;
-    if (objectName === "Option" && ["some", "none", "of"].includes(methodName) || objectName === "Either" && ["left", "right", "of"].includes(methodName) || objectName === "List" && ["of", "from", "empty"].includes(methodName)) {
-      return true;
-    }
-  }
-  if (callee.type === "MemberExpression") {
-    const methodName = callee.property?.name;
-    if ([
-      "map",
-      "flatMap",
-      "filter",
-      "fold",
-      "foldLeft",
-      "foldRight",
-      "getOrElse",
-      "orElse",
-      "isEmpty",
-      "nonEmpty",
-      "isDefined",
-      "isSome",
-      "isNone",
-      "isLeft",
-      "isRight",
-      "toArray"
-    ].includes(methodName)) {
-      return true;
-    }
-  }
-  return false;
-}
-function isAlreadyUsingFunctype(node, functypeImports) {
-  let parent = node.parent;
-  while (parent) {
-    if (isFunctypeCall(parent, functypeImports) || isFunctypeType(parent, functypeImports)) {
-      return true;
-    }
-    parent = parent.parent;
-  }
-  return false;
-}
-var init_functype_detection = __esm({
-  "src/utils/functype-detection.ts"() {
-  }
-});
-
-// src/rules/prefer-option.ts
-var require_prefer_option = __commonJS({
-  "src/rules/prefer-option.ts"(exports, module) {
-    init_functype_detection();
-    var rule = {
-      meta: {
-        type: "suggestion",
-        docs: {
-          description: "Prefer Option<T> over nullable types (T | null | undefined)",
-          category: "Stylistic Issues",
-          recommended: true
-        },
-        fixable: "code",
-        schema: [
-          {
-            type: "object",
-            properties: {
-              allowNullableIntersections: {
-                type: "boolean",
-                default: false
-              }
-            },
-            additionalProperties: false
-          }
-        ],
-        messages: {
-          preferOption: "Prefer Option<{{type}}> over nullable type '{{nullable}}'",
-          preferOptionReturn: "Prefer Option<{{type}}> as return type over nullable '{{nullable}}'"
-        }
-      },
-      create(context) {
-        const functypeImports = getFunctypeImports(context);
-        return {
-          TSUnionType(node) {
-            if (!node.types || node.types.length < 2) return;
-            const hasNull = node.types.some(
-              (type) => type.type === "TSNullKeyword" || type.type === "TSUndefinedKeyword"
-            );
-            if (!hasNull) return;
-            const nonNullTypes = node.types.filter(
-              (type) => type.type !== "TSNullKeyword" && type.type !== "TSUndefinedKeyword"
-            );
-            if (nonNullTypes.length === 1) {
-              const nonNullType = nonNullTypes[0];
-              if (isFunctypeType(nonNullType, functypeImports)) return;
-              if (isAlreadyUsingFunctype(node, functypeImports)) return;
-              const sourceCode = context.sourceCode;
-              const nonNullTypeText = sourceCode.getText(nonNullType);
-              const fullType = sourceCode.getText(node);
-              if (nonNullTypeText.startsWith("Option<")) return;
-              context.report({
-                node,
-                messageId: "preferOption",
-                data: {
-                  type: nonNullTypeText,
-                  nullable: fullType
-                },
-                fix(fixer) {
-                  return fixer.replaceText(node, `Option<${nonNullTypeText}>`);
-                }
-              });
-            }
-          }
-        };
-      }
-    };
-    module.exports = rule;
-  }
-});
-
-// src/rules/prefer-either.ts
-var require_prefer_either = __commonJS({
-  "src/rules/prefer-either.ts"(exports, module) {
-    var rule = {
-      meta: {
-        type: "suggestion",
-        docs: {
-          description: "Prefer Either<E, T> over try/catch blocks and throw statements",
-          category: "Best Practices",
-          recommended: true
-        },
-        schema: [
-          {
-            type: "object",
-            properties: {
-              allowThrowInTests: {
-                type: "boolean",
-                default: true
-              }
-            },
-            additionalProperties: false
-          }
-        ],
-        messages: {
-          preferEitherOverTryCatch: "Prefer Either<Error, T> over try/catch block",
-          preferEitherOverThrow: "Prefer Either.left(error) over throw statement",
-          preferEitherReturn: "Consider returning Either<Error, {{type}}> instead of throwing"
-        }
-      },
-      create(context) {
-        const options = context.options[0] || {};
-        const allowThrowInTests = options.allowThrowInTests !== false;
-        function isInTestFile() {
-          const filename = context.getFilename();
-          return /\.(test|spec)\.(ts|js|tsx|jsx)$/.test(filename) || filename.includes("__tests__") || filename.includes("/test/") || filename.includes("/tests/");
-        }
-        function hasThrowStatementsOutsideCatch(node) {
-          if (!node) return false;
-          if (node.type === "ThrowStatement") {
-            let parent = node.parent;
-            while (parent) {
-              if (parent.type === "CatchClause") return false;
-              parent = parent.parent;
-            }
-            return true;
-          }
-          if (node.type === "CatchClause") return false;
-          for (const key in node) {
-            if (key === "parent") continue;
-            const child = node[key];
-            if (Array.isArray(child)) {
-              for (const item of child) {
-                if (item && typeof item === "object" && hasThrowStatementsOutsideCatch(item)) {
-                  return true;
-                }
-              }
-            } else if (child && typeof child === "object" && hasThrowStatementsOutsideCatch(child)) {
-              return true;
-            }
-          }
-          return false;
-        }
-        return {
-          TryStatement(node) {
-            if (allowThrowInTests && isInTestFile()) return;
-            if (node.handler && node.handler.body) {
-              const catchBody = node.handler.body.body;
-              const hasRethrow = catchBody.some((stmt) => stmt.type === "ThrowStatement");
-              if (hasRethrow) return;
-            }
-            context.report({
-              node,
-              messageId: "preferEitherOverTryCatch"
-            });
-          },
-          ThrowStatement(node) {
-            if (allowThrowInTests && isInTestFile()) return;
-            let parent = node.parent;
-            while (parent) {
-              if (parent.type === "CatchClause") return;
-              parent = parent.parent;
-            }
-            context.report({
-              node,
-              messageId: "preferEitherOverThrow"
-            });
-          },
-          FunctionDeclaration(node) {
-            if (allowThrowInTests && isInTestFile()) return;
-            if (!node.body) return;
-            const hasThrowsNotInCatch = hasThrowStatementsOutsideCatch(node.body);
-            if (hasThrowsNotInCatch) {
-              const returnType = node.returnType?.typeAnnotation;
-              if (returnType) {
-                const sourceCode = context.sourceCode;
-                const returnTypeText = sourceCode.getText(returnType);
-                if (!returnTypeText.includes("Either")) {
-                  context.report({
-                    node: node.id || node,
-                    messageId: "preferEitherReturn",
-                    data: { type: returnTypeText }
-                  });
-                }
-              }
-            }
-          }
-        };
-      }
-    };
-    module.exports = rule;
-  }
-});
-
-// src/rules/prefer-list.ts
-var require_prefer_list = __commonJS({
-  "src/rules/prefer-list.ts"(exports, module) {
-    init_functype_detection();
-    var rule = {
-      meta: {
-        type: "suggestion",
-        docs: {
-          description: "Prefer List<T> over native arrays for immutable collections",
-          category: "Stylistic Issues",
-          recommended: true
-        },
-        fixable: "code",
-        schema: [
-          {
-            type: "object",
-            properties: {
-              allowArraysInTests: {
-                type: "boolean",
-                default: true
-              },
-              allowReadonlyArrays: {
-                type: "boolean",
-                default: true
-              }
-            },
-            additionalProperties: false
-          }
-        ],
-        messages: {
-          preferList: "Prefer List<{{type}}> over array type {{arrayType}}",
-          preferListLiteral: "Prefer List.of(...) or List.from([...]) over array literal"
-        }
-      },
-      create(context) {
-        const options = context.options[0] || {};
-        const allowArraysInTests = options.allowArraysInTests !== false;
-        const allowReadonlyArrays = options.allowReadonlyArrays !== false;
-        const functypeImports = getFunctypeImports(context);
-        function isInTestFile() {
-          const filename = context.getFilename();
-          return /\.(test|spec)\.(ts|js|tsx|jsx)$/.test(filename) || filename.includes("__tests__") || filename.includes("/test/") || filename.includes("/tests/");
-        }
-        function findTypeParameter(node, sourceCode) {
-          function findInNode(n) {
-            if (n.type === "TSTypeParameterInstantiation" && n.params && n.params[0]) {
-              return sourceCode.getText(n.params[0]);
-            }
-            for (const key in n) {
-              if (key === "parent") continue;
-              const child = n[key];
-              if (Array.isArray(child)) {
-                for (const item of child) {
-                  if (item && typeof item === "object" && item.type) {
-                    const result = findInNode(item);
-                    if (result) return result;
-                  }
-                }
-              } else if (child && typeof child === "object" && child.type) {
-                const result = findInNode(child);
-                if (result) return result;
-              }
-            }
-            return null;
-          }
-          return findInNode(node);
-        }
-        return {
-          TSArrayType(node) {
-            if (allowArraysInTests && isInTestFile()) return;
-            const sourceCode = context.sourceCode;
-            const elementType = sourceCode.getText(node.elementType);
-            const fullType = sourceCode.getText(node);
-            context.report({
-              node,
-              messageId: "preferList",
-              data: {
-                type: elementType,
-                arrayType: fullType
-              },
-              fix(fixer) {
-                return fixer.replaceText(node, `List<${elementType}>`);
-              }
-            });
-          },
-          TSTypeReference(node) {
-            if (allowArraysInTests && isInTestFile()) return;
-            const sourceCode = context.sourceCode;
-            let typeName = "";
-            if (node.typeName && node.typeName.type === "Identifier") {
-              typeName = node.typeName.name;
-            } else if (node.typeName) {
-              typeName = sourceCode.getText(node.typeName);
-            } else {
-              return;
-            }
-            if (typeName === "Array") {
-              const typeParam = findTypeParameter(node, sourceCode);
-              const fullType = sourceCode.getText(node);
-              if (allowReadonlyArrays && fullType.startsWith("readonly")) return;
-              context.report({
-                node,
-                messageId: "preferList",
-                data: {
-                  type: typeParam || "T",
-                  arrayType: fullType
-                },
-                fix(fixer) {
-                  return fixer.replaceText(node, `List<${typeParam || "T"}>`);
-                }
-              });
-            }
-            if (typeName === "ReadonlyArray") {
-              const typeParam = findTypeParameter(node, sourceCode);
-              const fullType = sourceCode.getText(node);
-              context.report({
-                node,
-                messageId: "preferList",
-                data: {
-                  type: typeParam || "T",
-                  arrayType: fullType
-                },
-                fix(fixer) {
-                  return fixer.replaceText(node, `List<${typeParam || "T"}>`);
-                }
-              });
-            }
-          },
-          ArrayExpression(node) {
-            if (allowArraysInTests && isInTestFile()) return;
-            if (node.elements.length === 0) return;
-            let parent = node.parent;
-            if (parent && isFunctypeCall(parent, functypeImports)) {
-              return;
-            }
-            if (parent && parent.type === "CallExpression" && parent.callee.type === "MemberExpression" && parent.callee.object.type === "Identifier" && parent.callee.object.name === "List" && ["from", "of"].includes(parent.callee.property.name)) {
-              return;
-            }
-            parent = node.parent;
-            while (parent) {
-              if (parent.type === "ArrayExpression") {
-                return;
-              }
-              parent = parent.parent;
-            }
-            let hasTypeAnnotation = false;
-            parent = node.parent;
-            while (parent) {
-              if (parent.type === "VariableDeclarator" && parent.id?.typeAnnotation) {
-                hasTypeAnnotation = true;
-                break;
-              }
-              if (parent.type === "TSTypeAnnotation") {
-                hasTypeAnnotation = true;
-                break;
-              }
-              parent = parent.parent;
-            }
-            if (hasTypeAnnotation) return;
-            context.report({
-              node,
-              messageId: "preferListLiteral",
-              fix(fixer) {
-                const sourceCode = context.sourceCode;
-                const elements = sourceCode.getText(node);
-                return fixer.replaceText(node, `List.from(${elements})`);
-              }
-            });
-          }
-        };
-      }
-    };
-    module.exports = rule;
-  }
-});
-
-// src/rules/no-get-unsafe.ts
-var require_no_get_unsafe = __commonJS({
-  "src/rules/no-get-unsafe.ts"(exports, module) {
-    var rule = {
-      meta: {
-        type: "problem",
-        docs: {
-          description: "Avoid unsafe .get() calls on Option, Either, and other monadic types",
-          category: "Possible Errors",
-          recommended: true
-        },
-        schema: [
-          {
-            type: "object",
-            properties: {
-              allowInTests: {
-                type: "boolean",
-                default: true
-              },
-              unsafeMethods: {
-                type: "array",
-                items: { type: "string" },
-                default: ["get", "getOrThrow", "unwrap", "expect"]
-              }
-            },
-            additionalProperties: false
-          }
-        ],
-        messages: {
-          noUnsafeGet: "Avoid unsafe .{{method}}() call. Use .fold(), .map(), or .getOrElse() instead",
-          noUnsafeGetSuggestion: "Consider using .getOrElse(defaultValue) or .fold() for safe access"
-        }
-      },
-      create(context) {
-        const options = context.options[0] || {};
-        const allowInTests = options.allowInTests !== false;
-        const unsafeMethods = options.unsafeMethods || ["get", "getOrThrow", "unwrap", "expect"];
-        function isInTestFile() {
-          const filename = context.getFilename();
-          return /\.(test|spec)\.(ts|js|tsx|jsx)$/.test(filename) || filename.includes("__tests__") || filename.includes("/test/") || filename.includes("/tests/");
-        }
-        function isMonadicType(node) {
-          if (!node) return false;
-          const sourceCode = context.sourceCode;
-          const text = sourceCode.getText(node);
-          if (/\b(Option|Either|Maybe|Result|Some|None|Left|Right)\b/.test(text)) {
-            return true;
-          }
-          if (/\.(map|flatMap|filter|fold)\s*\(/.test(text)) {
-            return true;
-          }
-          if (/\b(option|either|maybe|result|some|none|left|right)\w*\b/i.test(text)) {
-            return true;
-          }
-          if (node.type === "Identifier") {
-            const varName = node.name.toLowerCase();
-            if (/(option|either|maybe|result|some|none|left|right|opt)/.test(varName)) {
-              return true;
-            }
-          }
-          if (node.type === "CallExpression" && node.callee.type === "MemberExpression" && node.callee.object) {
-            return isMonadicType(node.callee.object);
-          }
-          return false;
-        }
-        return {
-          CallExpression(node) {
-            if (allowInTests && isInTestFile()) return;
-            if (node.callee.type !== "MemberExpression") return;
-            const property = node.callee.property;
-            if (!property || property.type !== "Identifier") return;
-            const methodName = property.name;
-            if (!unsafeMethods.includes(methodName)) return;
-            if (isMonadicType(node.callee.object)) {
-              context.report({
-                node,
-                messageId: "noUnsafeGet",
-                data: { method: methodName }
-              });
-            }
-          }
-        };
-      }
-    };
-    module.exports = rule;
-  }
-});
-
-// src/rules/prefer-fold.ts
-var require_prefer_fold = __commonJS({
-  "src/rules/prefer-fold.ts"(exports, module) {
-    var rule = {
-      meta: {
-        type: "suggestion",
-        docs: {
-          description: "Prefer .fold() over if/else chains when working with monadic types",
-          category: "Best Practices",
-          recommended: true
-        },
-        schema: [
-          {
-            type: "object",
-            properties: {
-              minComplexity: {
-                type: "integer",
-                minimum: 1,
-                default: 2
-              }
-            },
-            additionalProperties: false
-          }
-        ],
-        messages: {
-          preferFold: "Prefer .fold() over if/else when working with {{type}} types",
-          preferFoldTernary: "Consider using .fold() instead of ternary operator for {{type}}"
-        }
-      },
-      create(context) {
-        const options = context.options[0] || {};
-        const minComplexity = options.minComplexity || 2;
-        function isMonadicCheck(node) {
-          const sourceCode = context.sourceCode;
-          const text = sourceCode.getText(node);
-          if (/\.(isSome|isNone|isEmpty|isDefined)\s*\(\s*\)/.test(text)) {
-            return { isMonadic: true, type: "Option" };
-          }
-          if (/\.(isLeft|isRight)\s*\(\s*\)/.test(text)) {
-            return { isMonadic: true, type: "Either" };
-          }
-          if (/\.(isSuccess|isFailure)\s*\(\s*\)/.test(text)) {
-            return { isMonadic: true, type: "Result" };
-          }
-          if (node.type === "BinaryExpression") {
-            if ((node.operator === "===" || node.operator === "!==") && (node.left.type === "Literal" && (node.left.value === null || node.left.value === void 0) || node.right.type === "Literal" && (node.right.value === null || node.right.value === void 0))) {
-              return { isMonadic: true, type: "Option" };
-            }
-            if (node.operator === "==" || node.operator === "!=" || node.operator === "===" || node.operator === "!==") {
-              const leftIsUndefined = node.left.type === "Identifier" && node.left.name === "undefined" || node.left.type === "Literal" && node.left.value === void 0;
-              const rightIsUndefined = node.right.type === "Identifier" && node.right.name === "undefined" || node.right.type === "Literal" && node.right.value === void 0;
-              if (leftIsUndefined || rightIsUndefined) {
-                return { isMonadic: true, type: "Option" };
-              }
-            }
-          }
-          return { isMonadic: false, type: "" };
-        }
-        function analyzeIfStatement(node) {
-          const test = node.test;
-          const monadicInfo = isMonadicCheck(test);
-          if (!monadicInfo.isMonadic) return;
-          if (node.parent && node.parent.type === "IfStatement") return;
-          let complexity = 1;
-          let current = node;
-          while (current.alternate) {
-            complexity++;
-            if (current.alternate.type === "IfStatement") {
-              current = current.alternate;
-            } else {
-              break;
-            }
-          }
-          if (complexity >= minComplexity) {
-            context.report({
-              node,
-              messageId: "preferFold",
-              data: { type: monadicInfo.type }
-            });
-          }
-        }
-        return {
-          IfStatement(node) {
-            analyzeIfStatement(node);
-          },
-          ConditionalExpression(node) {
-            const monadicInfo = isMonadicCheck(node.test);
-            if (monadicInfo.isMonadic) {
-              context.report({
-                node,
-                messageId: "preferFoldTernary",
-                data: { type: monadicInfo.type }
-              });
-            }
-          }
-        };
-      }
-    };
-    module.exports = rule;
-  }
-});
-
-// src/rules/prefer-map.ts
-var require_prefer_map = __commonJS({
-  "src/rules/prefer-map.ts"(exports, module) {
-    var rule = {
-      meta: {
-        type: "suggestion",
-        docs: {
-          description: "Prefer .map() over manual transformations and imperative patterns",
-          category: "Best Practices",
-          recommended: true
-        },
-        schema: [
-          {
-            type: "object",
-            properties: {
-              checkArrayMethods: {
-                type: "boolean",
-                default: true
-              },
-              checkForLoops: {
-                type: "boolean",
-                default: true
-              }
-            },
-            additionalProperties: false
-          }
-        ],
-        messages: {
-          preferMapOverLoop: "Prefer .map() over for loop for transforming {{collection}}",
-          preferMapOverPush: "Prefer .map() over manual .push() in loop",
-          preferMapChain: "Consider using .map() for transformation instead of manual property access"
-        }
-      },
-      create(context) {
-        const options = context.options[0] || {};
-        const checkArrayMethods = options.checkArrayMethods !== false;
-        const checkForLoops = options.checkForLoops !== false;
-        function isTransformationLoop(node) {
-          if (!node.body || node.body.type !== "BlockStatement") return false;
-          const statements = node.body.body;
-          if (statements.length === 0) return false;
-          return statements.some((stmt) => {
-            if (stmt.type === "ExpressionStatement" && stmt.expression.type === "CallExpression") {
-              const call = stmt.expression;
-              return call.callee.type === "MemberExpression" && call.callee.property.name === "push";
-            }
-            return false;
-          });
-        }
-        function isSimplePropertyAccess(node) {
-          if (node.type === "CallExpression" && node.callee.type === "MemberExpression" && node.callee.property.name === "forEach") {
-            const callback = node.arguments[0];
-            if (callback && (callback.type === "ArrowFunctionExpression" || callback.type === "FunctionExpression")) {
-              const body = callback.body;
-              if (body.type === "MemberExpression") {
-                return true;
-              }
-            }
-          }
-          return false;
-        }
-        return {
-          ForStatement(node) {
-            if (!checkForLoops) return;
-            if (isTransformationLoop(node)) {
-              context.report({
-                node,
-                messageId: "preferMapOverLoop",
-                data: { collection: "array" }
-              });
-            }
-          },
-          ForInStatement(node) {
-            if (!checkForLoops) return;
-            if (isTransformationLoop(node)) {
-              context.report({
-                node,
-                messageId: "preferMapOverLoop",
-                data: { collection: "object" }
-              });
-            }
-          },
-          ForOfStatement(node) {
-            if (!checkForLoops) return;
-            if (isTransformationLoop(node)) {
-              context.report({
-                node,
-                messageId: "preferMapOverLoop",
-                data: { collection: "iterable" }
-              });
-            }
-          },
-          CallExpression(node) {
-            if (!checkArrayMethods) return;
-            if (node.callee.type === "MemberExpression" && node.callee.property.name === "forEach") {
-              if (isSimplePropertyAccess(node)) {
-                context.report({
-                  node,
-                  messageId: "preferMapChain"
-                });
-              }
-            }
-            if (node.callee.type === "MemberExpression" && node.callee.property.name === "push") {
-              let parent = node.parent;
-              while (parent) {
-                if (parent.type === "CallExpression" && parent.callee.type === "MemberExpression" && (parent.callee.property.name === "forEach" || parent.callee.property.name === "for")) {
-                  context.report({
-                    node,
-                    messageId: "preferMapOverPush"
-                  });
-                  break;
-                }
-                parent = parent.parent;
-              }
-            }
-          }
-        };
-      }
-    };
-    module.exports = rule;
-  }
-});
-
-// src/rules/prefer-flatmap.ts
-var require_prefer_flatmap = __commonJS({
-  "src/rules/prefer-flatmap.ts"(exports, module) {
-    var rule = {
-      meta: {
-        type: "suggestion",
-        docs: {
-          description: "Prefer .flatMap() over .map().flat() and nested transformations",
-          category: "Best Practices",
-          recommended: true
-        },
-        fixable: "code",
-        schema: [
-          {
-            type: "object",
-            properties: {
-              checkNestedMaps: {
-                type: "boolean",
-                default: true
-              }
-            },
-            additionalProperties: false
-          }
-        ],
-        messages: {
-          preferFlatMapOverMapFlat: "Use .flatMap() instead of .map().flat()",
-          preferFlatMapNested: "Consider .flatMap() for nested transformations that return arrays",
-          preferFlatMapChain: "Use .flatMap() instead of chained .map() operations that flatten results"
-        }
-      },
-      create(context) {
-        const options = context.options[0] || {};
-        const checkNestedMaps = options.checkNestedMaps !== false;
-        function isMapFollowedByFlat(node) {
-          if (node.type !== "CallExpression") return false;
-          const callee = node.callee;
-          if (callee.type !== "MemberExpression") return false;
-          if (callee.property.name === "flat") {
-            const object = callee.object;
-            if (object.type === "CallExpression" && object.callee.type === "MemberExpression" && object.callee.property.name === "map") {
-              return true;
-            }
-          }
-          return false;
-        }
-        function returnsArray(functionNode) {
-          if (!functionNode || !functionNode.body) return false;
-          if (functionNode.body.type === "ArrayExpression") {
-            return true;
-          }
-          if (functionNode.body.type === "CallExpression") {
-            const call = functionNode.body;
-            if (call.callee.type === "MemberExpression") {
-              const methodName = call.callee.property.name;
-              if (["map", "filter", "slice", "concat", "split"].includes(methodName)) {
-                return true;
-              }
-            }
-          }
-          if (functionNode.body.type === "BlockStatement") {
-            const statements = functionNode.body.body;
-            for (const stmt of statements) {
-              if (stmt.type === "ReturnStatement" && stmt.argument) {
-                if (stmt.argument.type === "ArrayExpression") {
-                  return true;
-                }
-                if (stmt.argument.type === "CallExpression") {
-                  const call = stmt.argument;
-                  if (call.callee.type === "MemberExpression") {
-                    const methodName = call.callee.property.name;
-                    if (["map", "filter", "slice", "concat", "split"].includes(methodName)) {
-                      return true;
-                    }
-                  }
-                }
-              }
-            }
-          }
-          return false;
-        }
-        function isNestedMapReturningArrays(node) {
-          if (node.type !== "CallExpression") return false;
-          const callee = node.callee;
-          if (callee.type !== "MemberExpression") return false;
-          if (callee.property.name === "map") {
-            const callback = node.arguments[0];
-            if (callback && (callback.type === "ArrowFunctionExpression" || callback.type === "FunctionExpression")) {
-              return returnsArray(callback);
-            }
-          }
-          return false;
-        }
-        return {
-          CallExpression(node) {
-            if (isMapFollowedByFlat(node)) {
-              const sourceCode = context.sourceCode;
-              context.report({
-                node,
-                messageId: "preferFlatMapOverMapFlat",
-                fix(fixer) {
-                  const mapCall = node.callee.object;
-                  const mapCallText = sourceCode.getText(mapCall);
-                  const flatMapText = mapCallText.replace(/\.map\s*\(/, ".flatMap(");
-                  return fixer.replaceText(node, flatMapText);
-                }
-              });
-              return;
-            }
-            if (node.callee.type === "MemberExpression" && node.callee.property.name === "map") {
-              const object = node.callee.object;
-              if (object.type === "CallExpression" && object.callee.type === "MemberExpression" && object.callee.property.name === "map") {
-                const firstMapCallback = object.arguments[0];
-                if (firstMapCallback && returnsArray(firstMapCallback)) {
-                  context.report({
-                    node: object,
-                    // Report on the first map call
-                    messageId: "preferFlatMapChain"
-                  });
-                  return;
-                }
-              }
-            }
-            if (checkNestedMaps && isNestedMapReturningArrays(node)) {
-              if (node.parent && node.parent.type === "MemberExpression" && node.parent.parent && node.parent.parent.type === "CallExpression" && node.parent.property.name === "flat") {
-                return;
-              }
-              const object = node.callee?.object;
-              if (object?.type === "CallExpression" && object.callee?.type === "MemberExpression" && object.callee?.property?.name === "map") {
-                return;
-              }
-              if (node.parent?.type === "MemberExpression" && node.parent.parent?.type === "CallExpression" && node.parent.parent.callee?.property?.name === "map") {
-                return;
-              }
-              context.report({
-                node,
-                messageId: "preferFlatMapNested"
-              });
-            }
-          }
-        };
-      }
-    };
-    module.exports = rule;
-  }
-});
-
-// src/rules/no-imperative-loops.ts
-var require_no_imperative_loops = __commonJS({
-  "src/rules/no-imperative-loops.ts"(exports, module) {
-    var rule = {
-      meta: {
-        type: "suggestion",
-        docs: {
-          description: "Prefer functional iteration methods over imperative for loops",
-          category: "Best Practices",
-          recommended: true
-        },
-        schema: [
-          {
-            type: "object",
-            properties: {
-              allowForIndexAccess: {
-                type: "boolean",
-                default: false
-              },
-              allowWhileLoops: {
-                type: "boolean",
-                default: false
-              },
-              allowInTests: {
-                type: "boolean",
-                default: true
-              }
-            },
-            additionalProperties: false
-          }
-        ],
-        messages: {
-          noForLoop: "Prefer functional methods (.map, .filter, .forEach, .reduce) over for loops",
-          noForInLoop: "Prefer Object.keys().forEach() or functional methods over for..in loops",
-          noForOfLoop: "Prefer .forEach() or .map() over for..of loops",
-          noWhileLoop: "Prefer functional iteration or recursion over while loops",
-          noDoWhileLoop: "Prefer functional iteration or recursion over do..while loops",
-          suggestFunctional: "Consider: {{suggestion}}"
-        }
-      },
-      create(context) {
-        const options = context.options[0] || {};
-        const allowForIndexAccess = options.allowForIndexAccess || false;
-        const allowWhileLoops = options.allowWhileLoops || false;
-        const allowInTests = options.allowInTests !== false;
-        function isInTestFile() {
-          const filename = context.getFilename();
-          return /\.(test|spec)\.(ts|js|tsx|jsx)$/.test(filename) || filename.includes("__tests__") || filename.includes("/test/") || filename.includes("/tests/");
-        }
-        function needsIndexAccess(node) {
-          if (!node.body || node.body.type !== "BlockStatement") return false;
-          const sourceCode = context.sourceCode;
-          const bodyText = sourceCode.getText(node.body);
-          return /\[\s*\w+\s*\]/.test(bodyText) && node.init && node.init.type === "VariableDeclaration";
-        }
-        return {
-          ForStatement(node) {
-            if (allowInTests && isInTestFile()) return;
-            if (allowForIndexAccess && needsIndexAccess(node)) return;
-            context.report({
-              node,
-              messageId: "noForLoop"
-            });
-          },
-          ForInStatement(node) {
-            if (allowInTests && isInTestFile()) return;
-            context.report({
-              node,
-              messageId: "noForInLoop"
-            });
-          },
-          ForOfStatement(node) {
-            if (allowInTests && isInTestFile()) return;
-            context.report({
-              node,
-              messageId: "noForOfLoop"
-            });
-          },
-          WhileStatement(node) {
-            if (allowWhileLoops) return;
-            if (allowInTests && isInTestFile()) return;
-            context.report({
-              node,
-              messageId: "noWhileLoop"
-            });
-          },
-          DoWhileStatement(node) {
-            if (allowWhileLoops) return;
-            if (allowInTests && isInTestFile()) return;
-            context.report({
-              node,
-              messageId: "noDoWhileLoop"
-            });
-          }
-        };
-      }
-    };
-    module.exports = rule;
-  }
-});
-
-// src/rules/index.ts
-var import_prefer_option, import_prefer_either, import_prefer_list, import_no_get_unsafe, import_prefer_fold, import_prefer_map, import_prefer_flatmap, import_no_imperative_loops, rules_default;
-var init_rules = __esm({
-  "src/rules/index.ts"() {
-    import_prefer_option = __toESM(require_prefer_option());
-    import_prefer_either = __toESM(require_prefer_either());
-    import_prefer_list = __toESM(require_prefer_list());
-    import_no_get_unsafe = __toESM(require_no_get_unsafe());
-    import_prefer_fold = __toESM(require_prefer_fold());
-    import_prefer_map = __toESM(require_prefer_map());
-    import_prefer_flatmap = __toESM(require_prefer_flatmap());
-    import_no_imperative_loops = __toESM(require_no_imperative_loops());
-    rules_default = {
-      "prefer-option": import_prefer_option.default,
-      "prefer-either": import_prefer_either.default,
-      "prefer-list": import_prefer_list.default,
-      "no-get-unsafe": import_no_get_unsafe.default,
-      "prefer-fold": import_prefer_fold.default,
-      "prefer-map": import_prefer_map.default,
-      "prefer-flatmap": import_prefer_flatmap.default,
-      "no-imperative-loops": import_no_imperative_loops.default
-    };
-  }
-});
-
-// src/index.ts
-var require_src = __commonJS({
-  "src/index.ts"(exports, module) {
-    init_rules();
-    var plugin = {
-      rules: rules_default,
-      // Meta information
-      meta: {
-        name: "eslint-plugin-functype",
-        version: "2.0.0"
-      }
-    };
-    module.exports = plugin;
-  }
-});
-var index = require_src();
-
-module.exports = index;
-//# sourceMappingURL=index.js.map
+import e from"./rules/index.js";const t={rules:e,meta:{name:`eslint-plugin-functype`,version:`2.0.0`}};export{t as default};
 //# sourceMappingURL=index.js.map