@xyo-network/hash 5.3.22 → 5.3.24

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xyo-network/hash",
-  "version": "5.3.22",
+  "version": "5.3.24",
   "description": "Primary SDK for using XYO Protocol 2.0",
   "homepage": "https://xyo.network",
   "bugs": {
@@ -44,45 +44,37 @@
   "types": "dist/neutral/index.d.ts",
   "files": [
     "dist",
-    "src",
     "!**/*.bench.*",
     "!**/*.spec.*",
     "!**/*.test.*",
     "README.md"
   ],
-  "scripts": {
-    "bundle": "yarn subtleHashBundle && yarn wasmHashBundle",
-    "package-build": "echo build && package-build-only && yarn bundle && yarn publint",
-    "package-compile": "echo compile && package-compile-only && yarn bundle && yarn publint",
-    "subtleHashBundle": "esbuild src/worker/subtleHash.ts --bundle --outfile=dist/browser/worker/subtleHash-bundle.mjs --target=chrome120,firefox120,safari14,edge120",
-    "wasmHashBundle": "esbuild src/worker/wasmHash.ts --bundle --outfile=dist/browser/worker/wasmHash-bundle.mjs --target=chrome120,firefox120,safari14,edge120"
-  },
   "dependencies": {
-    "@xylabs/threads": "~5.0.91",
-    "@xyo-network/wasm": "~5.3.22",
-    "hash-wasm": "~4.12.0"
+    "@xylabs/threads": "~5.0.93",
+    "hash-wasm": "~4.12.0",
+    "@xyo-network/wasm": "~5.3.24"
   },
   "devDependencies": {
     "@opentelemetry/api": "^1.9.1",
     "@types/node": "^25.5.0",
-    "@xylabs/hex": "^5.0.91",
-    "@xylabs/platform": "^5.0.91",
-    "@xylabs/sdk-js": "^5.0.91",
-    "@xylabs/ts-scripts-common": "~7.6.8",
-    "@xylabs/ts-scripts-yarn3": "~7.6.8",
-    "@xylabs/tsconfig": "~7.6.8",
-    "@xylabs/vitest-extended": "~5.0.91",
+    "@xylabs/hex": "^5.0.93",
+    "@xylabs/platform": "^5.0.93",
+    "@xylabs/sdk-js": "^5.0.93",
+    "@xylabs/threads": "~5.0.93",
+    "@xylabs/ts-scripts-common": "~7.6.16",
+    "@xylabs/ts-scripts-pnpm": "~7.6.16",
+    "@xylabs/tsconfig": "~7.6.16",
+    "@xylabs/vitest-extended": "~5.0.93",
     "acorn": "^8.16.0",
     "axios": "^1.14.0",
-    "cosmiconfig": "^9.0.1",
-    "esbuild": "~0.27.4",
-    "eslint": "^10.1.0",
+    "esbuild": "~0.28.0",
+    "hash-wasm": "~4.12.0",
     "publint": "~0.3.18",
-    "rollup": "^4.60.1",
     "typescript": "~5.9.3",
     "vite": "^8.0.3",
     "vitest": "~4.1.2",
-    "zod": "^4.3.6"
+    "zod": "^4.3.6",
+    "@xyo-network/wasm": "~5.3.24"
   },
   "peerDependencies": {
     "@xylabs/sdk-js": "^5",
@@ -90,5 +82,12 @@
   },
   "publishConfig": {
     "access": "public"
+  },
+  "scripts": {
+    "bundle": "pnpm subtleHashBundle && pnpm wasmHashBundle",
+    "package-build": "echo build && package-build-only && pnpm bundle && pnpm publint",
+    "package-compile": "echo compile && package-compile-only && pnpm bundle && pnpm publint",
+    "subtleHashBundle": "esbuild src/worker/subtleHash.ts --bundle --outfile=dist/browser/worker/subtleHash-bundle.mjs --target=chrome120,firefox120,safari17,edge120",
+    "wasmHashBundle": "esbuild src/worker/wasmHash.ts --bundle --outfile=dist/browser/worker/wasmHash-bundle.mjs --target=chrome120,firefox120,safari17,edge120"
   }
-}
+}

package/src/BrowserObjectHasher.ts

