@xyo-network/xns-record-payloadset-plugins 5.3.1 → 5.3.3

package/dist/node/estimate/lib/spec/matchers/index.d.ts

@@ -1,2 +0,0 @@
-export * from './customMatchers.ts';
-//# sourceMappingURL=index.d.ts.map

package/dist/node/estimate/lib/spec/matchers/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/estimate/lib/spec/matchers/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAA"}

package/src/estimate/index.ts

@@ -1 +0,0 @@
-export * from './lib/index.ts'

package/src/estimate/lib/index.ts

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

package/src/estimate/lib/parseDomainEstimates.ts

@@ -1,78 +0,0 @@
-import { findAs } from '@xylabs/array'
-import { exists } from '@xylabs/exists'
-import type { BoundWitness } from '@xyo-network/boundwitness-model'
-import { isBoundWitness } from '@xyo-network/boundwitness-model'
-import type { HashLeaseEstimate } from '@xyo-network/diviner-hash-lease'
-import { asHashLeaseEstimate, HashLeaseEstimateSchema } from '@xyo-network/diviner-hash-lease'
-import { PayloadBuilder } from '@xyo-network/payload-builder'
-import type {
-  Payload, Schema, WithSources,
-} from '@xyo-network/payload-model'
-import type {
-  DomainEstimate,
-  DomainRegistrationLease,
-} from '@xyo-network/xns-record-payload-plugins'
-import { asDomainRegistrationLeaseWithSources, DomainRegistrationLeaseSchema } from '@xyo-network/xns-record-payload-plugins'
-
-/**
- * Parses a generic array of payloads into estimates
- * @param payloads An array of payloads
- * @returns Parsed estimates
- */
-export const parseDomainEstimates = async (payloads?: Payload[]): Promise<DomainEstimate[]> => {
-  if (!payloads) return []
-  const bws = payloads
-    // Find all bound witnesses
-    .filter(isBoundWitness)
-    // that have the required estimate payloads
-    .filter(hasEstimatePayloads) ?? []
-  if (bws.length === 0) return []
-  const hashMap = await PayloadBuilder.toAllHashMap(payloads)
-  return bws.map<DomainEstimate | undefined>((bw) => {
-    const hashLeaseEstimate = getPayloadBySchemaFromBoundWitness<WithSources<HashLeaseEstimate>>(
-      bw,
-      HashLeaseEstimateSchema,
-      hashMap,
-      asHashLeaseEstimate,
-    )
-    if (!hashLeaseEstimate) return
-    const domainLease = getPayloadBySchemaFromBoundWitness<WithSources<DomainRegistrationLease>>(
-      bw,
-      DomainRegistrationLeaseSchema,
-      hashMap,
-      asDomainRegistrationLeaseWithSources,
-    )
-    if (!domainLease) return
-    return [bw, hashLeaseEstimate, domainLease]
-  }).filter(exists)
-}
-
-/**
- * Tests if a BoundWitness has the required estimate payloads
- * @param bw The BoundWitness to check for estimate payloads
- * @returns True if the BoundWitness has the required estimate payloads, false otherwise
- */
-const hasEstimatePayloads = (bw: BoundWitness): boolean => {
-  return bw.payload_schemas.includes(DomainRegistrationLeaseSchema)
-    && bw.payload_schemas.includes(HashLeaseEstimateSchema)
-}
-
-/**
- * Finds the first instance of a payload in a BoundWitness by schema
- * @param bw The BoundWitness to extract the payload from
- * @param schema The schema of the payload to extract
- * @param hashMap The hashmap of the payloads
- * @param identity An identity function to check if the payload is of the correct type
- * @returns The payload if it exists or undefined
- */
-const getPayloadBySchemaFromBoundWitness = <T extends Payload = Payload>(
-  bw: BoundWitness,
-  schema: Schema,
-  hashMap: Awaited<ReturnType<typeof PayloadBuilder.toHashMap>>,
-  identity: (payload: Payload) => T,
-): T | undefined => {
-  const schemaIndex = bw.payload_schemas.indexOf(schema)
-  if (schemaIndex === -1) return
-  const hash = bw.payload_hashes[schemaIndex]
-  return findAs([hashMap[hash]], identity)
-}

package/src/estimate/lib/spec/matchers/customMatchers.ts

