@xyo-network/module-model 5.3.22 → 5.3.24

package/src/ResolveHelper/ResolveHelper.ts

@@ -1,213 +0,0 @@
-/* eslint-disable max-statements */
-/* eslint-disable complexity */
-import type { Address, Logger } from '@xylabs/sdk-js'
-import {
-  assertEx,
-  exists,
-  IdLogger,
-  isAddress,
-  isDefined, isString, isTruthy,
-} from '@xylabs/sdk-js'
-
-import type {
-  ModuleFilterOptions, ModuleInstance, ModuleResolver,
-} from '../instance/index.ts'
-import { asModuleInstance } from '../instance/index.ts'
-import { duplicateModules } from '../lib/index.ts'
-import type { ModuleIdentifier } from '../ModuleIdentifier.ts'
-import type { ModuleIdentifierTransformer } from '../ModuleIdentifierTransformer.ts'
-import { ResolveHelperStatic } from './ResolveHelperStatic.ts'
-import { resolvePathToAddress } from './resolvePathToAddress.ts'
-import { traceModuleIdentifier } from './traceModuleIdentifier.ts'
-import { transformModuleIdentifier } from './transformModuleIdentifier.ts'
-
-/*
-
-Resolution rules
-
-1. Resolution is always done from the perspective of the module whose resolve function was called.
-
-2. Requesting '*' will return all the modules that the resolver can see. [limited by maxDepth]
-
-3. Requesting a simple ModuleName (string w/o ':' separator) will return an immediate child that has that name.
-
-4. Requesting a complex ModuleName (string w/ ':' separator) will resolve the first part and then recursively resolve
-   the remaining name by calling the first part's resolved module's resolve with the remainder of the name.
-
-5. Requesting an Address (string) will return the module with that address, regardless of how distant it is from the module. [limited by maxDepth]
-
-6. Requesting a ModuleFilter will first request all the modules '*' and then filter them based on the filter settings. [Do we need this mode?]
-
-7. When a string is passed as the ModuleIdentifier, do the following:
-    Check if id is complex (contains a ':')
-      a)  If it is complex, go to #4 above
-      b)  Call isAddress in the id to see if it is a valid address.
-        i)  If it is a valid address, go to #5 above
-        ii) If it is not a valid address, go to # 3 above
-
-    1: If someone were to name a module with a valid address, that name will not be resolvable.
-    2: If someone were to name a module with a string containing a ':', that name will not be resolvable.
-
-8. Modules have two resolvers, up and down.
-    a) Up Traversal
-      i)    Every module's upResolver also can call it's parent's upResolver
-      ii)   An upResolver also can see the parent's children's downResolvers
-      iii)  This means that when traversing upResolvers, you can traverse all the way up. [limited by maxDepth]
-      iv)   At any point of the up traversal, it can start traversing down to any immediate child, public or private.
-    b) Down Traversal
-      i)    A down traversal is limited to the public children of the module. [The same as scope as calling the 'resolve' function]
-
-9. An up or a down traversal counts against the maxDepth
-
-*/
-
-export interface ResolveHelperConfig {
-  address: Address
-  dead?: boolean
-  downResolver?: ModuleResolver
-  logger?: Logger
-  mod: ModuleInstance
-  privateResolver?: ModuleResolver
-  transformers: ModuleIdentifierTransformer[]
-  upResolver?: ModuleResolver
-}
-
-export class ResolveHelper extends ResolveHelperStatic {
-  static async resolve<T extends ModuleInstance = ModuleInstance>(
-    config: ResolveHelperConfig,
-    all: '*',
-    options?: ModuleFilterOptions<T>,
-  ): Promise<T[]>
-  static async resolve<T extends ModuleInstance = ModuleInstance>(
-    config: ResolveHelperConfig,
-    id: ModuleIdentifier,
-    options?: ModuleFilterOptions<T>,
-  ): Promise<T | undefined>
-  static async resolve<T extends ModuleInstance = ModuleInstance>(
-    config: ResolveHelperConfig,
-    id: ModuleIdentifier = '*',
-    {
-      maxDepth = 3, required = 'log', ...options
-    }: ModuleFilterOptions<T> = {},
-  ): Promise<T | T[] | undefined> {
-    const {
-      transformers, mod, logger = this.defaultLogger, dead = false, upResolver, downResolver, privateResolver,
-    } = config
-    const log = logger ? new IdLogger(logger, () => `ResolveHelper [${mod.id}][${id}]`) : undefined
-
-    const downLocalOptions: ModuleFilterOptions<T> = {
-      ...options, direction: 'down', maxDepth, required: false,
-    }
-    const upLocalOptions: ModuleFilterOptions<T> = { ...downLocalOptions, direction: 'up' }
-
-    const childOptions: ModuleFilterOptions<T> = {
-      ...options, maxDepth: maxDepth - 1, required: false,
-    }
-
-    const direction = options?.direction ?? 'all'
-    const up = direction === 'up' || direction === 'all'
-    const down = direction === 'down' || direction === 'all'
-    let result: T | T[] | undefined
-    log?.debug('start', id, maxDepth)
-    if (id === '*') {
-      if (dead) {
-        log?.warn('failed [dead]', id)
-        return []
-      }
-      const modules = [
-        ...(down ? await (downResolver as ModuleResolver).resolve<T>('*', downLocalOptions) : []),
-        ...(up ? await (upResolver as ModuleResolver).resolve<T>('*', upLocalOptions) : []),
-      ].filter(duplicateModules)
-
-      if (modules.length > 0) {
-        log?.debug('modules [count]', modules.length)
-      }
-
-      if (maxDepth === 0) {
-        return modules
-      }
-      const childModules = (await Promise.all(modules.map(async mod => await mod.resolve<T>('*', childOptions)))).flat().filter(duplicateModules)
-      return [...modules, ...childModules, mod as T].filter(duplicateModules)
-    } else {
-      switch (typeof id) {
-        case 'string': {
-          if (dead) {
-            return undefined
-          }
-
-          const resolvedId = assertEx((await resolvePathToAddress(mod, id, false, transformers)) ?? id, () => 'Invalid resolvedId')
-
-          const resolvers = [
-            [downResolver, downLocalOptions],
-            [up ? upResolver : undefined, upLocalOptions],
-            [up ? privateResolver : undefined, upLocalOptions],
-          ].filter(([resolver]) => exists(resolver)) as [ModuleResolver, ModuleFilterOptions<T>][]
-
-          for (const resolver of resolvers) {
-            const [resolverInstance] = resolver
-            if (!result) {
-              result = await this.resolveModuleIdentifier<T>(resolverInstance, resolvedId)
-            }
-          }
-
-          break
-        }
-        default: {
-          break
-        }
-      }
-    }
-    this.validateRequiredResolve(required, result, id, logger)
-    return result
-  }
-
-  // resolves a complex module path to addresses
-  static async resolveModuleIdentifier<T extends ModuleInstance = ModuleInstance>(
-    resolver: ModuleResolver,
-    path: ModuleIdentifier,
-    required?: boolean,
-  ): Promise<T | undefined> {
-    const parts = path.split(':')
-    const first = parts.shift()
-    const firstIsAddress = isAddress(first)
-    const resolvedModule
-      = (await resolver.resolve(first, { maxDepth: firstIsAddress ? 10 : 1 }))
-        ?? (isString(first) ? await resolver.resolvePrivate(first, { maxDepth: firstIsAddress ? 10 : 1 }) : undefined)
-    const finalModule = required ? assertEx(resolvedModule, () => `Failed to resolve [${first}] [${firstIsAddress}]`) : resolvedModule
-    const firstModule = asModuleInstance(finalModule, () => `Resolved invalid module instance [${first}]`)
-    return isDefined(firstModule) ? (parts.length > 0 ? await this.resolveModuleIdentifier<T>(firstModule, parts.join(':')) : firstModule as T) : undefined
-  }
-
-  // translates a complex module path to addresses
-  static traceModuleIdentifier(resolver: ModuleResolver, path: ModuleIdentifier) {
-    return traceModuleIdentifier(resolver, path)
-  }
-
-  static transformModuleIdentifier(identifier: ModuleIdentifier, transformers: ModuleIdentifierTransformer[] = ResolveHelper.transformers) {
-    return transformModuleIdentifier(identifier, transformers)
-  }
-
-  static validateRequiredResolve(
-    required: boolean | 'warn' | 'log',
-    result: ModuleInstance[] | ModuleInstance | undefined,
-    id: ModuleIdentifier,
-    logger = this.defaultLogger,
-  ) {
-    const log = logger ? new IdLogger(logger, () => `validateRequiredResolve [${id}][${result}]`) : undefined
-    if (isTruthy(required) && (result === undefined || (Array.isArray(result) && result.length > 0))) {
-      switch (required) {
-        case 'warn': {
-          log?.warn('resolve failed', id)
-          break
-        }
-        case 'log': {
-          log?.log('resolve failed', id)
-          break
-        }
-        default: {
-          throw new Error(`resolve failed [${id}]`)
-        }
-      }
-    }
-  }
-}

