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

package/dist/types/alphatab/src/importer/ScoreImporter.d.ts

@@ -0,0 +1,22 @@
+import type { IReadable } from "./../io/IReadable";
+import { Score } from "./../model/Score";
+import type { Settings } from "./../Settings";
+/**
+ * This is the base public class for creating new song importers which
+ * enable reading scores from any binary datasource
+ * @public
+ */
+export declare abstract class ScoreImporter {
+    protected data: IReadable;
+    protected settings: Settings;
+    /**
+     * Initializes the importer with the given data and settings.
+     */
+    init(data: IReadable, settings: Settings): void;
+    abstract get name(): string;
+    /**
+     * Reads the {@link Score} contained in the data.
+     * @returns The score that was contained in the data.
+     */
+    abstract readScore(): Score;
+}

package/dist/types/alphatab/src/importer/ScoreLoader.d.ts

@@ -0,0 +1,32 @@
+import type { Score } from "./../model/Score";
+import { Settings } from "./../Settings";
+/**
+ * The ScoreLoader enables you easy loading of Scores using all
+ * available importers
+ * @public
+ */
+export declare class ScoreLoader {
+    /**
+     * Loads the given alphaTex string.
+     * @param tex The alphaTex string.
+     * @param settings The settings to use for parsing.
+     * @returns The parsed {@see Score}.
+     */
+    static loadAlphaTex(tex: string, settings?: Settings): Score;
+    /**
+     * Loads a score asynchronously from the given datasource
+     * @param path the source path to load the binary file from
+     * @param success this function is called if the Score was successfully loaded from the datasource
+     * @param error this function is called if any error during the loading occured.
+     * @param settings settings for the score import
+     * @target web
+     */
+    static loadScoreAsync(path: string, success: (score: Score) => void, error: (error: any) => void, settings?: Settings): void;
+    /**
+     * Loads the score from the given binary data.
+     * @param data The binary data containing a score in any known file format.
+     * @param settings The settings to use during importing.
+     * @returns The loaded score.
+     */
+    static loadScoreFromBytes(data: Uint8Array, settings?: Settings): Score;
+}

package/dist/types/alphatab/src/importer/UnsupportedFormatError.d.ts

@@ -0,0 +1,9 @@
+import { AlphaTabError } from "./../AlphaTabError";
+/**
+ * The exception thrown by a {@link ScoreImporter} in case the
+ * binary data does not contain a reader compatible structure.
+ * @public
+ */
+export declare class UnsupportedFormatError extends AlphaTabError {
+    constructor(message?: string | null, inner?: Error);
+}

package/dist/types/alphatab/src/importer/_barrel.d.ts

@@ -0,0 +1,5 @@
+export { AlphaTexErrorWithDiagnostics, AlphaTexImporter } from "./AlphaTexImporter";
+export * as alphaTex from "./alphaTex/_barrel";
+export { ScoreImporter } from "./ScoreImporter";
+export { ScoreLoader } from "./ScoreLoader";
+export { UnsupportedFormatError } from "./UnsupportedFormatError";

package/dist/types/alphatab/src/importer/alphaTex/ATNF.d.ts

@@ -0,0 +1,19 @@
+import { type AlphaTexIdentifier, type AlphaTexMetaDataNode, type AlphaTexNumberLiteral, type AlphaTexPropertiesNode, type AlphaTexPropertyNode, type AlphaTexStringLiteral, type AlphaTexArgumentList, type IAlphaTexArgumentValue } from "./AlphaTexAst";
+/**
+ * AlphaTexNodeFactory (short name for less code)
+ * @internal
+ */
+export declare class Atnf {
+    static ident(text: string): AlphaTexIdentifier;
+    static string(text: string): AlphaTexStringLiteral;
+    static number(value: number): AlphaTexNumberLiteral;
+    static meta(tag: string, args?: AlphaTexArgumentList, properties?: AlphaTexPropertiesNode): AlphaTexMetaDataNode;
+    static identMeta(tag: string, value: string): AlphaTexMetaDataNode;
+    static numberMeta(tag: string, value: number): AlphaTexMetaDataNode;
+    static args(args: (IAlphaTexArgumentValue | undefined)[], parentheses?: boolean | undefined): AlphaTexArgumentList | undefined;
+    static stringValue(text: string): AlphaTexArgumentList;
+    static identValue(text: string): AlphaTexArgumentList;
+    static numberValue(value: number): AlphaTexArgumentList;
+    static props(properties: ([string, AlphaTexArgumentList | undefined] | undefined)[]): AlphaTexPropertiesNode;
+    static prop(properties: AlphaTexPropertyNode[], identifier: string, args?: AlphaTexArgumentList): void;
+}

package/dist/types/alphatab/src/importer/alphaTex/AlphaTex1EnumMappings.d.ts

