@kehto/services 0.2.0

package/dist/index.js

@@ -0,0 +1,885 @@
+// src/audio-service.ts
+var AUDIO_SERVICE_VERSION = "1.0.0";
+function createAudioService(options) {
+  const sources = /* @__PURE__ */ new Map();
+  const onChange = options?.onChange;
+  function notify() {
+    onChange?.(new Map(sources));
+  }
+  const descriptor = {
+    name: "audio",
+    version: AUDIO_SERVICE_VERSION,
+    description: "Audio source registry \u2014 tracks active audio sources per napplet window"
+  };
+  return {
+    descriptor,
+    handleMessage(windowId, message, send) {
+      if (message.type !== "ifc.emit") return;
+      const topic = message.topic;
+      if (!topic?.startsWith("audio:")) return;
+      const action = topic.slice(6);
+      const payload = message.payload ?? {};
+      switch (action) {
+        case "register": {
+          const nappletClass = typeof payload.nappletClass === "string" ? payload.nappletClass : "";
+          const title = typeof payload.title === "string" ? payload.title : "";
+          sources.set(windowId, { windowId, nappletClass, title, muted: false });
+          notify();
+          break;
+        }
+        case "unregister": {
+          if (sources.delete(windowId)) {
+            notify();
+          }
+          break;
+        }
+        case "state-changed": {
+          const source = sources.get(windowId);
+          if (!source) return;
+          if (typeof payload.title === "string") {
+            source.title = payload.title;
+          }
+          notify();
+          break;
+        }
+        case "mute": {
+          const targetWindowId = typeof payload.windowId === "string" ? payload.windowId : windowId;
+          const muted = payload.muted === true;
+          const source = sources.get(targetWindowId);
+          if (source) {
+            source.muted = muted;
+            notify();
+          }
+          send({ type: "ifc.event", topic: "napplet:audio-muted", payload: { muted } });
+          break;
+        }
+        default:
+          break;
+      }
+    },
+    onWindowDestroyed(windowId) {
+      if (sources.delete(windowId)) {
+        notify();
+      }
+    }
+  };
+}
+
+// src/notification-service.ts
+var NOTIFICATION_SERVICE_VERSION = "1.0.0";
+var DEFAULT_MAX_PER_WINDOW = 100;
+var idCounter = 0;
+function generateId() {
+  idCounter++;
+  return `notif-${Date.now()}-${idCounter}`;
+}
+function createNotificationService(options) {
+  const notifications = /* @__PURE__ */ new Map();
+  const onChange = options?.onChange;
+  const maxPerWindow = options?.maxPerWindow ?? DEFAULT_MAX_PER_WINDOW;
+  function getAllNotifications() {
+    const all = [];
+    for (const windowNotifs of notifications.values()) {
+      all.push(...windowNotifs);
+    }
+    return all;
+  }
+  function notify() {
+    onChange?.(getAllNotifications());
+  }
+  function getWindowNotifications(windowId) {
+    let list = notifications.get(windowId);
+    if (!list) {
+      list = [];
+      notifications.set(windowId, list);
+    }
+    return list;
+  }
+  function enforceLimit(list) {
+    while (list.length > maxPerWindow) {
+      list.shift();
+    }
+  }
+  function findById(id) {
+    for (const [windowId, list] of notifications) {
+      const index = list.findIndex((n) => n.id === id);
+      if (index !== -1) {
+        return [windowId, list[index], index];
+      }
+    }
+    return void 0;
+  }
+  const descriptor = {
+    name: "notifications",
+    version: NOTIFICATION_SERVICE_VERSION,
+    description: "Notification state registry \u2014 tracks notifications per napplet window"
+  };
+  return {
+    descriptor,
+    handleMessage(windowId, message, send) {
+      const msg = message;
+      if (message.type.startsWith("notify.")) {
+        const action2 = message.type.slice(7);
+        switch (action2) {
+          case "create": {
+            const title = typeof msg.title === "string" ? msg.title : "";
+            const body = typeof msg.body === "string" ? msg.body : "";
+            const id = generateId();
+            const notification = {
+              id,
+              windowId,
+              title,
+              body,
+              read: false,
+              createdAt: Math.floor(Date.now() / 1e3)
+            };
+            const list = getWindowNotifications(windowId);
+            list.push(notification);
+            enforceLimit(list);
+            notify();
+            send({ type: "notify.created", id });
+            break;
+          }
+          case "dismiss": {
+            const notifId = typeof msg.notificationId === "string" ? msg.notificationId : "";
+            if (!notifId) return;
+            const found = findById(notifId);
+            if (found) {
+              const [foundWindowId, , index] = found;
+              const list = notifications.get(foundWindowId);
+              if (list) {
+                list.splice(index, 1);
+                if (list.length === 0) notifications.delete(foundWindowId);
+                notify();
+              }
+            }
+            break;
+          }
+          case "read": {
+            const notifId = typeof msg.notificationId === "string" ? msg.notificationId : "";
+            if (!notifId) return;
+            const found = findById(notifId);
+            if (found) {
+              const [, notification] = found;
+              if (!notification.read) {
+                notification.read = true;
+                notify();
+              }
+            }
+            break;
+          }
+          case "list": {
+            const windowNotifs = notifications.get(windowId) ?? [];
+            send({ type: "notify.listed", notifications: windowNotifs });
+            break;
+          }
+          default:
+            break;
+        }
+        return;
+      }
+      if (message.type !== "ifc.emit") return;
+      const topic = msg.topic;
+      if (!topic?.startsWith("notifications:")) return;
+      const action = topic.slice(14);
+      const payload = msg.payload ?? {};
+      switch (action) {
+        case "create": {
+          const title = typeof payload.title === "string" ? payload.title : "";
+          const body = typeof payload.body === "string" ? payload.body : "";
+          const id = generateId();
+          const notification = {
+            id,
+            windowId,
+            title,
+            body,
+            read: false,
+            createdAt: Math.floor(Date.now() / 1e3)
+          };
+          const list = getWindowNotifications(windowId);
+          list.push(notification);
+          enforceLimit(list);
+          notify();
+          send({ type: "ifc.event", topic: "notifications:created", payload: { id } });
+          break;
+        }
+        case "dismiss": {
+          const id = typeof payload.id === "string" ? payload.id : "";
+          if (!id) return;
+          const found = findById(id);
+          if (found) {
+            const [foundWindowId, , index] = found;
+            const list = notifications.get(foundWindowId);
+            if (list) {
+              list.splice(index, 1);
+              if (list.length === 0) {
+                notifications.delete(foundWindowId);
+              }
+              notify();
+            }
+          }
+          break;
+        }
+        case "read": {
+          const id = typeof payload.id === "string" ? payload.id : "";
+          if (!id) return;
+          const found = findById(id);
+          if (found) {
+            const [, notification] = found;
+            if (!notification.read) {
+              notification.read = true;
+              notify();
+            }
+          }
+          break;
+        }
+        case "list": {
+          const windowNotifs = notifications.get(windowId) ?? [];
+          send({ type: "ifc.event", topic: "notifications:listed", payload: { notifications: windowNotifs } });
+          break;
+        }
+        default:
+          break;
+      }
+    },
+    onWindowDestroyed(windowId) {
+      if (notifications.delete(windowId)) {
+        notify();
+      }
+    }
+  };
+}
+
+// src/identity-service.ts
+var IDENTITY_SERVICE_VERSION = "1.0.0";
+function createIdentityService(options) {
+  return {
+    descriptor: {
+      name: "identity",
+      version: IDENTITY_SERVICE_VERSION,
+      description: "NIP-5D identity NUB 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 });
+      }
+      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) => {
+            sendError(
+              "identity.getPublicKey",
+              err?.message ?? "getPublicKey failed"
+            );
+          });
+          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) => {
+            sendError(
+              "identity.getRelays",
+              err?.message ?? "getRelays failed"
+            );
+          });
+          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}`);
+      }
+    },
+    // Identity service has no per-window state to clean up.
+    onWindowDestroyed(_windowId) {
+    }
+  };
+}
+
+// src/relay-pool-service.ts
+var EOSE_FALLBACK_MS = 15e3;
+function createRelayPoolService(options) {
+  const tracked = /* @__PURE__ */ new Map();
+  return {
+    descriptor: {
+      name: "relay-pool",
+      version: "1.0.0",
+      description: "Relay pool subscription and publishing"
+    },
+    handleMessage(windowId, message, send) {
+      if (message.type === "relay.subscribe") {
+        const subId = message.subId;
+        if (typeof subId !== "string") return;
+        const filters = message.filters;
+        const subKey = `${windowId}:${subId}`;
+        const existing = tracked.get(subKey);
+        if (existing) {
+          existing.handle.unsubscribe();
+          clearTimeout(existing.eoseTimer);
+          tracked.delete(subKey);
+        }
+        if (!options.isAvailable()) {
+          send({ type: "relay.eose", subId });
+          return;
+        }
+        const relayUrls = options.selectRelayTier(filters);
+        let eoseSent = false;
+        const eoseTimer = setTimeout(() => {
+          if (!eoseSent) {
+            eoseSent = true;
+            send({ type: "relay.eose", subId });
+          }
+        }, EOSE_FALLBACK_MS);
+        const handle = options.subscribe(filters, (item) => {
+          if (item === "EOSE") {
+            clearTimeout(eoseTimer);
+            if (!eoseSent) {
+              eoseSent = true;
+              send({ type: "relay.eose", subId });
+            }
+            return;
+          }
+          send({ type: "relay.event", subId, event: item });
+        }, relayUrls);
+        tracked.set(subKey, { handle, eoseTimer });
+        return;
+      }
+      if (message.type === "relay.close") {
+        const subId = message.subId;
+        if (typeof subId !== "string") return;
+        const subKey = `${windowId}:${subId}`;
+        const entry = tracked.get(subKey);
+        if (entry) {
+          entry.handle.unsubscribe();
+          clearTimeout(entry.eoseTimer);
+          tracked.delete(subKey);
+        }
+        return;
+      }
+      if (message.type === "relay.publish") {
+        const event = message.event;
+        if (event && typeof event === "object" && options.isAvailable()) {
+          options.publish(event);
+        }
+        return;
+      }
+      if (message.type === "relay.publishEncrypted") {
+        const event = message.event;
+        if (event && typeof event === "object" && options.isAvailable()) {
+          options.publish(event);
+        }
+        return;
+      }
+    },
+    onWindowDestroyed(windowId) {
+      const prefix = `${windowId}:`;
+      for (const [key, entry] of tracked) {
+        if (key.startsWith(prefix)) {
+          entry.handle.unsubscribe();
+          clearTimeout(entry.eoseTimer);
+          tracked.delete(key);
+        }
+      }
+    }
+  };
+}
+
+// src/cache-service.ts
+function createCacheService(options) {
+  return {
+    descriptor: {
+      name: "cache",
+      version: "1.0.0",
+      description: "Local event cache (IndexedDB, worker relay, etc.)"
+    },
+    handleMessage(_windowId, message, send) {
+      if (message.type === "relay.subscribe") {
+        const subId = message.subId;
+        if (typeof subId !== "string") return;
+        const filters = message.filters;
+        if (!options.isAvailable()) {
+          send({ type: "relay.eose", subId });
+          return;
+        }
+        options.query(filters).then((events) => {
+          for (const event of events) {
+            send({ type: "relay.event", subId, event });
+          }
+          send({ type: "relay.eose", subId });
+        }).catch(() => {
+          send({ type: "relay.eose", subId });
+        });
+        return;
+      }
+      if (message.type === "relay.publish") {
+        const event = message.event;
+        if (event && typeof event === "object" && options.isAvailable()) {
+          try {
+            options.store(event);
+          } catch {
+          }
+        }
+        return;
+      }
+    },
+    // Cache has no per-window state to clean up
+    onWindowDestroyed(_windowId) {
+    }
+  };
+}
+
+// src/coordinated-relay.ts
+var DEFAULT_EOSE_TIMEOUT_MS = 15e3;
+function createCoordinatedRelay(options) {
+  const timeoutMs = options.eoseTimeoutMs ?? DEFAULT_EOSE_TIMEOUT_MS;
+  const subs = /* @__PURE__ */ new Map();
+  function maybeSendEose(subKey, subId, send) {
+    const sub = subs.get(subKey);
+    if (!sub || sub.eoseSent) return;
+    if (sub.cacheEose && sub.relayEose) {
+      sub.eoseSent = true;
+      clearTimeout(sub.eoseTimer);
+      send({ type: "relay.eose", subId });
+    }
+  }
+  return {
+    descriptor: {
+      name: "relay",
+      version: "1.0.0",
+      description: "Coordinated relay pool + cache with dedup and unified EOSE"
+    },
+    handleMessage(windowId, message, send) {
+      if (message.type === "relay.subscribe") {
+        let deliver2 = function(event) {
+          if (tracked.seenIds.has(event.id)) return;
+          tracked.seenIds.add(event.id);
+          if (subs.has(subKey)) send({ type: "relay.event", subId, event });
+        };
+        var deliver = deliver2;
+        const subId = message.subId;
+        if (typeof subId !== "string") return;
+        const filters = message.filters;
+        const subKey = `${windowId}:${subId}`;
+        const existing = subs.get(subKey);
+        if (existing) {
+          existing.relayHandle?.unsubscribe();
+          clearTimeout(existing.eoseTimer);
+          subs.delete(subKey);
+        }
+        const cacheAvailable = options.cache.isAvailable();
+        const relayAvailable = options.relayPool.isAvailable();
+        if (!cacheAvailable && !relayAvailable) {
+          send({ type: "relay.eose", subId });
+          return;
+        }
+        const tracked = {
+          seenIds: /* @__PURE__ */ new Set(),
+          cacheEose: !cacheAvailable,
+          // mark done if cache not available
+          relayEose: !relayAvailable,
+          // mark done if relay not available
+          eoseSent: false,
+          eoseTimer: null,
+          relayHandle: null
+        };
+        subs.set(subKey, tracked);
+        if (cacheAvailable) {
+          options.cache.query(filters).then((events) => {
+            for (const event of events) deliver2(event);
+            tracked.cacheEose = true;
+            maybeSendEose(subKey, subId, send);
+          }).catch(() => {
+            tracked.cacheEose = true;
+            maybeSendEose(subKey, subId, send);
+          });
+        }
+        if (relayAvailable) {
+          tracked.eoseTimer = setTimeout(() => {
+            if (!tracked.eoseSent) {
+              tracked.relayEose = true;
+              maybeSendEose(subKey, subId, send);
+            }
+          }, timeoutMs);
+          const relayUrls = options.relayPool.selectRelayTier(filters);
+          tracked.relayHandle = options.relayPool.subscribe(filters, (item) => {
+            if (item === "EOSE") {
+              clearTimeout(tracked.eoseTimer);
+              tracked.relayEose = true;
+              maybeSendEose(subKey, subId, send);
+              return;
+            }
+            deliver2(item);
+            if (cacheAvailable) {
+              try {
+                options.cache.store(item);
+              } catch {
+              }
+            }
+          }, relayUrls);
+        }
+        return;
+      }
+      if (message.type === "relay.close") {
+        const subId = message.subId;
+        if (typeof subId !== "string") return;
+        const subKey = `${windowId}:${subId}`;
+        const entry = subs.get(subKey);
+        if (entry) {
+          entry.relayHandle?.unsubscribe();
+          clearTimeout(entry.eoseTimer);
+          subs.delete(subKey);
+        }
+        return;
+      }
+      if (message.type === "relay.publish") {
+        const event = message.event;
+        if (!event || typeof event !== "object") return;
+        if (options.relayPool.isAvailable()) {
+          options.relayPool.publish(event);
+        }
+        if (options.cache.isAvailable()) {
+          try {
+            options.cache.store(event);
+          } catch {
+          }
+        }
+        return;
+      }
+    },
+    onWindowDestroyed(windowId) {
+      const prefix = `${windowId}:`;
+      for (const [key, entry] of subs) {
+        if (key.startsWith(prefix)) {
+          entry.relayHandle?.unsubscribe();
+          clearTimeout(entry.eoseTimer);
+          subs.delete(key);
+        }
+      }
+    }
+  };
+}
+
+// src/keys-service.ts
+var KEYS_SERVICE_VERSION = "1.0.0";
+function createKeysService(options = {}) {
+  const descriptor = {
+    name: "keys",
+    version: KEYS_SERVICE_VERSION,
+    description: "NIP-5D keys NUB reference handler (stub)"
+  };
+  return {
+    descriptor,
+    handleMessage(_windowId, message, send) {
+      switch (message.type) {
+        case "keys.forward": {
+          const m = message;
+          options.onForward?.({
+            key: m.key,
+            code: m.code,
+            ctrlKey: m.ctrl,
+            altKey: m.alt,
+            shiftKey: m.shift,
+            metaKey: m.meta
+          });
+          return;
+        }
+        case "keys.registerAction": {
+          const m = message;
+          const result = {
+            type: "keys.registerAction.result",
+            id: m.id,
+            actionId: m.action.id,
+            ...m.action.defaultKey ? { binding: m.action.defaultKey } : {}
+          };
+          send(result);
+          return;
+        }
+        case "keys.unregisterAction": {
+          return;
+        }
+        default: {
+          const id = message.id ?? "";
+          send({
+            type: `${message.type}.error`,
+            id,
+            error: `Unknown keys method: ${message.type}`
+          });
+          return;
+        }
+      }
+    },
+    onWindowDestroyed(_windowId) {
+    }
+  };
+}
+
+// src/media-service.ts
+var MEDIA_SERVICE_VERSION = "1.0.0";
+function createMediaService(options = {}) {
+  const descriptor = {
+    name: "media",
+    version: MEDIA_SERVICE_VERSION,
+    description: "NIP-5D media NUB reference handler (stub)"
+  };
+  return {
+    descriptor,
+    handleMessage(windowId, message, send) {
+      switch (message.type) {
+        case "media.session.create": {
+          const m = message;
+          options.onSessionCreate?.(windowId, m.sessionId, m.metadata);
+          const result = {
+            type: "media.session.create.result",
+            id: m.id,
+            sessionId: m.sessionId
+          };
+          send(result);
+          return;
+        }
+        case "media.session.update": {
+          const m = message;
+          options.onSessionUpdate?.(windowId, m.sessionId ?? "", m.metadata);
+          return;
+        }
+        case "media.session.destroy": {
+          const m = message;
+          options.onSessionDestroy?.(windowId, m.sessionId ?? "");
+          return;
+        }
+        case "media.state": {
+          const m = message;
+          options.onState?.(windowId, m.sessionId ?? "", m);
+          return;
+        }
+        case "media.capabilities": {
+          const m = message;
+          options.onCapabilities?.(windowId, m.sessionId ?? "", m.actions);
+          return;
+        }
+        default: {
+          const id = message.id ?? "";
+          send({
+            type: `${message.type}.error`,
+            id,
+            error: `Unknown media method: ${message.type}`
+          });
+          return;
+        }
+      }
+    },
+    onWindowDestroyed(_windowId) {
+    }
+  };
+}
+
+// src/notify-service.ts
+var NOTIFY_SERVICE_VERSION = "1.0.0";
+function createNotifyService(options = {}) {
+  let counter = 0;
+  const gen = options.generateId ?? (() => {
+    counter += 1;
+    return `shell-${counter}`;
+  });
+  const defaultGrant = options.defaultGrant ?? true;
+  const descriptor = {
+    name: "notify",
+    version: NOTIFY_SERVICE_VERSION,
+    description: "NIP-5D notify NUB reference handler (stub)"
+  };
+  return {
+    descriptor,
+    handleMessage(windowId, message, send) {
+      switch (message.type) {
+        case "notify.send": {
+          const m = message;
+          options.onSend?.(windowId, m);
+          const result = {
+            type: "notify.send.result",
+            id: m.id,
+            notificationId: gen()
+          };
+          send(result);
+          return;
+        }
+        case "notify.dismiss":
+        case "notify.badge":
+        case "notify.channel.register":
+          return;
+        case "notify.permission.request": {
+          const m = message;
+          const result = {
+            type: "notify.permission.result",
+            id: m.id,
+            granted: defaultGrant
+          };
+          send(result);
+          return;
+        }
+        default: {
+          const id = message.id ?? "";
+          send({
+            type: `${message.type}.error`,
+            id,
+            error: `Unknown notify method: ${message.type}`
+          });
+        }
+      }
+    },
+    onWindowDestroyed(_windowId) {
+    }
+  };
+}
+
+// src/theme-service.ts
+var THEME_SERVICE_VERSION = "1.0.0";
+var DEFAULT_THEME = {
+  colors: {
+    background: "#0a0a0a",
+    text: "#e0e0e0",
+    primary: "#7aa2f7"
+  }
+  // fonts, background, title intentionally undefined — all optional per
+  // @napplet/nub-theme Theme interface.
+};
+function createThemeService(options = {}) {
+  let currentTheme = options.initialTheme ?? DEFAULT_THEME;
+  const descriptor = {
+    name: "theme",
+    version: THEME_SERVICE_VERSION,
+    description: "NIP-5D theme NUB reference handler"
+  };
+  const handler = {
+    descriptor,
+    handleMessage(_windowId, message, send) {
+      const id = message.id ?? "";
+      if (message.type === "theme.get") {
+        const result = {
+          type: "theme.get.result",
+          id,
+          theme: currentTheme
+        };
+        send(result);
+        return;
+      }
+      send({
+        type: `${message.type}.error`,
+        id,
+        error: `Unknown theme method: ${message.type}`
+      });
+    },
+    // Theme service has no per-window state to clean up.
+    onWindowDestroyed(_windowId) {
+    }
+  };
+  function publishTheme(theme) {
+    currentTheme = theme;
+    const envelope = { type: "theme.changed", theme };
+    options.onBroadcast?.(envelope);
+    return envelope;
+  }
+  function getCurrentTheme() {
+    return currentTheme;
+  }
+  return { handler, publishTheme, getCurrentTheme };
+}
+export {
+  createAudioService,
+  createCacheService,
+  createCoordinatedRelay,
+  createIdentityService,
+  createKeysService,
+  createMediaService,
+  createNotificationService,
+  createNotifyService,
+  createRelayPoolService,
+  createThemeService
+};
+//# sourceMappingURL=index.js.map