@rasmx/hash 1.0.0 → 1.0.2

package/index.d.ts

@@ -1,106 +1,113 @@
 export type InputData = string | Uint8Array | ArrayBuffer | SharedArrayBuffer;
 
 export interface HashFamily {
-    v224: (d: InputData) => Promise<string>;
-    v256: (d: InputData) => Promise<string>;
-    v384: (d: InputData) => Promise<string>;
-    v512: (d: InputData) => Promise<string>;
-    v512_224: (d: InputData) => Promise<string>;
-    v512_256: (d: InputData) => Promise<string>;
+    v224: (d: InputData) => string;
+    v256: (d: InputData) => string;
+    v384: (d: InputData) => string;
+    v512: (d: InputData) => string;
+    v512_224: (d: InputData) => string;
+    v512_256: (d: InputData) => string;
 }
 
 export const hash: {
     sha2: HashFamily;
-    sha3: HashFamily;
+    sha3: {
+        v224: (d: InputData) => string;
+        v256: (d: InputData) => string;
+        v384: (d: InputData) => string;
+        v512: (d: InputData) => string;
+    };
     keccak: HashFamily;
-    blake3: (d: InputData, key?: InputData) => Promise<string>;
+    blake3: (d: InputData, key?: InputData) => string;
     shake: {
-        v128: (d: InputData, len: number) => Promise<string>;
-        v256: (d: InputData, len: number) => Promise<string>;
+        v128: (d: InputData, len: number) => string;
+        v256: (d: InputData, len: number) => string;
     };
     xxh: {
-        v32: (d: InputData, seed?: number) => Promise<string>;
-        v64: (d: InputData, seed?: bigint) => Promise<string>;
-        v3_64: (d: InputData) => Promise<string>;
-        v3_64_seed: (d: InputData, seed: bigint) => Promise<string>;
-        v3_128: (d: InputData) => Promise<string>;
-        v3_128_seed: (d: InputData, seed: bigint) => Promise<string>;
+        v32: (d: InputData, seed?: number) => string;
+        v64: (d: InputData, seed?: bigint) => string;
+        v3_64: (d: InputData) => string;
+        v3_64_seed: (d: InputData, seed: bigint) => string;
+        v3_128: (d: InputData) => string;
+        v3_128_seed: (d: InputData, seed: bigint) => string;
     };
     hmac: {
-        sha256: (key: InputData, d: InputData) => Promise<string>;
-        sha512: (key: InputData, d: InputData) => Promise<string>;
+        sha256: (key: InputData, d: InputData) => string;
+        sha512: (key: InputData, d: InputData) => string;
     };
-    md5: (d: InputData) => Promise<string>;
-    stream: (readable: ReadableStream, hasher: any) => Promise<string>;
+    md5: (d: InputData) => string;
+    stream: (readable: ReadableStream, hasher: IHasher) => Promise<string>;
 };
 
 export interface IHasher {
-    update(d: InputData): Promise<void>;
-    finalize(): Promise<string>;
-    free(): Promise<void>;
+    update(d: InputData): void;
+    finalize(): string;
+    free(): void;
 }
 
 export class IncrementalSha256 implements IHasher {
     constructor();
-    update(d: InputData): Promise<void>;
-    finalize(): Promise<string>;
-    free(): Promise<void>;
+    update(d: InputData): void;
+    finalize(): string;
+    free(): void;
 }
 
 export class IncrementalSha512 implements IHasher {
     constructor();
-    update(d: InputData): Promise<void>;
-    finalize(): Promise<string>;
-    free(): Promise<void>;
+    update(d: InputData): void;
+    finalize(): string;
+    free(): void;
 }
 
 export class IncrementalMd5 implements IHasher {
     constructor();
-    update(d: InputData): Promise<void>;
-    finalize(): Promise<string>;
-    free(): Promise<void>;
+    update(d: InputData): void;
+    finalize(): string;
+    free(): void;
 }
 
 export class IncrementalBlake3 implements IHasher {
     constructor();
-    update(d: InputData): Promise<void>;
-    finalize(): Promise<string>;
-    free(): Promise<void>;
+    update(d: InputData): void;
+    finalize(): string;
+    free(): void;
 }
 
 export class IncrementalXxh3 {
     constructor();
-    update(d: InputData): Promise<void>;
-    finalize64(): Promise<string>;
-    finalize128(): Promise<string>;
-    finalize(): Promise<string>;
-    free(): Promise<void>;
+    update(d: InputData): void;
+    finalize64(): string;
+    finalize128(): string;
+    finalize(): string;
+    free(): void;
 }
 
 export class IncrementalXxh32 implements IHasher {
     constructor(seed?: number);
-    update(d: InputData): Promise<void>;
-    finalize(): Promise<string>;
-    free(): Promise<void>;
+    update(d: InputData): void;
+    finalize(): string;
+    free(): void;
 }
 
 export class IncrementalXxh64 implements IHasher {
     constructor(seed?: bigint);
-    update(d: InputData): Promise<void>;
-    finalize(): Promise<string>;
-    free(): Promise<void>;
+    update(d: InputData): void;
+    finalize(): string;
+    free(): void;
 }
 
 export class IncrementalSha3_256 implements IHasher {
     constructor();
-    update(d: InputData): Promise<void>;
-    finalize(): Promise<string>;
-    free(): Promise<void>;
+    update(d: InputData): void;
+    finalize(): string;
+    free(): void;
 }
 
 export class IncrementalKeccak256 implements IHasher {
     constructor();
-    update(d: InputData): Promise<void>;
-    finalize(): Promise<string>;
-    free(): Promise<void>;
-}
+    update(d: InputData): void;
+    finalize(): string;
+    free(): void;
+}
+
+export default function init(input?: string | URL | Request): Promise<void>;

