@woosh/meep-engine 2.100.1 → 2.100.3

package/build/meep.cjs

@@ -67748,6 +67748,83 @@ class AssetLoader {
     }
 }
 
+/**
+ *
+ * @param {Response} input
+ * @param {function} progress
+ * @return {Response}
+ */
+function observeResponseProgress(input, progress) {
+    let response = input;
+
+
+    if (typeof ReadableStream === 'undefined' || response.body.getReader === undefined) {
+
+        return response;
+
+    }
+
+    /**
+     * @type {ReadableStreamDefaultReader<Uint8Array>}
+     */
+    const reader = response.body.getReader();
+
+    const contentLength = response.headers.get('Content-Length');
+    const total = contentLength ? parseInt(contentLength) : 0;
+    let loaded = 0;
+
+    // periodically read data into the new stream tracking while download progress
+    const stream_prototype = {
+        type: "bytes",
+        start(controller) {
+
+            pump();
+
+            function pump() {
+
+                reader.read().then(({ done, value }) => {
+
+                    if (done) {
+                        // no more data, we're done
+                        controller.close();
+                        return;
+                    }
+
+                    loaded += value.byteLength;
+
+                    progress(loaded, total);
+
+                    controller.enqueue(value);
+                    pump();
+
+                });
+
+            }
+
+        }
+
+    };
+
+    /**
+     * @type {ReadableStream}
+     */
+    let stream;
+
+    try {
+        stream = new ReadableStream(stream_prototype);
+
+        response = new Response(stream);
+    } catch (e) {
+        /*
+         Workaround for Safari bug: "TypeError: ReadableByteStreamController is not implemented"
+         By not wrapping the response we lose the ability to track progress, but that's not a critical issue in most cases
+         */
+    }
+
+    return response;
+
+}
+
 class ArrayBufferLoader extends AssetLoader {
     /**
      *
@@ -67766,7 +67843,13 @@ class ArrayBufferLoader extends AssetLoader {
         this.__fetch_priority = fetch_priority;
     }
 
-    load(scope, path, success, failure = console.error, progress = noop) {
+    async load(
+        scope,
+        path,
+        success,
+        failure = console.error,
+        progress = noop
+    ) {
         const coc = this.assetManager !== null ? this.assetManager.crossOriginConfig : CrossOriginConfig.default;
 
         const headers = new Headers();
@@ -67781,93 +67864,36 @@ class ArrayBufferLoader extends AssetLoader {
             request.priority = this.__fetch_priority;
         }
 
-        fetch(request)
-            .then(handle_response)
-            .then(response_to_asset)
-            .catch(failure);
+        let response = await fetch(request);
 
-        /**
-         *
-         * @param {Response} response
-         * @return {Promise<void>}
-         */
-        async function response_to_asset(response) {
-            const arrayBuffer = await response.arrayBuffer();
+        if (!(response.status === 200 || response.status === 0)) {
 
-            const asset = new Asset(
-                function () {
-                    return arrayBuffer;
-                },
-                arrayBuffer.byteSize
-            );
+            throw Error(`fetch for "${response.url}" responded with ${response.status}: ${response.statusText}`);
 
-            success(asset);
         }
 
-        /**
-         *
-         * @param {Response} response
-         * @return {Response}
-         */
-        function handle_response(response) {
-            if (!(response.status === 200 || response.status === 0)) {
-
-                throw Error(`fetch for "${response.url}" responded with ${response.status}: ${response.statusText}`);
-
-            }
-
-            // Some browsers return HTTP Status 0 when using non-http protocol
-            // e.g. 'file://' or 'data://'. Handle as success.
-
-            if (response.status === 0) ;
-
-            if (typeof ReadableStream === 'undefined' || response.body.getReader === undefined) {
-
-                return response;
-
-            }
-
-            const reader = response.body.getReader();
-            const contentLength = response.headers.get('Content-Length');
-            const total = contentLength ? parseInt(contentLength) : 0;
-            let loaded = 0;
-
-            // periodically read data into the new stream tracking while download progress
-            const stream = new ReadableStream({
-                type: "bytes",
-                start(controller) {
-
-                    pump();
-
-                    function pump() {
-
-                        reader.read().then(({ done, value }) => {
-
-                            if (done) {
-                                // no more data, we're done
-                                controller.close();
-                                return;
-                            }
-
-                            loaded += value.byteLength;
+        // Some browsers return HTTP Status 0 when using non-http protocol
+        // e.g. 'file://' or 'data://'. Handle as success.
 
-                            progress(loaded, total);
+        if (response.status === 0) ;
 
-                            controller.enqueue(value);
-                            pump();
-
-                        });
-
-                    }
-
-                }
+        try {
+            response = observeResponseProgress(response, progress);
+        } catch (e) {
+        }
 
-            });
+        const arrayBuffer = await response.arrayBuffer();
 
-            return new Response(stream);
-        }
+        const asset = new Asset(
+            function () {
+                return arrayBuffer;
+            },
+            arrayBuffer.byteSize
+        );
 
+        success(asset);
 
+        return asset;
     }
 }
 
@@ -86225,7 +86251,12 @@ class AssetManager {
         try {
 
 
-            loader.load(scope, full_path, success, failure, progress);
+            const result = loader.load(scope, full_path, success, failure, progress);
+
+            if (result instanceof Promise) {
+                // allow promise responses
+                result.catch(failure);
+            }
 
         } catch (e) {
             failure(e);