Plugin Configuration

/**
 * 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;

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 containing name and version information
 */
interface PluginMeta {
  /** Plugin name: "eslint-plugin-functional" */
  name: "eslint-plugin-functional";
  /** Plugin version string */
  version: string;
}

/**
 * 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>;

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", ...]

/**
 * 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];

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

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