eslint-plugin-functype 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+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.

package/README.md

@@ -0,0 +1,210 @@
+# eslint-plugin-functype
+
+A curated ESLint configuration bundle for functional TypeScript programming. This plugin combines and configures rules from established ESLint plugins to enforce immutability patterns and functional programming best practices.
+
+## What This Plugin Does
+
+Instead of recreating functional programming rules, this plugin provides carefully curated configurations that combine rules from:
+
+- **eslint-plugin-functional**: Core functional programming rules
+- **@typescript-eslint/eslint-plugin**: TypeScript-specific functional patterns  
+- **ESLint core**: JavaScript immutability basics
+
+## Installation
+
+```bash
+npm install --save-dev eslint-plugin-functype @typescript-eslint/eslint-plugin @typescript-eslint/parser eslint-plugin-functional
+# or
+pnpm add -D eslint-plugin-functype @typescript-eslint/eslint-plugin @typescript-eslint/parser eslint-plugin-functional
+```
+
+## Usage
+
+### ESLint 8 (.eslintrc) - Quick Start
+
+```javascript
+// .eslintrc.js
+module.exports = {
+  extends: ["plugin:functype/recommended"],
+  parser: "@typescript-eslint/parser",
+  parserOptions: {
+    project: "./tsconfig.json",
+  },
+}
+```
+
+### ESLint 8 - Strict Mode
+
+```javascript
+// .eslintrc.js
+module.exports = {
+  extends: ["plugin:functype/strict"],
+  parser: "@typescript-eslint/parser",
+  parserOptions: {
+    project: "./tsconfig.json",
+  },
+}
+```
+
+### ESLint 9+ (Flat Config)
+
+For ESLint 9+, create your own flat config using our rule selections:
+
+```javascript
+// eslint.config.js
+import js from "@eslint/js"
+import tseslint from "@typescript-eslint/eslint-plugin"
+import functional from "eslint-plugin-functional"
+import parser from "@typescript-eslint/parser"
+
+export default [
+  js.configs.recommended,
+  {
+    files: ["**/*.ts", "**/*.tsx"],
+    languageOptions: {
+      parser,
+      parserOptions: {
+        ecmaVersion: "latest",
+        sourceType: "module",
+        project: "./tsconfig.json",
+      },
+    },
+    plugins: {
+      "@typescript-eslint": tseslint,
+      functional,
+    },
+    rules: {
+      // Core immutability
+      "prefer-const": "error",
+      "no-var": "error",
+      
+      // TypeScript functional patterns
+      "@typescript-eslint/consistent-type-imports": "error",
+      "@typescript-eslint/no-explicit-any": "error",
+      "@typescript-eslint/no-unused-vars": ["error", { argsIgnorePattern: "^_" }],
+      
+      // Functional programming rules
+      "functional/no-let": "error",
+      "functional/immutable-data": "warn",
+      "functional/no-loop-statements": "off", // Enable as "error" for strict mode
+    },
+  }
+]
+```
+
+### Individual Rule Usage
+
+You can also use individual rules without our presets:
+
+```javascript
+{
+  "plugins": ["@typescript-eslint", "functional"],
+  "rules": {
+    "functional/no-let": "error",
+    "functional/immutable-data": "warn",
+    "@typescript-eslint/no-explicit-any": "error",
+    "prefer-const": "error"
+  }
+}
+```
+
+## What Rules Are Included
+
+### Recommended Configuration
+- ✅ `prefer-const` / `no-var` - Basic immutability
+- ✅ `functional/no-let` - Disallow `let` declarations
+- ⚠️ `functional/immutable-data` - Warn on data mutation
+- ⚠️ `functional/no-mutation` - Warn on object/array mutations
+- ✅ `@typescript-eslint/consistent-type-imports` - Clean imports
+- ✅ `@typescript-eslint/no-explicit-any` - Type safety
+
+### Strict Configuration
+All recommended rules plus:
+- ✅ `functional/no-loop-statements` - Disallow imperative loops
+- ✅ `functional/immutable-data` - Error on data mutation
+- ✅ `functional/prefer-immutable-types` - Encourage readonly types
+- ✅ `@typescript-eslint/explicit-function-return-type` - Explicit return types
+
+## Examples
+
+```typescript
+// ❌ Bad (will be flagged)
+let x = 1;                    // functional/no-let
+arr.push(item);              // functional/immutable-data  
+for(let i = 0; i < 10; i++)  // functional/no-loop-statements (strict only)
+
+// ✅ Good  
+const x = 1;
+const newArr = [...arr, item];
+arr.forEach(item => process(item));
+```
+
+## Configurations
+
+- **`recommended`**: Balanced functional programming rules suitable for most projects
+- **`strict`**: Maximum functional programming enforcement for pure FP codebases
+
+## Philosophy
+
+This plugin follows the principle of **composition over recreation**. Rather than maintaining custom rules, we curate and combine battle-tested rules from the community, ensuring:
+
+- ✅ Less maintenance burden
+- ✅ Better rule quality and edge case handling  
+- ✅ Automatic updates from upstream plugins
+- ✅ Community-driven improvements
+
+## CLI Tools
+
+### List All Supported Rules
+
+See exactly which rules are configured in each preset:
+
+```bash
+# Basic rule listing
+pnpm run list-rules
+
+# Show rule options/configuration
+pnpm run list-rules:verbose  
+
+# Show usage examples
+pnpm run list-rules:usage
+
+# Show help
+pnpm run cli:help
+```
+
+### After Installation
+
+Once installed globally or in a project, you can also use:
+
+```bash
+# If installed globally
+functype-list-rules --help
+
+# Or with npx
+npx eslint-plugin-functype functype-list-rules
+```
+
+## CI/CD
+
+This plugin includes GitHub Actions workflows for:
+- ✅ **Testing** on Node.js 18, 20, 22
+- ✅ **Linting** with our own rules  
+- ✅ **Building** and validation
+- ✅ **Publishing** to npm on version changes
+
+## Development
+
+```bash
+# Install dependencies
+pnpm install
+
+# Build
+pnpm run build
+
+# Lint
+pnpm run lint
+
+# List rules during development  
+pnpm run list-rules
+```

