react-native-nitro-buffer 0.0.3 → 0.0.11

package/README.md

@@ -14,23 +14,43 @@ A high-performance, Node.js compatible `Buffer` implementation for React Native,
 
 `react-native-nitro-buffer` is significantly faster than other Buffer implementations for React Native.
 
-**Benchmark Results (1MB Buffer operations):**
+### Device: iPad Air 5 (M1) - Physical Device
 
 | Operation | Nitro Buffer | Competitor (Craftz) | Improvement |
 |:---|:---:|:---:|:---:|
-| `fill(0)` | **0.019ms** | 10.36ms | **~545x 🚀** |
-| `write(utf8)` | **2.53ms** | 212.42ms | **~84x 🚀** |
-| `toString(utf8)` | **0.25ms** | 170.72ms | **~691x 🚀** |
-| `toString(base64)` | **0.68ms** | 3.37ms | **~5x 🚀** |
-| `from(base64)` | **1.37ms** | 146.70ms | **~107x 🚀** |
-| `toString(hex)` | **4.86ms** | 56.77ms | **~11.7x 🚀** |
-| `from(hex)` | **11.05ms** | 136.64ms | **~12.4x 🚀** |
-| `alloc(1MB)` | 0.39ms | 0.09ms | 0.23x |
+| `fill(0)` | **0.019ms** | 10.37ms | **~545x 🚀** |
+| `write(utf8)` | **2.47ms** | 212.04ms | **~85x 🚀** |
+| `toString(utf8)` | **0.89ms** | 169.16ms | **~190x 🚀** |
+| `toString(base64)` | **0.69ms** | 3.40ms | **~4.9x 🚀** |
+| `from(base64)` | **1.40ms** | 146.56ms | **~104x 🚀** |
+| `toString(hex)` | **4.85ms** | 57.34ms | **~11.8x 🚀** |
+| `from(hex)` | **11.06ms** | 138.04ms | **~12.5x 🚀** |
+| `btoa(1MB)` | **3.00ms** | 45.90ms | **~15.3x 🚀** |
+| `atob(1MB)` | **5.12ms** | 149.73ms | **~29.2x 🚀** |
+| `alloc(1MB)` | 0.33ms | 0.09ms | 0.27x |
+
+### Device: iPhone 16 Pro Simulator (Mac mini M4)
 
-*> Benchmarks ran on iPad Air 5 (M1), averaging 50 iterations.*
+| Operation | Nitro Buffer | Competitor (Craftz) | Improvement |
+|:---|:---:|:---:|:---:|
+| `fill(0)` | **0.015ms** | 13.78ms | **~918x 🚀** |
+| `write(utf8)` | **4.27ms** | 163.46ms | **~38x 🚀** |
+| `toString(utf8)` | **0.93ms** | 141.56ms | **~152x 🚀** |
+| `toString(base64)` | **1.71ms** | 4.71ms | **~3x 🚀** |
+| `from(base64)` | **16.45ms** | 104.67ms | **~6x 🚀** |
+| `toString(hex)` | **4.89ms** | 43.46ms | **~9x 🚀** |
+| `from(hex)` | **17.93ms** | 95.00ms | **~5x 🚀** |
+| `btoa(1MB)` | **1.13ms** | 34.87ms | **~31x 🚀** |
+| `atob(1MB)` | **2.18ms** | 91.41ms | **~42x 🚀** |
+| `alloc(1MB)` | 0.18ms | 0.03ms | 0.16x |
+
+*> Benchmarks averaged over 50 iterations on 1MB Buffer operations.*
 
 > [!NOTE]
