@coderline/alphatab 1.6.0-alpha.1430 → 1.6.0-alpha.1432

package/dist/alphaTab.core.mjs

@@ -1,5 +1,5 @@
 /*!
- * alphaTab v1.6.0-alpha.1430 (develop, build 1430)
+ * alphaTab v1.6.0-alpha.1432 (develop, build 1432)
  *
  * Copyright © 2025, Daniel Kuschny and Contributors, All rights reserved.
  *
@@ -1006,6 +1006,26 @@ class Bar {
     get isEmpty() {
         return this._isEmpty;
     }
+    /**
+     * Whether this bar has any changes applied which are not related to the voices in it.
+     * (e.g. new key signatures)
+     */
+    get hasChanges() {
+        if (this.index === 0) {
+            return true;
+        }
+        const hasChangesToPrevious = this.keySignature !== this.previousBar.keySignature ||
+            this.keySignatureType !== this.previousBar.keySignatureType ||
+            this.clef !== this.previousBar.clef ||
+            this.clefOttava !== this.previousBar.clefOttava;
+        if (hasChangesToPrevious) {
+            return true;
+        }
+        return (this.simileMark !== SimileMark.None ||
+            this.sustainPedals.length > 0 ||
+            this.barLineLeft !== BarLineStyle.Automatic ||
+            this.barLineRight !== BarLineStyle.Automatic);
+    }
     /**
      * Whether this bar is empty or has only rests.
      */
@@ -2619,6 +2639,33 @@ class MasterBar {
          */
         this.directions = null;
     }