package/dist/cli/list-rules.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli/list-rules.js

@@ -0,0 +1,233 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+// Colors for console output
+const colors = {
+    reset: '\x1b[0m',
+    bright: '\x1b[1m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    magenta: '\x1b[35m',
+    cyan: '\x1b[36m',
+};
+function colorize(text, color) {
+    return colors[color] + text + colors.reset;
+}
+async function loadConfig(configPath) {
+    try {
+        // For built JS files, use require
+        if (configPath.endsWith('.js')) {
+            const configModule = require(configPath);
+            return configModule.default || configModule;
+        }
+        // For TS files, we'd need to use dynamic import
+        const configModule = await Promise.resolve(`${configPath}`).then(s => __importStar(require(s)));
+        return configModule.default || configModule;
+    }
+    catch (error) {
+        console.error(colorize(`Error loading config from ${configPath}:`, 'red'), error.message);
+        return null;
+    }
+}
+function extractRules(config) {
+    const rules = new Map();
+    if (config.rules) {
+        Object.entries(config.rules).forEach(([ruleName, ruleConfig]) => {
+            const severity = Array.isArray(ruleConfig) ? ruleConfig[0] : ruleConfig;
+            const options = Array.isArray(ruleConfig) ? ruleConfig.slice(1) : [];
+            rules.set(ruleName, {
+                severity,
+                options,
+                source: getRuleSource(ruleName)
+            });
+        });
+    }
+    return rules;
+}
+function getRuleSource(ruleName) {
+    if (ruleName.startsWith('functional/'))
+        return 'eslint-plugin-functional';
+    if (ruleName.startsWith('@typescript-eslint/'))
+        return '@typescript-eslint/eslint-plugin';
+    return 'eslint (core)';
+}
+function getSeverityColor(severity) {
+    switch (severity) {
+        case 'error':
+        case 2:
+            return 'red';
+        case 'warn':
+        case 1:
+            return 'yellow';
+        case 'off':
+        case 0:
+            return 'cyan';
+        default:
+            return 'reset';
+    }
+}
+function formatSeverity(severity) {
+    const severityMap = {
+        '0': 'off',
+        '1': 'warn',
+        '2': 'error',
+        'off': 'off',
+        'warn': 'warn',
+        'error': 'error'
+    };
+    return severityMap[String(severity)] || String(severity);
+}
+function printRules(configName, rules) {
+    console.log(colorize(`\n📋 ${configName} Configuration Rules:`, 'bright'));
+    console.log(colorize('='.repeat(50), 'blue'));
+    // Group rules by source
+    const rulesBySource = new Map();
+    rules.forEach((ruleData, ruleName) => {
+        const source = ruleData.source;
+        if (!rulesBySource.has(source)) {
+            rulesBySource.set(source, new Map());
+        }
+        rulesBySource.get(source).set(ruleName, ruleData);
+    });
+    // Print rules grouped by source
+    rulesBySource.forEach((sourceRules, source) => {
+        console.log(colorize(`\n📦 ${source}:`, 'magenta'));
+        sourceRules.forEach((ruleData, ruleName) => {
+            const shortName = ruleName.replace(/^.*\//, '');
+            const severity = formatSeverity(ruleData.severity);
+            const severityColored = colorize(`[${severity.toUpperCase()}]`, getSeverityColor(ruleData.severity));
+            const hasOptions = ruleData.options && ruleData.options.length > 0;
+            const optionsText = hasOptions ? colorize(' (with options)', 'cyan') : '';
+            console.log(`  ${severityColored} ${colorize(shortName, 'green')}${optionsText}`);
+            if (hasOptions && process.argv.includes('--verbose')) {
+                console.log(`    ${colorize('Options:', 'cyan')} ${JSON.stringify(ruleData.options)}`);
+            }
+        });
+    });
+}
+function printSummary(configs) {
+    console.log(colorize('\n📊 Summary:', 'bright'));
+    console.log(colorize('='.repeat(30), 'blue'));
+    configs.forEach(({ name, rules }) => {
+        const totalRules = rules.size;
+        const errorRules = Array.from(rules.values()).filter(r => r.severity === 'error' || r.severity === 2).length;
+        const warnRules = Array.from(rules.values()).filter(r => r.severity === 'warn' || r.severity === 1).length;
+        const offRules = Array.from(rules.values()).filter(r => r.severity === 'off' || r.severity === 0).length;
+        console.log(`\n${colorize(name, 'bright')}: ${totalRules} total rules`);
+        console.log(`  ${colorize('●', 'red')} ${errorRules} errors`);
+        console.log(`  ${colorize('●', 'yellow')} ${warnRules} warnings`);
+        console.log(`  ${colorize('●', 'cyan')} ${offRules} disabled`);
+    });
+}
+function printUsageInfo() {
+    console.log(colorize('\n💡 Usage Information:', 'bright'));
+    console.log(colorize('='.repeat(30), 'blue'));
+    console.log('\n📖 How to use these configurations:');
+    console.log('\n' + colorize('ESLint 8 (.eslintrc):', 'green'));
+    console.log('  extends: ["plugin:functype/recommended"]');
+    console.log('\n' + colorize('ESLint 9+ (flat config):', 'green'));
+    console.log('  Copy the rules from our documentation into your eslint.config.js');
+    console.log('\n' + colorize('Individual rules:', 'green'));
+    console.log('  You can enable any rule individually in your rules section');
+}
+async function main() {
+    const args = process.argv.slice(2);
+    const showHelp = args.includes('--help') || args.includes('-h');
+    const showUsage = args.includes('--usage') || args.includes('-u');
+    if (showHelp) {
+        console.log(colorize('📋 ESLint Plugin Functype - Rule Lister', 'bright'));
+        console.log('\nUsage: pnpm run list-rules [options]');
+        console.log('\nOptions:');
+        console.log('  --verbose, -v    Show rule options');
+        console.log('  --usage, -u      Show usage examples');
+        console.log('  --help, -h       Show this help message');
+        console.log('\nThis command lists all rules configured in the functype plugin configurations.');
+        return;
+    }
+    console.log(colorize('🔧 ESLint Plugin Functype - Supported Rules', 'bright'));
+    const distPath = path_1.default.join(__dirname, '..', '..', 'dist');
+    if (!fs_1.default.existsSync(distPath)) {
+        console.error(colorize('❌ Build directory not found. Run `pnpm run build` first.', 'red'));
+        process.exit(1);
+    }
+    const configs = [
+        {
+            name: 'Recommended',
+            path: path_1.default.join(distPath, 'configs', 'recommended.js')
+        },
+        {
+            name: 'Strict',
+            path: path_1.default.join(distPath, 'configs', 'strict.js')
+        }
+    ];
+    const loadedConfigs = [];
+    for (const { name, path: configPath } of configs) {
+        const config = await loadConfig(configPath);
+        if (config) {
+            const rules = extractRules(config);
+            loadedConfigs.push({ name, rules });
+            printRules(name, rules);
+        }
+    }
+    if (loadedConfigs.length > 0) {
+        printSummary(loadedConfigs);
+        if (showUsage) {
+            printUsageInfo();
+        }
+        console.log(colorize('\n💡 Tips:', 'bright'));
+        console.log('• Use --verbose to see rule options');
+        console.log('• Use --usage to see configuration examples');
+        console.log('• Red rules will cause build failures');
+        console.log('• Yellow rules are warnings only');
+        console.log('• Blue rules are disabled by default');
+        console.log(colorize('\n🔗 Links:', 'bright'));
+        console.log('• Documentation: https://github.com/jordanburke/eslint-plugin-functype');
+        console.log('• eslint-plugin-functional: https://github.com/eslint-functional/eslint-plugin-functional');
+        console.log('• @typescript-eslint: https://typescript-eslint.io/');
+    }
+}
+// Run the CLI
+main().catch(error => {
+    console.error(colorize('❌ Unexpected error:', 'red'), error);
+    process.exit(1);
+});

package/dist/configs/recommended.d.ts

@@ -0,0 +1,23 @@
+declare const _default: {
+    plugins: string[];
+    extends: string[];
+    rules: {
+        "prefer-const": string;
+        "no-var": string;
+        "@typescript-eslint/consistent-type-imports": string;
+        "@typescript-eslint/no-explicit-any": string;
+        "@typescript-eslint/no-unused-vars": (string | {
+            argsIgnorePattern: string;
+        })[];
+        "functional/no-let": string;
+        "functional/immutable-data": string;
+        "functional/no-loop-statements": string;
+        "functional/prefer-immutable-types": string;
+        "functional/no-mixed-types": string;
+        "functional/functional-parameters": string;
+        "functional/no-conditional-statements": string;
+        "functional/no-expression-statements": string;
+        "functional/no-return-void": string;
+    };
+};
+export default _default;

package/dist/configs/recommended.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// Legacy ESLint config format for compatibility
+exports.default = {
+    plugins: [
+        "@typescript-eslint",
+        "functional"
+    ],
+    extends: [
+        "eslint:recommended",
+        "@typescript-eslint/recommended"
+    ],
+    rules: {
+        // Core JavaScript immutability
+        "prefer-const": "error",
+        "no-var": "error",
+        // TypeScript functional patterns
+        "@typescript-eslint/consistent-type-imports": "error",
+        "@typescript-eslint/no-explicit-any": "error",
+        "@typescript-eslint/no-unused-vars": [
+            "error",
+            { argsIgnorePattern: "^_" }
+        ],
+        // Functional programming rules from eslint-plugin-functional
+        "functional/no-let": "error",
+        "functional/immutable-data": "warn",
+        "functional/no-loop-statements": "off", // Start disabled, can enable later
+        "functional/prefer-immutable-types": "off", // Too strict for most projects
+        "functional/no-mixed-types": "off",
+        "functional/functional-parameters": "off",
+        // Allow some flexibility
+        "functional/no-conditional-statements": "off",
+        "functional/no-expression-statements": "off",
+        "functional/no-return-void": "off",
+    },
+};

package/dist/configs/strict.d.ts

@@ -0,0 +1,25 @@
+declare const _default: {
+    rules: {
+        "functional/no-loop-statements": string;
+        "functional/immutable-data": string;
+        "functional/prefer-immutable-types": string;
+        "functional/functional-parameters": string;
+        "@typescript-eslint/explicit-function-return-type": string;
+        "@typescript-eslint/no-non-null-assertion": string;
+        "prefer-const": string;
+        "no-var": string;
+        "@typescript-eslint/consistent-type-imports": string;
+        "@typescript-eslint/no-explicit-any": string;
+        "@typescript-eslint/no-unused-vars": (string | {
+            argsIgnorePattern: string;
+        })[];
+        "functional/no-let": string;
+        "functional/no-mixed-types": string;
+        "functional/no-conditional-statements": string;
+        "functional/no-expression-statements": string;
+        "functional/no-return-void": string;
+    };
+    plugins: string[];
+    extends: string[];
+};
+export default _default;

package/dist/configs/strict.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const recommended_1 = __importDefault(require("./recommended"));
+exports.default = {
+    ...recommended_1.default,
+    rules: {
+        ...recommended_1.default.rules,
+        // Enable stricter functional rules
+        "functional/no-loop-statements": "error",
+        "functional/immutable-data": "error",
+        "functional/prefer-immutable-types": "warn",
+        "functional/functional-parameters": "warn",
+        // Stricter TypeScript rules (non-type-aware)
+        "@typescript-eslint/explicit-function-return-type": "error",
+        "@typescript-eslint/no-non-null-assertion": "error",
+    },
+};

package/dist/index.d.ts

@@ -0,0 +1,51 @@
+declare const plugin: {
+    configs: {
+        recommended: {
+            plugins: string[];
+            extends: string[];
+            rules: {
+                "prefer-const": string;
+                "no-var": string;
+                "@typescript-eslint/consistent-type-imports": string;
+                "@typescript-eslint/no-explicit-any": string;
+                "@typescript-eslint/no-unused-vars": (string | {
+                    argsIgnorePattern: string;
+                })[];
+                "functional/no-let": string;
+                "functional/immutable-data": string;
+                "functional/no-loop-statements": string;
+                "functional/prefer-immutable-types": string;
+                "functional/no-mixed-types": string;
+                "functional/functional-parameters": string;
+                "functional/no-conditional-statements": string;
+                "functional/no-expression-statements": string;
+                "functional/no-return-void": string;
+            };
+        };
+        strict: {
+            rules: {
+                "functional/no-loop-statements": string;
+                "functional/immutable-data": string;
+                "functional/prefer-immutable-types": string;
+                "functional/functional-parameters": string;
+                "@typescript-eslint/explicit-function-return-type": string;
+                "@typescript-eslint/no-non-null-assertion": string;
+                "prefer-const": string;
+                "no-var": string;
+                "@typescript-eslint/consistent-type-imports": string;
+                "@typescript-eslint/no-explicit-any": string;
+                "@typescript-eslint/no-unused-vars": (string | {
+                    argsIgnorePattern: string;
+                })[];
+                "functional/no-let": string;
+                "functional/no-mixed-types": string;
+                "functional/no-conditional-statements": string;
+                "functional/no-expression-statements": string;
+                "functional/no-return-void": string;
+            };
+            plugins: string[];
+            extends: string[];
+        };
+    };
+};
+export = plugin;

package/dist/index.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const recommended_1 = __importDefault(require("./configs/recommended"));
+const strict_1 = __importDefault(require("./configs/strict"));
+const plugin = {
+    configs: {
+        recommended: recommended_1.default,
+        strict: strict_1.default,
+    },
+};
+module.exports = plugin;

package/dist/rules/immutable-data.d.ts

@@ -0,0 +1,2 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+export declare const immutableDataRule: ESLintUtils.RuleModule<"noMutation" | "noArrayMutation", [], ESLintUtils.RuleListener>;

package/dist/rules/immutable-data.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.immutableDataRule = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule = utils_1.ESLintUtils.RuleCreator((name) => `https://github.com/jordanburke/eslint-plugin-functype/blob/main/docs/rules/${name}.md`);
+exports.immutableDataRule = createRule({
+    name: "immutable-data",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Enforce immutable data patterns",
+        },
+        messages: {
+            noMutation: "Avoid mutating data. Use immutable update patterns instead.",
+            noArrayMutation: "Array method '{{method}}' mutates the array. Use {{alternative}} instead.",
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        const mutatingArrayMethods = new Map([
+            ["push", "concat or spread syntax"],
+            ["pop", "slice(0, -1)"],
+            ["shift", "slice(1)"],
+            ["unshift", "spread syntax"],
+            ["splice", "slice or filter"],
+            ["sort", "toSorted or [...].sort()"],
+            ["reverse", "toReversed or [...].reverse()"],
+        ]);
+        return {
+            AssignmentExpression(node) {
+                if (node.left.type === "MemberExpression" &&
+                    node.operator === "=") {
+                    context.report({
+                        node,
+                        messageId: "noMutation",
+                    });
+                }
+            },
+            CallExpression(node) {
+                if (node.callee.type === "MemberExpression" &&
+                    node.callee.property.type === "Identifier") {
+                    const method = node.callee.property.name;
+                    const alternative = mutatingArrayMethods.get(method);
+                    if (alternative) {
+                        // Allow [...arr].sort() and [...arr].reverse() since they create copies first
+                        if ((method === "sort" || method === "reverse") &&
+                            node.callee.object.type === "ArrayExpression" &&
+                            node.callee.object.elements.length === 1 &&
+                            node.callee.object.elements[0]?.type === "SpreadElement") {
+                            return;
+                        }
+                        context.report({
+                            node,
+                            messageId: "noArrayMutation",
+                            data: {
+                                method,
+                                alternative,
+                            },
+                        });
+                    }
+                }
+            },
+        };
+    },
+});

package/dist/rules/index.d.ts

@@ -0,0 +1,5 @@
+export declare const rules: {
+    "no-let": import("@typescript-eslint/utils/dist/ts-eslint").RuleModule<"noLet", [], import("@typescript-eslint/utils/dist/ts-eslint").RuleListener>;
+    "immutable-data": import("@typescript-eslint/utils/dist/ts-eslint").RuleModule<"noMutation" | "noArrayMutation", [], import("@typescript-eslint/utils/dist/ts-eslint").RuleListener>;
+    "no-loop-statements": import("@typescript-eslint/utils/dist/ts-eslint").RuleModule<"noForLoop" | "noWhileLoop" | "noDoWhileLoop" | "noForInLoop" | "noForOfLoop", [], import("@typescript-eslint/utils/dist/ts-eslint").RuleListener>;
+};

package/dist/rules/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rules = void 0;
+const no_let_1 = require("./no-let");
+const immutable_data_1 = require("./immutable-data");
+const no_loop_statements_1 = require("./no-loop-statements");
+exports.rules = {
+    "no-let": no_let_1.noLetRule,
+    "immutable-data": immutable_data_1.immutableDataRule,
+    "no-loop-statements": no_loop_statements_1.noLoopStatementsRule,
+};

package/dist/rules/no-let.d.ts

@@ -0,0 +1,2 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+export declare const noLetRule: ESLintUtils.RuleModule<"noLet", [], ESLintUtils.RuleListener>;

package/dist/rules/no-let.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noLetRule = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule = utils_1.ESLintUtils.RuleCreator((name) => `https://github.com/jordanburke/eslint-plugin-functype/blob/main/docs/rules/${name}.md`);
+exports.noLetRule = createRule({
+    name: "no-let",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow let declarations to enforce immutability",
+        },
+        messages: {
+            noLet: "Use 'const' instead of 'let' for immutable bindings",
+        },
+        schema: [],
+        fixable: "code",
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            VariableDeclaration(node) {
+                if (node.kind === "let") {
+                    context.report({
+                        node,
+                        messageId: "noLet",
+                        fix(fixer) {
+                            const sourceCode = context.sourceCode;
+                            const letToken = sourceCode.getFirstToken(node);
+                            if (letToken) {
+                                return fixer.replaceText(letToken, "const");
+                            }
+                            return null;
+                        },
+                    });
+                }
+            },
+        };
+    },
+});

