tessl/npm-eslint-import-resolver-typescript

TypeScript resolver plugin for eslint-plugin-import that enables TypeScript module resolution with path mapping and @types/* support

—

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

Resolver Factory

Name: tessl/npm-eslint-import-resolver-typescript
Author: tessl

Factory function for creating ESLint-compatible resolver instances with TypeScript support and automatic configuration detection.

Capabilities

Create TypeScript Import Resolver

Creates a resolver instance compatible with eslint-plugin-import-x (version 4.5.0+) that can be used directly in ESLint flat configuration.

/**
 * Creates an ESLint-compatible TypeScript import resolver
 * @param options - TypeScript resolver configuration options
 * @returns Resolver object with interfaceVersion 3, name, and resolve method
 */
function createTypeScriptImportResolver(
  options?: TypeScriptResolverOptions | null
): {
  interfaceVersion: 3;
  name: string;
  resolve(source: string, file: string): ResolvedResult;
};

Usage Examples:

import { createTypeScriptImportResolver } from "eslint-import-resolver-typescript";

// Basic resolver creation
const resolver = createTypeScriptImportResolver({
  alwaysTryTypes: true,
  project: "./tsconfig.json"
});

// Use in ESLint flat config
export default [
  {
    settings: {
      'import-x/resolver-next': [
        createTypeScriptImportResolver({
          alwaysTryTypes: true,
          bun: true,
          project: 'path/to/folder',
        }),
      ],
    },
  },
];

// Multiple TypeScript configurations
const monorepoResolver = createTypeScriptImportResolver({
  project: [
    'packages/*/tsconfig.json',
    'other-packages/*/jsconfig.json',
  ],
  noWarnOnMultipleProjects: true
});

// Glob pattern support
const globResolver = createTypeScriptImportResolver({
  project: 'packages/*/{ts,js}config.json'
});

Resolver Interface

The created resolver implements the ESLint resolver interface version 3:

interface EslintResolver {
  /** ESLint resolver interface version */
  interfaceVersion: 3;
  /** Resolver name identifier */
  name: string;
  /** 
   * Resolve method called by ESLint for each import
   * @param source - Module specifier to resolve
   * @param file - Current file path containing the import
   * @returns Resolution result
   */
  resolve(source: string, file: string): ResolvedResult;
}

Resolver Features

The created resolver provides several advanced features:

Context Awareness: Automatically detects ESLint rule context changes
Dynamic Reconfiguration: Reconfigures when working directory changes
Intelligent Caching: Maintains resolver instances across multiple files
Option Normalization: Automatically normalizes configuration options
Project Detection: Auto-detects TypeScript/JavaScript configurations

Configuration Options

The resolver factory accepts comprehensive configuration options:

interface TypeScriptResolverOptions extends NapiResolveOptions {
  /** TypeScript project configuration paths */
  project?: string[] | string;
  /** Whether to always try to resolve @types packages (default: true) */
  alwaysTryTypes?: boolean;
  /** Whether Bun core modules should be accounted for */
  bun?: boolean;
  /** Suppress multiple projects warning */
  noWarnOnMultipleProjects?: boolean;
  
  // Inherited from NapiResolveOptions
  /** Condition names for package.json exports resolution */
  conditionNames?: string[];
  /** File extensions to resolve */
  extensions?: string[];
  /** Extension aliases for TypeScript compilation */
  extensionAlias?: Record<string, string[]>;
  /** Package.json main fields priority */
  mainFields?: string[];
}

Configuration Examples

Single Project Configuration:

const resolver = createTypeScriptImportResolver({
  project: './tsconfig.json',
  alwaysTryTypes: true
});

Monorepo Configuration:

const resolver = createTypeScriptImportResolver({
  project: [
    'packages/module-a/tsconfig.json',
    'packages/module-b/jsconfig.json',
  ],
  noWarnOnMultipleProjects: true
});

Glob Pattern Configuration:

const resolver = createTypeScriptImportResolver({
  project: 'packages/*/{ts,js}config.json'
});

Bun Environment Configuration:

const resolver = createTypeScriptImportResolver({
  bun: true,
  project: './tsconfig.json'
});

Custom Extensions and Conditions:

const resolver = createTypeScriptImportResolver({
  extensions: ['.ts', '.tsx', '.js', '.jsx', '.mjs'],
  conditionNames: ['types', 'import', 'require', 'default'],
  mainFields: ['types', 'module', 'main']
});

Legacy ESLint Configuration

For older versions of eslint-plugin-import or eslint-plugin-import-x, use the traditional configuration approach:

{
  "settings": {
    "import/resolver": {
      "typescript": {
        "alwaysTryTypes": true,
        "project": "./tsconfig.json"
      }
    }
  }
}

Performance Considerations

The resolver factory implements several performance optimizations:

Resolver Caching: Reuses resolver instances across multiple files
Configuration Caching: Caches normalized options to avoid recomputation
Context Tracking: Only recreates resolvers when necessary
Lazy Initialization: Defers expensive operations until needed

These optimizations ensure that the resolver performs efficiently even in large codebases with complex TypeScript configurations.

Install with Tessl CLI

npx tessl i tessl/npm-eslint-import-resolver-typescript

docs

tessl/npm-eslint-import-resolver-typescript