@xyo-network/module-model 2.94.40 → 2.95.0

package/dist/node/index.cjs

@@ -32,6 +32,7 @@ __export(src_exports, {
   IsAttachableModuleInstanceFactory: () => IsAttachableModuleInstanceFactory,
   IsInstanceFactory: () => IsInstanceFactory,
   IsModuleFactory: () => IsModuleFactory,
+  MODULE_PATH_SEPARATOR: () => MODULE_PATH_SEPARATOR,
   ModuleAddressQuerySchema: () => ModuleAddressQuerySchema,
   ModuleConfigSchema: () => ModuleConfigSchema,
   ModuleDescriptionSchema: () => ModuleDescriptionSchema,
@@ -75,6 +76,14 @@ __export(src_exports, {
   requiredModuleInstanceFunctions: () => requiredModuleInstanceFunctions,
   requiredModuleQueries: () => requiredModuleQueries,
   requiredModuleShape: () => requiredModuleShape,
+  resolveAddressToInstance: () => resolveAddressToInstance,
+  resolveAddressToInstanceDown: () => resolveAddressToInstanceDown,
+  resolveAddressToInstanceSiblings: () => resolveAddressToInstanceSiblings,
+  resolveAddressToInstanceUp: () => resolveAddressToInstanceUp,
+  resolveLocalNameToAddress: () => resolveLocalNameToAddress,
+  resolveLocalNameToAddressDown: () => resolveLocalNameToAddressDown,
+  resolveLocalNameToAddressUp: () => resolveLocalNameToAddressUp,
+  resolvePathToAddress: () => resolvePathToAddress,
   serializable: () => serializable,
   serializableField: () => serializableField,
   toCreatableModuleRegistry: () => toCreatableModuleRegistry,
@@ -457,6 +466,7 @@ var serializableField = /* @__PURE__ */ __name((field) => {
 
 // src/ModuleIdentifier.ts
 var import_hex = require("@xylabs/hex");
+var MODULE_PATH_SEPARATOR = ":";
 var DisallowedModuleIdentifierCharacters = {
   " ": true,
   "!": true,
@@ -518,12 +528,95 @@ var isModuleStateWithMeta = /* @__PURE__ */ __name((payload) => {
   return (0, import_payload_model.isPayloadOfSchemaType)(ModuleStateSchema)(payload);
 }, "isModuleStateWithMeta");
 
-// src/ResolveHelper.ts
-var import_assert3 = require("@xylabs/assert");
+// src/ResolveHelper/resolveAddressToInstance.ts
+var resolveAddressToInstanceDown = /* @__PURE__ */ __name(async (root, address, includePrivate = false, ignore = []) => {
+  var _a, _b, _c;
+  if (root.address === address) {
+    return root;
+  }
+  const cache = (_a = root.addressCache) == null ? void 0 : _a.call(root, "up", includePrivate);
+  const privateChildren = (includePrivate ? await ((_b = root.privateChildren) == null ? void 0 : _b.call(root)) : []) ?? [];
+  const publicChildren = await ((_c = root.publicChildren) == null ? void 0 : _c.call(root)) ?? [];
+  const children = [
+    ...privateChildren,
+    ...publicChildren
+  ];
+  for (const child of children) {
+    const found = await resolveAddressToInstanceDown(child, address, includePrivate, ignore);
+    if (found) {
+      cache == null ? void 0 : cache.set(address, new WeakRef(found));
+      return found;
+    }
+  }
+  cache == null ? void 0 : cache.set(address, null);
+}, "resolveAddressToInstanceDown");
+var resolveAddressToInstanceSiblings = /* @__PURE__ */ __name(async (root, address, includePrivate = false, ignore = []) => {
+  var _a;
+  const siblings = await ((_a = root.siblings) == null ? void 0 : _a.call(root)) ?? [];
+  for (const sibling of siblings) {
+    const found = await resolveAddressToInstanceDown(sibling, address, includePrivate, ignore);
+    if (found) {
+      return found;
+    }
+  }
+}, "resolveAddressToInstanceSiblings");
+var resolveAddressToInstanceUp = /* @__PURE__ */ __name(async (root, address, includePrivate = false, ignore = []) => {
+  var _a, _b;
+  const cache = (_a = root.addressCache) == null ? void 0 : _a.call(root, "up", includePrivate);
+  const parents = await ((_b = root.parents) == null ? void 0 : _b.call(root)) ?? [];
+  for (const parent of parents) {
+    const found = await resolveAddressToInstance(parent, address, includePrivate, ignore);
+    if (found) {
+      cache == null ? void 0 : cache.set(address, new WeakRef(found));
+      return found;
+    }
+  }
+  cache == null ? void 0 : cache.set(address, null);
+}, "resolveAddressToInstanceUp");
+var resolveAddressToInstance = /* @__PURE__ */ __name(async (root, address, includePrivate = false, ignore = []) => {
+  var _a;
+  const cache = (_a = root.addressCache) == null ? void 0 : _a.call(root, "all", includePrivate);
+  const result = await resolveAddressToInstanceDown(root, address, includePrivate, ignore) ?? await resolveAddressToInstanceUp(root, address, includePrivate, ignore);
+  cache == null ? void 0 : cache.set(address, result ? new WeakRef(result) : null);
+  return result;
+}, "resolveAddressToInstance");
+
+// src/ResolveHelper/ResolveHelper.ts
+var import_assert4 = require("@xylabs/assert");
 var import_exists = require("@xylabs/exists");
 var import_hex2 = require("@xylabs/hex");
 var import_logger = require("@xylabs/logger");
 var import_object10 = require("@xylabs/object");
+
+// src/ResolveHelper/traceModuleIdentifier.ts
+var import_assert3 = require("@xylabs/assert");
+var traceModuleIdentifier = /* @__PURE__ */ __name(async (resolver, path) => {
+  const parts = path.split(":");
+  const first = parts.shift();
+  const firstModule = asModuleInstance((0, import_assert3.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 [];
+}, "traceModuleIdentifier");
+
+// src/ResolveHelper/transformModuleIdentifier.ts
+var transformModuleIdentifier = /* @__PURE__ */ __name(async (id, transformers) => {
+  let result = id;
+  for (const transformer of transformers) {
+    result = await transformer.transform(id);
+  }
+  return result;
+}, "transformModuleIdentifier");
+
+// src/ResolveHelper/ResolveHelper.ts
 var _ResolveHelper = class _ResolveHelper {
   static async resolve(config, idOrFilter = "*", { maxDepth = 3, required = "log", ...options } = {}) {
     const { transformers, module: module2, logger = this.defaultLogger, dead = false, upResolver, downResolver, privateResolver } = config;
@@ -576,24 +669,26 @@ var _ResolveHelper = class _ResolveHelper {
             return void 0;
           }
           const id = await this.transformModuleIdentifier(idOrFilter, transformers);
-          const resolvers = [
-            [
-              downResolver,
-              downLocalOptions
-            ],
-            [
-              up ? upResolver : void 0,
-              upLocalOptions
-            ],
-            [
-              up ? privateResolver : void 0,
-              upLocalOptions
-            ]
-          ].filter(([resolver]) => (0, import_exists.exists)(resolver));
-          for (const resolver of resolvers) {
-            const [resolverInstance] = resolver;
-            if (!result) {
-              result = await this.resolveModuleIdentifier(resolverInstance, id);
+          if (id) {
+            const resolvers = [
+              [
+                downResolver,
+                downLocalOptions
+              ],
+              [
+                up ? upResolver : void 0,
+                upLocalOptions
+              ],
+              [
+                up ? privateResolver : void 0,
+                upLocalOptions
+              ]
+            ].filter(([resolver]) => (0, import_exists.exists)(resolver));
+            for (const resolver of resolvers) {
+              const [resolverInstance] = resolver;
+              if (!result) {
+                result = await this.resolveModuleIdentifier(resolverInstance, id);
+              }
             }
           }
           break;
@@ -624,35 +719,18 @@ var _ResolveHelper = class _ResolveHelper {
     }) ?? (first ? await resolver.resolvePrivate(first, {
       maxDepth: firstIsAddress ? 10 : 1
     }) : void 0);
-    const finalModule = required ? (0, import_assert3.assertEx)(resolvedModule, () => `Failed to resolve [${first}] [${firstIsAddress}]`) : resolvedModule;
+    const finalModule = required ? (0, import_assert4.assertEx)(resolvedModule, () => `Failed to resolve [${first}] [${firstIsAddress}]`) : resolvedModule;
     const firstModule = asModuleInstance(finalModule, () => `Resolved invalid module instance [${first}]`);
     if (firstModule) {
       return parts.length > 0 ? await this.resolveModuleIdentifier(firstModule, parts.join(":")) : firstModule;
     }
   }
   //translates a complex module path to addresses
-  static async traceModuleIdentifier(resolver, path) {
-    const parts = path.split(":");
-    const first = parts.shift();
-    const firstModule = asModuleInstance((0, import_assert3.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 this.traceModuleIdentifier(firstModule, parts.join(":"))
-      ] : [
-        firstModule.address
-      ];
-    }
-    return [];
+  static traceModuleIdentifier(resolver, path) {
+    return traceModuleIdentifier(resolver, path);
   }
-  static async transformModuleIdentifier(identifier, transformers = _ResolveHelper.transformers) {
-    let id = identifier;
-    for (const transformer of transformers) {
-      id = await transformer.transform(id);
-    }
-    return id;
+  static transformModuleIdentifier(identifier, transformers = _ResolveHelper.transformers) {
+    return transformModuleIdentifier(identifier, transformers);
   }
   static validateRequiredResolve(required, result, idOrFilter, logger = this.defaultLogger) {
     const log = logger ? new import_logger.IdLogger(logger, () => `validateRequiredResolve [${idOrFilter}][${result}]`) : void 0;
@@ -678,6 +756,45 @@ __publicField(_ResolveHelper, "defaultLogger");
 __publicField(_ResolveHelper, "transformers", []);
 var ResolveHelper = _ResolveHelper;
 
+// src/ResolveHelper/resolveLocalNameToAddress.ts
+var resolveLocalNameToAddressUp = /* @__PURE__ */ __name(async (root, localName) => {
+  var _a, _b;
+  const parents = await ((_a = root.parents) == null ? void 0 : _a.call(root)) ?? [];
+  return (_b = parents.find((parent) => parent.localName === localName)) == null ? void 0 : _b.address;
+}, "resolveLocalNameToAddressUp");
+var resolveLocalNameToAddressDown = /* @__PURE__ */ __name(async (root, localName, includePrivate = false) => {
+  var _a, _b, _c;
+  const privateChildren = (includePrivate ? await ((_a = root.privateChildren) == null ? void 0 : _a.call(root)) : []) ?? [];
+  const publicChildren = await ((_b = root.publicChildren) == null ? void 0 : _b.call(root)) ?? [];
+  const children = [
+    ...privateChildren,
+    ...publicChildren
+  ];
+  return (_c = children.find((child) => child.localName === localName)) == null ? void 0 : _c.address;
+}, "resolveLocalNameToAddressDown");
+var resolveLocalNameToAddress = /* @__PURE__ */ __name(async (root, localName, includePrivate = false) => {
+  return await resolveLocalNameToAddressDown(root, localName, includePrivate) ?? await resolveLocalNameToAddressUp(root, localName);
+}, "resolveLocalNameToAddress");
+
+// src/ResolveHelper/resolvePathToAddress.ts
+var import_assert5 = require("@xylabs/assert");
+var import_hex3 = require("@xylabs/hex");
+var resolvePathToAddress = /* @__PURE__ */ __name(async (root, path, includePrivate = false, transformers = []) => {
+  const parts = path.split(MODULE_PATH_SEPARATOR);
+  const first = await transformModuleIdentifier((0, import_assert5.assertEx)(parts.shift(), () => `First part is invalid [${path}]`), transformers);
+  if (!first) {
+    return void 0;
+  }
+  const firstAddress = (0, import_hex3.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;
+  }
+}, "resolvePathToAddress");
+
 // src/withModule.ts
 var WithFactory = {
   create: (typeCheck) => {
@@ -696,6 +813,7 @@ var withModuleInstance = WithFactory.create(isModuleInstance);
   IsAttachableModuleInstanceFactory,
   IsInstanceFactory,
   IsModuleFactory,
+  MODULE_PATH_SEPARATOR,
   ModuleAddressQuerySchema,
   ModuleConfigSchema,
   ModuleDescriptionSchema,
@@ -739,6 +857,14 @@ var withModuleInstance = WithFactory.create(isModuleInstance);
   requiredModuleInstanceFunctions,
   requiredModuleQueries,
   requiredModuleShape,
+  resolveAddressToInstance,
+  resolveAddressToInstanceDown,
+  resolveAddressToInstanceSiblings,
+  resolveAddressToInstanceUp,
+  resolveLocalNameToAddress,
+  resolveLocalNameToAddressDown,
+  resolveLocalNameToAddressUp,
+  resolvePathToAddress,
   serializable,
   serializableField,
   toCreatableModuleRegistry,