eslint-plugin-functype 1.4.0 → 2.0.1

package/dist/index.js

@@ -1,1365 +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 types = /* @__PURE__ */ new Set();
-  const functions = /* @__PURE__ */ new Set();
-  const all = /* @__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") {
-            const name = spec.imported.name;
-            all.add(name);
-            if (["Option", "Either", "List", "LazyList", "Task", "Try"].includes(name)) {
-              types.add(name);
-            } else if (["Do", "DoAsync", "$"].includes(name)) {
-              functions.add(name);
-            } else {
-              functions.add(name);
-            }
-          } else if (spec.type === "ImportDefaultSpecifier") {
-            all.add("default");
-            functions.add("default");
-          } else if (spec.type === "ImportNamespaceSpecifier") {
-            all.add("*");
-            types.add("*");
-            functions.add("*");
-          }
-        }
-      }
-    }
-  }
-  return { types, functions, all };
-}
-function getFunctypeImportsLegacy(context) {
-  return getFunctypeImports(context).all;
-}
-function isFunctypeType(node, functypeImports) {
-  if (!node) return false;
-  const types = functypeImports instanceof Set ? functypeImports : functypeImports.types || functypeImports.all;
-  if (node.type === "TSTypeReference" && node.typeName?.type === "Identifier") {
-    const typeName = node.typeName.name;
-    return types.has(typeName) || ["Option", "Either", "List", "LazyList", "Task", "Try"].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;
-}
-function isChainedMethodCall(node, methodName) {
-  if (!node || node.type !== "CallExpression") return false;
-  const callee = node.callee;
-  if (callee.type === "MemberExpression" && callee.property.type === "Identifier" && callee.property.name === methodName) {
-    return true;
-  }
-  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 rule2 = {
-      meta: {
-        type: "suggestion",
-        docs: {
-          description: "Prefer Option<T> over nullable types (T | null | undefined)",
-          category: "Stylistic Issues",
-          recommended: true
-        },
-        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 = getFunctypeImportsLegacy(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
-                }
-              });
-            }
-          }
-        };
-      }
-    };
-    module.exports = rule2;
-  }
-});
-
-// src/rules/prefer-either.ts
-var require_prefer_either = __commonJS({
-  "src/rules/prefer-either.ts"(exports, module) {
-    var rule2 = {
-      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 = rule2;
-  }
-});
-
-// src/rules/prefer-list.ts
-var require_prefer_list = __commonJS({
-  "src/rules/prefer-list.ts"(exports, module) {
-    init_functype_detection();
-    var rule2 = {
-      meta: {
-        type: "suggestion",
-        docs: {
-          description: "Prefer List<T> over native arrays for immutable collections",
-          category: "Stylistic Issues",
-          recommended: true
-        },
-        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 = getFunctypeImportsLegacy(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
-              }
-            });
-          },
-          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
-                }
-              });
-            }
-            if (typeName === "ReadonlyArray") {
-              const typeParam = findTypeParameter(node, sourceCode);
-              const fullType = sourceCode.getText(node);
-              context.report({
-                node,
-                messageId: "preferList",
-                data: {
-                  type: typeParam || "T",
-                  arrayType: fullType
-                }
-              });
-            }
-          },
-          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"
-            });
-          }
-        };
-      }
-    };
-    module.exports = rule2;
-  }
-});
-
-// src/rules/no-get-unsafe.ts
-var require_no_get_unsafe = __commonJS({
-  "src/rules/no-get-unsafe.ts"(exports, module) {
-    var rule2 = {
-      meta: {
-        type: "problem",
-        docs: {
-          description: "Avoid unsafe .get() calls on Option, Either, and other monadic types",
-          category: "Possible Errors",
-          recommended: true
-        },
-        fixable: "code",
-        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 },
-                fix(fixer) {
-                  const sourceCode = context.sourceCode;
-                  const objectText = sourceCode.getText(node.callee.object);
-                  let replacement;
-                  if (methodName === "get") {
-                    replacement = `${objectText}.getOrElse(/* TODO: provide default value */)`;
-                  } else if (methodName === "getOrThrow") {
-                    replacement = `${objectText}.getOrElse(/* TODO: provide default value */)`;
-                  } else if (methodName === "unwrap") {
-                    replacement = `${objectText}.getOrElse(/* TODO: provide default value */)`;
-                  } else if (methodName === "expect") {
-                    replacement = `${objectText}.getOrElse(/* TODO: provide default value */)`;
-                  } else {
-                    replacement = `${objectText}.getOrElse(/* TODO: provide default value */)`;
-                  }
-                  return fixer.replaceText(node, replacement);
-                }
-              });
-            }
-          }
-        };
-      }
-    };
-    module.exports = rule2;
-  }
-});
-
-// src/rules/prefer-fold.ts
-var require_prefer_fold = __commonJS({
-  "src/rules/prefer-fold.ts"(exports, module) {
-    var rule2 = {
-      meta: {
-        type: "suggestion",
-        docs: {
-          description: "Prefer .fold() over if/else chains when working with monadic types",
-          category: "Best Practices",
-          recommended: true
-        },
-        fixable: "code",
-        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 extractBodyForFold(node, sourceCode) {
-          if (node.type === "BlockStatement") {
-            const statements = node.body;
-            if (statements.length === 1 && statements[0].type === "ReturnStatement") {
-              return sourceCode.getText(statements[0].argument);
-            } else {
-              return sourceCode.getText(node).slice(1, -1).trim();
-            }
-          } else {
-            return sourceCode.getText(node);
-          }
-        }
-        function generateFoldFromIf(node) {
-          const sourceCode = context.sourceCode;
-          if (node.type !== "IfStatement") return null;
-          const test = node.test;
-          const consequent = node.consequent;
-          const alternate = node.alternate;
-          if (!consequent || !alternate) return null;
-          let monadicObj = null;
-          let isNegated = false;
-          if (test.type === "CallExpression" && test.callee.type === "MemberExpression") {
-            const methodName = test.callee.property.name;
-            monadicObj = sourceCode.getText(test.callee.object);
-            if (methodName === "isSome" || methodName === "isRight" || methodName === "isSuccess") {
-              isNegated = false;
-            } else if (methodName === "isNone" || methodName === "isEmpty" || methodName === "isLeft" || methodName === "isFailure") {
-              isNegated = true;
-            }
-          }
-          if (!monadicObj) return null;
-          if (consequent.type === "BlockStatement") {
-            if (consequent.body.length !== 1 || consequent.body[0].type !== "ReturnStatement") {
-              return null;
-            }
-          }
-          if (alternate.type === "BlockStatement") {
-            if (alternate.body.length !== 1 || alternate.body[0].type !== "ReturnStatement") {
-              return null;
-            }
-          } else if (alternate.type === "IfStatement") {
-            return null;
-          }
-          const thenBody = extractBodyForFold(consequent, sourceCode);
-          const elseBody = extractBodyForFold(alternate, sourceCode);
-          if (isNegated) {
-            return `${monadicObj}.fold(() => ${thenBody}, () => ${elseBody})`;
-          } else {
-            return `${monadicObj}.fold(() => ${elseBody}, (value) => ${thenBody})`;
-          }
-        }
-        function generateFoldFromTernary(node) {
-          const sourceCode = context.sourceCode;
-          if (node.type !== "ConditionalExpression") return null;
-          const test = node.test;
-          const consequent = node.consequent;
-          const alternate = node.alternate;
-          let monadicObj = null;
-          let isNegated = false;
-          if (test.type === "CallExpression" && test.callee.type === "MemberExpression") {
-            const methodName = test.callee.property.name;
-            monadicObj = sourceCode.getText(test.callee.object);
-            if (methodName === "isSome" || methodName === "isRight" || methodName === "isSuccess") {
-              isNegated = false;
-            } else if (methodName === "isNone" || methodName === "isEmpty" || methodName === "isLeft" || methodName === "isFailure") {
-              isNegated = true;
-            }
-          }
-          if (!monadicObj) return null;
-          const thenExpr = sourceCode.getText(consequent);
-          const elseExpr = sourceCode.getText(alternate);
-          if (isNegated) {
-            return `${monadicObj}.fold(() => ${thenExpr}, () => ${elseExpr})`;
-          } else {
-            return `${monadicObj}.fold(() => ${elseExpr}, (value) => ${thenExpr})`;
-          }
-        }
-        function shouldAutoFix(node) {
-          if (node.type === "CallExpression" && node.callee.type === "MemberExpression") {
-            const methodName = node.callee.property.name;
-            return ["isSome", "isNone", "isEmpty", "isRight", "isLeft", "isSuccess", "isFailure"].includes(methodName);
-          }
-          return false;
-        }
-        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 },
-              fix(fixer) {
-                if (!shouldAutoFix(node.test)) {
-                  return null;
-                }
-                const replacement = generateFoldFromIf(node);
-                if (replacement) {
-                  return fixer.replaceText(node, replacement);
-                }
-                return null;
-              }
-            });
-          }
-        }
-        return {
-          IfStatement(node) {
-            analyzeIfStatement(node);
-          },
-          ConditionalExpression(node) {
-            const monadicInfo = isMonadicCheck(node.test);
-            if (monadicInfo.isMonadic) {
-              context.report({
-                node,
-                messageId: "preferFoldTernary",
-                data: { type: monadicInfo.type },
-                fix(fixer) {
-                  if (!shouldAutoFix(node.test)) {
-                    return null;
-                  }
-                  const replacement = generateFoldFromTernary(node);
-                  if (replacement) {
-                    return fixer.replaceText(node, replacement);
-                  }
-                  return null;
-                }
-              });
-            }
-          }
-        };
-      }
-    };
-    module.exports = rule2;
-  }
-});
-
-// src/rules/prefer-map.ts
-var require_prefer_map = __commonJS({
-  "src/rules/prefer-map.ts"(exports, module) {
-    var rule2 = {
-      meta: {
-        type: "suggestion",
-        docs: {
-          description: "Prefer .map() over manual transformations and imperative patterns",
-          category: "Best Practices",
-          recommended: true
-        },
-        fixable: "code",
-        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 isForEachToMapSafe(node) {
-          if (node.type !== "CallExpression" || node.callee.type !== "MemberExpression" || node.callee.property.name !== "forEach") {
-            return false;
-          }
-          const callback = node.arguments[0];
-          if (callback && (callback.type === "ArrowFunctionExpression" || callback.type === "FunctionExpression")) {
-            const body = callback.body;
-            return body.type === "MemberExpression";
-          }
-          return 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",
-                  fix(fixer) {
-                    if (!isForEachToMapSafe(node)) {
-                      return null;
-                    }
-                    const sourceCode = context.sourceCode;
-                    const text = sourceCode.getText(node);
-                    const fixedText = text.replace(/\.forEach\s*\(/g, ".map(");
-                    return fixer.replaceText(node, fixedText);
-                  }
-                });
-              }
-            }
-            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 = rule2;
-  }
-});
-
-// src/rules/prefer-flatmap.ts
-var require_prefer_flatmap = __commonJS({
-  "src/rules/prefer-flatmap.ts"(exports, module) {
-    var rule2 = {
-      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 = rule2;
-  }
-});
-
-// src/rules/no-imperative-loops.ts
-var require_no_imperative_loops = __commonJS({
-  "src/rules/no-imperative-loops.ts"(exports, module) {
-    var rule2 = {
-      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 = rule2;
-  }
-});
-
-// src/rules/prefer-do-notation.ts
-var rule, prefer_do_notation_default;
-var init_prefer_do_notation = __esm({
-  "src/rules/prefer-do-notation.ts"() {
-    init_functype_detection();
-    rule = {
-      meta: {
-        type: "suggestion",
-        docs: {
-          description: "Prefer Do notation for complex monadic compositions and nested operations",
-          category: "Best Practices",
-          recommended: true
-        },
-        fixable: "code",
-        messages: {
-          preferDoForNestedChecks: "Prefer Do notation for nested null/undefined checks instead of logical AND chains",
-          preferDoForChainedMethods: "Prefer Do notation for complex flatMap chains ({{count}} levels deep)",
-          preferDoForMixedMonads: "Consider Do notation when mixing Option, Either, and Try operations",
-          preferDoAsyncForChainedTasks: "Prefer DoAsync notation for chained async operations"
-        },
-        schema: [
-          {
-            type: "object",
-            properties: {
-              minChainDepth: {
-                type: "integer",
-                minimum: 2,
-                default: 3
-              },
-              detectMixedMonads: {
-                type: "boolean",
-                default: true
-              }
-            },
-            additionalProperties: false
-          }
-        ]
-      },
-      create(context) {
-        const options = context.options[0] || {};
-        const minChainDepth = options.minChainDepth || 3;
-        const detectMixedMonads = options.detectMixedMonads !== false;
-        const functypeImports = getFunctypeImports(context);
-        const hasDoImport = functypeImports.functions.has("Do") || functypeImports.functions.has("DoAsync");
-        function checkNestedNullChecks(node) {
-          if (node.operator !== "&&") return;
-          let depth = 0;
-          let current = node;
-          while (current.type === "LogicalExpression" && current.operator === "&&") {
-            if (current.right.type === "MemberExpression" || current.right.type === "LogicalExpression" && current.right.operator === "&&") {
-              depth++;
-            }
-            current = current.left;
-          }
-          if (depth >= 2 && hasNestedPropertyAccess(node)) {
-            context.report({
-              node,
-              messageId: "preferDoForNestedChecks",
-              fix: hasDoImport ? (fixer) => fixNestedChecks(fixer, node) : void 0
-            });
-          }
-        }
-        function hasNestedPropertyAccess(node) {
-          const text = context.sourceCode.getText(node);
-          const nestedPattern = /\w+(\.\w+){2,}/g;
-          const matches = text.match(nestedPattern);
-          return matches !== null && matches.length > 0;
-        }
-        function checkChainedMethods(node) {
-          if (!isChainedMethodCall(node, "flatMap")) return;
-          const chainDepth = getChainDepth(node);
-          if (chainDepth >= minChainDepth) {
-            context.report({
-              node,
-              messageId: "preferDoForChainedMethods",
-              data: { count: chainDepth.toString() },
-              fix: hasDoImport ? (fixer) => fixChainedMethods(fixer, node) : void 0
-            });
-          }
-        }
-        function getChainDepth(node) {
-          let depth = 1;
-          let current = node;
-          while (current.callee.type === "MemberExpression" && current.callee.object.type === "CallExpression") {
-            const method = current.callee.property;
-            if (method.type === "Identifier" && ["flatMap", "map", "filter", "fold"].includes(method.name)) {
-              depth++;
-            }
-            current = current.callee.object;
-          }
-          return depth;
-        }
-        function fixNestedChecks(fixer, node) {
-          const text = context.sourceCode.getText(node);
-          const match = text.match(/(\w+)(\.\w+)+/);
-          if (match) {
-            const baseVar = match[1];
-            const chain = match[0];
-            const doNotation = `Do(function* () {
-  const obj = yield* $(Option(${baseVar}))
-  return yield* $(Option(obj${chain.substring(baseVar.length)}))
-})`;
-            return fixer.replaceText(node, doNotation);
-          }
-          return fixer.replaceText(node, `/* TODO: Convert to Do notation */ ${text}`);
-        }
-        function fixChainedMethods(fixer, node) {
-          const text = context.sourceCode.getText(node);
-          return fixer.replaceText(node, `/* TODO: Consider Do notation for complex chains */ ${text}`);
-        }
-        function checkMixedMonads(node) {
-          if (!detectMixedMonads) return;
-          const text = context.sourceCode.getText(node);
-          const monadTypes = ["Option", "Either", "Try", "Task"];
-          const foundMonads = monadTypes.filter((type) => text.includes(type));
-          if (foundMonads.length >= 2) {
-            context.report({
-              node,
-              messageId: "preferDoForMixedMonads"
-            });
-          }
-        }
-        return {
-          LogicalExpression(node) {
-            checkNestedNullChecks(node);
-          },
-          CallExpression(node) {
-            checkChainedMethods(node);
-            checkMixedMonads(node);
-          }
-        };
-      }
-    };
-    prefer_do_notation_default = 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());
-    init_prefer_do_notation();
-    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,
-      "prefer-do-notation": prefer_do_notation_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"./configs/recommended.js";import t from"./configs/strict.js";import n from"./rules/index.js";const r={rules:n,meta:{name:`eslint-plugin-functype`,version:`2.0.0`},configs:{}};r.configs={recommended:{name:`functype-plugin/recommended`,plugins:{functype:r},rules:e},strict:{name:`functype-plugin/strict`,plugins:{functype:r},rules:t}};export{r as default};
 //# sourceMappingURL=index.js.map