@coderline/alphatab-language-server 1.7.0-alpha.1626

package/dist/types/alphatex/src/types.d.ts

@@ -0,0 +1,161 @@
+import type * as alphaTab from '@coderline/alphatab';
+/**
+ * Common props for elements with descriptions.
+ */
+export interface WithDescription {
+    /**
+     * An optional long description, typically shown in the extended doc popup
+     * shown on hovers and code completions.
+     */
+    longDescription?: string;
+    /**
+     * A short description, typically shown in the code completion box.
+     */
+    shortDescription: string;
+    /**
+     * If defined, the element is deprecated.
+     */
+    deprecated?: string;
+    /**
+     * Additional remarks relevant for this item.
+     */
+    remarks?: string;
+}
+/**
+ * Describes an individual value for a specific parameter.
+ */
+export interface ParameterValueDefinition extends WithDescription {
+    /**
+     * The name of the item
+     */
+    name: string;
+    /**
+     * The snippet to insert
+     */
+    snippet: string;
+    /**
+     * Whether this value has no code completion and mapping but for completeness on enum mappings
+     */
+    skip?: true;
+}
+/**
+ * Defines the details of a single parameter for a {@link SignatureDefinition}
+ */
+export interface ParameterDefinition extends WithDescription {
+    /**
+     * The name of the parameter
+     */
+    name: string;
+    /**
+     * The mode used to parse this parameter.
+     */
+    parseMode: alphaTab.importer.alphaTex.ArgumentListParseTypesMode;
+    /**
+     * The node type for this parameter.
+     */
+    type: alphaTab.importer.alphaTex.AlphaTexNodeType | alphaTab.importer.alphaTex.AlphaTexNodeType[];
+    /**
+     * Whether to allow strings in place of identifiers and vice versa.
+     */
+    allowAllStringTypes?: boolean;
+    /**
+     * The default value of this parameter if not provided.
+     */
+    defaultValue?: unknown;
+    /**
+     * Whether the values list should only be used for providing completion items.
+     * If set to true the parser will parse tokens of any value into the AST and
+     * separately semantic errors have to be created.
+     */
+    valuesOnlyForCompletion?: true;
+    /**
+     * A list of possible values
+     */
+    values?: ParameterValueDefinition[];
+    /**
+     * A list of identifiers which are reserved and cannot be used for this parameter.
+     */
+    reservedIdentifiers?: string[];
+}
+/**
+ * Defines a signature for values which can be passed into the containing element
+ * (e.g. metadata or properties)
+ */
+export interface SignatureDefinition {
+    /**
+     * An additional description specific for this signature.
+     */
+    description?: string;
+    /**
+     * Whether parsing should be strict, meaning: single values can be without parenthesis
+     * multiple values need parenthesis.
+     */
+    strict?: boolean;
+    /**
+     * The parameters which can be passed into this signature.
+     */
+    parameters: ParameterDefinition[];
+}
+/**
+ * Common props for documented elements.
+ */
+export interface WithSignatures extends WithDescription {
+    /**
+     * A list of signatures defining all overloads which can be called for this element.
+     */
+    signatures: SignatureDefinition[];
+    /**
+     * The snippet to insert on autocompleting this item.
+     */
+    snippet: string;
+    /**
+     * One or more examples demonstrating the usage of this element.
+     */
+    examples: AlphaTexExample | AlphaTexExample[];
+    /**
+     * Whether this item is hidden from auto completes and the docs
+     * (e.g. because of outdated mechanisms or aliases)
+     */
+    hidden?: true;
+}
+/**
+ * The documentation for a property.
+ */
+export interface PropertyDefinition extends WithSignatures {
+    /**
+     * The name of the property.
+     */
+    property: string;
+}
+/**
+ * An alphaTex example demonstrating the usage of elements.
+ */
+export type AlphaTexExample = string | {
+    /**
+     * The options to apply when rendering the example
+     */
+    options?: alphaTab.json.SettingsJson;
+    /**
+     * The plain alphaTex code.
+     */
+    tex: string;
+    /**
+     * An alternative MDX code to use for extended documentation, mainly used for the
+     * alphaTab website when advanced examples are needed.
+     */
+    websiteMdx?: string;
+};
+/**
+ * A definition for an alphaTex metadata tag
+ */
+export interface MetadataTagDefinition extends WithSignatures {
+    /**
+     * The metadata tag (including the backslash)
+     */
+    tag: string;
+    /**
+     * A lookup containing the properties available for this metadata.
+     * The key is the lowercase identifier of the property.
+     */
+    properties?: Map<string, PropertyDefinition>;
+}

package/dist/types/lsp/src/index.d.ts

