Merge pull request #3 from maxjvh/main

Author: pimterry

Cargo.toml

@@ -18,7 +18,9 @@ lto = true
 opt-level = 's'
 
 [dependencies]
-wasm-bindgen = "0.2"
+wasm-bindgen = { version = "0.2", features = ["serde-serialize"] }
 brotli = "3.3"
 wee_alloc = { version = "0.4", optional = true }
-console_error_panic_hook = { version = "0.1", optional = true }
+console_error_panic_hook = { version = "0.1", optional = true }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = { version = "1.0" }

src/lib.rs

@@ -1,5 +1,6 @@
 use brotli;
 use wasm_bindgen::prelude::*;
+use serde::{Serialize, Deserialize};
 
 #[cfg(feature = "wee_alloc")]
 #[global_allocator]
@@ -10,11 +11,40 @@ fn set_panic_hook() {
     console_error_panic_hook::set_once();
 }
 
-#[wasm_bindgen(js_name = compress)]
-pub fn compress(buf: Box<[u8]>) -> Result<Box<[u8]>, JsValue> {
+#[wasm_bindgen(typescript_custom_section)]
+const TS_APPEND_CONTENT: &'static str = r#"
+
+type Options = {
+    quality?: number
+};
+
+export function compress(buf: Uint8Array, options?: Options): Uint8Array;
+"#;
+
+#[derive(Serialize, Deserialize)]
+pub struct Options {
+    #[serde(default = "default_quality")]
+    pub quality: i32
+}
+
+fn default_quality() -> i32 { 11 }
+
+#[wasm_bindgen(js_name = compress, skip_typescript)]
+pub fn compress(buf: Box<[u8]>, raw_options: &JsValue) -> Result<Box<[u8]>, JsValue> {
     set_panic_hook();
+
+    let options: Options;
+    if raw_options.is_undefined() {
+        options = serde_json::from_str("{}").unwrap();
+    } else if raw_options.is_object() {
+        options = raw_options.into_serde().unwrap();
+    } else {
+        return Err(JsValue::from_str("Options is not an object"));
+    }
+    
     let mut out = Vec::<u8>::new();
-    let params = brotli::enc::BrotliEncoderParams::default();
+    let mut params = brotli::enc::BrotliEncoderParams::default();
+    params.quality = options.quality;
 
     match brotli::BrotliCompress(&mut buf.as_ref(), &mut out, &params) {
         Ok(_) => (),

test/brotli.spec.ts

@@ -14,13 +14,38 @@ describe("Brotli-wasm", () => {
         expect(Buffer.from(result).toString('base64')).to.equal('Gw4A+KWpyubolCCjVAjmxJ4D');
     });
 
+    it("can compress data with a different quality setting", () => {
+        const input = Buffer.from("Test input data");
+        const result = brotli.compress(input, { quality: 1 });
+        expect(Buffer.from(result).toString('base64')).to.equal('CweAVGVzdCBpbnB1dCBkYXRhAw==');
+    });
+
     it("can decompress data", () => {
         // Generated with: echo -n '$CONTENT' | brotli --stdout - | base64
         const input = Buffer.from('GxoAABypU587dC0k9ianQOgqjS32iUTcCA==', 'base64');
         const result = brotli.decompress(input);
         expect(Buffer.from(result).toString('utf8')).to.equal('Brotli brotli brotli brotli');
     });
 
+    it("cleanly fails when options is something other than an object", () => {
+        const input = Buffer.from("Test input data");
+        expect(() =>
+            brotli.compress(input, "this should not be a string" as any)
+        ).to.throw('Options is not an object');
+    });
+
+    it("does not fail when options contain unknown properties", () => {
+        const input = Buffer.from("Test input data");
+        const result = brotli.compress(input, { someRandomKey: 1, quality: 5 } as any);
+        expect(Buffer.from(result).toString('base64')).to.equal('CweAVGVzdCBpbnB1dCBkYXRhAw==');
+    });
+
+    it("does not fail when compressing with an illegal quality value", () => {
+        const input = Buffer.from("Test input data");
+        const result = brotli.compress(input, { quality: 12 });
+        expect(Buffer.from(result).toString('base64')).to.equal('Gw4A+KWpyubolCCjVAjmxJ4D');
+    });
+
     it("cleanly fails when decompressing garbage", () => {
         const input = Buffer.from("This is not brotli data, it's just a string");
         expect(() =>
@@ -35,4 +60,12 @@ describe("Brotli-wasm", () => {
         ).toString('utf8');
         expect(result).to.equal(input);
     });
-});
+
+    it("can compress & decompress back to the original result with a different quality setting", () => {
+        const input = "Some thrilling text I urgently need to compress";
+        const result = Buffer.from(
+            brotli.decompress(brotli.compress(Buffer.from(input), { quality: 3 }))
+        ).toString('utf8');
+        expect(result).to.equal(input);
+    });
+});