react-native-nitro-buffer 0.0.1 → 0.0.3

package/README.md

@@ -124,6 +124,21 @@ This library achieves **100% API compatibility** with Node.js `Buffer`.
     const cBuf = CraftzBuffer.from(nBuf); // Works!
     ```
 
+## ⚠️ Compatibility Notes
+
+### `toString('ascii')` Behavior
+
+When decoding binary data with non-ASCII bytes (0x80-0xFF), `react-native-nitro-buffer` follows the **Node.js standard** by replacing invalid bytes with the Unicode replacement character (`U+FFFD`, displayed as `�`).
+
+```javascript
+const buf = Buffer.from([0x48, 0x69, 0x80, 0xFF, 0x21]); // "Hi" + invalid bytes + "!"
+buf.toString('ascii');
+// Nitro (Node.js compatible): "Hi��!" (length: 5)
+// @craftzdog/react-native-buffer: "Hi!" (length: 5) - incorrectly drops invalid bytes
+```
+
+This ensures consistent behavior with Node.js when handling binary protocols like WebSocket messages containing mixed text and binary data (e.g., Microsoft TTS audio streams).
+
 ## 📄 License
 
 ISC

package/cpp/HybridNitroBuffer.cpp

@@ -217,6 +217,177 @@ double HybridNitroBuffer::write(const std::shared_ptr<ArrayBuffer> &buffer,
   return actualWrite;
 }
 
+// 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) {
+  std::string result;
+  result.reserve(len); // Minimum reservation
+
+  size_t i = 0;
+  while (i < len) {
+    uint8_t byte1 = data[i];
+
+    // ASCII (0x00-0x7F)
+    if (byte1 <= 0x7F) {
+      result.push_back(static_cast<char>(byte1));
+      i++;
+      continue;
+    }
+
+    // Invalid leading byte (0x80-0xBF or 0xF8-0xFF)
+    if (byte1 < 0xC2 || byte1 > 0xF4) {
+      result.append(UTF8_REPLACEMENT);
+      i++;
+      continue;
+    }
+
+    // 2-byte sequence (0xC2-0xDF)
+    if (byte1 >= 0xC2 && byte1 <= 0xDF) {
+      if (i + 1 >= len) {
+        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));
+      i += 2;
+      continue;
+    }
+
+    // 3-byte sequence (0xE0-0xEF)
+    if (byte1 >= 0xE0 && byte1 <= 0xEF) {
+      if (i + 2 >= len) {
+        result.append(UTF8_REPLACEMENT);
+        i++;
+        continue;
+      }
+      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
+        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));
+      i += 3;
+      continue;
+    }
+
+    // 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;
+      continue;
+    }
+
+    // Fallback (should not reach here)
+    result.append(UTF8_REPLACEMENT);
+    i++;
+  }
+
+  return result;
+}
+
+// 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) {
+  std::string result;
+  result.reserve(len * 2); // Worst case: all bytes > 0x7F need 2 bytes in UTF-8
+
+  for (size_t i = 0; i < len; i++) {
+    uint8_t byte = data[i];
+    if (byte <= 0x7F) {
+      result.push_back(static_cast<char>(byte));
+    } else {
+      // Encode as 2-byte UTF-8 sequence
+      result.push_back(static_cast<char>(0xC0 | (byte >> 6)));
+      result.push_back(static_cast<char>(0x80 | (byte & 0x3F)));
+    }
+  }
+
+  return result;
+}
+
+// Decode as ASCII - bytes > 0x7F are replaced with U+FFFD
+static std::string decodeAscii(const uint8_t *data, size_t len) {
+  std::string result;
+  result.reserve(len);
+
+  for (size_t i = 0; i < len; i++) {
+    uint8_t byte = data[i];
+    if (byte <= 0x7F) {
+      result.push_back(static_cast<char>(byte));
+    } else {
+      result.append(UTF8_REPLACEMENT);
+    }
+  }
+
+  return result;
+}
+
 std::string
 HybridNitroBuffer::decode(const std::shared_ptr<ArrayBuffer> &buffer,
                           double offset, double length,
@@ -232,8 +403,15 @@ HybridNitroBuffer::decode(const std::shared_ptr<ArrayBuffer> &buffer,
   size_t actualRead = std::min(available, count);
 
   if (encoding == "utf8" || encoding == "utf-8") {
-    // Check for null termination? No, ArrayBuffer may not be null terminated.
-    return std::string((char *)(data + start), actualRead);
+    // WHATWG-compliant UTF-8 decoding with replacement character for invalid
+    // sequences
+    return decodeUtf8WithReplacement(data + start, actualRead);
+  } else if (encoding == "latin1" || encoding == "binary") {
+    // Each byte maps to Unicode code point 0x00-0xFF
+    return decodeLatin1(data + start, actualRead);
+  } else if (encoding == "ascii") {
+    // ASCII with replacement for non-ASCII bytes
+    return decodeAscii(data + start, actualRead);
   } else if (encoding == "hex") {
     std::string hex;
     hex.reserve(actualRead * 2);
@@ -248,7 +426,8 @@ HybridNitroBuffer::decode(const std::shared_ptr<ArrayBuffer> &buffer,
     return base64_encode(data + start, (unsigned int)actualRead);
   }
 
-  return std::string((char *)(data + start), actualRead);
+  // Default: UTF-8 with replacement
+  return decodeUtf8WithReplacement(data + start, actualRead);
 }
 
 double HybridNitroBuffer::compare(const std::shared_ptr<ArrayBuffer> &a,

package/lib/Buffer.d.ts

@@ -1,4 +1,5 @@
 export declare class Buffer extends Uint8Array {
+    static poolSize: number;
     constructor(length: number);
     constructor(array: Uint8Array);
     constructor(arrayBuffer: ArrayBuffer, byteOffset?: number, length?: number);
@@ -11,6 +12,7 @@ export declare class Buffer extends Uint8Array {
     static byteLength(string: string, encoding?: string): number;
     static isBuffer(obj: any): obj is Buffer;
     static compare(buf1: Uint8Array, buf2: Uint8Array): number;
+    equals(otherBuffer: Uint8Array): boolean;
     static copyBytesFrom(view: ArrayBufferView, offset?: number, length?: number): Buffer;
     static concat(list: Uint8Array[], totalLength?: number): Buffer;
     write(string: string, offset?: number, length?: number, encoding?: string): number;
@@ -70,7 +72,7 @@ export declare class Buffer extends Uint8Array {
         type: 'Buffer';
         data: number[];
     };
-    static poolSize: number;
+    inspect(): string;
     static isEncoding(encoding: string): boolean;
     swap16(): Buffer;
     swap32(): Buffer;

package/lib/Buffer.js

@@ -58,6 +58,9 @@ class Buffer extends Uint8Array {
         if (Array.isArray(value)) {
             return new Buffer(new Uint8Array(value).buffer);
         }
+        if (typeof value === 'object' && value !== null && value.type === 'Buffer' && Array.isArray(value.data)) {
+            return new Buffer(value.data);
+        }
         throw new TypeError('Unsupported type for Buffer.from');
     }
     static alloc(size, fill, encoding) {
@@ -91,6 +94,13 @@ class Buffer extends Uint8Array {
     static compare(buf1, buf2) {
         return getNative().compare(buf1.buffer, buf1.byteOffset, buf1.byteLength, buf2.buffer, buf2.byteOffset, buf2.byteLength);
     }
+    equals(otherBuffer) {
+        if (!Buffer.isBuffer(otherBuffer))
+            throw new TypeError('Argument must be a Buffer');
+        if (this === otherBuffer)
+            return true;
+        return Buffer.compare(this, otherBuffer) === 0;
+    }
     static copyBytesFrom(view, offset, length) {
         if (offset === undefined)
             offset = 0;
@@ -544,6 +554,22 @@ class Buffer extends Uint8Array {
             data: Array.from(this)
         };
     }
+    inspect() {
+        let str = '';
+        const max = 50; // Default max bytes to inspect
+        const len = Math.min(this.length, max);
+        for (let i = 0; i < len; i++) {
+            if (i > 0)
+                str += ' ';
+            str += this[i].toString(16).padStart(2, '0');
+        }
+        if (this.length > max)
+            str += ' ... ' + (this.length - max) + ' more bytes';
+        return '<Buffer ' + str + '>';
+    }
+    [Symbol.for('nodejs.util.inspect.custom')]() {
+        return this.inspect();
+    }
     static isEncoding(encoding) {
         switch (encoding.toLowerCase()) {
             case 'utf8':

package/package.json

@@ -1,55 +1,50 @@
 {
-  "name": "react-native-nitro-buffer",
-  "version": "0.0.1",
-  "description": "Node.js compatible buffer module for React Native",
-  "main": "lib/index.js",
-  "module": "lib/index.js",
-  "types": "lib/index.d.ts",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/iwater/react-native-nitro-buffer.git"
-  },
-  "homepage": "https://github.com/iwater/react-native-nitro-buffer",
-  "scripts": {
-    "build": "tsc",
-    "test": "jest",
-    "prepublishOnly": "npm run build"
-  },
-  "keywords": [
-    "react-native",
-    "ios",
-    "android",
-    "buffer",
-    "node-buffer",
-    "nitro"
-  ],
-  "author": "iwater <iwater@gmail.com>",
-  "license": "ISC",
-  "peerDependencies": {
-    "react": "*",
-    "react-native": "*",
-    "react-native-nitro-modules": "*"
-  },
-  "devDependencies": {
-    "@types/jest": "^30.0.0",
-    "@types/node": "^18.19.130",
-    "@types/react": "*",
-    "jest": "^29.0.0",
-    "react-native-nitro-modules": "*",
-    "ts-jest": "^29.0.0",
-    "typescript": "^5.0.0"
-  },
-  "dependencies": {
-    "react-native-nitro-modules": "*"
-  },
-  "packageManager": "yarn@4.12.0",
-  "files": [
-    "lib/",
-    "src/",
-    "cpp/",
-    "ios/",
-    "android/",
-    "nitrogen/",
-    "*.podspec"
-  ]
-}
+    "name": "react-native-nitro-buffer",
+    "version": "0.0.3",
+    "description": "Node.js compatible buffer module for React Native",
+    "main": "lib/index.js",
+    "module": "lib/index.js",
+    "types": "lib/index.d.ts",
+    "scripts": {
+        "build": "tsc",
+        "test": "jest",
+        "prepublishOnly": "npm run build"
+    },
+    "keywords": [
+        "react-native",
+        "ios",
+        "android",
+        "buffer",
+        "node-buffer",
+        "nitro"
+    ],
+    "author": "iwater <iwater@gmail.com>",
+    "license": "ISC",
+    "peerDependencies": {
+        "react": "*",
+        "react-native": "*",
+        "react-native-nitro-modules": "*"
+    },
+    "devDependencies": {
+        "@types/jest": "^30.0.0",
+        "@types/node": "^18.19.130",
+        "@types/react": "*",
+        "jest": "^29.0.0",
+        "react-native-nitro-modules": "*",
+        "ts-jest": "^29.0.0",
+        "typescript": "^5.0.0"
+    },
+    "dependencies": {
+        "react-native-nitro-modules": "*"
+    },
+    "packageManager": "yarn@4.12.0",
+    "files": [
+        "lib/",
+        "src/",
+        "cpp/",
+        "ios/",
+        "android/",
+        "nitrogen/",
+        "*.podspec"
+    ]
+}

package/react-native-nitro-buffer.podspec

@@ -6,12 +6,12 @@ Pod::Spec.new do |s|
   s.name         = "react-native-nitro-buffer"
   s.version      = package["version"]
   s.summary      = package["description"]
-  s.homepage     = "https://github.com/iwater/react-native-nitro-buffer"
+  s.homepage     = "https://github.com/iwater/rn-http-server"
   s.license      = package["license"]
   s.authors      = package["author"]
   
   s.platform     = :ios, "13.0"
-  s.source       = { :git => "https://github.com/iwater/react-native-nitro-buffer.git", :tag => "v#{s.version}" }
+  s.source       = { :git => "https://github.com/iwater/rn-http-server.git", :tag => "v#{s.version}" }
   
   s.source_files = [
     "ios/**/*.{h,m,mm,swift}",

package/src/Buffer.ts

@@ -12,6 +12,8 @@ function getNative(): NitroBuffer {
 }
 
 export class Buffer extends Uint8Array {
+    static poolSize = 8192
+
     constructor(length: number)
     constructor(array: Uint8Array)
     constructor(arrayBuffer: ArrayBuffer, byteOffset?: number, length?: number)
@@ -59,6 +61,9 @@ export class Buffer extends Uint8Array {
         if (Array.isArray(value)) {
             return new Buffer(new Uint8Array(value).buffer)
         }
+        if (typeof value === 'object' && value !== null && value.type === 'Buffer' && Array.isArray(value.data)) {
+            return new Buffer(value.data)
+        }
         throw new TypeError('Unsupported type for Buffer.from')
     }
 
@@ -100,6 +105,12 @@ export class Buffer extends Uint8Array {
         return getNative().compare(buf1.buffer as ArrayBuffer, buf1.byteOffset, buf1.byteLength, buf2.buffer as ArrayBuffer, buf2.byteOffset, buf2.byteLength)
     }
 
+    equals(otherBuffer: Uint8Array): boolean {
+        if (!Buffer.isBuffer(otherBuffer)) throw new TypeError('Argument must be a Buffer')
+        if (this === otherBuffer) return true
+        return Buffer.compare(this, otherBuffer) === 0
+    }
+
     static copyBytesFrom(view: ArrayBufferView, offset?: number, length?: number): Buffer {
         if (offset === undefined) offset = 0
         if (length === undefined) length = view.byteLength - offset
@@ -598,7 +609,21 @@ export class Buffer extends Uint8Array {
         }
     }
 
-    static poolSize: number = 8192
+    inspect(): string {
+        let str = ''
+        const max = 50 // Default max bytes to inspect
+        const len = Math.min(this.length, max)
+        for (let i = 0; i < len; i++) {
+            if (i > 0) str += ' '
+            str += this[i].toString(16).padStart(2, '0')
+        }
+        if (this.length > max) str += ' ... ' + (this.length - max) + ' more bytes'
+        return '<Buffer ' + str + '>'
+    }
+
+    [Symbol.for('nodejs.util.inspect.custom')]() {
+        return this.inspect()
+    }
 
     static isEncoding(encoding: string): boolean {
         switch (encoding.toLowerCase()) {