package/src/ResolveHelper/ResolveHelperStatic.ts

@@ -1,9 +0,0 @@
-import type { Logger } from '@xylabs/sdk-js'
-
-import type { ModuleIdentifierTransformer } from '../ModuleIdentifierTransformer.ts'
-
-export class ResolveHelperStatic {
-  static readonly defaultLogger?: Logger
-  // eslint-disable-next-line sonarjs/public-static-readonly
-  static transformers: ModuleIdentifierTransformer[] = []
-}

package/src/ResolveHelper/index.ts

@@ -1,9 +0,0 @@
-export * from './model.ts'
-export * from './resolveAddressToInstance.ts'
-export * from './resolveAll.ts'
-export * from './ResolveHelper.ts'
-export * from './resolveLocalNameToAddress.ts'
-export * from './resolveLocalNameToInstance.ts'
-export * from './resolvePathToAddress.ts'
-export * from './resolvePathToInstance.ts'
-export * from './transformModuleIdentifier.ts'

package/src/ResolveHelper/model.ts

@@ -1 +0,0 @@
-export type ModuleResolveDirection = 'all' | 'up' | 'down'

package/src/ResolveHelper/resolveAddressToInstance.ts

@@ -1,94 +0,0 @@
-import type { Address } from '@xylabs/sdk-js'
-
-import type { ModuleInstance } from '../instance/index.ts'
-import type { ModuleResolveDirection } from './model.ts'
-
-export const resolveAddressToInstanceDown = async (
-  root: ModuleInstance,
-  address: Address,
-  includePrivate: boolean | undefined = undefined,
-  ignore: Address[] = [],
-): Promise<ModuleInstance | undefined> => {
-  if (root.address === address) {
-    return root
-  }
-  const cache = root.addressCache?.('up', !!includePrivate)
-  const privateChildren = (includePrivate ? await root.privateChildren?.() : []) ?? []
-  const publicChildren = (await root.publicChildren?.()) ?? []
-  const children = [...privateChildren, ...publicChildren]
-  for (const child of children) {
-    const found = await resolveAddressToInstanceDown(child, address, includePrivate, ignore)
-    if (found) {
-      cache?.set(address, new WeakRef(found))
-      return found
-    }
-  }
-  cache?.set(address, null)
-}
-
-export const resolveAddressToInstanceSiblings = async (
-  root: ModuleInstance,
-  address: Address,
-  includePrivate: boolean | undefined = undefined,
-  ignore: Address[] = [],
-): Promise<ModuleInstance | undefined> => {
-  const siblings = (await root.siblings?.()) ?? []
-  for (const sibling of siblings) {
-    const found = await resolveAddressToInstanceDown(sibling, address, includePrivate, ignore)
-    if (found) {
-      return found
-    }
-  }
-}
-
-export const resolveAddressToInstanceUp = async (
-  root: ModuleInstance,
-  address: Address,
-  includePrivate: boolean | undefined = undefined,
-  ignore: Address[] = [],
-): Promise<ModuleInstance | undefined> => {
-  const cache = root.addressCache?.('up', includePrivate ?? true)
-  const parents = (await root.parents?.()) ?? []
-  for (const parent of parents) {
-    const found = await resolveAddressToInstance(parent, address, includePrivate, ignore)
-    if (found) {
-      cache?.set(address, new WeakRef(found))
-      return found
-    }
-  }
-  cache?.set(address, null)
-}
-
-export const resolveAddressToInstanceAll = async (
-  root: ModuleInstance,
-  address: Address,
-  includePrivate: boolean | undefined = undefined,
-  ignore: Address[] = [],
-): Promise<ModuleInstance | undefined> => {
-  const cache = root.addressCache?.('all', !!includePrivate)
-  const result
-    = (await resolveAddressToInstanceDown(root, address, includePrivate ?? false, ignore))
-      ?? (await resolveAddressToInstanceUp(root, address, includePrivate ?? true, ignore))
-  cache?.set(address, result ? new WeakRef(result) : null)
-  return result
-}
-
-export const resolveAddressToInstance = async (
-  root: ModuleInstance,
-  address: Address,
-  includePrivate: boolean | undefined = undefined,
-  ignore: Address[] = [],
-  direction: ModuleResolveDirection = 'all',
-): Promise<ModuleInstance | undefined> => {
-  switch (direction) {
-    case 'all': {
-      return await resolveAddressToInstanceAll(root, address, includePrivate, ignore)
-    }
-    case 'up': {
-      return await resolveAddressToInstanceUp(root, address, includePrivate ?? true, ignore)
-    }
-    case 'down': {
-      return await resolveAddressToInstanceDown(root, address, includePrivate ?? false, ignore)
-    }
-  }
-}

