@xyo-network/sdk 7.4.1 → 8.0.0

package/dist/neutral/module-resolver.mjs

@@ -65,8 +65,8 @@ var resolveAddressToInstanceDown = async (root, address, includePrivate, ignore
   if (root.address === address) {
     return root;
   }
-  const cache = root.addressCache?.("up", !!includePrivate);
-  const privateChildren = (includePrivate ? await root.privateChildren?.() : []) ?? [];
+  const cache = root.addressCache?.("up", includePrivate ?? false);
+  const privateChildren = (includePrivate === true ? await root.privateChildren?.() : []) ?? [];
   const publicChildren = await root.publicChildren?.() ?? [];
   const children = [...privateChildren, ...publicChildren];
   for (const child of children) {
@@ -100,7 +100,7 @@ var resolveAddressToInstanceUp = async (root, address, includePrivate, ignore =
   cache?.set(address, null);
 };
 var resolveAddressToInstanceAll = async (root, address, includePrivate, ignore = []) => {
-  const cache = root.addressCache?.("all", !!includePrivate);
+  const cache = root.addressCache?.("all", includePrivate ?? false);
   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;
@@ -125,26 +125,29 @@ var resolveAllUp = async (root, maxDepth = 10, exclude = []) => {
   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);
+  const allParents = await root.parents();
+  const parents = allParents.filter((mod) => !exclude.includes(mod.address));
+  if (maxDepth <= 1) {
+    return [...parents, root];
+  }
+  const upResults = await Promise.all(parents.map(async (mod) => await resolveAllUp(mod, maxDepth - 1, [...exclude, root.address])));
+  const downResults = await Promise.all(parents.map(async (mod) => await resolveAllDown(mod, maxDepth - 1, [...exclude, root.address], true)));
+  return [...upResults.flat(), ...downResults.flat(), ...parents, root];
 };
 var resolveAllDown = async (root, maxDepth = 10, exclude = [], includePrivate = false) => {
   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);
+  const publicModules = await root.publicChildren();
+  const children = publicModules.filter((mod) => !exclude.includes(mod.address));
+  if (maxDepth <= 1) {
+    return [...children, root];
+  }
+  const privateModules = includePrivate ? await root.privateChildren() : [];
+  const privateChildren = privateModules.filter((mod) => !exclude.includes(mod.address));
+  const childResults = await Promise.all(children.map((child) => resolveAllDown(child, maxDepth - 1, [...exclude, root.address])));
+  const privateChildResults = await Promise.all(privateChildren.map((child) => resolveAllDown(child, maxDepth - 1, [...exclude, root.address])));
+  return [...children, ...childResults.flat(), ...privateChildResults.flat(), root];
 };
 var resolveAll = async (root, maxDepth = 10, exclude = []) => {
   if (maxDepth === 0) {
@@ -181,7 +184,7 @@ var resolveLocalNameToInstanceUp = async (root, modName) => {
   return parents.find((parent) => parent.config.name === modName);
 };
 var resolveLocalNameToInstanceDown = async (root, modName, includePrivate) => {
-  const privateChildren = (includePrivate ? await root.privateChildren?.() : []) ?? [];
+  const privateChildren = (includePrivate === true ? await root.privateChildren?.() : []) ?? [];
   const publicChildren = await root.publicChildren?.() ?? [];
   const children = [...privateChildren, ...publicChildren];
   return children.find((child) => child.config.name === modName);
@@ -205,16 +208,20 @@ var resolveLocalNameToInstance = async (root, modName, includePrivate = false, d
 
 // src/modules/module-resolver/ResolveHelper/resolveLocalNameToAddress.ts
 var resolveLocalNameToAddressUp = async (root, modName) => {
-  return (await resolveLocalNameToInstanceUp(root, modName))?.address;
+  const instance = await resolveLocalNameToInstanceUp(root, modName);
+  return instance?.address;
 };
 var resolveLocalNameToAddressDown = async (root, modName, includePrivate) => {
-  return (await resolveLocalNameToInstanceDown(root, modName, includePrivate))?.address;
+  const instance = await resolveLocalNameToInstanceDown(root, modName, includePrivate);
+  return instance?.address;
 };
 var resolveLocalNameToAddressAll = async (root, modName, includePrivate) => {
-  return (await resolveLocalNameToInstanceAll(root, modName, includePrivate))?.address;
+  const instance = await resolveLocalNameToInstanceAll(root, modName, includePrivate);
+  return instance?.address;
 };
 var resolveLocalNameToAddress = async (root, modName, includePrivate, direction = "all") => {
-  return (await resolveLocalNameToInstance(root, modName, includePrivate, direction))?.address;
+  const instance = await resolveLocalNameToInstance(root, modName, includePrivate, direction);
+  return instance?.address;
 };
 
 // src/modules/module-resolver/ResolveHelper/transformModuleIdentifier.ts
@@ -233,7 +240,7 @@ var resolvePathToInstance = async (root, path, includePrivate, transformers = Re
     assertEx2(parts.shift(), () => `First part is invalid [${path}]`),
     transformers
   );
-  if (!first) {
+  if (first === void 0 || first === "") {
     return void 0;
   }
   const firstAddress = asAddress(first) ?? await resolveLocalNameToAddress(root, first, includePrivate);
@@ -248,7 +255,8 @@ var resolvePathToInstance = async (root, path, includePrivate, transformers = Re
 
 // src/modules/module-resolver/ResolveHelper/resolvePathToAddress.ts
 var resolvePathToAddress = async (root, path, includePrivate, transformers = ResolveHelperStatic.transformers) => {
-  return (await resolvePathToInstance(root, path, includePrivate, transformers))?.address;
+  const instance = await resolvePathToInstance(root, path, includePrivate, transformers);
+  return instance?.address;
 };
 
 // src/modules/module-resolver/ResolveHelper/traceModuleIdentifier.ts
@@ -268,7 +276,7 @@ var traceModuleIdentifier = async (resolver, path) => {
 };
 
 // src/modules/module-resolver/ResolveHelper/ResolveHelper.ts
-var ResolveHelper = class _ResolveHelper extends ResolveHelperStatic {
+var ResolveHelper = class extends ResolveHelperStatic {
   static async resolve(config, id = "*", {
     maxDepth = 3,
     required = "log",
@@ -299,7 +307,6 @@ var ResolveHelper = class _ResolveHelper extends ResolveHelperStatic {
     const direction = options?.direction ?? "all";
     const up = direction === "up" || direction === "all";
     const down = direction === "down" || direction === "all";
-    let result;
     log?.debug("start", id, maxDepth);
     if (id === "*") {
       if (dead) {
@@ -316,29 +323,30 @@ var ResolveHelper = class _ResolveHelper extends ResolveHelperStatic {
       if (maxDepth === 0) {
         return modules;
       }
-      const childModules = (await Promise.all(modules.map(async (mod2) => await mod2.resolve("*", childOptions)))).flat().filter(duplicateModules2);
+      const resolvedChildren = await Promise.all(modules.map(async (mod2) => await mod2.resolve("*", childOptions)));
+      const childModules = resolvedChildren.flat().filter(duplicateModules2);
       return [...modules, ...childModules, mod].filter(duplicateModules2);
-    } else {
-      switch (typeof id) {
-        case "string": {
-          if (dead) {
-            return void 0;
-          }
-          const resolvedId = assertEx4(await resolvePathToAddress(mod, id, false, transformers) ?? id, () => "Invalid resolvedId");
-          const resolvers = [
-            [downResolver, downLocalOptions],
-            [up ? upResolver : void 0, upLocalOptions],
-            [up ? privateResolver : void 0, upLocalOptions]
-          ].filter(([resolver]) => exists(resolver));
-          for (const resolver of resolvers) {
-            const [resolverInstance] = resolver;
-            result ??= await this.resolveModuleIdentifier(resolverInstance, resolvedId);
-          }
-          break;
+    }
+    let result;
+    switch (typeof id) {
+      case "string": {
+        if (dead) {
+          return void 0;
         }
-        default: {
-          break;
+        const resolvedId = assertEx4(await resolvePathToAddress(mod, id, false, transformers) ?? id, () => "Invalid resolvedId");
+        const resolvers = [
+          [downResolver, downLocalOptions],
+          [up ? upResolver : void 0, upLocalOptions],
+          [up ? privateResolver : void 0, upLocalOptions]
+        ].filter(([resolver]) => exists(resolver));
+        for (const resolver of resolvers) {
+          const [resolverInstance] = resolver;
+          result ??= await this.resolveModuleIdentifier(resolverInstance, resolvedId);
         }
+        break;
+      }
+      default: {
+        break;
       }
     }
     this.validateRequiredResolve(required, result, id, logger);
@@ -350,7 +358,7 @@ var ResolveHelper = class _ResolveHelper extends ResolveHelperStatic {
     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 }) : void 0);
-    const finalModule = required ? assertEx4(resolvedModule, () => `Failed to resolve [${first}] [${firstIsAddress}]`) : resolvedModule;
+    const finalModule = required === true ? assertEx4(resolvedModule, () => `Failed to resolve [${first}] [${firstIsAddress}]`) : resolvedModule;
     const firstModule = asModuleInstance3(finalModule, () => `Resolved invalid module instance [${first}]`);
     return isDefined(firstModule) ? parts.length > 0 ? await this.resolveModuleIdentifier(firstModule, parts.join(":")) : firstModule : void 0;
   }
@@ -358,7 +366,7 @@ var ResolveHelper = class _ResolveHelper extends ResolveHelperStatic {
   static traceModuleIdentifier(resolver, path) {
     return traceModuleIdentifier(resolver, path);
   }
-  static transformModuleIdentifier(identifier, transformers = _ResolveHelper.transformers) {
+  static transformModuleIdentifier(identifier, transformers = this.transformers) {
     return transformModuleIdentifier(identifier, transformers);
   }
   static validateRequiredResolve(required, result, id, logger = this.defaultLogger) {
@@ -421,30 +429,28 @@ var SimpleModuleResolver = class extends AbstractModuleResolver {
   }
   resolveHandler(id = "*", options) {
     const unfiltered = (() => {
-      if (id) {
-        if (typeof id === "string") {
-          if (id === "*") {
-            return Object.values(this.modules);
-          }
-          const name = isModuleName(id) ? id : void 0;
-          const address = isAddress2(id) ? id : void 0;
-          assertEx5(name ?? address, () => "module identifier must be a ModuleName or Address");
-          return (name ? this.resolveByName(Object.values(this.modules), [name]).pop() : void 0) ?? (address ? this.resolveByAddress(this.modules, [address]).pop() : void 0);
-        }
-      } else {
+      if (id === "") {
         return Object.values(this.modules);
       }
+      if (typeof id === "string") {
+        if (id === "*") {
+          return Object.values(this.modules);
+        }
+        const name = isModuleName(id) ? id : void 0;
+        const address = isAddress2(id) ? id : void 0;
+        assertEx5(name ?? address, () => "module identifier must be a ModuleName or Address");
+        return (name !== void 0 && name !== "" ? this.resolveByName(Object.values(this.modules), [name]).pop() : void 0) ?? (address ? this.resolveByAddress(this.modules, [address]).pop() : void 0);
+      }
     })();
     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] : [];
     }
+    return unfiltered ? Array.isArray(unfiltered) ? unfiltered : [unfiltered] : [];
   }
   resolveIdentifier(id, _options) {
     const moduleFromName = this.nameToModule[id];
-    if (moduleFromName) {
+    if (moduleFromName !== void 0) {
       return moduleFromName.address;
     }
     for (const mod of Object.values(this.modules)) {
@@ -454,21 +460,22 @@ var SimpleModuleResolver = class extends AbstractModuleResolver {
     }
   }
   addSingleModule(mod) {
-    if (mod) {
-      const modName = mod.modName;
-      if (modName && this.allowNameResolution) {
-        assertEx5(this.nameToModule[modName] === void 0, () => `Module with name ${modName} already added`);
-        this.nameToModule[modName] = mod;
-      }
-      this.modules[mod.address] = mod;
+    if (!mod) {
+      return;
     }
+    const modName = mod.modName;
+    if (modName !== void 0 && modName !== "" && this.allowNameResolution) {
+      assertEx5(this.nameToModule[modName] === void 0, () => `Module with name ${modName} already added`);
+      this.nameToModule[modName] = mod;
+    }
+    this.modules[mod.address] = mod;
   }
   removeSingleModule(address) {
     assertEx5(isAddress2(address), () => "Invalid address");
     const mod = assertEx5(this.modules[address], () => "Address not found in modules");
     delete this.modules[address];
     const modName = mod.modName;
-    if (modName) {
+    if (modName !== void 0 && modName !== "") {
       delete this.nameToModule[modName];
     }
   }
@@ -483,12 +490,10 @@ var SimpleModuleResolver = class extends AbstractModuleResolver {
     }).filter(exists2);
   }
   resolveByQuery(modules, query) {
-    return modules.filter((mod) => query?.reduce((supported, queryList) => {
-      return queryList.reduce((supported2, query2) => {
-        const queryable = mod.queries.includes(query2);
-        return supported2 && queryable;
-      }, true) || supported;
-    }, false)).filter(exists2);
+    return modules.filter((mod) => {
+      const queryLists = query ?? [];
+      return queryLists.some((queryList) => queryList.every((querySchema) => mod.queries.includes(querySchema)));
+    }).filter(exists2);
   }
 };
 
@@ -605,12 +610,13 @@ var CompositeModuleResolver = class _CompositeModuleResolver extends AbstractMod
         }
         const resolvePriority = async (priority) => {
           const resolvers = this.resolvers.filter((resolver) => resolver.priority === priority);
-          const results = (await Promise.all(
+          const resolved = await Promise.all(
             resolvers.map(async (resolver) => {
               const result2 = await resolver.resolve(resolvedId, mutatedOptions);
               return result2;
             })
-          )).filter(exists3);
+          );
+          const results = resolved.filter(exists3);
           const result = results.filter(exists3).findLast((v, i, a) => duplicateModules3(v, i, a));
           if (result) {
             this._cache.set(resolvedId, result);
@@ -629,11 +635,12 @@ var CompositeModuleResolver = class _CompositeModuleResolver extends AbstractMod
     if (idParts.length > 1) {
       return this.resolveComplexIdentifier(id);
     }
-    const results = (await Promise.all(
+    const resolved = await Promise.all(
       this.resolvers.map(async (resolver) => {
         return await resolver.resolveIdentifier(id);
       })
-    )).filter(exists3);
+    );
+    const results = resolved.filter(exists3);
     const result = results.shift();
     if (results.length > 0) {
       for (const altResult of results) {