@typespec/compiler/dist/src/server/types.d.ts

TypeSpec compiler and standard library

import { ApplyWorkspaceEditParams, ApplyWorkspaceEditResult, CodeAction, CodeActionParams, CompletionList, CompletionParams, DefinitionParams, DidChangeWatchedFilesParams, DocumentFormattingParams, DocumentHighlight, DocumentHighlightParams, DocumentSymbol, DocumentSymbolParams, FoldingRange, FoldingRangeParams, Hover, HoverParams, InitializeParams, InitializeResult, InitializedParams, Location, PrepareRenameParams, PublishDiagnosticsParams, Range, ReferenceParams, RenameFilesParams, RenameParams, SemanticTokens, SemanticTokensParams, SignatureHelp, SignatureHelpParams, TextDocumentChangeEvent, TextDocumentIdentifier, WorkspaceEdit, WorkspaceFolder, WorkspaceFoldersChangeEvent } from "vscode-languageserver";
import type { TextDocument, TextEdit } from "vscode-languageserver-textdocument";
import type { CompilerOptions } from "../core/options.js";
import type { Program } from "../core/program.js";
import type { CompilerHost, Diagnostic, NoTarget, SourceFile, SourceLocation, TypeSpecScriptNode } from "../core/types.js";
import { LoadedCoreTemplates } from "../init/core-templates.js";
import { EmitterTemplate, InitTemplate, InitTemplateLibrarySpec } from "../init/init-template.js";
import { ScaffoldingConfig } from "../init/scaffold.js";
import { CompileTracker, ServerCompileOptions } from "./server-compile-manager.js";
export type ServerLogLevel = "trace" | "debug" | "info" | "warning" | "error";
export interface ServerLog {
    level: ServerLogLevel;
    message: string;
    detail?: unknown;
}
export interface ServerHost {
    readonly compilerHost: CompilerHost;
    readonly throwInternalErrors?: boolean;
    readonly getOpenDocumentByURL: (url: string) => TextDocument | undefined;
    readonly sendDiagnostics: (params: PublishDiagnosticsParams) => void;
    readonly log: (log: ServerLog) => void;
    readonly applyEdit: (paramOrEdit: ApplyWorkspaceEditParams | WorkspaceEdit) => Promise<ApplyWorkspaceEditResult>;
}
export interface CompileResult {
    readonly program: Program;
    readonly document: TextDocument | undefined;
    readonly script: TypeSpecScriptNode | undefined;
    readonly optionsFromConfig: CompilerOptions;
    readonly tracker: CompileTracker;
}
export interface ServerDiagnostic extends Diagnostic {
    target: (SourceLocation & {
        position?: {
            line: number;
            column: number;
        };
    }) | typeof NoTarget;
}
export interface InternalCompileResult {
    readonly hasError: boolean;
    readonly diagnostics: ServerDiagnostic[];
    readonly entrypoint?: string;
    readonly options?: CompilerOptions;
}
export interface Server {
    readonly pendingMessages: readonly ServerLog[];
    readonly workspaceFolders: readonly ServerWorkspaceFolder[];
    compile(document: TextDocument | TextDocumentIdentifier, additionalOptions: CompilerOptions | undefined, serverCompileOptions: ServerCompileOptions): Promise<CompileResult | undefined>;
    initialize(params: InitializeParams): Promise<InitializeResult>;
    initialized(params: InitializedParams): void;
    workspaceFoldersChanged(e: WorkspaceFoldersChangeEvent): Promise<void>;
    watchedFilesChanged(params: DidChangeWatchedFilesParams): void;
    formatDocument(params: DocumentFormattingParams): Promise<TextEdit[]>;
    gotoDefinition(params: DefinitionParams): Promise<Location[]>;
    complete(params: CompletionParams): Promise<CompletionList>;
    findReferences(params: ReferenceParams): Promise<Location[]>;
    findDocumentHighlight(params: DocumentHighlightParams): Promise<DocumentHighlight[]>;
    prepareRename(params: PrepareRenameParams): Promise<Range | undefined>;
    rename(params: RenameParams): Promise<WorkspaceEdit>;
    renameFiles(params: RenameFilesParams): Promise<void>;
    getSemanticTokens(params: SemanticTokensParams): Promise<SemanticToken[]>;
    buildSemanticTokens(params: SemanticTokensParams): Promise<SemanticTokens>;
    checkChange(change: TextDocumentChangeEvent<TextDocument>): void;
    getHover(params: HoverParams): Promise<Hover>;
    getSignatureHelp(params: SignatureHelpParams): Promise<SignatureHelp | undefined>;
    getFoldingRanges(getFoldingRanges: FoldingRangeParams): Promise<FoldingRange[]>;
    getDocumentSymbols(params: DocumentSymbolParams): Promise<DocumentSymbol[]>;
    documentClosed(change: TextDocumentChangeEvent<TextDocument>): void;
    documentOpened(change: TextDocumentChangeEvent<TextDocument>): void;
    getCodeActions(params: CodeActionParams): Promise<CodeAction[]>;
    resolveCodeAction(codeAction: CodeAction): Promise<CodeAction>;
    reportDiagnostics({ program, document, optionsFromConfig }: CompileResult): void;
    log(log: ServerLog): void;
    getInitProjectContext(): Promise<InitProjectContext>;
    validateInitProjectTemplate(param: {
        template: InitTemplate;
    }): Promise<boolean>;
    initProject(param: {
        config: InitProjectConfig;
    }): Promise<boolean>;
    internalCompile(param: {
        doc: TextDocumentIdentifier;
        options: CompilerOptions;
    }): Promise<InternalCompileResult>;
}
export interface ServerSourceFile extends SourceFile {
    readonly document?: TextDocument;
}
export interface ServerWorkspaceFolder extends WorkspaceFolder {
    path: string;
}
export declare enum SemanticTokenKind {
    Namespace = 0,
    Type = 1,
    Class = 2,
    Enum = 3,
    Interface = 4,
    Struct = 5,
    TypeParameter = 6,
    Parameter = 7,
    Variable = 8,
    Property = 9,
    EnumMember = 10,
    Event = 11,
    Function = 12,
    Method = 13,
    Macro = 14,
    Keyword = 15,
    Comment = 16,
    String = 17,
    Number = 18,
    Regexp = 19,
    Operator = 20,
    DocCommentTag = 21
}
export interface SemanticToken {
    kind: SemanticTokenKind;
    pos: number;
    end: number;
}
export type CustomRequestName = "typespec/getInitProjectContext" | "typespec/initProject" | "typespec/validateInitProjectTemplate" | "typespec/internalCompile";
export interface ServerCustomCapacities {
    getInitProjectContext?: boolean;
    validateInitProjectTemplate?: boolean;
    initProject?: boolean;
    internalCompile?: boolean;
}
export interface ServerInitializeResult extends InitializeResult {
    customCapacities?: ServerCustomCapacities;
    compilerRootFolder?: string;
    compilerCliJsPath?: string;
}
export interface InitProjectContext {
    /** provide the default templates current compiler/cli supports */
    coreInitTemplates: LoadedCoreTemplates;
}
export type InitProjectConfig = ScaffoldingConfig;
export type InitProjectTemplate = InitTemplate;
export type InitProjectTemplateLibrarySpec = InitTemplateLibrarySpec;
export type InitProjectTemplateEmitterTemplate = EmitterTemplate;
//# sourceMappingURL=types.d.ts.map