package/src/ResolveHelper/resolveAll.ts

@@ -1,53 +0,0 @@
-import type { Address } from '@xylabs/sdk-js'
-
-import type { ModuleInstance } from '../instance/index.ts'
-import { duplicateModules } from '../lib/index.ts'
-
-export const resolveAllUp = async (root: ModuleInstance, maxDepth = 10, exclude: Address[] = []): Promise<ModuleInstance[]> => {
-  if (maxDepth === 0) {
-    return [root].filter(mod => !exclude.includes(mod.address))
-  }
-  const parents = (await root.parents()).filter(mod => !exclude.includes(mod.address))
-  return (
-    maxDepth > 1
-      ? [
-          ...(await Promise.all(parents.map(async mod => await resolveAllUp(mod, maxDepth - 1, [...exclude, root.address])))).flat(),
-          ...(await Promise.all(parents.map(async mod => await resolveAllDown(mod, maxDepth - 1, [...exclude, root.address], true)))).flat(),
-          ...parents,
-          root,
-        ]
-      : [...parents, root])
-    .filter(mod => !exclude.includes(mod.address))
-    .filter(duplicateModules)
-}
-
-export const resolveAllDown = async (
-  root: ModuleInstance,
-  maxDepth = 10,
-  exclude: Address[] = [],
-  includePrivate = false,
-): Promise<ModuleInstance[]> => {
-  if (maxDepth === 0) {
-    return [root]
-  }
-  const children = (await root.publicChildren()).filter(mod => !exclude.includes(mod.address))
-  const privateChildren = includePrivate ? (await root.privateChildren()).filter(mod => !exclude.includes(mod.address)) : []
-  return (
-    maxDepth > 1
-      ? [
-          ...children,
-          ...(await Promise.all(children.map(child => resolveAllDown(child, maxDepth - 1, [...exclude, root.address])))).flat(),
-          ...(await Promise.all(privateChildren.map(child => resolveAllDown(child, maxDepth - 1, [...exclude, root.address])))).flat(),
-          root,
-        ]
-      : [...children, root])
-    .filter(mod => !exclude.includes(mod.address))
-    .filter(duplicateModules)
-}
-
-export const resolveAll = async (root: ModuleInstance, maxDepth = 10, exclude: Address[] = []): Promise<ModuleInstance[]> => {
-  if (maxDepth === 0) {
-    return [root]
-  }
-  return [...(await resolveAllUp(root, maxDepth, exclude)), ...(await resolveAllDown(root, maxDepth, exclude))].filter(duplicateModules)
-}

