用 Rust 玩一玩 WASM

[package]
name = "modal_particles_wasm"
version = "0.1.0"
edition = "2018"

[lib]
crate-type = ["cdylib", "rlib"]

[features]
default = ["console_error_panic_hook"]

[dependencies]
wasm-bindgen = "0.2.84"

# The `console_error_panic_hook` crate provides better debugging of panics by
# logging them with `console.error`. This is great for development, but requires
# all the `std::fmt` and `std::panicking` infrastructure, so isn't great for
# code size when deploying.
console_error_panic_hook = { version = "0.1.7", optional = true }

modal_particles = { path = "../modal_particles"}

[dev-dependencies]
wasm-bindgen-test = "0.3.34"

[profile.release]
# Tell `rustc` to optimize for small code size.
opt-level = "s"

// 编码
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
    let mut idx=0usize;
    for byte in buf.iter() {
        let (mut ai,mut bi) = (byte & 0xF, (byte >> 4) & 0xF);

        let (a, b) = (
            ID2WORD.get(&(ai as usize)).unwrap(),
            ID2WORD.get(&(bi as usize)).unwrap(),
        );
        self.writer.write_all(a.as_bytes())?;
        self.writer
            .write_all(WORD_DICT2.get(idx).unwrap().as_bytes())?;
        idx = (idx + ai as usize) % WORD_DICT2.len();
        self.writer.write_all(b.as_bytes())?;
        self.writer
            .write_all(WORD_DICT2.get(idx).unwrap().as_bytes())?;
        idx = (idx + bi as usize) % WORD_DICT2.len();
    }
    Ok(buf.len())
}

// 解码
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
    // 因为输入的 buf 照样有可能不是完整的 UTF-8，必要时应截断
    let (s, len) = match std::str::from_utf8(buf) {
        Ok(s) => (s, buf.len()),
        Err(err) => unsafe {
            let valid_len = err.valid_up_to();
            (std::str::from_utf8_unchecked(buf), valid_len)
        },
    };
    // 差不多就行了，别在意
    let mut s = s.to_string();
    for d in WORD_DICT2 {
        s = s.replace(d, "/");
    }
    let u8_list: Vec<_> = s
        .split("/")
        .filter(|x| !x.is_empty())
        .map(|x| WORD2ID.get(x).unwrap())
        .map(|x| *x as u8)
        .collect();
    self.buffer.write_all(&u8_list)?;

    while self.buffer.len() >= 2 {
        let mut t: [u8; 2] = [0, 0];
        self.buffer.read(&mut t)?;
        let t = t[0] | (t[1] << 4);
        self.writer.write(&[t])?;
    }
    Ok(len)
}

use std::io::Write;

use wasm_bindgen::prelude::*;
use modal_particles::{Encoder, Decoder};

#[wasm_bindgen]
pub fn encode(str: &str) -> String {
    let mut encoder = Encoder::new(Vec::new());
    encoder.write_all(str.as_bytes()).unwrap();

    String::from_utf8(encoder.get_writer()).unwrap()
}

#[wasm_bindgen]
pub fn decode(str: &str) -> String {
    let mut decoder = Decoder::new(Vec::new());
    decoder.write_all(str.as_bytes()).unwrap();

    String::from_utf8(decoder.get_writer()).unwrap()
}