-> **About `alloc` Performance**: The slight difference in allocation time (~0.3ms) is due to the overhead of initializing the ES6 Class structure (`Object.setPrototypeOf`), which provides a cleaner and safer type inheritance model compared to the functional mixin approach. This one-time initialization cost is negligible compared to the massive **10x - 700x** performance gains in actual Buffer operations.
+> **About `alloc` Performance**: The slight difference in allocation time (~0.3ms) is due to the overhead of initializing the ES6 Class structure (`Object.setPrototypeOf`), which provides a cleaner and safer type inheritance model compared to the functional mixin approach. This one-time initialization cost is negligible compared to the massive **5x - 550x** performance gains in actual Buffer operations.
+
+> [!TIP]
+> **`atob`/`btoa` Optimization**: In modern React Native environments (Hermes), `global.atob` and `global.btoa` are natively implemented and highly optimized. `react-native-nitro-buffer` automatically detects and uses these native implementations if available, ensuring your app runs at peak performance while maintaining Node.js utility compatibility.
 
 ## 📦 Installation
 

package/android/CMakeLists.txt

@@ -0,0 +1,25 @@
+cmake_minimum_required(VERSION 3.10)
+project(NitroBuffer)
+
+set(CMAKE_CXX_STANDARD 20)
+
+# Add custom implementation and JNI adapter
+add_library(NitroBuffer SHARED
+    OnLoad.cpp
+    ../cpp/HybridNitroBuffer.cpp
+)
+
+# Include paths for our headers
+include_directories(
+    ${CMAKE_CURRENT_SOURCE_DIR}/../cpp
+)
+
+# Include the Nitrogen-generated CMake file (handles defines, sources, and linking)
+include(${CMAKE_CURRENT_SOURCE_DIR}/../nitrogen/generated/android/NitroBuffer+autolinking.cmake)
+
+# Link additional libraries
+find_library(LOG_LIB log)
+target_link_libraries(
+    NitroBuffer
+    ${LOG_LIB}
+)

package/android/OnLoad.cpp

@@ -0,0 +1,7 @@
+#include "NitroBufferOnLoad.hpp"
+#include <NitroModules/NitroDefines.hpp>
+#include <jni.h>
+
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *reserved) {
+  return margelo::nitro::buffer::initialize(vm);
+}

package/android/build.gradle

@@ -0,0 +1,81 @@
+apply plugin: "com.android.library"
+apply plugin: "org.jetbrains.kotlin.android"
+
+def reactNativeArchitectures() {
+  def value = rootProject.getProperties().get("reactNativeArchitectures")
+  return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
+}
+
+def getExtOrDefault(name, defaultValue) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : defaultValue
+}
+
+android {
+  namespace "com.margelo.nitro.buffer"
+  compileSdkVersion getExtOrDefault("compileSdkVersion", 34)
+
+  defaultConfig {
+    minSdkVersion getExtOrDefault("minSdkVersion", 21)
+    targetSdkVersion getExtOrDefault("targetSdkVersion", 34)
+
+    externalNativeBuild {
+      cmake {
+        cppFlags "-fexceptions -frtti -std=c++20"
+        arguments "-DANDROID_STL=c++_shared"
+        abiFilters (*reactNativeArchitectures())
+      }
+    }
+  }
+
+  buildFeatures {
+    buildConfig true
+    prefab true
+  }
+
+  externalNativeBuild {
+    cmake {
+      path "CMakeLists.txt"
+    }
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_17
+    targetCompatibility JavaVersion.VERSION_17
+  }
+
+  kotlinOptions {
+    jvmTarget = "17"
+  }
+
+  sourceSets {
+    main {
+      jniLibs.srcDirs += ['libs']
+    }
+  }
+
+  packagingOptions {
+    excludes = [
+            "META-INF",
+            "META-INF/**",
+            "**/libc++_shared.so",
+            "**/libfbjni.so",
+            "**/libjsi.so",
+            "**/libreactnative.so",
+            "**/libreact_nativemodule_core.so",
+            "**/libturbomodulejsijni.so",
+            "**/libhermes.so",
+            "**/libhermes_executor.so"
+    ]
+  }
+}
+
+dependencies {
+  // Use project reference for Nitro Modules to ensure autolinking works correctly in this repo
+  implementation project(":react-native-nitro-modules")
+  
+  // Use react-android instead of react-native for better compatibility with 0.71+
+  implementation "com.facebook.react:react-android"
+}
+
+// Apply the Nitrogen-generated Gradle file
+apply from: "../nitrogen/generated/android/NitroBuffer+autolinking.gradle"

