@xyo-network/module-model 2.100.28 → 2.101.1

package/src/ResolveHelper/resolveLocalNameToAddress.ts

@@ -2,28 +2,21 @@ import { Address } from '@xylabs/hex'
 
 import { ModuleInstance } from '../instance'
 import { ModuleName } from '../ModuleIdentifier'
+import { resolveLocalNameToInstance, resolveLocalNameToInstanceDown, resolveLocalNameToInstanceUp } from './resolveLocalNameToInstance'
 
-export const resolveLocalNameToAddressUp = async (root: ModuleInstance, localName: ModuleName): Promise<Address | undefined> => {
-  const parents = (await root.parents?.()) ?? []
-  return parents.find((parent) => parent.localName === localName)?.address
+export const resolveLocalNameToAddressUp = async (root: ModuleInstance, modName: ModuleName): Promise<Address | undefined> => {
+  return (await resolveLocalNameToInstanceUp(root, modName))?.address
 }
 
-//since this is a localName, it only checks the children of the root module
+//since this is a modName, it only checks the children of the root module
 export const resolveLocalNameToAddressDown = async (
   root: ModuleInstance,
-  localName: ModuleName,
+  modName: ModuleName,
   includePrivate = false,
 ): Promise<Address | undefined> => {
-  const privateChildren = (includePrivate ? await root.privateChildren?.() : []) ?? []
-  const publicChildren = (await root.publicChildren?.()) ?? []
-  const children = [...privateChildren, ...publicChildren]
-  return children.find((child) => child.localName === localName)?.address
+  return (await resolveLocalNameToInstanceDown(root, modName, includePrivate))?.address
 }
 
-export const resolveLocalNameToAddress = async (
-  root: ModuleInstance,
-  localName: ModuleName,
-  includePrivate = false,
-): Promise<Address | undefined> => {
-  return (await resolveLocalNameToAddressDown(root, localName, includePrivate)) ?? (await resolveLocalNameToAddressUp(root, localName))
+export const resolveLocalNameToAddress = async (root: ModuleInstance, modName: ModuleName, includePrivate = false): Promise<Address | undefined> => {
+  return (await resolveLocalNameToInstance(root, modName, includePrivate))?.address
 }

package/src/ResolveHelper/resolveLocalNameToInstance.ts

@@ -0,0 +1,27 @@
+import { ModuleInstance } from '../instance'
+import { ModuleName } from '../ModuleIdentifier'
+
+export const resolveLocalNameToInstanceUp = async (root: ModuleInstance, modName: ModuleName): Promise<ModuleInstance | undefined> => {
+  const parents = (await root.parents?.()) ?? []
+  return parents.find((parent) => parent.modName === modName)
+}
+
+//since this is a modName, it only checks the children of the root module
+export const resolveLocalNameToInstanceDown = async (
+  root: ModuleInstance,
+  modName: ModuleName,
+  includePrivate = false,
+): Promise<ModuleInstance | undefined> => {
+  const privateChildren = (includePrivate ? await root.privateChildren?.() : []) ?? []
+  const publicChildren = (await root.publicChildren?.()) ?? []
+  const children = [...privateChildren, ...publicChildren]
+  return children.find((child) => child.modName === modName)
+}
+
+export const resolveLocalNameToInstance = async (
+  root: ModuleInstance,
+  modName: ModuleName,
+  includePrivate = false,
+): Promise<ModuleInstance | undefined> => {
+  return (await resolveLocalNameToInstanceDown(root, modName, includePrivate)) ?? (await resolveLocalNameToInstanceUp(root, modName))
+}

package/src/ResolveHelper/resolvePathToAddress.ts

@@ -1,13 +1,9 @@
-import { assertEx } from '@xylabs/assert'
-import { Address, asAddress } from '@xylabs/hex'
+import { Address } from '@xylabs/hex'
 
 import { ModuleInstance } from '../instance'
-import { MODULE_PATH_SEPARATOR } from '../ModuleIdentifier'
 import { ModuleIdentifierTransformer } from '../ModuleIdentifierTransformer'
-import { resolveAddressToInstance } from './resolveAddressToInstance'
 import { ResolveHelper } from './ResolveHelper'
-import { resolveLocalNameToAddress } from './resolveLocalNameToAddress'
-import { transformModuleIdentifier } from './transformModuleIdentifier'
+import { resolvePathToInstance } from './resolvePathToInstance'
 
 export const resolvePathToAddress = async (
   root: ModuleInstance,
@@ -15,23 +11,5 @@ export const resolvePathToAddress = async (
   includePrivate = false,
   transformers: ModuleIdentifierTransformer[] = ResolveHelper.transformers,
 ): Promise<Address | 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 resolvePathToAddress(firstModule, parts.join(MODULE_PATH_SEPARATOR))
-    }
-    return firstAddress
-  }
+  return (await resolvePathToInstance(root, path, includePrivate, transformers))?.address
 }

package/src/ResolveHelper/resolvePathToInstance.ts

@@ -0,0 +1,37 @@
+import { assertEx } from '@xylabs/assert'
+import { asAddress } from '@xylabs/hex'
+
+import { ModuleInstance } from '../instance'
+import { MODULE_PATH_SEPARATOR } from '../ModuleIdentifier'
+import { ModuleIdentifierTransformer } from '../ModuleIdentifierTransformer'
+import { resolveAddressToInstance } from './resolveAddressToInstance'
+import { ResolveHelper } from './ResolveHelper'
+import { resolveLocalNameToAddress } from './resolveLocalNameToAddress'
+import { transformModuleIdentifier } from './transformModuleIdentifier'
+
+export const resolvePathToInstance = async (
+  root: ModuleInstance,
+  path: string,
+  includePrivate = false,
+  transformers: ModuleIdentifierTransformer[] = ResolveHelper.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/instance/Instance.ts

@@ -36,7 +36,7 @@ export interface ModuleFamilyFunctions {
   account?: AccountInstance | undefined
   addParent: (module: ModuleInstance) => void
   addressCache?: (direction: Direction, includePrivate: boolean) => AddressToWeakInstanceCache | undefined
-  localName: ModuleName | undefined
+  modName?: ModuleName
   parents: () => Promisable<ModuleInstance[]>
   privateChildren: () => Promisable<ModuleInstance[]>
   publicChildren: () => Promisable<ModuleInstance[]>

package/src/module/ModuleFields.ts

@@ -4,6 +4,7 @@ import { QueryBoundWitness } from '@xyo-network/boundwitness-model'
 import { Payload } from '@xyo-network/payload-model'
 
 import { ModuleConfig } from '../Config'
+import { ModuleName } from '../ModuleIdentifier'
 import { ModuleParams } from '../ModuleParams'
 import { ModuleQueryResult } from '../ModuleQueryResult'
 
@@ -14,6 +15,8 @@ export interface ModuleFields<TParams extends ModuleParams = ModuleParams> {
   /** The name (if specified) or address of the module */
   id: string
 
+  modName?: ModuleName
+
   params: TParams
 
   previousHash: () => Promisable<string | undefined>