package/dist/rules/no-loop-statements.d.ts

@@ -0,0 +1,2 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+export declare const noLoopStatementsRule: ESLintUtils.RuleModule<"noForLoop" | "noWhileLoop" | "noDoWhileLoop" | "noForInLoop" | "noForOfLoop", [], ESLintUtils.RuleListener>;

package/dist/rules/no-loop-statements.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noLoopStatementsRule = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule = utils_1.ESLintUtils.RuleCreator((name) => `https://github.com/jordanburke/eslint-plugin-functype/blob/main/docs/rules/${name}.md`);
+exports.noLoopStatementsRule = createRule({
+    name: "no-loop-statements",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow loop statements in favor of functional alternatives",
+        },
+        messages: {
+            noForLoop: "Avoid for loops. Use array methods like map, filter, reduce instead.",
+            noWhileLoop: "Avoid while loops. Use recursive functions or array methods instead.",
+            noDoWhileLoop: "Avoid do-while loops. Use recursive functions or array methods instead.",
+            noForInLoop: "Avoid for-in loops. Use Object.keys, Object.values, or Object.entries instead.",
+            noForOfLoop: "Avoid for-of loops. Use array methods like forEach, map, filter instead.",
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            ForStatement(node) {
+                context.report({
+                    node,
+                    messageId: "noForLoop",
+                });
+            },
+            WhileStatement(node) {
+                context.report({
+                    node,
+                    messageId: "noWhileLoop",
+                });
+            },
+            DoWhileStatement(node) {
+                context.report({
+                    node,
+                    messageId: "noDoWhileLoop",
+                });
+            },
+            ForInStatement(node) {
+                context.report({
+                    node,
+                    messageId: "noForInLoop",
+                });
+            },
+            ForOfStatement(node) {
+                context.report({
+                    node,
+                    messageId: "noForOfLoop",
+                });
+            },
+        };
+    },
+});

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "eslint-plugin-functype",
+  "version": "1.0.0",
+  "description": "Curated ESLint configuration bundle for functional TypeScript programming",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist/",
+    "README.md",
+    "LICENSE"
+  ],
+  "bin": {
+    "functype-list-rules": "dist/cli/list-rules.js"
+  },
+  "keywords": [
+    "eslint",
+    "eslintplugin",
+    "eslint-plugin",
+    "functional",
+    "typescript",
+    "immutable"
+  ],
+  "peerDependencies": {
+    "@typescript-eslint/eslint-plugin": "^8.39.0",
+    "@typescript-eslint/parser": "^8.39.0",
+    "eslint": "^9.32.0",
+    "eslint-plugin-functional": "^9.0.2"
+  },
+  "dependencies": {
+    "@eslint/eslintrc": "^3.3.1",
+    "@eslint/js": "^9.32.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.17.0",
+    "@typescript-eslint/eslint-plugin": "^8.39.0",
+    "@typescript-eslint/parser": "^8.39.0",
+    "eslint": "^9.32.0",
+    "eslint-plugin-functional": "^9.0.2",
+    "typescript": "^5.9.2"
+  },
+  "author": "",
+  "license": "ISC",
+  "scripts": {
+    "build": "tsc",
+    "lint": "eslint src --ext .ts",
+    "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",
+    "cli:help": "node dist/cli/list-rules.js --help"
+  }
+}