@bgx4k3p/huly-mcp-server 2.2.3 → 2.2.5

package/node_modules/prosemirror-menu/src/menu.ts

@@ -14,18 +14,20 @@ export interface MenuElement {
   /// Render the element for display in the menu. Must return a DOM
   /// element and a function that can be used to update the element to
   /// a new state. The `update` function must return false if the
-  /// update hid the entire element.
-  render(pm: EditorView): {dom: HTMLElement, update: (state: EditorState) => boolean}
+  /// update hid the entire element. May also return a `focusable`
+  /// DOM node, which is the node that should receive focus when this
+  /// element is focused. If not provided, the `dom` element will be used.
+  render(pm: EditorView): {dom: HTMLElement, update: (state: EditorState) => boolean, focusable?: HTMLElement}
 }
 
 const prefix = "ProseMirror-menu"
 
 /// An icon or label that, when clicked, executes a command.
-export class MenuItem implements MenuElement {
+export class MenuItem<E extends HTMLElement = HTMLButtonElement> implements MenuElement {
   /// Create a menu item.
   constructor(
     /// The spec used to create this item.
-    readonly spec: MenuItemSpec
+    readonly spec: MenuItemSpec<E>
   ) {}
 
   /// Renders the icon according to its [display
@@ -35,21 +37,25 @@ export class MenuItem implements MenuElement {
     let spec = this.spec
     let dom = spec.render ? spec.render(view)
         : spec.icon ? getIcon(view.root, spec.icon)
-        : spec.label ? crel("div", null, translate(view, spec.label))
+        : spec.label ? crel("button", {type: "button"}, translate(view, spec.label)) as HTMLButtonElement
         : null
     if (!dom) throw new RangeError("MenuItem without icon or label property")
     if (spec.title) {
-      const title = (typeof spec.title === "function" ? spec.title(view.state) : spec.title)
+      let title = (typeof spec.title === "function" ? spec.title(view.state) : spec.title)
       ;(dom as HTMLElement).setAttribute("title", translate(view, title))
     }
     if (spec.class) dom.classList.add(spec.class)
     if (spec.css) dom.style.cssText += spec.css
 
-    dom.addEventListener("mousedown", e => {
-      e.preventDefault()
-      if (!dom!.classList.contains(prefix + "-disabled"))
+    dom.addEventListener("click", e => {
+      if (!dom!.classList.contains(prefix + "-disabled")) {
+        let setFocus = document.activeElement == dom || document.activeElement == view.dom
         spec.run(view.state, view.dispatch, view, e)
+        if (setFocus && document.activeElement == dom) view.focus()
+      }
     })
+    // Clicking on a menu item should not remove focus from the editor
+    dom.addEventListener("mousedown", e => e.preventDefault())
 
     function update(state: EditorState) {
       if (spec.select) {
@@ -61,10 +67,12 @@ export class MenuItem implements MenuElement {
       if (spec.enable) {
         enabled = spec.enable(state) || false
         setClass(dom!, prefix + "-disabled", !enabled)
+        dom!.setAttribute("aria-disabled", (!enabled).toString())
       }
       if (spec.active) {
         let active = enabled && spec.active(state) || false
         setClass(dom!, prefix + "-active", active)
+        dom!.setAttribute("aria-pressed", active.toString())
       }
       return true
     }
@@ -88,7 +96,7 @@ function translate(view: EditorView, text: string): string {
 export type IconSpec = {path: string, width: number, height: number} | {text: string, css?: string} | {dom: Node}
 
 /// The configuration object passed to the `MenuItem` constructor.
-export interface MenuItemSpec {
+export interface MenuItemSpec<E extends HTMLElement = HTMLButtonElement> {
   /// The function to execute when the menu item is activated.
   run: (state: EditorState, dispatch: (tr: Transaction) => void, view: EditorView, event: Event) => void
 
@@ -108,7 +116,7 @@ export interface MenuItemSpec {
 
   /// A function that renders the item. You must provide either this,
   /// [`icon`](#menu.MenuItemSpec.icon), or [`label`](#MenuItemSpec.label).
-  render?: (view: EditorView) => HTMLElement
+  render?: (view: EditorView) => E
 
   /// Describes an icon to show for this item.
   icon?: IconSpec
@@ -144,6 +152,11 @@ function isMenuEvent(wrapper: HTMLElement) {
 export class Dropdown implements MenuElement {
   /// @internal
   content: readonly MenuElement[]
+  /// @internal
+  focusables: HTMLElement[] = []
+  /// @internal
+  focusIndex = 0
+  private focusTimeout = -1
 
   /// Create a dropdown wrapping the elements.
   constructor(
@@ -171,33 +184,66 @@ export class Dropdown implements MenuElement {
   /// Render the dropdown menu and sub-items.
   render(view: EditorView) {
     let content = renderDropdownItems(this.content, view)
+    this.focusables = content.focusables
     let win = view.dom.ownerDocument.defaultView || window
 
-    let label = crel("div", {class: prefix + "-dropdown " + (this.options.class || ""),
-                             style: this.options.css},
-                     translate(view, this.options.label || ""))
-    if (this.options.title) label.setAttribute("title", translate(view, this.options.title))
-    let wrap = crel("div", {class: prefix + "-dropdown-wrap"}, label)
+    let btn = crel(
+      "button", {
+        type: "button",
+        class: prefix + "-dropdown " + (this.options.class || ""),
+        style: this.options.css,
+        "aria-haspopup": "menu",
+        "aria-expanded": "false"
+      },
+      translate(view, this.options.label || "")
+    )
+    if (this.options.title) btn.setAttribute("title", translate(view, this.options.title))
+    let wrap = crel("div", {class: prefix + "-dropdown-wrap"}, btn)
     let open: {close: () => boolean, node: HTMLElement} | null = null
     let listeningOnClose: (() => void) | null = null
     let close = () => {
       if (open && open.close()) {
         open = null
-        win.removeEventListener("mousedown", listeningOnClose!)
+        win.removeEventListener("click", listeningOnClose!)
       }
     }
-    label.addEventListener("mousedown", e => {
-      e.preventDefault()
+    btn.addEventListener("click", e => {
       markMenuEvent(e)
       if (open) {
         close()
       } else {
-        open = this.expand(wrap, content.dom)
-        win.addEventListener("mousedown", listeningOnClose = () => {
+        open = this.expand(wrap, content.dom, btn)
+        win.addEventListener("click", listeningOnClose = () => {
           if (!isMenuEvent(wrap)) close()
         })
+
+        // If triggered using the keyboard, move focus to first item
+        if (e.detail === 0) {
+          let focusIndex = findFocusableIndex(this.focusables, -1, 1)
+          if (focusIndex != null) this.setFocusIndex(focusIndex)
+        }
+
+        open.node.addEventListener("keydown", (event) => {
+          markMenuEvent(event)
+          if (keyboardMoveFocus(this, event, "vertical")) {
+          } else if (event.key === "Escape") {
+            event.preventDefault()
+            event.stopPropagation()
+            btn.focus()
+            close()
+          }
+        })
+        open.node.addEventListener("focusout", () => {
+          clearTimeout(this.focusTimeout)
+          this.focusTimeout = setTimeout(() => {
+            let active = win.document.activeElement
+            if (active && open && !open.node.contains(active)) close()
+          }, 20)
+        })
       }
     })
+    // Clicking on a dropdown should not remove focus from the editor
+    btn.addEventListener("mousedown", e => e.preventDefault())
 
     function update(state: EditorState) {
       let inner = content.update(state)
@@ -205,11 +251,11 @@ export class Dropdown implements MenuElement {
       return inner
     }
 
-    return {dom: wrap, update}
+    return {dom: wrap, update, focusable: btn}
   }
 
   /// @internal
-  expand(dom: HTMLElement, items: readonly Node[]) {
+  expand(dom: HTMLElement, items: HTMLElement, trigger: HTMLElement) {
     let menuDOM = crel("div", {class: prefix + "-dropdown-menu " + (this.options.class || "")}, items)
 
     let done = false
@@ -217,26 +263,84 @@ export class Dropdown implements MenuElement {
       if (done) return false
       done = true
       dom.removeChild(menuDOM)
+      trigger.ariaControlsElements = []
+      trigger.setAttribute("aria-expanded", "false")
       return true
     }
+
     dom.appendChild(menuDOM)
+    trigger.ariaControlsElements = [items]
+    trigger.setAttribute("aria-expanded", "true")
     return {close, node: menuDOM}
   }
+
+  setFocusIndex(index: number) {
+    if (this.focusables.length <= 1) return
+    this.focusables[this.focusIndex].setAttribute("tabindex", "-1")
+    this.focusIndex = index
+    let nextFocusItem = this.focusables[index]
+    nextFocusItem.setAttribute("tabindex", "0")
+    nextFocusItem.focus()
+  }
+}
+
+export function findFocusableIndex(focusables: readonly HTMLElement[], startIndex: number, delta: 1 | -1) {
+  let length = focusables.length
+  for (let i = 0, index = startIndex + delta;; index += delta, i++) {
+    let normIndex = (index + length) % length
+    if (focusables[normIndex].style.display != "none") return normIndex
+    if (i == length) return null
+  }
+}
+
+export function keyboardMoveFocus(
+  control: {focusables: readonly HTMLElement[], focusIndex: number, setFocusIndex: (i: number) => void},
+  event: KeyboardEvent,
+  orientation: "vertical" | "horizontal"
+) {
+  let {focusables, focusIndex} = control
+  let move =
+    event.key == (orientation == "vertical" ? "ArrowDown" : "ArrowRight") ? findFocusableIndex(focusables, focusIndex, 1) :
+    event.key == (orientation == "vertical" ? "ArrowUp" : "ArrowLeft") ? findFocusableIndex(focusables, focusIndex, -1) :
+    event.key == "Home" ? findFocusableIndex(focusables, -1, 1) :
+    event.key == "End" ? findFocusableIndex(focusables, focusables.length, -1) : null
+  if (move == null) return false
+  event.preventDefault()
+  event.stopPropagation()
+  control.setFocusIndex(move)
+  return true
 }
 
 function renderDropdownItems(items: readonly MenuElement[], view: EditorView) {
-  let rendered = [], updates = []
+  let elts: HTMLElement[] = [], focusables: HTMLElement[] = [], updates: ((state: EditorState) => boolean)[] = []
   for (let i = 0; i < items.length; i++) {
-    let {dom, update} = items[i].render(view)
-    rendered.push(crel("div", {class: prefix + "-dropdown-item"}, dom))
+    let item = items[i]
+    let {dom, update, focusable} = item.render(view)
+    elts.push(crel("li", {
+      class: `${prefix}-dropdown-item`,
+      role: "menuitem",
+      "tabindex": "-1"
+    }, dom))
+    focusables.push(focusable || dom)
     updates.push(update)
   }
-  return {dom: rendered, update: combineUpdates(updates, rendered)}
+
+  function update(state: EditorState) {
+    let something = false
+    for (let i = 0; i < elts.length; i++) {
+      let dom = elts[i], up = updates[i](state)
+      if (up) something = true
+      dom.style.display = up ? "" : "none"
+    }
+    return something
+  }
+
+  return {dom: crel("ul", {role: "menu"}, elts), update, focusables}
 }
 
 function combineUpdates(
   updates: readonly ((state: EditorState) => boolean)[],
-  nodes: readonly HTMLElement[]
+  nodes: readonly HTMLElement[],
 ) {
   return (state: EditorState) => {
     let something = false
@@ -254,6 +358,11 @@ function combineUpdates(
 export class DropdownSubmenu implements MenuElement {
   /// @internal
   content: readonly MenuElement[]
+  /// @internal
+  focusables: HTMLElement[] = []
+  /// @internal
+  focusIndex = 0
+  private focusTimeout = -1
 
   /// Creates a submenu for the given group of menu elements. The
   /// following options are recognized:
@@ -271,24 +380,58 @@ export class DropdownSubmenu implements MenuElement {
   /// Renders the submenu.
   render(view: EditorView) {
     let items = renderDropdownItems(this.content, view)
+    this.focusables = items.focusables
     let win = view.dom.ownerDocument.defaultView || window
 
-    let label = crel("div", {class: prefix + "-submenu-label"}, translate(view, this.options.label || ""))
-    let wrap = crel("div", {class: prefix + "-submenu-wrap"}, label,
-                   crel("div", {class: prefix + "-submenu"}, items.dom))
+    let btn = crel("button", {type: "button", class: prefix + "-submenu-label"}, translate(view, this.options.label || ""))
+    let wrap = crel("div", {class: prefix + "-submenu-wrap"}, btn,
+                    crel("div", {class: prefix + "-submenu"}, items.dom))
     let listeningOnClose: (() => void) | null = null
-    label.addEventListener("mousedown", e => {
+
+    let openSubmenu = (e: Event) => {
       e.preventDefault()
+      e.stopPropagation()
       markMenuEvent(e)
-      setClass(wrap, prefix + "-submenu-wrap-active", false)
+      setClass(wrap, prefix + "-submenu-wrap-active", true)
       if (!listeningOnClose)
-        win.addEventListener("mousedown", listeningOnClose = () => {
+        win.addEventListener("click", listeningOnClose = () => {
           if (!isMenuEvent(wrap)) {
             wrap.classList.remove(prefix + "-submenu-wrap-active")
-            win.removeEventListener("mousedown", listeningOnClose!)
+            win.removeEventListener("click", listeningOnClose!)
             listeningOnClose = null
           }
         })
+      if (!(e.type == "click" && (e as MouseEvent).detail)) {
+        let focusIndex = findFocusableIndex(this.focusables, -1, 1)
+        if (focusIndex != null) this.setFocusIndex(focusIndex)
+      }
+    }
+
+    btn.addEventListener("click", openSubmenu)
+    btn.addEventListener("keydown", e => {
+      if (e.key === "ArrowRight") openSubmenu(e)
+    })
+    // Clicking on an item should not remove focus from the editor
+    btn.addEventListener("mousedown", e => e.preventDefault())
+
+    items.dom.addEventListener("keydown", (event) => {
+      markMenuEvent(event)
+      if (keyboardMoveFocus(this, event, "vertical")) {
+      } else if (event.key === "Escape" || event.key === "ArrowLeft") {
+        event.preventDefault()
+        event.stopPropagation()
+        setClass(wrap, prefix + "-submenu-wrap-active", false)
+        btn.focus()
+      }
+    })
+
+    items.dom.addEventListener("focusout", () => {
+      clearTimeout(this.focusTimeout)
+      this.focusTimeout = setTimeout(() => {
+        let active = win.document.activeElement
+        if (active && !items.dom.contains(active))
+          wrap.classList.remove(prefix + "-submenu-wrap-active")
+      }, 20)
     })
 
     function update(state: EditorState) {
@@ -296,7 +439,16 @@ export class DropdownSubmenu implements MenuElement {
       wrap.style.display = inner ? "" : "none"
       return inner
     }
-    return {dom: wrap, update}
+    return {dom: wrap, update, focusable: btn}
+  }
+
+  setFocusIndex(index: number) {
+    if (this.focusables.length <= 1) return
+    this.focusables[this.focusIndex].setAttribute("tabindex", "-1")
+    this.focusIndex = index
+    let nextFocusItem = this.focusables[index]
+    nextFocusItem.setAttribute("tabindex", "0")
+    nextFocusItem.focus()
   }
 }
 
@@ -306,11 +458,12 @@ export class DropdownSubmenu implements MenuElement {
 /// be empty).
 export function renderGrouped(view: EditorView, content: readonly (readonly MenuElement[])[]) {
   let result = document.createDocumentFragment()
-  let updates: ((state: EditorState) => boolean)[] = [], separators: HTMLElement[] = []
+  let updates: ((state: EditorState) => boolean)[] = [], focusables: HTMLElement[] = [], separators: HTMLElement[] = []
   for (let i = 0; i < content.length; i++) {
     let items = content[i], localUpdates = [], localNodes = []
     for (let j = 0; j < items.length; j++) {
-      let {dom, update} = items[j].render(view)
+      let {dom, update, focusable} = items[j].render(view)
+      focusables.push(focusable || dom)
       let span = crel("span", {class: prefix + "item"}, dom)
       result.appendChild(span)
       localNodes.push(span)
@@ -333,11 +486,11 @@ export function renderGrouped(view: EditorView, content: readonly (readonly Menu
     }
     return something
   }
-  return {dom: result, update}
+  return {dom: result, update, focusables}
 }
 
 function separator() {
-  return crel("span", {class: prefix + "separator"})
+  return crel("span", {class: prefix + "separator", role: "separator"})
 }
 
 /// A set of basic editor-related icons. Contains the properties

package/node_modules/prosemirror-menu/src/menubar.ts

@@ -2,7 +2,7 @@ import crel from "crelt"
 import {Plugin, EditorState} from "prosemirror-state"
 import {EditorView} from "prosemirror-view"
 
-import {renderGrouped, MenuElement} from "./menu"
+import {renderGrouped, MenuElement, keyboardMoveFocus, findFocusableIndex} from "./menu"
 
 const prefix = "ProseMirror-menubar"
 
@@ -19,6 +19,10 @@ export function menuBar(options: {
   /// passed to `renderGrouped`.
   content: readonly (readonly MenuElement[])[]
 
+  /// Determines whether the menu is placed before or after the editor in the DOM.
+  /// The default is "before".
+  position?: "before" | "after"
+
   /// Determines whether the menu floats, i.e. whether it sticks to
   /// the top of the viewport when the editor is partially scrolled
   /// out of view.
@@ -32,6 +36,8 @@ export function menuBar(options: {
 class MenuBarView {
   wrapper: HTMLElement
   menu: HTMLElement
+  focusables: HTMLElement[] = []
+  focusIndex = 0
   spacer: HTMLElement | null = null
   maxHeight = 0
   widthForMaxHeight = 0
@@ -46,17 +52,22 @@ class MenuBarView {
   ) {
     this.root = editorView.root
     this.wrapper = crel("div", {class: prefix + "-wrapper"})
-    this.menu = this.wrapper.appendChild(crel("div", {class: prefix}))
+    this.menu = this.wrapper.appendChild(crel("div", {class: prefix, role: "toolbar"}))
     this.menu.className = prefix
+    this.menu.ariaControlsElements = [editorView.dom]
 
     if (editorView.dom.parentNode)
       editorView.dom.parentNode.replaceChild(this.wrapper, editorView.dom)
-    this.wrapper.appendChild(editorView.dom)
+    if (options.position === "after") {
+      this.wrapper.insertBefore(editorView.dom, this.wrapper.firstChild)
+    } else {
+      this.wrapper.appendChild(editorView.dom)
+    }
 
-    let {dom, update} = renderGrouped(this.editorView, this.options.content)
+    let {dom, update, focusables} = renderGrouped(this.editorView, this.options.content)
     this.contentUpdate = update
+    this.focusables = focusables
     this.menu.appendChild(dom)
-    this.update()
 
     if (options.floating && !isIOS()) {
       this.updateFloat()
@@ -70,6 +81,35 @@ class MenuBarView {
       }
       potentialScrollers.forEach(el => el.addEventListener('scroll', this.scrollHandler!))
     }
+
+    // update focusIndex on focus change
+    for (let i = 0; i < focusables.length; i++) {
+      let focusable = focusables[i]
+      // set `tabindex` to -1 for all but the first focusable item
+      if (i) focusable.setAttribute("tabindex", "-1")
+      focusable.addEventListener("focus", () => {
+        if (this.focusIndex === i) return
+        let prevFocusItem = this.focusables[this.focusIndex]
+        prevFocusItem.setAttribute("tabindex", "-1")
+        focusable.setAttribute("tabindex", "0")
+        this.focusIndex = i
+      })
+    }
+
+    this.menu.addEventListener("keydown", (event) => {
+      keyboardMoveFocus(this, event, "horizontal")
+    })
+
+    this.update()
+  }
+
+  setFocusIndex(index: number) {
+    if (this.focusables.length <= 1) return
+    this.focusables[this.focusIndex].setAttribute("tabindex", "-1")
+    this.focusIndex = index
+    let nextFocusItem = this.focusables[index]
+    nextFocusItem.setAttribute("tabindex", "0")
+    nextFocusItem.focus()
   }
 
   update() {
@@ -79,7 +119,12 @@ class MenuBarView {
       this.menu.replaceChild(dom, this.menu.firstChild!)
       this.root = this.editorView.root
     }
+    let active = this.editorView.dom.ownerDocument.activeElement == this.focusables[this.focusIndex]
     this.contentUpdate(this.editorView.state)
+    if (active && this.focusables[this.focusIndex].style.display == "none") {
+      let next = findFocusableIndex(this.focusables, this.focusIndex, 1)
+      if (next != null) this.setFocusIndex(next)
+    }
 
     if (this.floating) {
       this.updateScrollCursor()

package/node_modules/prosemirror-menu/style/menu.css

@@ -18,17 +18,26 @@
   display: inline-block;
 }
 
+.ProseMirror-menuitem button {
+  border: none;
+  background: transparent;
+  box-shadow: none;
+  color: inherit;
+  font-size: inherit;
+  font-family: inherit;
+}
+
 .ProseMirror-menuseparator {
   border-right: 1px solid #ddd;
   margin-right: 3px;
 }
 
-.ProseMirror-menu-dropdown, .ProseMirror-menu-dropdown-menu {
+.ProseMirror-menuitem .ProseMirror-menu-dropdown, .ProseMirror-menu-dropdown-menu {
   font-size: 90%;
   white-space: nowrap;
 }
 
-.ProseMirror-menu-dropdown {
+.ProseMirror-menuitem .ProseMirror-menu-dropdown {
   vertical-align: 1px;
   cursor: pointer;
   position: relative;
@@ -60,17 +69,27 @@
   padding: 2px;
 }
 
+.ProseMirror-menu-dropdown-menu ul,
+.ProseMirror-menu-dropdown-menu ol,
+.ProseMirror-menu-submenu ul,
+.ProseMirror-menu-submenu ol {
+  margin: 0;
+  padding: 0;
+  list-style: none;
+}
+
 .ProseMirror-menu-dropdown-menu {
   z-index: 15;
   min-width: 6em;
 }
 
-.ProseMirror-menu-dropdown-item {
+.ProseMirror-menu-dropdown-item button {
   cursor: pointer;
   padding: 2px 8px 2px 4px;
 }
 
-.ProseMirror-menu-dropdown-item:hover {
+.ProseMirror-menu-dropdown-item:hover,
+.ProseMirror-menu-dropdown-item:focus-within {
   background: #f2f2f2;
 }
 
@@ -97,16 +116,18 @@
   top: -3px;
 }
 
-.ProseMirror-menu-active {
+.ProseMirror-menuitem .ProseMirror-menu-active {
   background: #eee;
   border-radius: 4px;
 }
 
-.ProseMirror-menu-disabled {
+.ProseMirror-menuitem .ProseMirror-menu-disabled {
   opacity: .3;
 }
 
-.ProseMirror-menu-submenu-wrap:hover .ProseMirror-menu-submenu, .ProseMirror-menu-submenu-wrap-active .ProseMirror-menu-submenu {
+.ProseMirror-menu-submenu-wrap:hover .ProseMirror-menu-submenu,
+.ProseMirror-menu-submenu:focus-within,
+.ProseMirror-menu-submenu-wrap-active .ProseMirror-menu-submenu {
   display: block;
 }
 

package/node_modules/prosemirror-model/CHANGELOG.md

@@ -1,3 +1,23 @@
+## 1.25.7 (2026-05-18)
+
+### Bug fixes
+
+Fix a regression (since 1.25.5) in the way `DOMOutputSpec`s are interpreted.
+
+## 1.25.6 (2026-05-15)
+
+### Bug fixes
+
+Remove an accidentally commited `console.log`.
+
+## 1.25.5 (2026-05-14)
+
+### Bug fixes
+
+Properly reflect the fact that nodes must not serialize to just text nodes in the `DOMOutputSpec` type.
+
+Don't check content constraints in `Slice.insertAt` when inserting into an open node.
+
 ## 1.25.4 (2025-10-21)
 
 ### Bug fixes