@babylonjs/react-native 2.0.0 → 2.0.1-preview

package/shared/BabylonNative/deps/bgfx.cmake-src/cmake/bgfx/3rdparty/tint.cmake

@@ -0,0 +1,98 @@
+# bgfx.cmake - bgfx building in cmake
+# Written in 2017 by Joshua Brookover <joshua.al.brookover@gmail.com>
+#
+# To the extent possible under law, the author(s) have dedicated all copyright
+# and related and neighboring rights to this software to the public domain
+# worldwide. This software is distributed without any warranty.
+#
+# You should have received a copy of the CC0 Public Domain Dedication along with
+# this software. If not, see <http://creativecommons.org/publicdomain/zero/1.0/>.
+
+if(TARGET tint)
+	return()
+endif()
+
+if(NOT IS_DIRECTORY ${BGFX_DIR})
+	message(SEND_ERROR "Could not load bgfx, directory does not exist. ${BGFX_DIR}")
+	return()
+endif()
+
+set(TINT_DIR ${BGFX_DIR}/3rdparty/dawn)
+set(SPIRV_HEADERS ${BGFX_DIR}/3rdparty/spirv-headers)
+set(SPIRV_TOOLS ${BGFX_DIR}/3rdparty/spirv-tools)
+
+file(
+	GLOB_RECURSE
+	TINT_SOURCES
+	${TINT_DIR}/src/tint/utils/*.cc
+	${TINT_DIR}/src/tint/utils/*.h
+	${TINT_DIR}/src/tint/lang/core/*.cc
+	${TINT_DIR}/src/tint/lang/core/*.h
+	${TINT_DIR}/src/tint/lang/null/*.cc
+	${TINT_DIR}/src/tint/lang/null/*.h
+	${TINT_DIR}/src/tint/lang/spirv/*.cc
+	${TINT_DIR}/src/tint/lang/spirv/*.h
+	${TINT_DIR}/src/tint/lang/wgsl/*.cc
+	${TINT_DIR}/src/tint/lang/wgsl/*.h
+	${TINT_DIR}/src/tint/api/*.cc
+	${TINT_DIR}/src/tint/api/*.h
+)
+
+add_library(tint STATIC ${TINT_SOURCES})
+
+set_target_properties(tint PROPERTIES FOLDER "bgfx")
+
+target_include_directories(
+	tint
+	PUBLIC ${TINT_DIR}
+		   ${TINT_DIR}/src/tint
+	PRIVATE ${TINT_DIR}/third_party/protobuf/src
+			${TINT_DIR}/third_party/abseil-cpp
+			${SPIRV_TOOLS}
+			${SPIRV_TOOLS}/include
+			${SPIRV_TOOLS}/include/generated
+			${SPIRV_HEADERS}/include
+)
+
+target_compile_definitions(
+	tint
+	PRIVATE TINT_BUILD_GLSL_WRITER=0
+			TINT_BUILD_HLSL_WRITER=0
+			TINT_BUILD_MSL_WRITER=0
+			TINT_BUILD_NULL_WRITER=0
+			TINT_BUILD_SPV_READER=1
+			TINT_BUILD_SPV_WRITER=0
+			TINT_BUILD_WGSL_READER=0
+			TINT_BUILD_WGSL_WRITER=1
+			TINT_ENABLE_IR_VALIDATION=0
+)
+
+if(WIN32)
+	target_compile_definitions(
+		tint
+		PRIVATE TINT_BUILD_IS_LINUX=0
+				TINT_BUILD_IS_MAC=0
+				TINT_BUILD_IS_WIN=1
+	)
+elseif(APPLE)
+	target_compile_definitions(
+		tint
+		PRIVATE TINT_BUILD_IS_LINUX=0
+				TINT_BUILD_IS_MAC=1
+				TINT_BUILD_IS_WIN=0
+	)
+else()
+	target_compile_definitions(
+		tint
+		PRIVATE TINT_BUILD_IS_LINUX=1
+				TINT_BUILD_IS_MAC=0
+				TINT_BUILD_IS_WIN=0
+	)
+endif()
+
+if(MSVC)
+	target_compile_options(
+		tint
+		PRIVATE "/Zc:preprocessor"
+	)
+endif()

package/shared/BabylonNative/deps/bgfx.cmake-src/cmake/bgfx/CMakeLists.txt

@@ -26,6 +26,7 @@ if(BGFX_BUILD_TOOLS_SHADER)
 	include(3rdparty/glsl-optimizer.cmake)
 	include(3rdparty/fcpp.cmake)
 	include(3rdparty/webgpu.cmake)
+	include(3rdparty/tint.cmake)
 	include(shaderc.cmake)
 endif()
 

package/shared/BabylonNative/deps/bgfx.cmake-src/cmake/bgfx/bgfx.cmake

@@ -19,22 +19,25 @@ if(NOT IS_DIRECTORY ${BGFX_DIR})
 	return()
 endif()
 
-if(NOT APPLE)
-	set(BGFX_AMALGAMATED_SOURCE ${BGFX_DIR}/src/amalgamated.cpp)
-else()
-	set(BGFX_AMALGAMATED_SOURCE ${BGFX_DIR}/src/amalgamated.mm)
-endif()
-
 # Grab the bgfx source files
 file(
 	GLOB
 	BGFX_SOURCES
 	${BGFX_DIR}/src/*.cpp
-	${BGFX_DIR}/src/*.mm
 	${BGFX_DIR}/src/*.h
 	${BGFX_DIR}/include/bgfx/*.h
 	${BGFX_DIR}/include/bgfx/c99/*.h
 )
+
+if(APPLE)
+	file(GLOB BGFX_OBJC_SOURCES ${BGFX_DIR}/src/*.mm)
+	list(APPEND BGFX_SOURCES ${BGFX_OBJC_SOURCES})
+	list(REMOVE_ITEM BGFX_SOURCES ${BGFX_DIR}/src/amalgamated.cpp)
+	set(BGFX_AMALGAMATED_SOURCE ${BGFX_DIR}/src/amalgamated.mm)
+else()
+	set(BGFX_AMALGAMATED_SOURCE ${BGFX_DIR}/src/amalgamated.cpp)
+endif()
+
 if(BGFX_AMALGAMATED)
 	set(BGFX_NOBUILD ${BGFX_SOURCES})
 	list(REMOVE_ITEM BGFX_NOBUILD ${BGFX_AMALGAMATED_SOURCE})
@@ -43,8 +46,7 @@ if(BGFX_AMALGAMATED)
 	endforeach()
 else()
 	# Do not build using amalgamated sources
-	set_source_files_properties(${BGFX_DIR}/src/amalgamated.cpp PROPERTIES HEADER_FILE_ONLY ON)
-	set_source_files_properties(${BGFX_DIR}/src/amalgamated.mm PROPERTIES HEADER_FILE_ONLY ON)
+	set_source_files_properties(${BGFX_AMALGAMATED_SOURCE} PROPERTIES HEADER_FILE_ONLY ON)
 endif()
 
 # Create the bgfx target

package/shared/BabylonNative/deps/bgfx.cmake-src/cmake/bgfx/examples.cmake

@@ -31,6 +31,8 @@ function(add_bgfx_shader FILE FOLDER)
 		set(COMMON FILE ${FILE} ${TYPE} INCLUDES ${BGFX_DIR}/src)
 		set(OUTPUTS "")
 		set(OUTPUTS_PRETTY "")
+		set(OUTPUT_FILES "")
+		set(COMMANDS "")
 
 		if(WIN32)
 			# dx11
@@ -85,11 +87,15 @@ function(add_bgfx_shader FILE FOLDER)
 			set(SPIRV_OUTPUT ${BGFX_DIR}/examples/runtime/shaders/spirv/${FILENAME}.bin)
 			_bgfx_shaderc_parse(SPIRV ${COMMON} LINUX PROFILE spirv OUTPUT ${SPIRV_OUTPUT})
 			list(APPEND OUTPUTS "SPIRV")
-			set(OUTPUTS_PRETTY "${OUTPUTS_PRETTY}SPIRV")
-			set(OUTPUT_FILES "")
-			set(COMMANDS "")
+			set(OUTPUTS_PRETTY "${OUTPUTS_PRETTY}SPIRV, ")
 		endif()
 
+		# wgsl
+		set(WGSL_OUTPUT ${BGFX_DIR}/examples/runtime/shaders/wgsl/${FILENAME}.bin)
+		_bgfx_shaderc_parse(WGSL ${COMMON} LINUX PROFILE wgsl OUTPUT ${WGSL_OUTPUT})
+		list(APPEND OUTPUTS "WGSL")
+		set(OUTPUTS_PRETTY "${OUTPUTS_PRETTY}WGSL")
+
 		foreach(OUT ${OUTPUTS})
 			list(APPEND OUTPUT_FILES ${${OUT}_OUTPUT})
 			list(APPEND COMMANDS COMMAND "bgfx::shaderc" ${${OUT}})
@@ -163,38 +169,44 @@ function(add_example ARG_NAME)
 				# on iOS we need to build a bundle so have to copy the data rather than symlink
 				# and on windows we can't create symlinks
 				add_custom_command(
-					TARGET example-${ARG_NAME} COMMAND ${CMAKE_COMMAND} -E copy_directory ${BGFX_DIR}/examples/runtime/
+					TARGET example-${ARG_NAME} POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy_directory ${BGFX_DIR}/examples/runtime/
 													   $<TARGET_FILE_DIR:example-${ARG_NAME}>
 				)
 			else()
 				# For everything else symlink some folders into our output directory
 				add_custom_command(
 					TARGET example-${ARG_NAME}
+					POST_BUILD
 					COMMAND ${CMAKE_COMMAND} -E create_symlink ${BGFX_DIR}/examples/runtime/font
 							$<TARGET_FILE_DIR:example-${ARG_NAME}>/font
 				)
 				add_custom_command(
 					TARGET example-${ARG_NAME}
+					POST_BUILD
 					COMMAND ${CMAKE_COMMAND} -E create_symlink ${BGFX_DIR}/examples/runtime/images
 							$<TARGET_FILE_DIR:example-${ARG_NAME}>/images
 				)
 				add_custom_command(
 					TARGET example-${ARG_NAME}
+					POST_BUILD
 					COMMAND ${CMAKE_COMMAND} -E create_symlink ${BGFX_DIR}/examples/runtime/meshes
 							$<TARGET_FILE_DIR:example-${ARG_NAME}>/meshes
 				)
 				add_custom_command(
 					TARGET example-${ARG_NAME}
+					POST_BUILD
 					COMMAND ${CMAKE_COMMAND} -E create_symlink ${BGFX_DIR}/examples/runtime/shaders
 							$<TARGET_FILE_DIR:example-${ARG_NAME}>/shaders
 				)
 				add_custom_command(
 					TARGET example-${ARG_NAME}
+					POST_BUILD
 					COMMAND ${CMAKE_COMMAND} -E create_symlink ${BGFX_DIR}/examples/runtime/text
 							$<TARGET_FILE_DIR:example-${ARG_NAME}>/text
 				)
 				add_custom_command(
 					TARGET example-${ARG_NAME}
+					POST_BUILD
 					COMMAND ${CMAKE_COMMAND} -E create_symlink ${BGFX_DIR}/examples/runtime/textures
 							$<TARGET_FILE_DIR:example-${ARG_NAME}>/textures
 				)

package/shared/BabylonNative/deps/bgfx.cmake-src/cmake/bgfx/shaderc.cmake

@@ -19,16 +19,6 @@ file(
 
 add_executable(shaderc ${SHADERC_SOURCES})
 
-target_link_libraries(
-	shaderc
-	PRIVATE bx
-			bgfx-vertexlayout
-			fcpp
-			glslang
-			glsl-optimizer
-			spirv-opt
-			spirv-cross
-)
 target_link_libraries(
 	shaderc
 	PRIVATE bx
@@ -40,7 +30,28 @@ target_link_libraries(
 			spirv-opt
 			spirv-cross
 			webgpu
+			tint
+)
+
+target_include_directories(
+	shaderc
+	PRIVATE ${BGFX_DIR}/3rdparty/dawn
+			${BGFX_DIR}/3rdparty/dawn/src
 )
+
+if(UNIX
+   AND NOT APPLE
+   AND NOT EMSCRIPTEN
+   AND NOT ANDROID
+)
+	target_include_directories(
+		shaderc
+		PRIVATE ${BGFX_DIR}/3rdparty/directx-headers/include/directx
+				${BGFX_DIR}/3rdparty/directx-headers/include
+				${BGFX_DIR}/3rdparty/directx-headers/include/wsl/stubs
+	)
+endif()
+
 if(BGFX_AMALGAMATED)
 	target_link_libraries(shaderc PRIVATE bgfx-shader)
 endif()

package/shared/BabylonNative/deps/bgfx.cmake-src/cmake/bx/bx.cmake

@@ -60,6 +60,11 @@ endforeach()
 
 add_library(bx STATIC ${BX_SOURCES})
 
+if(MSVC)
+	target_compile_options(bx PRIVATE /EHs-c-)
+	target_compile_definitions(bx PRIVATE _HAS_EXCEPTIONS=0)
+endif()
+
 # Put in a "bgfx" folder in Visual Studio
 set_target_properties(bx PROPERTIES FOLDER "bgfx")
 

package/shared/BabylonNative/deps/cmakeextensions-src/CMakeLists.txt

@@ -80,12 +80,24 @@ function(npm)
         set(NPM_WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
     endif()
 
-    message(STATUS "Installing npm modules (${NPM_WORKING_DIRECTORY})")
-    execute_process(COMMAND ${NPM_COMMAND} ${NPM_UNPARSED_ARGUMENTS} WORKING_DIRECTORY ${NPM_WORKING_DIRECTORY} RESULT_VARIABLE NPM_RESULT)
+    list(JOIN NPM_UNPARSED_ARGUMENTS " " NPM_ARGS_STRING)
+    message(STATUS "Running npm ${NPM_ARGS_STRING} (${NPM_WORKING_DIRECTORY})")
+    execute_process(
+        COMMAND ${NPM_COMMAND} ${NPM_UNPARSED_ARGUMENTS}
+        WORKING_DIRECTORY ${NPM_WORKING_DIRECTORY}
+        RESULT_VARIABLE NPM_RESULT
+        OUTPUT_VARIABLE NPM_OUTPUT
+        ERROR_VARIABLE NPM_ERROR)
     if(NOT ${NPM_RESULT} EQUAL 0)
-        message(FATAL_ERROR "npm command failed: ${NPM_RESULT}")
+        message(FATAL_ERROR "npm command failed: ${NPM_RESULT}\n${NPM_OUTPUT}\n${NPM_ERROR}")
     else()
-        message(STATUS "Installing npm modules (${NPM_WORKING_DIRECTORY}) - done")
+        if(NPM_OUTPUT)
+            message(VERBOSE "${NPM_OUTPUT}")
+        endif()
+        if(NPM_ERROR)
+            message(VERBOSE "${NPM_ERROR}")
+        endif()
+        message(STATUS "Running npm ${NPM_ARGS_STRING} (${NPM_WORKING_DIRECTORY}) - done")
     endif()
 endfunction()
 
@@ -101,7 +113,9 @@ function(FetchContent_MakeAvailable_With_Message)
 
     if(names)
         message(STATUS "Fetching ${names}")
+        list(APPEND CMAKE_MESSAGE_INDENT "  ")
         FetchContent_MakeAvailable(${names})
+        list(POP_BACK CMAKE_MESSAGE_INDENT)
         message(STATUS "Fetching ${names} - done")
     endif()
 
@@ -109,6 +123,18 @@ function(FetchContent_MakeAvailable_With_Message)
         string(TOLOWER ${name} name_lowercase)
         set(${name_lowercase}_POPULATED ${${name_lowercase}_POPULATED} PARENT_SCOPE)
         set(${name_lowercase}_SOURCE_DIR ${${name_lowercase}_SOURCE_DIR} PARENT_SCOPE)
-        set(${name_lowercase}_BINARY_DIR ${${sname_lowercase}_BINARY_DIR} PARENT_SCOPE)
+        set(${name_lowercase}_BINARY_DIR ${${name_lowercase}_BINARY_DIR} PARENT_SCOPE)
     endforeach()
 endfunction()
+
+if(APPLE)
+    function(enable_objc_arc target)
+        if(XCODE)
+            set_target_properties(${target} PROPERTIES XCODE_ATTRIBUTE_CLANG_ENABLE_OBJC_ARC YES)
+        elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+            target_compile_options(${target} PRIVATE "-fobjc-arc")
+        else()
+            message(FATAL_ERROR "Unrecognized compiler: ${CMAKE_CXX_COMPILER}")
+        endif()
+    endfunction()
+endif()

package/shared/BabylonNative/deps/cmakeextensions-src/README.md

@@ -1,2 +1,7 @@
 # CMakeExtensions
-Helper functions for CMake
+
+A collection of reusable CMake helper functions used by [BabylonNative](https://github.com/BabylonJS/BabylonNative) and related projects. These functions reduce boilerplate and provide cross-platform convenience wrappers for common build tasks.
+
+## Requirements
+
+CMake **3.16** or later is required.

package/shared/BabylonNative/deps/jsruntimehost-src/CMakeLists.txt

@@ -11,11 +11,11 @@ include(FetchContent)
 # --------------------------------------------------
 FetchContent_Declare(AndroidExtensions
     GIT_REPOSITORY https://github.com/BabylonJS/AndroidExtensions.git
-    GIT_TAG f7ed149b5360cc8a4908fece66607c5ce1e6095b
+    GIT_TAG 2d5af72259cc73e5f249d3c99bee2010be9cb042
     EXCLUDE_FROM_ALL)
 FetchContent_Declare(arcana.cpp
     GIT_REPOSITORY https://github.com/microsoft/arcana.cpp.git
-    GIT_TAG c02527c32d51b6b3ffeda36f8cf140d2e1c60bb9
+    GIT_TAG 7c6be8aaa29effbc8ee1a2217388fb6e399150d2
     EXCLUDE_FROM_ALL)
 FetchContent_Declare(asio
     GIT_REPOSITORY https://github.com/chriskohlhoff/asio.git
@@ -23,7 +23,7 @@ FetchContent_Declare(asio
     EXCLUDE_FROM_ALL)
 FetchContent_Declare(CMakeExtensions
     GIT_REPOSITORY https://github.com/BabylonJS/CMakeExtensions.git
-    GIT_TAG ea28b7689530bfdc4905806f27ecf7e8ed4b5419
+    GIT_TAG dc750e7f69dad76779419df6442f834c57a30a1f
     EXCLUDE_FROM_ALL)
 FetchContent_Declare(googletest
     URL "https://github.com/google/googletest/archive/refs/tags/v1.17.0.tar.gz"
@@ -37,7 +37,7 @@ FetchContent_Declare(llhttp
     EXCLUDE_FROM_ALL)
 FetchContent_Declare(UrlLib
     GIT_REPOSITORY https://github.com/BabylonJS/UrlLib.git
-    GIT_TAG 1f9d2c05f792d994b09fdfc1129b25294efbe182
+    GIT_TAG d53beb958b1cccafd5411260ace6d32b68b56a83
     EXCLUDE_FROM_ALL)
 # --------------------------------------------------
 
@@ -55,7 +55,7 @@ project(JsRuntimeHost)
 
 set_property(GLOBAL PROPERTY USE_FOLDERS ON)
 
-set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 # --------------------------------------------------
@@ -81,6 +81,7 @@ option(JSRUNTIMEHOST_POLYFILL_ABORT_CONTROLLER "Include JsRuntimeHost Polyfills
 option(JSRUNTIMEHOST_POLYFILL_WEBSOCKET "Include JsRuntimeHost Polyfill WebSocket." ON)
 option(JSRUNTIMEHOST_POLYFILL_BLOB "Include JsRuntimeHost Polyfill Blob." ON)
 option(JSRUNTIMEHOST_POLYFILL_PERFORMANCE "Include JsRuntimeHost Polyfill Performance." ON)
+option(JSRUNTIMEHOST_POLYFILL_TEXTDECODER "Include JsRuntimeHost Polyfill TextDecoder." ON)
 
 # Sanitizers
 option(ENABLE_SANITIZERS "Enable AddressSanitizer and UBSan" OFF)

package/shared/BabylonNative/deps/jsruntimehost-src/Core/Node-API/Source/js_native_api_javascriptcore.cc

@@ -7,8 +7,7 @@
 #include <stdexcept>
 #include <string>
 #include <vector>
-#include <locale>
-#include <codecvt>
+
 
 struct napi_callback_info__ {
   napi_value newTarget;
@@ -103,13 +102,68 @@ namespace {
     }
 
    private:
+    // Decode UTF-8 to UTF-16, replacing invalid sequences with U+FFFD.
+    static std::u16string Utf8ToUtf16(const char* str, size_t len) {
+      std::u16string result;
+      result.reserve(len);
+      const auto* s = reinterpret_cast<const unsigned char*>(str);
+      const auto* end = s + len;
+      while (s < end) {
+        uint32_t cp;
+        int trail;
+        unsigned char lead = *s++;
+        if (lead < 0x80) {
+          cp = lead; trail = 0;
+        } else if ((lead >> 5) == 0x6) {
+          cp = lead & 0x1F; trail = 1;
+        } else if ((lead >> 4) == 0xE) {
+          cp = lead & 0x0F; trail = 2;
+        } else if ((lead >> 3) == 0x1E) {
+          cp = lead & 0x07; trail = 3;
+        } else {
+          result.push_back(0xFFFD);
+          continue;
+        }
+        if (s + trail > end) {
+          result.push_back(0xFFFD);
+          break;
+        }
+        bool valid = true;
+        for (int i = 0; i < trail; ++i) {
+          if ((s[i] & 0xC0) != 0x80) { valid = false; break; }
+          cp = (cp << 6) | (s[i] & 0x3F);
+        }
+        if (!valid) {
+          result.push_back(0xFFFD);
+          continue;
+        }
+        s += trail;
+        // Reject overlong encodings, surrogates, and out-of-range values.
+        if ((trail == 1 && cp < 0x80) ||
+            (trail == 2 && cp < 0x800) ||
+            (trail == 3 && cp < 0x10000) ||
+            (cp >= 0xD800 && cp <= 0xDFFF) ||
+            cp > 0x10FFFF) {
+          result.push_back(0xFFFD);
+          continue;
+        }
+        if (cp <= 0xFFFF) {
+          result.push_back(static_cast<char16_t>(cp));
+        } else {
+          cp -= 0x10000;
+          result.push_back(static_cast<char16_t>(0xD800 + (cp >> 10)));
+          result.push_back(static_cast<char16_t>(0xDC00 + (cp & 0x3FF)));
+        }
+      }
+      return result;
+    }
+
     static JSStringRef CreateUTF8(const char* string, size_t length) {
       if (length == NAPI_AUTO_LENGTH) {
         return JSStringCreateWithUTF8CString(string);
       }
 
-      std::u16string u16str{std::wstring_convert<
-        std::codecvt_utf8_utf16<char16_t>, char16_t>{}.from_bytes(string, string + length)};
+      std::u16string u16str{Utf8ToUtf16(string, length)};
       return JSStringCreateWithCharacters(reinterpret_cast<JSChar*>(u16str.data()), u16str.size());
     }
 

package/shared/BabylonNative/deps/jsruntimehost-src/Polyfills/CMakeLists.txt

@@ -28,4 +28,8 @@ endif()
 
 if(JSRUNTIMEHOST_POLYFILL_PERFORMANCE)
     add_subdirectory(Performance)
+endif()
+
+if(JSRUNTIMEHOST_POLYFILL_TEXTDECODER)
+    add_subdirectory(TextDecoder)
 endif()

package/shared/BabylonNative/deps/jsruntimehost-src/Polyfills/TextDecoder/CMakeLists.txt

@@ -0,0 +1,15 @@
+set(SOURCES
+    "Include/Babylon/Polyfills/TextDecoder.h"
+    "Source/TextDecoder.cpp")
+
+add_library(TextDecoder ${SOURCES})
+warnings_as_errors(TextDecoder)
+
+target_include_directories(TextDecoder PUBLIC "Include")
+
+target_link_libraries(TextDecoder
+    PUBLIC napi
+    PUBLIC Foundation)
+
+set_property(TARGET TextDecoder PROPERTY FOLDER Polyfills)
+source_group(TREE ${CMAKE_CURRENT_SOURCE_DIR} FILES ${SOURCES})

package/shared/BabylonNative/deps/jsruntimehost-src/Polyfills/TextDecoder/Include/Babylon/Polyfills/TextDecoder.h

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

package/shared/BabylonNative/deps/jsruntimehost-src/Polyfills/TextDecoder/README.md

@@ -0,0 +1,39 @@
+# TextDecoder Polyfill
+
+A C++ implementation of the [WHATWG Encoding API](https://encoding.spec.whatwg.org/) `TextDecoder` interface for use in Babylon Native JavaScript runtimes via [Napi](https://github.com/nodejs/node-addon-api).
+
+## Current State
+
+### Supported
+
+- Decoding `Uint8Array`, `Int8Array`, and other typed array views from a UTF-8 encoded byte sequence.
+- Decoding raw `ArrayBuffer` objects.
+- Constructing `TextDecoder` with no argument (defaults to `utf-8`).
+- Constructing `TextDecoder` with the explicit encoding label `"utf-8"` or `"UTF-8"`.
+- Calling `decode()` with no argument or `undefined` returns an empty string (matches the Web API).
+
+### Not Supported
+
+- Encodings other than UTF-8 — passing any other label (e.g. `"utf-16"`, `"iso-8859-1"`) throws a JavaScript `Error`.
+- `DataView` is not accepted by `decode()` — due to missing `Napi::DataView` support in the underlying JSI layer.
+- Passing a non-BufferSource value (e.g. a string or number) to `decode()` throws a `TypeError`.
+- The `fatal` option: decoding errors are not detected and do not throw a `TypeError`.
+- The `ignoreBOM` option: the byte order mark is not stripped.
+- Streaming decode (passing `{ stream: true }` to `decode()`) — each call is stateless.
+- The `encoding` property on the `TextDecoder` instance is not exposed.
+
+## Usage
+
+```javascript
+const decoder = new TextDecoder();              // utf-8
+const decoder = new TextDecoder("utf-8");       // explicit, also fine
+
+const bytes = new Uint8Array([72, 101, 108, 108, 111]);
+decoder.decode(bytes); // "Hello"
+```
+
+Passing an unsupported encoding throws:
+
+```javascript
+new TextDecoder("utf-16"); // Error: TextDecoder: unsupported encoding 'utf-16', only 'utf-8' is supported
+```

package/shared/BabylonNative/deps/jsruntimehost-src/Polyfills/TextDecoder/Source/TextDecoder.cpp

@@ -0,0 +1,91 @@
+#include <Babylon/Polyfills/TextDecoder.h>
+
+#include <napi/napi.h>
+#include <cstring>
+#include <string>
+
+namespace
+{
+    class TextDecoder final : public Napi::ObjectWrap<TextDecoder>
+    {
+    public:
+        static void Initialize(Napi::Env env)
+        {
+            Napi::HandleScope scope{env};
+
+            static constexpr auto JS_TEXTDECODER_CONSTRUCTOR_NAME = "TextDecoder";
+            if (env.Global().Get(JS_TEXTDECODER_CONSTRUCTOR_NAME).IsUndefined())
+            {
+                Napi::Function func = DefineClass(
+                    env,
+                    JS_TEXTDECODER_CONSTRUCTOR_NAME,
+                    {
+                        InstanceMethod("decode", &TextDecoder::Decode),
+                    });
+
+                env.Global().Set(JS_TEXTDECODER_CONSTRUCTOR_NAME, func);
+            }
+        }
+
+        explicit TextDecoder(const Napi::CallbackInfo& info)
+            : Napi::ObjectWrap<TextDecoder>{info}
+        {
+            if (info.Length() > 0 && info[0].IsString())
+            {
+                auto encoding = info[0].As<Napi::String>().Utf8Value();
+                if (encoding != "utf-8" && encoding != "UTF-8")
+                {
+                    throw Napi::Error::New(Env(), "TextDecoder: unsupported encoding '" + encoding + "', only 'utf-8' is supported");
+                }
+            }
+        }
+
+    private:
+        Napi::Value Decode(const Napi::CallbackInfo& info)
+        {
+            if (info.Length() < 1 || info[0].IsUndefined())
+            {
+                return Napi::String::New(info.Env(), "");
+            }
+
+            std::string data;
+
+            if (info[0].IsTypedArray())
+            {
+                auto typedArray = info[0].As<Napi::TypedArray>();
+                auto arrayBuffer = typedArray.ArrayBuffer();
+                auto byteOffset = typedArray.ByteOffset();
+                auto byteLength = typedArray.ByteLength();
+                data.resize(byteLength);
+                if (byteLength > 0)
+                {
+                    std::memcpy(data.data(), static_cast<uint8_t*>(arrayBuffer.Data()) + byteOffset, byteLength);
+                }
+            }
+            else if (info[0].IsArrayBuffer())
+            {
+                auto arrayBuffer = info[0].As<Napi::ArrayBuffer>();
+                auto byteLength = arrayBuffer.ByteLength();
+                data.resize(byteLength);
+                if (byteLength > 0)
+                {
+                    std::memcpy(data.data(), arrayBuffer.Data(), byteLength);
+                }
+            }
+            else
+            {
+                throw Napi::TypeError::New(Env(), "TextDecoder.decode: input must be a BufferSource (ArrayBuffer or TypedArray)");
+            }
+
+            return Napi::String::New(info.Env(), data);
+        }
+    };
+}
+
+namespace Babylon::Polyfills::TextDecoder
+{
+    void BABYLON_API Initialize(Napi::Env env)
+    {
+        ::TextDecoder::Initialize(env);
+    }
+}