@xyo-network/module-resolver 5.3.22 → 5.3.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xyo-network/module-resolver",
-  "version": "5.3.22",
+  "version": "5.3.25",
   "description": "Primary SDK for using XYO Protocol 2.0",
   "homepage": "https://xyo.network",
   "bugs": {
@@ -30,40 +30,36 @@
   "types": "dist/neutral/index.d.ts",
   "files": [
     "dist",
-    "src",
     "!**/*.bench.*",
     "!**/*.spec.*",
     "!**/*.test.*",
     "README.md"
   ],
   "dependencies": {
-    "@xyo-network/diviner-model": "~5.3.22",
-    "@xyo-network/diviner-payload-model": "~5.3.22",
-    "@xyo-network/module-model": "~5.3.22",
-    "lru-cache": "~11.2.7"
+    "lru-cache": "~11.2.7",
+    "@xyo-network/diviner-model": "~5.3.25",
+    "@xyo-network/diviner-payload-model": "~5.3.25",
+    "@xyo-network/module-model": "~5.3.25"
   },
   "devDependencies": {
     "@opentelemetry/api": "^1.9.1",
     "@types/node": "^25.5.0",
-    "@xylabs/sdk-js": "^5.0.91",
-    "@xylabs/ts-scripts-common": "~7.6.8",
-    "@xylabs/ts-scripts-yarn3": "~7.6.8",
-    "@xylabs/tsconfig": "~7.6.8",
-    "@xylabs/vitest-extended": "~5.0.91",
-    "@xyo-network/diviner-model": "~5.3.22",
-    "@xyo-network/diviner-payload-model": "~5.3.22",
-    "@xyo-network/module-model": "~5.3.22",
+    "@xylabs/sdk-js": "^5.0.93",
+    "@xylabs/ts-scripts-common": "~7.6.16",
+    "@xylabs/ts-scripts-pnpm": "~7.6.16",
+    "@xylabs/tsconfig": "~7.6.16",
+    "@xylabs/vitest-extended": "~5.0.93",
     "acorn": "^8.16.0",
     "axios": "^1.14.0",
-    "cosmiconfig": "^9.0.1",
-    "esbuild": "^0.27.4",
-    "eslint": "^10.1.0",
-    "lru-cache": "^11.2.7",
-    "rollup": "^4.60.1",
+    "esbuild": "^0.28.0",
+    "lru-cache": "~11.2.7",
     "typescript": "~5.9.3",
     "vite": "^8.0.3",
     "vitest": "~4.1.2",
-    "zod": "^4.3.6"
+    "zod": "^4.3.6",
+    "@xyo-network/diviner-payload-model": "~5.3.25",
+    "@xyo-network/diviner-model": "~5.3.25",
+    "@xyo-network/module-model": "~5.3.25"
   },
   "peerDependencies": {
     "@xylabs/sdk-js": "^5",
@@ -72,4 +68,4 @@
   "publishConfig": {
     "access": "public"
   }
-}
+}

package/src/AbstractModuleResolver.ts