package/android/gradle.properties

@@ -0,0 +1 @@
+NitroBuffer_cmakeVersion=3.22.1

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

package/android/src/main/java/com/margelo/nitro/buffer/NitroBufferPackage.kt

@@ -0,0 +1,36 @@
+package com.margelo.nitro.buffer
+
+import com.facebook.react.TurboReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfoProvider
+import com.facebook.react.module.model.ReactModuleInfo
+import java.util.HashMap
+
+class NitroBufferPackage : TurboReactPackage() {
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+    return null
+  }
+
+  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+    return ReactModuleInfoProvider {
+      val moduleInfos: MutableMap<String, ReactModuleInfo> = HashMap()
+      moduleInfos["NitroBuffer"] = ReactModuleInfo(
+        "NitroBuffer",
+        "NitroBuffer",
+        false,  // canOverrideExistingModule
+        false,  // needsEagerInit
+        true,   // hasConstants
+        false,  // isCxxModule
+        true    // isTurboModule
+      )
+      moduleInfos
+    }
+  }
+
+  companion object {
+    init {
+      System.loadLibrary("NitroBuffer")
+    }
+  }
+}

package/cpp/HybridNitroBuffer.cpp

@@ -5,7 +5,7 @@
 #include <iostream>
 #include <vector>
 
