@xyo-network/hash 4.3.0 → 5.0.1

package/src/spec/ObjectHasher.spec.ts

@@ -0,0 +1,140 @@
+import '@xylabs/vitest-extended'
+
+import {
+  beforeAll, describe, expect, test,
+} from 'vitest'
+
+import { NodeObjectHasher as ObjectHasher } from '../NodeObjectHasher.ts'
+
+const perfIterations = 50
+
+describe('Hasher', () => {
+  const testObject = {
+    testArray: [1, 2, 3],
+    testBoolean: true,
+    testNull: null,
+    testNullObject: { t: null, x: undefined },
+    testNumber: 5,
+    testObject: { t: 1 },
+    testSomeNullObject: {
+      s: 1, t: null, x: undefined,
+    },
+    testString: 'hello there.  this is a pretty long string.  what do you think?',
+    testUndefined: undefined,
+  }
+
+  beforeAll(async () => {
+    await ObjectHasher.wasmInitialized
+  })
+  test('wasm vs js (compatibility-sync)', async () => {
+    ObjectHasher.warnIfUsingJsHash = false
+    ObjectHasher.allowSubtle = false
+    ObjectHasher.wasmSupport.allowWasm = false
+    const jsHash = await ObjectHasher.hash(testObject)
+    ObjectHasher.wasmSupport.allowWasm = true
+    const wasmHash = await ObjectHasher.hash(testObject)
+    expect(jsHash).toEqual(wasmHash)
+  })
+
+  test('wasm vs js (compatibility-async)', async () => {
+    ObjectHasher.warnIfUsingJsHash = false
+    ObjectHasher.allowSubtle = false
+    ObjectHasher.wasmSupport.allowWasm = false
+    const jsHash = await ObjectHasher.hash(testObject)
+    ObjectHasher.wasmSupport.allowWasm = true
+    const wasmHash = await ObjectHasher.hash(testObject)
+    expect(jsHash).toEqual(wasmHash)
+  })
+
+  test('subtle vs js (compatibility-async)', async () => {
+    ObjectHasher.warnIfUsingJsHash = false
+    ObjectHasher.allowSubtle = false
+    ObjectHasher.wasmSupport.allowWasm = false
+    const jsHash = await ObjectHasher.hash(testObject)
+    ObjectHasher.allowSubtle = true
+    const subtleHash = await ObjectHasher.hash(testObject)
+    expect(jsHash).toEqual(subtleHash)
+  })
+
+  test('wasm vs js (performance-serial)', async () => {
+    ObjectHasher.warnIfUsingJsHash = false
+    ObjectHasher.allowSubtle = false
+    ObjectHasher.wasmSupport.allowWasm = false
+    const jsHashStart = Date.now()
+    for (let x = 0; x < perfIterations; x++) {
+      await ObjectHasher.hash({ ...testObject, nonce: x })
+    }
+    const jsHashDuration = Date.now() - jsHashStart
+    ObjectHasher.wasmSupport.allowWasm = true
+    const wasmHashStart = Date.now()
+    for (let x = 0; x < perfIterations; x++) {
+      await ObjectHasher.hash({ ...testObject, nonce: x })
+    }
+    const wasmHashDuration = Date.now() - wasmHashStart
+    expect(wasmHashDuration).toBeDefined()
+    expect(jsHashDuration).toBeDefined()
+    console.log(
+      `Wasm (serial) is ${jsHashDuration - wasmHashDuration}ms (${((1 - wasmHashDuration / jsHashDuration) * 100).toPrecision(
+        2,
+      )}%) faster [${wasmHashDuration}ms vs ${jsHashDuration}ms ]`,
+    )
+  })
+
+  test.skip('wasm vs js (performance-parallel)', async () => {
+    ObjectHasher.warnIfUsingJsHash = false
+    ObjectHasher.allowSubtle = false
+    ObjectHasher.wasmSupport.allowWasm = false
+    const jsTestObjects: ObjectHasher[] = []
+    for (let x = 0; x < perfIterations; x++) {
+      jsTestObjects.push(new ObjectHasher({ ...testObject, nonce: x }))
+    }
+    const jsHashStart = Date.now()
+    await Promise.all(jsTestObjects.map(obj => obj.hash()))
+    const jsHashDuration = Date.now() - jsHashStart
+    ObjectHasher.allowSubtle = false
+    ObjectHasher.wasmSupport.allowWasm = true
+    const wasmTestObjects: ObjectHasher[] = []
+    for (let x = 0; x < perfIterations; x++) {
+      wasmTestObjects.push(new ObjectHasher({ ...testObject, nonce: x }))
+    }
+    const wasmHashStart = Date.now()
+    await Promise.all(wasmTestObjects.map(obj => obj.hash()))
+    const wasmHashDuration = Date.now() - wasmHashStart
+    expect(wasmHashDuration).toBeDefined()
+    expect(jsHashDuration).toBeDefined()
+    console.log(
+      `Wasm (parallel) is ${jsHashDuration - wasmHashDuration}ms (${((1 - wasmHashDuration / jsHashDuration) * 100).toPrecision(
+        2,
+      )}%) faster than js [${wasmHashDuration}ms vs ${jsHashDuration}ms ]`,
+    )
+  })
+
+  test('subtle vs js (performance-parallel)', async () => {
+    ObjectHasher.warnIfUsingJsHash = false
+    ObjectHasher.allowSubtle = false
+    ObjectHasher.wasmSupport.allowWasm = false
+    const jsTestObjects: ObjectHasher[] = []
+    for (let x = 0; x < perfIterations; x++) {
+      jsTestObjects.push(new ObjectHasher({ ...testObject, nonce: x }))
+    }
+    const jsHashStart = Date.now()
+    await Promise.all(jsTestObjects.map(obj => obj.hash()))
+    const jsHashDuration = Date.now() - jsHashStart
+    ObjectHasher.allowSubtle = true
+    ObjectHasher.wasmSupport.allowWasm = false
+    const subtleTestObjects: ObjectHasher[] = []
+    for (let x = 0; x < perfIterations; x++) {
+      subtleTestObjects.push(new ObjectHasher({ ...testObject, nonce: x }))
+    }
+    const subtleHashStart = Date.now()
+    await Promise.all(subtleTestObjects.map(obj => obj.hash()))
+    const subtleHashDuration = Date.now() - subtleHashStart
+    expect(subtleHashDuration).toBeDefined()
+    expect(jsHashDuration).toBeDefined()
+    console.log(
+      `Subtle (parallel) is ${jsHashDuration - subtleHashDuration}ms (${((1 - subtleHashDuration / jsHashDuration) * 100).toPrecision(
+        2,
+      )}%) faster than js [${subtleHashDuration}ms vs ${jsHashDuration}ms ]`,
+    )
+  })
+})

