@rslint/core 0.6.3 → 0.6.5

package/dist/index.d.ts

@@ -1,32 +1,10 @@
-export declare function applyFixes(options: ApplyFixesRequest): Promise<ApplyFixesResponse>;
-
-export declare interface ApplyFixesRequest {
-    fileContent: string;
-    diagnostics: Diagnostic[];
-}
-
-export declare interface ApplyFixesResponse {
-    fixedContent: string[];
-    wasFixed: boolean;
-    appliedCount: number;
-    unappliedCount: number;
-}
+/// <reference lib="esnext.disposable" />
 
 /**
  * Type-safe config helper. Returns the config array as-is (identity function).
  */
 export declare function defineConfig(config: RslintConfig): RslintConfig;
 
-export declare interface Diagnostic {
-    ruleName: string;
-    message: string;
-    messageId: string;
-    filePath: string;
-    range: Range;
-    severity?: string;
-    suggestions: any[];
-}
-
 /**
  * A real ESLint plugin object, as exported by community packages
  * (`eslint-plugin-unicorn`, etc.). Only the fields rslint consumes are
@@ -43,75 +21,6 @@ export declare interface ESLintPlugin {
     [key: string]: unknown;
 }
 
-/**
- * Edge in the flow graph (from antecedent to current)
- */
-declare interface FlowEdge {
-    from: number;
-    to: number;
-}
-
-/**
- * Flow graph for visualization
- */
-declare interface FlowGraph {
-    nodes: FlowGraphNode[];
-    edges: FlowEdge[];
-}
-
-/**
- * Node in the flow graph
- */
-declare interface FlowGraphNode {
-    id: number;
-    flags: number;
-    flagNames?: string[];
-    nodePos?: number;
-    nodeEnd?: number;
-    nodeKindName?: string;
-}
-
-/**
- * Control flow analysis information
- */
-export declare interface FlowInfo {
-    flags: number;
-    flagNames?: string[];
-    nodeKind?: number;
-    nodeKindName?: string;
-    nodePos?: number;
-    nodeEnd?: number;
-    antecedent?: FlowInfo;
-    antecedents?: FlowInfo[];
-    graph?: FlowGraph;
-}
-
-export declare function getAstInfo(options: GetAstInfoRequest): Promise<GetAstInfoResponse>;
-
-/**
- * Request for AST info at a specific position
- */
-export declare interface GetAstInfoRequest {
-    fileContent: string;
-    position: number;
-    end?: number;
-    kind?: number;
-    depth?: number;
-    fileName?: string;
-    compilerOptions?: Record<string, unknown>;
-}
-
-/**
- * Response containing detailed AST information
- */
-export declare interface GetAstInfoResponse {
-    node?: NodeInfo;
-    type?: TypeInfo;
-    symbol?: SymbolInfo;
-    signature?: SignatureInfo;
-    flow?: FlowInfo;
-}
-
 /**
  * Define a global-ignores config entry.
  *
@@ -134,15 +43,6 @@ export declare const importPlugin: {
     };
 };
 
-/**
- * Index signature information
- */
-export declare interface IndexInfo {
-    keyType: TypeInfo;
-    valueType: TypeInfo;
-    isReadonly: boolean;
-}
-
 export declare const jestPlugin: {
     configs: {
         recommended: RslintConfigEntry;
@@ -167,36 +67,47 @@ export declare const jsxA11yPlugin: {
  */
 declare type KnownPlugin = (typeof NATIVE_PLUGINS)[number];
 
-export declare interface LanguageOptions {
-    parserOptions?: ParserOptions;
-}
-
 /**
  * Language-specific configuration.
  */
-declare interface LanguageOptions_2 {
-    parserOptions?: ParserOptions_2;
+declare interface LanguageOptions {
+    parserOptions?: ParserOptions;
 }
 
-export declare function lint(options: LintOptions): Promise<LintResponse>;
+export declare interface LintMessage {
+    ruleId: string | null;
+    severity: 1 | 2;
+    message: string;
+    messageId?: string;
+    line: number;
+    column: number;
+    endLine?: number;
+    endColumn?: number;
+    fix?: LintMessageFix;
+    suggestions?: LintSuggestion[];
+}
 
-export declare interface LintOptions {
-    files?: string[];
-    config?: string;
-    workingDirectory?: string;
-    ruleOptions?: Record<string, string>;
-    fileContents?: Record<string, string>;
-    languageOptions?: LanguageOptions;
-    includeEncodedSourceFiles?: boolean;
+/** A single fix edit as a flat UTF-16 offset range + replacement text (ESLint shape). */
+export declare interface LintMessageFix {
+    range: [number, number];
+    text: string;
 }
 
-export declare interface LintResponse {
-    diagnostics: Diagnostic[];
+export declare interface LintResult {
+    filePath: string;
+    messages: LintMessage[];
     errorCount: number;
-    fileCount: number;
-    ruleCount: number;
-    duration: string;
-    encodedSourceFiles?: Record<string, string>;
+    warningCount: number;
+    fixableErrorCount: number;
+    fixableWarningCount: number;
+    output?: string;
+}
+
+export declare interface LintSuggestion {
+    messageId?: string;
+    data?: Record<string, string>;
+    desc: string;
+    fix: LintMessageFix;
 }
 
 /**
@@ -209,144 +120,10 @@ export declare interface LintResponse {
  */
 declare const NATIVE_PLUGINS: readonly ["@typescript-eslint", "import", "jest", "jsx-a11y", "promise", "react", "react-hooks", "unicorn"];
 
-/**
- * Detailed information about an AST node
- */
-export declare interface NodeInfo {
-    id?: number;
-    kind: number;
-    kindName: string;
-    pos: number;
-    end: number;
-    flags: number;
-    flagNames?: string[];
-    text?: string;
-    fileName?: string;
-    parent?: NodeInfo;
-    name?: NodeInfo;
-    expression?: NodeInfo;
-    left?: NodeInfo;
-    right?: NodeInfo;
-    operatorToken?: NodeInfo;
-    operand?: NodeInfo;
-    condition?: NodeInfo;
-    whenTrue?: NodeInfo;
-    whenFalse?: NodeInfo;
-    thenStatement?: NodeInfo;
-    elseStatement?: NodeInfo;
-    body?: NodeInfo;
-    initializer?: NodeInfo;
-    type?: NodeInfo;
-    members?: NodeInfo[];
-    heritageClauses?: NodeInfo[];
-    typeParameters?: NodeInfo[];
-    parameters?: NodeInfo[];
-    modifiers?: NodeInfo[];
-    arguments?: NodeInfo[];
-    statements?: NodeInfo[];
-    properties?: NodeInfo[];
-    elements?: NodeInfo[];
-    declarationList?: NodeInfo;
-    declarations?: NodeInfo[];
-    importClause?: NodeInfo;
-    moduleSpecifier?: NodeInfo;
-    namedBindings?: NodeInfo;
-    exportClause?: NodeInfo;
-    incrementor?: NodeInfo;
-    statement?: NodeInfo;
-    caseBlock?: NodeInfo;
-    clauses?: NodeInfo[];
-    tryBlock?: NodeInfo;
-    catchClause?: NodeInfo;
-    finallyBlock?: NodeInfo;
-    variableDeclaration?: NodeInfo;
-    block?: NodeInfo;
-    argumentExpression?: NodeInfo;
-    equalsToken?: NodeInfo;
-    objectAssignmentInitializer?: NodeInfo;
-    head?: NodeInfo;
-    templateSpans?: NodeInfo[];
-    literal?: NodeInfo;
-    tag?: NodeInfo;
-    template?: NodeInfo;
-    questionToken?: NodeInfo;
-    dotDotDotToken?: NodeInfo;
-    exclamationToken?: NodeInfo;
-    asteriskToken?: NodeInfo;
-    equalsGreaterThanToken?: NodeInfo;
-    questionDotToken?: NodeInfo;
-    typeArguments?: NodeInfo[];
-    constraint?: NodeInfo;
-    defaultType?: NodeInfo;
-    locals?: SymbolInfo[];
-    endOfFileToken?: NodeInfo;
-    imports?: NodeInfo[];
-    isDeclarationFile?: boolean;
-    scriptKind?: number;
-    identifierCount?: number;
-    symbolCount?: number;
-    nodeCount?: number;
-    listMetas?: Record<string, NodeListMeta>;
-}
-
-/**
- * NodeList metadata (Pos, End, HasTrailingComma)
- */
-declare interface NodeListMeta {
-    pos: number;
-    end: number;
-    hasTrailingComma: boolean;
-}
-
-/**
- * Node.js implementation of RslintService using child processes
- */
-export declare class NodeRslintService implements RslintServiceInterface {
-    private nextMessageId;
-    private readonly pendingMessages;
-    private readonly rslintPath;
-    private readonly process;
-    private chunks;
-    private chunkSize;
-    private expectedSize;
-    constructor(options?: RSlintOptions);
-    /**
-     * Send a message to the rslint process
-     */
-    sendMessage(kind: string, data: any): Promise<any>;
-    /**
-     * Handle incoming binary data chunks
-     */
-    private handleChunk;
-    /**
-     * Handle a complete message from rslint
-     */
-    private handleMessage;
-    /**
-     * Terminate the rslint process
-     */
-    terminate(): void;
-}
-
-/**
- * Function parameter information (deprecated - use SymbolInfo instead)
- */
-export declare interface ParameterInfo {
-    name: string;
-    type?: TypeInfo;
-    optional: boolean;
-    rest: boolean;
-}
-
-export declare interface ParserOptions {
-    projectService?: boolean;
-    project?: string[] | string;
-}
-
 /**
  * TypeScript parser options. `project` may be a single tsconfig path or a list.
  */
-declare interface ParserOptions_2 {
+declare interface ParserOptions {
     /**
      * Enable project service for typed linting (runs the TypeScript language
      * service behind the scenes).
@@ -365,25 +142,12 @@ declare interface ParserOptions_2 {
     project?: string | string[];
 }
 
-/**
- * Shared types for rslint IPC protocol across all environments
- */
-declare interface Position {
-    line: number;
-    column: number;
-}
-
 export declare const promisePlugin: {
     configs: {
         recommended: RslintConfigEntry;
     };
 };
 
-declare interface Range {
-    start: Position;
-    end: Position;
-}
-
 export declare const reactHooksPlugin: {
     configs: {
         recommended: RslintConfigEntry;
@@ -396,8 +160,43 @@ export declare const reactPlugin: {
     };
 };
 
+export declare class Rslint {
+    #private;
+    constructor(options?: RslintOptions);
+    /**
+     * Lint a string of code as if it lived at `filePath` (default a synthetic
+     * `.ts` path).
+     *
+     * ESLint-alignment note: if `code` begins with a UTF-8 BOM, the reported
+     * offsets (`fix.range`, `column`) are relative to the BOM-included input you
+     * passed — self-consistent within that input (result `output`, line/column,
+     * and re-applying `fix` all line up), but one unit ahead of ESLint v10, which
+     * strips a leading BOM from its in-memory source. (The overlay keeps the BOM
+     * and Go's offsets include it; lintFiles is unaffected because Go reads disk
+     * files BOM-stripped.) Strip a leading `U+FEFF` first for ESLint-identical
+     * offsets.
+     */
+    lintText(code: string, options?: {
+        filePath?: string;
+    }): Promise<LintResult[]>;
+    /**
+     * Lint files matched by glob pattern(s), resolved against `cwd`. Results are
+     * ordered by the linted file's path (deterministic), not by glob-walk order.
+     */
+    lintFiles(patterns: string | string[]): Promise<LintResult[]>;
+    /**
+     * Write the `output` of each result back to its file. Mirrors ESLint's
+     * guards: only when `output` is a string and `filePath` is absolute (so a
+     * lintText `<text>` result is skipped automatically).
+     */
+    static outputFixes(results: LintResult[]): Promise<void>;
+    /** Tear down the long-lived Go `--api` process. */
+    close(): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
+}
+
 /** Top-level rslint config: an array of entries. */
-declare type RslintConfig = RslintConfigEntry[];
+export declare type RslintConfig = RslintConfigEntry[];
 
 /**
  * A single entry in an rslint config array. Multiple entries may target
@@ -419,7 +218,7 @@ export declare interface RslintConfigEntry {
      */
     ignores?: string[];
     /** Language-level configuration (parser, etc.). */
-    languageOptions?: LanguageOptions_2;
+    languageOptions?: LanguageOptions;
     /**
      * Plugins enabled for this entry. Two forms:
      *
@@ -457,39 +256,34 @@ export declare interface RslintConfigEntry {
     rules?: RulesRecord;
 }
 
-export declare interface RSlintOptions {
-    rslintPath?: string;
-    workingDirectory?: string;
-}
-
-/**
- * Main RslintService class that automatically uses the appropriate implementation
- */
-export declare class RSLintService {
-    private readonly service;
-    constructor(service: RslintServiceInterface);
-    /**
-     * Run the linter on specified files
-     */
-    lint(options?: LintOptions): Promise<LintResponse>;
-    /**
-     * Apply fixes to a file based on diagnostics
-     */
-    applyFixes(options: ApplyFixesRequest): Promise<ApplyFixesResponse>;
+export declare interface RslintOptions {
+    /** Base directory for config discovery and relative path resolution. */
+    cwd?: string;
+    /** Extra config appended after the resolved/discovered config (ESLint's overrideConfig). */
+    overrideConfig?: RslintConfigEntry | RslintConfigEntry[] | null;
     /**
-     * Get detailed AST information at a specific position
-     * Returns Node, Type, Symbol, Signature, and Flow information
+     * `string` — use this config file (no discovery).
+     * `true`   — use only `overrideConfig` (no file, no discovery).
+     * `null`/absent — auto-discover the nearest config (ESLint v10 semantics; no `false`).
      */
-    getAstInfo(options: GetAstInfoRequest): Promise<GetAstInfoResponse>;
+    overrideConfigFile?: string | true | null;
+    /** Apply rule auto-fixes; results carry `output` (the JS side persists via outputFixes). */
+    fix?: boolean;
     /**
-     * Close the service
+     * In-memory file overlay (path → content) for fully in-memory linting (issue
+     * #1106): put the `tsconfig.json` that `parserOptions.project` names plus any
+     * dependency files here, then lint a buffer with `lintText`. Keys resolve
+     * against `cwd` like a linted path (relative or absolute both work); a
+     * same-path `lintText` code entry wins. Inside the tsconfig (`files`) and
+     * `parserOptions.project`, use relative paths — the TS compiler resolves
+     * those, and a bare POSIX-absolute path there has no drive letter on Windows,
+     * so it won't match the overlay. rslint-only — ESLint has no in-memory file
+     * map.
+     *
+     * Give the tsconfig explicit `files`, not a broad `include` glob: a glob is
+     * expanded against the real filesystem and would scan `cwd` on disk.
      */
-    close(): Promise<void>;
-}
-
-export declare interface RslintServiceInterface {
-    sendMessage(kind: string, data: any): Promise<any>;
-    terminate(): void;
+    virtualFiles?: Record<string, string>;
 }
 
 /**
@@ -524,41 +318,15 @@ declare type RuleSeverity = 'off' | 'warn' | 'error';
  */
 declare type RulesRecord = Record<string, RuleEntry>;
 
-/**
- * Detailed information about a function/method signature
- */
-export declare interface SignatureInfo {
-    flags: number;
-    flagNames?: string[];
-    minArgumentCount: number;
-    pos?: number;
-    fileName?: string;
-    parameters?: SymbolInfo[];
-    thisParameter?: SymbolInfo;
-    typeParameters?: TypeInfo[];
-    returnType?: TypeInfo;
-    typePredicate?: TypePredicateInfo;
-    declaration?: NodeInfo;
-}
+export declare function runCLI({ argv, }?: RunCLIOptions): Promise<void>;
 
-/**
- * Detailed information about a TypeScript symbol
- */
-export declare interface SymbolInfo {
-    id?: number;
-    name: string;
-    escapedName?: string;
-    flags: number;
-    flagNames?: string[];
-    checkFlags?: number;
-    checkFlagNames?: string[];
-    pos?: number;
-    fileName?: string;
-    declarations?: NodeInfo[];
-    valueDeclaration?: NodeInfo;
-    members?: SymbolInfo[];
-    exports?: SymbolInfo[];
-}
+export declare type RunCLIOptions = {
+    /**
+     * The command-line arguments to parse, matching the shape of Node.js `process.argv`
+     * @default process.argv
+     */
+    argv?: string[];
+};
 
 export declare const ts: {
     configs: {
@@ -567,56 +335,6 @@ export declare const ts: {
     };
 };
 
-/**
- * Detailed information about a TypeScript type
- */
-export declare interface TypeInfo {
-    id?: number;
-    flags: number;
-    flagNames?: string[];
-    objectFlags?: number;
-    objectFlagNames?: string[];
-    intrinsicName?: string;
-    typeString: string;
-    pos?: number;
-    fileName?: string;
-    value?: unknown;
-    freshType?: TypeInfo;
-    regularType?: TypeInfo;
-    symbol?: SymbolInfo;
-    aliasSymbol?: SymbolInfo;
-    typeArguments?: TypeInfo[];
-    baseTypes?: TypeInfo[];
-    properties?: SymbolInfo[];
-    callSignatures?: SignatureInfo[];
-    constructSignatures?: SignatureInfo[];
-    indexInfos?: IndexInfo[];
-    types?: TypeInfo[];
-    constraint?: TypeInfo;
-    default?: TypeInfo;
-    target?: TypeInfo;
-}
-
-/**
- * Generic type parameter information
- */
-export declare interface TypeParamInfo {
-    name: string;
-    constraint?: TypeInfo;
-    default?: TypeInfo;
-}
-
-/**
- * Type predicate information for type guards
- */
-export declare interface TypePredicateInfo {
-    kind: number;
-    kindName: string;
-    parameterName?: string;
-    parameterIndex?: number;
-    type?: TypeInfo;
-}
-
 export declare const unicornPlugin: {
     configs: {
         recommended: RslintConfigEntry;