@sanctumterra/raknet 1.2.71 → 1.3.1

package/.github/workflows/publish.yml

@@ -0,0 +1,84 @@
+name: Build & Publish
+
+on:
+  push:
+    branches:
+      - develop
+      - main
+
+jobs:
+  build:
+    needs: [lint]
+    permissions:
+      id-token: write
+      contents: read
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+        
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        
+      - name: Setup Rust toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+          override: true
+
+      - name: Install Rust dependencies
+        run: |
+          rustup target add x86_64-pc-windows-msvc 
+          rustup target add x86_64-apple-darwin 
+          rustup target add aarch64-apple-darwin 
+          rustup target add x86_64-unknown-linux-gnu 
+          rustup target add aarch64-unknown-linux-gnu 
+          rustup target add aarch64-linux-android 
+          rustup target add x86_64-linux-android 
+
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20.x'
+          registry-url: 'https://registry.npmjs.org'
+          
+      - name: Install dependencies
+        run: npm install
+        
+      - name: NAPI build
+        run: npm run build:rust
+        
+      - name: TypeScript build
+        run: npm run build:ts
+
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Node.js for linting
+        uses: actions/setup-node@v4 
+        with:
+          node-version: '20.x'
+      - name: Install dependencies for linting
+        run: npm install
+      - name: Run lint
+        run: npm run lint
+
+  publish:
+    needs: build  # Ensures this job runs after the build job completes successfully.
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository for publishing
+        uses: actions/checkout@v4
+
+      - name: Set up Node.js for publishing
+        uses: actions/setup-node@v4 
+        with:
+          node-version: '20.x'
+          registry-url: 'https://registry.npmjs.org'
+
+      - name: Publish package
+        run: npm publish --access=public
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/.gitignore

@@ -0,0 +1,7 @@
+/node_modules
+/target
+/build
+test.ts
+Cargo.lock
+package-lock.json
+dist/

package/Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "raknet"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+chrono = "0.4.38"
+rand = "0.8.5"
+napi = "2"
+napi-derive = "2"

package/package.json

@@ -1,25 +1,59 @@
 {
   "name": "@sanctumterra/raknet",
-  "version": "1.2.71",
-  "description": "",
+  "version": "1.3.1",
   "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "scripts": {
-    "build": "tsc",
-    "format": "npx @biomejs/biome format ./src",
-    "lint": "npx @biomejs/biome lint ./src",
-    "lint-write": "npx @biomejs/biome lint --write ./src",
-    "format-write": "npx @biomejs/biome format --write ./src"
+    "build:rust": "napi build --platform --release build",
+    "build:ts": "tsc",
+    "dev": "npm run build:rust && npm run build:ts",
+    "format": "npx @biomejs/biome format ./src_client",
+    "lint": "npx @biomejs/biome lint ./src_client",
+    "lint:write": "npx @biomejs/biome lint --write ./src_client",
+    "format:write": "npx @biomejs/biome format --write ./src_client",
+    "test": "echo \"Error: no test specified\" && exit 1"
   },
-  "keywords": [],
+  "keywords": [
+    "raknet",
+    "napi",
+    "rust",
+    "native"
+  ],
   "author": "",
   "license": "ISC",
-  "dependencies": {
-    "reflect-metadata": "^0.2.2",
-    "@serenityjs/emitter": "^0.5.2",
-    "@serenityjs/binarystream": "^2.6.6"
+  "description": "RakNet implementation in Rust with Node.js bindings",
+  "napi": {
+    "name": "raknet",
+    "triples": {
+      "defaults": true,
+      "additional": [
+        "x86_64-pc-windows-msvc",
+        "x86_64-apple-darwin",
+        "aarch64-apple-darwin",
+        "x86_64-unknown-linux-gnu",
+        "aarch64-unknown-linux-gnu"
+      ]
+    }
   },
   "devDependencies": {
     "@biomejs/biome": "^1.9.4",
-    "@types/node": "^22.8.0"
+    "@napi-rs/cli": "^2.18.4",
+    "@types/node": "^22.9.0",
+    "typescript": "^5.6.3"
+  },
+  "engines": {
+    "node": ">= 20"
+  },
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "build",
+    "dist",
+    ""
+  ],
+  "dependencies": {
+    "@serenityjs/binarystream": "^2.6.6",
+    "@serenityjs/emitter": "^0.5.2",
+    "reflect-metadata": "^0.2.2"
   }
 }