package/src/ResolveHelper/resolveLocalNameToAddress.ts

@@ -1,40 +0,0 @@
-import type { Address } from '@xylabs/sdk-js'
-
-import type { ModuleInstance } from '../instance/index.ts'
-import type { ModuleName } from '../ModuleIdentifier.ts'
-import type { ModuleResolveDirection } from './model.ts'
-import {
-  resolveLocalNameToInstance,
-  resolveLocalNameToInstanceAll,
-  resolveLocalNameToInstanceDown,
-  resolveLocalNameToInstanceUp,
-} from './resolveLocalNameToInstance.ts'
-
-export const resolveLocalNameToAddressUp = async (root: ModuleInstance, modName: ModuleName): Promise<Address | undefined> => {
-  return (await resolveLocalNameToInstanceUp(root, modName))?.address
-}
-
-export const resolveLocalNameToAddressDown = async (
-  root: ModuleInstance,
-  modName: ModuleName,
-  includePrivate: boolean | undefined = undefined,
-): Promise<Address | undefined> => {
-  return (await resolveLocalNameToInstanceDown(root, modName, includePrivate))?.address
-}
-
-export const resolveLocalNameToAddressAll = async (
-  root: ModuleInstance,
-  modName: ModuleName,
-  includePrivate: boolean | undefined = undefined,
-): Promise<Address | undefined> => {
-  return (await resolveLocalNameToInstanceAll(root, modName, includePrivate))?.address
-}
-
-export const resolveLocalNameToAddress = async (
-  root: ModuleInstance,
-  modName: ModuleName,
-  includePrivate: boolean | undefined = undefined,
-  direction: ModuleResolveDirection = 'all',
-): Promise<Address | undefined> => {
-  return (await resolveLocalNameToInstance(root, modName, includePrivate, direction))?.address
-}

