gzip and zlib support

Cargo.toml

@@ -1,5 +1,5 @@
 [package]
-name = "deflate"
+name = "denoflate"
 version = "0.1.0"
 authors = ["hazae41 <hazae41@gmail.com>"]
 edition = "2018"

README.md

@@ -1,21 +1,24 @@
 # Denoflate
 
-WebAssembly powered Deflate compression for Deno, written in Rust.
+WebAssembly powered Deflate/Gzip/Zlib compression for Deno, written in Rust.
 
 ## Usage
 
-    deno cache https://deno.land/x/denoflate/mod.ts
+    deno cache -r https://deno.land/x/denoflate/mod.ts
 
 ```typescript
 import { deflate, inflate } from "https://deno.land/x/denoflate/mod.ts";
+// or { gzip, gunzip }
+// or { zlib, unzlib }
 
 const bytes = new Uint8Array([1, 2, 3]);
-const compressed = deflate(bytes);
+const compressed = deflate(bytes, undefined);
 const decompressed = inflate(compressed);
 ```
 
 ## Test
 
+    deno cache -r https://deno.land/x/denoflate/test.ts
     deno run --allow-net https://deno.land/x/denoflate/test.ts
 
 ## Building

mod.ts

@@ -1,7 +1,8 @@
-export * from "./pkg/deflate.js";
+// @deno-types=./pkg/denoflate.d.ts
+export * from "./pkg/denoflate.js";
 
-// @deno-types=./pkg/deflate.d.ts
-import init from "./pkg/deflate.js";
+// @deno-types=./pkg/denoflate.d.ts
+import init from "./pkg/denoflate.js";
 
 async function read(path: string) {
   const url = new URL(path, import.meta.url);
@@ -14,4 +15,4 @@ async function read(path: string) {
   return await response.arrayBuffer();
 }
 
-await init(read("./pkg/deflate_bg.wasm"));
+await init(read("./pkg/denoflate_bg.wasm"));

src/lib.rs

@@ -2,10 +2,31 @@ use wasm_bindgen::prelude::*;
 
 use flate2::write::DeflateDecoder;
 use flate2::write::DeflateEncoder;
+
+use flate2::write::GzDecoder;
+use flate2::write::GzEncoder;
+
+use flate2::write::ZlibDecoder;
+use flate2::write::ZlibEncoder;
+
 use flate2::Compression;
 
 use std::io::Write;
 
+#[wasm_bindgen]
+pub fn deflate(input: &[u8], compression: Option<u32>) -> Result<Vec<u8>, JsValue> {
+    let _compression = compression
+        .map(|x| Compression::new(x))
+        .unwrap_or(Compression::default());
+
+    let mut encoder = DeflateEncoder::new(Vec::new(), _compression);
+
+    encoder
+        .write_all(input)
+        .and_then(|_| encoder.finish())
+        .map_err(|e| JsValue::from(&format!("{:?}: {}", e.kind(), e)))
+}
+
 #[wasm_bindgen]
 pub fn inflate(input: &[u8]) -> Result<Vec<u8>, JsValue> {
     let mut decoder = DeflateDecoder::new(Vec::new());
@@ -17,8 +38,46 @@ pub fn inflate(input: &[u8]) -> Result<Vec<u8>, JsValue> {
 }
 
 #[wasm_bindgen]
-pub fn deflate(input: &[u8]) -> Result<Vec<u8>, JsValue> {
-    let mut encoder = DeflateEncoder::new(Vec::new(), Compression::default());
+pub fn gzip(input: &[u8], compression: Option<u32>) -> Result<Vec<u8>, JsValue> {
+    let _compression = compression
+        .map(|x| Compression::new(x))
+        .unwrap_or(Compression::default());
+
+    let mut encoder = GzEncoder::new(Vec::new(), _compression);
+
+    encoder
+        .write_all(input)
+        .and_then(|_| encoder.finish())
+        .map_err(|e| JsValue::from(&format!("{:?}: {}", e.kind(), e)))
+}
+
+#[wasm_bindgen]
+pub fn gunzip(input: &[u8]) -> Result<Vec<u8>, JsValue> {
+    let mut encoder = GzDecoder::new(Vec::new());
+
+    encoder
+        .write_all(input)
+        .and_then(|_| encoder.finish())
+        .map_err(|e| JsValue::from(&format!("{:?}: {}", e.kind(), e)))
+}
+
+#[wasm_bindgen]
+pub fn zlib(input: &[u8], compression: Option<u32>) -> Result<Vec<u8>, JsValue> {
+    let _compression = compression
+        .map(|x| Compression::new(x))
+        .unwrap_or(Compression::default());
+
+    let mut encoder = ZlibEncoder::new(Vec::new(), _compression);
+
+    encoder
+        .write_all(input)
+        .and_then(|_| encoder.finish())
+        .map_err(|e| JsValue::from(&format!("{:?}: {}", e.kind(), e)))
+}
+
+#[wasm_bindgen]
+pub fn unzlib(input: &[u8]) -> Result<Vec<u8>, JsValue> {
+    let mut encoder = ZlibDecoder::new(Vec::new());
 
     encoder
         .write_all(input)

test.ts

@@ -1,10 +1,26 @@
-import { inflate, deflate } from "./mod.ts";
+import { inflate, deflate, gzip, gunzip, zlib, unzlib } from "./mod.ts";
 
 const bytes = new Uint8Array([1, 2, 3]);
 console.log(bytes);
 
-const compressed = deflate(bytes);
-console.log(compressed);
+function test_deflate() {
+  const compressed = deflate(bytes, undefined);
+  const decompressed = inflate(compressed);
+  console.log(decompressed);
+}
 
-const decompressed = inflate(compressed);
-console.log(decompressed);
+function test_gzip() {
+  const compressed = gzip(bytes, undefined);
+  const decompressed = gunzip(compressed);
+  console.log(decompressed);
+}
+
+function test_zlib() {
+  const compressed = zlib(bytes, undefined);
+  const decompressed = unzlib(compressed);
+  console.log(decompressed);
+}
+
+test_deflate();
+test_gzip();
+test_zlib();