@@ -1,89 +0,0 @@
-import type {
-  Address, BaseParams, Promisable,
-} from '@xylabs/sdk-js'
-import {
-  assertEx, Base, toSafeJsonString,
-} from '@xylabs/sdk-js'
-import type {
-  ModuleFilterOptions,
-  ModuleIdentifier,
-  ModuleInstance,
-  ModuleResolverInstance,
-  ObjectFilterOptions,
-} from '@xyo-network/module-model'
-import {
-  asModuleInstance,
-  ObjectResolverPriority,
-} from '@xyo-network/module-model'
-
-export interface ModuleResolverParams extends BaseParams {
-  priority?: ObjectResolverPriority
-  root: ModuleInstance
-}
-
-export abstract class AbstractModuleResolver<TParams extends ModuleResolverParams = ModuleResolverParams>
-  extends Base<TParams>
-  implements ModuleResolverInstance {
-  get priority() {
-    return this.params.priority ?? ObjectResolverPriority.Normal
-  }
-
-  set priority(value: ObjectResolverPriority) {
-    this.params.priority = value
-  }
-
-  get root() {
-    return assertEx(this.params.root, () => 'root is not set')
-  }
-
-  async resolve<T extends ModuleInstance = ModuleInstance>(): Promise<T[]>
-  async resolve<T extends ModuleInstance = ModuleInstance>(all: '*', options?: ModuleFilterOptions<T>): Promise<T[]>
-  async resolve<T extends ModuleInstance = ModuleInstance>(id: ModuleIdentifier, options?: ModuleFilterOptions<T>): Promise<T | undefined>
-  async resolve<T extends ModuleInstance = ModuleInstance>(
-    id: ModuleIdentifier = '*',
-    options?: ModuleFilterOptions<T>,
-  ): Promise<T[] | T | undefined> {
-    if (id === '*') {
-      const values = await this.resolveHandler(id, options)
-      assertEx(Array.isArray(values), () => 'resolveHandler returned a non-array')
-      return values.map(value =>
-        asModuleInstance<T>(value, () => {
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          return `resolveHandler returned invalid result (*) [${(value as any)?.constructor?.name}][${toSafeJsonString(value)}]`
-        }, { required: true }))
-    }
-    switch (typeof id) {
-      case 'string': {
-        const [value] = await this.resolveHandler(id, options)
-        return asModuleInstance<T>(
-          value,
-          () =>
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            `resolveHandler returned invalid result (string) [${(value as any)?.constructor?.name}][${toSafeJsonString(value)}]`,
-        )
-      }
-      default: {
-        break
-      }
-    }
-  }
-
-  async resolvePrivate<T extends ModuleInstance = ModuleInstance>(all: '*', options?: ObjectFilterOptions<T>): Promise<T[]>
-  async resolvePrivate<T extends ModuleInstance = ModuleInstance>(id: ModuleIdentifier, options?: ObjectFilterOptions<T>): Promise<T | undefined>
-  async resolvePrivate<T extends ModuleInstance = ModuleInstance>(
-    id: ModuleIdentifier,
-    _options?: ObjectFilterOptions<T>,
-  ): Promise<T | T[] | undefined> {
-    if (id === '*') return await Promise.resolve([])
-  }
-
-  abstract addResolver(resolver: ModuleResolverInstance): this
-  abstract removeResolver(resolver: ModuleResolverInstance): this
-
-  abstract resolveHandler<T extends ModuleInstance = ModuleInstance>(
-    id: ModuleIdentifier,
-    options?: ModuleFilterOptions<T>,
-  ): Promisable<T[]>
-
-  abstract resolveIdentifier(id: ModuleIdentifier, options?: ObjectFilterOptions): Promisable<Address | undefined>
-}

package/src/CompositeModuleResolver.ts

