@coderline/alphatab-monaco 1.7.0-alpha.1626

package/dist/yaml.mjs

@@ -0,0 +1,238 @@
+/*!
+ * alphaTab Monaco v1.7.0-alpha.1626 (develop, build 1626)
+ *
+ * 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 { m as monaco_editor_core_star } from './alphaTab.monaco2.mjs';
+
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.54.0(7c2310116c57517348bbd868a21139f32454be22)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget);
+
+// src/fillers/monaco-editor-core.ts
+var monaco_editor_core_exports = {};
+__reExport(monaco_editor_core_exports, monaco_editor_core_star);
+
+// src/basic-languages/yaml/yaml.ts
+var conf = {
+  comments: {
+    lineComment: "#"
+  },
+  brackets: [
+    ["{", "}"],
+    ["[", "]"],
+    ["(", ")"]
+  ],
+  autoClosingPairs: [
+    { open: "{", close: "}" },
+    { open: "[", close: "]" },
+    { open: "(", close: ")" },
+    { open: '"', close: '"' },
+    { open: "'", close: "'" }
+  ],
+  surroundingPairs: [
+    { open: "{", close: "}" },
+    { open: "[", close: "]" },
+    { open: "(", close: ")" },
+    { open: '"', close: '"' },
+    { open: "'", close: "'" }
+  ],
+  folding: {
+    offSide: true
+  },
+  onEnterRules: [
+    {
+      beforeText: /:\s*$/,
+      action: {
+        indentAction: monaco_editor_core_exports.languages.IndentAction.Indent
+      }
+    }
+  ]
+};
+var language = {
+  tokenPostfix: ".yaml",
+  brackets: [
+    { token: "delimiter.bracket", open: "{", close: "}" },
+    { token: "delimiter.square", open: "[", close: "]" }
+  ],
+  keywords: ["true", "True", "TRUE", "false", "False", "FALSE", "null", "Null", "Null", "~"],
+  numberInteger: /(?:0|[+-]?[0-9]+)/,
+  numberFloat: /(?:0|[+-]?[0-9]+)(?:\.[0-9]+)?(?:e[-+][1-9][0-9]*)?/,
+  numberOctal: /0o[0-7]+/,
+  numberHex: /0x[0-9a-fA-F]+/,
+  numberInfinity: /[+-]?\.(?:inf|Inf|INF)/,
+  numberNaN: /\.(?:nan|Nan|NAN)/,
+  numberDate: /\d{4}-\d\d-\d\d([Tt ]\d\d:\d\d:\d\d(\.\d+)?(( ?[+-]\d\d?(:\d\d)?)|Z)?)?/,
+  escapes: /\\(?:[btnfr\\"']|[0-7][0-7]?|[0-3][0-7]{2})/,
+  tokenizer: {
+    root: [
+      { include: "@whitespace" },
+      { include: "@comment" },
+      // Directive
+      [/%[^ ]+.*$/, "meta.directive"],
+      // Document Markers
+      [/---/, "operators.directivesEnd"],
+      [/\.{3}/, "operators.documentEnd"],
+      // Block Structure Indicators
+      [/[-?:](?= )/, "operators"],
+      { include: "@anchor" },
+      { include: "@tagHandle" },
+      { include: "@flowCollections" },
+      { include: "@blockStyle" },
+      // Numbers
+      [/@numberInteger(?![ \t]*\S+)/, "number"],
+      [/@numberFloat(?![ \t]*\S+)/, "number.float"],
+      [/@numberOctal(?![ \t]*\S+)/, "number.octal"],
+      [/@numberHex(?![ \t]*\S+)/, "number.hex"],
+      [/@numberInfinity(?![ \t]*\S+)/, "number.infinity"],
+      [/@numberNaN(?![ \t]*\S+)/, "number.nan"],
+      [/@numberDate(?![ \t]*\S+)/, "number.date"],
+      // Key:Value pair
+      [/(".*?"|'.*?'|[^#'"]*?)([ \t]*)(:)( |$)/, ["type", "white", "operators", "white"]],
+      { include: "@flowScalars" },
+      // String nodes
+      [
+        /.+?(?=(\s+#|$))/,
+        {
+          cases: {
+            "@keywords": "keyword",
+            "@default": "string"
+          }
+        }
+      ]
+    ],
+    // Flow Collection: Flow Mapping
+    object: [
+      { include: "@whitespace" },
+      { include: "@comment" },
+      // Flow Mapping termination
+      [/\}/, "@brackets", "@pop"],
+      // Flow Mapping delimiter
+      [/,/, "delimiter.comma"],
+      // Flow Mapping Key:Value delimiter
+      [/:(?= )/, "operators"],
+      // Flow Mapping Key:Value key
+      [/(?:".*?"|'.*?'|[^,\{\[]+?)(?=: )/, "type"],
+      // Start Flow Style
+      { include: "@flowCollections" },
+      { include: "@flowScalars" },
+      // Scalar Data types
+      { include: "@tagHandle" },
+      { include: "@anchor" },
+      { include: "@flowNumber" },
+      // Other value (keyword or string)
+      [
+        /[^\},]+/,
+        {
+          cases: {
+            "@keywords": "keyword",
+            "@default": "string"
+          }
+        }
+      ]
+    ],
+    // Flow Collection: Flow Sequence
+    array: [
+      { include: "@whitespace" },
+      { include: "@comment" },
+      // Flow Sequence termination
+      [/\]/, "@brackets", "@pop"],
+      // Flow Sequence delimiter
+      [/,/, "delimiter.comma"],
+      // Start Flow Style
+      { include: "@flowCollections" },
+      { include: "@flowScalars" },
+      // Scalar Data types
+      { include: "@tagHandle" },
+      { include: "@anchor" },
+      { include: "@flowNumber" },
+      // Other value (keyword or string)
+      [
+        /[^\],]+/,
+        {
+          cases: {
+            "@keywords": "keyword",
+            "@default": "string"
+          }
+        }
+      ]
+    ],
+    // First line of a Block Style
+    multiString: [[/^( +).+$/, "string", "@multiStringContinued.$1"]],
+    // Further lines of a Block Style
+    //   Workaround for indentation detection
+    multiStringContinued: [
+      [
+        /^( *).+$/,
+        {
+          cases: {
+            "$1==$S2": "string",
+            "@default": { token: "@rematch", next: "@popall" }
+          }
+        }
+      ]
+    ],
+    whitespace: [[/[ \t\r\n]+/, "white"]],
+    // Only line comments
+    comment: [[/#.*$/, "comment"]],
+    // Start Flow Collections
+    flowCollections: [
+      [/\[/, "@brackets", "@array"],
+      [/\{/, "@brackets", "@object"]
+    ],
+    // Start Flow Scalars (quoted strings)
+    flowScalars: [
+      [/"([^"\\]|\\.)*$/, "string.invalid"],
+      [/'([^'\\]|\\.)*$/, "string.invalid"],
+      [/'[^']*'/, "string"],
+      [/"/, "string", "@doubleQuotedString"]
+    ],
+    doubleQuotedString: [
+      [/[^\\"]+/, "string"],
+      [/@escapes/, "string.escape"],
+      [/\\./, "string.escape.invalid"],
+      [/"/, "string", "@pop"]
+    ],
+    // Start Block Scalar
+    blockStyle: [[/[>|][0-9]*[+-]?$/, "operators", "@multiString"]],
+    // Numbers in Flow Collections (terminate with ,]})
+    flowNumber: [
+      [/@numberInteger(?=[ \t]*[,\]\}])/, "number"],
+      [/@numberFloat(?=[ \t]*[,\]\}])/, "number.float"],
+      [/@numberOctal(?=[ \t]*[,\]\}])/, "number.octal"],
+      [/@numberHex(?=[ \t]*[,\]\}])/, "number.hex"],
+      [/@numberInfinity(?=[ \t]*[,\]\}])/, "number.infinity"],
+      [/@numberNaN(?=[ \t]*[,\]\}])/, "number.nan"],
+      [/@numberDate(?=[ \t]*[,\]\}])/, "number.date"]
+    ],
+    tagHandle: [[/\![^ ]*/, "tag"]],
+    anchor: [[/[&*][^ ]+/, "namespace"]]
+  }
+};
+
+export { conf, language };