package/src/spec/ObjectHasher.subtle.perf.spec.ts

@@ -0,0 +1,59 @@
+import { NodeObjectHasher as ObjectHasher } from '../NodeObjectHasher.ts'
+
+const perfIterations = 1000
+
+import '@xylabs/vitest-extended'
+
+import {
+  beforeAll, describe, expect, test,
+} from 'vitest'
+
+describe('Hasher - Subtle performance', () => {
+  const testObject = {
+    testArray: [1, 2, 3],
+    testBoolean: true,
+    testNull: null,
+    testNullObject: { t: null, x: undefined },
+    testNumber: 5,
+    testObject: { t: 1 },
+    testSomeNullObject: {
+      s: 1, t: null, x: undefined,
+    },
+    testString: 'hello there.  this is a pretty long string.  what do you think?',
+    testUndefined: undefined,
+  }
+
+  beforeAll(async () => {
+    await ObjectHasher.wasmInitialized
+  })
+  test('subtle vs js (performance-parallel)', async () => {
+    ObjectHasher.warnIfUsingJsHash = false
+    ObjectHasher.allowSubtle = false
+    ObjectHasher.wasmSupport.allowWasm = false
+    const jsTestObjects: ObjectHasher[] = []
+    for (let x = 0; x < perfIterations; x++) {
+      jsTestObjects.push(new ObjectHasher({ ...testObject, nonce: x }))
+    }
+    const jsHashStart = Date.now()
+    await Promise.all(jsTestObjects.map(obj => obj.hash()))
+    const jsHashDuration = Date.now() - jsHashStart
+
+    ObjectHasher.warnIfUsingJsHash = true
+    ObjectHasher.allowSubtle = true
+    ObjectHasher.wasmSupport.allowWasm = false
+    const subtleTestObjects: ObjectHasher[] = []
+    for (let x = 0; x < perfIterations; x++) {
+      subtleTestObjects.push(new ObjectHasher({ ...testObject, nonce: x }))
+    }
+    const subtleHashStart = Date.now()
+    await Promise.all(subtleTestObjects.map(obj => obj.hash()))
+    const subtleHashDuration = Date.now() - subtleHashStart
+    expect(subtleHashDuration).toBeDefined()
+    expect(jsHashDuration).toBeDefined()
+    console.log(
+      `Subtle (parallel) is ${jsHashDuration - subtleHashDuration}ms (${((1 - subtleHashDuration / jsHashDuration) * 100).toPrecision(
+        2,
+      )}%) faster than js [${subtleHashDuration}ms vs ${jsHashDuration}ms ]`,
+    )
+  })
+})