@@ -0,0 +1,21 @@
+import { startNodeLanguageServer, startWebWorkerLanguageServer } from "./server";
+declare const documentation: {
+    structuralMetaData: Map<string, MetadataTagDefinition>;
+    scoreMetaData: Map<string, MetadataTagDefinition>;
+    staffMetaData: Map<string, MetadataTagDefinition>;
+    barMetaData: Map<string, MetadataTagDefinition>;
+    durationChangeProperties: Map<string, PropertyDefinition>;
+    beatProperties: Map<string, PropertyDefinition>;
+    noteProperties: Map<string, PropertyDefinition>;
+};
+import type { AlphaTexExample, MetadataTagDefinition, ParameterDefinition, ParameterValueDefinition, PropertyDefinition, SignatureDefinition, WithDescription, WithSignatures } from "./../../alphatex/src/types";
+/**
+ * The TextMate grammar definition as JSON encoded.
+ * Write this to a local json (e.g. alphatex.tmLanguage.json ) or pass it to any supported parser for further use.
+ */
+declare const textMateGrammar: any;
+/**
+ * The contents of a language-configuration.json to use in editors like VSCode.
+ */
+declare const languageConfiguration: any;
+export { documentation, languageConfiguration, startNodeLanguageServer, startWebWorkerLanguageServer, textMateGrammar, type AlphaTexExample, type MetadataTagDefinition, type ParameterDefinition, type ParameterValueDefinition, type PropertyDefinition, type SignatureDefinition, type WithDescription, type WithSignatures };

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

@@ -0,0 +1,3 @@
+import type { AlphaTexTextDocument, Connection } from "./types";
+import { type TextDocuments } from "./types";
+export declare function setupCompletion(connection: Connection, documents: TextDocuments<AlphaTexTextDocument>): void;

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

@@ -0,0 +1,2 @@
+import { type AlphaTexTextDocument, type Connection, type TextDocuments } from "./types";
+export declare function setupDiagnostics(connection: Connection, documents: TextDocuments<AlphaTexTextDocument>): void;

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

@@ -0,0 +1,2 @@
+import type { AlphaTexTextDocument, Connection, TextDocuments } from "./types";
+export declare function setupHover(connection: Connection, documents: TextDocuments<AlphaTexTextDocument>): void;

package/dist/types/lsp/src/server/index.d.ts

@@ -0,0 +1,13 @@
+import { BrowserMessageReader } from 'vscode-languageserver/lib/browser/main.js';
+type Port = ConstructorParameters<typeof BrowserMessageReader>[0];
+/**
+ * Starts a new language server communicating via WebWorker.
+ * @param readerPort The port used to reading incoming language server messages
+ * @param writerPort The port used to writer outgoing language server messages
+ */
+export declare function startWebWorkerLanguageServer(readerPort: Port, writerPort: Port): void;
+/**
+ * Starts a new language server communicating from a Node.js process with a parent Node.js.
+ */
+export declare function startNodeLanguageServer(): void;
+export {};

package/dist/types/lsp/src/server/signatureHelp.d.ts

@@ -0,0 +1,2 @@
+import { type AlphaTexTextDocument, type Connection, type TextDocuments } from "./types";
+export declare function setupSignatureHelp(connection: Connection, documents: TextDocuments<AlphaTexTextDocument>): void;

package/dist/types/lsp/src/server/types.d.ts

@@ -0,0 +1,15 @@
+import type * as alphaTab from '@coderline/alphatab';
+import type { createConnection as createBrowserConnection } from 'vscode-languageserver/lib/browser/main.js';
+import type { createConnection as createNodeConnection } from 'vscode-languageserver/lib/node/main.js';
+import type { TextDocument } from 'vscode-languageserver-textdocument';
+export type NodeConnection = ReturnType<typeof createNodeConnection>;
+export type BrowserConnection = ReturnType<typeof createBrowserConnection>;
+export type Connection = NodeConnection | BrowserConnection;
+export interface AlphaTexTextDocument extends TextDocument {
+    score?: alphaTab.model.Score;
+    ast?: alphaTab.importer.alphaTex.AlphaTexScoreNode;
+}
+export { type RemoteConsole, type TextDocumentPositionParams, TextDocuments } from 'vscode-languageserver';
+export { type DocumentDiagnosticReport, DocumentDiagnosticReportKind, type InitializeParams, type InitializeResult, PositionEncodingKind, TextDocumentSyncKind } from 'vscode-languageserver-protocol';
+export { TextDocument } from 'vscode-languageserver-textdocument';
+export { type CompletionItem, CompletionItemKind, type Diagnostic, DiagnosticSeverity, type Hover, InsertTextFormat, ParameterInformation, type SignatureHelp, SignatureInformation, TextEdit, uinteger } from 'vscode-languageserver-types';

