@xyo-network/module-abstract 2.107.5 → 2.108.0

package/src/AbstractModule.ts

@@ -268,7 +268,7 @@ export abstract class AbstractModule<TParams extends ModuleParams = ModuleParams
   async busy<R>(closure: () => Promise<R>) {
     if (this._busyCount <= 0) {
       this._busyCount = 0
-      const args: ModuleBusyEventArgs = { busy: true, module: this }
+      const args: ModuleBusyEventArgs = { busy: true, mod: this }
       await this.emit('moduleBusy', args)
     }
     this._busyCount++
@@ -278,7 +278,7 @@ export abstract class AbstractModule<TParams extends ModuleParams = ModuleParams
       this._busyCount--
       if (this._busyCount <= 0) {
         this._busyCount = 0
-        const args: ModuleBusyEventArgs = { busy: false, module: this }
+        const args: ModuleBusyEventArgs = { busy: false, mod: this }
         await this.emit('moduleBusy', args)
       }
     }
@@ -339,7 +339,7 @@ export abstract class AbstractModule<TParams extends ModuleParams = ModuleParams
         resultPayloads.push(timestamp)
       }
       const result = await this.bindQueryResult(sourceQuery, resultPayloads, queryAccount ? [queryAccount] : [], errorPayloads)
-      const args: ModuleQueriedEventArgs = { module: this, payloads, query: sourceQuery, result }
+      const args: ModuleQueriedEventArgs = { mod: this, payloads, query: sourceQuery, result }
       await this.emit('moduleQueried', args)
       return result
     })

package/src/AbstractModuleInstance.ts

@@ -11,6 +11,8 @@ import {
   AddressPreviousHashPayload,
   AttachableModuleInstance,
   duplicateModules,
+  isAddressModuleFilter,
+  isNameModuleFilter,
   ModuleEventData,
   ModuleFilter,
   ModuleFilterOptions,
@@ -25,8 +27,11 @@ import {
   ModuleStateQuery,
   ModuleStateQuerySchema,
   ObjectFilterOptions,
+  resolveAddressToInstance,
   ResolveHelper,
   ResolveHelperConfig,
+  resolveLocalNameToInstance,
+  resolvePathToInstance,
 } from '@xyo-network/module-model'
 import { CompositeModuleResolver } from '@xyo-network/module-resolver'
 import { asNodeInstance, NodeInstance } from '@xyo-network/node-model'
@@ -40,6 +45,9 @@ export abstract class AbstractModuleInstance<TParams extends ModuleParams = Modu
 {
   static override readonly uniqueName = globallyUnique('AbstractModuleInstance', AbstractModuleInstance, 'xyo')
 
+  //switches between old and new resolution system
+  static readonly useNewResolver = false
+
   private _downResolver?: CompositeModuleResolver
   private _parents: NodeInstance[] = []
   private _privateResolver?: CompositeModuleResolver
@@ -102,10 +110,10 @@ export abstract class AbstractModuleInstance<TParams extends ModuleParams = Modu
     return this._upResolver
   }
 
-  addParent(module: ModuleInstance) {
-    const existingEntry = this._parents.find((parent) => parent.address === module.address)
+  addParent(mod: ModuleInstance) {
+    const existingEntry = this._parents.find((parent) => parent.address === mod.address)
     if (!existingEntry) {
-      this._parents.push(asNodeInstance(module, 'Only NodeInstances can be parents'))
+      this._parents.push(asNodeInstance(mod, 'Only NodeInstances can be parents'))
     }
   }
 
@@ -167,28 +175,51 @@ export abstract class AbstractModuleInstance<TParams extends ModuleParams = Modu
     idOrFilter: ModuleFilter<T> | ModuleIdentifier = '*',
     options: ModuleFilterOptions<T> = {},
   ): Promise<T | T[] | undefined> {
-    const config: ResolveHelperConfig = {
-      address: this.address,
-      dead: this.dead,
-      downResolver: this.downResolver,
-      logger: this.logger,
-      module: this,
-      transformers: this.moduleIdentifierTransformers,
-      upResolver: this.upResolver,
-    }
-    if (idOrFilter === '*') {
-      return (await ResolveHelper.resolve(config, idOrFilter, options)).filter((mod) => mod.address !== this.address)
-    }
-    switch (typeof idOrFilter) {
-      case 'string': {
-        return await ResolveHelper.resolve(config, idOrFilter, options)
+    if (AbstractModuleInstance.useNewResolver) {
+      if (idOrFilter === '*') {
+        return (await this.publicChildren()) as T[]
       }
-      case 'object': {
-        return (await ResolveHelper.resolve(config, idOrFilter, options)).filter((mod) => mod.address !== this.address)
+      switch (typeof idOrFilter) {
+        case 'string': {
+          return (await resolvePathToInstance(this, idOrFilter)) as T | undefined
+        }
+        case 'object': {
+          if (isNameModuleFilter(idOrFilter)) {
+            return (await Promise.all(idOrFilter.name.map(async (name) => await resolveLocalNameToInstance(this, name)))) as T[]
+          }
+          if (isAddressModuleFilter(idOrFilter)) {
+            return (await Promise.all(idOrFilter.address.map(async (address) => await resolveAddressToInstance(this, address)))) as T[]
+          }
+          throw new Error('Invalid filter type')
+        }
+        default: {
+          return (await this.publicChildren()) as T[]
+        }
       }
-      default: {
+    } else {
+      const config: ResolveHelperConfig = {
+        address: this.address,
+        dead: this.dead,
+        downResolver: this.downResolver,
+        logger: this.logger,
+        mod: this,
+        transformers: this.moduleIdentifierTransformers,
+        upResolver: this.upResolver,
+      }
+      if (idOrFilter === '*') {
         return (await ResolveHelper.resolve(config, idOrFilter, options)).filter((mod) => mod.address !== this.address)
       }
+      switch (typeof idOrFilter) {
+        case 'string': {
+          return await ResolveHelper.resolve(config, idOrFilter, options)
+        }
+        case 'object': {
+          return (await ResolveHelper.resolve(config, idOrFilter, options)).filter((mod) => mod.address !== this.address)
+        }
+        default: {
+          return (await ResolveHelper.resolve(config, idOrFilter, options)).filter((mod) => mod.address !== this.address)
+        }
+      }
     }
   }