@@ -0,0 +1,75 @@
+import type { AlphaTexAccidentalMode } from "./AlphaTexShared";
+import type { BarLineStyle } from "./../../model/Bar";
+import type { BarreShape } from "./../../model/BarreShape";
+import type { BendStyle } from "./../../model/BendStyle";
+import type { BendType } from "./../../model/BendType";
+import type { Clef } from "./../../model/Clef";
+import type { Direction } from "./../../model/Direction";
+import type { DynamicValue } from "./../../model/DynamicValue";
+import type { FermataType } from "./../../model/Fermata";
+import type { GraceType } from "./../../model/GraceType";
+import type { KeySignature } from "./../../model/KeySignature";
+import type { KeySignatureType } from "./../../model/KeySignatureType";
+import type { NoteAccidentalMode } from "./../../model/NoteAccidentalMode";
+import type { Ottavia } from "./../../model/Ottavia";
+import type { Rasgueado } from "./../../model/Rasgueado";
+import type { BracketExtendMode, TrackNameMode, TrackNameOrientation, TrackNamePolicy } from "./../../model/RenderStylesheet";
+import type { SimileMark } from "./../../model/SimileMark";
+import type { TripletFeel } from "./../../model/TripletFeel";
+import type { WhammyType } from "./../../model/WhammyType";
+import type { TextAlign } from "./../../platform/ICanvas";
+/**
+ * @internal
+ * @partial
+ */
+export declare class AlphaTex1EnumMappings {
+    private static _reverse;
+    static readonly whammyType: Map<string, WhammyType>;
+    static readonly whammyTypeReversed: Map<WhammyType, string>;
+    static readonly bendStyle: Map<string, BendStyle>;
+    static readonly bendStyleReversed: Map<BendStyle, string>;
+    static readonly graceType: Map<string, GraceType>;
+    static readonly graceTypeReversed: Map<GraceType, string>;
+    static readonly fermataType: Map<string, FermataType>;
+    static readonly fermataTypeReversed: Map<FermataType, string>;
+    static readonly alphaTexAccidentalMode: Map<string, AlphaTexAccidentalMode>;
+    static readonly alphaTexAccidentalModeReversed: Map<AlphaTexAccidentalMode, string>;
+    static readonly noteAccidentalMode: Map<string, NoteAccidentalMode>;
+    static readonly noteAccidentalModeReversed: Map<NoteAccidentalMode, string>;
+    static readonly barreShape: Map<string, BarreShape>;
+    static readonly barreShapeReversed: Map<BarreShape, string>;
+    static readonly ottavia: Map<string, Ottavia>;
+    static readonly ottaviaReversed: Map<Ottavia, string>;
+    static readonly rasgueado: Map<string, Rasgueado>;
+    static readonly rasgueadoReversed: Map<Rasgueado, string>;
+    static readonly dynamicValue: Map<string, DynamicValue>;
+    static readonly dynamicValueReversed: Map<DynamicValue, string>;
+    static readonly bracketExtendMode: Map<string, BracketExtendMode>;
+    static readonly bracketExtendModeReversed: Map<BracketExtendMode, string>;
+    static readonly trackNamePolicy: Map<string, TrackNamePolicy>;
+    static readonly trackNamePolicyReversed: Map<TrackNamePolicy, string>;
+    static readonly trackNameOrientation: Map<string, TrackNameOrientation>;
+    static readonly trackNameOrientationReversed: Map<TrackNameOrientation, string>;
+    static readonly trackNameMode: Map<string, TrackNameMode>;
+    static readonly trackNameModeReversed: Map<TrackNameMode, string>;
+    static readonly textAlign: Map<string, TextAlign>;
+    static readonly textAlignReversed: Map<TextAlign, string>;
+    static readonly bendType: Map<string, BendType>;
+    static readonly bendTypeReversed: Map<BendType, string>;
+    static readonly keySignature: Map<string, KeySignature>;
+    static readonly keySignatureReversed: Map<KeySignature, string>;
+    static readonly keySignatureType: Map<string, KeySignatureType>;
+    static readonly keySignatureTypeReversed: Map<KeySignatureType, string>;
+    static readonly clef: Map<string, Clef>;
+    static readonly clefReversed: Map<Clef, string>;
+    static readonly tripletFeel: Map<string, TripletFeel>;
+    static readonly tripletFeelReversed: Map<TripletFeel, string>;
+    static readonly barLineStyle: Map<string, BarLineStyle>;
+    static readonly barLineStyleReversed: Map<BarLineStyle, string>;
+    static readonly simileMark: Map<string, SimileMark>;
+    static readonly simileMarkReversed: Map<SimileMark, string>;
+    static readonly direction: Map<string, Direction>;
+    static readonly directionReversed: Map<Direction, string>;
+    static readonly keySignaturesMinorReversed: Map<KeySignature, string>;
+    static readonly keySignaturesMajorReversed: Map<KeySignature, string>;
+}

