tessl/npm-nx--eslint

The ESLint plugin for Nx contains executors, generators and utilities used for linting JavaScript/TypeScript projects within an Nx workspace.

—

Pending

Quality

Pending

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

Overview

Eval results

Files

Plugin Integration

Name: tessl/npm-nx--eslint
Author: tessl

Nx plugin functionality for automatic ESLint project inference and target creation, enabling seamless integration of ESLint into Nx workspace build systems.

Core Imports

import { createNodes, createNodesV2, EslintPluginOptions } from '@nx/eslint/plugin';
import type { CreateNodes, CreateNodesV2, CreateNodesResult, TargetConfiguration } from '@nx/devkit';

Capabilities

Create Nodes V2 (Recommended)

Modern plugin function for creating Nx project nodes from ESLint configurations with improved performance and caching.

/**
 * Creates Nx project nodes from ESLint configurations (V2 API)
 * @param configFiles - Array of configuration file paths
 * @param options - Plugin configuration options
 * @param context - Nx creation context with workspace information
 * @returns Promise resolving to array of creation results
 */
const createNodesV2: CreateNodesV2<EslintPluginOptions>;

type CreateNodesV2<T> = [
  configGlob: string,
  fn: (
    configFiles: readonly string[],
    options: T | undefined,
    context: CreateNodesContextV2
  ) => Promise<CreateNodesResult[]>
];

interface CreateNodesResult {
  projects?: Record<string, ProjectConfiguration>;
}

interface ProjectConfiguration {
  targets?: Record<string, TargetConfiguration>;
}

interface TargetConfiguration {
  command?: string;
  executor?: string;
  options?: Record<string, any>;
  cache?: boolean;
  inputs?: string[];
  outputs?: string[];
  metadata?: {
    technologies?: string[];
    description?: string;
    help?: {
      command?: string;
      example?: Record<string, any>;
    };
  };
}

Usage Examples:

// Plugin registration in nx.json
{
  "plugins": [
    {
      "plugin": "@nx/eslint/plugin",
      "options": {
        "targetName": "lint",
        "extensions": ["ts", "tsx", "js", "jsx"]
      }
    }
  ]
}

// Programmatic usage
import { createNodesV2 } from '@nx/eslint/plugin';

const [configGlob, createNodesFn] = createNodesV2;
const results = await createNodesFn(
  ['eslint.config.js', 'packages/*/eslint.config.js'],
  { targetName: 'lint' },
  context
);

Create Nodes (Legacy)

Legacy plugin function for backward compatibility (deprecated).

/**
 * Creates Nx project nodes (Legacy API - deprecated)
 * @param configFilePath - Path to ESLint configuration file
 * @param options - Plugin options
 * @param context - Creation context
 * @returns Creation result with project configurations
 */
const createNodes: CreateNodes<EslintPluginOptions>;

type CreateNodes<T> = [
  configGlob: string,
  fn: (
    configFilePath: string,
    options: T | undefined,
    context: CreateNodesContext
  ) => CreateNodesResult
];

Plugin Options

Configuration options for the ESLint plugin.

interface EslintPluginOptions {
  /** Name for the generated lint target */
  targetName?: string;
  /** File extensions to include in linting */
  extensions?: string[];
}

Default Configuration:

const defaultOptions: EslintPluginOptions = {
  targetName: 'lint',
  extensions: ['ts', 'cts', 'mts', 'tsx', 'js', 'cjs', 'mjs', 'jsx', 'html', 'vue']
};

Plugin Behavior

Target Generation

The plugin automatically creates lint targets for projects based on ESLint configuration files:

interface GeneratedTarget {
  command: string;
  cache: boolean;
  options: {
    cwd: string;
    env?: Record<string, string>;
  };
  inputs: string[];
  outputs: string[];
  metadata: {
    technologies: ['eslint'];
    description: 'Runs ESLint on project';
    help: {
      command: string;
      example: {
        options: Record<string, any>;
      };
    };
  };
}

Configuration File Detection

The plugin detects and processes various ESLint configuration formats:

eslint.config.js (Flat config)
eslint.config.mjs (Flat config ES modules)
eslint.config.cjs (Flat config CommonJS)
.eslintrc.json (Legacy format)
.eslintrc.js (Legacy format)
.eslintrc.yml / .eslintrc.yaml (Legacy format)

Project Inference

The plugin automatically infers project configurations based on:

interface InferenceFactors {
  /** ESLint configuration files in the project */
  configFiles: string[];
  /** Lintable files matching specified extensions */
  lintableFiles: string[];
  /** ESLint ignore patterns from .eslintignore */
  ignorePatterns: string[];
  /** Project metadata from project.json or package.json */
  projectMetadata: Record<string, any>;
}

Usage Examples:

// Automatic target creation for project with eslint.config.js
// Results in:
{
  "targets": {
    "lint": {
      "command": "eslint .",
      "cache": true,
      "options": {
        "cwd": "packages/my-lib"
      },
      "inputs": [
        "default",
        "^default",
        "{workspaceRoot}/eslint.config.js",
        "{workspaceRoot}/tools/eslint-rules/**/*",
        { "externalDependencies": ["eslint"] }
      ],
      "outputs": ["{options.outputFile}"]
    }
  }
}

Plugin Integration Points

The plugin integrates with Nx at several points:

interface PluginIntegration {
  /** File glob patterns for configuration detection */
  configGlob: string;
  /** Caching mechanisms for performance */
  projectsCache: Record<string, any>;
  /** Hash calculation for cache invalidation */
  hashCalculation: (context: any) => Promise<string>;
  /** Project root detection logic */
  projectRootInference: (files: string[]) => string[];
}

Advanced Configuration

Custom Extensions

// Register plugin with custom file extensions
{
  "plugins": [
    {
      "plugin": "@nx/eslint/plugin", 
      "options": {
        "extensions": ["ts", "tsx", "vue", "svelte"]
      }
    }
  ]
}

Custom Target Names

// Use custom target name
{
  "plugins": [
    {
      "plugin": "@nx/eslint/plugin",
      "options": {
        "targetName": "eslint-check"
      }
    }
  ]
}