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

package/src/server/completion.ts

@@ -1,553 +0,0 @@
-import * as alphaTab from '@coderline/alphatab';
-import {
-    allMetadata,
-    barMetaData,
-    beatProperties,
-    durationChangeProperties,
-    noteProperties,
-    scoreMetaData,
-    structuralMetaData
-} from '@coderline/alphatab-alphatex/definitions';
-import type {
-    MetadataTagDefinition,
-    ParameterValueDefinition,
-    PropertyDefinition,
-    SignatureDefinition
-} from '@coderline/alphatab-alphatex/types';
-import type { AlphaTexTextDocument, Connection } from '@coderline/alphatab-language-server/server/types';
-import {
-    type CompletionItem,
-    CompletionItemKind,
-    InsertTextFormat,
-    type RemoteConsole,
-    type TextDocumentPositionParams,
-    type TextDocuments,
-    TextEdit
-} from '@coderline/alphatab-language-server/server/types';
-import { binaryNodeSearch, resolveSignature } from '@coderline/alphatab-language-server/server/utils';
-
-interface MetaDataCompletionData {
-    tagLowerCase: string;
-    tag: string;
-}
-
-interface CompletionItemWithData<T> extends CompletionItem {
-    data: T;
-}
-
-const topLevelCompletions = [
-    ...createMetaDataDocCompletions(structuralMetaData),
-    ...createMetaDataDocCompletions(scoreMetaData),
-    ...createMetaDataDocCompletions(barMetaData)
-];
-
-export function setupCompletion(connection: Connection, documents: TextDocuments<AlphaTexTextDocument>) {
-    connection.onCompletion((params: TextDocumentPositionParams): CompletionItem[] => {
-        const document = documents.get(params.textDocument.uri);
-        if (!document?.ast) {
-            return topLevelCompletions;
-        }
-
-        const offset = document.offsetAt(params.position);
-
-        const bar = binaryNodeSearch(document.ast.bars, offset, Number.MAX_SAFE_INTEGER);
-        const barIndex = bar ? document.ast.bars.indexOf(bar) : 0;
-
-        // no bar
-        if (!bar) {
-            return sortCompletions(
-                createMetaDataCompletions(barIndex, undefined, offset, Number.MAX_SAFE_INTEGER),
-                connection.console
-            );
-        }
-
-        const endOfBar =
-            bar.pipe?.start!.offset ??
-            (barIndex === document.ast.bars.length - 1
-                ? Number.MAX_SAFE_INTEGER
-                : document.ast.bars[barIndex + 1].start!.offset);
-
-        const endOfBarMetaData = bar.beats[0]?.start!.offset ?? endOfBar;
-        const metaData = bar ? binaryNodeSearch(bar.metaData, offset, endOfBarMetaData) : undefined;
-        if (metaData) {
-            const metaDataIndex = bar.metaData.indexOf(metaData);
-            const endOfMetaData =
-                metaDataIndex === bar.metaData.length - 1
-                    ? endOfBarMetaData
-                    : bar.metaData[metaDataIndex + 1].start!.offset;
-            return sortCompletions(
-                createMetaDataCompletions(barIndex, metaData, offset, endOfMetaData),
-                connection.console
-            );
-        }
-
-        const beat = binaryNodeSearch(bar.beats, offset, endOfBar);
-        if (beat) {
-            const beatIndex = bar.beats.indexOf(beat);
-            const endOfBeat = beatIndex === bar.beats.length - 1 ? endOfBar : bar.beats[beatIndex + 1].start!.offset;
-
-            return sortCompletions(createBeatCompletions(beat, offset, endOfBeat), connection.console);
-        }
-
-        return sortCompletions(
-            createMetaDataCompletions(barIndex, undefined, offset, Number.MAX_SAFE_INTEGER),
-            connection.console
-        );
-    });
-
-    connection.onCompletionResolve((item: CompletionItem): CompletionItem => {
-        return item;
-    });
-}
-
-function sortCompletions(completions: CompletionItem[], console: RemoteConsole): CompletionItem[] {
-    let i = 'a'.charCodeAt(0);
-    for (const c of completions) {
-        c.sortText = `${String.fromCharCode(i++)}`;
-    }
-    console.debug(`Provide completions: ${JSON.stringify(completions)}`);
-    return completions;
-}
-
-const durations: [string, alphaTab.model.Duration][] = [
-    ['Whole Note', alphaTab.model.Duration.Whole],
-    ['Half Note', alphaTab.model.Duration.Half],
-    ['Quarter Note', alphaTab.model.Duration.Quarter],
-    ['8th Note', alphaTab.model.Duration.Eighth],
-    ['16th Note', alphaTab.model.Duration.Sixteenth],
-    ['32nd Note', alphaTab.model.Duration.ThirtySecond],
-    ['64th Note', alphaTab.model.Duration.SixtyFourth],
-    ['128th Note', alphaTab.model.Duration.OneHundredTwentyEighth],
-    ['256th Note', alphaTab.model.Duration.TwoHundredFiftySixth],
-    ['Quadruple Whole Note', alphaTab.model.Duration.QuadrupleWhole],
-    ['Double Whole Note', alphaTab.model.Duration.DoubleWhole]
-];
-
-const durationCompletionItems = durations.map(
-    d =>
-        ({
-            label: `${d[1] as number}`,
-            labelDetails: {
-                description: d[0]
-            },
-            kind: CompletionItemKind.Value,
-            insertText: `${d[1] as number} `,
-            insertTextFormat: InsertTextFormat.Snippet
-        }) satisfies CompletionItem
-);
-
-function createBeatCompletions(
-    beat: alphaTab.importer.alphaTex.AlphaTexBeatNode,
-    offset: number,
-    endOfBeat: number
-): CompletionItem[] {
-    const completions: CompletionItem[] = [];
-
-    if (
-        beat.durationChange &&
-        beat.durationChange.start!.offset < offset &&
-        offset <= beat.durationChange!.end!.offset
-    ) {
-        const endOfDurationChange = beat.notes?.start!.offset ?? endOfBeat;
-        return createDurationChangeCompletions(beat.durationChange, offset, endOfDurationChange);
-    }
-
-    if (beat.notes && beat.notes.start!.offset < offset && offset <= beat.notes.end!.offset) {
-        const endOfNotes =
-            beat.notes?.closeParenthesis?.start!.offset ??
-            beat.durationDot?.start!.offset ??
-            beat.beatEffects?.start!.offset ??
-            beat.beatMultiplier?.start!.offset ??
-            endOfBeat;
-        const note = binaryNodeSearch(beat.notes.notes, offset, endOfNotes);
-        if (note) {
-            const noteIndex = beat.notes.notes.indexOf(note);
-            const endOfNote =
-                noteIndex === beat.notes.notes.length - 1 ? endOfNotes : beat.notes.notes[noteIndex + 1].start!.offset;
-            return createNoteCompletions(beat, note, offset, endOfNote);
-        }
-    }
-
-    const afterDuration = beat.beatMultiplier?.start?.offset ?? beat.beatEffects?.start?.offset ?? beat.end!.offset;
-
-    if (beat.durationDot && beat.durationDot.start!.offset < offset && (offset <= afterDuration || !beat.beatEffects)) {
-        const replacement: TextEdit[] | undefined = beat.durationValue
-            ? [
-                  TextEdit.del({
-                      start: {
-                          line: beat.durationDot.end!.line - 1,
-                          character: beat.durationDot.end!.col - 1
-                      },
-                      end: {
-                          line: beat.durationValue!.end!.line - 1,
-                          character: beat.durationValue!.end!.col - 1
-                      }
-                  })
-              ]
-            : undefined;
-
-        completions.push(
-            ...durationCompletionItems.map(
-                d =>
-                    ({
-                        ...d,
-                        additionalTextEdits: replacement
-                    }) satisfies CompletionItem
-            )
-        );
-    }
-
-    if (beat.beatEffects && beat.beatEffects.start!.offset < offset && beat.beatEffects.end!.offset) {
-        const endOfProperties =
-            beat.beatEffects?.closeBrace?.start!.offset ?? beat.beatMultiplier?.start!.offset ?? endOfBeat;
-        completions.splice(
-            0,
-            0,
-            ...createPropertiesCompletions(beat.beatEffects, offset, beatProperties, endOfProperties)
-        );
-    }
-
-    return completions;
-}
-
-function createDurationChangeCompletions(
-    durationChange: alphaTab.importer.alphaTex.AlphaTexBeatDurationChangeNode,
-    offset: number,
-    endOfDurationChange: number
-): CompletionItem[] {
-    const completions: CompletionItem[] = [];
-
-    if (!durationChange.properties || offset < durationChange.properties.start!.offset) {
-        const endOfValue = durationChange.properties?.start ?? durationChange.end!;
-        const replacement: TextEdit[] | undefined = durationChange.properties
-            ? [
-                  TextEdit.del({
-                      start: {
-                          line: durationChange.colon.start!.line - 1,
-                          character: durationChange.colon.start!.col - 1
-                      },
-                      end: {
-                          line: endOfValue.line - 1,
-                          character: endOfValue.col - 1
-                      }
-                  })
-              ]
-            : undefined;
-
-        completions.push(
-            ...durationCompletionItems.map(d => ({
-                ...d,
-                additionalTextEdits: replacement
-            }))
-        );
-    } else if (
-        durationChange.properties &&
-        durationChange.properties.start!.offset < offset &&
-        durationChange.properties.end!.offset
-    ) {
-        const endOfProperties = durationChange.properties?.closeBrace?.start!.offset ?? endOfDurationChange;
-        completions.push(
-            ...createPropertiesCompletions(durationChange.properties, offset, durationChangeProperties, endOfProperties)
-        );
-    }
-
-    return completions;
-}
-
-function createNoteCompletions(
-    beat: alphaTab.importer.alphaTex.AlphaTexBeatNode,
-    note: alphaTab.importer.alphaTex.AlphaTexNoteNode,
-    offset: number,
-    endOfNote: number
-): CompletionItem[] {
-    const completions: CompletionItem[] = [];
-    if (note.noteEffects && note.noteEffects.start!.offset < offset && note.noteEffects.end!.offset) {
-        const endOfProperties = note.noteEffects.closeBrace?.start!.offset ?? endOfNote;
-
-        if (beat.notes!.notes.length === 1) {
-            completions.splice(
-                0,
-                0,
-                ...createPropertiesCompletions(note.noteEffects, offset, beatProperties, endOfProperties)
-            );
-        }
-
-        completions.splice(
-            0,
-            0,
-            ...createPropertiesCompletions(note.noteEffects, offset, noteProperties, endOfProperties)
-        );
-    }
-    return completions;
-}
-
-function propertyToCompletion(p: PropertyDefinition, more?: Partial<CompletionItem>): CompletionItem {
-    return {
-        label: p.property,
-        kind: CompletionItemKind.Property,
-        insertText: p.snippet,
-        labelDetails: p.shortDescription
-            ? {
-                  description: p.shortDescription
-              }
-            : undefined,
-        documentation: p.longDescription
-            ? {
-                  kind: 'markdown',
-                  value: p.longDescription
-              }
-            : undefined,
-        insertTextFormat: InsertTextFormat.Snippet,
-        ...more
-    };
-}
-function valueItemToCompletion(i: ParameterValueDefinition, more?: Partial<CompletionItem>): CompletionItem {
-    return {
-        label: i.name,
-        kind: CompletionItemKind.Value,
-        labelDetails: i.shortDescription
-            ? {
-                  description: i.shortDescription
-              }
-            : undefined,
-        documentation: i.longDescription
-            ? {
-                  kind: 'markdown',
-                  value: i.longDescription
-              }
-            : undefined,
-        insertText: i.snippet,
-        insertTextFormat: InsertTextFormat.Snippet,
-        ...more
-    };
-}
-
-function metaDataDocToCompletion(d: MetadataTagDefinition): CompletionItemWithData<MetaDataCompletionData> {
-    return {
-        label: d.tag,
-        kind: CompletionItemKind.Function,
-        labelDetails: d.shortDescription
-            ? {
-                  description: d.shortDescription
-              }
-            : undefined,
-        documentation: d.longDescription
-            ? {
-                  kind: 'markdown',
-                  value: d.longDescription
-              }
-            : undefined,
-        insertText: d.snippet,
-        insertTextFormat: InsertTextFormat.Snippet,
-        data: {
-            tag: d.tag.substring(1), // cut off backslash
-            tagLowerCase: d.tag.substring(1).toLowerCase()
-        }
-    };
-}
-
-function createMetaDataCompletions(
-    barIndex: number,
-    metaData: alphaTab.importer.alphaTex.AlphaTexMetaDataNode | undefined,
-    offset: number,
-    endOfMetaData: number
-) {
-    let completions: CompletionItem[] = [];
-    const tagCompletion = !metaData || (metaData.tag.start!.offset <= offset && offset <= metaData.tag.end!.offset);
-    if (tagCompletion) {
-        if (barIndex === 0) {
-            completions.push(...topLevelCompletions);
-        } else {
-            completions.push(
-                ...createMetaDataDocCompletions(structuralMetaData),
-                ...createMetaDataDocCompletions(barMetaData)
-            );
-        }
-
-        if (metaData) {
-            const keepValues = metaData.arguments || metaData.properties;
-            completions = completions.map(c => ({
-                ...c,
-                insertText: keepValues ? c.label : c.insertText,
-                additionalTextEdits: [
-                    TextEdit.del({
-                        start: {
-                            line: metaData.tag.start!.line - 1,
-                            character: metaData.tag.start!.col - 1
-                        },
-                        end: {
-                            line: metaData.tag.end!.line - 1,
-                            character: metaData.tag.end!.col - 1
-                        }
-                    })
-                ]
-            }));
-        }
-
-        return completions;
-    } else if (offset >= metaData.end!.offset) {
-        if (barIndex === 0) {
-            completions.push(...topLevelCompletions);
-        } else {
-            completions.push(
-                ...createMetaDataDocCompletions(structuralMetaData),
-                ...createMetaDataDocCompletions(barMetaData)
-            );
-        }
-    }
-
-    const metaDataDocs = allMetadata.get(`\\${metaData.tag.tag.text.toLowerCase()}`);
-    if (!metaDataDocs) {
-        return completions;
-    }
-
-    const endOfArguments =
-        metaData.arguments?.closeParenthesis?.start!.offset ??
-        metaData.arguments?.end!.offset ??
-        metaData.properties?.start!.offset ??
-        endOfMetaData;
-    completions.splice(
-        0,
-        0,
-        ...createArgumentCompletions(metaDataDocs.signatures, metaData.arguments, offset, endOfArguments)
-    );
-
-    if (metaDataDocs?.properties) {
-        const endOfProperties = metaData.properties?.closeBrace?.start!.offset ?? endOfMetaData;
-        completions.splice(
-            0,
-            0,
-            ...createPropertiesCompletions(metaData.properties, offset, metaDataDocs.properties, endOfProperties)
-        );
-    }
-
-    return completions;
-}
-
-function createArgumentCompletions(
-    signatures: SignatureDefinition[],
-    actualValues: alphaTab.importer.alphaTex.AlphaTexArgumentList | undefined,
-    offset: number,
-    trailingEnd: number
-) {
-    if (actualValues) {
-        const value = binaryNodeSearch(actualValues.arguments, offset, trailingEnd);
-        if (value?.parameterIndices) {
-            const signatureCandidates = resolveSignature(signatures, actualValues);
-            for (const [k, v] of signatureCandidates) {
-                const parameterIndex = value.parameterIndices.get(k);
-                const values = parameterIndex !== undefined ? v.parameters[parameterIndex].values : undefined;
-                if (values) {
-                    return values.map(i =>
-                        valueItemToCompletion(i, {
-                            additionalTextEdits: [
-                                TextEdit.del({
-                                    start: {
-                                        line: value.start!.line - 1,
-                                        character: value.start!.col - 1
-                                    },
-                                    end: {
-                                        line: value.end!.line - 1,
-                                        character: value.end!.col - 1
-                                    }
-                                })
-                            ]
-                        })
-                    );
-                }
-            }
-        }
-    } else {
-        const firstParameterValues = signatures.flatMap(s =>
-            s.parameters.length > 0 ? (s.parameters[0].values ?? []) : []
-        );
-        return firstParameterValues.map(i => valueItemToCompletion(i));
-    }
-
-    return [];
-}
-
-function createMetaDataDocCompletions(
-    metaData: Map<string, MetadataTagDefinition>
-): CompletionItemWithData<MetaDataCompletionData>[] {
-    return Array.from(metaData.values()).map(metaDataDocToCompletion);
-}
-
-function createPropertiesCompletions(
-    properties: alphaTab.importer.alphaTex.AlphaTexPropertiesNode | undefined,
-    offset: number,
-    availableProperties: Map<string, PropertyDefinition>,
-    endOfProperties: number
-): CompletionItem[] {
-    if (!properties) {
-        return [];
-    }
-
-    const end = properties.closeBrace?.start?.offset ?? properties.end!.offset;
-    if (offset < properties.openBrace!.start!.offset || offset > end) {
-        return [];
-    }
-
-    const allPropCompletions: CompletionItem[] = Array.from(availableProperties.values()).map(p =>
-        propertyToCompletion(p)
-    );
-
-    const prop = properties ? binaryNodeSearch(properties.properties, offset, endOfProperties) : undefined;
-    if (prop) {
-        const propIndex = properties.properties.indexOf(prop);
-        const endOfProp =
-            propIndex === properties.properties.length - 1
-                ? endOfProperties
-                : properties.properties[propIndex + 1].start!.offset;
-        return createPropertyCompletions(prop, offset, availableProperties, allPropCompletions, endOfProp);
-    }
-
-    return allPropCompletions;
-}
-
-function createPropertyCompletions(
-    property: alphaTab.importer.alphaTex.AlphaTexPropertyNode,
-    offset: number,
-    availableProperties: Map<string, PropertyDefinition>,
-    allPropCompletions: CompletionItem[],
-    endOfProperty: number
-) {
-    const completions: CompletionItem[] = [];
-    const propCompletion =
-        !property || (property.property.start!.offset <= offset && offset <= property.property.end!.offset);
-    if (propCompletion) {
-        completions.push(
-            ...allPropCompletions.map(c => ({
-                ...c,
-                additionalTextEdits: [
-                    TextEdit.del({
-                        start: {
-                            line: property.property.start!.line - 1,
-                            character: property.property.start!.col - 1
-                        },
-                        end: {
-                            line: property.property.end!.line - 1,
-                            character: property.property.end!.col - 1
-                        }
-                    })
-                ]
-            }))
-        );
-        return completions;
-    } else if (offset >= property.end!.offset) {
-        completions.push(...allPropCompletions);
-    }
-
-    const propDocs = availableProperties.get(property.property.text.toLowerCase());
-    if (!propDocs) {
-        return completions;
-    }
-
-    completions.splice(
-        0,
-        0,
-        ...createArgumentCompletions(propDocs.signatures, property.arguments, offset, endOfProperty)
-    );
-
-    return completions;
-}

