@kehto/shell 0.16.6 → 0.17.2

package/dist/index.js

@@ -961,36 +961,6 @@ var audioManager = {
   }
 };
 
-// src/keys-forwarder.ts
-function createKeysForwarder(deps) {
-  const target = deps.target ?? (typeof window !== "undefined" ? window : new EventTarget());
-  const listener = (ev) => {
-    const ke = ev;
-    const entries = deps.sessionRegistry.getAllEntries();
-    for (const entry of entries) {
-      if (!deps.hasKeysForwardCap(entry.pubkey)) continue;
-      const iframe = deps.originRegistry.getIframeWindow(entry.windowId);
-      if (!iframe) continue;
-      const envelope = {
-        type: "keys.forward",
-        key: ke.key ?? "",
-        code: ke.code ?? "",
-        ctrl: ke.ctrlKey ?? false,
-        alt: ke.altKey ?? false,
-        shift: ke.shiftKey ?? false,
-        meta: ke.metaKey ?? false
-      };
-      iframe.postMessage(envelope, "*");
-    }
-  };
-  target.addEventListener("keydown", listener);
-  return {
-    destroy() {
-      target.removeEventListener("keydown", listener);
-    }
-  };
-}
-
 // src/shell-init.ts
 var NAP_DOMAINS = [
   "identity",
@@ -1169,23 +1139,6 @@ function createShellBridge(hooks) {
       win.postMessage(envelope, "*");
     }
   }
