or run

npx @tessl/cli init

Version

Tile

Overview

Evals

Files

docs

configuration-presets.md index.md plugin-configuration.md rules.md

tile.json

Configuration Presets

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>;
}

Version

Tile

Files