@@ -1,287 +0,0 @@
-interface ExpectationResult {
-  actual?: unknown
-  expected?: unknown
-  message: () => string
-  pass: boolean
-}
-
-function toBeType(received: unknown, expectedType: string): ExpectationResult {
-  const pass = typeof received === expectedType && !Number.isNaN(received)
-  return pass
-    ? {
-        message: () => `expected ${received} not to be a ${expectedType}`,
-        pass: true,
-      }
-    : {
-        message: () => `expected ${received} to be a ${expectedType}`,
-        pass: false,
-      }
-}
-
-export const matchers = {
-  toBeArrayOfSize(received: unknown, expectedSize: number): ExpectationResult {
-    const pass = Array.isArray(received) && received.length === expectedSize
-    return pass
-      ? {
-          message: () => `expected array not to have size ${expectedSize}, but received array of size ${received.length}`,
-          pass: true,
-        }
-      : {
-          message: () => Array.isArray(received)
-            ? `expected array of size ${expectedSize}, but received array of size ${received.length}`
-            : `expected array of size ${expectedSize}, but received a non-array`,
-          pass: false,
-        }
-  },
-  toBeArray(received: unknown): ExpectationResult {
-    const pass = Array.isArray(received)
-    return pass
-      ? {
-          message: () => 'expected array',
-          pass: true,
-        }
-      : {
-          message: () => `expected array, but received ${typeof received}`,
-          pass: false,
-        }
-  },
-  toBeOneOf(received: unknown, expected: unknown[]): ExpectationResult {
-    const pass = expected.includes(received)
-    return pass
-      ? {
-          pass: true,
-          message: () =>
-            `expected ${received} not to be one of ${JSON.stringify(expected)}`,
-        }
-      : {
-          pass: false,
-          message: () =>
-            `expected ${received} to be one of ${JSON.stringify(expected)}`,
-        }
-  },
-  toBeNegative(received: number): ExpectationResult {
-    if (typeof received !== 'number') {
-      throw new TypeError(`Expected a number, but received ${typeof received}`)
-    }
-
-    const pass = received < 0
-    return pass
-      ? {
-          pass: true,
-          message: () =>
-            `expected ${received} not to be negative`,
-        }
-      : {
-          pass: false,
-          message: () =>
-            `expected ${received} to be negative`,
-        }
-  },
-  toBePositive(received: number): ExpectationResult {
-    if (typeof received !== 'number') {
-      throw new TypeError(`Expected a number, but received ${typeof received}`)
-    }
-
-    const pass = received > 0
-    return pass
-      ? {
-          pass: true,
-          message: () =>
-            `expected ${received} not to be positive`,
-        }
-      : {
-          pass: false,
-          message: () =>
-            `expected ${received} to be positive`,
-        }
-  },
-  toBeNumber: (received: unknown) => toBeType(received, 'number'),
-  toBeFunction: (received: unknown) => toBeType(received, 'function'),
-  toBeString: (received: unknown) => toBeType(received, 'string'),
-  toBeObject(received: unknown): ExpectationResult {
-    const pass = typeof received === 'object' && !Array.isArray(received) && received !== null
-    return pass
-      ? {
-          message: () => `expected ${received} to be object`,
-          pass: true,
-        }
-      : {
-          message: () => `expected ${received} to be an object but was ${Array.isArray(received) ? 'array' : typeof received}`,
-          pass: false,
-        }
-  },
-  toBeInteger(received: number): ExpectationResult {
-    if (typeof received !== 'number') {
-      throw new TypeError(`Expected a number, but received ${typeof received}`)
-    }
-
-    const pass = Number.isInteger(received)
-    return pass
-      ? {
-          pass: true,
-          message: () =>
-            `expected ${received} not to be an integer`,
-        }
-      : {
-          pass: false,
-          message: () =>
-            `expected ${received} to be an integer`,
-        }
-  },
-  toBeFalse(received: unknown): ExpectationResult {
-    const pass = received === false
-    return pass
-      ? {
-          message: () => `expected ${received} to be false`,
-          pass: true,
-        }
-      : {
-          message: () => `expected ${received} to be false but was not false`,
-          pass: false,
-        }
-  },
-  toBeTrue(received: unknown): ExpectationResult {
-    const pass = received === true
-    return pass
-      ? {
-          message: () => `expected ${received} to be true`,
-          pass: true,
-        }
-      : {
-          message: () => `expected ${received} to be true but was not true`,
-          pass: false,
-        }
-  },
-  toIncludeAllMembers(received: unknown[], expected: unknown[]): ExpectationResult {
-    if (!Array.isArray(received) || !Array.isArray(expected)) {
-      return {
-        pass: false,
-        message: () => 'Expected both received and expected values to be arrays.',
-      }
-    }
-
-    const missingMembers = expected.filter(item => !received.includes(item))
-
-    return missingMembers.length === 0
-      ? {
-          pass: true,
-          message: () =>
-            `Expected array not to include all members of ${JSON.stringify(expected)}, but it does.`,
-        }
-      : {
-          pass: false,
-          message: () =>
-            `Expected array to include all members of ${JSON.stringify(expected)}. Missing members: ${JSON.stringify(
-              missingMembers,
-            )}.`,
-        }
-  },
-  toContainAllKeys(received: object, expectedKeys: string[]): ExpectationResult {
-    if (typeof received !== 'object' || received === null) {
-      return {
-        pass: false,
-        message: () => `Expected ${JSON.stringify(received)} to be an object.`,
-      }
-    }
-
-    if (!Array.isArray(expectedKeys)) {
-      return {
-        pass: false,
-        message: () => `Expected keys to be an array, but received ${JSON.stringify(expectedKeys)}.`,
-      }
-    }
-
-    const missingKeys = expectedKeys.filter(key => !(key in received))
-
-    return missingKeys.length === 0
-      ? {
-          pass: true,
-          message: () =>
-            `Expected object not to contain all keys ${JSON.stringify(expectedKeys)}, but it does.`,
-        }
-      : {
-          pass: false,
-          message: () =>
-            `Expected object to contain all keys ${JSON.stringify(expectedKeys)}. Missing keys: ${JSON.stringify(
-              missingKeys,
-            )}.`,
-        }
-  },
-  toContainValues(received: object, expectedValues: unknown[]): ExpectationResult {
-    if (typeof received !== 'object' || received === null) {
-      return {
-        pass: false,
-        message: () => `Expected ${JSON.stringify(received)} to be an object.`,
-      }
-    }
-
-    if (!Array.isArray(expectedValues)) {
-      return {
-        pass: false,
-        message: () => `Expected values to be an array, but received ${JSON.stringify(expectedValues)}.`,
-      }
-    }
-
-    const objectValues = Object.values(received)
-
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const deepEqual = (a: any, b: any): boolean => {
-      if (a === b) return true
-      if (typeof a !== typeof b) return false
-      if (a && b && typeof a === 'object') {
-        const aKeys = Object.keys(a)
-        const bKeys = Object.keys(b)
-        if (aKeys.length !== bKeys.length) return false
-        return aKeys.every(key => deepEqual(a[key], b[key]))
-      }
-      return false
-    }
-
-    const missingValues = expectedValues.filter(
-      expectedValue => !objectValues.some(value => deepEqual(value, expectedValue)),
-    )
-
-    return missingValues.length === 0
-      ? {
-          pass: true,
-          message: () =>
-            `Expected object not to contain all values ${JSON.stringify(expectedValues)}, but it does.`,
-        }
-      : {
-          pass: false,
-          message: () =>
-            `Expected object to contain all values ${JSON.stringify(expectedValues)}. Missing values: ${JSON.stringify(
-              missingValues,
-            )}.`,
-        }
-  },
-  toBeEmpty(received: unknown): ExpectationResult {
-    let isEmpty = false
-
-    if (Array.isArray(received) || typeof received === 'string') {
-      isEmpty = received.length === 0
-    } else if (received && typeof received === 'object') {
-      isEmpty = Object.keys(received).length === 0
-    } else if (received instanceof Map || received instanceof Set) {
-      isEmpty = received.size === 0
-    } else {
-      return {
-        pass: false,
-        message: () =>
-          `Expected value to be an empty array, string, object, Map, or Set, but received ${typeof received}.`,
-      }
-    }
-
-    return isEmpty
-      ? {
-          pass: true,
-          message: () =>
-            'Expected value not to be empty, but it was.',
-        }
-      : {
-          pass: false,
-          message: () =>
-            'Expected value to be empty, but it was not.',
-        }
-  },
-}

