@babylonjs/core 8.45.4 → 8.45.5

package/Misc/tools.d.ts

@@ -276,6 +276,8 @@ export declare class Tools {
      * @returns a promise request object
      */
     static LoadBabylonScriptAsync(scriptUrl: string): Promise<void>;
+    private static _LoadScriptNative;
+    private static _LoadScriptWeb;
     /**
      * This function is used internally by babylon components to load a script (identified by an url). When the url returns, the
      * content of this file is added into a new script element, attached to the DOM (body element)
@@ -285,7 +287,7 @@ export declare class Tools {
      * @param scriptId defines the id of the script element
      * @param useModule defines if we should use the module strategy to load the script
      */
-    static LoadScript(scriptUrl: string, onSuccess?: () => void, onError?: (message?: string, exception?: any) => void, scriptId?: string, useModule?: boolean): void;
+    static LoadScript: (scriptUrl: string, onSuccess?: () => void, onError?: (message?: string, exception?: any) => void, scriptId?: string, useModule?: boolean) => void;
     /**
      * Load an asynchronous script (identified by an url). When the url returns, the
      * content of this file is added into a new script element, attached to the DOM (body element)

package/Misc/tools.js

@@ -1,3 +1,4 @@
+var _a;
 import { Observable } from "./observable.js";
 import { GetDOMTextContent, IsNavigatorAvailable, IsWindowObjectExist } from "./domManagement.js";
 import { Logger } from "./logger.js";
@@ -86,8 +87,8 @@ export class Tools {
      */
     // eslint-disable-next-line @typescript-eslint/naming-convention
     static set CDNBaseUrl(value) {
-        Tools.ScriptBaseUrl = value;
-        Tools.AssetBaseUrl = value;
+        _a.ScriptBaseUrl = value;
+        _a.AssetBaseUrl = value;
     }
     /**
      * Sets a preprocessing function to run on a source URL before importing it
@@ -369,10 +370,10 @@ export class Tools {
         if (!url) {
             return "";
         }
-        if (Tools.AssetBaseUrl && url.startsWith(Tools._DefaultAssetsUrl)) {
+        if (_a.AssetBaseUrl && url.startsWith(_a._DefaultAssetsUrl)) {
             // normalize the baseUrl
-            const baseUrl = Tools.AssetBaseUrl[Tools.AssetBaseUrl.length - 1] === "/" ? Tools.AssetBaseUrl.substring(0, Tools.AssetBaseUrl.length - 1) : Tools.AssetBaseUrl;
-            return url.replace(Tools._DefaultAssetsUrl, baseUrl);
+            const baseUrl = _a.AssetBaseUrl[_a.AssetBaseUrl.length - 1] === "/" ? _a.AssetBaseUrl.substring(0, _a.AssetBaseUrl.length - 1) : _a.AssetBaseUrl;
+            return url.replace(_a._DefaultAssetsUrl, baseUrl);
         }
         return url;
     }
@@ -387,16 +388,16 @@ export class Tools {
             return "";
         }
         // if the base URL was set, and the script Url is an absolute path change the default path
-        if (Tools.ScriptBaseUrl && scriptUrl.startsWith(Tools._DefaultCdnUrl)) {
+        if (_a.ScriptBaseUrl && scriptUrl.startsWith(_a._DefaultCdnUrl)) {
             // change the default host, which is https://cdn.babylonjs.com with the one defined
             // make sure no trailing slash is present
-            const baseUrl = Tools.ScriptBaseUrl[Tools.ScriptBaseUrl.length - 1] === "/" ? Tools.ScriptBaseUrl.substring(0, Tools.ScriptBaseUrl.length - 1) : Tools.ScriptBaseUrl;
-            scriptUrl = scriptUrl.replace(Tools._DefaultCdnUrl, baseUrl);
+            const baseUrl = _a.ScriptBaseUrl[_a.ScriptBaseUrl.length - 1] === "/" ? _a.ScriptBaseUrl.substring(0, _a.ScriptBaseUrl.length - 1) : _a.ScriptBaseUrl;
+            scriptUrl = scriptUrl.replace(_a._DefaultCdnUrl, baseUrl);
         }
         // run the preprocessor
-        scriptUrl = Tools.ScriptPreprocessUrl(scriptUrl);
-        if (forceAbsoluteUrl && !Tools.IsAbsoluteUrl(scriptUrl)) {
-            scriptUrl = Tools.GetAbsoluteUrl(scriptUrl);
+        scriptUrl = _a.ScriptPreprocessUrl(scriptUrl);
+        if (forceAbsoluteUrl && !_a.IsAbsoluteUrl(scriptUrl)) {
+            scriptUrl = _a.GetAbsoluteUrl(scriptUrl);
         }
         return scriptUrl;
     }
@@ -409,8 +410,8 @@ export class Tools {
      * @param scriptId defines the id of the script element
      */
     static LoadBabylonScript(scriptUrl, onSuccess, onError, scriptId) {
-        scriptUrl = Tools.GetBabylonScriptURL(scriptUrl);
-        Tools.LoadScript(scriptUrl, onSuccess, onError);
+        scriptUrl = _a.GetBabylonScriptURL(scriptUrl);
+        _a.LoadScript(scriptUrl, onSuccess, onError);
     }
     /**
      * Load an asynchronous script (identified by an url). When the url returns, the
@@ -419,19 +420,24 @@ export class Tools {
      * @returns a promise request object
      */
     static async LoadBabylonScriptAsync(scriptUrl) {
-        scriptUrl = Tools.GetBabylonScriptURL(scriptUrl);
-        return await Tools.LoadScriptAsync(scriptUrl);
+        scriptUrl = _a.GetBabylonScriptURL(scriptUrl);
+        return await _a.LoadScriptAsync(scriptUrl);
     }
-    /**
-     * This function is used internally by babylon components to load a script (identified by an url). When the url returns, the
-     * content of this file is added into a new script element, attached to the DOM (body element)
-     * @param scriptUrl defines the url of the script to load
-     * @param onSuccess defines the callback called when the script is loaded
-     * @param onError defines the callback to call if an error occurs
-     * @param scriptId defines the id of the script element
-     * @param useModule defines if we should use the module strategy to load the script
-     */
-    static LoadScript(scriptUrl, onSuccess, onError, scriptId, useModule = false) {
+    static _LoadScriptNative(scriptUrl, onSuccess, onError) {
+        if (_native) {
+            _a.LoadFile(scriptUrl, (data) => {
+                Function(data).apply(null);
+                if (onSuccess) {
+                    onSuccess();
+                }
+            }, undefined, undefined, false, (_request, exception) => {
+                if (onError) {
+                    onError("LoadScript Error", exception);
+                }
+            });
+        }
+    }
+    static _LoadScriptWeb(scriptUrl, onSuccess, onError, scriptId, useModule = false) {
         if (typeof importScripts === "function") {
             try {
                 importScripts(scriptUrl);
@@ -668,7 +674,7 @@ export class Tools {
      */
     static ToBlob(canvas, successCallback, mimeType = "image/png", quality) {
         // We need HTMLCanvasElement.toBlob for HD screenshots
-        if (!Tools._IsOffScreenCanvas(canvas) && !canvas.toBlob) {
+        if (!_a._IsOffScreenCanvas(canvas) && !canvas.toBlob) {
             //  low performance polyfill based on toDataURL (https://developer.mozilla.org/en-US/docs/Web/API/HTMLCanvasElement/toBlob)
             canvas.toBlob = function (callback, type, quality) {
                 setTimeout(() => {
@@ -680,7 +686,7 @@ export class Tools {
                 });
             };
         }
-        if (Tools._IsOffScreenCanvas(canvas)) {
+        if (_a._IsOffScreenCanvas(canvas)) {
             // eslint-disable-next-line @typescript-eslint/no-floating-promises
             canvas
                 .convertToBlob({
@@ -709,7 +715,7 @@ export class Tools {
                 const stringDate = (date.getFullYear() + "-" + (date.getMonth() + 1)).slice(2) + "-" + date.getDate() + "_" + date.getHours() + "-" + ("0" + date.getMinutes()).slice(-2);
                 fileName = "screenshot_" + stringDate + ".png";
             }
-            Tools.Download(blob, fileName);
+            _a.Download(blob, fileName);
         }
         else {
             if (blob && typeof URL !== "undefined") {
@@ -740,7 +746,7 @@ export class Tools {
         if (typeof fileName === "string" || !successCallback) {
             this.ToBlob(canvas, function (blob) {
                 if (blob) {
-                    Tools.DownloadBlob(blob, fileName);
+                    _a.DownloadBlob(blob, fileName);
                 }
                 if (successCallback) {
                     successCallback("");
@@ -748,7 +754,7 @@ export class Tools {
             }, mimeType, quality);
         }
         else if (successCallback) {
-            if (Tools._IsOffScreenCanvas(canvas)) {
+            if (_a._IsOffScreenCanvas(canvas)) {
                 // eslint-disable-next-line @typescript-eslint/no-floating-promises
                 canvas
                     .convertToBlob({
@@ -987,32 +993,32 @@ export class Tools {
      * Sets the current performance log level
      */
     static set PerformanceLogLevel(level) {
-        if ((level & Tools.PerformanceUserMarkLogLevel) === Tools.PerformanceUserMarkLogLevel) {
+        if ((level & _a.PerformanceUserMarkLogLevel) === _a.PerformanceUserMarkLogLevel) {
             if (_native?.enablePerformanceLogging) {
                 _native.enablePerformanceLogging(1 /* NativeTraceLevel.Mark */);
-                Tools.StartPerformanceCounter = Tools._StartMarkNative;
-                Tools.EndPerformanceCounter = Tools._EndMarkNative;
+                _a.StartPerformanceCounter = _a._StartMarkNative;
+                _a.EndPerformanceCounter = _a._EndMarkNative;
             }
             else {
-                Tools.StartPerformanceCounter = Tools._StartUserMark;
-                Tools.EndPerformanceCounter = Tools._EndUserMark;
+                _a.StartPerformanceCounter = _a._StartUserMark;
+                _a.EndPerformanceCounter = _a._EndUserMark;
             }
             return;
         }
-        if ((level & Tools.PerformanceConsoleLogLevel) === Tools.PerformanceConsoleLogLevel) {
+        if ((level & _a.PerformanceConsoleLogLevel) === _a.PerformanceConsoleLogLevel) {
             if (_native?.enablePerformanceLogging) {
                 _native.enablePerformanceLogging(2 /* NativeTraceLevel.Log */);
-                Tools.StartPerformanceCounter = Tools._StartMarkNative;
-                Tools.EndPerformanceCounter = Tools._EndMarkNative;
+                _a.StartPerformanceCounter = _a._StartMarkNative;
+                _a.EndPerformanceCounter = _a._EndMarkNative;
             }
             else {
-                Tools.StartPerformanceCounter = Tools._StartPerformanceConsole;
-                Tools.EndPerformanceCounter = Tools._EndPerformanceConsole;
+                _a.StartPerformanceCounter = _a._StartPerformanceConsole;
+                _a.EndPerformanceCounter = _a._EndPerformanceConsole;
             }
             return;
         }
-        Tools.StartPerformanceCounter = Tools._StartPerformanceCounterDisabled;
-        Tools.EndPerformanceCounter = Tools._EndPerformanceCounterDisabled;
+        _a.StartPerformanceCounter = _a._StartPerformanceCounterDisabled;
+        _a.EndPerformanceCounter = _a._EndPerformanceCounterDisabled;
         _native?.disablePerformanceLogging?.();
     }
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -1020,29 +1026,29 @@ export class Tools {
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     static _EndPerformanceCounterDisabled(counterName, condition) { }
     static _StartUserMark(counterName, condition = true) {
-        if (!Tools._Performance) {
+        if (!_a._Performance) {
             if (!IsWindowObjectExist()) {
                 return;
             }
-            Tools._Performance = window.performance;
+            _a._Performance = window.performance;
         }
-        if (!condition || !Tools._Performance.mark) {
+        if (!condition || !_a._Performance.mark) {
             return;
         }
-        Tools._Performance.mark(counterName + "-Begin");
+        _a._Performance.mark(counterName + "-Begin");
     }
     static _EndUserMark(counterName, condition = true) {
-        if (!condition || !Tools._Performance.mark) {
+        if (!condition || !_a._Performance.mark) {
             return;
         }
-        Tools._Performance.mark(counterName + "-End");
-        Tools._Performance.measure(counterName, counterName + "-Begin", counterName + "-End");
+        _a._Performance.mark(counterName + "-End");
+        _a._Performance.measure(counterName, counterName + "-Begin", counterName + "-End");
     }
     static _StartPerformanceConsole(counterName, condition = true) {
         if (!condition) {
             return;
         }
-        Tools._StartUserMark(counterName, condition);
+        _a._StartUserMark(counterName, condition);
         if (console.time) {
             console.time(counterName);
         }
@@ -1051,29 +1057,29 @@ export class Tools {
         if (!condition) {
             return;
         }
-        Tools._EndUserMark(counterName, condition);
+        _a._EndUserMark(counterName, condition);
         console.timeEnd(counterName);
     }
     static _StartMarkNative(counterName, condition = true) {
         if (condition && _native?.startPerformanceCounter) {
-            if (Tools._NativePerformanceCounterHandles.has(counterName)) {
-                Tools.Warn(`Performance counter with name ${counterName} is already started.`);
+            if (_a._NativePerformanceCounterHandles.has(counterName)) {
+                _a.Warn(`Performance counter with name ${counterName} is already started.`);
             }
             else {
                 const handle = _native.startPerformanceCounter(counterName);
-                Tools._NativePerformanceCounterHandles.set(counterName, handle);
+                _a._NativePerformanceCounterHandles.set(counterName, handle);
             }
         }
     }
     static _EndMarkNative(counterName, condition = true) {
         if (condition && _native?.endPerformanceCounter) {
-            const handle = Tools._NativePerformanceCounterHandles.get(counterName);
+            const handle = _a._NativePerformanceCounterHandles.get(counterName);
             if (handle) {
                 _native.endPerformanceCounter(handle);
-                Tools._NativePerformanceCounterHandles.delete(counterName);
+                _a._NativePerformanceCounterHandles.delete(counterName);
             }
             else {
-                Tools.Warn(`Performance counter with name ${counterName} was not started.`);
+                _a.Warn(`Performance counter with name ${counterName} was not started.`);
             }
         }
     }
@@ -1173,6 +1179,7 @@ export class Tools {
         return /^((?!chrome|android).)*safari/i.test(navigator.userAgent);
     }
 }
+_a = Tools;
 /**
  * The base URL to use to load assets. If empty the default base url is used.
  */
@@ -1201,6 +1208,16 @@ Tools._DefaultCdnUrl = "https://cdn.babylonjs.com";
  * @internal
  */
 Tools._DefaultAssetsUrl = "https://assets.babylonjs.com/core";
+/**
+ * This function is used internally by babylon components to load a script (identified by an url). When the url returns, the
+ * content of this file is added into a new script element, attached to the DOM (body element)
+ * @param scriptUrl defines the url of the script to load
+ * @param onSuccess defines the callback called when the script is loaded
+ * @param onError defines the callback to call if an error occurs
+ * @param scriptId defines the id of the script element
+ * @param useModule defines if we should use the module strategy to load the script
+ */
+Tools.LoadScript = typeof _native === "undefined" ? _a._LoadScriptWeb : _a._LoadScriptNative;
 // eslint-disable-next-line jsdoc/require-returns-check, jsdoc/require-param
 /**
  * @returns the absolute URL of a given (relative) url
@@ -1259,11 +1276,11 @@ Tools._NativePerformanceCounterHandles = new Map();
 /**
  * Starts a performance counter
  */
-Tools.StartPerformanceCounter = Tools._StartPerformanceCounterDisabled;
+Tools.StartPerformanceCounter = _a._StartPerformanceCounterDisabled;
 /**
  * Ends a specific performance counter
  */
-Tools.EndPerformanceCounter = Tools._EndPerformanceCounterDisabled;
+Tools.EndPerformanceCounter = _a._EndPerformanceCounterDisabled;
 /**
  * Use this className as a decorator on a given class definition to add it a name and optionally its module.
  * You can then use the Tools.getClassName(obj) on an instance to retrieve its class name.