flink-cdc-language-server/out-tsc/server-worker.js

A LSP-based language server for Apache Flink CDC

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const settings_1 = require("./settings");
const vscode_languageserver_1 = require("vscode-languageserver");
const vscode_languageserver_textdocument_1 = require("vscode-languageserver-textdocument");
const browser_1 = require("vscode-languageserver/browser");
const lsp_server_1 = require("./lsp-server");
const settings_2 = require("./settings");
const messageReader = new browser_1.BrowserMessageReader(self);
const messageWriter = new browser_1.BrowserMessageWriter(self);
const connection = (0, browser_1.createConnection)(messageReader, messageWriter);
connection.onInitialize(params => {
    (0, settings_2.updateCustomOptions)(params.initializationOptions);
    const capabilities = {
        textDocumentSync: vscode_languageserver_1.TextDocumentSyncKind.Incremental,
        executeCommandProvider: {
            commands: []
        },
        documentFormattingProvider: true,
        documentSymbolProvider: true,
        referencesProvider: true,
        hoverProvider: true,
        foldingRangeProvider: true,
        renameProvider: true,
        codeActionProvider: true,
        completionProvider: {
            triggerCharacters: [' ', ':'],
            resolveProvider: false
        }
    };
    return { capabilities };
});
const documents = new vscode_languageserver_1.TextDocuments(vscode_languageserver_textdocument_1.TextDocument);
const lspServer = new lsp_server_1.YamlLanguageService(settings_1.languageSettings, settings_2.languageServiceOptions);
const documentWithVersion = (uri) => {
    const textDocument = documents.get(uri);
    if (!textDocument) {
        console.error('Language Server: TextDocument not found.');
        return undefined;
    }
    return textDocument;
};
documents.listen(connection);
connection.onCodeAction((params) => {
    const actions = [];
    const diagnostics = params.context.diagnostics;
    if (!diagnostics.length) {
        return [];
    }
    const document = documents.get(params.textDocument.uri);
    if (!document) {
        console.error('Language Server: TextDocument not found.');
        return [];
    }
    const kinds = params.context.only;
    if (kinds?.includes(vscode_languageserver_1.CodeActionKind.QuickFix)) {
        diagnostics.forEach(diagnostic => {
            const quickFixes = diagnostic.data?.suggestions
                .filter((s) => s !== 'EOF')
                .map((newText) => ({
                title: `Cannot find name '${document.getText(diagnostic.range)}'. Do you mean '${newText}'?`,
                kind: vscode_languageserver_1.CodeActionKind.QuickFix,
                diagnostics: [diagnostic],
                edit: {
                    changes: {
                        [params.textDocument.uri]: [
                            {
                                newText,
                                range: diagnostic.range
                            }
                        ]
                    }
                }
            })) || [];
            actions.push(...quickFixes);
        });
    }
    return actions;
});
connection.onFoldingRanges(params => {
    const document = documents.get(params.textDocument.uri);
    if (!document) {
        console.error('Language Server: TextDocument not found.');
        return [];
    }
    return lspServer.getFoldingRanges(document);
});
connection.onHover(params => {
    const { textDocument, position } = params;
    const document = documentWithVersion(textDocument.uri);
    if (!document) {
        return null;
    }
    return lspServer.doHover(document, position);
});
connection.onRequest(vscode_languageserver_1.DocumentDiagnosticRequest.type, async (params) => {
    const textDocument = documentWithVersion(params.textDocument.uri);
    if (!textDocument) {
        return { kind: 'full', items: [] };
    }
    const items = await lspServer.doValidation(textDocument);
    return { kind: 'full', items };
});
connection.onCompletion(async (params) => {
    const { textDocument, position } = params;
    const document = documentWithVersion(textDocument.uri);
    if (!document) {
        return [];
    }
    const completionList = await lspServer.doCompletion(document, position);
    return completionList;
});
connection.onDocumentFormatting(params => {
    const textDocument = documentWithVersion(params.textDocument.uri);
    if (!textDocument) {
        return [];
    }
    const edits = lspServer.doFormat(textDocument);
    return edits;
});
connection.onDocumentSymbol(params => {
    const textDocument = documentWithVersion(params.textDocument.uri);
    if (!textDocument) {
        return [];
    }
    return lspServer.findDocumentSymbols(textDocument);
});
connection.listen();
//# sourceMappingURL=server-worker.js.map