@xyo-network/hash 2.90.17 → 2.90.19

package/src/PayloadHasher.ts

@@ -1,7 +1,9 @@
 import { assertEx } from '@xylabs/assert'
 import { asHash, Hash, hexFromArrayBuffer } from '@xylabs/hex'
 import { EmptyObject, ObjectWrapper } from '@xylabs/object'
+import { subtle } from '@xylabs/platform'
 import { WasmSupport } from '@xyo-network/wasm'
+import { sha256 } from 'hash-wasm'
 import shajs from 'sha.js'
 import { ModuleThread, Pool, spawn, Worker } from 'threads'
 // eslint-disable-next-line import/no-internal-modules
@@ -15,10 +17,19 @@ import { jsHashFunc, subtleHashFunc, wasmHashFunc } from './worker'
 const wasmSupportStatic = new WasmSupport(['bigInt'])
 
 export class PayloadHasher<T extends EmptyObject = EmptyObject> extends ObjectWrapper<T> {
+  static allowHashPooling = true
   static allowSubtle = true
   static createBrowserWorker?: (url?: URL) => Worker | undefined
   static createNodeWorker?: (func?: () => unknown) => Worker | undefined
 
+  static initialized = (() => {
+    globalThis.xyo = globalThis.xyo ?? {}
+    if (globalThis.xyo.hashing) {
+      console.warn('Two static instances of PayloadHasher detected')
+    }
+    globalThis.xyo === globalThis.xyo ?? { hashing: PayloadHasher }
+  })()
+
   static jsHashWorkerUrl?: URL
   static subtleHashWorkerUrl?: URL
 
@@ -29,23 +40,52 @@ export class PayloadHasher<T extends EmptyObject = EmptyObject> extends ObjectWr
   static readonly wasmInitialized = wasmSupportStatic.initialize()
   static readonly wasmSupport = wasmSupportStatic
 
+  // These get set to null if they fail to create and then we just don't use workers - needed for storybook
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  private static _jsHashPool?: Pool<ModuleThread<WorkerModule<any>>>
+  private static _jsHashPool?: Pool<ModuleThread<WorkerModule<any>>> | null
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  private static _subtleHashPool?: Pool<ModuleThread<WorkerModule<any>>>
+  private static _subtleHashPool?: Pool<ModuleThread<WorkerModule<any>>> | null
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  private static _wasmHashPool?: Pool<ModuleThread<WorkerModule<any>>>
+  private static _wasmHashPool?: Pool<ModuleThread<WorkerModule<any>>> | null
 
   private static get jsHashPool() {
-    return (this._jsHashPool = this._jsHashPool ?? this.createWorkerPool(this.jsHashWorkerUrl, jsHashFunc))
+    if (!this.allowHashPooling || this._jsHashPool === null) {
+      return null
+    }
+    try {
+      return (this._jsHashPool = this._jsHashPool ?? this.jsHashWorkerUrl ? this.createWorkerPool(this.jsHashWorkerUrl, jsHashFunc) : null)
+    } catch {
+      console.warn('Creating js hash worker failed')
+      this._jsHashPool = null
+      return null
+    }
   }
 
   private static get subtleHashPool() {
-    return (this._subtleHashPool = this._subtleHashPool ?? this.createWorkerPool(this.subtleHashWorkerUrl, subtleHashFunc))
+    if (!this.allowHashPooling || this._subtleHashPool === null) {
+      return null
+    }
+    try {
+      return (this._subtleHashPool =
+        this._subtleHashPool ?? this.subtleHashWorkerUrl ? this.createWorkerPool(this.subtleHashWorkerUrl, subtleHashFunc) : null)
+    } catch {
+      console.warn('Creating subtle hash worker failed')
+      this._subtleHashPool = null
+      return null
+    }
   }
 
   private static get wasmHashPool() {
-    return (this._wasmHashPool = this._wasmHashPool ?? this.createWorkerPool(this.wasmHashWorkerUrl, wasmHashFunc))
+    if (!this.allowHashPooling || this._wasmHashPool === null) {
+      return null
+    }
+    try {
+      return (this._wasmHashPool = this._wasmHashPool ?? this.wasmHashWorkerUrl ? this.createWorkerPool(this.wasmHashWorkerUrl, wasmHashFunc) : null)
+    } catch {
+      console.warn('Creating wasm hash worker failed')
+      this._wasmHashPool = null
+      return null
+    }
   }
 
   static createWorker(url?: URL, func?: () => unknown) {
@@ -131,7 +171,10 @@ export class PayloadHasher<T extends EmptyObject = EmptyObject> extends ObjectWr
     if (PayloadHasher.warnIfUsingJsHash) {
       console.warn('Using jsHash [No subtle or wasm?]')
     }
-    return await this.jsHashPool.queue(async (thread) => await thread.hash(data))
+    const pool = this.jsHashPool
+    return pool === null
+      ? asHash(shajs('sha256').update(data).digest().toString('hex'), true)
+      : await pool.queue(async (thread) => await thread.hash(data))
   }
 
   /**
@@ -154,11 +197,13 @@ export class PayloadHasher<T extends EmptyObject = EmptyObject> extends ObjectWr
   }
 
   static async subtleHash(data: Uint8Array): Promise<ArrayBuffer> {
-    return await this.subtleHashPool.queue(async (thread) => await thread.hash(data))
+    const pool = this.subtleHashPool
+    return pool === null ? await subtle.digest('SHA-256', data) : await pool.queue(async (thread) => await thread.hash(data))
   }
 
   static async wasmHash(data: string) {
-    return await this.wasmHashPool.queue(async (thread) => await thread.hash(data))
+    const pool = this.wasmHashPool
+    return pool === null ? asHash(await sha256(data), true) : pool.queue(async (thread) => await thread.hash(data))
   }
 
   // eslint-disable-next-line @typescript-eslint/no-explicit-any

package/src/globals.d.ts

@@ -0,0 +1,6 @@
+declare module globalThis {
+  // eslint-disable-next-line no-var
+  var xyo: {
+    hashing?: PayloadHasher
+  }
+}