package/src/ResolveHelper/resolveLocalNameToInstance.ts

@@ -1,47 +0,0 @@
-import type { ModuleInstance } from '../instance/index.ts'
-import type { ModuleName } from '../ModuleIdentifier.ts'
-import type { ModuleResolveDirection } from './model.ts'
-
-export const resolveLocalNameToInstanceUp = async (root: ModuleInstance, modName: ModuleName): Promise<ModuleInstance | undefined> => {
-  const parents = (await root.parents?.()) ?? []
-  return parents.find(parent => parent.config.name === modName)
-}
-
-// since this is a modName, it only checks the children of the root module
-export const resolveLocalNameToInstanceDown = async (
-  root: ModuleInstance,
-  modName: ModuleName,
-  includePrivate: boolean | undefined = undefined,
-): Promise<ModuleInstance | undefined> => {
-  const privateChildren = (includePrivate ? await root.privateChildren?.() : []) ?? []
-  const publicChildren = (await root.publicChildren?.()) ?? []
-  const children = [...privateChildren, ...publicChildren]
-  return children.find(child => child.config.name === modName)
-}
-
-export const resolveLocalNameToInstanceAll = async (
-  root: ModuleInstance,
-  modName: ModuleName,
-  includePrivate = false,
-): Promise<ModuleInstance | undefined> => {
-  return (await resolveLocalNameToInstanceDown(root, modName, includePrivate)) ?? (await resolveLocalNameToInstanceUp(root, modName))
-}
-
-export const resolveLocalNameToInstance = async (
-  root: ModuleInstance,
-  modName: ModuleName,
-  includePrivate = false,
-  direction: ModuleResolveDirection = 'all',
-): Promise<ModuleInstance | undefined> => {
-  switch (direction) {
-    case 'all': {
-      return await resolveLocalNameToInstanceAll(root, modName, includePrivate)
-    }
-    case 'up': {
-      return await resolveLocalNameToInstanceUp(root, modName)
-    }
-    case 'down': {
-      return await resolveLocalNameToInstanceDown(root, modName, includePrivate)
-    }
-  }
-}

package/src/ResolveHelper/resolvePathToAddress.ts

