eslint-plugin-functype 1.4.0 → 2.0.1

package/dist/rules/prefer-map.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-map.js","names":[],"sources":["../../src/rules/prefer-map.ts"],"sourcesContent":["import type { Rule } from \"eslint\"\n\nimport type { ASTNode } from \"../types/ast\"\n\nconst rule: Rule.RuleModule = {\n  meta: {\n    type: \"suggestion\",\n    docs: {\n      description: \"Prefer .map() over manual transformations and imperative patterns\",\n      recommended: true,\n    },\n    fixable: \"code\",\n    schema: [\n      {\n        type: \"object\",\n        properties: {\n          checkArrayMethods: {\n            type: \"boolean\",\n            default: true,\n          },\n          checkForLoops: {\n            type: \"boolean\",\n            default: true,\n          },\n        },\n        additionalProperties: false,\n      },\n    ],\n    messages: {\n      preferMapOverLoop: \"Prefer .map() over for loop for transforming {{collection}}\",\n      preferMapOverPush: \"Prefer .map() over manual .push() in loop\",\n      preferMapChain: \"Consider using .map() for transformation instead of manual property access\",\n    },\n  },\n\n  create(context) {\n    const options = context.options[0] || {}\n    const checkArrayMethods = options.checkArrayMethods !== false\n    const checkForLoops = options.checkForLoops !== false\n\n    function isForEachToMapSafe(node: ASTNode): boolean {\n      // Only auto-fix simple forEach → map transformations on expressions that return values\n      // This is safe because both native arrays and functype Lists have these methods\n      if (\n        node.type !== \"CallExpression\" ||\n        node.callee.type !== \"MemberExpression\" ||\n        node.callee.property.name !== \"forEach\"\n      ) {\n        return false\n      }\n\n      // Check if the callback returns a value (simple property access pattern)\n      const callback = node.arguments[0]\n      if (callback && (callback.type === \"ArrowFunctionExpression\" || callback.type === \"FunctionExpression\")) {\n        const body = callback.body\n        // Simple property access in arrow function (e.g., item => item.name)\n        return body.type === \"MemberExpression\"\n      }\n      return false\n    }\n\n    function isTransformationLoop(node: ASTNode): boolean {\n      if (!node.body || node.body.type !== \"BlockStatement\") return false\n\n      const statements = node.body.body\n      if (statements.length === 0) return false\n\n      // Look for patterns like: newArray.push(transform(item))\n      return statements.some((stmt: ASTNode) => {\n        if (stmt.type === \"ExpressionStatement\" && stmt.expression.type === \"CallExpression\") {\n          const call = stmt.expression\n          return call.callee.type === \"MemberExpression\" && call.callee.property.name === \"push\"\n        }\n        return false\n      })\n    }\n\n    function isSimplePropertyAccess(node: ASTNode): boolean {\n      // Check for patterns like: items.forEach(item => console.log(item.name))\n      // These could often be: items.map(item => item.name)\n      if (\n        node.type === \"CallExpression\" &&\n        node.callee.type === \"MemberExpression\" &&\n        node.callee.property.name === \"forEach\"\n      ) {\n        const callback = node.arguments[0]\n        if (callback && (callback.type === \"ArrowFunctionExpression\" || callback.type === \"FunctionExpression\")) {\n          const body = callback.body\n          // Simple property access in arrow function\n          if (body.type === \"MemberExpression\") {\n            return true\n          }\n        }\n      }\n      return false\n    }\n\n    return {\n      ForStatement(node: ASTNode) {\n        if (!checkForLoops) return\n\n        if (isTransformationLoop(node)) {\n          context.report({\n            node,\n            messageId: \"preferMapOverLoop\",\n            data: { collection: \"array\" },\n          })\n        }\n      },\n\n      ForInStatement(node: ASTNode) {\n        if (!checkForLoops) return\n\n        if (isTransformationLoop(node)) {\n          context.report({\n            node,\n            messageId: \"preferMapOverLoop\",\n            data: { collection: \"object\" },\n          })\n        }\n      },\n\n      ForOfStatement(node: ASTNode) {\n        if (!checkForLoops) return\n\n        if (isTransformationLoop(node)) {\n          context.report({\n            node,\n            messageId: \"preferMapOverLoop\",\n            data: { collection: \"iterable\" },\n          })\n        }\n      },\n\n      CallExpression(node: ASTNode) {\n        if (!checkArrayMethods) return\n\n        // Check for forEach that could be map\n        if (node.callee.type === \"MemberExpression\" && node.callee.property.name === \"forEach\") {\n          if (isSimplePropertyAccess(node)) {\n            context.report({\n              node,\n              messageId: \"preferMapChain\",\n              fix(fixer) {\n                // Only auto-fix safe forEach → map transformations\n                if (!isForEachToMapSafe(node)) {\n                  return null\n                }\n\n                const sourceCode = context.sourceCode\n                const text = sourceCode.getText(node)\n\n                // Simple replacement: forEach -> map\n                const fixedText = text.replace(/\\.forEach\\s*\\(/g, \".map(\")\n                return fixer.replaceText(node, fixedText)\n              },\n            })\n          }\n        }\n\n        // Check for manual push patterns in callbacks\n        if (node.callee.type === \"MemberExpression\" && node.callee.property.name === \"push\") {\n          // Check if we're inside a forEach or similar iteration\n          let parent = node.parent\n          while (parent) {\n            if (\n              parent.type === \"CallExpression\" &&\n              parent.callee.type === \"MemberExpression\" &&\n              (parent.callee.property.name === \"forEach\" || parent.callee.property.name === \"for\")\n            ) {\n              context.report({\n                node,\n                messageId: \"preferMapOverPush\",\n              })\n              break\n            }\n            parent = parent.parent\n          }\n        }\n      },\n    }\n  },\n}\n\nexport default rule\n"],"mappings":"AAIA,MAAM,EAAwB,CAC5B,KAAM,CACJ,KAAM,aACN,KAAM,CACJ,YAAa,oEACb,YAAa,GACd,CACD,QAAS,OACT,OAAQ,CACN,CACE,KAAM,SACN,WAAY,CACV,kBAAmB,CACjB,KAAM,UACN,QAAS,GACV,CACD,cAAe,CACb,KAAM,UACN,QAAS,GACV,CACF,CACD,qBAAsB,GACvB,CACF,CACD,SAAU,CACR,kBAAmB,8DACnB,kBAAmB,4CACnB,eAAgB,6EACjB,CACF,CAED,OAAO,EAAS,CACd,IAAM,EAAU,EAAQ,QAAQ,IAAM,EAAE,CAClC,EAAoB,EAAQ,oBAAsB,GAClD,EAAgB,EAAQ,gBAAkB,GAEhD,SAAS,EAAmB,EAAwB,CAGlD,GACE,EAAK,OAAS,kBACd,EAAK,OAAO,OAAS,oBACrB,EAAK,OAAO,SAAS,OAAS,UAE9B,MAAO,GAIT,IAAM,EAAW,EAAK,UAAU,GAMhC,OALI,IAAa,EAAS,OAAS,2BAA6B,EAAS,OAAS,sBACnE,EAAS,KAEV,OAAS,mBAEhB,GAGT,SAAS,EAAqB,EAAwB,CACpD,GAAI,CAAC,EAAK,MAAQ,EAAK,KAAK,OAAS,iBAAkB,MAAO,GAE9D,IAAM,EAAa,EAAK,KAAK,KAI7B,OAHI,EAAW,SAAW,EAAU,GAG7B,EAAW,KAAM,GAAkB,CACxC,GAAI,EAAK,OAAS,uBAAyB,EAAK,WAAW,OAAS,iBAAkB,CACpF,IAAM,EAAO,EAAK,WAClB,OAAO,EAAK,OAAO,OAAS,oBAAsB,EAAK,OAAO,SAAS,OAAS,OAElF,MAAO,IACP,CAGJ,SAAS,EAAuB,EAAwB,CAGtD,GACE,EAAK,OAAS,kBACd,EAAK,OAAO,OAAS,oBACrB,EAAK,OAAO,SAAS,OAAS,UAC9B,CACA,IAAM,EAAW,EAAK,UAAU,GAChC,GAAI,IAAa,EAAS,OAAS,2BAA6B,EAAS,OAAS,uBACnE,EAAS,KAEb,OAAS,mBAChB,MAAO,GAIb,MAAO,GAGT,MAAO,CACL,aAAa,EAAe,CACrB,GAED,EAAqB,EAAK,EAC5B,EAAQ,OAAO,CACb,OACA,UAAW,oBACX,KAAM,CAAE,WAAY,QAAS,CAC9B,CAAC,EAIN,eAAe,EAAe,CACvB,GAED,EAAqB,EAAK,EAC5B,EAAQ,OAAO,CACb,OACA,UAAW,oBACX,KAAM,CAAE,WAAY,SAAU,CAC/B,CAAC,EAIN,eAAe,EAAe,CACvB,GAED,EAAqB,EAAK,EAC5B,EAAQ,OAAO,CACb,OACA,UAAW,oBACX,KAAM,CAAE,WAAY,WAAY,CACjC,CAAC,EAIN,eAAe,EAAe,CACvB,OAGD,EAAK,OAAO,OAAS,oBAAsB,EAAK,OAAO,SAAS,OAAS,WACvE,EAAuB,EAAK,EAC9B,EAAQ,OAAO,CACb,OACA,UAAW,iBACX,IAAI,EAAO,CAET,GAAI,CAAC,EAAmB,EAAK,CAC3B,OAAO,KAOT,IAAM,EAJa,EAAQ,WACH,QAAQ,EAAK,CAGd,QAAQ,kBAAmB,QAAQ,CAC1D,OAAO,EAAM,YAAY,EAAM,EAAU,EAE5C,CAAC,CAKF,EAAK,OAAO,OAAS,oBAAsB,EAAK,OAAO,SAAS,OAAS,QAAQ,CAEnF,IAAI,EAAS,EAAK,OAClB,KAAO,GAAQ,CACb,GACE,EAAO,OAAS,kBAChB,EAAO,OAAO,OAAS,qBACtB,EAAO,OAAO,SAAS,OAAS,WAAa,EAAO,OAAO,SAAS,OAAS,OAC9E,CACA,EAAQ,OAAO,CACb,OACA,UAAW,oBACZ,CAAC,CACF,MAEF,EAAS,EAAO,UAIvB,EAEJ"}