+    /**
+     * 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() {
+        if (this.index === 0) {
+            return false;
+        }
+        const hasChangesToPrevious = this.timeSignatureCommon !== this.previousMasterBar.timeSignatureCommon ||
+            this.timeSignatureNumerator !== this.previousMasterBar.timeSignatureNumerator ||
+            this.timeSignatureDenominator !== this.previousMasterBar.timeSignatureDenominator ||
+            this.tripletFeel !== this.previousMasterBar.tripletFeel;
+        if (hasChangesToPrevious) {
+            return true;
+        }
+        return (this.alternateEndings !== 0 ||
+            this.isRepeatStart ||
+            this.isRepeatEnd ||
+            this.isFreeTime ||
+            this.isSectionStart ||
+            this.tempoAutomations.length > 0 ||
+            this.syncPoints && this.syncPoints.length > 0 ||
+            (this.fermata !== null && this.fermata.size > 0) ||
+            (this.directions !== null && this.directions.size > 0) ||
+            this.isAnacrusis);
+    }
     /**
      * The key signature used on all bars.
      * @deprecated Use key signatures on bar level
@@ -3560,6 +3607,43 @@ class ModelUtils {
             }
         }
     }
+    /**
+     * Trims any empty bars at the end of the song.
+     * @param score
+     */
+    static trimEmptyBarsAtEnd(score) {
+        while (score.masterBars.length > 1) {
+            const barIndex = score.masterBars.length - 1;
+            const masterBar = score.masterBars[barIndex];
+            if (masterBar.hasChanges) {
+                return;
+            }
+            for (const track of score.tracks) {
+                for (const staff of track.staves) {
+                    if (barIndex < staff.bars.length) {
+                        const bar = staff.bars[barIndex];
+                        if (!bar.isEmpty || bar.hasChanges) {
+                            // found a non-empty bar, stop whole cleanup
+                            return;
+                        }
+                    }
+                }
+            }
+            // if we reach here, all found bars are empty, remove the bar
+            for (const track of score.tracks) {
+                for (const staff of track.staves) {
+                    if (barIndex < staff.bars.length) {
+                        const bar = staff.bars[barIndex];
+                        staff.bars.pop();
+                        // unlink
+                        bar.previousBar.nextBar = null;
+                    }
+                }
+            }
+            score.masterBars.pop();
+            masterBar.previousMasterBar.nextMasterBar = null;
+        }
+    }
 }
 ModelUtils.TuningLetters = new Set([
     0x43 /* C */, 0x44 /* D */, 0x45 /* E */, 0x46 /* F */, 0x47 /* G */, 0x41 /* A */, 0x42 /* B */, 0x63 /* c */,
@@ -8677,6 +8761,7 @@ class AlphaTexImporter extends ScoreImporter {
         this._slurs = new Map();
         this._articulationValueToIndex = new Map();
         this._accidentalMode = AlphaTexAccidentalMode.Explicit;
+        this._syncPoints = [];
         this.logErrors = false;
     }
     get name() {
@@ -8717,10 +8802,16 @@ class AlphaTexImporter extends ScoreImporter {
                 if (!anyMetaRead && !anyBarsRead) {
                     throw new UnsupportedFormatError('No alphaTex data found');
                 }
+                if (this._sy === AlphaTexSymbols.Dot) {
+                    this._sy = this.newSy();
+                    this.syncPoints();
+                }
             }
             ModelUtils.consolidate(this._score);
             this._score.finish(this.settings);
+            ModelUtils.trimEmptyBarsAtEnd(this._score);
             this._score.rebuildRepeatGroups();
+            this._score.applyFlatSyncPoints(this._syncPoints);
             for (const [track, lyrics] of this._lyrics) {
                 this._score.tracks[track].applyLyrics(lyrics);
             }
@@ -8737,6 +8828,47 @@ class AlphaTexImporter extends ScoreImporter {
             throw e;
         }
     }
+    syncPoints() {
+        while (this._sy !== AlphaTexSymbols.Eof) {
+            this.syncPoint();
+        }
+    }
+    syncPoint() {
+        // \sync BarIndex Occurence MillisecondOffset
+        // \sync BarIndex Occurence MillisecondOffset RatioPosition
+        if (this._sy !== AlphaTexSymbols.MetaCommand || this._syData !== 'sync') {
+            this.error('syncPoint', AlphaTexSymbols.MetaCommand, true);
+        }
+        this._sy = this.newSy();
+        if (this._sy !== AlphaTexSymbols.Number) {
+            this.error('syncPointBarIndex', AlphaTexSymbols.Number, true);
+        }
+        const barIndex = this._syData;
+        this._sy = this.newSy();
+        if (this._sy !== AlphaTexSymbols.Number) {
+            this.error('syncPointBarOccurence', AlphaTexSymbols.Number, true);
+        }
+        const barOccurence = this._syData;
+        this._sy = this.newSy();
+        if (this._sy !== AlphaTexSymbols.Number) {
+            this.error('syncPointBarMillis', AlphaTexSymbols.Number, true);
+        }
+        const millisecondOffset = this._syData;
+        this._allowFloat = true;
+        this._sy = this.newSy();
+        this._allowFloat = false;
+        let barPosition = 0;
+        if (this._sy === AlphaTexSymbols.Number) {
+            barPosition = this._syData;
+            this._sy = this.newSy();
+        }
+        this._syncPoints.push({
+            barIndex,
+            barOccurence,
+            barPosition,
+            millisecondOffset
+        });
+    }
     error(nonterm, expected, wrongSymbol = true) {
         let receivedSymbol;
         let showSyData = false;
@@ -33102,7 +33234,7 @@ class AlphaSynthWorkerSynthOutput {
     addSamples(samples) {
         this._worker.postMessage({
             cmd: 'alphaSynth.output.addSamples',
-            samples: samples
+            samples: Environment.prepareForPostMessage(samples)
         });
     }
     play() {
@@ -33298,7 +33430,7 @@ class AlphaSynthWebWorker {
     onSoundFontLoadFailed(e) {
         this._main.postMessage({
             cmd: 'alphaSynth.soundFontLoadFailed',
-            error: this.serializeException(e)
+            error: this.serializeException(Environment.prepareForPostMessage(e))
         });
     }
     serializeException(e) {
@@ -33329,7 +33461,7 @@ class AlphaSynthWebWorker {
     onMidiLoadFailed(e) {
         this._main.postMessage({
             cmd: 'alphaSynth.midiLoaded',
-            error: this.serializeException(e)
+            error: this.serializeException(Environment.prepareForPostMessage(e))
         });
     }
     onReadyForPlayback() {
@@ -42454,6 +42586,18 @@ class FileLoadError extends AlphaTabError {
  * available importers
  */
 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, settings) {
+        const parser = new AlphaTexImporter();
+        parser.logErrors = true;
+        parser.initFromString(tex, settings ?? new Settings());
+        return parser.readScore();
+    }
     /**
      * Loads a score asynchronously from the given datasource
      * @param path the source path to load the binary file from
@@ -43304,7 +43448,7 @@ class AlphaSynthWebWorkerApi {
         this._midiEventsPlayedFilter = value;
         this._synth.postMessage({
             cmd: 'alphaSynth.setMidiEventsPlayedFilter',
-            value: value
+            value: Environment.prepareForPostMessage(value)
         });
     }
     get playbackSpeed() {
@@ -43369,7 +43513,7 @@ class AlphaSynthWebWorkerApi {
         this._playbackRange = value;
         this._synth.postMessage({
             cmd: 'alphaSynth.setPlaybackRange',
-            value: value
+            value: Environment.prepareForPostMessage(value)
         });
     }
     constructor(player, settings) {
@@ -43463,13 +43607,13 @@ class AlphaSynthWebWorkerApi {
     playOneTimeMidiFile(midi) {
         this._synth.postMessage({
             cmd: 'alphaSynth.playOneTimeMidiFile',
-            midi: JsonConverter.midiFileToJsObject(midi)
+            midi: JsonConverter.midiFileToJsObject(Environment.prepareForPostMessage(midi))
         });
     }
     loadSoundFont(data, append) {
         this._synth.postMessage({
             cmd: 'alphaSynth.loadSoundFontBytes',
-            data: data,
+            data: Environment.prepareForPostMessage(data),
             append: append
         });
     }
@@ -43481,13 +43625,13 @@ class AlphaSynthWebWorkerApi {
     loadMidiFile(midi) {
         this._synth.postMessage({
             cmd: 'alphaSynth.loadMidi',
-            midi: JsonConverter.midiFileToJsObject(midi)
+            midi: JsonConverter.midiFileToJsObject(Environment.prepareForPostMessage(midi))
         });
     }
     applyTranspositionPitches(transpositionPitches) {
         this._synth.postMessage({
             cmd: 'alphaSynth.applyTranspositionPitches',
-            transpositionPitches: JSON.stringify(Array.from(transpositionPitches.entries()))
+            transpositionPitches: JSON.stringify(Array.from(Environment.prepareForPostMessage(transpositionPitches).entries()))
         });
     }
     setChannelTranspositionPitch(channel, semitones) {
@@ -43659,7 +43803,7 @@ class AlphaTabWorkerScoreRenderer {
         });
     }
     serializeSettingsForWorker(settings) {
-        const jsObject = JsonConverter.settingsToJsObject(settings);
+        const jsObject = JsonConverter.settingsToJsObject(Environment.prepareForPostMessage(settings));
         // cut out player settings, they are only needed on UI thread side
         jsObject.delete('player');
         return jsObject;
@@ -43717,11 +43861,11 @@ class AlphaTabWorkerScoreRenderer {
         }
     }
     renderScore(score, trackIndexes) {
-        const jsObject = score == null ? null : JsonConverter.scoreToJsObject(score);
+        const jsObject = score == null ? null : JsonConverter.scoreToJsObject(Environment.prepareForPostMessage(score));
         this._worker.postMessage({
             cmd: 'alphaTab.renderScore',
             score: jsObject,
-            trackIndexes: trackIndexes,
+            trackIndexes: Environment.prepareForPostMessage(trackIndexes),
             fontSizes: FontSizes.FontSizeLookupTables
         });
     }
@@ -43912,7 +44056,7 @@ class AlphaSynthAudioWorkletOutput extends AlphaSynthWebAudioOutputBase {
     addSamples(f) {
         this._worklet?.port.postMessage({
             cmd: AlphaSynthWorkerSynthOutput.CmdOutputAddSamples,
-            samples: f
+            samples: Environment.prepareForPostMessage(f)
         });
     }
     resetSamples() {
@@ -61132,9 +61276,9 @@ class VersionInfo {
         print(`build date: ${VersionInfo.date}`);
     }
 }
-VersionInfo.version = '1.6.0-alpha.1430';
-VersionInfo.date = '2025-05-29T22:21:21.689Z';
-VersionInfo.commit = '98a4c2bec8d71f2645008118d3b77fb40973e7fe';
+VersionInfo.version = '1.6.0-alpha.1432';
+VersionInfo.date = '2025-05-31T02:06:00.256Z';
+VersionInfo.commit = '91e41f1b2cf0b786a1ca2053f51cf3f370da4bc6';
 
 /**
  * A factory for custom layout engines.
@@ -61679,6 +61823,29 @@ class Environment {
             print(`Screen Size: ${window.screen.width}x${window.screen.height}`);
         }
     }
+    /**
+     * Prepares the given object to be sent to workers. Web Frameworks like Vue might
+     * create proxy objects for all objects used. This code handles the necessary unwrapping.
+     * @internal
+     * @target web
+     */
+    static prepareForPostMessage(object) {
+        if (!object) {
+            return object;
+        }
+        // Vue toRaw:
+        // https://github.com/vuejs/core/blob/e7381761cc7971c0d40ae0a0a72687a500fd8db3/packages/reactivity/src/reactive.ts#L378-L381
+        if (typeof object === 'object') {
+            const unwrapped = object.__v_raw;
+            if (unwrapped) {
+                return Environment.prepareForPostMessage(unwrapped);
+            }
+        }
+        // Solidjs unwrap: the symbol required to access the raw object is unfortunately hidden and we cannot unwrap it without importing
+        // import { unwrap } from "solid-js/store"
+        // alternative for users is to replace this method during runtime. 
+        return object;
+    }
 }
 Environment.StaffIdBeforeSlashAlways = 'before-slash-always';
 Environment.StaffIdBeforeScoreAlways = 'before-score-always';
@@ -61950,6 +62117,7 @@ class CoreSettings {
 
 const _barrel$7 = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
     __proto__: null,
+    AlphaTexImporter,
     ScoreImporter,
     ScoreLoader,
     UnsupportedFormatError

package/dist/alphaTab.d.ts

@@ -3014,6 +3014,155 @@ declare enum AlphaTabSystemExclusiveEvents {
     Rest = 1
 }
 
+/**
+ * This importer can parse alphaTex markup into a score structure.
+ */
+declare class AlphaTexImporter extends ScoreImporter {
+    private static readonly Eof;
+    private _trackChannel;
+    private _score;
+    private _currentTrack;
+    private _currentStaff;
+    private _barIndex;
+    private _voiceIndex;
+    private _input;
+    private _ch;
+    private _curChPos;
+    private _line;
+    private _col;
+    private _lastValidSpot;
+    private _sy;
+    private _syData;
+    private _allowNegatives;
+    private _allowFloat;
+    private _allowTuning;
+    private _currentDuration;
+    private _currentDynamics;
+    private _currentTuplet;
+    private _lyrics;
+    private _staffHasExplicitDisplayTransposition;
+    private _staffHasExplicitTuning;
+    private _staffTuningApplied;
+    private _percussionArticulationNames;
+    private _sustainPedalToBeat;
+    private _slurs;
+    private _articulationValueToIndex;
+    private _accidentalMode;
+    private _syncPoints;
+    logErrors: boolean;
+    get name(): string;
+    initFromString(tex: string, settings: Settings): void;
+    readScore(): Score;
+    private syncPoints;
+    private syncPoint;
+    private error;
+    private errorMessage;
+    /**
+     * Initializes the song with some required default values.
+     * @returns
+     */
+    private createDefaultScore;
+    private newTrack;
+    /**
+     * Converts a clef string into the clef value.
+     * @param str the string to convert
+     * @returns the clef value
+     */
+    private parseClefFromString;
+    /**
+     * Converts a clef tuning into the clef value.
+     * @param i the tuning value to convert
+     * @returns the clef value
+     */
+    private parseClefFromInt;
+    private parseTripletFeelFromString;
+    private parseTripletFeelFromInt;
+    /**
+     * Converts a keysignature string into the assocciated value.
+     * @param str the string to convert
+     * @returns the assocciated keysignature value
+     */
+    private parseKeySignature;
+    private parseKeySignatureType;
+    /**
+     * Reads, saves, and returns the next character of the source stream.
+     */
+    private nextChar;
+    /**
+     * Saves the current position, line, and column.
+     * All parsed data until this point is assumed to be valid.
+     */
+    private saveValidSpot;
+    /**
+     * Reads, saves, and returns the next terminal symbol.
+     */
+    private newSy;
+    private readNumberOrName;
+    /**
+     * Checks if the given character is a valid letter for a name.
+     * (no control characters, whitespaces, numbers or dots)
+     */
+    private static isNameLetter;
+    private static isTerminal;
+    private static isWhiteSpace;
+    private isDigit;
+    /**
+     * Reads a string from the stream.
+     * @returns the read string.
+     */
+    private readName;
+    private metaData;
+    headerFooterStyle(element: ScoreSubElement): void;
+    private parseTrackNamePolicy;
+    private parseTrackNameMode;
+    private parseTrackNameOrientation;
+    private handleStaffMeta;
+    private handleAccidentalMode;
+    private makeCurrentStaffPitched;
+    /**
+     * Encodes a given string to a shorthand text form without spaces or special characters
+     */
+    private static toArticulationId;
+    private applyPercussionStaff;
+    private chordProperties;
+    private bars;
+    private trackStaffMeta;
+    private handleNewVoice;
+    private beginStaff;
+    private trackProperties;
+    private staffProperties;
+    private bar;
+    private newBar;
+    private beat;
+    private beatDuration;
+    private beatEffects;
+    /**
+     * Tries to apply a beat effect to the given beat.
+     * @returns true if a effect could be applied, otherwise false
+     */
+    private applyBeatEffect;
+    private parseBracketExtendMode;
+    private parseFermataFromString;
+    private parseClefOttavaFromString;
+    private getChordId;
+    private static applyTuplet;
+    private isNoteText;
+    private note;
+    private noteEffects;
+    private harmonicValue;
+    private toFinger;
+    private parseDuration;
+    private parseBendStyle;
+    private parseBendType;
+    private barMeta;
+    private parseBarLineStyle;
+    private parseSimileMarkFromString;
+    private handleDirections;
+    private readTempoAutomation;
+    private applyAlternateEnding;
+    private parseWhammyType;
+}
+
 /**
  * Automations are used to change the behaviour of a song.
  * @cloneable
@@ -3211,6 +3360,11 @@ declare class Bar {
      * Whether this bar is fully empty (not even having rests).
      */
     get isEmpty(): boolean;
+    /**
+     * Whether this bar has any changes applied which are not related to the voices in it.
+     * (e.g. new key signatures)
+     */
+    get hasChanges(): boolean;
     /**
      * Whether this bar is empty or has only rests.
      */
@@ -6372,6 +6526,7 @@ export declare class Environment {
      * @partial
      */
     private static printPlatformInfo;
+    /* Excluded from this release type: prepareForPostMessage */
 }
 
 export declare namespace exporter {
@@ -7669,7 +7824,8 @@ export declare namespace importer {
     export {
         ScoreImporter,
         ScoreLoader,
-        UnsupportedFormatError
+        UnsupportedFormatError,
+        AlphaTexImporter
     }
 }
 
@@ -8683,6 +8839,12 @@ declare class 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
@@ -12952,6 +13114,13 @@ declare abstract class ScoreLayout {
  * available importers
  */
 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