@@ -1,28 +0,0 @@
-import type { EmptyObject } from '@xylabs/sdk-js'
-
-import { createBrowserWorker } from './createBrowserWorker.ts'
-import { createNodeWorker } from './createNodeWorker.ts'
-import { ObjectHasher } from './ObjectHasher.ts'
-
-ObjectHasher.createBrowserWorker = createBrowserWorker
-ObjectHasher.createNodeWorker = createNodeWorker
-
-export class BrowserObjectHasher<T extends EmptyObject = EmptyObject> extends ObjectHasher<T> {
-  static override readonly createBrowserWorker = createBrowserWorker
-  static override readonly createNodeWorker = createNodeWorker
-  static override readonly subtleHashWorkerUrl = (() => {
-    try {
-      return new URL('worker/subtleHash-bundle.mjs', import.meta.url)
-    } catch {
-      return
-    }
-  })()
-
-  static override readonly wasmHashWorkerUrl = (() => {
-    try {
-      return new URL('worker/wasmHash-bundle.mjs', import.meta.url)
-    } catch {
-      return
-    }
-  })()
-}

package/src/NodeObjectHasher.ts

@@ -1,10 +0,0 @@
-import type { EmptyObject } from '@xylabs/sdk-js'
-
-import { createNodeWorker } from './createNodeWorker.ts'
-import { ObjectHasher } from './ObjectHasher.ts'
-
-ObjectHasher.createNodeWorker = createNodeWorker
-
-export class NodeObjectHasher<T extends EmptyObject = EmptyObject> extends ObjectHasher<T> {
-  static override readonly createNodeWorker = createNodeWorker
-}

package/src/ObjectHasher.ts

