@coderline/alphatab-monaco 1.7.0-alpha.1626

package/dist/types/alphatab/src/model/JsonConverter.d.ts

@@ -0,0 +1,95 @@
+import { type MidiEvent } from "./../midi/MidiEvent";
+import { MidiFile } from "./../midi/MidiFile";
+import { Score } from "./Score";
+import { Settings } from "./../Settings";
+/**
+ * This class can convert a full {@link Score} instance to a simple JavaScript object and back for further
+ * JSON serialization.
+ * @public
+ */
+export declare class JsonConverter {
+    /**
+     * @target web
+     */
+    private static _jsonReplacer;
+    /**
+     * Converts the given score into a JSON encoded string.
+     * @param score The score to serialize.
+     * @returns A JSON encoded string.
+     * @target web
+     */
+    static scoreToJson(score: Score): string;
+    /**
+     * Converts the given JSON string back to a {@link Score} object.
+     * @param json The JSON string
+     * @param settings The settings to use during conversion.
+     * @returns The converted score object.
+     * @target web
+     */
+    static jsonToScore(json: string, settings?: Settings): Score;
+    /**
+     * Converts the score into a JavaScript object without circular dependencies.
+     * @param score The score object to serialize
+     * @returns A serialized score object without ciruclar dependencies that can be used for further serializations.
+     */
+    static scoreToJsObject(score: Score): unknown;
+    /**
+     * Converts the given JavaScript object into a score object.
+     * @param jsObject The javascript object created via {@link Score}
+     * @param settings The settings to use during conversion.
+     * @returns The converted score object.
+     */
+    static jsObjectToScore(jsObject: unknown, settings?: Settings): Score;
+    /**
+     * Converts the given settings into a JSON encoded string.
+     * @param settings The settings to serialize.
+     * @returns A JSON encoded string.
+     * @target web
+     */
+    static settingsToJson(settings: Settings): string;
+    /**
+     * Converts the given JSON string back to a {@link Score} object.
+     * @param json The JSON string
+     * @returns The converted settings object.
+     * @target web
+     */
+    static jsonToSettings(json: string): Settings;
+    /**
+     * Converts the settings object into a JavaScript object for transmission between components or saving purposes.
+     * @param settings The settings object to serialize
+     * @returns A serialized settings object without ciruclar dependencies that can be used for further serializations.
+     */
+    static settingsToJsObject(settings: Settings): Map<string, unknown> | null;
+    /**
+     * Converts the given JavaScript object into a settings object.
+     * @param jsObject The javascript object created via {@link Settings}
+     * @returns The converted Settings object.
+     */
+    static jsObjectToSettings(jsObject: unknown): Settings;
+    /**
+     * Converts the given JavaScript object into a MidiFile object.
+     * @param jsObject The javascript object to deserialize.
+     * @returns The converted MidiFile.
+     */
+    static jsObjectToMidiFile(jsObject: unknown): MidiFile;
+    private static _jsObjectToMidiTrack;
+    /**
+     * Converts the given JavaScript object into a MidiEvent object.
+     * @param jsObject The javascript object to deserialize.
+     * @returns The converted MidiEvent.
+     */
+    static jsObjectToMidiEvent(midiEvent: unknown): MidiEvent;
+    /**
+     * Converts the given MidiFile object into a serialized JavaScript object.
+     * @param midi The midi file to convert.
+     * @returns A serialized MidiFile object without ciruclar dependencies that can be used for further serializations.
+     */
+    static midiFileToJsObject(midi: MidiFile): Map<string, unknown>;
+    private static _midiTrackToJsObject;
+    /**
+     * Converts the given MidiEvent object into a serialized JavaScript object.
+     * @param midi The midi file to convert.
+     * @returns A serialized MidiEvent object without ciruclar dependencies that can be used for further serializations.
+     */
+    static midiEventToJsObject(midiEvent: MidiEvent): Map<string, unknown>;
+}

package/dist/types/alphatab/src/model/KeySignature.d.ts