package/src/spec/ObjectHasher.wasm-subtle.perf.spec.ts

@@ -0,0 +1,75 @@
+import '@xylabs/vitest-extended'
+
+import { delay } from '@xylabs/delay'
+import type { AnyObject } from '@xylabs/object'
+import {
+  beforeAll,
+  describe, expect, test,
+} from 'vitest'
+
+import { NodeObjectHasher as ObjectHasher } from '../NodeObjectHasher.ts'
+
+const perfIterations = 1000
+
+describe('Hasher', () => {
+  const testObject = () => ({
+    salt: `${Date.now()}-${Math.floor(Math.random() * 1000)}`,
+    testArray: [1, 2, 3],
+    testBoolean: true,
+    testNull: null,
+    testNullObject: { t: null, x: undefined },
+    testNumber: 5,
+    testObject: { t: 1 },
+    testSomeNullObject: {
+      s: 1, t: null, x: undefined,
+    },
+    testString: 'hello there.  this is a pretty long string.  what do you think?',
+    testUndefined: undefined,
+  })
+
+  beforeAll(async () => {
+    await ObjectHasher.wasmInitialized
+  })
+
+  test('subtle vs wasm (performance-parallel)', async () => {
+    const testObjects: AnyObject[] = []
+    for (let x = 0; x < perfIterations; x++) {
+      testObjects.push(testObject())
+    }
+
+    const subtleHashDuration = await (async () => {
+      ObjectHasher.allowSubtle = true
+      ObjectHasher.wasmSupport.allowWasm = false
+      // prime it
+      await Promise.all([{ length: 8 }].map(async (_, index) => await ObjectHasher.hash(testObjects[index])))
+      const subtleHashStart = Date.now()
+      const subtleResult = await Promise.all(testObjects.map(obj => ObjectHasher.hash(obj)))
+      console.log(`subtleResult count: ${subtleResult.length}`)
+      return Date.now() - subtleHashStart
+    })()
+
+    // allow for cleanup
+    await delay(2000)
+
+    const wasmHashDuration = await (async () => {
+      ObjectHasher.allowSubtle = false
+      ObjectHasher.wasmSupport.allowWasm = true
+      // prime it
+      await Promise.all([{ length: 8 }].map(async (_, index) => await ObjectHasher.hash(testObjects[index])))
+      const wasmHashStart = Date.now()
+      const wasmResult = await Promise.all(testObjects.map(obj => ObjectHasher.hash(obj)))
+      console.log(`wasmResult count: ${wasmResult.length}`)
+      return Date.now() - wasmHashStart
+    })()
+
+    expect(wasmHashDuration).toBeDefined()
+    expect(subtleHashDuration).toBeDefined()
+    console.log(
+      `Subtle (parallel) is ${wasmHashDuration - subtleHashDuration}ms (${((1 - subtleHashDuration / wasmHashDuration) * 100).toPrecision(
+        2,
+      )}%) faster than Wasm [${subtleHashDuration}ms vs ${wasmHashDuration}ms ]`,
+    )
+    console.log(`Wasm Average: ${(wasmHashDuration / perfIterations).toPrecision(2)}ms`)
+    console.log(`Subtle Average: ${(subtleHashDuration / perfIterations).toPrecision(2)}ms`)
+  })
+})