-namespace margelo::nitro::nitro_buffer {
+namespace margelo::nitro::buffer {
 
 static const char base64_chars[] =
     "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
@@ -220,11 +220,74 @@ double HybridNitroBuffer::write(const std::shared_ptr<ArrayBuffer> &buffer,
 // UTF-8 replacement character (U+FFFD) encoded as UTF-8
 static const char UTF8_REPLACEMENT[] = "\xEF\xBF\xBD";
 
-// Decode UTF-8 with WHATWG-compliant error handling (replace invalid bytes with
-// U+FFFD) This matches Node.js Buffer.toString('utf8') behavior
-static std::string decodeUtf8WithReplacement(const uint8_t *data, size_t len) {
+// Fast validation: returns true if all data is valid UTF-8, false otherwise
+// This allows us to use memcpy for the common case of valid UTF-8
+static bool isValidUtf8(const uint8_t *data, size_t len) {
+  size_t i = 0;
+  while (i < len) {
+    uint8_t byte1 = data[i];
+
+    // ASCII (0x00-0x7F) - most common case
+    if (byte1 <= 0x7F) {
+      i++;
+      continue;
+    }
+
+    // Invalid leading byte
+    if (byte1 < 0xC2 || byte1 > 0xF4) {
+      return false;
+    }
+
+    // 2-byte sequence (0xC2-0xDF)
+    if (byte1 <= 0xDF) {
+      if (i + 1 >= len || (data[i + 1] & 0xC0) != 0x80) {
+        return false;
+      }
+      i += 2;
+      continue;
+    }
+
+    // 3-byte sequence (0xE0-0xEF)
+    if (byte1 <= 0xEF) {
+      if (i + 2 >= len)
+        return false;
+      uint8_t byte2 = data[i + 1];
+      uint8_t byte3 = data[i + 2];
+      if ((byte2 & 0xC0) != 0x80 || (byte3 & 0xC0) != 0x80)
+        return false;
+      // Check overlong and surrogate
+      if (byte1 == 0xE0 && byte2 < 0xA0)
+        return false;
+      if (byte1 == 0xED && byte2 >= 0xA0)
+        return false;
+      i += 3;
+      continue;
+    }
+
+    // 4-byte sequence (0xF0-0xF4)
+    if (i + 3 >= len)
+      return false;
+    uint8_t byte2 = data[i + 1];
+    uint8_t byte3 = data[i + 2];
+    uint8_t byte4 = data[i + 3];
+    if ((byte2 & 0xC0) != 0x80 || (byte3 & 0xC0) != 0x80 ||
+        (byte4 & 0xC0) != 0x80)
+      return false;
+    if (byte1 == 0xF0 && byte2 < 0x90)
+      return false;
+    if (byte1 == 0xF4 && byte2 > 0x8F)
+      return false;
+    i += 4;
+  }
+  return true;
+}
+
+// Slow path: Decode UTF-8 with replacement for invalid bytes
+// Only called when isValidUtf8 returns false
+static std::string decodeUtf8WithReplacementSlow(const uint8_t *data,
+                                                 size_t len) {
   std::string result;
-  result.reserve(len); // Minimum reservation
+  result.reserve(len + len / 10); // Add 10% for potential replacements
 
   size_t i = 0;
   while (i < len) {
@@ -245,27 +308,20 @@ static std::string decodeUtf8WithReplacement(const uint8_t *data, size_t len) {
     }
 
     // 2-byte sequence (0xC2-0xDF)
-    if (byte1 >= 0xC2 && byte1 <= 0xDF) {
-      if (i + 1 >= len) {
+    if (byte1 <= 0xDF) {
+      if (i + 1 >= len || (data[i + 1] & 0xC0) != 0x80) {
         result.append(UTF8_REPLACEMENT);
         i++;
         continue;
       }
-      uint8_t byte2 = data[i + 1];
-      if ((byte2 & 0xC0) != 0x80) {
-        result.append(UTF8_REPLACEMENT);
-        i++;
-        continue;
-      }
-      // Valid 2-byte sequence
       result.push_back(static_cast<char>(byte1));
-      result.push_back(static_cast<char>(byte2));
+      result.push_back(static_cast<char>(data[i + 1]));
       i += 2;
       continue;
     }
 
     // 3-byte sequence (0xE0-0xEF)
-    if (byte1 >= 0xE0 && byte1 <= 0xEF) {
+    if (byte1 <= 0xEF) {
       if (i + 2 >= len) {
         result.append(UTF8_REPLACEMENT);
         i++;
@@ -273,28 +329,12 @@ static std::string decodeUtf8WithReplacement(const uint8_t *data, size_t len) {
       }
       uint8_t byte2 = data[i + 1];
       uint8_t byte3 = data[i + 2];
-
-      // Check continuation bytes
-      if ((byte2 & 0xC0) != 0x80 || (byte3 & 0xC0) != 0x80) {
-        result.append(UTF8_REPLACEMENT);
-        i++;
-        continue;
-      }
-
-      // Check for overlong encoding and surrogate halves
-      if (byte1 == 0xE0 && byte2 < 0xA0) {
-        result.append(UTF8_REPLACEMENT);
-        i++;
-        continue;
-      }
-      if (byte1 == 0xED && byte2 >= 0xA0) {
-        // Surrogate halves (0xD800-0xDFFF) are invalid in UTF-8
+      if ((byte2 & 0xC0) != 0x80 || (byte3 & 0xC0) != 0x80 ||
+          (byte1 == 0xE0 && byte2 < 0xA0) || (byte1 == 0xED && byte2 >= 0xA0)) {
         result.append(UTF8_REPLACEMENT);
         i++;
         continue;
       }
-
-      // Valid 3-byte sequence
       result.push_back(static_cast<char>(byte1));
       result.push_back(static_cast<char>(byte2));
       result.push_back(static_cast<char>(byte3));
@@ -303,54 +343,43 @@ static std::string decodeUtf8WithReplacement(const uint8_t *data, size_t len) {
     }
 
     // 4-byte sequence (0xF0-0xF4)
-    if (byte1 >= 0xF0 && byte1 <= 0xF4) {
-      if (i + 3 >= len) {
-        result.append(UTF8_REPLACEMENT);
-        i++;
-        continue;
-      }
-      uint8_t byte2 = data[i + 1];
-      uint8_t byte3 = data[i + 2];
-      uint8_t byte4 = data[i + 3];
-
-      // Check continuation bytes
-      if ((byte2 & 0xC0) != 0x80 || (byte3 & 0xC0) != 0x80 ||
-          (byte4 & 0xC0) != 0x80) {
-        result.append(UTF8_REPLACEMENT);
-        i++;
-        continue;
-      }
-
-      // Check for overlong encoding and out-of-range code points
-      if (byte1 == 0xF0 && byte2 < 0x90) {
-        result.append(UTF8_REPLACEMENT);
-        i++;
-        continue;
-      }
-      if (byte1 == 0xF4 && byte2 > 0x8F) {
-        // Code points above U+10FFFF
-        result.append(UTF8_REPLACEMENT);
-        i++;
-        continue;
-      }
-
-      // Valid 4-byte sequence
-      result.push_back(static_cast<char>(byte1));
-      result.push_back(static_cast<char>(byte2));
-      result.push_back(static_cast<char>(byte3));
-      result.push_back(static_cast<char>(byte4));
-      i += 4;
+    if (i + 3 >= len) {
+      result.append(UTF8_REPLACEMENT);
+      i++;
       continue;
     }
-
-    // Fallback (should not reach here)
-    result.append(UTF8_REPLACEMENT);
-    i++;
+    uint8_t byte2 = data[i + 1];
+    uint8_t byte3 = data[i + 2];
+    uint8_t byte4 = data[i + 3];
+    if ((byte2 & 0xC0) != 0x80 || (byte3 & 0xC0) != 0x80 ||
+        (byte4 & 0xC0) != 0x80 || (byte1 == 0xF0 && byte2 < 0x90) ||
+        (byte1 == 0xF4 && byte2 > 0x8F)) {
+      result.append(UTF8_REPLACEMENT);
+      i++;
+      continue;
+    }
+    result.push_back(static_cast<char>(byte1));
+    result.push_back(static_cast<char>(byte2));
+    result.push_back(static_cast<char>(byte3));
+    result.push_back(static_cast<char>(byte4));
+    i += 4;
   }
 
   return result;
 }
 
+// Decode UTF-8 with WHATWG-compliant error handling
+// Uses fast path (memcpy) for valid UTF-8, slow path with replacement for
+// invalid
+static std::string decodeUtf8WithReplacement(const uint8_t *data, size_t len) {
+  // Fast path: if data is valid UTF-8, just copy it directly
+  if (isValidUtf8(data, len)) {
+    return std::string(reinterpret_cast<const char *>(data), len);
+  }
+  // Slow path: need to replace invalid sequences
+  return decodeUtf8WithReplacementSlow(data, len);
+}
+
 // Decode as latin1/binary - each byte maps directly to Unicode code point
 // 0x00-0xFF
 static std::string decodeLatin1(const uint8_t *data, size_t len) {
@@ -673,4 +702,4 @@ void HybridNitroBuffer::fill(const std::shared_ptr<ArrayBuffer> &buffer,
   memset(data + start, (int)value, actualFill);
 }
 
-} // namespace margelo::nitro::nitro_buffer
+} // namespace margelo::nitro::buffer

package/cpp/HybridNitroBuffer.hpp

@@ -2,7 +2,7 @@
 #include "HybridNitroBufferSpec.hpp"
 #include <NitroModules/ArrayBuffer.hpp>
 
-namespace margelo::nitro::nitro_buffer {
+namespace margelo::nitro::buffer {
 
 class HybridNitroBuffer : public HybridNitroBufferSpec {
 public:
@@ -41,4 +41,4 @@ public:
                   double length) override;
 };
 
-} // namespace margelo::nitro::nitro_buffer
+} // namespace margelo::nitro::buffer

package/lib/utils.js

@@ -8,9 +8,15 @@ exports.transcode = transcode;
 exports.resolveObjectURL = resolveObjectURL;
 const Buffer_1 = require("./Buffer");
 function atob(data) {
+    if (typeof global.atob === 'function') {
+        return global.atob(data);
+    }
     return Buffer_1.Buffer.from(data, 'base64').toString('binary');
 }
 function btoa(data) {
+    if (typeof global.btoa === 'function') {
+        return global.btoa(data);
+    }
     return Buffer_1.Buffer.from(data, 'binary').toString('base64');
 }
 function isAscii(input) {

package/nitrogen/generated/android/NitroBufferOnLoad.cpp

@@ -17,11 +17,11 @@
 
 #include "HybridNitroBuffer.hpp"
 
-namespace margelo::nitro::nitro_buffer {
+namespace margelo::nitro::buffer {
 
 int initialize(JavaVM* vm) {
   using namespace margelo::nitro;
-  using namespace margelo::nitro::nitro_buffer;
+  using namespace margelo::nitro::buffer;
   using namespace facebook;
 
   return facebook::jni::initialize(vm, [] {
@@ -41,4 +41,4 @@ int initialize(JavaVM* vm) {
   });
 }
 
-} // namespace margelo::nitro::nitro_buffer
+} // namespace margelo::nitro::buffer

package/nitrogen/generated/android/NitroBufferOnLoad.hpp

@@ -8,7 +8,7 @@
 #include <jni.h>
 #include <NitroModules/NitroDefines.hpp>
 
-namespace margelo::nitro::nitro_buffer {
+namespace margelo::nitro::buffer {
 
   /**
    * Initializes the native (C++) part of NitroBuffer, and autolinks all Hybrid Objects.
@@ -16,10 +16,10 @@ namespace margelo::nitro::nitro_buffer {
    * Example:
    * ```cpp (cpp-adapter.cpp)
    * JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
-   *   return margelo::nitro::nitro_buffer::initialize(vm);
+   *   return margelo::nitro::buffer::initialize(vm);
    * }
    * ```
    */
   int initialize(JavaVM* vm);
 
-} // namespace margelo::nitro::nitro_buffer
+} // namespace margelo::nitro::buffer

package/nitrogen/generated/android/kotlin/com/margelo/nitro/{nitro_buffer → buffer}/NitroBufferOnLoad.kt

@@ -5,7 +5,7 @@
 /// Copyright © 2025 Marc Rousavy @ Margelo
 ///
 
-package com.margelo.nitro.nitro_buffer
+package com.margelo.nitro.buffer
 
 import android.util.Log
 

package/nitrogen/generated/ios/NitroBuffer+autolinking.rb

@@ -52,7 +52,7 @@ def add_nitrogen_files(spec)
   spec.pod_target_xcconfig = current_pod_target_xcconfig.merge({
     # Use C++ 20
     "CLANG_CXX_LANGUAGE_STANDARD" => "c++20",
-    # Enables C++ <-> Swift interop (by default it's only C)
+    # Enables C++ <-> Swift interop (by default it's only ObjC)
     "SWIFT_OBJC_INTEROP_MODE" => "objcxx",
     # Enables stricter modular headers
     "DEFINES_MODULE" => "YES",

package/nitrogen/generated/ios/NitroBuffer-Swift-Cxx-Bridge.cpp

@@ -10,8 +10,8 @@
 // Include C++ implementation defined types
 
 
-namespace margelo::nitro::nitro_buffer::bridge::swift {
+namespace margelo::nitro::buffer::bridge::swift {
 
   
 
-} // namespace margelo::nitro::nitro_buffer::bridge::swift
+} // namespace margelo::nitro::buffer::bridge::swift

package/nitrogen/generated/ios/NitroBuffer-Swift-Cxx-Bridge.hpp

@@ -20,8 +20,8 @@
  * Contains specialized versions of C++ templated types so they can be accessed from Swift,
  * as well as helper functions to interact with those C++ types from Swift.
  */
-namespace margelo::nitro::nitro_buffer::bridge::swift {
+namespace margelo::nitro::buffer::bridge::swift {
 
   
 
-} // namespace margelo::nitro::nitro_buffer::bridge::swift
+} // namespace margelo::nitro::buffer::bridge::swift

package/nitrogen/generated/ios/NitroBufferAutolinking.mm

@@ -19,7 +19,7 @@
 
 + (void) load {
   using namespace margelo::nitro;
-  using namespace margelo::nitro::nitro_buffer;
+  using namespace margelo::nitro::buffer;
 
   HybridObjectRegistry::registerHybridObjectConstructor(
     "NitroBuffer",

package/nitrogen/generated/ios/NitroBufferAutolinking.swift

@@ -6,7 +6,7 @@
 ///
 
 public final class NitroBufferAutolinking {
-  public typealias bridge = margelo.nitro.nitro_buffer.bridge.swift
+  public typealias bridge = margelo.nitro.buffer.bridge.swift
 
   
 }

package/nitrogen/generated/shared/c++/HybridNitroBufferSpec.cpp

@@ -7,7 +7,7 @@
 
 #include "HybridNitroBufferSpec.hpp"
 
-namespace margelo::nitro::nitro_buffer {
+namespace margelo::nitro::buffer {
 
   void HybridNitroBufferSpec::loadHybridMethods() {
     // load base methods/properties
@@ -29,4 +29,4 @@ namespace margelo::nitro::nitro_buffer {
     });
   }
 
-} // namespace margelo::nitro::nitro_buffer
+} // namespace margelo::nitro::buffer

package/nitrogen/generated/shared/c++/HybridNitroBufferSpec.hpp

@@ -18,7 +18,7 @@
 #include <NitroModules/ArrayBuffer.hpp>
 #include <string>
 
-namespace margelo::nitro::nitro_buffer {
+namespace margelo::nitro::buffer {
 
   using namespace margelo::nitro;
 
@@ -71,4 +71,4 @@ namespace margelo::nitro::nitro_buffer {
       static constexpr auto TAG = "NitroBuffer";
   };
 
-} // namespace margelo::nitro::nitro_buffer
+} // namespace margelo::nitro::buffer

package/package.json

@@ -1,12 +1,13 @@
 {
     "name": "react-native-nitro-buffer",
-    "version": "0.0.3",
-    "description": "Node.js compatible buffer module for React Native",
+    "version": "0.0.11",
+    "description": "The fastest, 100% Node.js-compatible Buffer implementation for React Native, powered by Nitro Modules and C++.",
     "main": "lib/index.js",
     "module": "lib/index.js",
     "types": "lib/index.d.ts",
+    "react-native": "src/index.ts",
     "scripts": {
-        "build": "tsc",
+        "build": "npx nitrogen@0.32.0 && tsc",
         "test": "jest",
         "prepublishOnly": "npm run build"
     },
@@ -23,20 +24,17 @@
     "peerDependencies": {
         "react": "*",
         "react-native": "*",
-        "react-native-nitro-modules": "*"
+        "react-native-nitro-modules": "^0.32.0"
     },
     "devDependencies": {
         "@types/jest": "^30.0.0",
         "@types/node": "^18.19.130",
         "@types/react": "*",
         "jest": "^29.0.0",
-        "react-native-nitro-modules": "*",
+        "react-native-nitro-modules": "^0.32.0",
         "ts-jest": "^29.0.0",
         "typescript": "^5.0.0"
     },
-    "dependencies": {
-        "react-native-nitro-modules": "*"
-    },
     "packageManager": "yarn@4.12.0",
     "files": [
         "lib/",

package/src/utils.ts

@@ -2,10 +2,16 @@
 import { Buffer } from './Buffer'
 
 export function atob(data: string): string {
+    if (typeof global.atob === 'function') {
+        return global.atob(data)
+    }
     return Buffer.from(data, 'base64').toString('binary')
 }
 
 export function btoa(data: string): string {
+    if (typeof global.btoa === 'function') {
+        return global.btoa(data)
+    }
     return Buffer.from(data, 'binary').toString('base64')
 }