@@ -0,0 +1,66 @@
+/**
+ * This public enumeration lists all available key signatures
+ * @public
+ */
+export declare enum KeySignature {
+    /**
+     * Cb (7 flats)
+     */
+    Cb = -7,
+    /**
+     * Gb (6 flats)
+     */
+    Gb = -6,
+    /**
+     * Db (5 flats)
+     */
+    Db = -5,
+    /**
+     * Ab (4 flats)
+     */
+    Ab = -4,
+    /**
+     * Eb (3 flats)
+     */
+    Eb = -3,
+    /**
+     * Bb (2 flats)
+     */
+    Bb = -2,
+    /**
+     * F (1 flat)
+     */
+    F = -1,
+    /**
+     * C (no signs)
+     */
+    C = 0,
+    /**
+     * G (1 sharp)
+     */
+    G = 1,
+    /**
+     * D (2 sharp)
+     */
+    D = 2,
+    /**
+     * A (3 sharp)
+     */
+    A = 3,
+    /**
+     * E (4 sharp)
+     */
+    E = 4,
+    /**
+     * B (5 sharp)
+     */
+    B = 5,
+    /**
+     * F# (6 sharp)
+     */
+    FSharp = 6,
+    /**
+     * C# (7 sharp)
+     */
+    CSharp = 7
+}

package/dist/types/alphatab/src/model/KeySignatureType.d.ts

@@ -0,0 +1,14 @@
+/**
+ * This public enumeration lists all available types of KeySignatures
+ * @public
+ */
+export declare enum KeySignatureType {
+    /**
+     * Major
+     */
+    Major = 0,
+    /**
+     * Minor
+     */
+    Minor = 1
+}

package/dist/types/alphatab/src/model/Lyrics.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Represents the lyrics of a song.
+ * @public
+ */
+export declare class Lyrics {
+    private static readonly _charCodeLF;
+    private static readonly _charCodeTab;
+    private static readonly _charCodeCR;
+    private static readonly _charCodeSpace;
+    private static readonly _charCodeBrackedClose;
+    private static readonly _charCodeBrackedOpen;
+    private static readonly _charCodeDash;
+    /**
+     * Gets or sets he start bar on which the lyrics should begin.
+     */
+    startBar: number;
+    /**
+     * Gets or sets the raw lyrics text in Guitar Pro format.
+     * (spaces split word syllables, plus merge syllables, [..] are comments)
+     */
+    text: string;
+    /**
+     * Gets or sets the prepared chunks of the lyrics to apply to beats.
+     */
+    chunks: string[];
+    finish(skipEmptyEntries?: boolean): void;
+    private _parse;
+    private _addChunk;
+    private _prepareChunk;
+}

package/dist/types/alphatab/src/model/MasterBar.d.ts

