@xylabs/hex 5.0.5 → 5.0.6

package/src/address/address.ts

@@ -1,85 +1,15 @@
-import { isObject } from '@xylabs/typeof'
+import type { Brand } from '@xylabs/typeof'
 import z from 'zod'
 
-import type { AssertConfig } from '../assert.ts'
-import { assertError } from '../assert.ts'
-import type { Hex, HexConfig } from '../hex/index.ts'
-import {
-  hexFrom, hexFromHexString, isHex,
-} from '../hex/index.ts'
+import type { Hex } from '../hex/index.ts'
 import { HexRegExMinMax } from '../HexRegEx.ts'
-import { AddressZodTransform } from './AddressZodTransform.ts'
-import { AddressZodValidation } from './AddressZodValidation.ts'
-
-// using true instead of unique symbol to avoid conflicts with other versions of library
-export type Address = Hex & {
-  readonly __address: true
-}
-
-export const AddressRegEx = HexRegExMinMax(20, 20)
-
-export const AddressToStringZod = z.string().regex(AddressRegEx)
-
-/** @deprecated use AddressToStringZod */
-export const AddressToStringSchema = AddressToStringZod
-
-export const AddressFromStringZod = z.string().toLowerCase().regex(AddressRegEx).transform(v => toAddress(v))
-
-/** @deprecated use AddressFromStringZod */
-export const AddressFromStringSchema = AddressFromStringZod
 
 export const ZERO_ADDRESS = '0000000000000000000000000000000000000000' as Address
 export const ADDRESS_LENGTH = 40 as const
 
-export const toAddress = (value: string | number | bigint | ArrayBufferLike, config: HexConfig = {}): Address => {
-  const { bitLength = 160, prefix = false } = config
-  return hexFrom(value, {
-    bitLength, prefix, ...config,
-  }) as Address
-}
-
-export const isAddress = (value: unknown, config: HexConfig = {}): value is Address => {
-  const { bitLength = 160, prefix = false } = config
-  return isHex(value, { bitLength, prefix })
-}
-
-export function asAddress(value: unknown): Address | undefined
-export function asAddress(value: unknown, assert: AssertConfig): Address
-export function asAddress(value: unknown, assert?: AssertConfig): Address | undefined {
-  try {
-    let stringValue: string | undefined = undefined
-
-    switch (typeof value) {
-      case 'string': {
-        stringValue = hexFromHexString(value, { prefix: false })
-        break
-      }
-      default: {
-        return isObject(assert) ? assertError(value, assert, `Unsupported type [${typeof value}]`) : undefined
-      }
-    }
-    return isAddress(stringValue) ? stringValue : assertError(value, assert, `Value is not an Address [${value}]`)
-  } catch (ex) {
-    const error = ex as Error
-    return assertError(undefined, assert, error.message)
-  }
-}
-
-/** @alpha */
-export function isAddressV2(value: unknown): value is Address {
-  return AddressZodValidation.safeParse(value).success
-}
+export const AddressRegEx = HexRegExMinMax(ADDRESS_LENGTH / 2, ADDRESS_LENGTH / 2)
 
-/** @alpha */
-export function asAddressV2(value: unknown, assert: boolean = false): Address | undefined {
-  return assert
-    ? AddressZodValidation.parse(value)
-    : AddressZodValidation.safeParse(value).data
-}
+export const AddressZod = z.string()
+  .regex(AddressRegEx, { message: 'Invalid hex format' }) as unknown as z.ZodType<Brand<Hex, { readonly __address: true }>>
 
-/** @alpha */
-export function toAddressV2(value: unknown, assert: boolean = false): Address | undefined {
-  return assert
-    ? AddressZodTransform.parse(value)
-    : AddressZodTransform.safeParse(value).data
-}
+export type Address = z.infer<typeof AddressZod>

package/src/address/addressDeprecated.ts

@@ -0,0 +1,18 @@
+import z from 'zod'
+
+import { AddressRegEx } from './address.ts'
+import { toAddress } from './to.ts'
+
+/** @deprecated use AddressZod */
+export const AddressToStringZod = z.string().regex(AddressRegEx)
+
+/** @deprecated use AddressZod */
+// eslint-disable-next-line sonarjs/deprecation
+export const AddressToStringSchema = AddressToStringZod
+
+/** @deprecated use AddressZod */
+export const AddressFromStringZod = z.string().toLowerCase().regex(AddressRegEx).transform(v => toAddress(v))
+
+/** @deprecated use AddressZod */
+// eslint-disable-next-line sonarjs/deprecation
+export const AddressFromStringSchema = AddressFromStringZod