package/index.js

@@ -1,13 +1,17 @@
-import init, * as wasm from './pkg/rasmx_hash.js';
+import initWasm, * as wasm from './pkg/rasmx_hash.js';
 
 let ready = false;
-async function ensure() {
-    if (!ready) {
-        await init();
-        ready = true;
-    }
+
+export default async function init(input) {
+    if (ready) return;
+    await initWasm(input);
+    ready = true;
 }
 
+const check = () => {
+    if (!ready) throw new Error("@rasmx/hash: WASM module not initialized. Call 'await init()' once before use.");
+};
+
 function toBuf(data) {
     if (data instanceof Uint8Array) return data;
     if (typeof data === 'string') return new TextEncoder().encode(data);
@@ -19,63 +23,72 @@ function toBuf(data) {
 
 export const hash = {
     sha2: {
-        v224: async (d) => { await ensure(); return wasm.sha2_224(toBuf(d)); },
-        v256: async (d) => { await ensure(); return wasm.sha2_256(toBuf(d)); },
-        v384: async (d) => { await ensure(); return wasm.sha2_384(toBuf(d)); },
-        v512: async (d) => { await ensure(); return wasm.sha2_512(toBuf(d)); },
-        v512_224: async (d) => { await ensure(); return wasm.sha2_512_224(toBuf(d)); },
-        v512_256: async (d) => { await ensure(); return wasm.sha2_512_256(toBuf(d)); }
+        v224: (d) => { check(); return wasm.sha2_224(toBuf(d)); },
+        v256: (d) => { check(); return wasm.sha2_256(toBuf(d)); },
+        v384: (d) => { check(); return wasm.sha2_384(toBuf(d)); },
+        v512: (d) => { check(); return wasm.sha2_512(toBuf(d)); },
+        v512_224: (d) => { check(); return wasm.sha2_512_224(toBuf(d)); },
+        v512_256: (d) => { check(); return wasm.sha2_512_256(toBuf(d)); }
     },
     sha3: {
-        v224: async (d) => { await ensure(); return wasm.sha3_224(toBuf(d)); },
-        v256: async (d) => { await ensure(); return wasm.sha3_256(toBuf(d)); },
-        v384: async (d) => { await ensure(); return wasm.sha3_384(toBuf(d)); },
-        v512: async (d) => { await ensure(); return wasm.sha3_512(toBuf(d)); }
+        v224: (d) => { check(); return wasm.sha3_224(toBuf(d)); },
+        v256: (d) => { check(); return wasm.sha3_256(toBuf(d)); },
+        v384: (d) => { check(); return wasm.sha3_384(toBuf(d)); },
+        v512: (d) => { check(); return wasm.sha3_512(toBuf(d)); }
     },
     keccak: {
-        v224: async (d) => { await ensure(); return wasm.keccak_224(toBuf(d)); },
-        v256: async (d) => { await ensure(); return wasm.keccak_256(toBuf(d)); },
-        v384: async (d) => { await ensure(); return wasm.keccak_384(toBuf(d)); },
-        v512: async (d) => { await ensure(); return wasm.keccak_512(toBuf(d)); }
+        v224: (d) => { check(); return wasm.keccak_224(toBuf(d)); },
+        v256: (d) => { check(); return wasm.keccak_256(toBuf(d)); },
+        v384: (d) => { check(); return wasm.keccak_384(toBuf(d)); },
+        v512: (d) => { check(); return wasm.keccak_512(toBuf(d)); }
     },
     shake: {
-        v128: async (d, len) => { await ensure(); return wasm.shake128(toBuf(d), len); },
-        v256: async (d, len) => { await ensure(); return wasm.shake256(toBuf(d), len); }
+        v128: (d, len) => { check(); return wasm.shake128(toBuf(d), len); },
+        v256: (d, len) => { check(); return wasm.shake256(toBuf(d), len); }
     },
-    blake3: async (d, key = null) => { 
-        await ensure(); 
+    blake3: (d, key = null) => { 
+        check(); 
         return key ? wasm.blake3_keyed_hex(toBuf(d), toBuf(key)) : wasm.blake3_hex(toBuf(d)); 
     },
     xxh: {
-        v32: async (d, seed = 0) => { await ensure(); return wasm.xxh32_hex(toBuf(d), seed); },
-        v64: async (d, seed = 0n) => { await ensure(); return wasm.xxh64_hex(toBuf(d), BigInt(seed)); },
-        v3_64: async (d) => { await ensure(); return wasm.xxh3_64_hex(toBuf(d)); },
-        v3_64_seed: async (d, seed) => { await ensure(); return wasm.xxh3_64_seed_hex(toBuf(d), BigInt(seed)); },
-        v3_128: async (d) => { await ensure(); return wasm.xxh3_128_hex(toBuf(d)); },
-        v3_128_seed: async (d, seed) => { await ensure(); return wasm.xxh3_128_seed_hex(toBuf(d), BigInt(seed)); }
+        v32: (d, seed = 0) => { check(); return wasm.xxh32_hex(toBuf(d), seed); },
+        v64: (d, seed = 0n) => { check(); return wasm.xxh64_hex(toBuf(d), BigInt(seed)); },
+        v3_64: (d) => { check(); return wasm.xxh3_64_hex(toBuf(d)); },
+        v3_64_seed: (d, seed) => { check(); return wasm.xxh3_64_seed_hex(toBuf(d), BigInt(seed)); },
+        v3_128: (d) => { check(); return wasm.xxh3_128_hex(toBuf(d)); },
+        v3_128_seed: (d, seed) => { check(); return wasm.xxh3_128_seed_hex(toBuf(d), BigInt(seed)); }
     },
     hmac: {
-        sha256: async (key, d) => { await ensure(); return wasm.hmac_sha256(toBuf(key), toBuf(d)); },
-        sha512: async (key, d) => { await ensure(); return wasm.hmac_sha512(toBuf(key), toBuf(d)); }
+        sha256: (key, d) => { check(); return wasm.hmac_sha256(toBuf(key), toBuf(d)); },
+        sha512: (key, d) => { check(); return wasm.hmac_sha512(toBuf(key), toBuf(d)); }
     },
-    md5: async (d) => { await ensure(); return wasm.md5_hex(toBuf(d)); },
+    md5: (d) => { check(); return wasm.md5_hex(toBuf(d)); },
+    
     stream: async (readable, hasher) => {
         const reader = readable.getReader();
-        while (true) {
-            const { done, value } = await reader.read();
-            if (done) break;
-            await hasher.update(value);
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done) break;
+                hasher.update(value);
+            }
+            return hasher.finalize();
+        } finally {
+            if (hasher.free) hasher.free();
         }
-        const res = await hasher.finalize();
-        if (hasher.free) await hasher.free();
-        return res;
     }
 };
 
 class BaseIncremental {
-    constructor() { this.p = ensure(); this.i = null; }
-    async free() {
-        await this.p;
+    constructor(wasmClassInstance) {
+        check();
+        this.i = wasmClassInstance;
+    }
+    update(d) { 
+        if (!this.i) throw new Error("Hasher already finalized or freed");
+        this.i.update(toBuf(d)); 
+    }
+    free() {
         if (this.i) {
             this.i.free();
             this.i = null;
@@ -84,57 +97,98 @@ class BaseIncremental {
 }
 
 export class IncrementalSha256 extends BaseIncremental {
-    constructor() { super(); this.p = this.p.then(() => this.i = new wasm.IncrementalSha256()); }
-    async update(d) { await this.p; this.i.update(toBuf(d)); }
-    async finalize() { await this.p; return this.i.finalize(); }
+    constructor() { super(new wasm.IncrementalSha256()); }
+    finalize() { 
+        if (!this.i) throw new Error("Hasher already finalized or freed");
+        const res = this.i.finalize(); 
+        this.i = null; 
+        return res;
+    }
 }
 
 export class IncrementalSha512 extends BaseIncremental {
-    constructor() { super(); this.p = this.p.then(() => this.i = new wasm.IncrementalSha512()); }
-    async update(d) { await this.p; this.i.update(toBuf(d)); }
-    async finalize() { await this.p; return this.i.finalize(); }
+    constructor() { super(new wasm.IncrementalSha512()); }
+    finalize() { 
+        if (!this.i) throw new Error("Hasher already finalized or freed");
+        const res = this.i.finalize(); 
+        this.i = null; 
+        return res;
+    }
 }
 
 export class IncrementalSha3_256 extends BaseIncremental {
-    constructor() { super(); this.p = this.p.then(() => this.i = new wasm.IncrementalSha3_256()); }
-    async update(d) { await this.p; this.i.update(toBuf(d)); }
-    async finalize() { await this.p; return this.i.finalize(); }
+    constructor() { super(new wasm.IncrementalSha3_256()); }
+    finalize() { 
+        if (!this.i) throw new Error("Hasher already finalized or freed");
+        const res = this.i.finalize(); 
+        this.i = null; 
+        return res;
+    }
 }
 
 export class IncrementalKeccak256 extends BaseIncremental {
-    constructor() { super(); this.p = this.p.then(() => this.i = new wasm.IncrementalKeccak256()); }
-    async update(d) { await this.p; this.i.update(toBuf(d)); }
-    async finalize() { await this.p; return this.i.finalize(); }
+    constructor() { super(new wasm.IncrementalKeccak256()); }
+    finalize() { 
+        if (!this.i) throw new Error("Hasher already finalized or freed");
+        const res = this.i.finalize(); 
+        this.i = null; 
+        return res;
+    }
 }
 
 export class IncrementalMd5 extends BaseIncremental {
-    constructor() { super(); this.p = this.p.then(() => this.i = new wasm.IncrementalMd5()); }
-    async update(d) { await this.p; this.i.update(toBuf(d)); }
-    async finalize() { await this.p; return this.i.finalize(); }
+    constructor() { super(new wasm.IncrementalMd5()); }
+    finalize() { 
+        if (!this.i) throw new Error("Hasher already finalized or freed");
+        const res = this.i.finalize(); 
+        this.i = null; 
+        return res;
+    }
 }
 
 export class IncrementalBlake3 extends BaseIncremental {
-    constructor() { super(); this.p = this.p.then(() => this.i = new wasm.IncrementalBlake3()); }
-    async update(d) { await this.p; this.i.update(toBuf(d)); }
-    async finalize() { await this.p; return this.i.finalize(); }
+    constructor() { super(new wasm.IncrementalBlake3()); }
+    finalize() { 
+        if (!this.i) throw new Error("Hasher already finalized or freed");
+        const res = this.i.finalize(); 
+        this.i = null; 
+        return res;
+    }
 }
 
 export class IncrementalXxh3 extends BaseIncremental {
-    constructor() { super(); this.p = this.p.then(() => this.i = new wasm.IncrementalXxh3()); }
-    async update(d) { await this.p; this.i.update(toBuf(d)); }
-    async finalize64() { await this.p; return this.i.finalize_64(); }
-    async finalize128() { await this.p; return this.i.finalize_128(); }
-    async finalize() { return this.finalize64(); }
+    constructor() { super(new wasm.IncrementalXxh3()); }
+    finalize64() { 
+        if (!this.i) throw new Error("Hasher already finalized or freed");
+        const res = this.i.finalize_64(); 
+        this.i = null; 
+        return res;
+    }
+    finalize128() { 
+        if (!this.i) throw new Error("Hasher already finalized or freed");
+        const res = this.i.finalize_128(); 
+        this.i = null; 
+        return res;
+    }
+    finalize() { return this.finalize64(); }
 }
 
 export class IncrementalXxh32 extends BaseIncremental {
-    constructor(seed = 0) { super(); this.p = this.p.then(() => this.i = new wasm.IncrementalXxh32(seed)); }
-    async update(d) { await this.p; this.i.update(toBuf(d)); }
-    async finalize() { await this.p; return this.i.finalize(); }
+    constructor(seed = 0) { super(new wasm.IncrementalXxh32(seed)); }
+    finalize() { 
+        if (!this.i) throw new Error("Hasher already finalized or freed");
+        const res = this.i.finalize(); 
+        this.i = null; 
+        return res;
+    }
 }
 
 export class IncrementalXxh64 extends BaseIncremental {
-    constructor(seed = 0n) { super(); this.p = this.p.then(() => this.i = new wasm.IncrementalXxh64(BigInt(seed))); }
-    async update(d) { await this.p; this.i.update(toBuf(d)); }
-    async finalize() { await this.p; return this.i.finalize(); }
+    constructor(seed = 0n) { super(new wasm.IncrementalXxh64(BigInt(seed))); }
+    finalize() { 
+        if (!this.i) throw new Error("Hasher already finalized or freed");
+        const res = this.i.finalize(); 
+        this.i = null; 
+        return res;
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rasmx/hash",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Blazing fast WASM hashing library powered by Rust. Support for SHA2, SHA3, Keccak, XXHash, and MD5 with streaming support.",
   "publishConfig": {
     "access": "public"