@@ -0,0 +1,182 @@
+import type { Automation } from "./Automation";
+import type { Beat } from "./Beat";
+import type { Fermata } from "./Fermata";
+import type { KeySignature } from "./KeySignature";
+import type { KeySignatureType } from "./KeySignatureType";
+import type { RepeatGroup } from "./RepeatGroup";
+import type { Score } from "./Score";
+import type { Section } from "./Section";
+import { TripletFeel } from "./TripletFeel";
+import type { Direction } from "./Direction";
+/**
+ * The MasterBar stores information about a bar which affects
+ * all tracks.
+ * @json
+ * @json_strict
+ * @public
+ */
+export declare class MasterBar {
+    static readonly MaxAlternateEndings: number;
+    /**
+     * Gets or sets the bitflag for the alternate endings. Each bit defines for which repeat counts
+     * the bar is played.
+     */
+    alternateEndings: number;
+    /**
+     * Gets or sets the next masterbar in the song.
+     * @json_ignore
+     */
+    nextMasterBar: MasterBar | null;
+    /**
+     * Gets or sets the next masterbar in the song.
+     * @json_ignore
+     */
+    previousMasterBar: MasterBar | null;
+    /**
+     * Gets the zero based index of the masterbar.
+     * @json_ignore
+     */
+    index: number;
+    /**
+     * Whether the masterbar is has any changes applied to it (e.g. tempo changes, time signature changes etc)
+     * The first bar is always considered changed due to initial setup of values. It does not consider
+     * elements like whether the tempo really changes to the previous bar.
+     */
+    get hasChanges(): boolean;
+    /**
+     * The key signature used on all bars.
+     * @deprecated Use key signatures on bar level
+     */
+    get keySignature(): KeySignature;
+    /**
+     * The key signature used on all bars.
+     * @deprecated Use key signatures on bar level
+     */
+    set keySignature(value: KeySignature);
+    /**
+     * The type of key signature (major/minor)
+     * @deprecated Use key signatures on bar level
+     */
+    get keySignatureType(): KeySignatureType;
+    /**
+     * The type of key signature (major/minor)
+     * @deprecated Use key signatures on bar level
+     */
+    set keySignatureType(value: KeySignatureType);
+    /**
+     * Gets or sets whether a double bar is shown for this masterbar.
+     * @deprecated Use {@link Bar.barLineLeft} and {@link Bar.barLineRight}
+     */
+    isDoubleBar: boolean;
+    /**
+     * Gets or sets whether a repeat section starts on this masterbar.
+     */
+    isRepeatStart: boolean;
+    get isRepeatEnd(): boolean;
+    /**
+     * Gets or sets the number of repeats for the current repeat section.
+     */
+    repeatCount: number;
+    /**
+     * Gets or sets the repeat group this bar belongs to.
+     * @json_ignore
+     */
+    repeatGroup: RepeatGroup;
+    /**
+     * Gets or sets the time signature numerator.
+     */
+    timeSignatureNumerator: number;
+    /**
+     * Gets or sets the time signature denominiator.
+     */
+    timeSignatureDenominator: number;
+    /**
+     * Gets or sets whether this is bar has a common time signature.
+     */
+    timeSignatureCommon: boolean;
+    /**
+     * Gets or sets whether the bar indicates a free time playing.
+     */
+    isFreeTime: boolean;
+    /**
+     * Gets or sets the triplet feel that is valid for this bar.
+     */
+    tripletFeel: TripletFeel;
+    /**
+     * Gets or sets the new section information for this bar.
+     */
+    section: Section | null;
+    get isSectionStart(): boolean;
+    /**
+     * Gets or sets the first tempo automation for this bar.
+     * @deprecated Use {@link tempoAutomations}.
+     */
+    get tempoAutomation(): Automation | null;
+    /**
+     * Gets or sets all tempo automation for this bar.
+     */
+    tempoAutomations: Automation[];
+    /**
+     * The sync points for this master bar to synchronize the alphaTab time axis with the
+     * external backing track audio.
+     * @json_add addSyncPoint
+     */
+    syncPoints: Automation[] | undefined;
+    /**
+     * Gets or sets the reference to the score this song belongs to.
+     * @json_ignore
+     */
+    score: Score;
+    /**
+     * Gets or sets the fermatas for this bar. The key is the offset of the fermata in midi ticks.
+     * @json_add addFermata
+     */
+    fermata: Map<number, Fermata> | null;
+    /**
+     * The timeline position of the voice within the whole score. (unit: midi ticks)
+     */
+    start: number;
+    /**
+     * Gets or sets a value indicating whether the master bar is an anacrusis (aka. pickup bar)
+     */
+    isAnacrusis: boolean;
+    /**
+     * Gets a percentual scale for the size of the bars when displayed in a multi-track layout.
+     */
+    displayScale: number;
+    /**
+     * An absolute width of the bar to use when displaying in a multi-track layout.
+     */
+    displayWidth: number;
+    /**
+     * The directions applied to this masterbar.
+     * @json_add addDirection
+     */
+    directions: Set<Direction> | null;
+    /**
+     * Calculates the time spent in this bar. (unit: midi ticks)
+     */
+    calculateDuration(respectAnacrusis?: boolean): number;
+    /**
+     * Adds a fermata to the masterbar.
+     * @param offset The offset of the fermata within the bar in midi ticks.
+     * @param fermata The fermata.
+     */
+    addFermata(offset: number, fermata: Fermata): void;
+    /**
+     * Adds a direction to the masterbar.
+     * @param direction The direction to add.
+     */
+    addDirection(direction: Direction): void;
+    /**
+     * Gets the fermata for a given beat.
+     * @param beat The beat to get the fermata for.
+     * @returns
+     */
+    getFermata(beat: Beat): Fermata | null;
+    /**
+     * Adds the given sync point to the list of sync points for this bar.
+     * @param syncPoint  The sync point to add.
+     */
+    addSyncPoint(syncPoint: Automation): void;
+}

package/dist/types/alphatab/src/model/ModelUtils.d.ts

