or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

configuration-presets.mdhelpful-warnings-rules.mdindex.mdmodule-systems-rules.mdplugin-interface.mdstatic-analysis-rules.mdstyle-guide-rules.md
tile.json

tessl/npm-eslint-plugin-import

ESLint plugin that enforces ES2015+ import/export syntax rules and prevents common issues with module imports.

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
npmpkg:npm/eslint-plugin-import@2.32.x

To install, run

npx @tessl/cli install tessl/npm-eslint-plugin-import@2.32.0

index.mddocs/

ESLint Plugin Import

ESLint Plugin Import provides comprehensive linting rules for ES2015+ (ES6+) import/export syntax. It helps prevent issues with misspelling of file paths and import names, enforces proper module resolution, detects circular dependencies, and maintains consistent import ordering and formatting. The plugin offers static analysis capabilities to validate import statements and supports maximum compatibility across different JavaScript environments and build tools.

Package Information

  • Package Name: eslint-plugin-import
  • Package Type: npm
  • Language: JavaScript/TypeScript
  • Installation: npm install eslint-plugin-import --save-dev

Core Imports

// For ESLint flat config (ESLint 9+)
import importPlugin from "eslint-plugin-import";

// For legacy ESLint config
module.exports = {
  plugins: ["import"],
  extends: ["plugin:import/recommended"]
};

Basic Usage

ESLint Flat Config (ESLint 9+)

import importPlugin from "eslint-plugin-import";

export default [
  {
    name: "import/recommended",
    plugins: { import: importPlugin },
    rules: {
      ...importPlugin.flatConfigs.recommended.rules,
    },
    languageOptions: {
      ecmaVersion: 2018,
      sourceType: "module",
    },
  },
];

Legacy ESLint Config

module.exports = {
  plugins: ["import"],
  extends: ["plugin:import/recommended"],
  rules: {
    "import/no-unresolved": "error",
    "import/no-duplicates": "warn",
    "import/order": ["error", {
      "groups": ["builtin", "external", "internal", "parent", "sibling", "index"],
      "newlines-between": "always"
    }]
  }
};

Architecture

ESLint Plugin Import is structured around several key components:

  • Plugin System: Standard ESLint plugin interface with rules, configs, and metadata
  • Rule Categories: 46 rules organized into Helpful Warnings, Module Systems, Static Analysis, and Style Guide categories
  • Configuration Presets: 8 pre-configured rule sets for different environments (recommended, React, TypeScript, etc.)
  • Dual Config Support: Both legacy ESLint configs and modern flat configs for ESLint 9+
  • Static Analysis Engine: Core utilities for import resolution, cycle detection, and module analysis

Capabilities

Plugin Interface

Core plugin structure and metadata for ESLint integration.

interface ImportPlugin {
  meta: {
    name: string;
    version: string;
  };
  rules: { [ruleName: string]: Rule.RuleModule };
  configs: { [configName: string]: Linter.LegacyConfig };
  flatConfigs: { [configName: string]: Linter.FlatConfig };
}

Plugin Interface

Rule Categories

Collection of 46 ESLint rules organized by functionality for comprehensive import/export validation.

interface RuleModule {
  meta: {
    type: "problem" | "suggestion" | "layout";
    docs: {
      category: string;
      description: string;
      url: string;
    };
    schema: Array<any>;
    fixable?: "code" | "whitespace";
  };
  create(context: Rule.RuleContext): Rule.RuleListener;
}

Rule Categories:

  • Helpful Warnings (8 rules): Detect problematic patterns like invalid exports and deprecated imports
  • Module Systems (5 rules): Enforce ES modules vs CommonJS/AMD usage
  • Static Analysis (15 rules): Validate import resolution, cycles, and module structure
  • Style Guide (18 rules): Enforce consistent import formatting and organization

Helpful Warnings Rules

Module Systems Rules

Static Analysis Rules

Style Guide Rules

Configuration Presets

Pre-configured rule sets optimized for different environments and use cases.

interface LegacyConfig {
  plugins: string[];
  rules: { [ruleName: string]: string | [string, ...any[]] };
  parserOptions?: {
    sourceType: "module" | "script";
    ecmaVersion: number;
  };
}

interface FlatConfig {
  name: string; 
  plugins: { import: ImportPlugin };
  rules: { [ruleName: string]: string | [string, ...any[]] };
  languageOptions?: {
    sourceType: "module" | "script";
    ecmaVersion: number;
  };
}

Available Configurations:

  • recommended: Essential rules for import/export validation
  • errors: Error-level rules only
  • warnings: Warning-level rules only
  • react: React-specific optimizations
  • react-native: React Native environment
  • electron: Electron application support
  • typescript: TypeScript project optimizations

Legacy-only configurations (not available in flat configs):

  • stage-0: Experimental rules

Configuration Presets

Types

// Core plugin interface
interface ImportPlugin {
  meta: {
    name: string;
    version: string;
  };
  rules: { [ruleName: string]: Rule.RuleModule };
  configs: { [configName: string]: Linter.LegacyConfig };
  flatConfigs: { [configName: string]: Linter.FlatConfig };
}

// Rule severity levels
type RuleSeverity = "off" | "warn" | "error" | 0 | 1 | 2;

// Rule configuration
type RuleConfig = RuleSeverity | [RuleSeverity, ...any[]];

// Configuration objects  
interface LegacyConfig {
  plugins?: string[];
  extends?: string[];
  rules?: { [ruleName: string]: RuleConfig };
  parserOptions?: {
    sourceType?: "module" | "script";
    ecmaVersion?: number;
  };
}

interface FlatConfig {
  name?: string;
  plugins?: { [name: string]: any };
  rules?: { [ruleName: string]: RuleConfig };
  languageOptions?: {
    sourceType?: "module" | "script"; 
    ecmaVersion?: number;
  };
}