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

Plugin Configuration

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

Core plugin functionality including metadata, rule registration, and configuration management for ESLint Plugin Functional.

Capabilities

Plugin Object

The main plugin export that provides ESLint with rule definitions and configurations.

/**
 * Main plugin object containing meta, rules, and configs
 */
interface EslintPluginFunctional {
  meta: PluginMeta;
  rules: Rules;
  configs: Configs;
}

interface PluginMeta {
  name: "eslint-plugin-functional";
  version: string;
}

declare const plugin: EslintPluginFunctional;
export default plugin;

Usage Example:

import functional from "eslint-plugin-functional";

// Access plugin metadata
console.log(functional.meta.name); // "eslint-plugin-functional"
console.log(functional.meta.version); // "9.0.2"

// Use in ESLint configuration
export default [
  {
    plugins: {
      functional,
    },
    rules: {
      "functional/no-let": "error",
    },
  },
];

Plugin Metadata

Information about the plugin including name and version.

/**
 * Plugin metadata containing name and version information
 */
interface PluginMeta {
  /** Plugin name: "eslint-plugin-functional" */
  name: "eslint-plugin-functional";
  /** Plugin version string */
  version: string;
}

Rules Registry

Registry containing all available ESLint rules provided by the plugin.

/**
 * All rules provided by the plugin, keyed by rule name
 */
type Rules = Record<string, ESLintRule>;

interface ESLintRule {
  meta: RuleMeta;
  create(context: RuleContext): RuleListener;
}

interface RuleMeta {
  type: "problem" | "suggestion" | "layout";
  docs: {
    description: string;
    recommended?: boolean | "recommended" | "strict";
    category: string;
    requiresTypeChecking?: boolean;
    recommendedSeverity?: "error" | "warn";
  };
  schema: JSONSchema4 | JSONSchema4[];
  deprecated?: boolean;
  fixable?: "code" | "whitespace";
  hasSuggestions?: boolean;
}

type RuleListener = Record<string, (node: any) => void>;

Usage Example:

import functional from "eslint-plugin-functional";

// Access specific rule
const noLetRule = functional.rules["no-let"];
console.log(noLetRule.meta.docs.description);

// List all available rules
const ruleNames = Object.keys(functional.rules);
console.log(ruleNames); // ["functional-parameters", "immutable-data", ...]

Configuration Registry

Registry containing all predefined rule configurations for different use cases.

/**
 * Predefined configurations combining multiple rules
 */
type Configs = Record<string, FlatConfig.Config>;

interface FlatConfig.Config {
  plugins?: Record<string, Plugin>;
  rules?: Record<string, RuleConfiguration>;
  files?: string[];
  ignores?: string[];
  languageOptions?: LanguageOptions;
}

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

Usage Example:

import functional from "eslint-plugin-functional";

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

// Combine multiple configurations
export default [
  {
    plugins: { functional },
    rules: {
      ...functional.configs.lite.rules,
      ...functional.configs.stylistic.rules,
    },
  },
];

Types

import type { FlatConfig } from "@typescript-eslint/utils/ts-eslint";
import type { JSONSchema4 } from "@typescript-eslint/utils/json-schema";

interface RuleContext {
  id: string;
  options: any[];
  settings: Record<string, any>;
  parserPath: string;
  parserServices?: any;
  getAncestors(): any[];
  getDeclaredVariables(node: any): any[];
  getFilename(): string;
  getPhysicalFilename(): string;
  getScope(): any;
  getSourceCode(): any;
  markVariableAsUsed(name: string): boolean;
  report(descriptor: ReportDescriptor): void;
}

interface ReportDescriptor {
  node: any;
  loc?: SourceLocation;
  message: string;
  data?: Record<string, any>;
  fix?: (fixer: RuleFixer) => Fix | Fix[] | null;
  suggest?: SuggestionDescriptor[];
}

interface LanguageOptions {
  ecmaVersion?: number | "latest";
  sourceType?: "script" | "module";
  globals?: Record<string, boolean>;
  parser?: any;
  parserOptions?: any;
}