package/src/estimate/lib/spec/matchers/index.ts

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

package/src/estimate/lib/spec/matchers/vitest.customMatchers.d.ts

@@ -1,27 +0,0 @@
-// vitest.customMatchers.d.ts
-import 'vitest'
-
-interface CustomMatchers<T = unknown> {
-  toBeArray(): T
-  toBeArrayOfSize(size: number): T
-  toBeEmpty(): T
-  toBeFalse(): T
-  toBeFunction(): T
-  toBeInteger(): T
-  toBeNegative(): T
-  toBeNumber(): T
-  toBeObject(): T
-  toBeOneOf(expected: unknown[]): T
-  toBePositive(): T
-  toBeString(): T
-  toBeTrue(): T
-  toContainAllKeys(expectedKeys: string[]): T
-  toContainValues(expectedValues: unknown[]): T
-  toIncludeAllMembers(expected: unknown[]): T
-}
-
-// Extend the expect Matchers interface
-declare module 'vitest' {
-  interface Assertion<T = unknown> extends CustomMatchers<T> {}
-  interface AsymmetricMatchersContaining extends CustomMatchers {}
-}

package/src/index.ts

@@ -1,2 +0,0 @@
-export * from './estimate/index.ts'
-export * from './validation/index.ts'

package/src/validation/index.ts

