tessl/npm-typescript-eslint--typescript-estree

A parser that converts TypeScript source code into an ESTree compatible form

—

Pending

Overview

Eval results

Files

Program Management

Name: tessl/npm-typescript-eslint--typescript-estree
Author: tessl

Functions for creating and managing TypeScript programs with sophisticated caching. These utilities handle TypeScript program creation, file system operations, and cache management for optimal performance.

Capabilities

Program Creation

Functions for creating TypeScript programs from configuration files and managing program lifecycle.

/**
 * Creates a TypeScript program from a config file
 * @param configFile - Path to tsconfig.json file
 * @returns TypeScript Program instance
 */
function createProgram(configFile: string): ts.Program;

/**
 * Gets the canonical file name for the current file system
 * @param fileName - File path to canonicalize
 * @returns Canonical file name respecting case sensitivity
 */
function getCanonicalFileName(fileName: string): string;

Usage Examples:

import { createProgram, getCanonicalFileName } from "@typescript-eslint/typescript-estree";

// Create program from config
const program = createProgram('./tsconfig.json');
const checker = program.getTypeChecker();

// Get canonical file names
const canonical = getCanonicalFileName('/path/to/File.ts');
// On case-insensitive systems: '/path/to/file.ts'
// On case-sensitive systems: '/path/to/File.ts'

Script Kind Utilities

Functions for determining TypeScript script kinds and language variants from file paths.

/**
 * Determines TypeScript script kind from file path and JSX setting
 * @param filePath - Path to the file
 * @param jsx - Whether JSX is enabled for unknown extensions
 * @returns TypeScript ScriptKind enum value
 */
function getScriptKind(filePath: string, jsx: boolean): ts.ScriptKind;

/**
 * Gets language variant from script kind
 * @param scriptKind - TypeScript ScriptKind
 * @returns Language variant (JSX or Standard)
 */
function getLanguageVariant(scriptKind: ts.ScriptKind): ts.LanguageVariant;

Usage Examples:

import { getScriptKind, getLanguageVariant } from "@typescript-eslint/typescript-estree";

// Determine script kinds
const jsKind = getScriptKind('file.js', false);     // ScriptKind.JS
const tsKind = getScriptKind('file.ts', false);     // ScriptKind.TS
const jsxKind = getScriptKind('file.jsx', false);   // ScriptKind.JSX
const tsxKind = getScriptKind('file.tsx', false);   // ScriptKind.TSX
const unknownKind = getScriptKind('file.vue', true); // ScriptKind.TSX (jsx=true)

// Get language variants
const jsxVariant = getLanguageVariant(jsxKind);     // LanguageVariant.JSX
const standardVariant = getLanguageVariant(tsKind); // LanguageVariant.Standard

Cache Management

Comprehensive cache clearing functions for managing internal parser state and memory usage.

/**
 * Clears all internal caches including programs, configurations, and globs
 * Use in tests or iterative linting to prevent memory leaks
 */
function clearCaches(): void;

/**
 * @deprecated Use clearCaches() instead
 * Legacy alias for clearCaches function
 */
function clearProgramCache(): void;

Usage Examples:

import { clearCaches } from "@typescript-eslint/typescript-estree";

// Clear all caches (recommended)
clearCaches();

// In testing scenarios
afterEach(() => {
  clearCaches();
});

// In long-running processes between projects
function processProject(projectPath: string) {
  // ... process project
  clearCaches(); // Clean up for next project
}

Internal Cache Functions

Internal cache management functions for specific cache types (primarily for testing).

/**
 * Clears watch program caches
 * @internal
 */
function clearWatchCaches(): void;

/**
 * Clears default project matched files cache
 * @internal
 */
function clearDefaultProjectMatchedFiles(): void;

/**
 * Clears TSConfig match cache
 * @internal
 */
function clearTSConfigMatchCache(): void;

/**
 * Clears TypeScript server project service
 * @internal
 */
function clearTSServerProjectService(): void;

/**
 * Clears glob resolution cache
 * @internal
 */
function clearGlobCache(): void;

Configuration Management

Functions for managing TypeScript configuration root directories and project detection.

/**
 * Adds a candidate directory for TypeScript config root detection
 * @param candidate - Directory path to add as candidate
 */
function addCandidateTSConfigRootDir(candidate: string): void;

/**
 * Clears all candidate TypeScript config root directories
 */
function clearCandidateTSConfigRootDirs(): void;

/**
 * Gets the inferred TypeScript config root directory
 * @returns Inferred root directory path
 * @throws Error if multiple candidates exist without explicit setting
 * @internal
 */
function getInferredTSConfigRootDir(): string;

Usage Examples:

import { 
  addCandidateTSConfigRootDir,
  clearCandidateTSConfigRootDirs
} from "@typescript-eslint/typescript-estree";

// Add candidate directories
addCandidateTSConfigRootDir('/project1');
addCandidateTSConfigRootDir('/project2');

// Clear candidates (typically in cleanup)
clearCandidateTSConfigRootDirs();

Program and File System Types

// Internal program result types
interface ASTAndNoProgram {
  ast: ts.SourceFile;
  program: null;
}

interface ASTAndDefiniteProgram {
  ast: ts.SourceFile;
  program: ts.Program;
}

type ASTAndProgram = ASTAndDefiniteProgram | ASTAndNoProgram;

// Canonical path type for file system operations
type CanonicalPath = string & { __brand: 'CanonicalPath' };

// Default file extensions supported
const DEFAULT_EXTRA_FILE_EXTENSIONS: Set<string>;

// Default compiler options for program creation
interface DefaultCompilerOptions extends ts.CompilerOptions {
  allowJs: true;
  allowNonTsExtensions: true;
  checkJs: true;
  // ... additional core options
}

Install with Tessl CLI

npx tessl i tessl/npm-typescript-eslint--typescript-estree

docs

program-management.md

type-system.md

tile.json

tessl/npm-typescript-eslint--typescript-estree