@@ -1,15 +0,0 @@
-import type { Address } from '@xylabs/sdk-js'
-
-import type { ModuleInstance } from '../instance/index.ts'
-import type { ModuleIdentifierTransformer } from '../ModuleIdentifierTransformer.ts'
-import { ResolveHelperStatic } from './ResolveHelperStatic.ts'
-import { resolvePathToInstance } from './resolvePathToInstance.ts'
-
-export const resolvePathToAddress = async (
-  root: ModuleInstance,
-  path: string,
-  includePrivate: boolean | undefined = undefined,
-  transformers: ModuleIdentifierTransformer[] = ResolveHelperStatic.transformers,
-): Promise<Address | undefined> => {
-  return (await resolvePathToInstance(root, path, includePrivate, transformers))?.address
-}

package/src/ResolveHelper/resolvePathToInstance.ts

@@ -1,36 +0,0 @@
-import { asAddress, assertEx } from '@xylabs/sdk-js'
-
-import type { ModuleInstance } from '../instance/index.ts'
-import { MODULE_PATH_SEPARATOR } from '../ModuleIdentifier.ts'
-import type { ModuleIdentifierTransformer } from '../ModuleIdentifierTransformer.ts'
-import { resolveAddressToInstance } from './resolveAddressToInstance.ts'
-import { ResolveHelperStatic } from './ResolveHelperStatic.ts'
-import { resolveLocalNameToAddress } from './resolveLocalNameToAddress.ts'
-import { transformModuleIdentifier } from './transformModuleIdentifier.ts'
-
-export const resolvePathToInstance = async (
-  root: ModuleInstance,
-  path: string,
-  includePrivate: boolean | undefined = undefined,
-  transformers: ModuleIdentifierTransformer[] = ResolveHelperStatic.transformers,
-): Promise<ModuleInstance | undefined> => {
-  const parts = path.split(MODULE_PATH_SEPARATOR)
-  const first = await transformModuleIdentifier(
-    assertEx(parts.shift(), () => `First part is invalid [${path}]`),
-    transformers,
-  )
-
-  if (!first) {
-    return undefined
-  }
-
-  const firstAddress = asAddress(first) ?? (await resolveLocalNameToAddress(root, first, includePrivate))
-
-  if (firstAddress) {
-    const firstModule = await resolveAddressToInstance(root, firstAddress, includePrivate)
-    if (firstModule && parts.length > 0) {
-      return resolvePathToInstance(firstModule, parts.join(MODULE_PATH_SEPARATOR))
-    }
-    return firstModule
-  }
-}

package/src/ResolveHelper/traceModuleIdentifier.ts

@@ -1,19 +0,0 @@
-import type { Address } from '@xylabs/sdk-js'
-import { assertEx } from '@xylabs/sdk-js'
-
-import type { ModuleResolver } from '../instance/index.ts'
-import { asModuleInstance } from '../instance/index.ts'
-import type { ModuleIdentifier } from '../ModuleIdentifier.ts'
-
-export const traceModuleIdentifier = async (resolver: ModuleResolver, path: ModuleIdentifier): Promise<Address[]> => {
-  const parts = path.split(':')
-  const first = parts.shift()
-  const firstModule = asModuleInstance(
-    assertEx(await resolver.resolve(first, { maxDepth: 1 }), () => `Failed to resolve [${first}]`),
-    () => `Resolved invalid module instance [${first}]`,
-  )
-  if (firstModule) {
-    return parts.length > 0 ? [firstModule.address, ...(await traceModuleIdentifier(firstModule, parts.join(':')))] : [firstModule.address]
-  }
-  return []
-}

package/src/ResolveHelper/transformModuleIdentifier.ts

@@ -1,13 +0,0 @@
-import type { ModuleIdentifier } from '../ModuleIdentifier.ts'
-import type { ModuleIdentifierTransformer } from '../ModuleIdentifierTransformer.ts'
-
-export const transformModuleIdentifier = async (
-  id: ModuleIdentifier,
-  transformers: ModuleIdentifierTransformer[],
-): Promise<ModuleIdentifier | undefined> => {
-  let result: ModuleIdentifier | undefined = id
-  for (const transformer of transformers) {
-    result = await transformer.transform(id)
-  }
-  return result
-}

package/src/cache.ts