package/dist/types/lsp/src/server/utils.d.ts

@@ -0,0 +1,6 @@
+import * as alphaTab from '@coderline/alphatab';
+import type { ParameterDefinition, SignatureDefinition } from "./../../../alphatex/src/types";
+export declare function binaryNodeSearch<T extends alphaTab.importer.alphaTex.AlphaTexAstNode>(items: T[], offset: number, trailingEnd?: number): T | undefined;
+export declare function resolveSignature(signatures: SignatureDefinition[], args: alphaTab.importer.alphaTex.AlphaTexArgumentList): Map<number, SignatureDefinition>;
+export declare function parameterToSyntax(parameter: ParameterDefinition, onlyParameterNames: boolean): string;
+export declare function nodeTypesToTypeDocs(parameter: ParameterDefinition): string;

package/dist/types/lsp/test/placeholder.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/lsp/vite.config.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vite").UserConfigFnObject;
+export default _default;

package/dist/types/tooling/src/typescript.d.ts

@@ -0,0 +1,9 @@
+import * as ts from 'typescript';
+type Logger = Pick<Console, 'log' | 'info' | 'warn' | 'error'>;
+export declare function createDiagnosticReporter(pretty: boolean, logger: Logger): ts.DiagnosticReporter;
+export declare function symbolFromNode(checker: ts.TypeChecker, node: ts.Node): ts.Symbol | undefined;
+export declare function resolveImportedSourceFile(checker: ts.TypeChecker, node: ts.ImportDeclaration): ts.SourceFile | undefined;
+export declare function createApiDtsFiles(dtsBaseDir: string, dtsFiles: string[], projectDir: string, outDir: string, logger: Logger): Promise<void>;
+export declare function isElementStyleHelper(node: ts.Statement): boolean;
+export declare function elementStyleUsingTransformer(): (context: ts.TransformationContext) => (source: ts.SourceFile) => ts.SourceFile;
+export {};

package/dist/types/tooling/src/vite.d.ts

@@ -0,0 +1,13 @@
+import { type RollupTypescriptOptions } from '@rollup/plugin-typescript';
+import type { OutputChunk } from 'rollup';
+import ts from 'typescript';
+import { type UserConfig } from 'vite';
+export declare function licenseHeaderPlugin(): import("rollup").Plugin<any>;
+export declare function defineEsmAndCommonJsConfig(entry: string): import("vite").UserConfigFnObject;
+export declare function defaultBuildUserConfig(): UserConfig;
+export declare function enableTypeScript(config: UserConfig, o?: Partial<RollupTypescriptOptions>, types?: boolean): void;
+export declare function umd(config: UserConfig, projectDir: string, name: string, entry: string, tsOptions?: RollupTypescriptOptions, withMin?: boolean): void;
+export declare function commonjs(config: UserConfig, projectDir: string, name: string, entry: string, tsOptions?: RollupTypescriptOptions): void;
+export declare function esm(config: UserConfig, projectDir: string, name: string, entry: string, tsOptions?: RollupTypescriptOptions, shouldCreateDts?: (chunk: OutputChunk) => boolean, withMin?: boolean): void;
+export declare function dtsPathsTransformer(mapping?: Record<string, string>, externals?: (string | RegExp)[]): (context: ts.TransformationContext) => (source: ts.SourceFile | ts.Bundle) => ts.SourceFile | ts.Bundle;
+export declare function defineEsmLibConfig(): import("vite").UserConfigFnObject;

package/dist/types/tooling/src/vite.plugin.dts.d.ts

@@ -0,0 +1 @@
+export default function generateDts(root: string, dtsPath: string, outputFile: string, externals: (string | RegExp)[]): void;

package/dist/types/tooling/src/vite.plugin.min.d.ts

@@ -0,0 +1,3 @@
+import type { OutputPlugin } from 'rollup';
+import { type MinifyOptions } from 'terser';
+export default function min(options: MinifyOptions): OutputPlugin;

package/package.json

@@ -0,0 +1,59 @@
+{
+    "name": "@coderline/alphatab-language-server",
+    "version": "1.7.0-alpha.1626",
+    "description": "A language server for alphaTab providing coding assistance for alphaTex.",
+    "keywords": [
+        "guitar",
+        "music-notation",
+        "music-sheet",
+        "html5",
+        "svg",
+        "guitar-tablature",
+        "alphaTab",
+        "alphaTex",
+        "language",
+        "server",
+        "lsp"
+    ],
+    "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",
+        "vscode-languageserver": "^9.0.1",
+        "vscode-languageserver-textdocument": "^1.0.12"
+    },
+    "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/server.mjs",
+    "main": "./dist/server.mjs",
+    "types": "./dist/server.d.ts",
+    "type": "module"
+}

