deduplicate some assetloader code

Author: aecsocket

crates/bevy_asset/src/loader_builders.rs

@@ -131,7 +131,7 @@ mod sealed {
 /// [`NestedLoader`] will be provided the type of asset as a type parameter on
 /// [`load`].
 ///
-/// [`load`]: Self::load
+/// [`load`]: NestedLoader::load
 pub struct Typed {
     _priv: (),
 }
@@ -257,7 +257,7 @@ impl<'ctx, 'builder, T: sealed::Typing, M: sealed::Mode> NestedLoader<'ctx, 'bui
     ///
     /// [`load`]: Self::load
     #[must_use]
-    pub fn of_unknown_type(self) -> NestedLoader<'ctx, 'builder, UnknownType, M> {
+    pub fn unknown_type(self) -> NestedLoader<'ctx, 'builder, UnknownType, M> {
         NestedLoader {
             load_context: self.load_context,
             meta_transform: self.meta_transform,

crates/bevy_asset/src/server/mod.rs

@@ -20,7 +20,7 @@ use crate::{
 use alloc::sync::Arc;
 use atomicow::CowArc;
 use bevy_ecs::prelude::*;
-use bevy_tasks::IoTaskPool;
+use bevy_tasks::{IoTaskPool, Task};
 use bevy_utils::{
     tracing::{error, info},
     HashSet,
@@ -382,14 +382,7 @@ impl AssetServer {
         );
 
         if should_load {
-            let owned_handle = Some(handle.clone().untyped());
-            let server = self.clone();
-            let task = IoTaskPool::get().spawn(async move {
-                if let Err(err) = server.load_internal(owned_handle, path, false, None).await {
-                    error!("{}", err);
-                }
-                drop(guard);
-            });
+            let task = self.spawn_load_task(handle.clone().untyped(), path, guard);
 
             #[cfg(not(any(target_arch = "wasm32", not(feature = "multi_threaded"))))]
             infos.pending_tasks.insert(handle.id().untyped(), task);
@@ -420,14 +413,7 @@ impl AssetServer {
         );
 
         if should_load {
-            let owned_handle = Some(handle.clone());
-            let server = self.clone();
-            let task = IoTaskPool::get().spawn(async move {
-                if let Err(err) = server.load_internal(owned_handle, path, false, None).await {
-                    error!("{}", err);
-                }
-                drop(guard);
-            });
+            let task = self.spawn_load_task(handle.clone(), path, guard);
 
             #[cfg(not(any(target_arch = "wasm32", not(feature = "multi_threaded"))))]
             infos.pending_tasks.insert(handle.id(), task);
@@ -439,6 +425,21 @@ impl AssetServer {
         handle
     }
 
+    pub(crate) fn spawn_load_task<G: Send + Sync + 'static>(
+        &self,
+        handle: UntypedHandle,
+        path: AssetPath<'static>,
+        guard: G,
+    ) -> Task<()> {
+        let server = self.clone();
+        IoTaskPool::get().spawn(async move {
+            if let Err(err) = server.load_internal(Some(handle), path, false, None).await {
+                error!("{}", err);
+            }
+            drop(guard);
+        })
+    }
+
     /// Asynchronously load an asset that you do not know the type of statically. If you _do_ know the type of the asset,
     /// you should use [`AssetServer::load`]. If you don't know the type of the asset, but you can't use an async method,
     /// consider using [`AssetServer::load_untyped`].

examples/asset/asset_decompression.rs

@@ -72,7 +72,7 @@ impl AssetLoader for GzAssetLoader {
 
         let uncompressed = load_context
             .loader()
-            .of_unknown_type()
+            .unknown_type()
             .immediate()
             .with_reader(&mut reader)
             .load(contained_path)