package/dist/rules/prefer-option.d.ts

@@ -0,0 +1,7 @@
+import { Rule } from "eslint";
+
+//#region src/rules/prefer-option.d.ts
+declare const rule: Rule.RuleModule;
+//#endregion
+export { rule as default };
+//# sourceMappingURL=prefer-option.d.ts.map

package/dist/rules/prefer-option.js

@@ -0,0 +1,2 @@
+import{getFunctypeImportsLegacy as e,isAlreadyUsingFunctype as t,isFunctypeType as n}from"../utils/functype-detection.js";const r={meta:{type:`suggestion`,docs:{description:`Prefer Option<T> over nullable types (T | null | undefined)`,recommended:!0},schema:[{type:`object`,properties:{allowNullableIntersections:{type:`boolean`,default:!1}},additionalProperties:!1}],messages:{preferOption:`Prefer Option<{{type}}> over nullable type '{{nullable}}'`,preferOptionReturn:`Prefer Option<{{type}}> as return type over nullable '{{nullable}}'`}},create(r){let i=e(r);return{TSUnionType(e){if(!e.types||e.types.length<2||!e.types.some(e=>e.type===`TSNullKeyword`||e.type===`TSUndefinedKeyword`))return;let a=e.types.filter(e=>e.type!==`TSNullKeyword`&&e.type!==`TSUndefinedKeyword`);if(a.length===1){let o=a[0];if(n(o,i)||t(e,i))return;let s=r.sourceCode,c=s.getText(o),l=s.getText(e);if(c.startsWith(`Option<`))return;r.report({node:e,messageId:`preferOption`,data:{type:c,nullable:l}})}}}}};export{r as default};
+//# sourceMappingURL=prefer-option.js.map