package/package.json

@@ -0,0 +1,58 @@
+{
+    "name": "@coderline/alphatab-monaco",
+    "version": "1.7.0-alpha.1626",
+    "description": "A Monaco editor integration for alphaTab providing coding assistance for alphaTex.",
+    "keywords": [
+        "guitar",
+        "music-notation",
+        "music-sheet",
+        "html5",
+        "svg",
+        "guitar-tablature",
+        "alphaTab",
+        "alphaTex"
+    ],
+    "homepage": "https://alphatab.net",
+    "bugs": {
+        "url": "https://github.com/coderline/alphaTab/issues"
+    },
+    "author": "Daniel Kuschny",
+    "license": "MPL-2.0",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/coderline/alphaTab.git"
+    },
+    "scripts": {
+        "clean": "rimraf dist",
+        "lint": "biome lint",
+        "typecheck": "tsc --noEmit",
+        "build": "vite build",
+        "dev": "vite build --watch",
+        "test": "mocha"
+    },
+    "dependencies": {
+        "@coderline/alphatab": "^1.7.0-alpha.1626",
+        "monaco-editor": "^0.54.0",
+        "vscode-languageserver-types": "^3.17.5",
+        "vscode-oniguruma": "^2.0.1",
+        "vscode-textmate": "^9.2.1"
+    },
+    "devDependencies": {
+        "@biomejs/biome": "^2.2.6",
+        "@microsoft/api-extractor": "^7.53.1",
+        "@types/chai": "^5.2.2",
+        "@types/mocha": "^10.0.10",
+        "@types/node": "^24.8.1",
+        "assert": "^2.1.0",
+        "chai": "^6.2.0",
+        "mocha": "^11.7.4",
+        "rimraf": "^6.0.1",
+        "tslib": "^2.8.1",
+        "tsx": "^4.20.6",
+        "typescript": "^5.9.3"
+    },
+    "bin": "./dist/alphaTab.monaco.mjs",
+    "main": "./dist/alphaTab.monaco.mjs",
+    "types": "./dist/alphaTab.monaco.d.ts",
+    "type": "module"
+}

