@kehto/services 0.8.0 → 0.10.0

package/dist/index.js

@@ -1366,7 +1366,7 @@ var DEFAULT_THEME = {
     primary: "#7aa2f7"
   }
   // fonts, background, title intentionally undefined — all optional per
-  // @napplet/nub/theme Theme interface.
+  // @napplet/nap/theme Theme interface.
 };
 function createThemeService(options = {}) {
   let currentTheme = options.initialTheme ?? DEFAULT_THEME;
@@ -2396,6 +2396,244 @@ function toErrorMessage3(err) {
   return "upload failed";
 }
 
+// src/intent-service.ts
+var INTENT_SERVICE_VERSION = "1.0.0";
+var INTENT_DESCRIPTOR = {
+  name: "intent",
+  version: INTENT_SERVICE_VERSION,
+  description: "NAP-INTENT archetype intent dispatch \u2014 invoke/available/handlers"
+};
+function toErrorMessage4(err) {
+  if (err instanceof Error) return err.message;
+  if (typeof err === "string") return err;
+  return "intent request failed";
+}
+function createIntentService(options) {
+  if (!options || typeof options.resolver !== "object" || options.resolver === null) {
+    throw new Error("createIntentService: options.resolver is required");
+  }
+  const { resolver } = options;
+  const windows = /* @__PURE__ */ new Map();
+  resolver.onChanged?.((availability) => {
+    for (const send of windows.values()) {
+      send({ type: "intent.changed", availability });
+    }
+  });
+  function settle(call, send, resultType, id, onValue) {
+    let pending;
+    try {
+      pending = Promise.resolve(call());
+    } catch (err) {
+      send({ type: resultType, id, error: toErrorMessage4(err) });
+      return;
+    }
+    pending.then((value) => send(onValue(value))).catch((err) => send({ type: resultType, id, error: toErrorMessage4(err) }));
+  }
+  function handleInvoke(windowId, msg, send) {
+    const m = msg;
+    const id = m.id ?? "";
+    const request = m.request;
+    if (!request || typeof request !== "object" || typeof request.archetype !== "string" || request.archetype.length === 0) {
+      send({ type: "intent.invoke.result", id, error: "invalid request" });
+      return;
+    }
+    settle(
+      () => resolver.invoke(request, { windowId }),
+      send,
+      "intent.invoke.result",
+      id,
+      (result) => ({ type: "intent.invoke.result", id, result })
+    );
+  }
+  function handleAvailable(msg, send) {
+    const m = msg;
+    const id = m.id ?? "";
+    if (typeof m.archetype !== "string" || m.archetype.length === 0) {
+      send({ type: "intent.available.result", id, error: "invalid archetype" });
+      return;
+    }
+    const archetype = m.archetype;
+    settle(
+      () => resolver.available(archetype),
+      send,
+      "intent.available.result",
+      id,
+      (availability) => ({ type: "intent.available.result", id, availability })
+    );
+  }
+  function handleHandlers(msg, send) {
+    const m = msg;
+    const id = m.id ?? "";
+    settle(
+      () => resolver.handlers(),
+      send,
+      "intent.handlers.result",
+      id,
+      (handlers) => ({ type: "intent.handlers.result", id, handlers })
+    );
+  }
+  return {
+    descriptor: INTENT_DESCRIPTOR,
+    handleMessage(windowId, message, send) {
+      windows.set(windowId, send);
+      switch (message.type) {
+        case "intent.invoke":
+          handleInvoke(windowId, message, send);
+          return;
+        case "intent.available":
+          handleAvailable(message, send);
+          return;
+        case "intent.handlers":
+          handleHandlers(message, send);
+          return;
+        default:
+          return;
+      }
+    },
+    onWindowDestroyed(windowId) {
+      windows.delete(windowId);
+    }
+  };
+}
+
+// src/catalog-intent-resolver.ts
+function candidatesFor(catalog, archetype, defaultHandler) {
+  const candidates = [];
+  for (const entry of catalog) {
+    const support = entry.archetypes[archetype];
+    if (!support) continue;
+    candidates.push({
+      dTag: entry.dTag,
+      ...entry.title === void 0 ? {} : { title: entry.title },
+      actions: support.actions,
+      protocols: support.protocols,
+      ...entry.dTag === defaultHandler ? { isDefault: true } : {}
+    });
+  }
+  return candidates;
+}
+function fail(archetype, action, error) {
+  return { ok: false, archetype, action, handled: false, error };
+}
+function createCatalogIntentResolver(options) {
+  if (!options || typeof options.loadCatalog !== "function") {
+    throw new Error("createCatalogIntentResolver: options.loadCatalog is required");
+  }
+  if (!options.windows || typeof options.windows.open !== "function") {
+    throw new Error("createCatalogIntentResolver: options.windows is required");
+  }
+  const { loadCatalog, windows, getDefaultHandler, chooseHandler, defaultProtocol } = options;
+  const listeners = /* @__PURE__ */ new Set();
+  async function availabilityFor(archetype) {
+    const catalog = await loadCatalog();
+    const def = getDefaultHandler?.(archetype);
+    const candidates = candidatesFor(catalog, archetype, def);
+    return {
+      archetype,
+      available: candidates.length > 0,
+      candidates,
+      hasDefault: def !== void 0 && candidates.some((c) => c.dTag === def)
+    };
+  }
+  async function pickHandler(archetype, candidates, preference, callerWindowId) {
+    if (typeof preference === "string" && preference !== "default" && preference !== "choose") {
+      return preference;
+    }
+    if (preference === "choose") {
+      const picked = await chooseHandler?.(archetype, candidates, callerWindowId);
+      return picked ?? null;
+    }
+    const def = getDefaultHandler?.(archetype);
+    if (def !== void 0 && candidates.some((c) => c.dTag === def)) return def;
+    if (candidates.length === 1) return candidates[0].dTag;
+    if (chooseHandler) {
+      const picked = await chooseHandler(archetype, candidates, callerWindowId);
+      return picked ?? null;
+    }
+    return candidates[0].dTag;
+  }
+  async function invoke(request, context) {
+    const archetype = request.archetype;
+    const action = request.action ?? "open";
+    const catalog = await loadCatalog();
+    const candidates = candidatesFor(catalog, archetype, getDefaultHandler?.(archetype));
+    if (candidates.length === 0) return fail(archetype, action, "no handler");
+    const pickedDTag = await pickHandler(archetype, candidates, request.handler, context.windowId);
+    if (pickedDTag === null) return fail(archetype, action, "user cancelled");
+    const handler = candidates.find((c) => c.dTag === pickedDTag);
+    if (!handler) return fail(archetype, action, "no handler");
+    if (!handler.actions.includes(action)) return fail(archetype, action, "unsupported action");
+    const protocol = request.protocol ?? defaultProtocol?.(archetype) ?? handler.protocols[0];
+    if (protocol !== void 0 && handler.protocols.length > 0 && !handler.protocols.includes(protocol)) {
+      return fail(archetype, action, "unsupported protocol");
+    }
+    let windowId;
+    try {
+      const opened = await windows.open({
+        dTag: handler.dTag,
+        archetype,
+        action,
+        ...protocol === void 0 ? {} : { protocol },
+        ...request.payload === void 0 ? {} : { payload: request.payload },
+        ...request.behavior === void 0 ? {} : { behavior: request.behavior },
+        callerWindowId: context.windowId
+      });
+      windowId = opened.windowId;
+    } catch {
+      return fail(archetype, action, "invoke failed");
+    }
+    return {
+      ok: true,
+      archetype,
+      action,
+      handled: true,
+      handler: handler.dTag,
+      windowId,
+      ...protocol === void 0 ? {} : { protocol }
+    };
+  }
+  async function handlers() {
+    const catalog = await loadCatalog();
+    const archetypes = /* @__PURE__ */ new Set();
+    for (const entry of catalog) {
+      for (const slug of Object.keys(entry.archetypes)) archetypes.add(slug);
+    }
+    return Promise.all([...archetypes].map((a) => availabilityFor(a)));
+  }
+  return {
+    invoke,
+    available: availabilityFor,
+    handlers,
+    onChanged(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    notifyChanged(archetype) {
+      if (listeners.size === 0) return;
+      void availabilityFor(archetype).then((availability) => {
+        for (const listener of listeners) listener(availability);
+      });
+    }
+  };
+}
+
+// src/manifest-intent-catalog.ts
+var DEFAULT_ACTIONS = ["open"];
+function manifestToIntentCatalogEntry(manifest) {
+  const archetypes = {};
+  for (const { slug, nap } of manifest.archetypes) {
+    archetypes[slug] = {
+      actions: [...DEFAULT_ACTIONS],
+      protocols: nap ? [nap] : []
+    };
+  }
+  return {
+    dTag: manifest.dTag,
+    ...manifest.title === void 0 ? {} : { title: manifest.title },
+    archetypes
+  };
+}
+
 // src/cvm-service.ts
 var CVM_SERVICE_VERSION = "1.0.0";
 var CVM_DESCRIPTOR = {
@@ -2438,7 +2676,7 @@ function createCvmService(options) {
     const m = msg;
     const id = m.id ?? "";
     void transport.discover(m.query).then((servers) => send({ type: "cvm.discover.result", id, servers })).catch(
-      (err) => send({ type: "cvm.discover.result", id, servers: [], error: toErrorMessage4(err) })
+      (err) => send({ type: "cvm.discover.result", id, servers: [], error: toErrorMessage5(err) })
     );
   }
   function handleRequest(windowId, msg, send) {
@@ -2454,7 +2692,7 @@ function createCvmService(options) {
     }
     openSession(windowId, m.server, send);
     void transport.request(m.server, m.message, m.options).then((message) => send({ type: "cvm.request.result", id, message })).catch(
-      (err) => send({ type: "cvm.request.result", id, error: toErrorMessage4(err) })
+      (err) => send({ type: "cvm.request.result", id, error: toErrorMessage5(err) })
     );
   }
   function handleClose(windowId, msg, send) {
@@ -2465,7 +2703,7 @@ function createCvmService(options) {
       return;
     }
     closeSession(windowId, m.server.pubkey);
-    void transport.close(m.server).then(() => send({ type: "cvm.close.result", id })).catch((err) => send({ type: "cvm.close.result", id, error: toErrorMessage4(err) }));
+    void transport.close(m.server).then(() => send({ type: "cvm.close.result", id })).catch((err) => send({ type: "cvm.close.result", id, error: toErrorMessage5(err) }));
   }
   return {
     descriptor: CVM_DESCRIPTOR,
@@ -2496,7 +2734,7 @@ function createCvmService(options) {
     }
   };
 }
-function toErrorMessage4(err) {
+function toErrorMessage5(err) {
   if (err instanceof Error) return err.message;
   if (typeof err === "string") return err;
   return "cvm request failed";
@@ -2505,11 +2743,13 @@ export {
   createAudioService,
   createBrowserMediaBridge,
   createCacheService,
+  createCatalogIntentResolver,
   createConfigService,
   createCoordinatedRelay,
   createCvmService,
   createHttpUploader,
   createIdentityService,
+  createIntentService,
   createKeysService,
   createMediaService,
   createNotificationService,
@@ -2519,6 +2759,7 @@ export {
   createRelayPoolService,
   createResourceService,
   createThemeService,
-  createUploadService
+  createUploadService,
+  manifestToIntentCatalogEntry
 };
 //# sourceMappingURL=index.js.map