package/src/server/diagnostics.ts

@@ -1,126 +0,0 @@
-import * as alphaTab from '@coderline/alphatab';
-import {
-    type AlphaTexTextDocument,
-    type Connection,
-    type Diagnostic,
-    DiagnosticSeverity,
-    type DocumentDiagnosticReport,
-    DocumentDiagnosticReportKind,
-    type TextDocuments,
-    uinteger
-} from '@coderline/alphatab-language-server/server/types';
-
-export function setupDiagnostics(connection: Connection, documents: TextDocuments<AlphaTexTextDocument>) {
-    connection.languages.diagnostics.on(async params => {
-        const document = documents.get(params.textDocument.uri);
-        if (document !== undefined) {
-            return {
-                kind: DocumentDiagnosticReportKind.Full,
-                items: await validateTextDocument(document)
-            } satisfies DocumentDiagnosticReport;
-        } else {
-            return {
-                kind: DocumentDiagnosticReportKind.Full,
-                items: []
-            } satisfies DocumentDiagnosticReport;
-        }
-    });
-
-    documents.onDidChangeContent(async change => {
-        const diagnostics = await validateTextDocument(change.document);
-        connection.sendDiagnostics({
-            diagnostics: diagnostics,
-            uri: change.document.uri,
-            version: change.document.version
-        });
-    });
-}
-
-function mapDiagnostics(atDiag: Iterable<alphaTab.importer.alphaTex.AlphaTexDiagnostic>): Diagnostic[] {
-    const diagnostics: Diagnostic[] = [];
-    for (const d of atDiag) {
-        const diagnostic: Diagnostic = {
-            severity: DiagnosticSeverity.Warning,
-            range: {
-                start: {
-                    line: d.start!.line - 1,
-                    character: d.start!.col - 1
-                },
-                end: {
-                    line: d.end!.line - 1,
-                    character: d.end!.col - 1
-                }
-            },
-            message: d.message,
-            code: `AT${d.code}`,
-            source: 'alphaTab'
-        };
-        switch (d.severity) {
-            case alphaTab.importer.alphaTex.AlphaTexDiagnosticsSeverity.Hint:
-                diagnostic.severity = DiagnosticSeverity.Hint;
-                break;
-            case alphaTab.importer.alphaTex.AlphaTexDiagnosticsSeverity.Warning:
-                diagnostic.severity = DiagnosticSeverity.Warning;
-                break;
-            case alphaTab.importer.alphaTex.AlphaTexDiagnosticsSeverity.Error:
-                diagnostic.severity = DiagnosticSeverity.Error;
-                break;
-        }
-        diagnostics.push(diagnostic);
-    }
-    return diagnostics;
-}
-function handleError(e: Error): Diagnostic[] {
-    let atError: alphaTab.importer.AlphaTexErrorWithDiagnostics | undefined;
-    if (e instanceof alphaTab.importer.AlphaTexErrorWithDiagnostics) {
-        atError = e;
-    } else if (
-        e instanceof alphaTab.importer.UnsupportedFormatError &&
-        e.cause instanceof alphaTab.importer.AlphaTexErrorWithDiagnostics
-    ) {
-        atError = e.cause;
-    }
-
-    if (atError) {
-        return mapDiagnostics(atError.iterateDiagnostics());
-    } else {
-        return [
-            {
-                severity: DiagnosticSeverity.Warning,
-                range: {
-                    start: {
-                        line: 0,
-                        character: 0
-                    },
-                    end: {
-                        line: 0,
-                        character: uinteger.MAX_VALUE
-                    }
-                },
-                message: `Unexpected error parsing alphaTex: ${e.message}`,
-                source: 'alphaTab'
-            }
-        ];
-    }
-}
-
-async function validateTextDocument(textDocument: AlphaTexTextDocument): Promise<Diagnostic[]> {
-    const diagnostics: Diagnostic[] = [];
-    const text = textDocument.getText();
-
-    const importer = new alphaTab.importer.AlphaTexImporter();
-    importer.initFromString(text, new alphaTab.Settings());
-    try {
-        textDocument.score = importer.readScore();
-        textDocument.ast = importer.scoreNode;
-        diagnostics.push(...mapDiagnostics(importer.lexerDiagnostics));
-        diagnostics.push(...mapDiagnostics(importer.parserDiagnostics));
-        diagnostics.push(...mapDiagnostics(importer.semanticDiagnostics));
-    } catch (e) {
-        textDocument.score = undefined;
-        textDocument.ast = importer.scoreNode;
-
-        diagnostics.push(...handleError(e as Error));
-    }
-    return diagnostics;
-}