package/dist/rules/prefer-option.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-option.js","names":[],"sources":["../../src/rules/prefer-option.ts"],"sourcesContent":["import type { Rule } from \"eslint\"\n\nimport type { ASTNode } from \"../types/ast\"\nimport { getFunctypeImportsLegacy, isAlreadyUsingFunctype, isFunctypeType } from \"../utils/functype-detection\"\n\nconst rule: Rule.RuleModule = {\n  meta: {\n    type: \"suggestion\",\n    docs: {\n      description: \"Prefer Option<T> over nullable types (T | null | undefined)\",\n      recommended: true,\n    },\n    schema: [\n      {\n        type: \"object\",\n        properties: {\n          allowNullableIntersections: {\n            type: \"boolean\",\n            default: false,\n          },\n        },\n        additionalProperties: false,\n      },\n    ],\n    messages: {\n      preferOption: \"Prefer Option<{{type}}> over nullable type '{{nullable}}'\",\n      preferOptionReturn: \"Prefer Option<{{type}}> as return type over nullable '{{nullable}}'\",\n    },\n  },\n\n  create(context) {\n    // const options = context.options[0] || {}\n    // Remove unused variable\n    // const _allowNullableIntersections = options.allowNullableIntersections || false\n\n    // Get functype imports if available (but still apply rule even without explicit import)\n    const functypeImports = getFunctypeImportsLegacy(context)\n\n    return {\n      TSUnionType(node: ASTNode) {\n        if (!node.types || node.types.length < 2) return\n\n        const hasNull = node.types.some(\n          (type: ASTNode) => type.type === \"TSNullKeyword\" || type.type === \"TSUndefinedKeyword\",\n        )\n\n        if (!hasNull) return\n\n        const nonNullTypes = node.types.filter(\n          (type: ASTNode) => type.type !== \"TSNullKeyword\" && type.type !== \"TSUndefinedKeyword\",\n        )\n\n        if (nonNullTypes.length === 1) {\n          const nonNullType = nonNullTypes[0]\n\n          // Skip if it's already an Option type or other functype type\n          if (isFunctypeType(nonNullType, functypeImports)) return\n\n          // Skip if we're already in a functype context\n          if (isAlreadyUsingFunctype(node, functypeImports)) return\n\n          const sourceCode = context.sourceCode\n          const nonNullTypeText = sourceCode.getText(nonNullType)\n          const fullType = sourceCode.getText(node)\n\n          // Skip if it's already an Option type (fallback check)\n          if (nonNullTypeText.startsWith(\"Option<\")) return\n\n          context.report({\n            node,\n            messageId: \"preferOption\",\n            data: {\n              type: nonNullTypeText,\n              nullable: fullType,\n            },\n          })\n        }\n      },\n    }\n  },\n}\n\nexport default rule\n"],"mappings":"0HAKA,MAAM,EAAwB,CAC5B,KAAM,CACJ,KAAM,aACN,KAAM,CACJ,YAAa,8DACb,YAAa,GACd,CACD,OAAQ,CACN,CACE,KAAM,SACN,WAAY,CACV,2BAA4B,CAC1B,KAAM,UACN,QAAS,GACV,CACF,CACD,qBAAsB,GACvB,CACF,CACD,SAAU,CACR,aAAc,4DACd,mBAAoB,sEACrB,CACF,CAED,OAAO,EAAS,CAMd,IAAM,EAAkB,EAAyB,EAAQ,CAEzD,MAAO,CACL,YAAY,EAAe,CAOzB,GANI,CAAC,EAAK,OAAS,EAAK,MAAM,OAAS,GAMnC,CAJY,EAAK,MAAM,KACxB,GAAkB,EAAK,OAAS,iBAAmB,EAAK,OAAS,qBACnE,CAEa,OAEd,IAAM,EAAe,EAAK,MAAM,OAC7B,GAAkB,EAAK,OAAS,iBAAmB,EAAK,OAAS,qBACnE,CAED,GAAI,EAAa,SAAW,EAAG,CAC7B,IAAM,EAAc,EAAa,GAMjC,GAHI,EAAe,EAAa,EAAgB,EAG5C,EAAuB,EAAM,EAAgB,CAAE,OAEnD,IAAM,EAAa,EAAQ,WACrB,EAAkB,EAAW,QAAQ,EAAY,CACjD,EAAW,EAAW,QAAQ,EAAK,CAGzC,GAAI,EAAgB,WAAW,UAAU,CAAE,OAE3C,EAAQ,OAAO,CACb,OACA,UAAW,eACX,KAAM,CACJ,KAAM,EACN,SAAU,EACX,CACF,CAAC,GAGP,EAEJ"}