@@ -1,259 +0,0 @@
-/* eslint-disable max-statements */
-import type { Address, Promisable } from '@xylabs/sdk-js'
-import {
-  assertEx,
-  exists, isDefined, isString,
-} from '@xylabs/sdk-js'
-import type {
-  CacheConfig,
-  ModuleFilterOptions,
-  ModuleIdentifier,
-  ModuleIdentifierPart,
-  ModuleIdentifierTransformer,
-  ModuleInstance,
-  ModuleRepository,
-  ModuleResolverInstance,
-  ObjectFilterOptions,
-} from '@xyo-network/module-model'
-import {
-  duplicateModules,
-  ObjectResolverPriority,
-  ResolveHelper,
-} from '@xyo-network/module-model'
-import { LRUCache } from 'lru-cache'
-
-import type { ModuleResolverParams } from './AbstractModuleResolver.ts'
-import { AbstractModuleResolver } from './AbstractModuleResolver.ts'
-import { SimpleModuleResolver } from './SimpleModuleResolver.ts'
-
-export interface CompositeModuleResolverParams extends ModuleResolverParams {
-  allowNameResolution?: boolean
-  cache?: CacheConfig
-  moduleIdentifierTransformers?: ModuleIdentifierTransformer[]
-}
-
-const moduleIdentifierParts = (moduleIdentifier: ModuleIdentifier): ModuleIdentifierPart[] => {
-  return moduleIdentifier?.split(':') as ModuleIdentifierPart[]
-}
-
-export class CompositeModuleResolver<T extends CompositeModuleResolverParams = CompositeModuleResolverParams>
-  extends AbstractModuleResolver<T>
-  implements ModuleRepository, ModuleResolverInstance {
-  static readonly defaultMaxDepth = 3
-
-  protected _cache: LRUCache<ModuleIdentifier, ModuleInstance>
-  protected resolvers: ModuleResolverInstance[] = []
-  private _allowAddResolver = true
-  private _localResolver: SimpleModuleResolver
-
-  constructor(params: T) {
-    super(params)
-    const localResolver = new SimpleModuleResolver({ allowNameResolution: params.allowNameResolution, root: params.root })
-    this.addResolver(localResolver)
-    const { max = 100, ttl = 1000 * 5 /* five seconds */ } = params.cache ?? {}
-    this._cache = new LRUCache<ModuleIdentifier, ModuleInstance>({
-      max, ttl, ...params.cache,
-    })
-    this._localResolver = localResolver
-  }
-
-  get allowAddResolver() {
-    return this._allowAddResolver
-  }
-
-  set allowAddResolver(value: boolean) {
-    this.resolvers = [this._localResolver]
-    this._allowAddResolver = value
-  }
-
-  get allowNameResolution() {
-    return this.params.allowNameResolution ?? true
-  }
-
-  private get moduleIdentifierTransformers() {
-    return this.params.moduleIdentifierTransformers ?? ResolveHelper.transformers
-  }
-
-  add(mod: ModuleInstance): this
-  add(mod: ModuleInstance[]): this
-  add(mod: ModuleInstance | ModuleInstance[]): this {
-    if (Array.isArray(mod)) {
-      for (const modItem of mod) this.addSingleModule(modItem)
-    } else {
-      this.addSingleModule(mod)
-    }
-    return this
-  }
-
-  addResolver(resolver: ModuleResolverInstance): this {
-    if (this.allowAddResolver) {
-      this.resolvers.push(resolver)
-    }
-    return this
-  }
-
-  remove(addresses: Address[] | Address): this {
-    if (Array.isArray(addresses)) {
-      for (const address of addresses) this.removeSingleModule(address)
-    } else {
-      this.removeSingleModule(addresses)
-    }
-    return this
-  }
-
-  removeResolver(resolver: ModuleResolverInstance): this {
-    this.resolvers = this.resolvers.filter(item => item !== resolver)
-    return this
-  }
-
-  // eslint-disable-next-line complexity
-  async resolveHandler<T extends ModuleInstance = ModuleInstance>(
-    id: ModuleIdentifier = '*',
-    options: ModuleFilterOptions<T> = {},
-  ): Promise<T[]> {
-    const mutatedOptions = { ...options, maxDepth: options?.maxDepth ?? CompositeModuleResolver.defaultMaxDepth }
-
-    // resolve all
-    if (id === '*') {
-      // wen't too far?
-      if (mutatedOptions.maxDepth < 0) {
-        return []
-      }
-
-      // identity resolve?
-      if (mutatedOptions.maxDepth === 0) {
-        return (await this._localResolver.resolve('*', mutatedOptions)) ?? []
-      }
-
-      const childOptions = { ...mutatedOptions, maxDepth: mutatedOptions?.maxDepth - 1 }
-
-      const result = await Promise.all(
-        this.resolvers.map(async (resolver) => {
-          const result: T[] = await resolver.resolve<T>('*', childOptions)
-          return result
-        }),
-      )
-      const flatResult: T[] = result.flat().filter(exists)
-      return flatResult.filter((v, i, a) => duplicateModules(v, i, a))
-    }
-
-    if (typeof id === 'string') {
-      // wen't too far?
-      if (mutatedOptions.maxDepth < 0) {
-        return []
-      }
-
-      // resolve ModuleIdentifier
-      const idParts = moduleIdentifierParts(id)
-      if (idParts.length > 1) {
-        const mod = await this.resolveMultipartIdentifier<T>(id)
-        return (
-          mod
-            ? Array.isArray(mod)
-              ? mod
-              : [mod]
-            : []
-        )
-      }
-      const resolvedId = await ResolveHelper.transformModuleIdentifier(id, this.moduleIdentifierTransformers)
-      if (isString(resolvedId)) {
-        if (mutatedOptions.maxDepth < 0) {
-          return []
-        }
-        const cachedResult = this._cache.get(resolvedId)
-        if (cachedResult) {
-          if (cachedResult.status === 'error') {
-            this._cache.delete(id)
-          } else {
-            return [cachedResult] as T[]
-          }
-        }
-
-        // identity resolve?
-        if (mutatedOptions.maxDepth === 0) {
-          const mod = await this._localResolver.resolve(resolvedId, mutatedOptions)
-          return (
-            isDefined(mod)
-              ? Array.isArray(mod)
-                ? mod
-                : [mod]
-              : []
-          )
-        }
-
-        // recursive function to resolve by priority
-        const resolvePriority = async (priority: ObjectResolverPriority): Promise<T | undefined> => {
-          const resolvers = this.resolvers.filter(resolver => resolver.priority === priority)
-          const results: T[] = (
-            await Promise.all(
-              resolvers.map(async (resolver) => {
-                const result: T | undefined = await resolver.resolve<T>(resolvedId, mutatedOptions)
-                return result
-              }),
-            )
-          ).filter(exists)
-
-          const result: T | undefined = results.filter(exists).findLast((v, i, a) => duplicateModules(v, i, a))
-          if (result) {
-            this._cache.set(resolvedId, result)
-            return result
-          }
-          // we know that ObjectResolverPriority.VeryLow is the minimum priority, so we can subtract 1 from the rest
-          return priority === ObjectResolverPriority.VeryLow ? undefined : await resolvePriority((priority - 1) as ObjectResolverPriority)
-        }
-        const mod = await resolvePriority(ObjectResolverPriority.VeryHigh)
-        return (
-          mod
-            ? Array.isArray(mod)
-              ? mod
-              : [mod]
-            : []
-        )
-      }
-    }
-    return []
-  }
-
-  async resolveIdentifier(id: ModuleIdentifier, _options?: ObjectFilterOptions): Promise<Address | undefined> {
-    const idParts = id.split(':')
-    if (idParts.length > 1) {
-      return this.resolveComplexIdentifier(id)
-    }
-    const results = (
-      await Promise.all(
-        this.resolvers.map(async (resolver) => {
-          return await resolver.resolveIdentifier(id)
-        }),
-      )
-    ).filter(exists)
-    const result = results.shift()
-    if (results.length > 0) {
-      for (const altResult of results) {
-        assertEx(altResult === result, () => `Inconsistent results for ${id} [${result}][${altResult}]`)
-      }
-    }
-    return result
-  }
-
-  protected resolveComplexIdentifier(_id: ModuleIdentifier, _options?: ObjectFilterOptions): Promisable<Address | undefined> {
-    throw new Error('Method not implemented.')
-  }
-
-  private addSingleModule(mod?: ModuleInstance) {
-    if (mod) {
-      this._localResolver.add(mod)
-    }
-  }
-
-  private removeSingleModule(address: Address) {
-    this._localResolver.remove(address)
-  }
-
-  private async resolveMultipartIdentifier<T extends ModuleInstance = ModuleInstance>(moduleIdentifier: ModuleIdentifier): Promise<T | undefined> {
-    const idParts = moduleIdentifierParts(moduleIdentifier)
-    assertEx(idParts.length >= 2, () => 'Not a valid multipart identifier')
-    const id = assertEx(idParts.shift())
-    const mod = (await this.resolve<T>(id)) ?? (await this.resolvePrivate<T>(id))
-    return (await mod?.resolve<T>(idParts.join(':'))) ?? (await mod?.resolvePrivate<T>(idParts.join(':')))
-  }
-}