@@ -1,2 +0,0 @@
-export * from './name/index.ts'
-export * from './validation/index.ts'

package/src/validation/name/Name.ts

@@ -1,123 +0,0 @@
-import { assertEx } from '@xylabs/assert'
-import { isHash } from '@xylabs/hex'
-import type { Promisable } from '@xylabs/promise'
-import type { Payload } from '@xyo-network/payload-model'
-import type { DomainFields, TopLevelDomain } from '@xyo-network/xns-record-payload-plugins'
-import { DomainSchema } from '@xyo-network/xns-record-payload-plugins'
-
-import { MAX_DOMAIN_LENGTH, XnsNameSimpleValidators } from '../validation/index.ts'
-import { removeDisallowedCharacters } from './lib/index.ts'
-import type { ValidSourceTypes } from './types/index.ts'
-
-const defaultMaskOptions = { maskStartEndHyphens: false }
-
-export class XnsNameHelper {
-  static readonly ValidTLDs = ['.xyo'] as const
-
-  private _xnsName: Payload<DomainFields>
-
-  private constructor(xnsName: Payload<DomainFields>) {
-    this._xnsName = xnsName
-  }
-
-  get domain() {
-    return assertEx(this.xnsName.domain, () => 'domain not found in payload')
-  }
-
-  get name() {
-    return `${this.domain}.${this.tld}`
-  }
-
-  get tld() {
-    return assertEx(this.xnsName.tld, () => 'tld not found in payload')
-  }
-
-  get xnsName() {
-    return assertEx(this._xnsName, () => 'XnsNameHelper xnsName not set')
-  }
-
-  /**
-   * Create an XnsNameHelper from a domain payload
-   * @param  {Domain} domain
-   * @returns Promise<XnsNameHelper>
-   */
-  static fromPayload(domain: Payload<DomainFields>): Promisable<XnsNameHelper> {
-    return new XnsNameHelper(domain)
-  }
-
-  /**
-   * Create an XnsNameHelper from a string
-   * @param  {string} xnsName
-   * @returns Promise<XnsNameHelper>
-   */
-  static fromString(xnsName: string): XnsNameHelper {
-    const parts = xnsName.split('.')
-    assertEx(parts.length === 2, () => 'Unable to parse xnsName')
-
-    const domain = parts[0]
-    const tld = parts[1] as TopLevelDomain
-    return new XnsNameHelper({
-      schema: DomainSchema, domain, tld,
-    })
-  }
-
-  /**
-   * Determine if a string is a valid XNS name or hash
-   * @param  {string} source?
-   * @returns ValidSourceTypes
-   */
-  static isPotentialXnsNameOrHash(source?: string): ValidSourceTypes {
-    if (isHash(source)) return 'hash'
-    const xnsName = XnsNameHelper.ValidTLDs.some(tld => source?.endsWith(tld)) ? source : null
-    return xnsName ? 'xnsName' : null
-  }
-
-  static async isValid(domain: Payload<DomainFields>): Promise<boolean> {
-    const results = await Promise.all(XnsNameSimpleValidators.map(validator => validator(domain)))
-    for (const result of results) {
-      if (!result) return false
-    }
-    return true
-  }
-
-  /**
-   * Mask a string to be a valid XNS name
-   * @param {string} str
-   * @returns string
-   */
-  static mask(str: string, options: { maskStartEndHyphens: boolean } = defaultMaskOptions): string {
-    // Check if the domain name is too long
-    if (str.length > MAX_DOMAIN_LENGTH) {
-      throw new Error(`Domain name too long: ${str.length} exceeds max length: ${MAX_DOMAIN_LENGTH}`)
-    }
-
-    // convert to lowercase
-    const lowercaseXnsName = str.toLowerCase()
-
-    // Remove everything except letters, numbers, and dashes
-
-    let formattedXnsName = lowercaseXnsName.replaceAll(/[^\dA-Za-z-]+$/g, '')
-
-    // Remove leading and trailing dashes
-
-    if (options.maskStartEndHyphens) formattedXnsName = formattedXnsName.replaceAll(/^-+|-+$/g, '')
-
-    // Filter out disallowed characters.
-    return removeDisallowedCharacters(formattedXnsName)
-  }
-
-  async validate(): Promise<[boolean, string[]]> {
-    const errorMessages: string[] = []
-    const onErrorsInternal = (message: string[]) => errorMessages.push(...message)
-
-    for (const validator of XnsNameSimpleValidators) {
-      await validator(this.xnsName, onErrorsInternal)
-    }
-
-    if (errorMessages.length > 0) {
-      return [false, errorMessages]
-    }
-
-    return [true, []]
-  }
-}

