@knime/scripting-editor 0.0.11 → 0.0.12

package/dist/src/components/ScriptingEditor.vue.d.ts

@@ -1,6 +1,6 @@
 import { type PropType } from "vue";
 import type { MenuItem } from "webapps-common/ui/components/MenuItems.vue";
-import type { editor } from './monaco-editor';
+import type { editor } from "monaco-editor";
 import type { ConsoleHandler } from "./OutputConsole.vue";
 type PaneSizes = {
     [key in "left" | "right" | "bottom"]: number;

package/dist/src/editor-service.d.ts

@@ -1,4 +1,4 @@
-import { editor as monaco } from './monaco-editor';
+import { editor as monaco } from "monaco-editor";
 export declare class EditorService {
     editor?: monaco.IStandaloneCodeEditor;
     editorModel?: monaco.ITextModel;

package/dist/src/lsp/completion.d.ts

@@ -0,0 +1,7 @@
+import { Position, editor, languages, type IRange } from "monaco-editor";
+import { CompletionItem, CompletionList, type CompletionClientCapabilities, type CompletionContext, type CompletionParams } from "vscode-languageserver-protocol";
+export declare const completionCapibilities: CompletionClientCapabilities;
+export declare const getCompletionParams: (model: editor.ITextModel, position: Position, context: languages.CompletionContext) => CompletionParams;
+export declare const mapCompletionResult: (result: CompletionList | CompletionItem[], model: editor.ITextModel, position: Position) => languages.CompletionList;
+export declare const getCompletionResolveParams: (item: languages.CompletionItem) => CompletionItem;
+export declare const mapCompletionResolveResult: (result: CompletionItem, range: IRange | languages.CompletionItemRanges) => languages.CompletionItem;

package/dist/src/lsp/connection.d.ts

@@ -0,0 +1,49 @@
+import { editor } from "monaco-editor";
+import { MessageReader, MessageWriter, type LSPAny } from "vscode-languageserver-protocol";
+export declare class MonacoLSPConnection {
+    private _editorModel;
+    /**
+     * Create a new connection to a language server.
+     *
+     * @param editorModel the editor model that holds the open document
+     * @param reader a message reader for communication with the language server
+     * @param writer a message writer for communication with the language server
+     * @returns a fully initialized connection
+     */
+    static create(editorModel: editor.ITextModel, reader: MessageReader, writer: MessageWriter): Promise<MonacoLSPConnection>;
+    private _connection;
+    private constructor();
+    /**
+     * Change the configuration of the language server.
+     * Can be called anytime to update the current configuration.
+     *
+     * @param settings the settings that are sent to the server
+     */
+    changeConfiguration(settings: LSPAny): Promise<void>;
+    private getLanguageId;
+    /**
+     * Lifecyle - Initialize Request
+     */
+    private initializeLanguageServer;
+    private notifyInitialized;
+    /**
+     * Document synchronization
+     */
+    private syncDocument;
+    /**
+     * Hover
+     */
+    private registerHoverProvider;
+    /**
+     * Auto-completion
+     */
+    private registerCompletionProvider;
+    /**
+     * Signature help
+     */
+    private registerSignatureHelpProvider;
+    /**
+     * Diagnostics
+     */
+    private registerOnPublishDiagnostic;
+}

package/dist/src/lsp/diagnostics.d.ts

@@ -0,0 +1,4 @@
+import { editor } from "monaco-editor";
+import { type Diagnostic, type PublishDiagnosticsClientCapabilities } from "vscode-languageserver-protocol";
+export declare const publishDiagnosticsCapibilities: PublishDiagnosticsClientCapabilities;
+export declare const mapDiagnosticToMarkerData: (diagnostics: Diagnostic[]) => editor.IMarkerData[];

package/dist/src/lsp/doc-sync.d.ts

@@ -0,0 +1,5 @@
+import type { editor } from "monaco-editor";
+import type { DidChangeTextDocumentParams, DidOpenTextDocumentParams, TextDocumentSyncClientCapabilities } from "vscode-languageserver-protocol";
+export declare const documentSyncCapabilities: TextDocumentSyncClientCapabilities;
+export declare const getDidOpenParams: (model: editor.ITextModel) => DidOpenTextDocumentParams;
+export declare const getDidChangeParams: (model: editor.ITextModel, changeEvent: editor.IModelContentChangedEvent) => DidChangeTextDocumentParams;

package/dist/src/lsp/hover.d.ts

@@ -0,0 +1,5 @@
+import { Position, editor, languages } from "monaco-editor";
+import { Hover, type HoverClientCapabilities, type HoverParams } from "vscode-languageserver-protocol";
+export declare const hoverCapibilities: HoverClientCapabilities;
+export declare const getHoverParams: (editorModel: editor.ITextModel, position: Position) => HoverParams;
+export declare const mapHoverResult: (result: Hover) => languages.Hover;

package/dist/src/lsp/knime-io.d.ts

@@ -0,0 +1,20 @@
+import { AbstractMessageReader, AbstractMessageWriter, Disposable, Message, MessageReader, MessageWriter, type DataCallback } from "vscode-languageserver-protocol";
+/**
+ * This class is used to read messages from the language server. The callback
+ * is registered by the connection and called each time a message from the
+ * language server is received.
+ */
+export declare class KnimeMessageReader extends AbstractMessageReader implements MessageReader {
+    protected messageCache: string[];
+    protected callback: DataCallback | null;
+    constructor();
+    listen(callback: DataCallback): Disposable;
+    readMessage(message: string): void;
+}
+/**
+ * This class is used to write messages to the language server.
+ */
+export declare class KnimeMessageWriter extends AbstractMessageWriter implements MessageWriter {
+    write(msg: Message): Promise<void>;
+    end(): void;
+}

package/dist/src/lsp/mapping-utils.d.ts

@@ -0,0 +1,8 @@
+import { Position, editor, type IMarkdownString, type IRange } from "monaco-editor";
+import { Position as LSPPosition, MarkupContent, Range, TextDocumentIdentifier, type TextDocumentPositionParams } from "vscode-languageserver-protocol";
+export declare const mapPositionToLSP: (position: Position) => LSPPosition;
+export declare const mapMarkupToMonaco: (markup: MarkupContent | string) => IMarkdownString;
+export declare const mapRangeToMonaco: (range: Range) => IRange;
+export declare const mapRangeToLSP: (range: IRange) => Range;
+export declare const mapDocumentIdToLSP: (editorModel: editor.ITextModel) => TextDocumentIdentifier;
+export declare const getTextDocPositionParms: (editorModel: editor.ITextModel, position: Position) => TextDocumentPositionParams;

package/dist/src/lsp/signature-help.d.ts

@@ -0,0 +1,5 @@
+import { Position, editor, languages } from "monaco-editor";
+import { type SignatureHelp, type SignatureHelpClientCapabilities, type SignatureHelpContext, type SignatureHelpParams } from "vscode-languageserver-protocol";
+export declare const signatureHelpClientCapabilities: SignatureHelpClientCapabilities;
+export declare const getSignatureHelpParams: (model: editor.ITextModel, position: Position, context: languages.SignatureHelpContext) => SignatureHelpParams;
+export declare const mapSignatureHelpResult: (result: SignatureHelp) => languages.SignatureHelpResult;

package/dist/src/scripting-service.d.ts

@@ -1,8 +1,8 @@
+import { editor as monaco } from "monaco-editor";
 import type { ConsoleText } from "./components/OutputConsole.vue";
 export type NodeSettings = {
     script: string;
 };
-import { editor as monaco } from './monaco-editor';
 declare class ScriptingService {
     private _knimeService;
     private _jsonDataService;
@@ -10,6 +10,7 @@ declare class ScriptingService {
     private _eventHandlers;
     private _runEventPoller;
     private _editorService;
+    private _monacoLSPConnection;
     constructor();
     private eventPoller;
     stopEventPoller(): void;
@@ -23,6 +24,8 @@ declare class ScriptingService {
     initEditorService(editor: monaco.IStandaloneCodeEditor, editorModel: monaco.ITextModel): void;
     getScript(): string | null;
     getSelectedLines(): string | null;
+    connectToLanguageServer(): Promise<void>;
+    configureLanguageServer(settings: any): Promise<void>;
 }
 export type ScriptingServiceType = Pick<ScriptingService, keyof ScriptingService>;
 declare const getScriptingService: (mock?: ScriptingServiceType) => ScriptingServiceType;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@knime/scripting-editor",
   "type": "module",
-  "version": "0.0.11",
+  "version": "0.0.12",
   "description": "Shared Scripting Editor components for KNIME",
   "author": "KNIME AG, Zurich, Switzerland",
   "license": "See the file license.txt",
@@ -26,10 +26,10 @@
   "dependencies": {
     "@knime/ui-extension-service": "0.16.0",
     "eslint-import-resolver-typescript": "3.5.5",
-    "monaco-editor": "0.40.0",
-    "monaco-languageclient": "4.0.3",
+    "monaco-editor": "0.41.0",
     "pinia": "2.1.4",
     "splitpanes": "3.1.5",
+    "vscode-languageserver-protocol": "3.17.3",
     "vue": "3.x",
     "webapps-common": "file:webapps-common",
     "xterm": "5.2.1",