tessl/npm-eslint-plugin-functional

ESLint rules to promote functional programming in TypeScript.

—

Pending

Quality

Pending

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

Securityby

Pending

The risk profile of this skill

Overview

Eval results

Files

Configuration Presets

Name: tessl/npm-eslint-plugin-functional
Author: tessl

14 predefined rule configurations covering different functional programming approaches from beginner-friendly to strict enforcement. Each preset combines multiple rules with appropriate settings for specific use cases.

Capabilities

All Configuration

Enables all available rules with their default settings.

/**
 * Enables all available rules
 * Config: functional.configs.all
 */
interface AllConfig extends FlatConfig.Config {
  plugins: { functional: EslintPluginFunctional };
  rules: Record<string, "error">;
}

Usage Example:

import functional from "eslint-plugin-functional";

export default [
  {
    plugins: { functional },
    rules: {
      ...functional.configs.all.rules,
    },
  },
];

Lite Configuration

Lightweight configuration ideal for beginners or gradual adoption of functional programming patterns.

/**
 * Beginner-friendly functional programming rules
 * Config: functional.configs.lite
 */
interface LiteConfig extends FlatConfig.Config {
  plugins: { functional: EslintPluginFunctional };
  rules: {
    // Based on recommended rules with lighter overrides
    "functional/functional-parameters": ["error", {
      enforceParameterCount: false;
    }];
    "functional/immutable-data": ["error", { 
      ignoreClasses: "fieldsOnly";  
    }];
    "functional/no-classes": "off";
    "functional/no-conditional-statements": "off";
    "functional/no-expression-statements": "off";
    "functional/prefer-immutable-types": ["error", {
      enforcement: "None";
      overrides: Array<{
        specifiers: { from: "file" };
        options: {
          ignoreInferredTypes: true;
          parameters: { enforcement: "ReadonlyShallow" };
        };
      }>;
    }];
    // ... plus other recommended rules
  };
}

Usage Example:

import functional from "eslint-plugin-functional";

export default [
  {
    plugins: { functional },
    rules: {
      ...functional.configs.lite.rules,
    },
  },
];

Recommended Configuration

Balanced configuration with practical overrides for real-world usage. Good balance between functional programming enforcement and practicality.

/**
 * Recommended rules with practical overrides
 * Config: functional.configs.recommended
 */
interface RecommendedConfig extends FlatConfig.Config {
  plugins: { functional: EslintPluginFunctional };
  rules: {
    "functional/functional-parameters": ["error", {
      enforceParameterCount: false;
      overrides: Array<{
        specifiers: Array<{ from: "file" }>;
        options: {
          enforceParameterCount: {
            count: "atLeastOne";
            ignoreLambdaExpression: true;
            ignoreIIFE: true;
            ignoreGettersAndSetters: true;
          };
        };
      }>;
    }];
    "functional/no-conditional-statements": ["error", {
      allowReturningBranches: true;
    }];
    "functional/no-let": ["error", {
      allowInForLoopInit: true;
    }];
    "functional/no-this-expressions": "off";
    "functional/no-throw-statements": ["error", {
      allowToRejectPromises: true;
    }];
    "functional/no-try-statements": "off";
    // ... other rules with specific configurations
  };
}

Usage Example:

import functional from "eslint-plugin-functional";

export default [
  {
    plugins: { functional },
    rules: {
      ...functional.configs.recommended.rules,
    },
  },
];

Strict Configuration

Strict functional programming enforcement with minimal exceptions.

/**
 * Strict functional programming rules
 * Config: functional.configs.strict
 */
interface StrictConfig extends FlatConfig.Config {
  plugins: { functional: EslintPluginFunctional };
  rules: Record<string, "error">;
}

Usage Example:

import functional from "eslint-plugin-functional";

export default [
  {
    plugins: { functional },
    rules: {
      ...functional.configs.strict.rules,
    },
  },
];

Off Configuration

Disables all functional programming rules. Useful for temporarily disabling the plugin.

/**
 * Disables all rules
 * Config: functional.configs.off
 */
interface OffConfig extends FlatConfig.Config {
  plugins: { functional: EslintPluginFunctional };
  rules: Record<string, "off">;
}

Usage Example:

import functional from "eslint-plugin-functional";

export default [
  {
    plugins: { functional },
    rules: {
      ...functional.configs.off.rules,
    },
  },
];

Disable Type Checked Configuration

Disables TypeScript type-aware rules while keeping other functional programming rules active.

/**
 * Disables TypeScript type-aware rules
 * Config: functional.configs.disableTypeChecked
 */
interface DisableTypeCheckedConfig extends FlatConfig.Config {
  plugins: { functional: EslintPluginFunctional };
  rules: Record<string, "off">;
}

Usage Example:

import functional from "eslint-plugin-functional";

export default [
  {
    plugins: { functional },
    rules: {
      ...functional.configs.recommended.rules,
      ...functional.configs.disableTypeChecked.rules,
    },
  },
];

External Vanilla Recommended Configuration

External recommended configuration optimized for vanilla JavaScript projects.