package/src/address/as.ts

@@ -0,0 +1,37 @@
+import { isObject } from '@xylabs/typeof'
+
+import type { AssertConfig } from '../assert.ts'
+import { assertError } from '../assert.ts'
+import { hexFromHexString } from '../hex/index.ts'
+import type { Address } from './address.ts'
+import { AddressValidationZod } from './AddressValidationZod.ts'
+import { isAddress } from './is.ts'
+
+export function asAddress(value: unknown): Address | undefined
+export function asAddress(value: unknown, assert: AssertConfig): Address
+export function asAddress(value: unknown, assert?: AssertConfig): Address | undefined {
+  try {
+    let stringValue: string | undefined = undefined
+
+    switch (typeof value) {
+      case 'string': {
+        stringValue = hexFromHexString(value, { prefix: false })
+        break
+      }
+      default: {
+        return isObject(assert) ? assertError(value, assert, `Unsupported type [${typeof value}]`) : undefined
+      }
+    }
+    return isAddress(stringValue) ? stringValue : assertError(value, assert, `Value is not an Address [${value}]`)
+  } catch (ex) {
+    const error = ex as Error
+    return assertError(undefined, assert, error.message)
+  }
+}
+
+/** @alpha */
+export function asAddressV2(value: unknown, assert: boolean = false): Address | undefined {
+  return assert
+    ? AddressValidationZod.parse(value)
+    : AddressValidationZod.safeParse(value).data
+}

package/src/address/index.ts

@@ -1,3 +1,7 @@
 export * from './address.ts'
-export * from './AddressZodTransform.ts'
-export * from './AddressZodValidation.ts'
+export * from './addressDeprecated.ts'
+export * from './AddressTransformZod.ts'
+export * from './AddressValidationZod.ts'
+export * from './as.ts'
+export * from './is.ts'
+export * from './to.ts'

package/src/address/is.ts

@@ -0,0 +1,14 @@
+import type { HexConfig } from '../hex/index.ts'
+import { isHex } from '../hex/index.ts'
+import type { Address } from './address.ts'
+import { AddressValidationZod } from './AddressValidationZod.ts'
+
+export const isAddress = (value: unknown, config: HexConfig = {}): value is Address => {
+  const { bitLength = 160, prefix = false } = config
+  return isHex(value, { bitLength, prefix })
+}
+
+/** @alpha */
+export function isAddressV2(value: unknown): value is Address {
+  return AddressValidationZod.safeParse(value).success
+}

package/src/address/to.ts

@@ -0,0 +1,18 @@
+import type { HexConfig } from '../hex/index.ts'
+import { hexFrom } from '../hex/index.ts'
+import type { Address } from './address.ts'
+import { AddressTransformZod } from './AddressTransformZod.ts'
+
+export const toAddress = (value: string | number | bigint | ArrayBufferLike, config: HexConfig = {}): Address => {
+  const { bitLength = 160, prefix = false } = config
+  return hexFrom(value, {
+    bitLength, prefix, ...config,
+  }) as unknown as Address
+}
+
+/** @alpha */
+export function toAddressV2(value: unknown, assert: boolean = false): Address | undefined {
+  return assert
+    ? AddressTransformZod.parse(value)
+    : AddressTransformZod.safeParse(value).data
+}

package/src/ethAddress.ts

@@ -11,8 +11,15 @@ import { HexRegExMinMaxMixedCaseWithPrefix } from './HexRegEx.ts'
 
 export const EthAddressRegEx = HexRegExMinMaxMixedCaseWithPrefix(20, 20)
 
-export const EthAddressToStringSchema = z.string().regex(EthAddressRegEx)
-export const EthAddressFromStringSchema = z.string().regex(EthAddressRegEx).transform(v => toEthAddress(v))
+export const EthAddressToStringZod = z.string().regex(EthAddressRegEx)
+
+/** @deprecated use EthAddressToStringZod */
+export const EthAddressToStringSchema = EthAddressToStringZod
+
+export const EthAddressFromStringZod = z.string().regex(EthAddressRegEx).transform(v => toEthAddress(v))
+
+/** @deprecated use EthAddressFromStringZod */
+export const EthAddressFromStringSchema = EthAddressFromStringZod
 
 // using true instead of unique symbol to avoid conflicts with other versions of library
 export type EthAddress = Brand<string, { readonly __eth_address: true }>

package/src/hash/as.ts