-  let keysForwarder = null;
-  if (typeof window !== "undefined") {
-    try {
-      keysForwarder = createKeysForwarder({
-        originRegistry,
-        sessionRegistry,
-        hasKeysForwardCap: (pubkey) => {
-          const entry = sessionRegistry.getEntry(pubkey);
-          if (!entry) return false;
-          const acl = aclStore.getEntry(entry.pubkey, entry.dTag, entry.aggregateHash);
-          return acl?.capabilities.includes("keys:forward") ?? false;
-        }
-      });
-    } catch {
-      keysForwarder = null;
-    }
-  }
   return {
     handleMessage(event) {
       const sourceWindow = event.source;
@@ -1217,7 +1170,6 @@ function createShellBridge(hooks) {
       runtime.injectEvent(topic, payload);
     },
     destroy() {
-      keysForwarder?.destroy();
       runtime.destroy();
     },
     registerConsentHandler(handler) {
@@ -1255,14 +1207,14 @@ function scriptJson(value) {
   return JSON.stringify(value).replace(/</g, "\\u003c");
 }
 function renderNappletNamespacePrelude(options) {
-  const domains = uniqueBareDomains(options.domains);
+  const domains = uniqueBareDomains(["shell", ...options.domains]);
   return `<script data-kehto-nip5d-injection>(${nappletNamespacePrelude.toString()})(${scriptJson(domains)});</script>`;
 }
 function injectNappletNamespacePrelude(html, options) {
   const prelude = renderNappletNamespacePrelude(options);
   const cspMeta = /(<meta\s+http-equiv=["']Content-Security-Policy["'][^>]*>)/i;
   if (cspMeta.test(html)) {
-    return html.replace(cspMeta, `$1${prelude}`);
+    return html.replace(cspMeta, (match) => `${match}${prelude}`);
   }
   if (/<head[^>]*>/i.test(html)) {
     return html.replace(/<head[^>]*>/i, (open) => `${open}${prelude}`);
@@ -1349,6 +1301,67 @@ function nappletNamespacePrelude(domains) {
       }
     };
   }
+  function makeShell() {
+    const emptyServices = Object.freeze([]);
+    const readyHandlers = /* @__PURE__ */ new Set();
+    let environment;
+    let resolveReady = () => void 0;
+    const ready = new Promise((resolve) => {
+      resolveReady = resolve;
+    });
+    const off = listen((event) => {
+      if (!isParentMessage(event) || environment) return;
+      const incoming = event.data;
+      if (typeof incoming !== "object" || incoming === null) return;
+      const message = incoming;
+      if (message.type !== "shell.init") return;
+      const services = Object.freeze(
+        Array.isArray(message.services) ? message.services.filter((service) => typeof service === "string") : []
+      );
+      environment = Object.freeze({
+        capabilities: message.capabilities ?? {},
+        services
+      });
+      off();
+      resolveReady(environment);
+      for (const handler of readyHandlers) handler(environment);
+      readyHandlers.clear();
+    });
+    function supports(domain, protocol) {
+      if (!environment || typeof environment.capabilities !== "object" || environment.capabilities === null) {
+        return false;
+      }
+      const capabilities = environment.capabilities;
+      if (protocol !== void 0) {
+        const protocols = capabilities.protocols;
+        if (typeof protocols === "object" && protocols !== null) {
+          const supported = protocols[domain];
+          if (Array.isArray(supported) && supported.includes(protocol)) return true;
+        }
+        return Array.isArray(capabilities.naps) && capabilities.naps.includes(`${domain}:${protocol}`);
+      }
+      return Array.isArray(capabilities.domains) && capabilities.domains.includes(domain) || Array.isArray(capabilities.naps) && capabilities.naps.includes(domain);
+    }
+    const shell2 = {
+      ready: () => ready,
+      supports,
+      get services() {
+        return environment?.services ?? emptyServices;
+      },
+      set services(_services) {
+      },
+      onReady(handler) {
+        if (environment) {
+          handler(environment);
+          return subscriptionHandle(() => void 0);
+        }
+        readyHandlers.add(handler);
+        return subscriptionHandle(() => readyHandlers.delete(handler));
+      }
+    };
+    post({ type: "shell.ready" });
+    return shell2;
+  }
   function domainEventHandle(eventType, callback, select = (message) => message.event) {
     const off = listen((event) => {
       if (!isParentMessage(event)) return;
@@ -1524,30 +1537,177 @@ function nappletNamespacePrelude(domains) {
       }
     };
   }
+  const keyActionCallbacks = /* @__PURE__ */ new Map();
+  const keyBindingActions = /* @__PURE__ */ new Map();
+  const modifierKeys = /* @__PURE__ */ new Set(["Control", "Alt", "Shift", "Meta"]);
+  const reservedKeyNames = /* @__PURE__ */ new Set(["Tab", "Escape"]);
+  const nonTextInputTypes = /* @__PURE__ */ new Set([
+    "button",
+    "checkbox",
+    "color",
+    "file",
+    "hidden",
+    "image",
+    "radio",
+    "range",
+    "reset",
+    "submit"
+  ]);
+  let keysSmartForwardingInstalled = false;
+  function normalizeKeyName(key) {
+    if (typeof key !== "string") return "";
+    return key.length === 1 ? key.toUpperCase() : key;
+  }
+  function keyComboKey(value) {
+    return `${value.ctrl}|${value.alt}|${value.shift}|${value.meta}|${normalizeKeyName(value.key)}`;
+  }
+  function bindingComboKey(binding) {
+    if (typeof binding !== "string" || binding.trim() === "") return null;
+    const parts = binding.split("+");
+    const key = parts.pop()?.trim();
+    if (!key) return null;
+    const combo = { ctrl: false, alt: false, shift: false, meta: false, key };
+    for (const raw of parts) {
+      const token = raw.trim().toLowerCase();
+      if (!token) continue;
+      if (token === "ctrl" || token === "control") combo.ctrl = true;
+      else if (token === "alt" || token === "option") combo.alt = true;
+      else if (token === "shift") combo.shift = true;
+      else if (token === "meta" || token === "cmd" || token === "command" || token === "win" || token === "super") combo.meta = true;
+      else return null;
+    }
+    return keyComboKey(combo);
+  }
+  function eventComboKey(event) {
+    const key = typeof event.key === "string" ? event.key : "";
+    if (!key) return null;
+    return keyComboKey({
+      ctrl: Boolean(event.ctrlKey),
+      alt: Boolean(event.altKey),
+      shift: Boolean(event.shiftKey),
+      meta: Boolean(event.metaKey),
+      key
+    });
+  }
+  function isTextEntryTarget(value) {
+    if (!value || typeof value !== "object") return false;
+    const targetNode = value;
+    if (targetNode.isContentEditable === true) return true;
+    const tagName = typeof targetNode.tagName === "string" ? targetNode.tagName.toLowerCase() : "";
+    if (tagName === "textarea" || tagName === "select") return true;
+    if (tagName === "input") {
+      const type = typeof targetNode.type === "string" && targetNode.type ? targetNode.type.toLowerCase() : "text";
+      return !nonTextInputTypes.has(type);
+    }
+    if (typeof targetNode.closest === "function") {
+      try {
+        return Boolean(targetNode.closest('[contenteditable=""],[contenteditable="true"],[contenteditable="plaintext-only"]'));
+      } catch {
+        return false;
+      }
+    }
+    return false;
+  }
+  function rememberKeyBinding(actionId, binding) {
+    if (typeof actionId !== "string") return;
+    const combo = bindingComboKey(binding);
+    if (combo) keyBindingActions.set(combo, actionId);
+  }
+  function removeKeyBindingsForAction(actionId) {
+    for (const [combo, boundActionId] of keyBindingActions) {
+      if (boundActionId === actionId) keyBindingActions.delete(combo);
+    }
+  }
+  function replaceKeyBindings(bindings) {
+    keyBindingActions.clear();
+    if (!Array.isArray(bindings)) return;
+    for (const binding of bindings) {
+      if (!binding || typeof binding !== "object") continue;
+      const entry = binding;
+      rememberKeyBinding(entry.actionId, entry.key);
+    }
+  }
+  function notifyKeyAction(actionId) {
+    for (const callback of keyActionCallbacks.get(actionId) ?? []) callback();
+  }
+  function forwardKeyEvent(event = {}) {
+    fire({
+      type: "keys.forward",
+      key: typeof event.key === "string" ? event.key : "",
+      code: typeof event.code === "string" ? event.code : "",
+      ctrl: Boolean(event.ctrl ?? event.ctrlKey),
+      alt: Boolean(event.alt ?? event.altKey),
+      shift: Boolean(event.shift ?? event.shiftKey),
+      meta: Boolean(event.meta ?? event.metaKey)
+    });
+  }
+  function installKeysSmartForwarding() {
+    if (keysSmartForwardingInstalled) return;
+    keysSmartForwardingInstalled = true;
+    listen((event) => {
+      if (!isParentMessage(event)) return;
+      const msg = event.data;
+      if (typeof msg === "object" && msg !== null && msg.type === "keys.bindings") {
+        replaceKeyBindings(msg.bindings);
+      }
+    });
+    const documentLike = target.document;
+    const listenerTarget = typeof documentLike?.addEventListener === "function" ? documentLike : target;
+    if (typeof listenerTarget.addEventListener !== "function") return;
+    listenerTarget.addEventListener("keydown", (event) => {
+      const keyEvent = event;
+      if (keyEvent.isComposing) return;
+      if (typeof keyEvent.key === "string" && modifierKeys.has(keyEvent.key)) return;
+      if (isTextEntryTarget(keyEvent.target ?? documentLike?.activeElement)) return;
+      const combo = eventComboKey(keyEvent);
+      const actionId = combo ? keyBindingActions.get(combo) : void 0;
+      const isReserved = typeof keyEvent.key === "string" && reservedKeyNames.has(keyEvent.key);
+      if (actionId && !isReserved) {
+        keyEvent.preventDefault?.();
+        notifyKeyAction(actionId);
+        return;
+      }
+      forwardKeyEvent(keyEvent);
+    });
+  }
   function makeKeys() {
+    installKeysSmartForwarding();
     return {
-      forward: (event = {}) => fire({
-        type: "keys.forward",
-        key: typeof event.key === "string" ? event.key : "",
-        code: typeof event.code === "string" ? event.code : "",
-        ctrl: Boolean(event.ctrl ?? event.ctrlKey),
-        alt: Boolean(event.alt ?? event.altKey),
-        shift: Boolean(event.shift ?? event.shiftKey),
-        meta: Boolean(event.meta ?? event.metaKey)
-      }),
+      forward: forwardKeyEvent,
       registerAction: (action) => request(
         { type: "keys.registerAction", action },
         "keys.registerAction.result",
         resultOrError
-      ),
-      unregisterAction: (actionId) => fire({ type: "keys.unregisterAction", actionId }),
+      ).then((result) => {
+        const actionRecord = action && typeof action === "object" ? action : {};
+        const resultRecord = result;
+        rememberKeyBinding(
+          typeof resultRecord.actionId === "string" ? resultRecord.actionId : actionRecord.id,
+          resultRecord.binding
+        );
+        return result;
+      }),
+      unregisterAction: (actionId) => {
+        removeKeyBindingsForAction(actionId);
+        fire({ type: "keys.unregisterAction", actionId });
+      },
       onAction(actionId, callback) {
+        let callbacks = keyActionCallbacks.get(actionId);
+        if (!callbacks) {
+          callbacks = /* @__PURE__ */ new Set();
+          keyActionCallbacks.set(actionId, callbacks);
+        }
+        callbacks.add(callback);
         const off = listen((event) => {
           if (!isParentMessage(event)) return;
           const msg = event.data;
           if (typeof msg === "object" && msg !== null && msg.type === "keys.action" && msg.actionId === actionId) callback();
         });
-        return subscriptionHandle(off);
+        return subscriptionHandle(() => {
+          off();
+          callbacks.delete(callback);
+          if (callbacks.size === 0) keyActionCallbacks.delete(actionId);
+        });
       }
     };
   }
@@ -1962,7 +2122,9 @@ function nappletNamespacePrelude(domains) {
       }
     };
   }
+  const shell = makeShell();
   function makeDomain(domain, existing) {
+    if (domain === "shell") return shell;
     if (existing && typeof existing === "object" && Object.keys(existing).length > 0) return existing;
     switch (domain) {
       case "relay":
@@ -2138,7 +2300,6 @@ export {
   buildShellCapabilities,
   createEnforceGate,
   createIdentityProxy,
-  createKeysForwarder,
   createKeysProxy,
   createMediaProxy,
   createNapEnforceGate,