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

package/dist/alphaTab.js

@@ -1,5 +1,5 @@
 /**
- * alphaTab v1.3.0-alpha.422 (develop, build 422)
+ * alphaTab v1.3.0-alpha.424 (develop, build 424)
  * 
  * Copyright © 2022, Daniel Kuschny and Contributors, All rights reserved.
  * 
@@ -25922,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);
+                }
+            });
+        }
     }
 
     /**
@@ -27387,7 +27424,7 @@
                     if (this._api.settings.core.enableLazyLoading) {
                         this._intersectionObserver.unobserve(canvasElement.lastChild);
                     }
-                    canvasElement.removeChild(canvasElement.lastChild);
+                    canvasElement.removeChild(canvasElement.lastElementChild);
                 }
             }
             else {
@@ -41387,8 +41424,8 @@
     // </auto-generated>
     class VersionInfo {
     }
-    VersionInfo.version = '1.3.0-alpha.422';
-    VersionInfo.date = '2022-10-15T01:02:48.729Z';
+    VersionInfo.version = '1.3.0-alpha.424';
+    VersionInfo.date = '2022-10-17T01:10:24.242Z';
 
     var index$5 = /*#__PURE__*/Object.freeze({
         __proto__: null,