package/dist/types/ast.d.ts

@@ -0,0 +1,12 @@
+//#region src/types/ast.d.ts
+/**
+ * ESLint AST Node type alias
+ *
+ * ESLint's AST node types are complex and not fully typed in the public API.
+ * Using `any` is the standard practice for ESLint rule development when working
+ * with AST nodes that need dynamic property access.
+ */
+type ASTNode = any;
+//#endregion
+export { ASTNode };
+//# sourceMappingURL=ast.d.ts.map

package/dist/types/ast.js

@@ -0,0 +1 @@
+export{};

package/dist/utils/dependency-validator.d.ts

@@ -1,18 +1,20 @@
+//#region src/utils/dependency-validator.d.ts
 interface PeerDependency {
-    name: string;
-    packageName: string;
-    description: string;
-    required: boolean;
+  name: string;
+  packageName: string;
+  description: string;
+  required: boolean;
 }
 interface ValidationResult {
-    isValid: boolean;
-    missing: PeerDependency[];
-    available: PeerDependency[];
-    installCommand: string;
-    warnings: string[];
+  isValid: boolean;
+  missing: PeerDependency[];
+  available: PeerDependency[];
+  installCommand: string;
+  warnings: string[];
 }
 declare function validatePeerDependencies(): ValidationResult;
 declare function createValidationError(result: ValidationResult): Error;
 declare function shouldValidateDependencies(): boolean;
-
-export { type ValidationResult, createValidationError, shouldValidateDependencies, validatePeerDependencies };
+//#endregion
+export { ValidationResult, createValidationError, shouldValidateDependencies, validatePeerDependencies };
+//# sourceMappingURL=dependency-validator.d.ts.map

package/dist/utils/dependency-validator.js

