@babylonjs/core 9.12.1 → 9.14.0

package/Loading/sceneLoader.js

@@ -101,11 +101,91 @@ function formatErrorMessage(fileInfo, message, exception) {
     }
     return errorMessage;
 }
-async function loadDataAsync(fileInfo, scene, onSuccess, onProgress, onError, onDispose, pluginExtension, name, pluginOptions) {
+function createLoadError(fileInfo, message, exception) {
+    const errorMessage = formatErrorMessage(fileInfo, message, exception);
+    return new RuntimeError(errorMessage, ErrorCodes.SceneLoaderError, exception);
+}
+function getErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+// Converts an error into a SceneLoader RuntimeError, leaving an already-wrapped SceneLoader error untouched
+// so that it is not double-wrapped (which would duplicate the "Unable to load from ..." prefix).
+function toLoadError(fileInfo, error) {
+    return error instanceof RuntimeError && error.errorCode === ErrorCodes.SceneLoaderError ? error : createLoadError(fileInfo, getErrorMessage(error), error);
+}
+const loadAssetContainerNotSupportedMessage = "LoadAssetContainer is not supported by this plugin. Plugin did not provide a loadAssetContainer or loadAssetContainerAsync method.";
+// A synchronous plugin exposes the synchronous import/load methods; an asynchronous plugin exposes the *Async methods.
+function isSyncPlugin(plugin) {
+    const candidate = plugin;
+    return !!candidate.importMesh || !!candidate.load || !!candidate.loadAssetContainer;
+}
+// Adapts a synchronous ISceneLoaderPlugin into an ISceneLoaderPluginAsync so that callers can use a single
+// promise-based code path regardless of whether the underlying plugin is synchronous or asynchronous.
+// Asynchronous plugins are returned unchanged. The synchronous plugin reports failure via an onError callback
+// and/or a falsy return value; both are translated into a rejected promise.
+function toAsyncPlugin(plugin, fileInfo) {
+    if (!isSyncPlugin(plugin)) {
+        return plugin;
+    }
+    const runSync = (invoke) => {
+        let pluginError;
+        const result = invoke((message, exception) => {
+            pluginError = { message, exception };
+        });
+        if (!result) {
+            throw createLoadError(fileInfo, pluginError?.message, pluginError?.exception);
+        }
+        return result;
+    };
+    return {
+        name: plugin.name,
+        extensions: plugin.extensions,
+        importMeshAsync: async (meshesNames, scene, data, rootUrl) => {
+            const meshes = [];
+            const particleSystems = [];
+            const skeletons = [];
+            runSync((onError) => plugin.importMesh(meshesNames, scene, data, rootUrl, meshes, particleSystems, skeletons, onError));
+            return { meshes, particleSystems, skeletons, animationGroups: [], transformNodes: [], geometries: [], lights: [], spriteManagers: [] };
+        },
+        loadAsync: async (scene, data, rootUrl) => {
+            runSync((onError) => plugin.load(scene, data, rootUrl, onError));
+        },
+        loadAssetContainerAsync: async (scene, data, rootUrl) => {
+            return runSync((onError) => plugin.loadAssetContainer(scene, data, rootUrl, onError));
+        },
+    };
+}
+// Reports a load failure to the legacy onError callback. The onError signature requires a Scene, but a scene
+// may not be available (e.g. the error occurred before any scene was created). In that case, fall back to
+// logging so the error handler does not throw a secondary error and mask the original failure.
+function reportLegacyLoadError(onError, reportScene, error) {
+    const message = getErrorMessage(error);
+    if (onError && reportScene) {
+        onError(reportScene, message, error);
+    }
+    else {
+        Logger.Error(message);
+    }
+}
+// Wraps a user supplied progress callback so that an exception thrown by it is logged rather than
+// aborting the entire loading operation.
+function wrapProgress(onProgress) {
+    if (!onProgress) {
+        return undefined;
+    }
+    return (event) => {
+        try {
+            onProgress(event);
+        }
+        catch (error) {
+            Logger.Warn("Error in onProgress callback: " + getErrorMessage(error));
+        }
+    };
+}
+async function loadDataAsync(fileInfo, scene, onProgress, pluginExtension, name, pluginOptions) {
     const directLoad = getDirectLoad(fileInfo.url);
     if (fileInfo.rawData && !pluginExtension) {
-        // eslint-disable-next-line no-throw-literal
-        throw "When using ArrayBufferView to load data the file extension must be provided.";
+        throw new Error("When using ArrayBufferView to load data the file extension must be provided.");
     }
     const fileExtension = !directLoad && !pluginExtension ? getFilenameExtension(fileInfo.url) : "";
     let registeredPlugin = pluginExtension
@@ -119,7 +199,6 @@ async function loadDataAsync(fileInfo, scene, onSuccess, onProgress, onError, on
             const response = await _FetchAsync(fileInfo.url, { method: "HEAD", responseHeaders: ["Content-Type"] });
             const mimeType = response.headerValues ? response.headerValues["Content-Type"] : "";
             if (mimeType) {
-                // eslint-disable-next-line require-atomic-updates
                 registeredPlugin = getPluginForMimeType(mimeType);
             }
         }
@@ -134,101 +213,103 @@ async function loadDataAsync(fileInfo, scene, onSuccess, onProgress, onError, on
         throw new Error(`The '${registeredPlugin.plugin.name}' plugin is disabled via the loader options passed to the loading operation.`);
     }
     if (fileInfo.rawData && !registeredPlugin.isBinary) {
-        // eslint-disable-next-line no-throw-literal
-        throw "Loading from ArrayBufferView can not be used with plugins that don't support binary loading.";
-    }
-    const getPluginInstance = (callback) => {
-        // For plugin factories, the plugin is instantiated on each SceneLoader operation. This makes options handling
-        // much simpler as we can just pass the options to the factory, rather than passing options through to every possible
-        // plugin call. Given this, options are only supported for plugins that provide a factory function.
-        if (IsFactory(registeredPlugin.plugin)) {
-            const pluginFactory = registeredPlugin.plugin;
-            const partialPlugin = pluginFactory.createPlugin((pluginOptions ?? {}));
-            if (partialPlugin instanceof Promise) {
-                // eslint-disable-next-line github/no-then
-                partialPlugin.then(callback).catch((error) => {
-                    onError("Error instantiating plugin.", error);
-                });
-                // When async factories are used, the plugin instance cannot be returned synchronously.
-                // In this case, the legacy loader functions will return null.
-                return null;
-            }
-            else {
-                callback(partialPlugin);
-                return partialPlugin;
-            }
-        }
-        else {
-            callback(registeredPlugin.plugin);
-            return registeredPlugin.plugin;
+        throw new Error("Loading from ArrayBufferView can not be used with plugins that don't support binary loading.");
+    }
+    // For plugin factories, the plugin is instantiated on each SceneLoader operation. This makes options handling
+    // much simpler as we can just pass the options to the factory, rather than passing options through to every possible
+    // plugin call. Given this, options are only supported for plugins that provide a factory function.
+    let plugin;
+    if (IsFactory(registeredPlugin.plugin)) {
+        const pluginFactory = registeredPlugin.plugin;
+        try {
+            // Only await when the factory is actually asynchronous, so that for synchronous factories the plugin is
+            // instantiated (and onPluginActivatedObservable is notified) synchronously within the calling load operation.
+            const createdPlugin = pluginFactory.createPlugin((pluginOptions ?? {}));
+            plugin = createdPlugin instanceof Promise ? await createdPlugin : createdPlugin;
         }
-    };
-    return getPluginInstance((plugin) => {
-        if (!plugin) {
-            // eslint-disable-next-line no-throw-literal
-            throw `The loader plugin corresponding to the '${pluginExtension}' file type has not been found. If using es6, please import the plugin you wish to use before.`;
+        catch (error) {
+            throw createLoadError(fileInfo, "Error instantiating plugin.", error);
         }
-        onPluginActivatedObservable.notifyObservers(plugin);
-        // Check if we have a direct load url. If the plugin is registered to handle
-        // it or it's not a base64 data url, then pass it through the direct load path.
-        if (directLoad && ((plugin.canDirectLoad && plugin.canDirectLoad(fileInfo.url)) || !IsBase64DataUrl(fileInfo.url))) {
-            if (plugin.directLoad) {
-                const result = plugin.directLoad(scene, directLoad);
-                if (result instanceof Promise) {
-                    result
-                        // eslint-disable-next-line github/no-then
-                        .then((data) => {
-                        onSuccess(plugin, data);
-                    })
-                        // eslint-disable-next-line github/no-then
-                        .catch((error) => {
-                        onError("Error in directLoad of _loadData: " + error, error);
-                    });
-                }
-                else {
-                    onSuccess(plugin, result);
-                }
+    }
+    else {
+        plugin = registeredPlugin.plugin;
+    }
+    if (!plugin) {
+        throw new Error(`The loader plugin corresponding to the '${pluginExtension}' file type has not been found. If using es6, please import the plugin you wish to use before.`);
+    }
+    onPluginActivatedObservable.notifyObservers(plugin);
+    // Check if we have a direct load url. If the plugin is registered to handle
+    // it or it's not a base64 data url, then pass it through the direct load path.
+    if (directLoad && ((plugin.canDirectLoad && plugin.canDirectLoad(fileInfo.url)) || !IsBase64DataUrl(fileInfo.url))) {
+        if (plugin.directLoad) {
+            let data;
+            try {
+                data = await plugin.directLoad(scene, directLoad);
             }
-            else {
-                onSuccess(plugin, directLoad);
+            catch (error) {
+                throw createLoadError(fileInfo, "Error in directLoad of _loadData: " + error, error);
             }
-            return;
+            return { plugin, data };
         }
-        const useArrayBuffer = registeredPlugin.isBinary;
-        const dataCallback = (data, responseURL) => {
-            if (scene.isDisposed) {
-                onError("Scene has been disposed");
-                return;
-            }
-            onSuccess(plugin, data, responseURL);
-        };
+        return { plugin, data: directLoad };
+    }
+    const useArrayBuffer = registeredPlugin.isBinary;
+    return await new Promise((resolve, reject) => {
         let request = null;
         let pluginDisposed = false;
-        plugin.onDisposeObservable?.add(() => {
+        const onDisposeObserver = plugin.onDisposeObservable?.add(() => {
             pluginDisposed = true;
             if (request) {
                 request.abort();
                 request = null;
             }
-            onDispose();
+            rejectAndCleanup(createLoadError(fileInfo, "Loading was aborted because the plugin was disposed."));
         });
+        // Ensure the onDispose observer is removed once the promise settles, so observers do not accumulate across loads.
+        const cleanup = () => {
+            if (onDisposeObserver) {
+                plugin.onDisposeObservable?.remove(onDisposeObserver);
+            }
+        };
+        const resolveAndCleanup = (value) => {
+            cleanup();
+            resolve(value);
+        };
+        const rejectAndCleanup = (error) => {
+            cleanup();
+            reject(error);
+        };
+        const dataCallback = (data, responseURL) => {
+            if (scene.isDisposed) {
+                rejectAndCleanup(createLoadError(fileInfo, "Scene has been disposed"));
+                return;
+            }
+            resolveAndCleanup({ plugin, data, responseURL });
+        };
         const manifestChecked = () => {
             if (pluginDisposed) {
                 return;
             }
             const errorCallback = (request, exception) => {
-                onError(request?.statusText, exception);
+                rejectAndCleanup(createLoadError(fileInfo, request?.statusText, exception));
             };
             if (!plugin.loadFile && fileInfo.rawData) {
-                // eslint-disable-next-line no-throw-literal
-                throw "Plugin does not support loading ArrayBufferView.";
+                rejectAndCleanup(createLoadError(fileInfo, "Plugin does not support loading ArrayBufferView."));
+                return;
+            }
+            try {
+                request = plugin.loadFile
+                    ? plugin.loadFile(scene, fileInfo.rawData || fileInfo.file || fileInfo.url, fileInfo.rootUrl, dataCallback, onProgress, useArrayBuffer, errorCallback, name)
+                    : scene._loadFile(fileInfo.file || fileInfo.url, dataCallback, onProgress, true, useArrayBuffer, errorCallback);
+            }
+            catch (error) {
+                rejectAndCleanup(createLoadError(fileInfo, undefined, error));
             }
-            request = plugin.loadFile
-                ? plugin.loadFile(scene, fileInfo.rawData || fileInfo.file || fileInfo.url, fileInfo.rootUrl, dataCallback, onProgress, useArrayBuffer, errorCallback, name)
-                : scene._loadFile(fileInfo.file || fileInfo.url, dataCallback, onProgress, true, useArrayBuffer, errorCallback);
         };
         const engine = scene.getEngine();
-        let canUseOfflineSupport = engine.enableOfflineSupport;
+        // File objects and raw data buffers are already in-memory and are not URL-backed requests, so they must
+        // not be routed through the offline (manifest/cache) provider.
+        let canUseOfflineSupport = !fileInfo.file && !fileInfo.rawData && engine.enableOfflineSupport;
         if (canUseOfflineSupport) {
             // Also check for exceptions
             let exceptionFound = false;
@@ -242,7 +323,12 @@ async function loadDataAsync(fileInfo, scene, onSuccess, onProgress, onError, on
         }
         if (canUseOfflineSupport && AbstractEngine.OfflineProviderFactory) {
             // Checking if a manifest file has been set for this scene and if offline mode has been requested
-            scene.offlineProvider = AbstractEngine.OfflineProviderFactory(fileInfo.url, manifestChecked, engine.disableManifestCheck);
+            try {
+                scene.offlineProvider = AbstractEngine.OfflineProviderFactory(fileInfo.url, manifestChecked, engine.disableManifestCheck);
+            }
+            catch (error) {
+                rejectAndCleanup(createLoadError(fileInfo, undefined, error));
+            }
         }
         else {
             manifestChecked();
@@ -350,120 +436,55 @@ export function GetRegisteredSceneLoaderPluginMetadata() {
  */
 export async function ImportMeshAsync(source, scene, options) {
     const { meshNames, rootUrl = "", onProgress, pluginExtension, name, pluginOptions } = options ?? {};
-    return await importMeshAsyncCoreAsync(meshNames, rootUrl, source, scene, onProgress, pluginExtension, name, pluginOptions);
+    return await importMeshCoreAsync(meshNames, rootUrl, source, scene, onProgress, pluginExtension, name, pluginOptions);
 }
-async function importMeshAsync(meshNames, rootUrl, sceneFilename = "", scene = EngineStore.LastCreatedScene, onSuccess = null, onProgress = null, onError = null, pluginExtension = null, name = "", pluginOptions = {}) {
+async function importMeshCoreAsync(meshNames, rootUrl, sceneFilename = "", scene = EngineStore.LastCreatedScene, onProgress, pluginExtension, name = "", pluginOptions = {}) {
     if (!scene) {
-        Logger.Error("No scene available to import mesh to");
-        return null;
+        throw new Error("No scene available to import mesh to");
     }
     const fileInfo = GetFileInfo(rootUrl, sceneFilename);
     if (!fileInfo) {
-        return null;
+        throw new Error("Cannot load file: a valid scene filename or root url was not provided.");
     }
     const loadingToken = {};
     scene.addPendingData(loadingToken);
-    const disposeHandler = () => {
-        scene.removePendingData(loadingToken);
-    };
-    const errorHandler = (message, exception) => {
-        const errorMessage = formatErrorMessage(fileInfo, message, exception);
-        if (onError) {
-            onError(scene, errorMessage, new RuntimeError(errorMessage, ErrorCodes.SceneLoaderError, exception));
-        }
-        else {
-            Logger.Error(errorMessage);
-            // should the exception be thrown?
-        }
-        disposeHandler();
-    };
-    const progressHandler = onProgress
-        ? (event) => {
-            try {
-                onProgress(event);
-            }
-            catch (e) {
-                errorHandler("Error in onProgress callback: " + e, e);
-            }
-        }
-        : undefined;
-    const successHandler = (meshes, particleSystems, skeletons, animationGroups, transformNodes, geometries, lights, spriteManagers) => {
-        scene.importedMeshesFiles.push(fileInfo.url);
-        if (onSuccess) {
-            try {
-                onSuccess(meshes, particleSystems, skeletons, animationGroups, transformNodes, geometries, lights, spriteManagers);
-            }
-            catch (e) {
-                errorHandler("Error in onSuccess callback: " + e, e);
-            }
-        }
-        scene.removePendingData(loadingToken);
-    };
-    return await loadDataAsync(fileInfo, scene, (plugin, data, responseURL) => {
+    const progressHandler = wrapProgress(onProgress);
+    try {
+        const { plugin, data, responseURL } = await loadDataAsync(fileInfo, scene, progressHandler, pluginExtension ?? null, name, pluginOptions);
         if (plugin.rewriteRootURL) {
             fileInfo.rootUrl = plugin.rewriteRootURL(fileInfo.rootUrl, responseURL);
         }
-        if (plugin.importMesh) {
-            const syncedPlugin = plugin;
-            const meshes = [];
-            const particleSystems = [];
-            const skeletons = [];
-            if (!syncedPlugin.importMesh(meshNames, scene, data, fileInfo.rootUrl, meshes, particleSystems, skeletons, errorHandler)) {
-                return;
-            }
-            scene.loadingPluginName = plugin.name;
-            successHandler(meshes, particleSystems, skeletons, [], [], [], [], []);
-        }
-        else {
-            const asyncedPlugin = plugin;
-            asyncedPlugin
-                .importMeshAsync(meshNames, scene, data, fileInfo.rootUrl, progressHandler, fileInfo.name)
-                // eslint-disable-next-line github/no-then
-                .then((result) => {
-                scene.loadingPluginName = plugin.name;
-                successHandler(result.meshes, result.particleSystems, result.skeletons, result.animationGroups, result.transformNodes, result.geometries, result.lights, result.spriteManagers);
-            })
-                // eslint-disable-next-line github/no-then
-                .catch((error) => {
-                errorHandler(error.message, error);
-            });
-        }
-    }, progressHandler, errorHandler, disposeHandler, pluginExtension, name, pluginOptions);
-}
-async function importMeshAsyncCoreAsync(meshNames, rootUrl, sceneFilename, scene, onProgress, pluginExtension, name, pluginOptions) {
-    return await new Promise((resolve, reject) => {
+        let result;
         try {
-            importMeshAsync(meshNames, rootUrl, sceneFilename, scene, (meshes, particleSystems, skeletons, animationGroups, transformNodes, geometries, lights, spriteManagers) => {
-                resolve({
-                    meshes: meshes,
-                    particleSystems: particleSystems,
-                    skeletons: skeletons,
-                    animationGroups: animationGroups,
-                    transformNodes: transformNodes,
-                    geometries: geometries,
-                    lights: lights,
-                    spriteManagers: spriteManagers,
-                });
-            }, onProgress, (scene, message, exception) => {
-                // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
-                reject(exception || new Error(message));
-            }, pluginExtension, name, pluginOptions
-            // eslint-disable-next-line github/no-then
-            ).catch(reject);
+            result = await toAsyncPlugin(plugin, fileInfo).importMeshAsync(meshNames, scene, data, fileInfo.rootUrl, progressHandler, fileInfo.name);
         }
         catch (error) {
-            // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
-            reject(error);
+            throw toLoadError(fileInfo, error);
         }
-    });
+        // eslint-disable-next-line require-atomic-updates
+        scene.loadingPluginName = plugin.name;
+        scene.importedMeshesFiles.push(fileInfo.url);
+        return result;
+    }
+    finally {
+        scene.removePendingData(loadingToken);
+    }
 }
 // This is the core implementation of load scene
-async function loadSceneImplAsync(rootUrl, sceneFilename = "", engine = EngineStore.LastCreatedEngine, onSuccess = null, onProgress = null, onError = null, pluginExtension = null, name = "", pluginOptions = {}) {
+async function loadSceneCoreAsync(rootUrl, sceneFilename = "", engine = EngineStore.LastCreatedEngine, onProgress, pluginExtension, name = "", pluginOptions = {}) {
     if (!engine) {
-        Tools.Error("No engine available");
-        return;
+        throw new Error("No engine available");
+    }
+    const scene = new Scene(engine);
+    try {
+        await appendSceneCoreAsync(rootUrl, sceneFilename, scene, onProgress, pluginExtension, name, pluginOptions);
     }
-    await appendSceneImplAsync(rootUrl, sceneFilename, new Scene(engine), onSuccess, onProgress, onError, pluginExtension, name, pluginOptions);
+    catch (error) {
+        // The scene was created here, so dispose it on failure to avoid leaking the partially loaded scene.
+        scene.dispose();
+        throw error;
+    }
+    return scene;
 }
 /**
  * Load a scene
@@ -474,7 +495,7 @@ async function loadSceneImplAsync(rootUrl, sceneFilename = "", engine = EngineSt
  */
 export async function LoadSceneAsync(source, engine, options) {
     const { rootUrl = "", onProgress, pluginExtension, name, pluginOptions } = options ?? {};
-    return await loadSceneSharedAsync(rootUrl, source, engine, onProgress, pluginExtension, name, pluginOptions);
+    return await loadSceneCoreAsync(rootUrl, source, engine, onProgress, pluginExtension, name, pluginOptions);
 }
 /**
  * Load a scene
@@ -487,33 +508,17 @@ export async function LoadSceneAsync(source, engine, options) {
 export async function loadSceneAsync(source, engine, options) {
     return await LoadSceneAsync(source, engine, options);
 }
-// This function is shared between the new module level loadSceneAsync and the legacy SceneLoader.LoadAsync
-async function loadSceneSharedAsync(rootUrl, sceneFilename, engine, onProgress, pluginExtension, name, pluginOptions) {
-    return await new Promise((resolve, reject) => {
-        // eslint-disable-next-line @typescript-eslint/no-floating-promises
-        loadSceneImplAsync(rootUrl, sceneFilename, engine, (scene) => {
-            resolve(scene);
-        }, onProgress, (scene, message, exception) => {
-            // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
-            reject(exception || new Error(message));
-        }, pluginExtension, name, pluginOptions);
-    });
-}
 // This is the core implementation of append scene
-async function appendSceneImplAsync(rootUrl, sceneFilename = "", scene = EngineStore.LastCreatedScene, onSuccess = null, onProgress = null, onError = null, pluginExtension = null, name = "", pluginOptions = {}) {
+async function appendSceneCoreAsync(rootUrl, sceneFilename = "", scene = EngineStore.LastCreatedScene, onProgress, pluginExtension, name = "", pluginOptions = {}) {
     if (!scene) {
-        Logger.Error("No scene available to append to");
-        return null;
+        throw new Error("No scene available to append to");
     }
     const fileInfo = GetFileInfo(rootUrl, sceneFilename);
     if (!fileInfo) {
-        return null;
+        throw new Error("Cannot load file: a valid scene filename or root url was not provided.");
     }
     const loadingToken = {};
     scene.addPendingData(loadingToken);
-    const disposeHandler = () => {
-        scene.removePendingData(loadingToken);
-    };
     if (SceneLoaderFlags.ShowLoadingScreen && !showingLoadingScreen) {
         showingLoadingScreen = true;
         scene.getEngine().displayLoadingUI();
@@ -522,62 +527,22 @@ async function appendSceneImplAsync(rootUrl, sceneFilename = "", scene = EngineS
             showingLoadingScreen = false;
         });
     }
-    const errorHandler = (message, exception) => {
-        const errorMessage = formatErrorMessage(fileInfo, message, exception);
-        if (onError) {
-            onError(scene, errorMessage, new RuntimeError(errorMessage, ErrorCodes.SceneLoaderError, exception));
-        }
-        else {
-            Logger.Error(errorMessage);
-            // should the exception be thrown?
-        }
-        disposeHandler();
-    };
-    const progressHandler = onProgress
-        ? (event) => {
-            try {
-                onProgress(event);
-            }
-            catch (e) {
-                errorHandler("Error in onProgress callback", e);
-            }
+    const progressHandler = wrapProgress(onProgress);
+    try {
+        const { plugin, data } = await loadDataAsync(fileInfo, scene, progressHandler, pluginExtension ?? null, name, pluginOptions);
+        try {
+            await toAsyncPlugin(plugin, fileInfo).loadAsync(scene, data, fileInfo.rootUrl, progressHandler, fileInfo.name);
         }
-        : undefined;
-    const successHandler = () => {
-        if (onSuccess) {
-            try {
-                onSuccess(scene);
-            }
-            catch (e) {
-                errorHandler("Error in onSuccess callback", e);
-            }
+        catch (error) {
+            throw toLoadError(fileInfo, error);
         }
+        // eslint-disable-next-line require-atomic-updates
+        scene.loadingPluginName = plugin.name;
+        return scene;
+    }
+    finally {
         scene.removePendingData(loadingToken);
-    };
-    return await loadDataAsync(fileInfo, scene, (plugin, data) => {
-        if (plugin.load) {
-            const syncedPlugin = plugin;
-            if (!syncedPlugin.load(scene, data, fileInfo.rootUrl, errorHandler)) {
-                return;
-            }
-            scene.loadingPluginName = plugin.name;
-            successHandler();
-        }
-        else {
-            const asyncedPlugin = plugin;
-            asyncedPlugin
-                .loadAsync(scene, data, fileInfo.rootUrl, progressHandler, fileInfo.name)
-                // eslint-disable-next-line github/no-then
-                .then(() => {
-                scene.loadingPluginName = plugin.name;
-                successHandler();
-            })
-                // eslint-disable-next-line github/no-then
-                .catch((error) => {
-                errorHandler(error.message, error);
-            });
-        }
-    }, progressHandler, errorHandler, disposeHandler, pluginExtension, name, pluginOptions);
+    }
 }
 /**
  * Append a scene
@@ -588,7 +553,7 @@ async function appendSceneImplAsync(rootUrl, sceneFilename = "", scene = EngineS
  */
 export async function AppendSceneAsync(source, scene, options) {
     const { rootUrl = "", onProgress, pluginExtension, name, pluginOptions } = options ?? {};
-    await appendSceneSharedAsync(rootUrl, source, scene, onProgress, pluginExtension, name, pluginOptions);
+    await appendSceneCoreAsync(rootUrl, source, scene, onProgress, pluginExtension, name, pluginOptions);
 }
 /**
  * Append a scene
@@ -601,102 +566,39 @@ export async function AppendSceneAsync(source, scene, options) {
 export async function appendSceneAsync(source, scene, options) {
     return await AppendSceneAsync(source, scene, options);
 }
-// This function is shared between the new module level appendSceneAsync and the legacy SceneLoader.AppendAsync
-async function appendSceneSharedAsync(rootUrl, sceneFilename, scene, onProgress, pluginExtension, name, pluginOptions) {
-    return await new Promise((resolve, reject) => {
-        try {
-            appendSceneImplAsync(rootUrl, sceneFilename, scene, (scene) => {
-                resolve(scene);
-            }, onProgress, (scene, message, exception) => {
-                // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
-                reject(exception || new Error(message));
-            }, pluginExtension, name, pluginOptions
-            // eslint-disable-next-line github/no-then
-            ).catch(reject);
-        }
-        catch (error) {
-            // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
-            reject(error);
-        }
-    });
-}
 // This is the core implementation of load asset container
-async function loadAssetContainerImplAsync(rootUrl, sceneFilename = "", scene = EngineStore.LastCreatedScene, onSuccess = null, onProgress = null, onError = null, pluginExtension = null, name = "", pluginOptions = {}) {
+async function loadAssetContainerCoreAsync(rootUrl, sceneFilename = "", scene = EngineStore.LastCreatedScene, onProgress, pluginExtension, name = "", pluginOptions = {}) {
     if (!scene) {
-        Logger.Error("No scene available to load asset container to");
-        return null;
+        throw new Error("No scene available to load asset container to");
     }
     const fileInfo = GetFileInfo(rootUrl, sceneFilename);
     if (!fileInfo) {
-        return null;
+        throw new Error("Cannot load file: a valid scene filename or root url was not provided.");
     }
     const loadingToken = {};
     scene.addPendingData(loadingToken);
-    const disposeHandler = () => {
-        scene.removePendingData(loadingToken);
-    };
-    const errorHandler = (message, exception) => {
-        const errorMessage = formatErrorMessage(fileInfo, message, exception);
-        if (onError) {
-            onError(scene, errorMessage, new RuntimeError(errorMessage, ErrorCodes.SceneLoaderError, exception));
-        }
-        else {
-            Logger.Error(errorMessage);
-            // should the exception be thrown?
-        }
-        disposeHandler();
-    };
-    const progressHandler = onProgress
-        ? (event) => {
-            try {
-                onProgress(event);
-            }
-            catch (e) {
-                errorHandler("Error in onProgress callback", e);
-            }
+    const progressHandler = wrapProgress(onProgress);
+    try {
+        const { plugin, data } = await loadDataAsync(fileInfo, scene, progressHandler, pluginExtension ?? null, name, pluginOptions);
+        const asyncPlugin = toAsyncPlugin(plugin, fileInfo);
+        if (!asyncPlugin.loadAssetContainerAsync) {
+            throw createLoadError(fileInfo, loadAssetContainerNotSupportedMessage);
+        }
+        let assetContainer;
+        try {
+            assetContainer = await asyncPlugin.loadAssetContainerAsync(scene, data, fileInfo.rootUrl, progressHandler, fileInfo.name);
         }
-        : undefined;
-    const successHandler = (assets) => {
-        if (onSuccess) {
-            try {
-                onSuccess(assets);
-            }
-            catch (e) {
-                errorHandler("Error in onSuccess callback", e);
-            }
+        catch (error) {
+            throw toLoadError(fileInfo, error);
         }
+        assetContainer.populateRootNodes();
+        // eslint-disable-next-line require-atomic-updates
+        scene.loadingPluginName = plugin.name;
+        return assetContainer;
+    }
+    finally {
         scene.removePendingData(loadingToken);
-    };
-    return await loadDataAsync(fileInfo, scene, (plugin, data) => {
-        if (plugin.loadAssetContainer) {
-            const syncedPlugin = plugin;
-            const assetContainer = syncedPlugin.loadAssetContainer(scene, data, fileInfo.rootUrl, errorHandler);
-            if (!assetContainer) {
-                return;
-            }
-            assetContainer.populateRootNodes();
-            scene.loadingPluginName = plugin.name;
-            successHandler(assetContainer);
-        }
-        else if (plugin.loadAssetContainerAsync) {
-            const asyncedPlugin = plugin;
-            asyncedPlugin
-                .loadAssetContainerAsync(scene, data, fileInfo.rootUrl, progressHandler, fileInfo.name)
-                // eslint-disable-next-line github/no-then
-                .then((assetContainer) => {
-                assetContainer.populateRootNodes();
-                scene.loadingPluginName = plugin.name;
-                successHandler(assetContainer);
-            })
-                // eslint-disable-next-line github/no-then
-                .catch((error) => {
-                errorHandler(error.message, error);
-            });
-        }
-        else {
-            errorHandler("LoadAssetContainer is not supported by this plugin. Plugin did not provide a loadAssetContainer or loadAssetContainerAsync method.");
-        }
-    }, progressHandler, errorHandler, disposeHandler, pluginExtension, name, pluginOptions);
+    }
 }
 /**
  * Load a scene into an asset container
@@ -707,7 +609,7 @@ async function loadAssetContainerImplAsync(rootUrl, sceneFilename = "", scene =
  */
 export async function LoadAssetContainerAsync(source, scene, options) {
     const { rootUrl = "", onProgress, pluginExtension, name, pluginOptions } = options ?? {};
-    return await loadAssetContainerSharedAsync(rootUrl, source, scene, onProgress, pluginExtension, name, pluginOptions);
+    return await loadAssetContainerCoreAsync(rootUrl, source, scene, onProgress, pluginExtension, name, pluginOptions);
 }
 /**
  * Load a scene into an asset container
@@ -720,30 +622,10 @@ export async function LoadAssetContainerAsync(source, scene, options) {
 export async function loadAssetContainerAsync(source, scene, options) {
     return await LoadAssetContainerAsync(source, scene, options);
 }
-// This function is shared between the new module level loadAssetContainerAsync and the legacy SceneLoader.LoadAssetContainerAsync
-async function loadAssetContainerSharedAsync(rootUrl, sceneFilename, scene, onProgress, pluginExtension, name, pluginOptions) {
-    return await new Promise((resolve, reject) => {
-        try {
-            loadAssetContainerImplAsync(rootUrl, sceneFilename, scene, (assets) => {
-                resolve(assets);
-            }, onProgress, (scene, message, exception) => {
-                // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
-                reject(exception || new Error(message));
-            }, pluginExtension, name, pluginOptions
-            // eslint-disable-next-line github/no-then
-            ).catch(reject);
-        }
-        catch (error) {
-            // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
-            reject(error);
-        }
-    });
-}
 // This is the core implementation of import animations
-async function importAnimationsImplAsync(rootUrl, sceneFilename = "", scene = EngineStore.LastCreatedScene, overwriteAnimations = true, animationGroupLoadingMode = 0 /* SceneLoaderAnimationGroupLoadingMode.Clean */, targetConverter = null, onSuccess = null, onProgress = null, onError = null, pluginExtension = null, name = "", pluginOptions = {}) {
+async function importAnimationsCoreAsync(rootUrl, sceneFilename = "", scene = EngineStore.LastCreatedScene, overwriteAnimations = true, animationGroupLoadingMode = 0 /* SceneLoaderAnimationGroupLoadingMode.Clean */, targetConverter = null, onProgress, pluginExtension, name = "", pluginOptions = {}) {
     if (!scene) {
-        Logger.Error("No scene available to load animations to");
-        return;
+        throw new Error("No scene available to load animations to");
     }
     if (overwriteAnimations) {
         // Reset, stop and dispose all animations before loading new ones
@@ -785,20 +667,14 @@ async function importAnimationsImplAsync(rootUrl, sceneFilename = "", scene = En
                 // nothing to do
                 break;
             default:
-                Logger.Error("Unknown animation group loading mode value '" + animationGroupLoadingMode + "'");
-                return;
+                throw new Error("Unknown animation group loading mode value '" + animationGroupLoadingMode + "'");
         }
     }
     const startingIndexForNewAnimatables = scene.animatables.length;
-    const onAssetContainerLoaded = (container) => {
-        container.mergeAnimationsTo(scene, scene.animatables.slice(startingIndexForNewAnimatables), targetConverter);
-        container.dispose();
-        scene.onAnimationFileImportedObservable.notifyObservers(scene);
-        if (onSuccess) {
-            onSuccess(scene);
-        }
-    };
-    await loadAssetContainerImplAsync(rootUrl, sceneFilename, scene, onAssetContainerLoaded, onProgress, onError, pluginExtension, name, pluginOptions);
+    const container = await loadAssetContainerCoreAsync(rootUrl, sceneFilename, scene, onProgress, pluginExtension, name, pluginOptions);
+    container.mergeAnimationsTo(scene, scene.animatables.slice(startingIndexForNewAnimatables), targetConverter);
+    container.dispose();
+    scene.onAnimationFileImportedObservable.notifyObservers(scene);
 }
 /**
  * Import animations from a file into a scene
@@ -809,7 +685,7 @@ async function importAnimationsImplAsync(rootUrl, sceneFilename = "", scene = En
  */
 export async function ImportAnimationsAsync(source, scene, options) {
     const { rootUrl = "", overwriteAnimations, animationGroupLoadingMode, targetConverter, onProgress, pluginExtension, name, pluginOptions } = options ?? {};
-    await importAnimationsSharedAsync(rootUrl, source, scene, overwriteAnimations, animationGroupLoadingMode, targetConverter, onProgress, pluginExtension, name, pluginOptions);
+    await importAnimationsCoreAsync(rootUrl, source, scene, overwriteAnimations, animationGroupLoadingMode, targetConverter, onProgress, pluginExtension, name, pluginOptions);
 }
 /**
  * Import animations from a file into a scene
@@ -822,25 +698,6 @@ export async function ImportAnimationsAsync(source, scene, options) {
 export async function importAnimationsAsync(source, scene, options) {
     return await ImportAnimationsAsync(source, scene, options);
 }
-// This function is shared between the new module level importAnimationsAsync and the legacy SceneLoader.ImportAnimationsAsync
-async function importAnimationsSharedAsync(rootUrl, sceneFilename, scene, overwriteAnimations, animationGroupLoadingMode, targetConverter, onProgress, pluginExtension, name, pluginOptions) {
-    return await new Promise((resolve, reject) => {
-        try {
-            importAnimationsImplAsync(rootUrl, sceneFilename, scene, overwriteAnimations, animationGroupLoadingMode, targetConverter, (scene) => {
-                resolve(scene);
-            }, onProgress, (scene, message, exception) => {
-                // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
-                reject(exception || new Error(message));
-            }, pluginExtension, name, pluginOptions
-            // eslint-disable-next-line github/no-then
-            ).catch(reject);
-        }
-        catch (error) {
-            // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
-            reject(error);
-        }
-    });
-}
 /**
  * Class used to load scene from various file formats using registered plugins
  * @see https://doc.babylonjs.com/features/featuresDeepDive/importers/loadingFileTypes
@@ -933,8 +790,16 @@ export class SceneLoader {
      * @deprecated Please use the module level {@link ImportMeshAsync} instead
      */
     static ImportMesh(meshNames, rootUrl, sceneFilename, scene, onSuccess, onProgress, onError, pluginExtension, name, pluginOptions) {
-        // eslint-disable-next-line github/no-then
-        importMeshAsync(meshNames, rootUrl, sceneFilename, scene, onSuccess, onProgress, onError, pluginExtension, name, pluginOptions).catch((error) => onError?.(EngineStore.LastCreatedScene, error?.message, error));
+        const reportScene = scene ?? EngineStore.LastCreatedScene;
+        void (async () => {
+            try {
+                const result = await importMeshCoreAsync(meshNames, rootUrl, sceneFilename, scene, onProgress, pluginExtension, name, pluginOptions);
+                onSuccess?.(result.meshes, result.particleSystems, result.skeletons, result.animationGroups, result.transformNodes, result.geometries, result.lights, result.spriteManagers);
+            }
+            catch (error) {
+                reportLegacyLoadError(onError, reportScene, error);
+            }
+        })();
     }
     /**
      * Import meshes into a scene
@@ -949,7 +814,7 @@ export class SceneLoader {
      * @deprecated Please use the module level {@link ImportMeshAsync} instead
      */
     static async ImportMeshAsync(meshNames, rootUrl, sceneFilename, scene, onProgress, pluginExtension, name) {
-        return await importMeshAsyncCoreAsync(meshNames, rootUrl, sceneFilename, scene, onProgress, pluginExtension, name);
+        return await importMeshCoreAsync(meshNames, rootUrl, sceneFilename, scene, onProgress, pluginExtension, name);
     }
     /**
      * Load a scene
@@ -964,8 +829,15 @@ export class SceneLoader {
      * @deprecated Please use the module level {@link LoadSceneAsync} instead
      */
     static Load(rootUrl, sceneFilename, engine, onSuccess, onProgress, onError, pluginExtension, name) {
-        // eslint-disable-next-line github/no-then
-        loadSceneImplAsync(rootUrl, sceneFilename, engine, onSuccess, onProgress, onError, pluginExtension, name).catch((error) => onError?.(EngineStore.LastCreatedScene, error?.message, error));
+        void (async () => {
+            try {
+                const scene = await loadSceneCoreAsync(rootUrl, sceneFilename, engine, onProgress, pluginExtension, name);
+                onSuccess?.(scene);
+            }
+            catch (error) {
+                reportLegacyLoadError(onError, EngineStore.LastCreatedScene, error);
+            }
+        })();
     }
     /**
      * Load a scene
@@ -979,7 +851,7 @@ export class SceneLoader {
      * @deprecated Please use the module level {@link LoadSceneAsync} instead
      */
     static async LoadAsync(rootUrl, sceneFilename, engine, onProgress, pluginExtension, name) {
-        return await loadSceneSharedAsync(rootUrl, sceneFilename, engine, onProgress, pluginExtension, name);
+        return await loadSceneCoreAsync(rootUrl, sceneFilename, engine, onProgress, pluginExtension, name);
     }
     /**
      * Append a scene
@@ -994,8 +866,16 @@ export class SceneLoader {
      * @deprecated Please use the module level {@link AppendSceneAsync} instead
      */
     static Append(rootUrl, sceneFilename, scene, onSuccess, onProgress, onError, pluginExtension, name) {
-        // eslint-disable-next-line github/no-then
-        appendSceneImplAsync(rootUrl, sceneFilename, scene, onSuccess, onProgress, onError, pluginExtension, name).catch((error) => onError?.((scene ?? EngineStore.LastCreatedScene), error?.message, error));
+        const reportScene = scene ?? EngineStore.LastCreatedScene;
+        void (async () => {
+            try {
+                const appendedScene = await appendSceneCoreAsync(rootUrl, sceneFilename, scene, onProgress, pluginExtension, name);
+                onSuccess?.(appendedScene);
+            }
+            catch (error) {
+                reportLegacyLoadError(onError, reportScene, error);
+            }
+        })();
     }
     /**
      * Append a scene
@@ -1009,7 +889,7 @@ export class SceneLoader {
      * @deprecated Please use the module level {@link AppendSceneAsync} instead
      */
     static async AppendAsync(rootUrl, sceneFilename, scene, onProgress, pluginExtension, name) {
-        return await appendSceneSharedAsync(rootUrl, sceneFilename, scene, onProgress, pluginExtension, name);
+        return await appendSceneCoreAsync(rootUrl, sceneFilename, scene, onProgress, pluginExtension, name);
     }
     /**
      * Load a scene into an asset container
@@ -1024,8 +904,16 @@ export class SceneLoader {
      * @deprecated Please use the module level {@link LoadAssetContainerAsync} instead
      */
     static LoadAssetContainer(rootUrl, sceneFilename, scene, onSuccess, onProgress, onError, pluginExtension, name) {
-        // eslint-disable-next-line github/no-then
-        loadAssetContainerImplAsync(rootUrl, sceneFilename, scene, onSuccess, onProgress, onError, pluginExtension, name).catch((error) => onError?.((scene ?? EngineStore.LastCreatedScene), error?.message, error));
+        const reportScene = scene ?? EngineStore.LastCreatedScene;
+        void (async () => {
+            try {
+                const assets = await loadAssetContainerCoreAsync(rootUrl, sceneFilename, scene, onProgress, pluginExtension, name);
+                onSuccess?.(assets);
+            }
+            catch (error) {
+                reportLegacyLoadError(onError, reportScene, error);
+            }
+        })();
     }
     /**
      * Load a scene into an asset container
@@ -1039,7 +927,7 @@ export class SceneLoader {
      * @deprecated Please use the module level {@link LoadAssetContainerAsync} instead
      */
     static async LoadAssetContainerAsync(rootUrl, sceneFilename, scene, onProgress, pluginExtension, name) {
-        return await loadAssetContainerSharedAsync(rootUrl, sceneFilename, scene, onProgress, pluginExtension, name);
+        return await loadAssetContainerCoreAsync(rootUrl, sceneFilename, scene, onProgress, pluginExtension, name);
     }
     /**
      * Import animations from a file into a scene
@@ -1057,9 +945,16 @@ export class SceneLoader {
      * @deprecated Please use the module level {@link ImportAnimationsAsync} instead
      */
     static ImportAnimations(rootUrl, sceneFilename, scene, overwriteAnimations, animationGroupLoadingMode, targetConverter, onSuccess, onProgress, onError, pluginExtension, name) {
-        importAnimationsImplAsync(rootUrl, sceneFilename, scene, overwriteAnimations, animationGroupLoadingMode, targetConverter, onSuccess, onProgress, onError, pluginExtension, name
-        // eslint-disable-next-line github/no-then
-        ).catch((error) => onError?.((scene ?? EngineStore.LastCreatedScene), error?.message, error));
+        const reportScene = scene ?? EngineStore.LastCreatedScene;
+        void (async () => {
+            try {
+                await importAnimationsCoreAsync(rootUrl, sceneFilename, scene, overwriteAnimations, animationGroupLoadingMode, targetConverter, onProgress, pluginExtension, name);
+                onSuccess?.(reportScene);
+            }
+            catch (error) {
+                reportLegacyLoadError(onError, reportScene, error);
+            }
+        })();
     }
     /**
      * Import animations from a file into a scene
@@ -1082,7 +977,9 @@ export class SceneLoader {
     onSuccess, onProgress, 
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     onError, pluginExtension, name) {
-        return await importAnimationsSharedAsync(rootUrl, sceneFilename, scene, overwriteAnimations, animationGroupLoadingMode, targetConverter, onProgress, pluginExtension, name);
+        const targetScene = scene ?? EngineStore.LastCreatedScene;
+        await importAnimationsCoreAsync(rootUrl, sceneFilename, targetScene, overwriteAnimations, animationGroupLoadingMode, targetConverter, onProgress, pluginExtension, name);
+        return targetScene;
     }
 }
 /**