@coderline/alphatab 1.3.0-alpha.418 → 1.3.0-alpha.424

package/dist/alphaTab.d.ts

@@ -5517,6 +5517,7 @@ declare class MidiFileGenerator {
     private static getDynamicValue;
     private generateFadeIn;
     private generateVibrato;
+    vibratoResolution: number;
     private generateVibratorWithParams;
     /**
      * Maximum semitones that are supported in bends in one direction (up or down)

package/dist/alphaTab.js

@@ -1,5 +1,5 @@
 /**
- * alphaTab v1.3.0-alpha.418 (develop, build 418)
+ * alphaTab v1.3.0-alpha.424 (develop, build 424)
  * 
  * Copyright © 2022, Daniel Kuschny and Contributors, All rights reserved.
  * 
@@ -23004,6 +23004,7 @@
              */
             this.tickLookup = new MidiTickLookup();
             this._currentTripletFeel = null;
+            this.vibratoResolution = 16;
             this._score = score;
             this._settings = !settings ? new Settings() : settings;
             this._currentTempo = this._score.tempo;
@@ -23342,7 +23343,7 @@
             else if (note.slideInType !== SlideInType.None || note.slideOutType !== SlideOutType.None) {
                 this.generateSlide(note, noteStart, noteDuration, noteKey, dynamicValue, channel);
             }
-            else if (note.vibrato !== VibratoType.None) {
+            else if (note.vibrato !== VibratoType.None || (note.isTieDestination && note.tieOrigin.vibrato !== VibratoType.None)) {
                 this.generateVibrato(note, noteStart, noteDuration, noteKey, channel);
             }
             // for tied notes, and target notes of legato slides we do not pick the note
@@ -23488,7 +23489,9 @@
         generateVibrato(note, noteStart, noteDuration, noteKey, channel) {
             let phaseLength = 0;
             let bendAmplitude = 0;
-            switch (note.vibrato) {
+            const vibratoType = note.vibrato !== VibratoType.None ? note.vibrato : (note.isTieDestination ? note.tieOrigin.vibrato :
+                VibratoType.Slight /* should never happen unless called wrongly */);
+            switch (vibratoType) {
                 case VibratoType.Slight:
                     phaseLength = this._settings.player.vibrato.noteSlightLength;
                     bendAmplitude = this._settings.player.vibrato.noteSlightAmplitude;
@@ -23506,7 +23509,7 @@
             });
         }
         generateVibratorWithParams(noteStart, noteDuration, phaseLength, bendAmplitude, addBend) {
-            const resolution = 16;
+            const resolution = this.vibratoResolution;
             const phaseHalf = (phaseLength / 2) | 0;
             // 1st Phase stays at bend 0,
             // then we have a sine wave with the given amplitude and phase length
@@ -25919,52 +25922,89 @@
                 }
             }, 5000);
             Logger.debug('Font', `Start checking for font availablility: ${this._families.join(', ')}`);
-            let errorHandler = () => {
+            let errorHandler = (e) => {
                 if (this._families.length > 1) {
-                    Logger.debug('Font', `[${this._families[0]}] Loading Failed, switching to ${this._families[1]}`);
+                    Logger.debug('Font', `[${this._families[0]}] Loading Failed, switching to ${this._families[1]}`, e);
                     this._families.shift();
                     window.setTimeout(() => {
+                        // tslint:disable-next-line: no-floating-promises
                         checkFont();
                     }, 0);
                 }
                 else {
-                    Logger.error('Font', `[${this._originalFamilies.join(',')}] Loading Failed, rendering cannot start`);
+                    Logger.error('Font', `[${this._originalFamilies.join(',')}] Loading Failed, rendering cannot start`, e);
                     window.clearInterval(failCounterId);
+                    debugger;
                 }
             };
             let successHandler = (font) => {
-                Logger.debug('Rendering', `[${font}] Font API signaled available`);
+                Logger.debug('Font', `[${font}] Font API signaled available`);
                 this.isFontLoaded = true;
                 window.clearInterval(failCounterId);
                 this.fontLoaded.trigger(this._families[0]);
             };
-            let checkFont = () => {
+            let checkFont = async () => {
                 // Fast Path: check if one of the specified fonts is already available.
                 for (const font of this._families) {
-                    if (document.fonts.check('1em ' + font)) {
+                    if (await this.isFontAvailable(font, false)) {
                         successHandler(font);
                         return;
                     }
                 }
                 // Slow path: Wait for fonts to be loaded sequentially
-                const promise = document.fonts.load(`1em ${this._families[0]}`);
-                promise.then(() => {
-                    Logger.debug('Font', `[${this._families[0]}] Font API signaled loaded`);
-                    if (document.fonts.check('1em ' + this._families[0])) {
-                        successHandler(this._families[0]);
-                    }
-                    else {
-                        errorHandler();
-                    }
-                    return true;
-                }, reason => {
-                    errorHandler();
-                });
+                try {
+                    await document.fonts.load(`1em ${this._families[0]}`);
+                }
+                catch (e) {
+                    errorHandler(e);
+                }
+                Logger.debug('Font', `[${this._families[0]}] Font API signaled loaded`);
+                if (await this.isFontAvailable(this._families[0], true)) {
+                    successHandler(this._families[0]);
+                }
+                else {
+                    errorHandler('Font not available');
+                }
+                return true;
             };
             document.fonts.ready.then(() => {
+                // tslint:disable-next-line: no-floating-promises
                 checkFont();
             });
         }
+        isFontAvailable(family, advancedCheck) {
+            return new Promise(resolve => {
+                // In some very rare occasions Chrome reports false for the font.
+                // in this case we try to force some refresh and reload by creating an element with this font.
+                const fontString = '1em ' + family;
+                if (document.fonts.check(fontString)) {
+                    resolve(true);
+                }
+                else if (advancedCheck) {
+                    Logger.debug('Font', `Font ${family} not available, creating test element to trigger load`);
+                    const testElement = document.createElement('div');
+                    testElement.style.font = fontString;
+                    testElement.style.opacity = '0';
+                    testElement.style.position = 'absolute';
+                    testElement.style.top = '0';
+                    testElement.style.left = '0';
+                    testElement.innerText = `Trigger ${family} load`;
+                    document.body.appendChild(testElement);
+                    setTimeout(() => {
+                        document.body.removeChild(testElement);
+                        if (document.fonts.check(fontString)) {
+                            resolve(true);
+                        }
+                        else {
+                            resolve(false);
+                        }
+                    }, 200);
+                }
+                else {
+                    resolve(false);
+                }
+            });
+        }
     }
 
     /**
@@ -27384,7 +27424,7 @@
                     if (this._api.settings.core.enableLazyLoading) {
                         this._intersectionObserver.unobserve(canvasElement.lastChild);
                     }
-                    canvasElement.removeChild(canvasElement.lastChild);
+                    canvasElement.removeChild(canvasElement.lastElementChild);
                 }
             }
             else {
@@ -41384,8 +41424,8 @@
     // </auto-generated>
     class VersionInfo {
     }
-    VersionInfo.version = '1.3.0-alpha.418';
-    VersionInfo.date = '2022-10-11T00:58:31.859Z';
+    VersionInfo.version = '1.3.0-alpha.424';
+    VersionInfo.date = '2022-10-17T01:10:24.242Z';
 
     var index$5 = /*#__PURE__*/Object.freeze({
         __proto__: null,