package/src/validation/name/index.ts

@@ -1,2 +0,0 @@
-export * from './Name.ts'
-export * from './types/index.ts'

package/src/validation/name/lib/index.ts

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

package/src/validation/name/lib/removeDisallowedCharacters.ts

@@ -1,26 +0,0 @@
-import { DisallowedModuleIdentifierCharacters } from '@xyo-network/module-model'
-
-/**
- * A set of all the disallowed characters in module identifiers
- */
-const DISALLOWED_CHARACTERS = new Set(Object.keys(DisallowedModuleIdentifierCharacters))
-
-/**
- * Iterates over a string removing disallowed characters
- * @param xnsName The XNS name to remove disallowed characters from
- * @returns The XNS name with disallowed characters removed
- */
-export const removeDisallowedCharacters = (xnsName: string): string => {
-  // Create the initial result
-  let result = ''
-  // Iterate over each character in the XNS name
-  for (const char of xnsName) {
-    // If the character is not a disallowed character
-    if (!DISALLOWED_CHARACTERS.has(char)) {
-      // add it to the result
-      result += char
-    }
-  }
-  // Return the result which contains only allowed characters
-  return result
-}

package/src/validation/name/types/ValidSources.ts

@@ -1 +0,0 @@
-export type ValidSourceTypes = 'xnsName' | 'hash' | null

package/src/validation/name/types/index.ts

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

package/src/validation/validation/Constants.ts

@@ -1,2 +0,0 @@
-export const MIN_DOMAIN_LENGTH = 3
-export const MAX_DOMAIN_LENGTH = 128

package/src/validation/validation/factory/index.ts

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

package/src/validation/validation/factory/validators.ts

@@ -1,47 +0,0 @@
-import type { Payload, PayloadValidationFunction } from '@xyo-network/payload-model'
-import type { DomainFields } from '@xyo-network/xns-record-payload-plugins'
-
-export const getDomainReservedStringsValidator = (
-  reservedStrings: string[],
-): PayloadValidationFunction<Payload<DomainFields>> => {
-  return (payload: Payload<DomainFields>) => {
-    const { domain } = payload
-    // Check if in one of the reserved name lists
-    if (reservedStrings.includes(domain)) {
-      console.log('Reserved name')
-      return false
-    }
-    return true
-  }
-}
-
-export const getDomainReservedFragmentsValidator = (
-  reservedFragments: string[],
-): PayloadValidationFunction<Payload<DomainFields>> => {
-  return (payload: Payload<DomainFields>) => {
-    const { domain } = payload
-    // Check if any of our fragments are in the name
-    for (const reserved of reservedFragments) {
-      if (domain.includes(reserved)) {
-        console.log('Reserved name fragment')
-        return false
-      }
-    }
-    return true
-  }
-}
-
-export const getDomainReservedNamesValidator = (reservedNames: string[]): PayloadValidationFunction<Payload<DomainFields>> => {
-  return (payload: Payload<DomainFields>) => {
-    const { domain } = payload
-    // Check if any of our fragments are in the name
-    for (const reserved of reservedNames) {
-      const parts = reserved.split(' ')
-      if (domain === [parts[1], parts[0]].join('') || domain === [parts[0], parts[1]].join('')) {
-        console.log('Reserved name')
-        return false
-      }
-    }
-    return true
-  }
-}

package/src/validation/validation/index.ts

@@ -1,3 +0,0 @@
-export * from './Constants.ts'
-export * from './factory/index.ts'
-export * from './validators/index.ts'

package/src/validation/validation/validators/index.ts

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