@kehto/paja 0.1.0 → 0.2.0

package/dist/browser-host.js

@@ -3432,6 +3432,184 @@ function createNotificationService(options) {
   };
 }
 var IDENTITY_SERVICE_VERSION = "1.0.0";
+function sendProviderError(send, result, fallback, err) {
+  send({
+    ...result,
+    error: err?.message ?? fallback
+  });
+}
+async function getCurrentPubkey(options) {
+  const currentSigner = options.getSigner();
+  if (!currentSigner?.getPublicKey) return "";
+  try {
+    return await currentSigner.getPublicKey() ?? "";
+  } catch {
+    return "";
+  }
+}
+function sendOptionalProviderResult(options, send, fallbackResult, errorFallback, buildResult) {
+  if (!buildResult) {
+    send(fallbackResult);
+    return;
+  }
+  Promise.resolve(getCurrentPubkey(options)).then((pubkey) => buildResult(pubkey)).then((result) => send(result)).catch((err) => sendProviderError(send, fallbackResult, errorFallback, err));
+}
+function sendIdentityError(send, id, typeBase, error) {
+  send({ type: `${typeBase}.error`, id, error });
+}
+function sendSignerError(send, id, typeBase, fallback, err) {
+  sendIdentityError(send, id, typeBase, err?.message ?? fallback);
+}
+function handleGetPublicKey(options, id, send) {
+  const signer = options.getSigner();
+  if (!signer) {
+    const result = {
+      type: "identity.getPublicKey.result",
+      id,
+      pubkey: ""
+    };
+    send(result);
+    return;
+  }
+  Promise.resolve(signer.getPublicKey?.()).then((pubkey) => {
+    const result = {
+      type: "identity.getPublicKey.result",
+      id,
+      pubkey: pubkey ?? ""
+    };
+    send(result);
+  }).catch((err) => sendSignerError(send, id, "identity.getPublicKey", "getPublicKey failed", err));
+}
+function handleGetRelays(options, id, send) {
+  const signer = options.getSigner();
+  if (!signer) {
+    sendIdentityError(send, id, "identity.getRelays", "no signer configured");
+    return;
+  }
+  Promise.resolve(signer.getRelays?.() ?? {}).then((relays) => {
+    const result = {
+      type: "identity.getRelays.result",
+      id,
+      relays
+    };
+    send(result);
+  }).catch((err) => sendSignerError(send, id, "identity.getRelays", "getRelays failed", err));
+}
+function handleReadProvider(options, id, message, send) {
+  switch (message.type) {
+    case "identity.getProfile":
+      sendOptionalProviderResult(
+        options,
+        send,
+        { type: "identity.getProfile.result", id, profile: null },
+        "getProfile failed",
+        options.getProfile ? async (pubkey) => ({
+          type: "identity.getProfile.result",
+          id,
+          profile: await options.getProfile(pubkey, message)
+        }) : void 0
+      );
+      return true;
+    case "identity.getFollows":
+      sendOptionalProviderResult(
+        options,
+        send,
+        { type: "identity.getFollows.result", id, pubkeys: [] },
+        "getFollows failed",
+        options.getFollows ? async (pubkey) => ({
+          type: "identity.getFollows.result",
+          id,
+          pubkeys: await options.getFollows(pubkey, message)
+        }) : void 0
+      );
+      return true;
+    case "identity.getList":
+      handleGetList(options, id, message, send);
+      return true;
+    case "identity.getZaps":
+      sendOptionalProviderResult(
+        options,
+        send,
+        { type: "identity.getZaps.result", id, zaps: [] },
+        "getZaps failed",
+        options.getZaps ? async (pubkey) => ({
+          type: "identity.getZaps.result",
+          id,
+          zaps: await options.getZaps(pubkey, message)
+        }) : void 0
+      );
+      return true;
+    case "identity.getMutes":
+      sendOptionalProviderResult(
+        options,
+        send,
+        { type: "identity.getMutes.result", id, pubkeys: [] },
+        "getMutes failed",
+        options.getMutes ? async (pubkey) => ({
+          type: "identity.getMutes.result",
+          id,
+          pubkeys: await options.getMutes(pubkey, message)
+        }) : void 0
+      );
+      return true;
+    case "identity.getBlocked":
+      sendOptionalProviderResult(
+        options,
+        send,
+        { type: "identity.getBlocked.result", id, pubkeys: [] },
+        "getBlocked failed",
+        options.getBlocked ? async (pubkey) => ({
+          type: "identity.getBlocked.result",
+          id,
+          pubkeys: await options.getBlocked(pubkey, message)
+        }) : void 0
+      );
+      return true;
+    case "identity.getBadges":
+      sendOptionalProviderResult(
+        options,
+        send,
+        { type: "identity.getBadges.result", id, badges: [] },
+        "getBadges failed",
+        options.getBadges ? async (pubkey) => ({
+          type: "identity.getBadges.result",
+          id,
+          badges: await options.getBadges(pubkey, message)
+        }) : void 0
+      );
+      return true;
+    default:
+      return false;
+  }
+}
+function handleGetList(options, id, message, send) {
+  sendOptionalProviderResult(
+    options,
+    send,
+    { type: "identity.getList.result", id, entries: [] },
+    "getList failed",
+    options.getList ? async (pubkey) => ({
+      type: "identity.getList.result",
+      id,
+      entries: await options.getList(message.listType, pubkey, message)
+    }) : void 0
+  );
+}
+function handleIdentityServiceMessage(options, message, send) {
+  const id = message.id ?? "";
+  switch (message.type) {
+    case "identity.getPublicKey":
+      handleGetPublicKey(options, id, send);
+      return;
+    case "identity.getRelays":
+      handleGetRelays(options, id, send);
+      return;
+    default:
+      if (!handleReadProvider(options, id, message, send)) {
+        sendIdentityError(send, id, message.type, `Unknown identity method: ${message.type}`);
+      }
+  }
+}
 function createIdentityService(options) {
   return {
     descriptor: {
@@ -3440,116 +3618,7 @@ function createIdentityService(options) {
       description: "NIP-5D identity NAP reference handler (9 read-only identity queries)"
     },
     handleMessage(_windowId, message, send) {
-      const id = message.id ?? "";
-      function sendError(typeBase, error) {
-        send({ type: `${typeBase}.error`, id, error });
-      }
-      function sendSignerError(typeBase, fallback, err) {
-        sendError(typeBase, err?.message ?? fallback);
-      }
-      const signer = options.getSigner();
-      switch (message.type) {
-        case "identity.getPublicKey": {
-          if (!signer) {
-            const result = {
-              type: "identity.getPublicKey.result",
-              id,
-              pubkey: ""
-            };
-            send(result);
-            return;
-          }
-          Promise.resolve(signer.getPublicKey?.()).then((pubkey) => {
-            const result = {
-              type: "identity.getPublicKey.result",
-              id,
-              pubkey: pubkey ?? ""
-            };
-            send(result);
-          }).catch((err) => sendSignerError("identity.getPublicKey", "getPublicKey failed", err));
-          return;
-        }
-        case "identity.getRelays": {
-          if (!signer) {
-            sendError("identity.getRelays", "no signer configured");
-            return;
-          }
-          Promise.resolve(signer.getRelays?.() ?? {}).then((relays) => {
-            const result = {
-              type: "identity.getRelays.result",
-              id,
-              relays
-            };
-            send(result);
-          }).catch((err) => sendSignerError("identity.getRelays", "getRelays failed", err));
-          return;
-        }
-        case "identity.getProfile": {
-          const result = {
-            type: "identity.getProfile.result",
-            id,
-            profile: null
-          };
-          send(result);
-          return;
-        }
-        case "identity.getFollows": {
-          const result = {
-            type: "identity.getFollows.result",
-            id,
-            pubkeys: []
-          };
-          send(result);
-          return;
-        }
-        case "identity.getList": {
-          const result = {
-            type: "identity.getList.result",
-            id,
-            entries: []
-          };
-          send(result);
-          return;
-        }
-        case "identity.getZaps": {
-          const result = {
-            type: "identity.getZaps.result",
-            id,
-            zaps: []
-          };
-          send(result);
-          return;
-        }
-        case "identity.getMutes": {
-          const result = {
-            type: "identity.getMutes.result",
-            id,
-            pubkeys: []
-          };
-          send(result);
-          return;
-        }
-        case "identity.getBlocked": {
-          const result = {
-            type: "identity.getBlocked.result",
-            id,
-            pubkeys: []
-          };
-          send(result);
-          return;
-        }
-        case "identity.getBadges": {
-          const result = {
-            type: "identity.getBadges.result",
-            id,
-            badges: []
-          };
-          send(result);
-          return;
-        }
-        default:
-          sendError(message.type, `Unknown identity method: ${message.type}`);
-      }
+      handleIdentityServiceMessage(options, message, send);
     },
     // Identity service has no per-window state to clean up.
     onWindowDestroyed(_windowId) {