@lpc-lang/core/server/session.d.ts

LPC Language Compiler Library

/// <reference types="node" />
import { CompletionEntryDetails, LanguageServiceMode, RenameLocation } from "./_namespaces/lpc";
import { Logger, NormalizedPath, Project, ProjectService, ProjectServiceEventHandler, ServerHost } from "./_namespaces/lpc.server";
import * as protocol from "./protocol.js";
export interface HostCancellationToken {
    isCancellationRequested(): boolean;
}
export interface ServerCancellationToken extends HostCancellationToken {
    setRequest(requestId: number): void;
    resetRequest(requestId: number): void;
}
export declare const nullCancellationToken: ServerCancellationToken;
export interface SessionOptions {
    host: ServerHost;
    cancellationToken: ServerCancellationToken;
    useSingleInferredProject: boolean;
    useInferredProjectPerProjectRoot: boolean;
    byteLength: (buf: string, encoding?: BufferEncoding) => number;
    hrtime: (start?: [number, number]) => [number, number];
    logger: Logger;
    /**
     * If falsy, all events are suppressed.
     */
    canUseEvents: boolean;
    canUseWatchEvents?: boolean;
    eventHandler?: ProjectServiceEventHandler;
    /** Has no effect if eventHandler is also specified. */
    suppressDiagnosticEvents?: boolean;
    serverMode?: LanguageServiceMode;
    throttleWaitMilliseconds?: number;
    noGetErrOnBackgroundUpdate?: boolean;
    globalPlugins?: readonly string[];
    pluginProbeLocations?: readonly string[];
    allowLocalPluginLoads?: boolean;
    typesMapLocation?: string;
    projectRootFolder?: string;
}
export type Event = <T extends object>(body: T, eventName: string) => void;
export interface EventSender {
    event: Event;
}
export declare class Session<TMessage = string> implements EventSender {
    private readonly gcTimer;
    private changeSeq;
    private performanceData;
    private currentRequestId;
    private errorCheck;
    protected host: ServerHost;
    private readonly cancellationToken;
    protected byteLength: (buf: string, encoding?: BufferEncoding) => number;
    private hrtime;
    protected logger: Logger;
    protected canUseEvents: boolean;
    private suppressDiagnosticEvents?;
    private readonly noGetErrOnBackgroundUpdate?;
    protected projectService: ProjectService;
    constructor(opts: SessionOptions);
    exit(): void;
    send(msg: protocol.Message): void;
    protected writeMessage(msg: protocol.Message): void;
    event<T extends object>(body: T, eventName: string): void;
    private sendRequestCompletedEvent;
    private setCurrentRequest;
    private resetCurrentRequest;
    executeWithRequestId<T>(requestId: number, f: () => T): T;
    logError(err: Error, cmd: string): void;
    private logErrorWorker;
    private getFileAndProject;
    private getFileAndLanguageServiceForSyntacticOperation;
    private getProject;
    private getFileAndProjectWorker;
    private getProjectInfo;
    /**
     * @param fileName is the name of the file to be opened
     * @param fileContent is a version of the file content that is known to be more up to date than the one on disk
     */
    private openClientFile;
    openFile(args: protocol.OpenRequestArgs): protocol.OpenRequestArgs;
    private getPosition;
    private mapDisplayParts;
    private updateOpenWorker;
    private closeClientFile;
    private change;
    private getDiagnostics;
    private toPendingErrorCheck;
    setCompilerOptionsForInferredProjects(args: protocol.SetCompilerOptionsForInferredProjectsArgs): void;
    /** It is the caller's responsibility to verify that `!this.suppressDiagnosticEvents`. */
    private updateErrorCheck;
    private sendAllDiagnostics;
    private semanticCheck;
    private syntacticCheck;
    private suggestionCheck;
    private getConfigFileAndProject;
    private getConfigFileDiagnostics;
    private convertToDiagnosticsWithLinePositionFromDiagnosticFile;
    private getFormatOptions;
    private getDocCommentTemplate;
    getSemanticDiagnosticsSync(args: protocol.SemanticDiagnosticsSyncRequestArgs): readonly protocol.DiagnosticWithLinePosition[] | readonly protocol.Diagnostic[];
    private getDiagnosticsWorker;
    private convertToDiagnosticsWithLinePosition;
    private sendDiagnosticsEvent;
    getDiagnosticsForFiles(args: protocol.DiagnosticRequestArgs): void;
    getDiagnosticsForProject(args: protocol.DiagnosticForProjectRequestArgs): void;
    private getEncodedSemanticClassifications;
    private getSignatureHelpItems;
    private mapSignatureHelpItems;
    private getQuickInfoWorker;
    private getProjectInfoWorker;
    private getDiagnosticsForProjectWorker;
    getCanonicalFileName(fileName: string): string;
    private mapJSDocTagInfo;
    private getPositionInFile;
    private mapDefinitionInfoLocations;
    private toFileSpan;
    private toFileSpanWithContext;
    private mapDefinitionInfo;
    private getDefinition;
    private toLocationNavigationTree;
    private getNavigationTree;
    private static mapToOriginalLocation;
    getRenameLocations(args: protocol.RenameRequestArgs, simplifiedResult: boolean): protocol.RenameResponseBody | readonly RenameLocation[];
    private mapRenameInfo;
    private toSpanGroups;
    private getProjects;
    private getDefaultProject;
    private getReferences;
    private getPreferences;
    private getCompletions;
    getCompletionEntryDetails(args: protocol.CompletionDetailsRequestArgs, fullResult: boolean): readonly protocol.CompletionEntryDetails[] | readonly CompletionEntryDetails[];
    private mapCodeAction;
    private mapTextChangesToCodeEdits;
    private mapTextChangeToCodeEdit;
    private convertTextChangeToCodeEdit;
    private requiredResponse;
    private notRequired;
    private handlers;
    executeCommand(request: protocol.Request): HandlerResponse;
    protected toStringMessage(message: TMessage): string;
    onMessage(request: protocol.Request): {};
}
export interface HandlerResponse {
    response?: {};
    responseRequired?: boolean;
}
export declare function formatMessage<T extends protocol.Message>(msg: T, logger: Logger, byteLength: (s: string, encoding: BufferEncoding) => number, newLine: string): string;
export interface PendingErrorCheck {
    fileName: NormalizedPath;
    project: Project;
}
//# sourceMappingURL=session.d.ts.map