@coderline/alphatab-monaco 1.7.0-alpha.1626 → 1.7.0-alpha.1628

package/dist/alphaTab.monaco.d.ts

@@ -1,40 +1,2 @@
-import * as monaco from 'monaco-editor';
-import type { Registry } from 'vscode-textmate';
-
-/**
- * Adds TextMate grammar support to Monaco via `vscode-oniguruma` and `vscode-textmate`
- * @param onigurumaWasm The `onig.wasm` file shipped together with vscode-oniguruma.
- */
-export declare function addTextMateGrammarSupport(onigurumaWasm: ArrayBuffer): TextMateGrammarSupport;
-
-/**
- * Registers alphaTex as language in the provided grammar support context.
- * @param grammarSupport The context for handling grammar support in Monaco.
- */
-export declare function registerAlphaTexGrammar(grammarSupport: TextMateGrammarSupport): Promise<void>;
-
-/**
- * Registers a TextMate grammar in moncao.
- * @param grammarSupport The support object in which to register the grammar.
- * @param languageId The ID of the language
- * @param loadGrammar A promise to load the grammar source code.
- * @param loadLanguageConfiguration A promise to load the monaco language configuration.
- */
-export declare function registerGrammar(grammarSupport: TextMateGrammarSupport, languageId: string, loadGrammar: () => Promise<string>, loadLanguageConfiguration: () => Promise<monaco.languages.LanguageConfiguration>): Promise<void>;
-
-/**
- * A wrapper around components related to textmate grammar support for Monaco.
- */
-declare type TextMateGrammarSupport = {
-    /**
-     * The underlying {@link Registry} handling loading of grammars.
-     */
-    registry: Registry;
-    /**
-     * A lookup to register supported grammars. The key is the `scopeName` requested
-     * by a language and the value is a promise to load the grammar in a supported formats.
-     */
-    grammars: Record<string, () => Promise<string>>;
-};
-
-export { }
+export * from './alphatex';
+export * from './textmate';

package/dist/alphaTab.monaco.mjs

@@ -1,5 +1,5 @@
 /*!
- * alphaTab Monaco v1.7.0-alpha.1626 (develop, build 1626)
+ * alphaTab Monaco v1.7.0-alpha.1628 (develop, build 1628)
  *
  * Copyright © 2025, Daniel Kuschny and Contributors, All rights reserved.
  *
@@ -11,4 +11,5 @@
  * @license
  */
 
-export { a as addTextMateGrammarSupport, r as registerAlphaTexGrammar, b as registerGrammar } from './alphaTab.monaco2.mjs';
+export { registerAlphaTexGrammar } from './alphatex.mjs';
+export { addTextMateGrammarSupport, registerGrammar } from './textmate.mjs';

package/dist/alphatex.mjs

@@ -0,0 +1,27 @@
+/*!
+ * alphaTab Monaco v1.7.0-alpha.1628 (develop, build 1628)
+ *
+ * Copyright © 2025, 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';
+
+/**
+ * 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);
+}
+
+export { registerAlphaTexGrammar };

package/{src/lsp.ts → dist/lsp.mjs}

@@ -1,38 +1,20 @@
-import {
-    lspToMonacoCompletionItem,
-    lspToMonacoHover,
-    lspToMonacoMarker,
-    lspToMonacoSignatureHelp,
-    monacoToLspCompletionItem,
-    monacoToLspCompletionTriggerKind,
-    monacoToLspContentChange,
-    monacoToLspSignatureHelp,
-    monacoToLspSignatureHelpTriggerKind
-} from '@coderline/alphatab-monaco/lspMonacoMappings';
+/*!
+ * alphaTab Monaco v1.7.0-alpha.1628 (develop, build 1628)
+ *
+ * Copyright © 2025, 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, lspToMonacoMarker, monacoToLspCompletionItem, lspToMonacoCompletionItem, monacoToLspCompletionTriggerKind, lspToMonacoHover, monacoToLspSignatureHelp, monacoToLspSignatureHelpTriggerKind, lspToMonacoSignatureHelp } from './lspMonacoMappings.mjs';
 import * as monaco from 'monaco-editor';
-import {
-    type CompletionParams,
-    CompletionRequest,
-    CompletionResolveRequest,
-    DidChangeTextDocumentNotification,
-    DidOpenTextDocumentNotification,
-    type HoverParams,
-    HoverRequest,
-    type InitializeParams,
-    InitializeRequest,
-    type InitializeResult,
-    type Logger,
-    PositionEncodingKind,
-    type ProtocolConnection,
-    PublishDiagnosticsNotification,
-    type SignatureHelpParams,
-    SignatureHelpRequest
-} from 'vscode-languageserver-protocol';
-import {
-    BrowserMessageReader,
-    BrowserMessageWriter,
-    createProtocolConnection
-} from 'vscode-languageserver-protocol/browser';
+import { PositionEncodingKind, InitializeRequest, DidOpenTextDocumentNotification, DidChangeTextDocumentNotification, PublishDiagnosticsNotification, CompletionResolveRequest, CompletionRequest, HoverRequest, SignatureHelpRequest } from 'vscode-languageserver-protocol';
+import { BrowserMessageReader, BrowserMessageWriter, createProtocolConnection } from 'vscode-languageserver-protocol/browser';
 
 /**
  * Enables a basic Language Server integration for the given editor covering:
@@ -47,15 +29,7 @@ import {
  * @param editor The editor to integrate with.
  * @param languageServerWorker The web worker with a language server listening for messages.
  */
