feat: implement async variant

Author: wemeetagain

hashtree

@@ -5,3 +5,4 @@
 
 export function hash(input: Uint8Array): Uint8Array
 export function hashInto(input: Uint8Array, output: Uint8Array): void
+export function hashAsync(input: Uint8Array): Promise<Uint8Array>

index.d.ts

@@ -310,7 +310,8 @@ if (!nativeBinding) {
   throw new Error(`Failed to load native binding`)
 }
 
-const { hash, hashInto } = nativeBinding
+const { hash, hashInto, hashAsync } = nativeBinding
 
 module.exports.hash = hash
 module.exports.hashInto = hashInto
+module.exports.hashAsync = hashAsync

index.js

@@ -1,7 +1,7 @@
 #![deny(clippy::all)]
 
 use hashtree_rs::{hash as HASH, init};
-use napi::{bindgen_prelude::Uint8Array, Error};
+use napi::{bindgen_prelude::{AsyncTask, Uint8Array}, Env, Error, Task};
 use std::sync::Once;
 
 #[macro_use]
@@ -45,3 +45,25 @@ pub fn hash_into(input: Uint8Array, mut output: Uint8Array) -> Result<(), Error>
   HASH(output.as_mut(), input.as_ref(), output_len / 32);
   Ok(())
 }
+
+pub struct AsyncHash {
+  input: Uint8Array
+}
+
+#[napi]
+impl Task for AsyncHash {
+  type Output = Uint8Array;
+  type JsValue = Uint8Array;
+  fn compute(&mut self) -> Result<Uint8Array, Error> {
+    hash(self.input.clone())
+  }
+
+  fn resolve(&mut self, _env: Env, output: Self::Output) -> Result<Self::JsValue, Error> {
+    Ok(output)
+  }
+}
+
+#[napi]
+pub fn hash_async(input: Uint8Array) -> AsyncTask<AsyncHash> {
+  AsyncTask::new(AsyncHash { input })
+}

src/lib.rs

@@ -1,5 +1,5 @@
 import {createHash} from "node:crypto";
-import {hash, hashInto} from "../index";
+import {hash, hashInto, hashAsync} from "../index";
 
 type BufferLike = string | Uint8Array | Buffer;
 
@@ -49,10 +49,11 @@ function nodeCryptoHashInto(input: Buffer, output: Buffer): void {
 
 describe("should hash similarly to crypto.createHash('sha256')", () => {
   for (let i = 1; i <= 16; i++) {
-    test(`No of Chunks=${i}`, () => {
+    test(`No of Chunks=${i}`, async () => {
       for (let j = 0; j < 255; j++) {
         const input = Buffer.alloc(CHUNK_SIZE * i, j);
         expectEqualHex(hash(input), nodeCryptoHash(input));
+        expectEqualHex(hash(input), await hashAsync(input));
       }
     });
   }