package/src/spec/ObjectHasher.wasm.perf.spec.ts

@@ -0,0 +1,60 @@
+import '@xylabs/vitest-extended'
+
+import {
+  beforeAll,
+  describe, expect, test,
+} from 'vitest'
+
+import { NodeObjectHasher as ObjectHasher } from '../NodeObjectHasher.ts'
+
+const perfIterations = 1000
+
+describe('Hasher', () => {
+  const testObject = {
+    testArray: [1, 2, 3],
+    testBoolean: true,
+    testNull: null,
+    testNullObject: { t: null, x: undefined },
+    testNumber: 5,
+    testObject: { t: 1 },
+    testSomeNullObject: {
+      s: 1, t: null, x: undefined,
+    },
+    testString: 'hello there.  this is a pretty long string.  what do you think?',
+    testUndefined: undefined,
+  }
+
+  beforeAll(async () => {
+    await ObjectHasher.wasmInitialized
+  })
+
+  test('wasm vs js (performance-parallel)', async () => {
+    ObjectHasher.warnIfUsingJsHash = false
+    ObjectHasher.allowSubtle = false
+    ObjectHasher.wasmSupport.allowWasm = false
+    const jsTestObjects: ObjectHasher[] = []
+    for (let x = 0; x < perfIterations; x++) {
+      jsTestObjects.push(new ObjectHasher({ ...testObject, nonce: x }))
+    }
+    const jsHashStart = Date.now()
+    await Promise.all(jsTestObjects.map(obj => obj.hash()))
+    const jsHashDuration = Date.now() - jsHashStart
+    ObjectHasher.warnIfUsingJsHash = true
+    ObjectHasher.allowSubtle = false
+    ObjectHasher.wasmSupport.allowWasm = true
+    const wasmTestObjects: ObjectHasher[] = []
+    for (let x = 0; x < perfIterations; x++) {
+      wasmTestObjects.push(new ObjectHasher({ ...testObject, nonce: x }))
+    }
+    const wasmHashStart = Date.now()
+    await Promise.all(wasmTestObjects.map(obj => obj.hash()))
+    const wasmHashDuration = Date.now() - wasmHashStart
+    expect(wasmHashDuration).toBeDefined()
+    expect(jsHashDuration).toBeDefined()
+    console.log(
+      `Wasm (parallel) is ${jsHashDuration - wasmHashDuration}ms (${((1 - wasmHashDuration / jsHashDuration) * 100).toPrecision(
+        2,
+      )}%) faster than js [${wasmHashDuration}ms vs ${jsHashDuration}ms ]`,
+    )
+  })
+})

package/src/spec/removeEmptyFields.spec.ts

@@ -0,0 +1,31 @@
+import '@xylabs/vitest-extended'
+
+import {
+  describe, expect, test,
+} from 'vitest'
+
+import { removeEmptyFields } from '../removeEmptyFields.ts'
+
+describe('removeEmptyFields', () => {
+  test('deep', () => {
+    const testObject = {
+      testArray: [1, 2, 3],
+      testBoolean: true,
+      testNull: null,
+      testNullObject: { t: null, x: undefined },
+      testNumber: 5,
+      testObject: { t: 1 },
+      testSomeNullObject: {
+        s: 1, t: null, x: undefined,
+      },
+      testString: 'hi',
+      testUndefined: undefined,
+    }
+
+    const result = removeEmptyFields(testObject)
+
+    expect(Object.keys(result).length).toBe(8)
+    expect(Object.keys(result.testSomeNullObject as object).length).toBe(2)
+    expect(Object.keys(result.testNullObject as object).length).toBe(1)
+  })
+})

package/src/types/global.d.ts

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

package/xy.config.ts

@@ -1,9 +0,0 @@
-import type { XyTsupConfig } from '@xylabs/ts-scripts-yarn3'
-const config: XyTsupConfig = {
-  compile: {
-    browser: { src: { entry: ['index-browser.ts', 'worker/subtleHash.ts', 'worker/wasmHash.ts'] } },
-    node: { src: { entry: ['index.ts', 'worker/subtleHashNode.ts', 'worker/wasmHashNode.ts'] } },
-  },
-}
-
-export default config