package/src/NameRegistrarTransformer.ts

@@ -1,52 +0,0 @@
-import type { Address } from '@xylabs/sdk-js'
-import { isDefined, isUndefined } from '@xylabs/sdk-js'
-import type { DivinerInstance } from '@xyo-network/diviner-model'
-import { PayloadDivinerQuerySchema } from '@xyo-network/diviner-payload-model'
-import type { ModuleIdentifier, ModuleIdentifierTransformer } from '@xyo-network/module-model'
-import { LRUCache } from 'lru-cache'
-
-export class NameRegistrarTransformer implements ModuleIdentifierTransformer {
-  private _cache: LRUCache<ModuleIdentifier, ModuleIdentifier> = new LRUCache<ModuleIdentifier, ModuleIdentifier>({ max: 1000, ttl: 1000 * 5 })
-
-  private registrarDiviner: DivinerInstance
-  private root: string
-
-  constructor(
-    registrarDiviner: DivinerInstance,
-    root: string,
-  ) {
-    this.registrarDiviner = registrarDiviner
-    this.root = root
-  }
-
-  async transform(identifier: ModuleIdentifier): Promise<ModuleIdentifier> {
-    const parts = identifier.split(':')
-    const first = parts.shift()
-    const nameParts = first?.split('.')
-    if (nameParts?.length === 2 && nameParts[1] === this.root) {
-      // check cache
-      const cachedResult = this._cache.get(identifier)
-      if (isDefined(cachedResult)) return cachedResult
-
-      // not cached, so check registrar
-      const query = {
-        domain: nameParts[0], order: 'desc' as const, schema: PayloadDivinerQuerySchema, tld: nameParts[1],
-      }
-      const result = await this.registrarDiviner?.divine([query])
-      const resultPayload = result?.shift()
-      if (isUndefined(resultPayload)) {
-        throw new Error(`Unable to resolve registrar name (failed) [${first}]`)
-      }
-      // TODO: Use proper types for this check
-      if (isDefined(resultPayload)) {
-        const address = (resultPayload as unknown as { address: Address[] }).address?.shift()
-        if (address) {
-          this._cache.set(identifier, address)
-          return address
-        }
-      }
-      throw new Error(`Unable to resolve registrar name (not found) [${first}]`)
-    }
-    return identifier
-  }
-}

