Add File / FileReader polyfill

CMakeLists.txt

@@ -21,6 +21,10 @@ FetchContent_Declare(asio
     GIT_REPOSITORY https://github.com/chriskohlhoff/asio.git
     GIT_TAG f693a3eb7fe72a5f19b975289afc4f437d373d9c
     EXCLUDE_FROM_ALL)
+FetchContent_Declare(base-n
+    GIT_REPOSITORY https://github.com/azawadzki/base-n.git
+    GIT_TAG 7573e77c0b9b0e8a5fb63d96dbde212c921993b4
+    EXCLUDE_FROM_ALL)
 FetchContent_Declare(CMakeExtensions
     GIT_REPOSITORY https://github.com/BabylonJS/CMakeExtensions.git
     GIT_TAG dc750e7f69dad76779419df6442f834c57a30a1f
@@ -80,6 +84,7 @@ option(JSRUNTIMEHOST_POLYFILL_URL "Include JsRuntimeHost Polyfill URL and URLSea
 option(JSRUNTIMEHOST_POLYFILL_ABORT_CONTROLLER "Include JsRuntimeHost Polyfills AbortController and AbortSignal." ON)
 option(JSRUNTIMEHOST_POLYFILL_WEBSOCKET "Include JsRuntimeHost Polyfill WebSocket." ON)
 option(JSRUNTIMEHOST_POLYFILL_BLOB "Include JsRuntimeHost Polyfill Blob." ON)
+option(JSRUNTIMEHOST_POLYFILL_FILE "Include JsRuntimeHost Polyfill File and FileReader." ON)
 option(JSRUNTIMEHOST_POLYFILL_PERFORMANCE "Include JsRuntimeHost Polyfill Performance." ON)
 option(JSRUNTIMEHOST_POLYFILL_TEXTDECODER "Include JsRuntimeHost Polyfill TextDecoder." ON)
 option(JSRUNTIMEHOST_POLYFILL_TEXTENCODER "Include JsRuntimeHost Polyfill TextEncoder." ON)
@@ -140,6 +145,13 @@ if(JSRUNTIMEHOST_POLYFILL_XMLHTTPREQUEST)
     set_property(TARGET UrlLib PROPERTY FOLDER Dependencies)
 endif()
 
+if(JSRUNTIMEHOST_POLYFILL_FILE)
+    FetchContent_MakeAvailable_With_Message(base-n)
+    add_library(base-n INTERFACE)
+    target_include_directories(base-n INTERFACE "${base-n_SOURCE_DIR}/include")
+    set_property(TARGET base-n PROPERTY FOLDER Dependencies)
+endif()
+
 if(BABYLON_DEBUG_TRACE)
     add_definitions(-DBABYLON_DEBUG_TRACE)
 endif()

Polyfills/CMakeLists.txt

@@ -26,6 +26,10 @@ if(JSRUNTIMEHOST_POLYFILL_BLOB)
     add_subdirectory(Blob)
 endif()
 
+if(JSRUNTIMEHOST_POLYFILL_FILE)
+    add_subdirectory(File)
+endif()
+
 if(JSRUNTIMEHOST_POLYFILL_PERFORMANCE)
     add_subdirectory(Performance)
 endif()

Polyfills/File/CMakeLists.txt

@@ -0,0 +1,18 @@
+set(SOURCES
+    "Include/Babylon/Polyfills/File.h"
+    "Source/File.h"
+    "Source/File.cpp"
+    "Source/FileReader.h"
+    "Source/FileReader.cpp")
+
+add_library(File ${SOURCES})
+warnings_as_errors(File)
+
+target_include_directories(File PUBLIC "Include")
+
+target_link_libraries(File
+    PRIVATE base-n
+    PUBLIC JsRuntime)
+
+set_property(TARGET File PROPERTY FOLDER Polyfills)
+source_group(TREE ${CMAKE_CURRENT_SOURCE_DIR} FILES ${SOURCES})

Polyfills/File/Include/Babylon/Polyfills/File.h

@@ -0,0 +1,9 @@
+#pragma once
+
+#include <napi/env.h>
+#include <Babylon/Api.h>
+
+namespace Babylon::Polyfills::File
+{
+    void BABYLON_API Initialize(Napi::Env env);
+}

Polyfills/File/Readme.md

@@ -0,0 +1,35 @@
+# File
+
+Implements the `File` and `FileReader` web APIs on top of the native `Blob`
+polyfill provided by JsRuntimeHost. Babylon.js GLTF/OBJ serializer
+round-trip codepaths construct `new File([blob], 'scene.glb')` and read it
+back via `FileReader.readAsArrayBuffer(...)`, so the runtime needs both
+constructors for those tests (and any consumer code that wraps serializer
+output) to work.
+
+## Behaviour
+
+* No-op when the runtime already exposes a global `File` / `FileReader`
+  (e.g. V8 in some embeddings).
+* `File` is self-contained: the constructor delegates to the global
+  `Blob` constructor to build the underlying byte storage, then decorates
+  the instance with `name` and `lastModified`. Methods (`size`, `type`,
+  `arrayBuffer`, `text`, `bytes`) forward to the inner `Blob`.
+* `FileReader` supports `readAsArrayBuffer`, `readAsText`, and
+  `readAsDataURL`, plus `abort`, `addEventListener` /
+  `removeEventListener` / `dispatchEvent`, and the standard `onload` /
+  `onerror` / `onloadstart` / `onloadend` / `onprogress` / `onabort`
+  handler slots. `abort()` invalidates in-flight reads via a monotonic
+  token so late-resolving `arrayBuffer()` promises cannot dispatch a
+  phantom `load` event after a user-initiated abort.
+* `File` extends `Blob`: the JS-visible prototype chain is wired so
+  `new File(...) instanceof Blob === true`. Babylon.js core branches on
+  `instanceof Blob` in several places (fileTools, Offline/database,
+  abstractEngine, thinNativeEngine).
+
+## Prerequisites
+
+`Babylon::Polyfills::Blob::Initialize(env)` (from JsRuntimeHost) must be
+called before `Babylon::Polyfills::File::Initialize(env)`; if `Blob` is
+missing from the global object when `File::Initialize` runs, the `File`
+constructor will not be registered.

Polyfills/File/Source/File.cpp

@@ -0,0 +1,185 @@
+#include "File.h"
+#include "FileReader.h"
+
+#include <Babylon/Polyfills/File.h>
+
+#include <chrono>
+#include <string>
+
+namespace Babylon::Polyfills::Internal
+{
+    namespace
+    {
+        constexpr auto JS_FILE_CONSTRUCTOR_NAME = "File";
+        constexpr auto JS_BLOB_CONSTRUCTOR_NAME = "Blob";
+    }
+
+    void File::Initialize(Napi::Env env)
+    {
+        auto global = env.Global();
+
+        // No-op if the runtime already provides a global File. Cheapest
+        // check, and the common path on platforms with a native File.
+        if (!global.Get(JS_FILE_CONSTRUCTOR_NAME).IsUndefined())
+        {
+            return;
+        }
+
+        // Require the native Blob polyfill: File delegates byte storage to
+        // a Blob, so without it the constructor cannot produce useful
+        // instances. Use IsUndefined() rather than IsFunction() because
+        // some JavaScriptCore builds (notably libjavascriptcoregtk on
+        // Linux) classify constructors created via JSObjectMakeConstructor
+        // as typeof 'object', not 'function', so napi_typeof returns
+        // napi_object for them.
+        auto blob = global.Get(JS_BLOB_CONSTRUCTOR_NAME);
+        if (blob.IsUndefined() || blob.IsNull())
+        {
+            throw Napi::Error::New(env,
+                "File polyfill requires the Blob polyfill to be installed first.");
+        }
+
+        Napi::Function func = DefineClass(
+            env,
+            JS_FILE_CONSTRUCTOR_NAME,
+            {
+                InstanceAccessor("size", &File::GetSize, nullptr),
+                InstanceAccessor("type", &File::GetType, nullptr),
+                InstanceAccessor("name", &File::GetName, nullptr),
+                InstanceAccessor("lastModified", &File::GetLastModified, nullptr),
+                InstanceMethod("arrayBuffer", &File::ArrayBuffer),
+                InstanceMethod("text", &File::Text),
+                InstanceMethod("bytes", &File::Bytes),
+            });
+
+        global.Set(JS_FILE_CONSTRUCTOR_NAME, func);
+
+        // Wire File.prototype's [[Prototype]] to Blob.prototype so
+        // `new File(...) instanceof Blob === true`. WHATWG specs File as
+        // a Blob subtype; BJS core (fileTools, Offline/database,
+        // abstractEngine, thinNativeEngine) branches on `instanceof Blob`
+        // and needs File inputs to satisfy that check.
+        auto setPrototypeOf = env.Global().Get("Object").As<Napi::Object>()
+            .Get("setPrototypeOf").As<Napi::Function>();
+        setPrototypeOf.Call({
+            func.Get("prototype"),
+            blob.As<Napi::Function>().Get("prototype"),
+        });
+    }
+
+    File::File(const Napi::CallbackInfo& info)
+        : Napi::ObjectWrap<File>{info}
+    {
+        auto env = info.Env();
+
+        // The WHATWG File constructor takes (fileBits, fileName, [options]).
+        // Both fileBits and fileName are required (USVString without
+        // `optional`), so missing either is a TypeError per WebIDL bindings.
+        if (info.Length() < 2)
+        {
+            throw Napi::TypeError::New(env,
+                "Failed to construct 'File': 2 arguments required, but only " +
+                std::to_string(info.Length()) + " present.");
+        }
+
+        Napi::Value parts = info[0];
+        Napi::Value name = info[1];
+        Napi::Value options = info.Length() > 2 ? info[2] : env.Undefined();
+
+        // USVString conversion: undefined -> "undefined", null -> "null",
+        // numbers/objects -> their .toString() representation. Napi::Value::
+        // ToString() routes through napi_coerce_to_string, which matches
+        // these semantics on all three engines.
+        m_name = name.ToString().Utf8Value();
+
+        // Default lastModified to the current wall clock in milliseconds,
+        // matching Date.now() semantics used by the JS File constructor.
+        m_lastModified = static_cast<double>(
+            std::chrono::duration_cast<std::chrono::milliseconds>(
+                std::chrono::system_clock::now().time_since_epoch())
+                .count());
+
+        auto blobOptions = Napi::Object::New(env);
+
+        if (options.IsObject())
+        {
+            auto optsObj = options.As<Napi::Object>();
+            if (optsObj.Has("type"))
+            {
+                blobOptions.Set("type", optsObj.Get("type"));
+            }
+            if (optsObj.Has("lastModified"))
+            {
+                auto lm = optsObj.Get("lastModified");
+                if (lm.IsNumber())
+                {
+                    m_lastModified = lm.As<Napi::Number>().DoubleValue();
+                }
+            }
+        }
+
+        Napi::Value partsArray;
+        if (parts.IsArray())
+        {
+            partsArray = parts;
+        }
+        else
+        {
+            partsArray = Napi::Array::New(env, 0);
+        }
+
+        // Delegate byte-buffer construction to the native Blob polyfill so
+        // we benefit from its existing BlobPart handling (ArrayBuffer,
+        // typed array, string, Blob).
+        auto blobCtor = env.Global().Get(JS_BLOB_CONSTRUCTOR_NAME).As<Napi::Function>();
+        auto blobInstance = blobCtor.New({partsArray, blobOptions});
+        m_blob = Napi::Persistent(blobInstance);
+    }
+
+    Napi::Value File::GetSize(const Napi::CallbackInfo&)
+    {
+        return m_blob.Value().Get("size");
+    }
+
+    Napi::Value File::GetType(const Napi::CallbackInfo&)
+    {
+        return m_blob.Value().Get("type");
+    }
+
+    Napi::Value File::GetName(const Napi::CallbackInfo& info)
+    {
+        return Napi::String::New(info.Env(), m_name);
+    }
+
+    Napi::Value File::GetLastModified(const Napi::CallbackInfo& info)
+    {
+        return Napi::Number::New(info.Env(), m_lastModified);
+    }
+
+    Napi::Value File::ArrayBuffer(const Napi::CallbackInfo&)
+    {
+        auto blob = m_blob.Value();
+        return blob.Get("arrayBuffer").As<Napi::Function>().Call(blob, {});
+    }
+
+    Napi::Value File::Text(const Napi::CallbackInfo&)
+    {
+        auto blob = m_blob.Value();
+        return blob.Get("text").As<Napi::Function>().Call(blob, {});
+    }
+
+    Napi::Value File::Bytes(const Napi::CallbackInfo&)
+    {
+        auto blob = m_blob.Value();
+        return blob.Get("bytes").As<Napi::Function>().Call(blob, {});
+    }
+}
+
+namespace Babylon::Polyfills::File
+{
+    void BABYLON_API Initialize(Napi::Env env)
+    {
+        Internal::File::Initialize(env);
+        Internal::FileReader::Initialize(env);
+    }
+}

Polyfills/File/Source/File.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <napi/napi.h>
+
+#include <string>
+
+namespace Babylon::Polyfills::Internal
+{
+    class File final : public Napi::ObjectWrap<File>
+    {
+    public:
+        static void Initialize(Napi::Env env);
+
+        explicit File(const Napi::CallbackInfo& info);
+
+    private:
+        Napi::Value GetSize(const Napi::CallbackInfo& info);
+        Napi::Value GetType(const Napi::CallbackInfo& info);
+        Napi::Value GetName(const Napi::CallbackInfo& info);
+        Napi::Value GetLastModified(const Napi::CallbackInfo& info);
+
+        Napi::Value ArrayBuffer(const Napi::CallbackInfo& info);
+        Napi::Value Text(const Napi::CallbackInfo& info);
+        Napi::Value Bytes(const Napi::CallbackInfo& info);
+
+        Napi::ObjectReference m_blob;
+        std::string m_name;
+        double m_lastModified{0.0};
+    };
+}