package/dist/types/alphatab/src/importer/alphaTex/AlphaTex1LanguageDefinitions.d.ts

@@ -0,0 +1,39 @@
+import type { AlphaTexNodeType } from "./AlphaTexAst";
+import type { ArgumentListParseTypesMode } from "./AlphaTexShared";
+/**
+ * @record
+ * @internal
+ */
+export interface AlphaTexParameterDefinition {
+    expectedTypes: Set<AlphaTexNodeType>;
+    parseMode: ArgumentListParseTypesMode;
+    allowedValues?: Set<string>;
+    reservedIdentifiers?: Set<string>;
+}
+/**
+ * @record
+ * @internal
+ */
+export interface AlphaTexSignatureDefinition {
+    isStrict: boolean;
+    parameters: AlphaTexParameterDefinition[];
+}
+/**
+ * @internal
+ */
+export declare class AlphaTex1LanguageDefinitions {
+    private static _param;
+    private static _simple;
+    private static _metaProps;
+    private static _props;
+    private static _signatures;
+    static readonly scoreMetaDataSignatures: Map<string, AlphaTexSignatureDefinition[] | null>;
+    static readonly staffMetaDataSignatures: Map<string, AlphaTexSignatureDefinition[] | null>;
+    static readonly structuralMetaDataSignatures: Map<string, AlphaTexSignatureDefinition[] | null>;
+    static readonly barMetaDataSignatures: Map<string, AlphaTexSignatureDefinition[] | null>;
+    static readonly metaDataProperties: Map<string, Map<string, AlphaTexSignatureDefinition[] | null> | null>;
+    static readonly metaDataSignatures: Map<string, AlphaTexSignatureDefinition[] | null>[];
+    static readonly durationChangeProperties: Map<string, AlphaTexSignatureDefinition[] | null>;
+    static readonly beatProperties: Map<string, AlphaTexSignatureDefinition[] | null>;
+    static readonly noteProperties: Map<string, AlphaTexSignatureDefinition[] | null>;
+}

package/dist/types/alphatab/src/importer/alphaTex/AlphaTex1LanguageHandler.d.ts

@@ -0,0 +1,72 @@
+import { type AlphaTexMetaDataNode, type AlphaTexPropertyNode } from "./AlphaTexAst";
+import { type IAlphaTexImporter } from "./AlphaTexShared";
+import { ApplyNodeResult, ApplyStructuralMetaDataResult, type IAlphaTexLanguageImportHandler } from "./IAlphaTexLanguageImportHandler";
+import { type Bar } from "./../../model/Bar";
+import { type Beat } from "./../../model/Beat";
+import type { Note } from "./../../model/Note";
+import { Score } from "./../../model/Score";
+import { Staff } from "./../../model/Staff";
+/**
+ * @internal
+ */
+export declare class AlphaTex1LanguageHandler implements IAlphaTexLanguageImportHandler {
+    static readonly instance: AlphaTex1LanguageHandler;
+    applyScoreMetaData(importer: IAlphaTexImporter, score: Score, metaData: AlphaTexMetaDataNode): ApplyNodeResult;
+    private _checkArgumentTypes;
+    applyStaffMetaData(importer: IAlphaTexImporter, staff: Staff, metaData: AlphaTexMetaDataNode): ApplyNodeResult;
+    applyBarMetaData(importer: IAlphaTexImporter, bar: Bar, metaData: AlphaTexMetaDataNode): ApplyNodeResult;
+    private static _handleAccidentalMode;
+    private static _getChordId;
+    private _buildSyncPoint;
+    private _validateArgumentTypes;
+    private _headerFooterStyle;
+    private _readTrackInstrument;
+    private _chordProperties;
+    private _tuningProperties;
+    private static _booleanLikeValue;
+    applyStructuralMetaData(importer: IAlphaTexImporter, metaData: AlphaTexMetaDataNode): ApplyStructuralMetaDataResult;
+    private _checkProperty;
+    private _staffProperties;
+    private _trackProperties;
+    applyBeatDurationProperty(importer: IAlphaTexImporter, p: AlphaTexPropertyNode): ApplyNodeResult;
+    private static _getTupletDenominator;
+    private _allKnownBarMetaDataTags;
+    get allKnownMetaDataTags(): Set<string>;
+    private _knownScoreMetaDataTags;
+    get knownScoreMetaDataTags(): Set<string>;
+    private _knownStructuralMetaDataTags;
+    get knownStructuralMetaDataTags(): Set<string>;
+    private _knownBarMetaDataTags;
+    get knownBarMetaDataTags(): Set<string>;
+    private _knownStaffMetaDataTags;
+    get knownStaffMetaDataTags(): Set<string>;
+    private _knownBeatDurationProperties;
+    get knownBeatDurationProperties(): Set<string>;
+    private _knownBeatProperties;
+    get knownBeatProperties(): Set<string>;
+    private _knownNoteProperties;
+    get knownNoteProperties(): Set<string>;
+    applyBeatProperty(importer: IAlphaTexImporter, beat: Beat, p: AlphaTexPropertyNode): ApplyNodeResult;
+    private static _applySustainPedal;
+    private static _applyBrush;
+    applyNoteProperty(importer: IAlphaTexImporter, note: Note, p: AlphaTexPropertyNode): ApplyNodeResult;
+    private static _toFinger;
+    private static _harmonicValue;
+    private _getBendPoints;
+    private static _parseEnumValue;
+    private static readonly _defaultScore;
+    private static readonly _defaultTrack;
+    buildScoreMetaDataNodes(score: Score): AlphaTexMetaDataNode[];
+    private static _buildStyleSheetMetaData;
+    private static _buildScoreInfoMeta;
+    buildSyncPointNodes(score: Score): AlphaTexMetaDataNode[];
+    buildBarMetaDataNodes(staff: Staff, bar: Bar | undefined, voice: number, isMultiVoice: boolean): AlphaTexMetaDataNode[];
+    private static _buildStaffMetaDataNodes;
+    private static _buildChordNode;
+    private static _buildMasterBarMetaDataNodes;
+    private static _buildStructuralMetaDataNodes;
+    private static _buildNewStaffNode;
+    private static _buildNewTrackNode;
+    buildNoteEffects(note: Note): AlphaTexPropertyNode[];
+    buildBeatEffects(beat: Beat): AlphaTexPropertyNode[];
+}

