@coderline/alphatab-monaco 1.8.2 → 1.8.3

package/dist/alphaTab.monaco.mjs

@@ -1,15 +1,15 @@
 /*!
- * alphaTab Monaco v1.8.2 (, build 31)
- *
- * Copyright © 2026, Daniel Kuschny and Contributors, All rights reserved.
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/.
- *
- * @preserve
- * @license
- */
-
-export { registerAlphaTexGrammar } from './alphatex.mjs';
-export { addTextMateGrammarSupport, registerGrammar } from './textmate.mjs';
+* alphaTab Monaco v1.8.3 (, build 32)
+*
+* Copyright © 2026, Daniel Kuschny and Contributors, All rights reserved.
+*
+* This Source Code Form is subject to the terms of the Mozilla Public
+* License, v. 2.0. If a copy of the MPL was not distributed with this
+* file, You can obtain one at http://mozilla.org/MPL/2.0/.
+*
+* @preserve
+* @license
+*/
+import { addTextMateGrammarSupport, registerGrammar } from "./textmate.mjs";
+import { registerAlphaTexGrammar } from "./alphatex.mjs";
+export { addTextMateGrammarSupport, registerAlphaTexGrammar, registerGrammar };

package/dist/alphatex.mjs

@@ -1,27 +1,26 @@
 /*!
- * alphaTab Monaco v1.8.2 (, build 31)
- *
- * Copyright © 2026, Daniel Kuschny and Contributors, All rights reserved.
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/.
- *
- * @preserve
- * @license
- */
-
-import { languageConfiguration, textMateGrammar } from '@coderline/alphatab-language-server';
-import { registerGrammar } from './textmate.mjs';
-
+* alphaTab Monaco v1.8.3 (, build 32)
+*
+* Copyright © 2026, Daniel Kuschny and Contributors, All rights reserved.
+*
+* This Source Code Form is subject to the terms of the Mozilla Public
+* License, v. 2.0. If a copy of the MPL was not distributed with this
+* file, You can obtain one at http://mozilla.org/MPL/2.0/.
+*
+* @preserve
+* @license
+*/
+import { registerGrammar } from "./textmate.mjs";
+import { languageConfiguration, textMateGrammar } from "@coderline/alphatab-language-server";
+//#region src/alphatex.ts
 /**
- * Registers alphaTex as language in the provided grammar support context.
- * @param grammarSupport The context for handling grammar support in Monaco.
- */
+* Registers alphaTex as language in the provided grammar support context.
+* @param grammarSupport The context for handling grammar support in Monaco.
+*/
 async function registerAlphaTexGrammar(grammarSupport) {
-    return registerGrammar(grammarSupport, 'alphatex', async () => {
-        return JSON.stringify(textMateGrammar);
-    }, async () => languageConfiguration);
+	return registerGrammar(grammarSupport, "alphatex", async () => {
+		return JSON.stringify(textMateGrammar);
+	}, async () => languageConfiguration);
 }
-
+//#endregion
 export { registerAlphaTexGrammar };

package/dist/lsp.mjs