@@ -0,0 +1,134 @@
+import type { Duration } from "./Duration";
+import { HeaderFooterStyle, type Score, type ScoreSubElement } from "./Score";
+import type { Settings } from "./../Settings";
+import { NoteAccidentalMode } from "./NoteAccidentalMode";
+import type { Track } from "./Track";
+import { MusicFontSymbol } from "./MusicFontSymbol";
+import type { KeySignature } from "./KeySignature";
+import { AccidentalType } from "./AccidentalType";
+/**
+ * @internal
+ */
+export declare class TuningParseResult {
+    note: string | null;
+    tone: TuningParseResultTone;
+    octave: number;
+    get realValue(): number;
+}
+/**
+ * @internal
+ */
+export declare class TuningParseResultTone {
+    noteValue: number;
+    accidentalMode: NoteAccidentalMode;
+    constructor(noteValue?: number, accidentalMode?: NoteAccidentalMode);
+}
+/**
+ * This public class contains some utilities for working with model public classes
+ * @partial
+ * @internal
+ */
+export declare class ModelUtils {
+    static getIndex(duration: Duration): number;
+    static keySignatureIsFlat(ks: number): boolean;
+    static keySignatureIsNatural(ks: number): boolean;
+    static keySignatureIsSharp(ks: number): boolean;
+    static applyPitchOffsets(settings: Settings, score: Score): void;
+    /**
+     * Checks if the given string is a tuning inticator.
+     * @param name
+     */
+    static isTuning(name: string): boolean;
+    /**
+     * @internal
+     */
+    static readonly tuningLetters: Set<number>;
+    static parseTuning(name: string): TuningParseResult | null;
+    static getTuningForText(str: string): number;
+    static getToneForText(note: string): TuningParseResultTone | null;
+    /**
+     * @internal
+     */
+    static readonly reverseAccidentalModeMapping: Map<NoteAccidentalMode, string>;
+    /**
+     * @internal
+     */
+    static readonly accidentalModeMapping: Map<string, NoteAccidentalMode>;
+    static parseAccidentalMode(data: string): NoteAccidentalMode;
+    static newGuid(): string;
+    static isAlmostEqualTo(a: number, b: number): boolean;
+    static toHexString(n: number, digits?: number): string;
+    /**
+     * Gets the list of alternate endings on which the master bar is played.
+     * @param bitflag The alternate endings bitflag.
+     */
+    static getAlternateEndingsList(bitflag: number): number[];
+    static deltaFretToHarmonicValue(deltaFret: number): number;
+    static clamp(value: number, min: number, max: number): number;
+    static buildMultiBarRestInfo(tracks: Track[] | null, startIndex: number, endIndexInclusive: number): Map<number, number[]> | null;
+    static computeFirstDisplayedBarIndex(score: Score, settings: Settings): number;
+    static computeLastDisplayedBarIndex(score: Score, settings: Settings, startIndex: number): number;
+    static getOrCreateHeaderFooterStyle(score: Score, element: ScoreSubElement): HeaderFooterStyle;
+    /**
+     * Performs some general consolidations of inconsistencies on the given score like
+     * missing bars, beats, duplicated midi channels etc
+     */
+    static consolidate(score: Score): void;
+    /**
+     * Trims any empty bars at the end of the song.
+     * @param score
+     */
+    static trimEmptyBarsAtEnd(score: Score): void;
+    private static _allMusicFontSymbols;
+    /**
+     * Gets a list of all music font symbols used in alphaTab.
+     */
+    static getAllMusicFontSymbols(): MusicFontSymbol[];
+    /**
+     * Lists the display transpositions for some known midi instruments.
+     * It is a common practice to transpose the standard notation for instruments like guitars.
+     */
+    static readonly displayTranspositionPitches: Map<number, number>;
+    /**
+     * @internal
+     */
+    static flooredDivision(a: number, b: number): number;
+    /**
+     * Converts the key transpose table to actual key signatures.
+     * @param texts An array where every item indicates the number of accidentals and which accidental
+     * placed for the key signature.
+     *
+     * e.g. 3# is 3-sharps -> KeySignature.A
+     */
+    private static _translateKeyTransposeTable;
+    /**
+     * @internal
+     */
+    private static readonly _keyTransposeTable;
+    /**
+     * Transposes the given key signature.
+     * @internal
+     * @param keySignature The key signature to transpose
+     * @param transpose The number of semitones to transpose (+/- 0-11)
+     * @returns
+     */
+    static transposeKey(keySignature: KeySignature, transpose: number): KeySignature;
+    /**
+     * a lookup list containing an info whether the notes within an octave
+     * need an accidental rendered. the accidental symbol is determined based on the type of key signature.
+     */
+    private static _keySignatureLookup;
+    /**
+     * Contains the list of notes within an octave have accidentals set.
+     * @internal
+     */
+    static accidentalNotes: boolean[];
+    /**
+     * @internal
+     */
+    static computeAccidental(keySignature: KeySignature, accidentalMode: NoteAccidentalMode, noteValue: number, quarterBend: boolean, currentAccidental?: AccidentalType | null): AccidentalType;
+    /**
+     * @internal
+     */
+    static toArticulationId(plain: string): string;
+}