@@ -1,109 +1 @@
-'use strict';
-
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-
-// src/utils/dependency-validator.ts
-var PEER_DEPENDENCIES = [
-  {
-    name: "@typescript-eslint/eslint-plugin",
-    packageName: "@typescript-eslint/eslint-plugin",
-    description: "TypeScript-aware ESLint rules",
-    required: true
-  },
-  {
-    name: "@typescript-eslint/parser",
-    packageName: "@typescript-eslint/parser",
-    description: "TypeScript parser for ESLint",
-    required: true
-  },
-  {
-    name: "eslint-plugin-functional",
-    packageName: "eslint-plugin-functional",
-    description: "Functional programming ESLint rules",
-    required: true
-  },
-  {
-    name: "eslint-plugin-prettier",
-    packageName: "eslint-plugin-prettier",
-    description: "Code formatting rules",
-    required: false
-  },
-  {
-    name: "eslint-plugin-simple-import-sort",
-    packageName: "eslint-plugin-simple-import-sort",
-    description: "Import sorting rules",
-    required: false
-  },
-  {
-    name: "prettier",
-    packageName: "prettier",
-    description: "Code formatter",
-    required: false
-  }
-];
-function tryRequire(packageName) {
-  try {
-    __require.resolve(packageName);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function validatePeerDependencies() {
-  const missing = [];
-  const available = [];
-  const warnings = [];
-  for (const dep of PEER_DEPENDENCIES) {
-    if (tryRequire(dep.packageName)) {
-      available.push(dep);
-    } else {
-      missing.push(dep);
-      if (dep.required) ; else {
-        warnings.push(`Optional plugin '${dep.name}' not found. Some rules will be skipped.`);
-      }
-    }
-  }
-  const requiredMissing = missing.filter((dep) => dep.required);
-  const isValid = requiredMissing.length === 0;
-  const missingPackageNames = missing.map((dep) => dep.packageName);
-  const installCommand = missingPackageNames.length > 0 ? `pnpm add -D ${missingPackageNames.join(" ")}` : "";
-  return {
-    isValid,
-    missing,
-    available,
-    installCommand,
-    warnings
-  };
-}
-function createValidationError(result) {
-  const requiredMissing = result.missing.filter((dep) => dep.required);
-  if (requiredMissing.length === 0) {
-    return new Error("No validation errors");
-  }
-  const missingList = requiredMissing.map((dep) => `  \u2022 ${dep.name} - ${dep.description}`).join("\n");
-  const message = [
-    "\u274C Missing required peer dependencies for eslint-plugin-functype:",
-    "",
-    missingList,
-    "",
-    "\u{1F4E6} Install missing dependencies:",
-    `   ${result.installCommand}`,
-    "",
-    "\u{1F4D6} See installation guide: https://github.com/jordanburke/eslint-plugin-functype#installation"
-  ].join("\n");
-  return new Error(message);
-}
-function shouldValidateDependencies() {
-  return process.env.NODE_ENV !== "test" && process.env.FUNCTYPE_SKIP_VALIDATION !== "true";
-}
-
-exports.createValidationError = createValidationError;
-exports.shouldValidateDependencies = shouldValidateDependencies;
-exports.validatePeerDependencies = validatePeerDependencies;
-//# sourceMappingURL=dependency-validator.js.map
-//# sourceMappingURL=dependency-validator.js.map
+import{n as e,r as t,t as n}from"../dependency-validator-BBxa9-7D.js";export{n as createValidationError,e as shouldValidateDependencies,t as validatePeerDependencies};

package/dist/utils/functype-detection.d.ts

@@ -0,0 +1,69 @@
+import { ASTNode } from "../types/ast.js";
+import { Rule } from "eslint";
+
+//#region src/utils/functype-detection.d.ts
+/**
+ * Utility functions for detecting functype library usage in ESLint rules
+ */
+/**
+ * Check if functype library is imported in the current file
+ */
+declare function hasFunctypeImport(context: Rule.RuleContext): boolean;
+/**
+ * Enhanced functype imports tracking
+ */
+interface FunctypeImports {
+  types: Set<string>;
+  functions: Set<string>;
+  all: Set<string>;
+}
+/**
+ * Get imported functype symbols from the current file
+ */
+declare function getFunctypeImports(context: Rule.RuleContext): FunctypeImports;
+/**
+ * Legacy compatibility - returns the 'all' set
+ */
+declare function getFunctypeImportsLegacy(context: Rule.RuleContext): Set<string>;
+/**
+ * Check if a type reference is using functype types
+ */
+declare function isFunctypeType(node: ASTNode, functypeImports: FunctypeImports | Set<string>): boolean;
+/**
+ * Check if a call expression is using functype methods
+ */
+declare function isFunctypeCall(node: ASTNode, functypeImports: Set<string>): boolean;
+/**
+ * Check if current context is already using functype patterns appropriately
+ */
+declare function isAlreadyUsingFunctype(node: ASTNode, functypeImports: Set<string>): boolean;
+/**
+ * Check if a variable or parameter is typed with functype types
+ */
+declare function hasFunctypeTypeAnnotation(node: ASTNode, functypeImports: FunctypeImports | Set<string>): boolean;
+/**
+ * Check if a call expression is a Do notation call
+ */
+declare function isDoNotationCall(node: ASTNode, functypeImports: FunctypeImports): boolean;
+/**
+ * Check if a call expression uses the $ helper function
+ */
+declare function isDollarHelper(node: ASTNode, functypeImports: FunctypeImports): boolean;
+/**
+ * Check if current expression is inside a Do notation block
+ */
+declare function isInsideDoNotation(node: ASTNode, functypeImports: FunctypeImports): boolean;
+/**
+ * Check if a method call is a chained method call on functype types
+ */
+declare function isChainedMethodCall(node: ASTNode, methodName: string): boolean;
+/**
+ * Detect if code could benefit from Do notation
+ */
+declare function shouldUseDoNotation(node: ASTNode, functypeImports: FunctypeImports): {
+  shouldUse: boolean;
+  reason: "nested-checks" | "chained-flatmaps" | "mixed-monads" | "async-chains" | null;
+};
+//#endregion
+export { FunctypeImports, getFunctypeImports, getFunctypeImportsLegacy, hasFunctypeImport, hasFunctypeTypeAnnotation, isAlreadyUsingFunctype, isChainedMethodCall, isDoNotationCall, isDollarHelper, isFunctypeCall, isFunctypeType, isInsideDoNotation, shouldUseDoNotation };
+//# sourceMappingURL=functype-detection.d.ts.map

package/dist/utils/functype-detection.js

@@ -0,0 +1,2 @@
+function e(e){let t=e.sourceCode.ast;for(let e of t.body)if(e.type===`ImportDeclaration`&&e.source.type===`Literal`&&e.source.value===`functype`)return!0;return!1}function t(e){let t=new Set,n=new Set,r=new Set,i=e.sourceCode.ast;for(let e of i.body)if(e.type===`ImportDeclaration`&&e.source.type===`Literal`&&e.source.value===`functype`&&e.specifiers)for(let i of e.specifiers)if(i.type===`ImportSpecifier`&&i.imported.type===`Identifier`){let e=i.imported.name;r.add(e),[`Option`,`Either`,`List`,`LazyList`,`Task`,`Try`].includes(e)?t.add(e):([`Do`,`DoAsync`,`$`].includes(e),n.add(e))}else i.type===`ImportDefaultSpecifier`?(r.add(`default`),n.add(`default`)):i.type===`ImportNamespaceSpecifier`&&(r.add(`*`),t.add(`*`),n.add(`*`));return{types:t,functions:n,all:r}}function n(e){return t(e).all}function r(e,t){if(!e)return!1;let n=t instanceof Set?t:t.types||t.all;if(e.type===`TSTypeReference`&&e.typeName?.type===`Identifier`){let t=e.typeName.name;return n.has(t)||[`Option`,`Either`,`List`,`LazyList`,`Task`,`Try`].includes(t)}return!1}function i(e,t){if(!e||e.type!==`CallExpression`)return!1;let n=e.callee;if(n.type===`MemberExpression`&&n.object.type===`Identifier`){let e=n.object.name,r=n.property?.name;if(t.has(e)||e===`Option`&&[`some`,`none`,`of`].includes(r)||e===`Either`&&[`left`,`right`,`of`].includes(r)||e===`List`&&[`of`,`from`,`empty`].includes(r))return!0}if(n.type===`MemberExpression`){let e=n.property?.name;if([`map`,`flatMap`,`filter`,`fold`,`foldLeft`,`foldRight`,`getOrElse`,`orElse`,`isEmpty`,`nonEmpty`,`isDefined`,`isSome`,`isNone`,`isLeft`,`isRight`,`toArray`].includes(e))return!0}return!1}function a(e,t){let n=e.parent;for(;n;){if(i(n,t)||r(n,t))return!0;n=n.parent}return!1}function o(e,t){return e.typeAnnotation?.typeAnnotation?r(e.typeAnnotation.typeAnnotation,t):!1}function s(e,t){if(!e||e.type!==`CallExpression`)return!1;let n=e.callee;if(n.type===`Identifier`){let e=n.name;return t.functions.has(e)&&[`Do`,`DoAsync`].includes(e)}return!1}function c(e,t){if(!e||e.type!==`CallExpression`)return!1;let n=e.callee;return n.type===`Identifier`&&n.name===`$`?t.functions.has(`$`):!1}function l(e,t){let n=e.parent;for(;n;){if(n.type===`CallExpression`&&s(n,t))return!0;n=n.parent}return!1}function u(e,t){if(!e||e.type!==`CallExpression`)return!1;let n=e.callee;return n.type===`MemberExpression`&&n.property.type===`Identifier`&&n.property.name===t}function d(e,t){if(l(e,t))return{shouldUse:!1,reason:null};if(e.type===`LogicalExpression`&&e.operator===`&&`){let t=e.toString?e.toString():``;if(t.includes(`&&`)&&t.match(/\w+(\.\w+){2,}/))return{shouldUse:!0,reason:`nested-checks`}}if(u(e,`flatMap`)){let t=0,n=e;for(;n&&n.type===`CallExpression`&&u(n,`flatMap`)&&(t++,n.callee.type===`MemberExpression`);)n=n.callee.object;if(t>=3)return{shouldUse:!0,reason:`chained-flatmaps`}}return{shouldUse:!1,reason:null}}export{t as getFunctypeImports,n as getFunctypeImportsLegacy,e as hasFunctypeImport,o as hasFunctypeTypeAnnotation,a as isAlreadyUsingFunctype,u as isChainedMethodCall,s as isDoNotationCall,c as isDollarHelper,i as isFunctypeCall,r as isFunctypeType,l as isInsideDoNotation,d as shouldUseDoNotation};
+//# sourceMappingURL=functype-detection.js.map

package/dist/utils/functype-detection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"functype-detection.js","names":[],"sources":["../../src/utils/functype-detection.ts"],"sourcesContent":["import type { Rule } from \"eslint\"\n\nimport type { ASTNode } from \"../types/ast\"\n\n/**\n * Utility functions for detecting functype library usage in ESLint rules\n */\n\n/**\n * Check if functype library is imported in the current file\n */\nexport function hasFunctypeImport(context: Rule.RuleContext): boolean {\n  const sourceCode = context.sourceCode\n  const program = sourceCode.ast\n\n  // Look for import statements that import from 'functype'\n  for (const node of program.body) {\n    if (node.type === \"ImportDeclaration\" && node.source.type === \"Literal\" && node.source.value === \"functype\") {\n      return true\n    }\n  }\n\n  return false\n}\n\n/**\n * Enhanced functype imports tracking\n */\nexport interface FunctypeImports {\n  types: Set<string> // Option, Either, List, etc.\n  functions: Set<string> // Do, DoAsync, $, etc.\n  all: Set<string> // Combined for compatibility\n}\n\n/**\n * Get imported functype symbols from the current file\n */\nexport function getFunctypeImports(context: Rule.RuleContext): FunctypeImports {\n  const types = new Set<string>()\n  const functions = new Set<string>()\n  const all = new Set<string>()\n\n  const sourceCode = context.sourceCode\n  const program = sourceCode.ast\n\n  for (const node of program.body) {\n    if (node.type === \"ImportDeclaration\" && node.source.type === \"Literal\" && node.source.value === \"functype\") {\n      // Handle named imports: import { Option, Either, Do, $ } from 'functype'\n      if (node.specifiers) {\n        for (const spec of node.specifiers) {\n          if (spec.type === \"ImportSpecifier\" && spec.imported.type === \"Identifier\") {\n            const name = spec.imported.name\n            all.add(name)\n\n            // Categorize imports\n            if ([\"Option\", \"Either\", \"List\", \"LazyList\", \"Task\", \"Try\"].includes(name)) {\n              types.add(name)\n            } else if ([\"Do\", \"DoAsync\", \"$\"].includes(name)) {\n              functions.add(name)\n            } else {\n              // Other imports (constructors, utilities, etc.)\n              functions.add(name)\n            }\n          } else if (spec.type === \"ImportDefaultSpecifier\") {\n            all.add(\"default\")\n            functions.add(\"default\")\n          } else if (spec.type === \"ImportNamespaceSpecifier\") {\n            all.add(\"*\")\n            types.add(\"*\")\n            functions.add(\"*\")\n          }\n        }\n      }\n    }\n  }\n\n  return { types, functions, all }\n}\n\n/**\n * Legacy compatibility - returns the 'all' set\n */\nexport function getFunctypeImportsLegacy(context: Rule.RuleContext): Set<string> {\n  return getFunctypeImports(context).all\n}\n\n/**\n * Check if a type reference is using functype types\n */\nexport function isFunctypeType(node: ASTNode, functypeImports: FunctypeImports | Set<string>): boolean {\n  if (!node) return false\n\n  // Handle both new and legacy API\n  const types = functypeImports instanceof Set ? functypeImports : functypeImports.types || functypeImports.all\n\n  // Check direct type names\n  if (node.type === \"TSTypeReference\" && node.typeName?.type === \"Identifier\") {\n    const typeName = node.typeName.name\n    return types.has(typeName) || [\"Option\", \"Either\", \"List\", \"LazyList\", \"Task\", \"Try\"].includes(typeName)\n  }\n\n  return false\n}\n\n/**\n * Check if a call expression is using functype methods\n */\nexport function isFunctypeCall(node: ASTNode, functypeImports: Set<string>): boolean {\n  if (!node || node.type !== \"CallExpression\") return false\n\n  const callee = node.callee\n\n  // Check for static method calls like Option.some(), Either.left(), List.of()\n  if (callee.type === \"MemberExpression\" && callee.object.type === \"Identifier\") {\n    const objectName = callee.object.name\n    const methodName = callee.property?.name\n\n    // Check if calling methods on imported functype types\n    if (functypeImports.has(objectName)) return true\n\n    // Check for common functype patterns\n    if (\n      (objectName === \"Option\" && [\"some\", \"none\", \"of\"].includes(methodName)) ||\n      (objectName === \"Either\" && [\"left\", \"right\", \"of\"].includes(methodName)) ||\n      (objectName === \"List\" && [\"of\", \"from\", \"empty\"].includes(methodName))\n    ) {\n      return true\n    }\n  }\n\n  // Check for method calls on functype instances like someOption.map()\n  if (callee.type === \"MemberExpression\") {\n    const methodName = callee.property?.name\n\n    // Common functype methods\n    if (\n      [\n        \"map\",\n        \"flatMap\",\n        \"filter\",\n        \"fold\",\n        \"foldLeft\",\n        \"foldRight\",\n        \"getOrElse\",\n        \"orElse\",\n        \"isEmpty\",\n        \"nonEmpty\",\n        \"isDefined\",\n        \"isSome\",\n        \"isNone\",\n        \"isLeft\",\n        \"isRight\",\n        \"toArray\",\n      ].includes(methodName)\n    ) {\n      return true\n    }\n  }\n\n  return false\n}\n\n/**\n * Check if current context is already using functype patterns appropriately\n */\nexport function isAlreadyUsingFunctype(node: ASTNode, functypeImports: Set<string>): boolean {\n  let parent = node.parent\n\n  // Walk up the AST to find functype usage\n  while (parent) {\n    if (isFunctypeCall(parent as ASTNode, functypeImports) || isFunctypeType(parent as ASTNode, functypeImports)) {\n      return true\n    }\n    parent = parent.parent\n  }\n\n  return false\n}\n\n/**\n * Check if a variable or parameter is typed with functype types\n */\nexport function hasFunctypeTypeAnnotation(node: ASTNode, functypeImports: FunctypeImports | Set<string>): boolean {\n  // Check for type annotation\n  if (node.typeAnnotation?.typeAnnotation) {\n    return isFunctypeType(node.typeAnnotation.typeAnnotation, functypeImports)\n  }\n\n  return false\n}\n\n/**\n * Check if a call expression is a Do notation call\n */\nexport function isDoNotationCall(node: ASTNode, functypeImports: FunctypeImports): boolean {\n  if (!node || node.type !== \"CallExpression\") return false\n\n  const callee = node.callee\n\n  // Check for Do() or DoAsync() calls\n  if (callee.type === \"Identifier\") {\n    const name = callee.name\n    return functypeImports.functions.has(name) && [\"Do\", \"DoAsync\"].includes(name)\n  }\n\n  return false\n}\n\n/**\n * Check if a call expression uses the $ helper function\n */\nexport function isDollarHelper(node: ASTNode, functypeImports: FunctypeImports): boolean {\n  if (!node || node.type !== \"CallExpression\") return false\n\n  const callee = node.callee\n\n  // Check for $() calls\n  if (callee.type === \"Identifier\" && callee.name === \"$\") {\n    return functypeImports.functions.has(\"$\")\n  }\n\n  return false\n}\n\n/**\n * Check if current expression is inside a Do notation block\n */\nexport function isInsideDoNotation(node: ASTNode, functypeImports: FunctypeImports): boolean {\n  let current = node.parent\n\n  while (current) {\n    if (current.type === \"CallExpression\" && isDoNotationCall(current as ASTNode, functypeImports)) {\n      return true\n    }\n    current = current.parent\n  }\n\n  return false\n}\n\n/**\n * Check if a method call is a chained method call on functype types\n */\nexport function isChainedMethodCall(node: ASTNode, methodName: string): boolean {\n  if (!node || node.type !== \"CallExpression\") return false\n\n  const callee = node.callee\n\n  if (\n    callee.type === \"MemberExpression\" &&\n    callee.property.type === \"Identifier\" &&\n    callee.property.name === methodName\n  ) {\n    return true\n  }\n\n  return false\n}\n\n/**\n * Detect if code could benefit from Do notation\n */\nexport function shouldUseDoNotation(\n  node: ASTNode,\n  functypeImports: FunctypeImports,\n): {\n  shouldUse: boolean\n  reason: \"nested-checks\" | \"chained-flatmaps\" | \"mixed-monads\" | \"async-chains\" | null\n} {\n  // Already using Do notation\n  if (isInsideDoNotation(node, functypeImports)) {\n    return { shouldUse: false, reason: null }\n  }\n\n  // Check for nested null checks (a && a.b && a.b.c pattern)\n  if (node.type === \"LogicalExpression\" && node.operator === \"&&\") {\n    const text = node.toString ? node.toString() : \"\"\n    if (text.includes(\"&&\") && text.match(/\\w+(\\.\\w+){2,}/)) {\n      return { shouldUse: true, reason: \"nested-checks\" }\n    }\n  }\n\n  // Check for chained flatMap calls\n  if (isChainedMethodCall(node, \"flatMap\")) {\n    // Count chain depth\n    let depth = 0\n    let current = node\n\n    while (current && current.type === \"CallExpression\" && isChainedMethodCall(current, \"flatMap\")) {\n      depth++\n      if (current.callee.type === \"MemberExpression\") {\n        current = current.callee.object as ASTNode\n      } else {\n        break\n      }\n    }\n\n    if (depth >= 3) {\n      return { shouldUse: true, reason: \"chained-flatmaps\" }\n    }\n  }\n\n  return { shouldUse: false, reason: null }\n}\n"],"mappings":"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"}

package/package.json

@@ -1,11 +1,21 @@
 {
   "name": "eslint-plugin-functype",
-  "version": "1.4.0",
-  "description": "Custom ESLint rules for functional TypeScript programming with functype library patterns including Do notation (ESLint 9.x+)",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "version": "2.0.1",
+  "description": "Custom ESLint rules for functional TypeScript programming with functype library patterns including Do notation (ESLint 10+)",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
   "files": [
-    "dist/",
+    "lib",
+    "dist",
     "README.md",
     "LICENSE"
   ],
@@ -24,30 +34,37 @@
     "either",
     "list"
   ],
-  "peerDependencies": {
-    "eslint": "^9.32.0"
+  "scripts": {
+    "validate": "ts-builds validate",
+    "format": "ts-builds format",
+    "format:check": "ts-builds format:check",
+    "lint": "ts-builds lint",
+    "lint:check": "ts-builds lint:check",
+    "typecheck": "ts-builds typecheck",
+    "test": "ts-builds test",
+    "test:watch": "ts-builds test:watch",
+    "test:ui": "ts-builds test:ui",
+    "test:coverage": "ts-builds test:coverage",
+    "build": "ts-builds build",
+    "dev": "ts-builds dev",
+    "prepublishOnly": "pnpm validate",
+    "list-rules": "node dist/cli/list-rules.js",
+    "list-rules:verbose": "node dist/cli/list-rules.js --verbose",
+    "list-rules:usage": "node dist/cli/list-rules.js --usage",
+    "check-deps": "node dist/cli/list-rules.js --check-deps",
+    "cli:help": "node dist/cli/list-rules.js --help"
   },
-  "dependencies": {
-    "@eslint/eslintrc": "^3.3.1",
-    "@eslint/js": "^9.35.0"
+  "prettier": "ts-builds/prettier",
+  "peerDependencies": {
+    "eslint": "^10.0.3"
   },
   "devDependencies": {
-    "@types/node": "^22.18.3",
-    "@typescript-eslint/eslint-plugin": "^8.43.0",
-    "@typescript-eslint/parser": "^8.43.0",
-    "@typescript-eslint/rule-tester": "^8.43.0",
-    "@vitest/coverage-v8": "^3.2.4",
-    "@vitest/ui": "^3.2.4",
-    "eslint": "^9.35.0",
-    "eslint-plugin-functional": "^9.0.2",
-    "eslint-plugin-prettier": "^5.5.4",
-    "eslint-plugin-simple-import-sort": "^12.1.1",
-    "functype": "^0.15.0",
-    "prettier": "^3.6.2",
-    "rimraf": "^6.0.1",
-    "tsup": "^8.5.0",
-    "typescript": "^5.9.2",
-    "vitest": "^3.2.4"
+    "@types/node": "^24.12.0",
+    "@typescript-eslint/rule-tester": "^8.57.0",
+    "eslint-config-prettier": "^10.1.8",
+    "functype": "^0.49.0",
+    "ts-builds": "^2.5.1",
+    "tsdown": "^0.21.2"
   },
   "author": {
     "name": "Jordan Burke",
@@ -56,35 +73,14 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/jordanburke/eslint-plugin-functype.git"
+    "url": "https://github.com/jordanburke/eslint-functype",
+    "directory": "packages/plugin"
   },
   "bugs": {
-    "url": "https://github.com/jordanburke/eslint-plugin-functype/issues"
+    "url": "https://github.com/jordanburke/eslint-functype/issues"
   },
-  "homepage": "https://github.com/jordanburke/eslint-plugin-functype#readme",
+  "homepage": "https://github.com/jordanburke/eslint-functype#readme",
   "engines": {
     "node": ">=22.0.0"
-  },
-  "scripts": {
-    "validate": "pnpm format && pnpm lint && pnpm test && pnpm build",
-    "format": "prettier --write .",
-    "format:check": "prettier --check .",
-    "lint": "eslint src --fix",
-    "lint:check": "eslint src",
-    "test": "VITE_CJS_IGNORE_WARNING=true vitest run",
-    "test:watch": "VITE_CJS_IGNORE_WARNING=true vitest --watch",
-    "test:ui": "VITE_CJS_IGNORE_WARNING=true vitest --ui",
-    "test:coverage": "VITE_CJS_IGNORE_WARNING=true vitest --coverage",
-    "build": "rimraf dist && pnpm run typecheck && tsup",
-    "build:watch": "tsup --watch",
-    "typecheck": "tsc --noEmit",
-    "compile": "tsc --noEmit",
-    "clean": "rimraf dist",
-    "check": "pnpm run typecheck && pnpm run lint:check && pnpm run test",
-    "list-rules": "node dist/cli/list-rules.js",
-    "list-rules:verbose": "node dist/cli/list-rules.js --verbose",
-    "list-rules:usage": "node dist/cli/list-rules.js --usage",
-    "check-deps": "node dist/cli/list-rules.js --check-deps",
-    "cli:help": "node dist/cli/list-rules.js --help"
   }
-}
+}

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2024
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.