/**
 * External recommended for vanilla JavaScript
 * Config: functional.configs.externalVanillaRecommended
 */
interface ExternalVanillaRecommendedConfig extends FlatConfig.Config {
  plugins: { functional: EslintPluginFunctional };
  rules: Record<string, RuleConfiguration>;
}

External TypeScript Recommended Configuration

External recommended configuration optimized for TypeScript projects.

/**
 * External recommended for TypeScript
 * Config: functional.configs.externalTypeScriptRecommended
 */
interface ExternalTypeScriptRecommendedConfig extends FlatConfig.Config {
  plugins: { functional: EslintPluginFunctional };
  rules: Record<string, RuleConfiguration>;
}

Currying Configuration

Rules focused on supporting and encouraging currying patterns.

/**
 * Rules for currying support
 * Config: functional.configs.currying
 */
interface CurryingConfig extends FlatConfig.Config {
  plugins: { functional: EslintPluginFunctional };
  rules: {
    "functional/functional-parameters": "error";
    "functional/prefer-tacit": "error";
    // ... other currying-related rules
  };
}

Usage Example:

import functional from "eslint-plugin-functional";

export default [
  {
    plugins: { functional },
    rules: {
      ...functional.configs.lite.rules,
      ...functional.configs.currying.rules,
    },
  },
];

No Exceptions Configuration

Rules that prevent exception-based error handling.

/**
 * Rules preventing exceptions
 * Config: functional.configs.noExceptions
 */
interface NoExceptionsConfig extends FlatConfig.Config {
  plugins: { functional: EslintPluginFunctional };
  rules: {
    "functional/no-promise-reject": "error";
    "functional/no-throw-statements": "error";
    "functional/no-try-statements": "error";
  };
}

No Mutations Configuration

Rules that prevent data mutations.

/**
 * Rules preventing mutations
 * Config: functional.configs.noMutations
 */
interface NoMutationsConfig extends FlatConfig.Config {
  plugins: { functional: EslintPluginFunctional };
  rules: {
    "functional/immutable-data": "error";
    "functional/no-let": "error";
    "functional/prefer-immutable-types": "error";
    "functional/readonly-type": "error";
    "functional/type-declaration-immutability": "error";
  };
}

No Other Paradigms Configuration

Rules that prevent non-functional programming paradigms.

/**
 * Rules preventing non-functional paradigms
 * Config: functional.configs.noOtherParadigms
 */
interface NoOtherParadigmsConfig extends FlatConfig.Config {
  plugins: { functional: EslintPluginFunctional };
  rules: {
    "functional/no-classes": "error";
    "functional/no-class-inheritance": "error";
    "functional/no-mixed-types": "error";
    "functional/no-this-expressions": "error";
  };
}

No Statements Configuration

Rules that prevent imperative statements.

/**
 * Rules preventing imperative statements
 * Config: functional.configs.noStatements
 */
interface NoStatementsConfig extends FlatConfig.Config {
  plugins: { functional: EslintPluginFunctional };
  rules: {
    "functional/no-conditional-statements": "error";
    "functional/no-expression-statements": "error";
    "functional/no-loop-statements": "error";
    "functional/no-return-void": "error";
  };
}

Stylistic Configuration

Stylistic functional programming rules that don't affect functionality but encourage better patterns.

/**
 * Stylistic functional programming rules
 * Config: functional.configs.stylistic
 */
interface StylisticConfig extends FlatConfig.Config {
  plugins: { functional: EslintPluginFunctional };
  rules: {
    "functional/prefer-property-signatures": "error";
    "functional/prefer-tacit": "error";
    // ... other stylistic rules
  };
}

Configuration Combining

You can combine multiple presets to create custom configurations:

Usage Examples:

import functional from "eslint-plugin-functional";

// Combine lite with specific focuses
export default [
  {
    plugins: { functional },
    rules: {
      ...functional.configs.lite.rules,
      ...functional.configs.noMutations.rules,
      ...functional.configs.stylistic.rules,
    },
  },
];

// Build custom strict configuration
export default [
  {
    plugins: { functional },
    rules: {
      ...functional.configs.recommended.rules,
      ...functional.configs.noExceptions.rules,
      ...functional.configs.noStatements.rules,
    },
  },
];

// TypeScript-specific configuration
export default [
  {
    plugins: { functional },
    rules: {
      ...functional.configs.externalTypeScriptRecommended.rules,
      ...functional.configs.noMutations.rules,
    },
  },
];

Types

type RuleConfiguration = 
  | "off" | 0
  | "warn" | 1  
  | "error" | 2
  | ["off" | "warn" | "error" | 0 | 1 | 2]
  | ["off" | "warn" | "error" | 0 | 1 | 2, any];

interface FlatConfig.Config {
  plugins?: Record<string, Plugin>;
  rules?: Record<string, RuleConfiguration>;
  files?: string[];
  ignores?: string[];
  languageOptions?: LanguageOptions;
  linterOptions?: LinterOptions;
  processor?: string | Processor;
  settings?: Record<string, any>;
}