-export async function basicEditorLspIntegration(
-    editor: monaco.editor.IStandaloneCodeEditor,
-    languageServerWorker: Worker,
-    info: {
-        languageId: string;
-        logger?: Logger;
-        clientInfo?: InitializeParams['clientInfo'];
-    }
-) {
+async function basicEditorLspIntegration(editor, languageServerWorker, info) {
     const reader = new BrowserMessageReader(languageServerWorker);
     const writer = new BrowserMessageWriter(languageServerWorker);
     const connection = createProtocolConnection(reader, writer, info.logger);
@@ -65,8 +39,7 @@ export async function basicEditorLspIntegration(
     connection.onClose(() => {
         info.logger?.log(`Language Server connection closed`);
     });
-
-    const initRequest: InitializeParams = {
+    const initRequest = {
         processId: null,
         clientInfo: info.clientInfo,
         rootUri: null,
@@ -111,17 +84,14 @@ export async function basicEditorLspIntegration(
             }
         }
     };
-
     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()!;
+    const model = editor.getModel();
     await connection.sendNotification(DidOpenTextDocumentNotification.type, {
         textDocument: {
             languageId: info.languageId,
@@ -130,20 +100,14 @@ export async function basicEditorLspIntegration(
             version: model.getVersionId()
         }
     });
-
     setupDocumentHandling(editor, documentUri, connection);
     setupDiagnostics(editor, connection);
     setupCompletion(documentUri, info.languageId, connection, initResponse);
     setupHover(documentUri, info.languageId, connection, initResponse);
     setupSignatureHelp(documentUri, info.languageId, connection, initResponse);
 }
-
-function setupDocumentHandling(
-    editor: monaco.editor.IStandaloneCodeEditor,
-    documentUri: string,
-    connection: ProtocolConnection
-) {
-    editor.onDidChangeModelContent(async e => {
+function setupDocumentHandling(editor, documentUri, connection) {
+    editor.onDidChangeModelContent(async (e) => {
         await connection.sendNotification(DidChangeTextDocumentNotification.type, {
             textDocument: {
                 uri: documentUri,
@@ -153,30 +117,19 @@ function setupDocumentHandling(
         });
     });
 }
-
-function setupDiagnostics(
-    editor: monaco.editor.IStandaloneCodeEditor,
-    connection: ProtocolConnection
-) {
+function setupDiagnostics(editor, connection) {
     connection.onNotification(PublishDiagnosticsNotification.type, e => {
-        monaco.editor.setModelMarkers(editor.getModel()!, 'lsp', e.diagnostics.map(lspToMonacoMarker));
+        monaco.editor.setModelMarkers(editor.getModel(), 'lsp', e.diagnostics.map(lspToMonacoMarker));
     });
 }
-
-function setupHover(
-    documentUri: string,
-    languageId: string,
-    connection: ProtocolConnection,
-    initResponse: InitializeResult<any>
-) {
+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: HoverParams = {
+            const params = {
                 position: {
                     line: position.lineNumber - 1,
                     character: position.column - 1
@@ -193,21 +146,14 @@ function setupHover(
         }
     });
 }
-
-function setupSignatureHelp(
-    documentUri: string,
-    languageId: string,
-    connection: ProtocolConnection,
-    initResponse: InitializeResult<any>
-) {
+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: SignatureHelpParams = {
+            const params = {
                 position: {
                     character: position.column - 1,
                     line: position.lineNumber - 1
@@ -224,33 +170,25 @@ function setupSignatureHelp(
                     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
+        signatureHelpRetriggerCharacters: initResponse.capabilities.signatureHelpProvider.retriggerCharacters,
+        signatureHelpTriggerCharacters: initResponse.capabilities.signatureHelpProvider.triggerCharacters
     });
 }
-function setupCompletion(
-    documentUri: string,
-    languageId: string,
-    connection: ProtocolConnection,
-    initResponse: InitializeResult<any>
-) {
+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,
+        triggerCharacters: initResponse.capabilities.completionProvider.triggerCharacters,
         async provideCompletionItems(_, position, context, token) {
-            const params: CompletionParams = {
+            const params = {
                 position: {
                     line: position.lineNumber - 1,
                     character: position.column - 1
@@ -267,30 +205,22 @@ function setupCompletion(
             if (response === null) {
                 return null;
             }
-            const range: monaco.Range = new monaco.Range(
-                position.lineNumber,
-                position.column,
-                position.lineNumber,
-                position.column
-            );
-
+            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.map(r => lspToMonacoCompletionItem(r, range)),
+                    incomplete: false
+                }
                 : {
-                      suggestions: response.items.map(r => lspToMonacoCompletionItem(r, range)),
-                      incomplete: response.isIncomplete
-                  };
+                    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
-            );
+            const response = await connection.sendRequest(CompletionResolveRequest.type, monacoToLspCompletionItem(item), token);
             return lspToMonacoCompletionItem(response, item.range);
         }
     });
 }
+
+export { basicEditorLspIntegration };