WebBuf

WebBuf is a simple Rust library designed to provide efficient base64 and hex encoding/decoding for WebAssembly (WASM) projects, especially targeting JavaScript use cases. It can also be used directly in Rust, where it re-exports functionality from the popular base64 and hex libraries. This library is ideal for developers working with WebAssembly, but its utility extends to general Rust projects as well.

Features

• Base64 encoding/decoding: Convert byte slices to base64 strings and vice versa.
• Hex encoding/decoding: Convert byte slices to hex strings and vice versa.
• Built for WebAssembly: Optimized to work seamlessly in WebAssembly (WASM) and can be easily integrated into JavaScript projects via WASM bindings.
• Re-exports from base64 and hex libraries: Provides a Rust interface for encoding and decoding while making the functions available in WASM for JavaScript.

Installation

To use WebBuf in your Rust project, add the following to your Cargo.toml:

[dependencies]
base64 = "0.13"
hex = "0.4"
wasm-bindgen = "0.2"

To build it for WebAssembly, ensure you have wasm-pack installed:

cargo install wasm-pack

Then, build the library with:

wasm-pack build

Usage

Rust

You can use WebBuf in any Rust project to encode and decode data into base64 or hex strings. Here's an example of how you can use the functions:

use webbuf::{encode_base64, decode_base64, encode_hex, decode_hex};

fn main() {
    // Base64 Encoding
    let data = b"Hello, world!";
    let base64_string = encode_base64(data);
    println!("Base64: {}", base64_string);

    // Base64 Decoding
    let decoded_data = decode_base64(&base64_string).unwrap();
    println!("Decoded: {:?}", decoded_data);

    // Hex Encoding
    let hex_string = encode_hex(data);
    println!("Hex: {}", hex_string);

    // Hex Decoding
    let decoded_hex = decode_hex(&hex_string).unwrap();
    println!("Decoded Hex: {:?}", decoded_hex);
}

WebAssembly (JavaScript)

After compiling WebBuf to WebAssembly, you can use the functions in a JavaScript/TypeScript environment as follows:

import { encode_base64, decode_base64, encode_hex, decode_hex } from "./webbuf_bg.wasm";

// Base64 Encoding
const data = new Uint8Array([72, 101, 108, 108, 111]); // "Hello"
const base64String = encode_base64(data);
console.log(`Base64: ${base64String}`);

// Base64 Decoding
const decodedData = decode_base64(base64String);
console.log(`Decoded: ${new TextDecoder().decode(new Uint8Array(decodedData))}`);

// Hex Encoding
const hexString = encode_hex(data);
console.log(`Hex: ${hexString}`);

// Hex Decoding
const decodedHex = decode_hex(hexString);
console.log(`Decoded Hex: ${new TextDecoder().decode(new Uint8Array(decodedHex))}`);

Methods

• encode_base64(data: &[u8]) -> String: Encodes a byte slice into a base64 string.
• decode_base64(encoded: &str) -> Result<Vec<u8>, String>: Decodes a base64 string into a byte vector. Returns an error string if the decoding fails.
• encode_hex(data: &[u8]) -> String: Encodes a byte slice into a hex string.
• decode_hex(encoded: &str) -> Result<Vec<u8>, String>: Decodes a hex string into a byte vector. Returns an error string if the decoding fails.

Testing

You can run tests on the Rust code using cargo test. The tests cover both valid and invalid cases for base64 and hex encoding/decoding.

cargo test

The tests included in the tests module verify that the library performs encoding and decoding correctly. Example tests:

• Base64 encoding of "Hello, world!" should return "SGVsbG8sIHdvcmxkIQ==".
• Base64 decoding of "SGVsbG8sIHdvcmxkIQ==" should return "Hello, world!".
• Hex encoding of "Hello, world!" should return "48656c6c6f2c20776f726c6421".
• Hex decoding of "48656c6c6f2c20776f726c6421" should return "Hello, world!".

Contributing

Contributions are welcome! Feel free to open issues or submit pull requests to improve WebBuf.

License

This project is licensed under the MIT License.