@@ -0,0 +1,24 @@
+import { isUndefined } from '@xylabs/typeof'
+
+import type { AssertConfig } from '../assert.ts'
+import { assertError } from '../assert.ts'
+import { hexFromHexString } from '../hex/index.ts'
+import { type Hash } from './hash.ts'
+import { isHash } from './is.ts'
+
+export function asHash(value: unknown): Hash | undefined
+export function asHash(value: unknown, assert: AssertConfig): Hash
+export function asHash(value: unknown, assert?: AssertConfig): Hash | undefined {
+  let stringValue: string | undefined = undefined
+
+  switch (typeof value) {
+    case 'string': {
+      stringValue = hexFromHexString(value)
+      break
+    }
+    default: {
+      return isUndefined(assert) ? undefined : assertError(value, assert, `Unsupported type [${typeof value}]`)
+    }
+  }
+  return isHash(stringValue) ? stringValue : assertError(value, assert, `Value is not a Hash [${value}]`)
+}

package/src/hash/hash.ts

@@ -0,0 +1,23 @@
+import type { Brand } from '@xylabs/typeof'
+import z from 'zod'
+
+import type { Hex } from '../hex/index.ts'
+import { HexRegExMinMax } from '../HexRegEx.ts'
+
+export const HASH_LENGTH = 32 as const
+
+export const HashRegEx = HexRegExMinMax(HASH_LENGTH, HASH_LENGTH)
+
+export const ZERO_HASH = '0000000000000000000000000000000000000000000000000000000000000000' as Hash
+
+export type HashBitLength = 32 | 64 | 128 | 256 | 512 | 1024 | 2048 | 4096
+export const HashBitLength: HashBitLength[] = [32, 64, 128, 256, 512, 1024, 2048, 4096]
+
+export const isHashBitLength = (value: unknown): value is HashBitLength => {
+  return typeof value === 'number' && HashBitLength.includes(value as HashBitLength)
+}
+
+export const HashZod = z.string()
+  .regex(HashRegEx, { message: 'Invalid hex format' }) as unknown as z.ZodType<Brand<Hex, { readonly __hash: true }>>
+
+export type Hash = z.infer<typeof HashZod>

package/src/hash/index.ts

@@ -0,0 +1,3 @@
+export * from './as.ts'
+export * from './hash.ts'
+export * from './is.ts'

package/src/hash/is.ts

@@ -0,0 +1,6 @@
+import { isHex } from '../hex/index.ts'
+import type { Hash, HashBitLength } from './hash.ts'
+
+export const isHash = (value: unknown, bitLength: HashBitLength = 256): value is Hash => {
+  return isHex(value, { bitLength })
+}

package/src/hex/as.ts

@@ -1,8 +1,8 @@
 import type { AssertConfig } from '../assert.ts'
 import { assertError } from '../assert.ts'
 import { hexFromHexString } from './from/index.ts'
+import type { Hex } from './hex.ts'
 import { isHex } from './is.ts'
-import type { Hex } from './model.ts'
 
 export function asHex(value: unknown): Hex | undefined
 export function asHex(value: unknown, assert: AssertConfig): Hex

package/src/hex/from/from.ts

@@ -1,4 +1,4 @@
-import type { Hex, HexConfig } from '../model.ts'
+import type { Hex, HexConfig } from '../hex.ts'
 import { hexFromArrayBuffer } from './fromArrayBuffer.ts'
 import { hexFromBigInt } from './fromBigInt.ts'
 import { hexFromHexString } from './fromHexString.ts'

package/src/hex/from/fromArrayBuffer.ts

@@ -1,4 +1,4 @@
-import type { Hex, HexConfig } from '../model.ts'
+import type { Hex, HexConfig } from '../hex.ts'
 import { hexFromHexString } from './fromHexString.ts'
 
 /** Convert an ArrayBuffer to a hex string */

package/src/hex/from/fromBigInt.ts

@@ -1,4 +1,4 @@
-import type { Hex, HexConfig } from '../model.ts'
+import type { Hex, HexConfig } from '../hex.ts'
 import { hexFromHexString } from './fromHexString.ts'
 
 /** Convert a bigint to a hex string */

package/src/hex/from/fromHexString.ts

@@ -1,7 +1,7 @@
 import { isNumber } from '@xylabs/typeof'
 
+import type { Hex, HexConfig } from '../hex.ts'
 import { isHex } from '../is.ts'