package/src/ResolverEventEmitter.ts

@@ -1,51 +0,0 @@
-import type {
-  ModuleIdentifier, ModuleResolver,
-  QueryableModule,
-} from '@xyo-network/module-model'
-
-export interface ModuleResolvedEventArgs {
-  id?: ModuleIdentifier
-  mod: QueryableModule
-}
-
-export interface ResolverEventEmitter {
-  on(event: 'moduleResolved', listener: (args: ModuleResolvedEventArgs) => void): void
-}
-
-type ListenerFunction = (args: ModuleResolvedEventArgs) => void
-
-const getMixin = <T extends ModuleResolver = ModuleResolver>(resolver: T) => {
-  const listeners: ListenerFunction[] = []
-  const emit = (event: 'moduleResolved', args: ModuleResolvedEventArgs): boolean => {
-    if (listeners.length === 0) return false
-    for (const listener of listeners) listener(args)
-    return true
-  }
-  const onModuleResolved = (mod: QueryableModule, id?: ModuleIdentifier) => {
-    const args = { id, mod }
-    emit('moduleResolved', args)
-  }
-
-  const { resolve } = resolver
-  function originalResolve(filter?: ModuleIdentifier) {
-    return resolve.bind(resolver)(filter)
-  }
-
-  return {
-    on: (event: 'moduleResolved', listener: (args: ModuleResolvedEventArgs) => void) => {
-      listeners.push(listener)
-    },
-    resolve: async (id?: ModuleIdentifier): Promise<QueryableModule[]> => {
-      const modulesResult = await originalResolve(id) ?? []
-      const modules = Array.isArray(modulesResult) ? modulesResult : [modulesResult]
-
-      await Promise.allSettled(modules.map(mod => onModuleResolved(mod, id)))
-      return modules
-    },
-  }
-}
-
-export const mixinResolverEventEmitter = <T extends ModuleResolver = ModuleResolver>(resolver: T): T & ResolverEventEmitter => {
-  const mixin = getMixin(resolver)
-  return Object.assign(resolver, mixin)
-}

package/src/SimpleModuleResolver.ts