package/src/alphaTab.monaco.ts

@@ -0,0 +1,3 @@
+export * from './alphatex';
+export * from './textmate';
+

package/src/alphatex.ts

@@ -0,0 +1,18 @@
+import { languageConfiguration, textMateGrammar } from '@coderline/alphatab-language-server';
+import { registerGrammar } from '@coderline/alphatab-monaco/textmate';
+import type { TextMateGrammarSupport } from '@coderline/alphatab-monaco/types';
+
+/**
+ * Registers alphaTex as language in the provided grammar support context.
+ * @param grammarSupport The context for handling grammar support in Monaco.
+ */
+export async function registerAlphaTexGrammar(grammarSupport: TextMateGrammarSupport) {
+    return registerGrammar(
+        grammarSupport,
+        'alphatex',
+        async () => {
+            return JSON.stringify(textMateGrammar);
+        },
+        async () => languageConfiguration
+    );
+}

package/src/lsp.ts

@@ -0,0 +1,296 @@
+import {
+    lspToMonacoCompletionItem,
+    lspToMonacoHover,
+    lspToMonacoMarker,
+    lspToMonacoSignatureHelp,
+    monacoToLspCompletionItem,
+    monacoToLspCompletionTriggerKind,
+    monacoToLspContentChange,
+    monacoToLspSignatureHelp,
+    monacoToLspSignatureHelpTriggerKind
+} from '@coderline/alphatab-monaco/lspMonacoMappings';
+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';
+
+/**
+ * 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.
+ */
+export async function basicEditorLspIntegration(
+    editor: monaco.editor.IStandaloneCodeEditor,
+    languageServerWorker: Worker,
+    info: {
+        languageId: string;
+        logger?: Logger;
+        clientInfo?: InitializeParams['clientInfo'];
+    }
+) {
+    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: InitializeParams = {
+        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()
+        }
+    });
+
+    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 => {
+        await connection.sendNotification(DidChangeTextDocumentNotification.type, {
+            textDocument: {
+                uri: documentUri,
+                version: e.versionId
+            },
+            contentChanges: e.changes.map(monacoToLspContentChange)
+        });
+    });
+}
+
+function setupDiagnostics(
+    editor: monaco.editor.IStandaloneCodeEditor,
+    connection: ProtocolConnection
+) {
+    connection.onNotification(PublishDiagnosticsNotification.type, e => {
+        monaco.editor.setModelMarkers(editor.getModel()!, 'lsp', e.diagnostics.map(lspToMonacoMarker));
+    });
+}
+
+function setupHover(
+    documentUri: string,
+    languageId: string,
+    connection: ProtocolConnection,
+    initResponse: InitializeResult<any>
+) {
+    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 = {
+                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: string,
+    languageId: string,
+    connection: ProtocolConnection,
+    initResponse: InitializeResult<any>
+) {
+    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 = {
+                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
+    });
+}
+function setupCompletion(
+    documentUri: string,
+    languageId: string,
+    connection: ProtocolConnection,
+    initResponse: InitializeResult<any>
+) {
+    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: CompletionParams = {
+                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: monaco.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);
+        }
+    });
+}