@@ -1,234 +1,187 @@
 /*!
- * alphaTab Monaco v1.8.2 (, build 31)
- *
- * Copyright © 2026, Daniel Kuschny and Contributors, All rights reserved.
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/.
- *
- * @preserve
- * @license
- */
-
-import { monacoToLspContentChange, monacoToLspCompletionItem, lspToMonacoCompletionItem, monacoToLspCompletionTriggerKind, lspToMonacoHover, monacoToLspSignatureHelp, monacoToLspSignatureHelpTriggerKind, lspToMonacoSignatureHelp, lspToMonacoMarker } from './lspMonacoMappings.mjs';
-import * as monaco from 'monaco-editor';
-import { PositionEncodingKind, InitializeRequest, DidOpenTextDocumentNotification, DidChangeTextDocumentNotification, CompletionResolveRequest, CompletionRequest, HoverRequest, SignatureHelpRequest, DocumentDiagnosticRequest } from 'vscode-languageserver-protocol';
-import { BrowserMessageReader, BrowserMessageWriter, createProtocolConnection } from 'vscode-languageserver-protocol/browser';
-
+* alphaTab Monaco v1.8.3 (, build 32)
+*
+* Copyright © 2026, Daniel Kuschny and Contributors, All rights reserved.
+*
+* This Source Code Form is subject to the terms of the Mozilla Public
+* License, v. 2.0. If a copy of the MPL was not distributed with this
+* file, You can obtain one at http://mozilla.org/MPL/2.0/.
+*
+* @preserve
+* @license
+*/
+import { lspToMonacoCompletionItem, lspToMonacoHover, lspToMonacoMarker, lspToMonacoSignatureHelp, monacoToLspCompletionItem, monacoToLspCompletionTriggerKind, monacoToLspContentChange, monacoToLspSignatureHelp, monacoToLspSignatureHelpTriggerKind } from "./lspMonacoMappings.mjs";
+import * as monaco from "monaco-editor";
+import { CompletionRequest, CompletionResolveRequest, DidChangeTextDocumentNotification, DidOpenTextDocumentNotification, DocumentDiagnosticRequest, HoverRequest, InitializeRequest, PositionEncodingKind, SignatureHelpRequest } from "vscode-languageserver-protocol";
+import { BrowserMessageReader, BrowserMessageWriter, createProtocolConnection } from "vscode-languageserver-protocol/browser";
+//#region src/lsp.ts
 /**
- * Enables a basic Language Server integration for the given editor covering:
- * * A single document backend (no workspace integration with file open,close, rename etc.)
- * * Diagnostics Provider (https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#textDocument_pullDiagnostics)
- * * Completions (https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#textDocument_completion)
- * * Hover (https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#textDocument_hover)
- * * Signature Help (https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#textDocument_signatureHelp)
- *
- * This feature set is mainly aligned with the capabilities of the alphaTab language server.
- *
- * @param editor The editor to integrate with.
- * @param languageServerWorker The web worker with a language server listening for messages.
- */
+* Enables a basic Language Server integration for the given editor covering:
+* * A single document backend (no workspace integration with file open,close, rename etc.)
+* * Diagnostics Provider (https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#textDocument_pullDiagnostics)
+* * Completions (https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#textDocument_completion)
+* * Hover (https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#textDocument_hover)
+* * Signature Help (https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#textDocument_signatureHelp)
+*
+* This feature set is mainly aligned with the capabilities of the alphaTab language server.
+*
+* @param editor The editor to integrate with.
+* @param languageServerWorker The web worker with a language server listening for messages.
+*/
 async function basicEditorLspIntegration(editor, languageServerWorker, info) {
-    const reader = new BrowserMessageReader(languageServerWorker);
-    const writer = new BrowserMessageWriter(languageServerWorker);
-    const connection = createProtocolConnection(reader, writer, info.logger);
-    connection.onError(data => {
-        info.logger?.error(`Error on protocol connection: ${data}`);
-    });
-    connection.onClose(() => {
-        info.logger?.log(`Language Server connection closed`);
-    });
-    const initRequest = {
-        processId: null,
-        clientInfo: info.clientInfo,
-        rootUri: null,
-        capabilities: {
-            general: {
-                staleRequestSupport: {
-                    cancel: true,
-                    retryOnContentModified: []
-                },
-                regularExpressions: {
-                    engine: 'ECMAScript',
-                    version: 'ES2020'
-                },
-                markdown: {
-                    parser: 'marked',
-                    version: '1.1.0'
-                },
-                positionEncodings: [PositionEncodingKind.UTF16]
-            },
-            textDocument: {
-                completion: {
-                    completionItem: {
-                        snippetSupport: true,
-                        documentationFormat: ['markdown', 'plaintext'],
-                        insertReplaceSupport: true,
-                        labelDetailsSupport: true
-                    }
-                },
-                hover: {
-                    contentFormat: ['markdown', 'plaintext']
-                },
-                signatureHelp: {
-                    signatureInformation: {
-                        documentationFormat: ['markdown', 'plaintext'],
-                        parameterInformation: {
-                            labelOffsetSupport: true
-                        },
-                        activeParameterSupport: true
-                    }
-                },
-                diagnostic: {}
-            }
-        }
-    };
-    info.logger?.log(`Begin listen on connection`);
-    connection.listen();
-    info.logger?.log(`Listening now on connection`);
-    info.logger?.log(`Begin Language Server initialization`);
-    const initResponse = await connection.sendRequest(InitializeRequest.type, initRequest);
-    info.logger?.log(`Finished Language Server initialization`);
-    const documentUri = 'monaco://standalone.document';
-    const model = editor.getModel();
-    await connection.sendNotification(DidOpenTextDocumentNotification.type, {
-        textDocument: {
-            languageId: info.languageId,
-            text: model.getValue(),
-            uri: documentUri,
-            version: model.getVersionId()
-        }
-    });
-    setupDocumentHandlingAndDiagnostics(editor, documentUri, connection);
-    setupCompletion(documentUri, info.languageId, connection, initResponse);
-    setupHover(documentUri, info.languageId, connection, initResponse);
-    setupSignatureHelp(documentUri, info.languageId, connection, initResponse);
+	const connection = createProtocolConnection(new BrowserMessageReader(languageServerWorker), new BrowserMessageWriter(languageServerWorker), info.logger);
+	connection.onError((data) => {
+		info.logger?.error(`Error on protocol connection: ${data}`);
+	});
+	connection.onClose(() => {
+		info.logger?.log(`Language Server connection closed`);
+	});
+	const initRequest = {
+		processId: null,
+		clientInfo: info.clientInfo,
+		rootUri: null,
+		capabilities: {
+			general: {
+				staleRequestSupport: {
+					cancel: true,
+					retryOnContentModified: []
+				},
+				regularExpressions: {
+					engine: "ECMAScript",
+					version: "ES2020"
+				},
+				markdown: {
+					parser: "marked",
+					version: "1.1.0"
+				},
+				positionEncodings: [PositionEncodingKind.UTF16]
+			},
+			textDocument: {
+				completion: { completionItem: {
+					snippetSupport: true,
+					documentationFormat: ["markdown", "plaintext"],
+					insertReplaceSupport: true,
+					labelDetailsSupport: true
+				} },
+				hover: { contentFormat: ["markdown", "plaintext"] },
+				signatureHelp: { signatureInformation: {
+					documentationFormat: ["markdown", "plaintext"],
+					parameterInformation: { labelOffsetSupport: true },
+					activeParameterSupport: true
+				} },
+				diagnostic: {}
+			}
+		}
+	};
+	info.logger?.log(`Begin listen on connection`);
+	connection.listen();
+	info.logger?.log(`Listening now on connection`);
+	info.logger?.log(`Begin Language Server initialization`);
+	const initResponse = await connection.sendRequest(InitializeRequest.type, initRequest);
+	info.logger?.log(`Finished Language Server initialization`);
+	const documentUri = "monaco://standalone.document";
+	const model = editor.getModel();
+	await connection.sendNotification(DidOpenTextDocumentNotification.type, { textDocument: {
+		languageId: info.languageId,
+		text: model.getValue(),
+		uri: documentUri,
+		version: model.getVersionId()
+	} });
+	setupDocumentHandlingAndDiagnostics(editor, documentUri, connection);
+	setupCompletion(documentUri, info.languageId, connection, initResponse);
+	setupHover(documentUri, info.languageId, connection, initResponse);
+	setupSignatureHelp(documentUri, info.languageId, connection, initResponse);
 }
 function setupDocumentHandlingAndDiagnostics(editor, documentUri, connection) {
-    async function updateDiagnostics() {
-        const params = {
-            textDocument: {
-                uri: documentUri
-            }
-        };
-        const result = await connection.sendRequest(DocumentDiagnosticRequest.type, params);
-        if (result.kind === 'unchanged') {
-            return;
-        }
-        monaco.editor.setModelMarkers(editor.getModel(), 'lsp', result.items.map(lspToMonacoMarker));
-    }
-    updateDiagnostics();
-    editor.onDidChangeModelContent(async (e) => {
-        await connection.sendNotification(DidChangeTextDocumentNotification.type, {
-            textDocument: {
-                uri: documentUri,
-                version: e.versionId
-            },
-            contentChanges: e.changes.map(monacoToLspContentChange)
-        });
-        await updateDiagnostics();
-    });
+	async function updateDiagnostics() {
+		const params = { textDocument: { uri: documentUri } };
+		const result = await connection.sendRequest(DocumentDiagnosticRequest.type, params);
+		if (result.kind === "unchanged") return;
+		monaco.editor.setModelMarkers(editor.getModel(), "lsp", result.items.map(lspToMonacoMarker));
+	}
+	updateDiagnostics();
+	editor.onDidChangeModelContent(async (e) => {
+		await connection.sendNotification(DidChangeTextDocumentNotification.type, {
+			textDocument: {
+				uri: documentUri,
+				version: e.versionId
+			},
+			contentChanges: e.changes.map(monacoToLspContentChange)
+		});
+		await updateDiagnostics();
+	});
 }
 function setupHover(documentUri, languageId, connection, initResponse) {
-    if (!initResponse.capabilities.hoverProvider) {
-        return;
-    }
-    // TODO: registration is global, this will break with multiple editors
-    monaco.languages.registerHoverProvider(languageId, {
-        async provideHover(_, position, token) {
-            const params = {
-                position: {
-                    line: position.lineNumber - 1,
-                    character: position.column - 1
-                },
-                textDocument: {
-                    uri: documentUri
-                }
-            };
-            const response = await connection.sendRequest(HoverRequest.type, params, token);
-            if (response === null) {
-                return null;
-            }
-            return lspToMonacoHover(response);
-        }
-    });
+	if (!initResponse.capabilities.hoverProvider) return;
+	monaco.languages.registerHoverProvider(languageId, { async provideHover(_, position, token) {
+		const params = {
+			position: {
+				line: position.lineNumber - 1,
+				character: position.column - 1
+			},
+			textDocument: { uri: documentUri }
+		};
+		const response = await connection.sendRequest(HoverRequest.type, params, token);
+		if (response === null) return null;
+		return lspToMonacoHover(response);
+	} });
 }
 function setupSignatureHelp(documentUri, languageId, connection, initResponse) {
-    if (!initResponse.capabilities.signatureHelpProvider) {
-        return;
-    }
-    // TODO: registration is global, this will break with multiple editors
-    monaco.languages.registerSignatureHelpProvider(languageId, {
-        async provideSignatureHelp(_, position, token, context) {
-            const params = {
-                position: {
-                    character: position.column - 1,
-                    line: position.lineNumber - 1
-                },
-                textDocument: {
-                    uri: documentUri
-                },
-                context: {
-                    isRetrigger: context.isRetrigger,
-                    triggerKind: monacoToLspSignatureHelpTriggerKind(context.triggerKind),
-                    activeSignatureHelp: context.activeSignatureHelp
-                        ? monacoToLspSignatureHelp(context.activeSignatureHelp)
-                        : undefined,
-                    triggerCharacter: context.triggerCharacter
-                }
-            };
-            const response = await connection.sendRequest(SignatureHelpRequest.type, params, token);
-            if (response === null) {
-                return null;
-            }
-            return lspToMonacoSignatureHelp(response);
-        },
-        signatureHelpRetriggerCharacters: initResponse.capabilities.signatureHelpProvider.retriggerCharacters,
-        signatureHelpTriggerCharacters: initResponse.capabilities.signatureHelpProvider.triggerCharacters
-    });
+	if (!initResponse.capabilities.signatureHelpProvider) return;
+	monaco.languages.registerSignatureHelpProvider(languageId, {
+		async provideSignatureHelp(_, position, token, context) {
+			const params = {
+				position: {
+					character: position.column - 1,
+					line: position.lineNumber - 1
+				},
+				textDocument: { uri: documentUri },
+				context: {
+					isRetrigger: context.isRetrigger,
+					triggerKind: monacoToLspSignatureHelpTriggerKind(context.triggerKind),
+					activeSignatureHelp: context.activeSignatureHelp ? monacoToLspSignatureHelp(context.activeSignatureHelp) : void 0,
+					triggerCharacter: context.triggerCharacter
+				}
+			};
+			const response = await connection.sendRequest(SignatureHelpRequest.type, params, token);
+			if (response === null) return null;
+			return lspToMonacoSignatureHelp(response);
+		},
+		signatureHelpRetriggerCharacters: initResponse.capabilities.signatureHelpProvider.retriggerCharacters,
+		signatureHelpTriggerCharacters: initResponse.capabilities.signatureHelpProvider.triggerCharacters
+	});
 }
 function setupCompletion(documentUri, languageId, connection, initResponse) {
-    if (!initResponse.capabilities.completionProvider) {
-        return;
-    }
-    // TODO: registration is global, this will break with multiple editors
-    monaco.languages.registerCompletionItemProvider(languageId, {
-        triggerCharacters: initResponse.capabilities.completionProvider.triggerCharacters,
-        async provideCompletionItems(_, position, context, token) {
-            const params = {
-                position: {
-                    line: position.lineNumber - 1,
-                    character: position.column - 1
-                },
-                textDocument: {
-                    uri: documentUri
-                },
-                context: {
-                    triggerKind: monacoToLspCompletionTriggerKind(context.triggerKind),
-                    triggerCharacter: context.triggerCharacter
-                }
-            };
-            const response = await connection.sendRequest(CompletionRequest.type, params, token);
-            if (response === null) {
-                return null;
-            }
-            const range = new monaco.Range(position.lineNumber, position.column, position.lineNumber, position.column);
-            return Array.isArray(response)
-                ? {
-                    suggestions: response.map(r => lspToMonacoCompletionItem(r, range)),
-                    incomplete: false
-                }
-                : {
-                    suggestions: response.items.map(r => lspToMonacoCompletionItem(r, range)),
-                    incomplete: response.isIncomplete
-                };
-        },
-        async resolveCompletionItem(item, token) {
-            const response = await connection.sendRequest(CompletionResolveRequest.type, monacoToLspCompletionItem(item), token);
-            return lspToMonacoCompletionItem(response, item.range);
-        }
-    });
+	if (!initResponse.capabilities.completionProvider) return;
+	monaco.languages.registerCompletionItemProvider(languageId, {
+		triggerCharacters: initResponse.capabilities.completionProvider.triggerCharacters,
+		async provideCompletionItems(_, position, context, token) {
+			const params = {
+				position: {
+					line: position.lineNumber - 1,
+					character: position.column - 1
+				},
+				textDocument: { uri: documentUri },
+				context: {
+					triggerKind: monacoToLspCompletionTriggerKind(context.triggerKind),
+					triggerCharacter: context.triggerCharacter
+				}
+			};
+			const response = await connection.sendRequest(CompletionRequest.type, params, token);
+			if (response === null) return null;
+			const range = new monaco.Range(position.lineNumber, position.column, position.lineNumber, position.column);
+			return Array.isArray(response) ? {
+				suggestions: response.map((r) => lspToMonacoCompletionItem(r, range)),
+				incomplete: false
+			} : {
+				suggestions: response.items.map((r) => lspToMonacoCompletionItem(r, range)),
+				incomplete: response.isIncomplete
+			};
+		},
+		async resolveCompletionItem(item, token) {
+			return lspToMonacoCompletionItem(await connection.sendRequest(CompletionResolveRequest.type, monacoToLspCompletionItem(item), token), item.range);
+		}
+	});
 }
-
+//#endregion
 export { basicEditorLspIntegration };