@@ -1,5 +0,0 @@
-export interface CacheConfig {
-  max?: number
-  maxSize?: number
-  ttl?: number
-}

package/src/index.ts

@@ -1,20 +0,0 @@
-export * from './cache.ts'
-export * from './Config/index.ts'
-export * from './CreatableModule/index.ts'
-export * from './DetailsError.ts'
-export * from './EventsModels/index.ts'
-export * from './instance/index.ts'
-export * from './Labels/index.ts'
-export * from './lib/index.ts'
-export * from './ModuleDescription.ts'
-export * from './ModuleFactoryLocatorInstance.ts'
-export * from './ModuleIdentifier.ts'
-export * from './ModuleIdentifierTransformer.ts'
-export * from './ModuleQueryHandlerResult.ts'
-export * from './ModuleQueryResult.ts'
-export * from './ModuleStatusReporter.ts'
-export * from './Payload/index.ts'
-export * from './Queries/index.ts'
-export * from './QueryableModule/index.ts'
-export * from './ResolveHelper/index.ts'
-export * from './withModule.ts'

package/src/instance/Instance.ts

@@ -1,68 +0,0 @@
-import type {
-  Address, CreatableStatus, Promisable,
-  TypeCheck,
-} from '@xylabs/sdk-js'
-import { IsObjectFactory, toSafeJsonString } from '@xylabs/sdk-js'
-import type { AccountInstance } from '@xyo-network/account-model'
-
-import type { ModuleEventData } from '../EventsModels/index.ts'
-import type { ModuleIdentifier, ModuleName } from '../ModuleIdentifier.ts'
-import type {
-  QueryableModule, QueryableModuleFunctions,
-  QueryableModuleParams,
-} from '../QueryableModule/index.ts'
-import type { Direction } from './ObjectFilter.ts'
-import type { ObjectResolver } from './ObjectResolver.ts'
-
-export type ModulePipeLine = Lowercase<'one-to-one' | 'one-to-many' | 'many-to-one' | 'many-to-many'>
-
-export type ModuleStatus = CreatableStatus | 'wrapped' | 'proxy'
-
-export class DeadModuleError extends Error {
-  error: Error | undefined
-  id: ModuleIdentifier
-  constructor(
-    id: ModuleIdentifier,
-    error: Error | undefined,
-    msg = 'Dead Module Error',
-  ) {
-    super(`${msg} [${id}]: ${error?.message ?? toSafeJsonString(error)}`)
-    this.id = id
-    this.error = error
-
-    // Set the prototype explicitly.
-    Object.setPrototypeOf(this, DeadModuleError.prototype)
-  }
-}
-
-export interface AddressToWeakInstanceCache {
-  get: (address: Address) => WeakRef<ModuleInstance> | null
-  set: (address: Address, instance: WeakRef<ModuleInstance> | null) => void
-}
-
-export interface ModuleFamilyFunctions {
-  account?: AccountInstance
-  addParent: (mod: ModuleInstance) => void
-  addressCache?: (direction: Direction, includePrivate: boolean) => AddressToWeakInstanceCache | undefined
-  modName?: ModuleName
-  parents: () => Promisable<ModuleInstance[]>
-  privateChildren: () => Promisable<ModuleInstance[]>
-  publicChildren: () => Promisable<ModuleInstance[]>
-  removeParent: (address: Address) => void
-  siblings: () => Promisable<ModuleInstance[]>
-}
-
-export interface ModuleInstance<TParams extends QueryableModuleParams = QueryableModuleParams, TEventData extends ModuleEventData = ModuleEventData>
-  extends QueryableModule<TParams, TEventData>,
-  ObjectResolver<ModuleInstance>,
-  QueryableModuleFunctions,
-  ModuleFamilyFunctions {
-  readonly pipeline?: ModulePipeLine
-
-  // if the module has become non-functional, such as a broken bridge connection, this will be 'dead'
-  readonly status: ModuleStatus | null
-}
-
-export type InstanceTypeCheck<T extends ModuleInstance = ModuleInstance> = TypeCheck<T>
-
-export class IsInstanceFactory<T extends ModuleInstance = ModuleInstance> extends IsObjectFactory<T> {}