-import type { Hex, HexConfig } from '../model.ts'
 import { bitsToNibbles } from '../nibble.ts'
 
 export const hexFromHexString = (value: string, config: HexConfig = {}): Hex => {

package/src/hex/from/fromNumber.ts

@@ -1,4 +1,4 @@
-import type { Hex, HexConfig } from '../model.ts'
+import type { Hex, HexConfig } from '../hex.ts'
 import { hexFromBigInt } from './fromBigInt.ts'
 
 export const hexFromNumber = (value: number, config?: HexConfig): Hex => {

package/src/hex/index.ts

@@ -1,8 +1,8 @@
 export * from './as.ts'
 export * from './from/index.ts'
+export * from './hex.ts'
 export * from './is.ts'
 export * from './isHexZero.ts'
 export * from './legacy.ts'
-export * from './model.ts'
 export * from './nibble.ts'
 export * from './to.ts'

package/src/hex/is.ts

@@ -1,5 +1,5 @@
 import { HexRegEx, HexRegExWithPrefix } from '../HexRegEx.ts'
-import type { Hex, HexConfig } from './model.ts'
+import type { Hex, HexConfig } from './hex.ts'
 import { bitsToNibbles } from './nibble.ts'
 
 export const isHex = (value: unknown, config?: HexConfig): value is Hex => {

package/src/hex/to.ts

@@ -1,5 +1,5 @@
 import { hexFrom } from './from/index.ts'
-import type { HexConfig } from './model.ts'
+import type { HexConfig } from './hex.ts'
 
 /** takes any value and tries our best to convert it to a hex string */
 export const toHex = (

package/src/index-internal.ts

@@ -1,7 +1,7 @@
 export * from './address/index.ts'
 export * from './assert.ts'
 export * from './ethAddress.ts'
-export * from './hash.ts'
+export * from './hash/index.ts'
 export * from './hex/index.ts'
 export * from './HexRegEx.ts'
 export * from './hexToBigInt.ts'

package/src/spec/hash.spec.ts

@@ -4,7 +4,7 @@ import {
   describe, expect, test,
 } from 'vitest'
 
-import { isHash } from '../hash.ts'
+import { isHash } from '../hash/index.ts'
 import { hexFromNumber } from '../hex/index.ts'
 
 describe('hash', () => {

package/dist/neutral/address/AddressZodTransform.d.ts

@@ -1,5 +0,0 @@
-import z from 'zod';
-import type { Address } from './address.ts';
-export declare const AddressZodTransform: z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodBigInt]>, z.ZodTransform<string, string | bigint>>, z.ZodTransform<Address, string>>;
-export type AddressZodTransformType = z.infer<typeof AddressZodTransform>;
-//# sourceMappingURL=AddressZodTransform.d.ts.map

package/dist/neutral/address/AddressZodTransform.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"AddressZodTransform.d.ts","sourceRoot":"","sources":["../../../src/address/AddressZodTransform.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAA;AAEnB,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAG3C,eAAO,MAAM,mBAAmB,iJAWD,CAAA;AAE/B,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA"}

package/dist/neutral/address/AddressZodValidation.d.ts

@@ -1,5 +0,0 @@
-import z from 'zod';
-import type { Address } from './address.ts';
-export declare const AddressZodValidation: z.ZodPipe<z.ZodString, z.ZodTransform<Address, string>>;
-export type AddressZodValidationType = z.infer<typeof AddressZodValidation>;
-//# sourceMappingURL=AddressZodValidation.d.ts.map

package/dist/neutral/address/AddressZodValidation.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"AddressZodValidation.d.ts","sourceRoot":"","sources":["../../../src/address/AddressZodValidation.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAA;AAGnB,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAG3C,eAAO,MAAM,oBAAoB,yDAGF,CAAA;AAE/B,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA"}

package/dist/neutral/hash.d.ts

@@ -1,17 +0,0 @@
-import type { Brand } from '@xylabs/typeof';
-import z from 'zod';
-import type { AssertConfig } from './assert.ts';
-import type { Hex } from './hex/index.ts';
-export declare const HashRegEx: RegExp;
-export declare const ZERO_HASH: Hash;
-export type HashBitLength = 32 | 64 | 128 | 256 | 512 | 1024 | 2048 | 4096;
-export declare const HashBitLength: HashBitLength[];
-export declare const isHashBitLength: (value: unknown) => value is HashBitLength;
-export type Hash = Brand<Hex, {
-    readonly __hash: true;
-}>;
-export declare const isHash: (value: unknown, bitLength?: HashBitLength) => value is Hash;
-export declare const HashZod: z.ZodString;
-export declare function asHash(value: unknown): Hash | undefined;
-export declare function asHash(value: unknown, assert: AssertConfig): Hash;
-//# sourceMappingURL=hash.d.ts.map

package/dist/neutral/hash.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../../src/hash.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAA;AAE3C,OAAO,CAAC,MAAM,KAAK,CAAA;AAEnB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAE/C,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAA;AAIzC,eAAO,MAAM,SAAS,QAAyB,CAAA;AAE/C,eAAO,MAAM,SAAS,EAAyE,IAAI,CAAA;AAEnG,MAAM,MAAM,aAAa,GAAG,EAAE,GAAG,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,CAAA;AAC1E,eAAO,MAAM,aAAa,EAAE,aAAa,EAA8C,CAAA;AAEvF,eAAO,MAAM,eAAe,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,aAEzD,CAAA;AAGD,MAAM,MAAM,IAAI,GAAG,KAAK,CAAC,GAAG,EAAE;IAAE,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAA;CAAE,CAAC,CAAA;AAExD,eAAO,MAAM,MAAM,GAAI,OAAO,OAAO,EAAE,YAAW,aAAmB,KAAG,KAAK,IAAI,IAEhF,CAAA;AAED,eAAO,MAAM,OAAO,aAKjB,CAAA;AAEH,wBAAgB,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,GAAG,SAAS,CAAA;AACxD,wBAAgB,MAAM,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,YAAY,GAAG,IAAI,CAAA"}

package/dist/neutral/hex/model.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../../../src/hex/model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAA;AAC3C,OAAO,CAAC,MAAM,KAAK,CAAA;AAInB,eAAO,MAAM,MAAM,EACiD,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE;IAAE,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAA;CAAE,CAAC,CAAC,CAAA;AAEjI,MAAM,MAAM,GAAG,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,MAAM,CAAC,CAAA;AAExC,oDAAoD;AACpD,MAAM,WAAW,SAAS;IACxB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,MAAM,CAAC,EAAE,OAAO,CAAA;CACjB"}

package/src/address/AddressZodTransform.ts

@@ -1,19 +0,0 @@
-import z from 'zod'
-
-import type { Address } from './address.ts'
-import { AddressZodValidation } from './AddressZodValidation.ts'
-
-export const AddressZodTransform = z.union([z.string(), z.bigint()])
-  .transform((value) => {
-    if (typeof value === 'bigint') {
-      return value.toString(16).padStart(40, '0')
-    }
-    if (value.startsWith('0x')) {
-      return value.slice(2)
-    }
-    return value
-  })
-  .refine(x => AddressZodValidation.safeParse(x).data)
-  .transform(x => x as Address)
-
-export type AddressZodTransformType = z.infer<typeof AddressZodTransform>

package/src/hash.ts

@@ -1,51 +0,0 @@
-import type { Brand } from '@xylabs/typeof'
-import { isUndefined } from '@xylabs/typeof'
-import z from 'zod'
-
-import type { AssertConfig } from './assert.ts'
-import { assertError } from './assert.ts'
-import type { Hex } from './hex/index.ts'
-import { hexFromHexString, isHex } from './hex/index.ts'
-import { HexRegExMinMax } from './HexRegEx.ts'
-
-export const HashRegEx = HexRegExMinMax(32, 32)
-
-export const ZERO_HASH = '0000000000000000000000000000000000000000000000000000000000000000' as Hash
-
-export type HashBitLength = 32 | 64 | 128 | 256 | 512 | 1024 | 2048 | 4096
-export const HashBitLength: HashBitLength[] = [32, 64, 128, 256, 512, 1024, 2048, 4096]
-
-export const isHashBitLength = (value: unknown): value is HashBitLength => {
-  return typeof value === 'number' && HashBitLength.includes(value as HashBitLength)
-}
-
-// using true instead of unique symbol to avoid conflicts with other versions of library
-export type Hash = Brand<Hex, { readonly __hash: true }>
-
-export const isHash = (value: unknown, bitLength: HashBitLength = 256): value is Hash => {
-  return isHex(value, { bitLength })
-}
-
-export const HashZod = z.string()
-  .toLowerCase()
-  .regex(HashRegEx, { message: 'Invalid hash format' })
-  .refine(
-    isHash,
-  )
-
-export function asHash(value: unknown): Hash | undefined
-export function asHash(value: unknown, assert: AssertConfig): Hash
-export function asHash(value: unknown, assert?: AssertConfig): Hash | undefined {
-  let stringValue: string | undefined = undefined
-
-  switch (typeof value) {
-    case 'string': {
-      stringValue = hexFromHexString(value)
-      break
-    }
-    default: {
-      return isUndefined(assert) ? undefined : assertError(value, assert, `Unsupported type [${typeof value}]`)
-    }
-  }
-  return isHash(stringValue) ? stringValue : assertError(value, assert, `Value is not a Hash [${value}]`)
-}