package/src/alphatex.tmLanguage.json

@@ -0,0 +1,151 @@
+{
+    "$schema": "https://raw.githubusercontent.com/martinring/tmlanguage/master/tmlanguage.json",
+    "name": "alphaTex",
+    "scopeName": "source.alphatex",
+    "uuid": "1ebe68ca-6558-428e-a6af-90831f41e88e",
+    "patterns": [
+        { "include": "#statements" }
+    ],
+    "repository": {
+        "statements": {
+            "patterns": [
+                { "include": "#string" },
+                { "include": "#comment" },
+                { "include": "#metadata" },
+                { "include": "#literal" },
+                { "include": "#expression" },
+                { "include": "#punctuation-pipe" },
+                { "include": "#punctuation-dot" }
+            ]
+        },
+        "string": {
+            "patterns": [
+                { "include": "#qstring-single" },
+                { "include": "#qstring-double" }
+            ]
+        },
+        "qstring-single": {
+            "name": "string.quoted.single.alphatex",
+            "begin": "'",
+            "beginCaptures": { "0": { "name": "punctuation.definition.string.begin.alphatex" } },
+            "end": "(\\')|((?:[^\\\\\\n])$)",
+            "endCaptures": {
+                "1": { "name": "punctuation.definition.string.end.alphatex" },
+                "2": { "name": "invalid.illegal.newline.alphatex" }
+            },
+            "patterns": [ { "include": "#string-character-escape" } ]
+        },
+        "qstring-double": {
+            "name": "string.quoted.double.alphatex",
+            "begin": "\"",
+            "beginCaptures": { "0": { "name": "punctuation.definition.string.begin.alphatex" } },
+            "end": "(\")|((?:[^\\\\\\n])$)",
+            "endCaptures": {
+                "1": { "name": "punctuation.definition.string.end.alphatex" },
+                "2": { "name": "invalid.illegal.newline.alphatex" }
+            },
+            "patterns": [ { "include": "#string-character-escape" } ]
+        },
+        "string-character-escape": {
+            "name": "constant.character.escape.alphatex",
+            "match": "\\\\(u[0-9A-Fa-f]{4}|.|$)"
+        },
+        "comment": {
+            "patterns": [
+                {
+                    "name": "comment.block.alphatex",
+                    "begin": "/\\*",
+                    "beginCaptures": { "0": { "name": "punctuation.definition.comment.alphatex" } },
+                    "end": "\\*/",
+                    "endCaptures": { "0": { "name": "punctuation.definition.comment.alphatex" } }
+                },
+                {
+                    "begin": "(^[ \\t]+)?(?=//)",
+                    "beginCaptures": { "1": { "name": "punctuation.whitespace.comment.leading.alphatex" } },
+                    "end": "(?=$)",
+                    "patterns": [
+                        {
+                            "name": "comment.line.double-slash.alphatex",
+                            "begin": "//",
+                            "beginCaptures": { "0": { "name": "punctuation.definition.comment.alphatex" } },
+                            "end": "(?=$)"
+                        }
+                    ]
+                }
+            ]
+        },
+        "literal": {
+            "patterns": [ { "include": "#numeric-literal" } ]
+        },
+        "numeric-literal": {
+            "name": "constant.numeric.decimal.alphatex",
+            "match": "[0-9]+",
+            "captures": { "0": { "name": "constant.numeric.decimal.alphatex" } }
+        },
+        "expression": {
+            "patterns": [
+                { "include": "#string" },
+                { "include": "#comment" },
+                { "include": "#literal" },
+                { "include": "#identifier" },
+                { "include": "#valueList" },
+                { "include": "#properties" },
+                { "include": "#punctuation" }
+            ]
+        },
+        "valueList": {
+            "begin": "\\(",
+            "beginCaptures": { "0": { "name": "punctuation.definition.value-list.begin.js" } },
+            "end": "\\)",
+            "endCaptures": { "0": { "name": "punctuation.definition.value-list.end.js" } },
+            "patterns": [
+                { "include": "#string" },
+                { "include": "#comment" },
+                { "include": "#literal" },
+                { "include": "#identifier" }
+            ]
+        },
+        "properties": {
+            "begin": "\\{",
+            "beginCaptures": { "0": { "name": "punctuation.definition.properties.begin.js" } },
+            "end": "\\}",
+            "endCaptures": { "0": { "name": "punctuation.definition.properties.end.js" } },
+            "patterns": [
+                { "include": "#string" },
+                { "include": "#comment" },
+                { "include": "#literal" },
+                { "include": "#identifier" },
+                { "include": "#valueList" }
+            ]
+        },
+        "metadata": {
+            "name": "keyword.metadata.alphatex",
+            "match": "\\\\{1,2}[^\\s]+",
+            "captures": { "0": { "name": "keyword.metadata.alphatex" } }
+        },
+        "identifier": {
+            "name": "variable.identifier.alphatex",
+            "match": "[^/\"'-\\.:\\(\\)\\{\\}\\|\\*\\\\\\s][^/\"'\\.:\\(\\)\\{\\}\\|\\*\\\\\\s]+",
+            "captures": { "0": { "name": "variable.identifier.alphatex" } }
+        },
+        "punctuation": {
+            "patterns": [
+                { "include": "#punctuation-dot" },
+                { "include": "#punctuation-pipe" },
+                { "include": "#punctuation-asterisk" }
+            ]
+        },
+        "punctuation-pipe": {
+            "name": "punctuation.bar.alphatex",
+            "match": "\\|"
+        },
+        "punctuation-dot": {
+            "name": "punctuation.dot.alphatex",
+            "match": "\\."
+        },
+        "punctuation-asterisk": {
+            "name": "punctuation.asterisk.alphatex",
+            "match": "\\*"
+        }
+    }
+}

