@xyo-network/core 2.73.4 → 2.74.0

package/src/Hasher/Hasher.ts

@@ -1,96 +0,0 @@
-import { cloneDeep } from '@xylabs/lodash'
-import { sha256 } from 'hash-wasm'
-import shajs from 'sha.js'
-
-import { AnyObject, ObjectWrapper } from '../lib'
-import { WasmSupport } from '../Wasm'
-import { removeEmptyFields } from './removeEmptyFields'
-import { deepOmitUnderscoreFields } from './removeFields'
-import { sortFields } from './sortFields'
-
-const wasmSupportStatic = new WasmSupport(['bigInt'])
-
-export class PayloadHasher<T extends AnyObject = AnyObject> extends ObjectWrapper<T> {
-  static readonly wasmInitialized = wasmSupportStatic.initialize()
-  static readonly wasmSupport = wasmSupportStatic
-
-  /** @deprecated use hashAsync instead */
-  get hash() {
-    // eslint-disable-next-line deprecation/deprecation
-    return PayloadHasher.hash(this.obj)
-  }
-
-  get hashFields() {
-    return PayloadHasher.hashFields(this.obj)
-  }
-
-  get stringified() {
-    return PayloadHasher.stringify(this.obj)
-  }
-
-  static async filterExclude<T extends AnyObject>(objs: T[] = [], hash: string[] | string): 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 filterInclude<T extends AnyObject>(objs: T[] = [], hash: string[] | string): 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 find<T extends AnyObject>(objs: T[] = [], hash: string): Promise<T | undefined> {
-    return (await this.hashPairs(objs)).find(([_, objHash]) => objHash === hash)?.[0]
-  }
-
-  /** @deprecated use hashSync or hashAsync instead */
-  static hash<T extends AnyObject>(obj: T) {
-    return shajs('sha256').update(this.stringify(obj)).digest().toString('hex')
-  }
-
-  static async hashAsync<T extends AnyObject>(obj: T): Promise<string> {
-    await PayloadHasher.wasmInitialized
-    if (PayloadHasher.wasmSupport.canUseWasm) {
-      const stringToHash = PayloadHasher.stringify(obj)
-      try {
-        return await sha256(stringToHash)
-      } catch (ex) {
-        PayloadHasher.wasmSupport.allowWasm = false
-      }
-    }
-    // eslint-disable-next-line deprecation/deprecation
-    return this.hash(obj)
-  }
-
-  static hashFields<T extends AnyObject>(obj: T) {
-    return removeEmptyFields(deepOmitUnderscoreFields(cloneDeep(obj)))
-  }
-
-  static async hashPairs<T extends AnyObject>(objs: T[]): Promise<[T, string][]> {
-    return await Promise.all(objs.map<Promise<[T, string]>>(async (obj) => [obj, await PayloadHasher.hashAsync(obj)]))
-  }
-
-  static hashSync<T extends AnyObject>(obj: T) {
-    return shajs('sha256').update(this.stringify(obj)).digest().toString('hex')
-  }
-
-  static async hashes<T extends AnyObject>(objs: T[]) {
-    return await Promise.all(objs.map((obj) => this.hashAsync(obj)))
-  }
-
-  static stringify<T extends AnyObject>(obj: T) {
-    return JSON.stringify(sortFields(this.hashFields(obj)))
-  }
-
-  static async toMap<T extends AnyObject>(objs: T[]): Promise<Record<string, T>> {
-    const result: Record<string, T> = {}
-    await Promise.all(objs.map(async (obj) => (result[await PayloadHasher.hashAsync(obj)] = obj)))
-    return result
-  }
-
-  async hashAsync() {
-    return await PayloadHasher.hashAsync(this.obj)
-  }
-}
-
-/** @deprecated use PayloadHasher instead */
-export class Hasher<T extends AnyObject = AnyObject> extends PayloadHasher<T> {}

package/src/Hasher/index.ts

@@ -1,4 +0,0 @@
-export * from './Hasher'
-export * from './removeEmptyFields'
-export * from './removeFields'
-export * from './sortFields'

package/src/Hasher/removeEmptyFields.ts