package/src/binarystream/binarystream.rs

@@ -0,0 +1,313 @@
+use std::error::Error;
+
+use super::Endianness;
+
+#[derive(Debug)]
+pub enum BinaryStreamError {
+    OutOfBounds,
+    InvalidLength,
+}
+
+impl std::fmt::Display for BinaryStreamError {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "{:?}", self)
+    }
+}
+
+impl Error for BinaryStreamError {}
+
+#[derive(Debug)]
+pub struct BinaryStream {
+    pub binary: Vec<u8>,
+    offset: u32
+}
+
+impl BinaryStream {
+    pub fn new(binary: Option<Vec<u8>>, offset: Option<u32>) -> Self {
+        let bin = match binary {
+            Some(buffer) => buffer,
+            None => vec![],
+          };
+      
+          let offset = match offset {
+            Some(offset) => offset,
+            None => 0,
+          };
+      
+        BinaryStream {
+            binary: bin,
+            offset,
+        }
+    }
+
+    pub fn from(binary: Vec<u8>, offset: Option<u32>) -> Self {
+        let offset = match offset {
+            Some(offset) => offset,
+            None => 0,
+        };
+    
+        BinaryStream {
+          binary: binary,
+          offset,
+        }
+    }
+
+    pub fn read(&mut self, length: u32) -> Result<Vec<u8>, BinaryStreamError> {
+        if length > self.binary.len() as u32 {
+            return Err(BinaryStreamError::InvalidLength);
+        }
+    
+        if self.offset + length > self.binary.len() as u32 {
+            return Err(BinaryStreamError::OutOfBounds);
+        }
+    
+        let start = self.offset as usize;
+        let end = (self.offset + length) as usize;
+        self.offset += length;
+    
+        Ok(self.binary[start..end].to_vec())
+    }
+
+    pub fn write(&mut self, data: Vec<u8>) {
+        self.binary.extend(data);
+    }
+
+    pub fn read_remaining(&mut self) -> Vec<u8> {
+        let start = self.offset as usize;
+        let end = self.binary.len();
+        self.offset = end as u32;
+    
+        self.binary[start..end].to_vec()
+    }
+
+    pub fn skip(&mut self, length: u32) {
+        self.offset += length;
+    }
+
+    pub fn cursor_at_end(&self) -> bool {
+        self.offset == self.binary.len() as u32
+    }
+    
+    pub fn cursor_at_start(&self) -> bool {
+        self.offset == 0
+    }
+
+    pub fn get_offset(&self) -> u32 {
+        self.offset
+    }
+
+    pub fn read_bytes(&mut self, length: u32) -> Result<Vec<u8>, BinaryStreamError> {
+        Ok(self.read(length)?)
+    }
+
+    pub fn write_bytes(&mut self, data: Vec<u8>) {
+        self.write(data);
+    }
+
+    pub fn read_u8(&mut self) -> Result<u8, BinaryStreamError> {
+        let bytes = self.read(1)?;
+        Ok(bytes[0])
+    }
+
+    pub fn write_u8(&mut self, value: u8) {
+        self.write(vec![value]);
+    }
+
+    pub fn read_magic(&mut self) -> Result<Vec<u8>, BinaryStreamError> {
+        let magic = self.read(16)?;
+        Ok(magic)
+    }
+
+    pub fn write_magic(&mut self, magic: Vec<u8>) {
+        self.write(magic);
+    }
+
+    pub fn read_u16(&mut self, endianness: Option<Endianness>) -> Result<u16, BinaryStreamError> {
+        let bytes = self.read(2)?;
+        Ok(match endianness.unwrap_or(Endianness::Big) {
+            Endianness::Big => u16::from_be_bytes(bytes.try_into().unwrap()),
+            Endianness::Little => u16::from_le_bytes(bytes.try_into().unwrap()),
+        })
+    }
+
+    pub fn write_u16(&mut self, value: u16, endianness: Option<Endianness>) {
+        let bytes = match endianness.unwrap_or(Endianness::Big) {
+            Endianness::Big => value.to_be_bytes(),
+            Endianness::Little => value.to_le_bytes(),
+        };
+        self.write(bytes.to_vec());
+    }
+
+    pub fn read_u64(&mut self, endianness: Option<Endianness>) -> Result<u64, BinaryStreamError> {
+        let bytes = self.read(8)?;
+        let bytes: [u8; 8] = bytes.try_into()
+            .map_err(|_| BinaryStreamError::InvalidLength)?;
+            
+        Ok(match endianness.unwrap_or(Endianness::Little) {
+            Endianness::Big => u64::from_be_bytes(bytes),
+            Endianness::Little => u64::from_le_bytes(bytes),
+        })
+    }
+
+    pub fn write_u64(&mut self, value: u64, endianness: Option<Endianness>) {
+        let bytes = match endianness.unwrap_or(Endianness::Little) {
+            Endianness::Big => value.to_be_bytes(),
+            Endianness::Little => value.to_le_bytes(),
+        };
+        self.write(bytes.to_vec());
+    }
+
+    pub fn read_u32(&mut self, endianness: Option<Endianness>) -> Result<u32, BinaryStreamError> {
+        let endian = match endianness {
+            Some(endian) => endian,
+            None => Endianness::Big,
+        };
+      
+        let bytes = match self.read(4) {
+            Ok(bytes) => bytes,
+            Err(err) => return Err(err)
+        };
+          
+        match endian {
+            Endianness::Big => Ok(u32::from_be_bytes([bytes[0], bytes[1], bytes[2], bytes[3]])),
+            Endianness::Little => Ok(u32::from_le_bytes([bytes[0], bytes[1], bytes[2], bytes[3]])),
+        }
+    }
+
+    pub fn write_u32(&mut self, value: u32, endianness: Option<Endianness>) {
+        let endian = match endianness {
+            Some(endian) => endian,
+            None => Endianness::Big,
+        };
+        match endian {
+            Endianness::Big => self.write(value.to_be_bytes().to_vec()),
+            Endianness::Little => self.write(value.to_le_bytes().to_vec()),
+        }
+    }
+
+    pub fn read_bool(&mut self) -> Result<bool, BinaryStreamError> {
+        let value = self.read_u8()?;
+        Ok(value != 0)
+    }
+
+    pub fn write_bool(&mut self, value: bool) {
+        self.write_u8(if value { 1 } else { 0 });
+    }
+
+    pub fn read_u24(&mut self, endianness: Option<Endianness>) -> Result<u32, BinaryStreamError> {
+        let endian = match endianness {
+            Some(endian) => endian,
+            None => Endianness::Big,
+        };
+          
+        let bytes = match self.read(3) {
+            Ok(bytes) => bytes,
+            Err(err) => return Err(err)
+        };
+      
+        match endian {
+            Endianness::Big => Ok(u32::from_be_bytes([0, bytes[0], bytes[1], bytes[2]])),
+            Endianness::Little => Ok(u32::from_le_bytes([bytes[0], bytes[1], bytes[2], 0])),
+        }
+    }
+
+    pub fn write_u24(&mut self, value: u32, endianness: Option<Endianness>) {
+        let endian = match endianness {
+            Some(endian) => endian,
+            None => Endianness::Big,
+        };
+      
+        match endian {
+            Endianness::Big => self.write(value.to_be_bytes()[1..].to_vec()),
+            Endianness::Little => self.write(value.to_le_bytes()[..3].to_vec()),
+        }    
+    }
+
+    pub fn read_i16(&mut self, endianness: Option<Endianness>) -> Result<i16, BinaryStreamError> {
+        let endian = match endianness {
+            Some(endian) => endian,
+            None => Endianness::Big,
+        };
+      
+        let bytes = match self.read(2) {
+            Ok(bytes) => bytes,
+            Err(err) => return Err(err)
+        };
+      
+        match endian {
+            Endianness::Big => Ok(i16::from_be_bytes([bytes[0], bytes[1]])),
+            Endianness::Little => Ok(i16::from_le_bytes([bytes[0], bytes[1]])),
+        }
+    }
+
+    pub fn write_i16(&mut self, value: i16, endianness: Option<Endianness>) {
+        let endian = match endianness {
+            Some(endian) => endian,
+            None => Endianness::Big,
+        };
+
+        match endian {
+            Endianness::Big => self.write(value.to_be_bytes().to_vec()),
+            Endianness::Little => self.write(value.to_le_bytes().to_vec()),
+        }
+    }
+
+    pub fn read_i64(&mut self, endianness: Option<Endianness>) -> Result<i64, BinaryStreamError> {
+        let bytes = self.read(8)?;
+        let bytes: [u8; 8] = bytes.try_into()
+            .map_err(|_| BinaryStreamError::InvalidLength)?;
+        Ok(match endianness.unwrap_or(Endianness::Big) {
+            Endianness::Big => i64::from_be_bytes(bytes),
+            Endianness::Little => i64::from_le_bytes(bytes),
+        })
+    }
+
+    pub fn write_i64(&mut self, value: i64, endianness: Option<Endianness>) {
+        let endian = match endianness {
+            Some(endian) => endian,
+            None => Endianness::Big,
+        };
+      
+        match endian {
+            Endianness::Big => self.write(value.to_be_bytes().to_vec()),
+            Endianness::Little => self.write(value.to_le_bytes().to_vec()),
+        }
+    }
+
+    pub fn read_long(&mut self, endianness: Option<Endianness>) -> Result<i64, BinaryStreamError> {
+        Ok(self.read_i64(Some(endianness.unwrap_or(Endianness::Big)))?)
+    }
+
+    pub fn write_long(&mut self, value: i64, endianness: Option<Endianness>) {
+        self.write_i64(value, Some(endianness.unwrap_or(Endianness::Big)));
+    }
+
+    pub fn read_short(&mut self, endianness: Option<Endianness>) -> Result<u16, BinaryStreamError> {
+        let bytes = self.read(2)?;
+
+        match endianness.unwrap_or(Endianness::Big) {
+            Endianness::Big => Ok((bytes[0] as u16) << 8 | bytes[1] as u16),
+            Endianness::Little => Ok((bytes[1] as u16) << 8 | bytes[0] as u16),
+        }
+    }
+
+    pub fn write_short(&mut self, value: u16, endianness: Option<Endianness>) {
+        match endianness.unwrap_or(Endianness::Big) {
+            Endianness::Big => {
+                self.write(vec![(value >> 8) as u8, (value & 0xFF) as u8]);
+            },
+            Endianness::Little => {
+                self.write(vec![(value & 0xFF) as u8, (value >> 8) as u8]);
+            }
+        }
+    }
+
+    pub fn read_byte(&mut self) -> Result<u8, BinaryStreamError> {
+        let byte = self.read(1)?;
+        Ok(byte[0])
+    }
+
+    pub fn write_byte(&mut self, value: u8) {
+        self.write(vec![value]);
+    }
+}

package/src/binarystream/endianess.rs

@@ -0,0 +1,5 @@
+#[derive(Debug)]
+pub enum Endianness {
+    Big,
+    Little,
+}

package/src/binarystream/mod.rs

@@ -0,0 +1,6 @@
+pub mod binarystream;
+pub mod endianess;
+
+pub use binarystream::BinaryStream;
+pub use binarystream::BinaryStreamError;
+pub use endianess::Endianness;