package/dist/types/alphatab/src/importer/alphaTex/AlphaTex1MetaDataReader.d.ts

@@ -0,0 +1,42 @@
+import { type AlphaTexSignatureDefinition } from "./AlphaTex1LanguageDefinitions";
+import { type AlphaTexArgumentList, type AlphaTexMetaDataTagNode, type AlphaTexNumberLiteral, type AlphaTexPropertyNode, type IAlphaTexArgumentValue, type IAlphaTexAstNode } from "./AlphaTexAst";
+import { type AlphaTexParser } from "./AlphaTexParser";
+import type { IAlphaTexMetaDataReader } from "./IAlphaTexMetaDataReader";
+/**
+ * @internal
+ * @record
+ */
+export interface SignatureResolutionInfo {
+    signature: AlphaTexSignatureDefinition;
+    parameterIndex: number;
+    parameterHasValues: boolean;
+    parameterValueMatches: number;
+}
+/**
+ * @internal
+ */
+export declare class AlphaTex1MetaDataReader implements IAlphaTexMetaDataReader {
+    static readonly instance: AlphaTex1MetaDataReader;
+    private static readonly _argumentTypes;
+    readMetaDataArguments(parser: AlphaTexParser, metaData: AlphaTexMetaDataTagNode): AlphaTexArgumentList | undefined;
+    readMetaDataPropertyArguments(parser: AlphaTexParser, metaData: AlphaTexMetaDataTagNode, property: AlphaTexPropertyNode): AlphaTexArgumentList | undefined;
+    readBeatPropertyArguments(parser: AlphaTexParser, property: AlphaTexPropertyNode): AlphaTexArgumentList | undefined;
+    readDurationChangePropertyArguments(parser: AlphaTexParser, property: AlphaTexPropertyNode): AlphaTexArgumentList | undefined;
+    readNotePropertyArguments(parser: AlphaTexParser, property: AlphaTexPropertyNode): AlphaTexArgumentList | undefined;
+    private _readPropertyArguments;
+    private _readArguments;
+    private _validateArguments;
+    private _createArgumentList;
+    private _filterCandidates;
+    static sortCandidates(allCandidates: [number, SignatureResolutionInfo][]): void;
+    private _skipRemainingArguments;
+    private static _hasExactMatch;
+    static filterIncompleteCandidates(candidates: Map<number, SignatureResolutionInfo>): void;
+    static generateSignaturesFromArguments(args: IAlphaTexArgumentValue[] | undefined): string;
+    static generateSignatures(signatures: AlphaTexSignatureDefinition[], ambiguousOverloads?: Set<number>): string;
+    private static _generateSignature;
+    private static _generateSignatureParameter;
+    static filterSignatureCandidates(candidates: Map<number, SignatureResolutionInfo>, value: IAlphaTexAstNode, valueCanBeEndOfList: boolean, trackValue: (value: IAlphaTexAstNode, signature: number) => void, extendToFloat?: (value: AlphaTexNumberLiteral) => void): boolean;
+    private static _checkArgumentMatch;
+    private static _isValueListMatch;
+}