@@ -1,173 +0,0 @@
-import type { Address, Promisable } from '@xylabs/sdk-js'
-import {
-  assertEx, exists, isAddress,
-} from '@xylabs/sdk-js'
-import type {
-  ModuleFilterOptions,
-  ModuleIdentifier,
-  ModuleInstance,
-  ModuleName,
-  ModuleRepository,
-  ModuleResolverInstance,
-  ObjectFilterOptions,
-} from '@xyo-network/module-model'
-import { isModuleName } from '@xyo-network/module-model'
-
-import type { ModuleResolverParams } from './AbstractModuleResolver.ts'
-import { AbstractModuleResolver } from './AbstractModuleResolver.ts'
-
-export type SimpleModuleResolverParams = ModuleResolverParams & {
-  allowNameResolution?: boolean
-}
-
-export class SimpleModuleResolver extends AbstractModuleResolver<SimpleModuleResolverParams> implements ModuleRepository {
-  private modules: Record<Address, ModuleInstance> = {}
-  private nameToModule: Record<ModuleName, ModuleInstance> = {}
-
-  constructor(params: SimpleModuleResolverParams) {
-    super(params)
-  }
-
-  get allowNameResolution() {
-    return this.params.allowNameResolution ?? true
-  }
-
-  add(mods: ModuleInstance): this
-  add(mods: ModuleInstance[]): this
-  add(mods: ModuleInstance | ModuleInstance[]): this {
-    if (Array.isArray(mods)) {
-      for (const mod of mods) this.addSingleModule(mod)
-    } else {
-      this.addSingleModule(mods)
-    }
-    return this
-  }
-
-  addResolver(_resolver: ModuleResolverInstance): this {
-    throw 'Adding resolvers not supported'
-  }
-
-  remove(address: Address | Address[]): this {
-    if (Array.isArray(address)) {
-      for (const addr of address) this.removeSingleModule(addr)
-    } else {
-      this.removeSingleModule(address)
-    }
-    return this
-  }
-
-  removeResolver(_resolver: ModuleResolverInstance): this {
-    throw 'Removing resolvers not supported'
-  }
-
-  resolveHandler<T extends ModuleInstance = ModuleInstance>(
-    id: ModuleIdentifier = '*',
-    options?: ModuleFilterOptions<T>,
-  ): Promisable<T[]> {
-    const unfiltered = (() => {
-      if (id) {
-        if (typeof id === 'string') {
-          if (id === '*') {
-            return Object.values(this.modules) as T[]
-          }
-          const name = isModuleName(id) ? id : undefined
-          const address = isAddress(id) ? id : undefined
-          assertEx(name || address, () => 'module identifier must be a ModuleName or Address')
-          return (
-            (name ? this.resolveByName<T>(Object.values(this.modules), [name]).pop() : undefined)
-            ?? (address ? this.resolveByAddress<T>(this.modules, [address]).pop() : undefined)
-          )
-        }
-      } else {
-        return Object.values(this.modules) as T[]
-      }
-    })()
-    const identity = options?.identity
-    if (identity) {
-      return (
-        Array.isArray(unfiltered)
-          ? unfiltered?.filter(mod => identity(mod))
-          : identity(unfiltered)
-            ? [unfiltered]
-            : []
-      )
-    } else {
-      return (
-        unfiltered
-          ? Array.isArray(unfiltered)
-            ? unfiltered
-            : [unfiltered]
-          : []
-      )
-    }
-  }
-
-  resolveIdentifier(id: ModuleIdentifier, _options?: ObjectFilterOptions): Promisable<Address | undefined> {
-    // check if id is a name of one of modules in the resolver
-    const moduleFromName = this.nameToModule[id]
-    if (moduleFromName) {
-      return moduleFromName.address
-    }
-
-    // check if any of the modules have the id as an address
-    for (const mod of Object.values(this.modules)) {
-      if (mod.address === id) {
-        return mod.address
-      }
-    }
-  }
-
-  private addSingleModule(mod?: ModuleInstance) {
-    if (mod) {
-      const modName = mod.modName
-      if (modName && this.allowNameResolution) {
-        // check for collision
-        assertEx(this.nameToModule[modName] === undefined, () => `Module with name ${modName} already added`)
-        this.nameToModule[modName] = mod
-      }
-      this.modules[mod.address] = mod
-    }
-  }
-
-  private removeSingleModule(address: Address) {
-    assertEx(isAddress(address), () => 'Invalid address')
-    const mod = assertEx(this.modules[address], () => 'Address not found in modules')
-    delete this.modules[address]
-    const modName = mod.modName
-    if (modName) {
-      delete this.nameToModule[modName]
-    }
-  }
-
-  private resolveByAddress<T extends ModuleInstance = ModuleInstance>(modules: Record<Address, ModuleInstance>, address: Address[]): T[] {
-    return (
-      address.map((address) => {
-        return modules[address]
-      })
-    ).filter(exists) as T[]
-  }
-
-  private resolveByName<T extends ModuleInstance = ModuleInstance>(modules: ModuleInstance[], name: ModuleName[]): T[] {
-    return (
-      name.map((name) => {
-        return modules.find(mod => mod.modName === name)
-      })
-    ).filter(exists) as T[]
-  }
-
-  private resolveByQuery<T extends ModuleInstance = ModuleInstance>(modules: ModuleInstance[], query: string[][]): T[] {
-    return (
-      modules.filter(mod =>
-        // eslint-disable-next-line unicorn/no-array-reduce
-        query?.reduce((supported, queryList) => {
-          return (
-            // eslint-disable-next-line unicorn/no-array-reduce
-            queryList.reduce((supported, query) => {
-              const queryable = mod.queries.includes(query)
-              return supported && queryable
-            }, true) || supported
-          )
-        }, false))
-    ).filter(exists) as T[]
-  }
-}

package/src/index.ts

@@ -1,5 +0,0 @@
-export * from './AbstractModuleResolver.ts'
-export * from './CompositeModuleResolver.ts'
-export * from './NameRegistrarTransformer.ts'
-export * from './ResolverEventEmitter.ts'
-export * from './SimpleModuleResolver.ts'