@@ -1,213 +0,0 @@
-/* eslint-disable sonarjs/public-static-readonly */
-
-import type { EmptyObject, Hash } from '@xylabs/sdk-js'
-import {
-  asHash, assertEx,
-  hexFromArrayBuffer, ObjectWrapper, omitBy, subtle,
-} from '@xylabs/sdk-js'
-import type { ModuleThread, Worker } from '@xylabs/threads/master'
-import { Pool, spawn } from '@xylabs/threads/master'
-import { WasmSupport } from '@xyo-network/wasm'
-import { sha256 } from 'hash-wasm'
-
-import { removeEmptyFields } from './removeEmptyFields.ts'
-import { sortFields } from './sortFields.ts'
-import { subtleHashFunc, wasmHashFunc } from './worker/index.ts'
-
-export type WorkerFunction = ((...args: unknown[]) => unknown) | (() => unknown)
-export type WorkerModule<Keys extends string> = {
-  [key in Keys]: WorkerFunction
-}
-
-const wasmSupportStatic = new WasmSupport(['bigInt'])
-
-const omitByPredicate = (prefix: string) => (_: unknown, key: string) => {
-  assertEx(typeof key === 'string', () => `Invalid key type [${String(key)}, ${typeof key}]`)
-  return String(key).startsWith(prefix)
-}
-
-export class ObjectHasher<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 readonly subtleHashWorkerUrl?: URL
-
-  static warnIfUsingJsHash = true
-
-  static readonly wasmHashWorkerUrl?: URL
-
-  static readonly wasmInitialized = wasmSupportStatic.initialize()
-  static readonly wasmSupport = wasmSupportStatic
-
-  // eslint-disable-next-line @typescript-eslint/no-explicit-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>>> | null
-
-  private static get subtleHashPool() {
-    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() {
-    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): Worker {
-    if (url) console.debug(`createWorker: ${url}`)
-    return assertEx(this.createBrowserWorker?.(url) ?? this.createNodeWorker?.(func), () => 'Unable to create worker')
-  }
-
-  static async filterExcludeByHash<T extends EmptyObject>(objs: T[] = [], hash: Hash[] | Hash): Promise<T[]> {
-    const hashes = Array.isArray(hash) ? hash : [hash]
-    return (await this.hashPairs(objs)).filter(([_, objHash]) => !hashes.includes(objHash))?.map(pair => pair[0])
-  }
-
-  static async filterIncludeByHash<T extends EmptyObject>(objs: T[] = [], hash: Hash[] | Hash): Promise<T[]> {
-    const hashes = Array.isArray(hash) ? hash : [hash]
-    return (await this.hashPairs(objs)).filter(([_, objHash]) => hashes.includes(objHash))?.map(pair => pair[0])
-  }
-
-  static async findByHash<T extends EmptyObject>(objs: T[] = [], hash: Hash): Promise<T | undefined> {
-    return (await this.hashPairs(objs)).find(([_, objHash]) => objHash === hash)?.[0]
-  }
-
-  /**
-   * Asynchronously hashes a payload
-   * @param obj A payload
-   * @returns The payload hash
-   */
-  static async hash<T extends EmptyObject>(obj: T): Promise<Hash> {
-    const stringToHash = this.stringifyHashFields(obj)
-    const enc = new TextEncoder()
-    const data = enc.encode(stringToHash)
-
-    if (ObjectHasher.allowSubtle) {
-      try {
-        const hashArray = await this.subtleHash(data)
-        return hexFromArrayBuffer(hashArray, { bitLength: 256 }) as Hash
-      } catch {
-        ObjectHasher.allowSubtle = false
-      }
-    }
-
-    await this.wasmInitialized
-    if (this.wasmSupport.canUseWasm) {
-      try {
-        return await this.wasmHash(data)
-      } catch {
-        this.wasmSupport.allowWasm = false
-      }
-    }
-    throw new Error('No subtle or wasm hashing available')
-  }
-
-  static async hashBytes(bytes: ArrayBuffer | Uint8Array): Promise<Hash> {
-    const bytesArray = new Uint8Array(bytes)
-    if (ObjectHasher.allowSubtle) {
-      const hashArray = await this.subtleHash(bytesArray)
-      return hexFromArrayBuffer(hashArray, { bitLength: 256 }) as Hash
-    } else {
-      await this.wasmInitialized
-      if (this.wasmSupport.canUseWasm) {
-        return await this.wasmHash(bytesArray)
-      }
-      throw new Error('No subtle or wasm hashing available')
-    }
-  }
-
-  static hashFields<T extends EmptyObject>(obj: T): T {
-    return sortFields(removeEmptyFields(omitBy(obj, omitByPredicate('_')))) as T
-  }
-
-  /**
-   * Creates an array of payload/hash tuples based on the payloads passed in
-   * @param objs Any array of payloads
-   * @returns An array of payload/hash tuples
-   */
-  static async hashPairs<T extends EmptyObject>(objs: T[]): Promise<[T, Hash][]> {
-    return await Promise.all(objs.map<Promise<[T, Hash]>>(async obj => [obj, await ObjectHasher.hash(obj)]))
-  }
-
-  /**
-   * Creates an array of payload hashes based on the payloads passed in
-   * @param objs Any array of payloads
-   * @returns An array of payload hashes
-   */
-  static async hashes<T extends EmptyObject>(objs?: T[]): Promise<Hash[] | undefined> {
-    return objs ? await Promise.all(objs.map(obj => this.hash(obj))) : undefined
-  }
-
-  /**
-   * Returns a clone of the payload that is JSON safe
-   * @param obj A payload
-   * @param meta Keeps underscore (meta) fields if set to true
-   * @returns Returns a clone of the payload that is JSON safe
-   */
-  static json<T extends EmptyObject>(payload: T, meta = false): T {
-    return sortFields(removeEmptyFields(meta ? payload : omitBy(payload, omitByPredicate('_')))) as T
-  }
-
-  /** @deprecated us json instead */
-  static jsonPayload<T extends EmptyObject>(payload: T, meta = false): T {
-    return this.json(payload, meta)
-  }
-
-  static stringifyHashFields<T extends EmptyObject>(obj: T) {
-    return JSON.stringify(this.hashFields(obj))
-  }
-
-  static async subtleHash(data: Uint8Array<ArrayBuffer>): Promise<ArrayBuffer> {
-    const pool = this.subtleHashPool
-    return pool === null ? await subtle.digest('SHA-256', data) : pool.queue(async thread => await thread.hash(data))
-  }
-
-  static async wasmHash(data: Uint8Array): Promise<Hash> {
-    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
-  private static createWorkerPool<T extends WorkerModule<any>>(url?: URL, func?: () => unknown, size = 8) {
-    if (url) console.debug(`createWorkerPool: ${url}`)
-    const createFunc = () => spawn<T>(this.createWorker(url, func))
-    return Pool(createFunc, size)
-  }
-
-  async hash(): Promise<Hash> {
-    return await ObjectHasher.hash(this.obj)
-  }
-
-  /**
-   * Returns a clone of the payload that is JSON safe
-   * @param meta Keeps underscore (meta) fields if set to true
-   * @returns Returns a clone of the payload that is JSON safe
-   */
-  json(meta = false): T {
-    return ObjectHasher.json(this.obj, meta)
-  }
-}
-
-/** @deprecated use PayloadBuilder or ObjectHasher instead */
-export class PayloadHasher<T extends object> extends ObjectHasher<T> {}

package/src/createBrowserWorker.ts

@@ -1,10 +0,0 @@
-import { Worker } from '@xylabs/threads/master'
-
-export const createBrowserWorker = (url?: URL): Worker => {
-  try {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    return new Worker(url as any)
-  } catch {
-    throw new Error('Unable to create worker')
-  }
-}

package/src/createNodeWorker.ts

@@ -1,14 +0,0 @@
-import { Worker } from '@xylabs/threads/master'
-
-export const createNodeWorker = (func?: () => unknown): Worker => {
-  try {
-    const code = func?.toString().slice(6) ?? ''
-    return new Worker(
-      code,
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      { fromSource: true } as any,
-    )
-  } catch {
-    throw new Error('Unable to create worker')
-  }
-}

package/src/hasEmptyFields.ts

@@ -1,17 +0,0 @@
-import type { EmptyObject } from '@xylabs/sdk-js'
-import { typeOf } from '@xylabs/sdk-js'
-
-export const hasEmptyFields = <T extends EmptyObject>(obj: T): boolean => {
-  if (obj == null || Array.isArray(obj)) return false
-
-  if (obj == undefined || Object.keys(obj).length === 0) return true
-
-  for (const [value] of Object.values(obj)) {
-    if (typeOf(value) === 'object') {
-      if (hasEmptyFields(value as Record<string, unknown>)) return true
-    } else if (value === undefined) {
-      return true
-    }
-  }
-  return false
-}

package/src/index-browser.ts

@@ -1,3 +0,0 @@
-export { BrowserObjectHasher as ObjectHasher } from './BrowserObjectHasher.ts'
-export * from './removeEmptyFields.ts'
-export * from './sortFields.ts'

package/src/index.ts

@@ -1,4 +0,0 @@
-export * from './hasEmptyFields.ts'
-export { NodeObjectHasher as ObjectHasher } from './NodeObjectHasher.ts'
-export * from './removeEmptyFields.ts'
-export * from './sortFields.ts'

package/src/removeEmptyFields.ts

@@ -1,20 +0,0 @@
-import type { AnyObject, EmptyObject } from '@xylabs/sdk-js'
-import { typeOf } from '@xylabs/sdk-js'
-
-export const removeEmptyFields = <T extends EmptyObject>(obj: T): T => {
-  if (obj == null) return obj
-
-  if (Array.isArray(obj)) {
-    return obj.map(value => (typeof value === 'object' ? removeEmptyFields(value) : value)) as T
-  }
-
-  const newObject: AnyObject = {}
-  for (const [key, value] of Object.entries(obj)) {
-    if (typeOf(value) === 'object') {
-      newObject[key] = removeEmptyFields(value as Record<string, unknown>)
-    } else if (value !== undefined) {
-      newObject[key] = value
-    }
-  }
-  return newObject as T
-}

package/src/sortFields.ts

@@ -1,17 +0,0 @@
-import type { AnyObject, EmptyObject } from '@xylabs/sdk-js'
-import { isObject } from '@xylabs/sdk-js'
-
-// if an object, sub-sort
-const subSort = (value: unknown) => {
-  return isObject(value) ? sortFields(value) : value
-}
-
-export const sortFields = <T extends EmptyObject>(obj: T) => {
-  const result: AnyObject = {}
-  const keys = Object.keys(obj) as (keyof T)[]
-  // eslint-disable-next-line sonarjs/no-alphabetical-sort
-  for (const key of keys.toSorted()) {
-    result[key] = subSort(obj[key])
-  }
-  return result as T
-}

package/src/types/global.d.ts

@@ -1,5 +0,0 @@
-export declare global {
-  var xyo: {
-    hashing?: boolean
-  }
-}

package/src/worker/index.ts

@@ -1,2 +0,0 @@
-export * from './subtleHashNode.ts'
-export * from './wasmHashNode.ts'

package/src/worker/subtleHash.ts

@@ -1,8 +0,0 @@
-import { subtle } from '@xylabs/sdk-js'
-import { expose } from '@xylabs/threads/worker'
-
-expose({
-  async hash(data: ArrayBuffer) {
-    return await subtle.digest('SHA-256', data)
-  },
-})

package/src/worker/subtleHashNode.ts

@@ -1,11 +0,0 @@
-/* eslint-disable @typescript-eslint/no-require-imports */
-export const subtleHashFunc = () => {
-  const { subtle } = require('@xylabs/platform')
-  const { expose } = require('@xylabs/threads/worker')
-
-  expose({
-    async hash(data: ArrayBuffer) {
-      return await subtle.digest('SHA-256', data)
-    },
-  })
-}

package/src/worker/wasmHash.ts

@@ -1,9 +0,0 @@
-import { asHash } from '@xylabs/sdk-js'
-import { expose } from '@xylabs/threads/worker'
-import { sha256 } from 'hash-wasm'
-
-expose({
-  async hash(data: string) {
-    return asHash(await sha256(data), true)
-  },
-})

package/src/worker/wasmHashNode.ts

@@ -1,13 +0,0 @@
-/* eslint-disable @typescript-eslint/no-require-imports */
-export const wasmHashFunc = () => {
-  const { sha256 } = require('hash-wasm')
-  const { asHash } = require('@xylabs/hex')
-
-  const { expose } = require('@xylabs/threads/worker')
-
-  expose({
-    async hash(data: string) {
-      return asHash(await sha256(data), true)
-    },
-  })
-}