package/src/index.ts

@@ -0,0 +1,56 @@
+import {
+    barMetaData,
+    beatProperties,
+    durationChangeProperties,
+    noteProperties,
+    scoreMetaData,
+    staffMetaData,
+    structuralMetaData
+} from '@coderline/alphatab-alphatex/definitions';
+import { startNodeLanguageServer, startWebWorkerLanguageServer } from '@coderline/alphatab-language-server/server';
+
+const documentation = {
+    structuralMetaData,
+    scoreMetaData,
+    staffMetaData,
+    barMetaData,
+    durationChangeProperties,
+    beatProperties,
+    noteProperties
+};
+
+import type {
+    AlphaTexExample,
+    MetadataTagDefinition,
+    ParameterDefinition,
+    ParameterValueDefinition,
+    PropertyDefinition,
+    SignatureDefinition,
+    WithDescription,
+    WithSignatures
+} from '@coderline/alphatab-alphatex/types';
+
+import textMateGrammarJson from './alphatex.tmLanguage.json';
+import languageConfigurationJson from './language-configuration.json';
+
+// export jsons as untyped objects for further use
+
+/**
+ * The TextMate grammar definition as JSON encoded.
+ * Write this to a local json (e.g. alphatex.tmLanguage.json ) or pass it to any supported parser for further use.
+ */
+const textMateGrammar: any = textMateGrammarJson;
+/**
+ * The contents of a language-configuration.json to use in editors like VSCode.
+ */
+const languageConfiguration: any = languageConfigurationJson;
+
+export {
+    documentation, languageConfiguration, startNodeLanguageServer,
+    startWebWorkerLanguageServer, textMateGrammar, type AlphaTexExample,
+    type MetadataTagDefinition, type ParameterDefinition, type ParameterValueDefinition, type PropertyDefinition, type SignatureDefinition, type WithDescription, type WithSignatures
+};
+
+if (import.meta.main) {
+    startNodeLanguageServer();
+}

package/src/language-configuration.json

@@ -0,0 +1,70 @@
+{
+    "comments": {
+        "lineComment": {
+            "comment": "//",
+            "noIndent": false
+        },
+        "blockComment": [
+            "/*",
+            "*/"
+        ]
+    },
+    "brackets": [
+        [
+            "{",
+            "}"
+        ],
+        [
+            "[",
+            "]"
+        ],
+        [
+            "(",
+            ")"
+        ]
+    ],
+    "autoClosingPairs": [
+        {
+            "open": "{",
+            "close": "}"
+        },
+        {
+            "open": "[",
+            "close": "]"
+        },
+        {
+            "open": "(",
+            "close": ")"
+        },
+        {
+            "open": "\"",
+            "close": "\""
+        },
+        {
+            "open": "'",
+            "close": "'"
+        }
+    ],
+    "surroundingPairs": [
+        {
+            "open": "{",
+            "close": "}"
+        },
+        {
+            "open": "[",
+            "close": "]"
+        },
+        {
+            "open": "(",
+            "close": ")"
+        },
+        {
+            "open": "\"",
+            "close": "\""
+        },
+        {
+            "open": "'",
+            "close": "'"
+        }
+    ]
+}