@@ -1,15 +0,0 @@
-import { typeOf } from '@xyo-network/typeof'
-
-export const removeEmptyFields = <T extends Record<string, unknown>>(obj: T) => {
-  if (obj === null || Array.isArray(obj)) return obj
-
-  const newObject: Record<string, unknown> = {}
-  Object.entries(obj).forEach(([key, value]) => {
-    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/Hasher/removeFields.ts

@@ -1,32 +0,0 @@
-import { isObject, mapValues, merge, omitBy, pickBy } from '@xylabs/lodash'
-// eslint-disable-next-line no-restricted-imports
-import type { ValueKeyIteratee } from 'lodash'
-
-import { AnyObject } from '../lib'
-
-export const deepBy = <T extends AnyObject>(obj: T, predicate: ValueKeyIteratee<T>, func: typeof omitBy | typeof pickBy): T => {
-  if (Array.isArray(obj)) {
-    return obj
-  }
-
-  //pick the child objects
-  const onlyObjects = pickBy<T>(obj, isObject)
-
-  //pick the child non-objects
-  const nonObjects = pickBy<T>(obj, (value) => !isObject(value))
-
-  const pickedObjects = omitBy(onlyObjects, predicate)
-  const pickedNonObjects = omitBy(nonObjects, predicate)
-
-  const processedObjects = mapValues(pickedObjects, (obj: T) => deepBy(obj, predicate, func))
-
-  return merge({}, pickedNonObjects, processedObjects) as T
-}
-
-export const deepOmitUnderscoreFields = <T extends AnyObject>(obj: T) => {
-  return deepBy(obj, (_, key) => key.startsWith('_'), omitBy)
-}
-
-export const deepPickUnderscoreFields = <T extends AnyObject>(obj: T) => {
-  return deepBy(obj, (_, key) => key.startsWith('_'), pickBy)
-}

package/src/Hasher/sortFields.ts

@@ -1,29 +0,0 @@
-import { typeOf } from '@xyo-network/typeof'
-
-import { AnyObject, StringKeyObject } from '../lib'
-
-//if an object, sub-sort
-const subSort = (value: unknown) => {
-  switch (typeOf(value)) {
-    case 'object':
-      return sortFields(value as Record<string, unknown>)
-    default:
-      return value
-  }
-}
-
-export const sortFields = <T extends AnyObject = AnyObject>(obj: T) => {
-  if (obj === null) {
-    return null
-  }
-
-  const stringyObj = obj as StringKeyObject
-
-  const result: StringKeyObject = {}
-  Object.keys(stringyObj)
-    .sort()
-    .forEach((key) => {
-      result[key] = subSort(stringyObj[key])
-    })
-  return result as T
-}

package/src/Wasm/WasmSupport.ts

@@ -1,168 +0,0 @@
-import {
-  bigInt,
-  bulkMemory,
-  exceptions,
-  extendedConst,
-  gc,
-  memory64,
-  multiValue,
-  mutableGlobals,
-  referenceTypes,
-  relaxedSimd,
-  saturatedFloatToInt,
-  signExtensions,
-  simd,
-  streamingCompilation,
-  tailCall,
-  threads,
-} from 'wasm-feature-detect'
-
-export const WasmFeatureDetectors = {
-  bigInt: bigInt,
-  bulkMemory: bulkMemory,
-  exceptions: exceptions,
-  extendedConst: extendedConst,
-  gc: gc,
-  memory64: memory64,
-  multiValue: multiValue,
-  mutableGlobals: mutableGlobals,
-  referenceTypes: referenceTypes,
-  relaxedSimd: relaxedSimd,
-  saturatedFloatToInt: saturatedFloatToInt,
-  signExtensions: signExtensions,
-  simd: simd,
-  streamingCompilation: streamingCompilation,
-  tailCall: tailCall,
-  threads: threads,
-} as const
-
-export type WasmFeature = keyof typeof WasmFeatureDetectors
-
-export class WasmSupport {
-  private _allowWasm = true
-  private _featureSupport: Partial<Record<WasmFeature, boolean>> = {}
-  private _forceWasm = false
-  private _isInitialized = false
-  private _isWasmFeatureSetSupported = false
-
-  /**
-   * Instance constructor for use where async instantiation
-   * is not possible. Where possible, prefer the static
-   * create method over use of this constructor directly
-   * as no initialization (feature detection) is able to
-   * be done here
-   * @param desiredFeatures The desired feature set
-   */
-  constructor(protected desiredFeatures: WasmFeature[]) {}
-
-  /**
-   * Is Wasm allowed
-   */
-  get allowWasm(): boolean {
-    return this._allowWasm
-  }
-  /**
-   * Whether or not to allow WASM usage
-   */
-  set allowWasm(v: boolean) {
-    this._allowWasm = v
-  }
-
-  /**
-   * Whether or not Wasm should be used based on the desired
-   * feature set, initialization state, or force-use settings
-   */
-  get canUseWasm(): boolean {
-    return (
-      // Just force WASM
-      this._forceWasm ||
-      // Or if we haven't checked be optimistic
-      (this._allowWasm && !this._isInitialized) ||
-      // Or if we have checked and WASM is not supported, be realistic
-      (this._allowWasm && this._isInitialized && this._isWasmFeatureSetSupported)
-    )
-  }
-
-  /**
-   * Returns a object containing a property for each desired wasm feature
-   * with a boolean value indicating whether or not the feature is supported
-   */
-  get featureSupport(): Readonly<Partial<Record<WasmFeature, boolean>>> {
-    return { ...this._featureSupport }
-  }
-
-  /**
-   * Force use of Wasm
-   */
-  get forceWasm(): boolean {
-    return this._forceWasm
-  }
-  /**
-   * Whether or not to force Wasm usage
-   */
-  set forceWasm(v: boolean) {
-    this._forceWasm = v
-  }
-
-  /**
-   * Whether or not Wasm is supported based
-   * on the desired feature set
-   */
-  get isDesiredFeatureSetSupported(): boolean {
-    return this._isWasmFeatureSetSupported
-  }
-
-  /**
-   * Whether or not Wasm detection has been run
-   * for the desired feature set
-   */
-  get isInitialized(): boolean {
-    return this._isInitialized
-  }
-
-  /**
-   * Static creation & async initialization for use where
-   * async instantiation is possible
-   * @param desiredFeatures The desired feature set
-   * @returns An initialized instance of the class with detection
-   * for the desired feature set
-   */
-  static async create(desiredFeatures: WasmFeature[]): Promise<WasmSupport> {
-    const instance = new WasmSupport(desiredFeatures)
-    await instance.initialize()
-    return Promise.resolve(instance)
-  }
-
-  /**
-   * Checks for specific wasm features
-   * @param features The list of features to check for
-   * @returns True if all the features are supported, false otherwise
-   */
-  async featureCheck(features: WasmFeature[]): Promise<boolean> {
-    const results = await Promise.all(features.map((feature) => WasmFeatureDetectors[feature]).map(async (detector) => await detector()))
-    return results.every((result) => result)
-  }
-
-  /**
-   * Does feature detection for the desired feature set
-   */
-  async initialize(): Promise<void> {
-    if (this._isInitialized) return
-    await this.detectDesiredFeatures()
-    this._isInitialized = true
-    return
-  }
-
-  protected async detectDesiredFeatures(): Promise<void> {
-    for (let feature = 0; feature < this.desiredFeatures.length; feature++) {
-      const desiredFeature = this.desiredFeatures[feature]
-      const detector = WasmFeatureDetectors[desiredFeature]
-      if (!(await detector())) {
-        this._featureSupport[desiredFeature] = false
-      } else {
-        this._featureSupport[desiredFeature] = true
-      }
-    }
-    this._isWasmFeatureSetSupported = Object.values(this._featureSupport).every((v) => v)
-  }
-}

package/src/Wasm/index.ts

@@ -1 +0,0 @@
-export * from './WasmSupport'

package/src/lib/Address/index.ts

@@ -1,2 +0,0 @@
-export * from './normalizeAddress'
-export * from './trimAddressPrefix'

package/src/lib/Address/normalizeAddress.ts

@@ -1,5 +0,0 @@
-import { trimAddressPrefix } from './trimAddressPrefix'
-
-export const normalizeAddress = (address: string) => {
-  return trimAddressPrefix(address.toLowerCase())
-}

package/src/lib/Address/trimAddressPrefix.ts

@@ -1,10 +0,0 @@
-export const addressPrefix = '0x'
-
-// NOTE: To prevent calling `.length` on every invocation, we cache the length
-// but do want to tether it to the length of the actual prefix so it's not some
-// magic number.
-const addressPrefixLength = addressPrefix.length
-
-export const trimAddressPrefix = (address: string) => {
-  return address.toLowerCase().startsWith(addressPrefix) ? address.substring(addressPrefixLength) : address
-}

package/src/lib/AnyObject.ts

@@ -1,2 +0,0 @@
-// eslint-disable-next-line @typescript-eslint/ban-types
-export type AnyObject = {}

package/src/lib/EmptyObject.ts

@@ -1 +0,0 @@
-export type EmptyObject = { [key: string]: never }

package/src/lib/ObjectWrapper.ts

@@ -1,12 +0,0 @@
-import { EmptyObject } from './EmptyObject'
-import { StringKeyObject } from './StringKeyObject'
-
-export abstract class ObjectWrapper<T extends EmptyObject = EmptyObject> {
-  readonly obj: T
-  constructor(obj: T) {
-    this.obj = obj
-  }
-  protected get stringKeyObj() {
-    return this.obj as StringKeyObject
-  }
-}

package/src/lib/StringKeyObject.ts

@@ -1,4 +0,0 @@
-import { AnyObject } from './AnyObject'
-
-export type StringKeyObject = { [key: string]: unknown }
-export type WithAdditional<T, TAdditional extends AnyObject | undefined = undefined> = TAdditional extends AnyObject ? T & TAdditional : T

package/tsup.config.ts

@@ -1,16 +0,0 @@
-import { defineConfig } from 'tsup'
-
-// eslint-disable-next-line import/no-default-export
-export default defineConfig({
-  bundle: true,
-  cjsInterop: true,
-  clean: false,
-  dts: {
-    entry: ['src/index.ts'],
-  },
-  entry: ['src/index.ts'],
-  format: ['cjs', 'esm'],
-  sourcemap: true,
-  splitting: false,
-  tsconfig: 'tsconfig.json',
-})