@relevaince/mentions 0.3.3 → 0.6.0

package/dist/index.js

@@ -39,6 +39,7 @@ module.exports = __toCommonJS(index_exports);
 
 // src/components/MentionsInput.tsx
 var import_react5 = require("react");
+var import_react_dom = require("react-dom");
 var import_react6 = require("@tiptap/react");
 
 // src/hooks/useMentionsEditor.ts
@@ -64,6 +65,12 @@ var MentionNode = import_core.Node.create({
   atom: true,
   selectable: true,
   draggable: false,
+  addOptions() {
+    return {
+      onClickRef: void 0,
+      onHoverRef: void 0
+    };
+  },
   addAttributes() {
     return {
       id: {
@@ -96,11 +103,17 @@ var MentionNode = import_core.Node.create({
     const label = node.attrs.label;
     const prefix = DEFAULT_PREFIXES[entityType] ?? "@";
     const display = `${prefix}${label}`;
+    const hasClick = !!this.options.onClickRef?.current;
+    const extraAttrs = {};
+    if (hasClick) {
+      extraAttrs["data-mention-clickable"] = "";
+    }
     return [
       "span",
       (0, import_core.mergeAttributes)(HTMLAttributes, {
         "data-mention": "",
-        class: "mention-chip"
+        class: "mention-chip",
+        ...extraAttrs
       }),
       display
     ];
@@ -111,6 +124,58 @@ var MentionNode = import_core.Node.create({
     const prefix = DEFAULT_PREFIXES[entityType] ?? "@";
     return `${prefix}${label}`;
   },
+  addNodeView() {
+    const options = this.options;
+    return ({ node, HTMLAttributes }) => {
+      const entityType = node.attrs.entityType;
+      const label = node.attrs.label;
+      const id = node.attrs.id;
+      const prefix = DEFAULT_PREFIXES[entityType] ?? "@";
+      const dom = document.createElement("span");
+      Object.entries(
+        (0, import_core.mergeAttributes)(HTMLAttributes, {
+          "data-mention": "",
+          "data-type": entityType,
+          "data-id": id,
+          class: "mention-chip"
+        })
+      ).forEach(([key, val]) => {
+        if (val != null && val !== false) dom.setAttribute(key, String(val));
+      });
+      dom.textContent = `${prefix}${label}`;
+      if (options.onClickRef?.current) {
+        dom.setAttribute("data-mention-clickable", "");
+        dom.style.cursor = "pointer";
+      }
+      dom.addEventListener("click", (event) => {
+        const handler = options.onClickRef?.current;
+        if (handler) {
+          event.preventDefault();
+          event.stopPropagation();
+          handler({ id, type: entityType, label }, event);
+        }
+      });
+      let tooltip = null;
+      dom.addEventListener("mouseenter", () => {
+        const hoverFn = options.onHoverRef?.current;
+        if (!hoverFn) return;
+        const content = hoverFn({ id, type: entityType, label });
+        if (!content) return;
+        tooltip = document.createElement("div");
+        tooltip.setAttribute("data-mention-tooltip", "");
+        tooltip.textContent = typeof content === "string" ? content : "";
+        dom.style.position = "relative";
+        dom.appendChild(tooltip);
+      });
+      dom.addEventListener("mouseleave", () => {
+        if (tooltip && tooltip.parentNode) {
+          tooltip.parentNode.removeChild(tooltip);
+          tooltip = null;
+        }
+      });
+      return { dom };
+    };
+  },
   addKeyboardShortcuts() {
     return {
       Backspace: () => this.editor.commands.command(({ tr, state }) => {
@@ -143,7 +208,13 @@ function detectTrigger(text, cursorPos, docStartPos, triggers) {
       if (before.substring(i, i + trigger.length) === trigger) {
         if (i === 0 || /\s/.test(before[i - 1])) {
           const query = before.slice(i + trigger.length);
-          return { trigger, query, from: docStartPos + i, to: cursorPos };
+          return {
+            trigger,
+            query,
+            from: docStartPos + i,
+            to: cursorPos,
+            textBefore: before.slice(0, i)
+          };
         }
       }
     }
@@ -151,7 +222,7 @@ function detectTrigger(text, cursorPos, docStartPos, triggers) {
   return null;
 }
 var suggestionPluginKey = new import_state.PluginKey("mentionSuggestion");
-function createSuggestionExtension(triggers, callbacksRef) {
+function createSuggestionExtension(triggers, callbacksRef, allowTriggerRef, streamingRef) {
   return import_core2.Extension.create({
     name: "mentionSuggestion",
     priority: 200,
@@ -202,6 +273,15 @@ function createSuggestionExtension(triggers, callbacksRef) {
         view() {
           return {
             update(view, _prevState) {
+              if (streamingRef?.current) {
+                if (active) {
+                  active = false;
+                  lastQuery = null;
+                  lastTrigger = null;
+                  callbacksRef.current.onExit();
+                }
+                return;
+              }
               const { state } = view;
               const { selection } = state;
               if (!selection.empty) {
@@ -229,6 +309,20 @@ function createSuggestionExtension(triggers, callbacksRef) {
               const cursorPos = $pos.pos;
               const match = detectTrigger(blockText, cursorPos, blockStart, triggers);
               if (match) {
+                if (allowTriggerRef?.current) {
+                  const allowed = allowTriggerRef.current(match.trigger, {
+                    textBefore: match.textBefore
+                  });
+                  if (!allowed) {
+                    if (active) {
+                      active = false;
+                      lastQuery = null;
+                      lastTrigger = null;
+                      callbacksRef.current.onExit();
+                    }
+                    return;
+                  }
+                }
                 const range = { from: match.from, to: match.to };
                 const props = {
                   query: match.query,
@@ -398,27 +492,48 @@ function buildOutput(editor) {
     plainText: extractPlainText(json)
   };
 }
-function createSubmitExtension(onSubmitRef, clearOnSubmitRef) {
+function collectMentionTokens(doc) {
+  const tokens = [];
+  function walk(node) {
+    if (node.type === "mention" && node.attrs) {
+      tokens.push({
+        id: node.attrs.id,
+        type: node.attrs.entityType ?? node.attrs.type,
+        label: node.attrs.label
+      });
+    }
+    if (node.content) {
+      for (const child of node.content) walk(child);
+    }
+  }
+  walk(doc);
+  return tokens;
+}
+function createSubmitExtension(onSubmitRef, clearOnSubmitRef, submitKeyRef) {
   return import_core3.Extension.create({
     name: "submitShortcut",
     priority: 150,
     addKeyboardShortcuts() {
       return {
         "Mod-Enter": () => {
-          if (onSubmitRef.current) {
-            onSubmitRef.current(buildOutput(this.editor));
-            if (clearOnSubmitRef.current) {
-              this.editor.commands.clearContent(true);
+          const key = submitKeyRef.current;
+          if (key === "mod+enter" || key === "enter") {
+            if (onSubmitRef.current) {
+              onSubmitRef.current(buildOutput(this.editor));
+              if (clearOnSubmitRef.current) {
+                this.editor.commands.clearContent(true);
+              }
             }
+            return true;
           }
-          return true;
+          return false;
         }
       };
     }
   });
 }
 var enterSubmitPluginKey = new import_state2.PluginKey("enterSubmit");
-function createEnterExtension(onSubmitRef, clearOnSubmitRef) {
+function createEnterExtension(onSubmitRef, clearOnSubmitRef, submitKeyRef) {
   return import_core3.Extension.create({
     name: "enterSubmit",
     priority: 150,
@@ -430,6 +545,11 @@ function createEnterExtension(onSubmitRef, clearOnSubmitRef) {
           props: {
             handleKeyDown(_view, event) {
               if (event.key !== "Enter") return false;
+              const key = submitKeyRef.current;
+              if (key === "none") return false;
+              if (key === "mod+enter") {
+                return false;
+              }
               if (event.shiftKey) {
                 editor.commands.splitBlock();
                 return true;
@@ -449,6 +569,61 @@ function createEnterExtension(onSubmitRef, clearOnSubmitRef) {
     }
   });
 }
+var mentionRemovePluginKey = new import_state2.PluginKey("mentionRemove");
+function createMentionRemoveExtension(onMentionRemoveRef) {
+  return import_core3.Extension.create({
+    name: "mentionRemoveDetector",
+    priority: 100,
+    addProseMirrorPlugins() {
+      return [
+        new import_state2.Plugin({
+          key: mentionRemovePluginKey,
+          appendTransaction(transactions, oldState, newState) {
+            if (!onMentionRemoveRef.current) return null;
+            const oldMentions = collectMentionTokens(oldState.doc.toJSON());
+            const newMentions = collectMentionTokens(newState.doc.toJSON());
+            if (oldMentions.length <= newMentions.length) return null;
+            const newIds = new Set(newMentions.map((m) => m.id));
+            for (const m of oldMentions) {
+              if (!newIds.has(m.id)) {
+                onMentionRemoveRef.current(m);
+              }
+            }
+            return null;
+          }
+        })
+      ];
+    }
+  });
+}
+var streamingBlockPluginKey = new import_state2.PluginKey("streamingBlock");
+function createStreamingBlockExtension(streamingRef) {
+  return import_core3.Extension.create({
+    name: "streamingBlock",
+    priority: 200,
+    addProseMirrorPlugins() {
+      return [
+        new import_state2.Plugin({
+          key: streamingBlockPluginKey,
+          props: {
+            handleKeyDown() {
+              return streamingRef.current;
+            },
+            handleKeyPress() {
+              return streamingRef.current;
+            },
+            handlePaste() {
+              return streamingRef.current;
+            },
+            handleDrop() {
+              return streamingRef.current;
+            }
+          }
+        })
+      ];
+    }
+  });
+}
 function useMentionsEditor({
   providers,
   value,
@@ -458,7 +633,17 @@ function useMentionsEditor({
   placeholder,
   autoFocus = false,
   editable = true,
-  callbacksRef
+  callbacksRef,
+  onFocus,
+  onBlur,
+  submitKey = "enter",
+  onMentionRemove,
+  onMentionClick,
+  onMentionHover,
+  allowTrigger,
+  validateMention,
+  streaming = false,
+  onStreamingComplete
 }) {
   const onChangeRef = (0, import_react.useRef)(onChange);
   onChangeRef.current = onChange;
@@ -466,6 +651,30 @@ function useMentionsEditor({
   onSubmitRef.current = onSubmit;
   const clearOnSubmitRef = (0, import_react.useRef)(clearOnSubmit);
   clearOnSubmitRef.current = clearOnSubmit;
+  const onFocusRef = (0, import_react.useRef)(onFocus);
+  onFocusRef.current = onFocus;
+  const onBlurRef = (0, import_react.useRef)(onBlur);
+  onBlurRef.current = onBlur;
+  const submitKeyRef = (0, import_react.useRef)(submitKey);
+  submitKeyRef.current = submitKey;
+  const onMentionRemoveRef = (0, import_react.useRef)(onMentionRemove);
+  onMentionRemoveRef.current = onMentionRemove;
+  const onMentionClickRef = (0, import_react.useRef)(onMentionClick);
+  onMentionClickRef.current = onMentionClick;
+  const onMentionHoverRef = (0, import_react.useRef)(onMentionHover);
+  onMentionHoverRef.current = onMentionHover;
+  const allowTriggerRef = (0, import_react.useRef)(allowTrigger);
+  allowTriggerRef.current = allowTrigger;
+  const validateMentionRef = (0, import_react.useRef)(validateMention);
+  validateMentionRef.current = validateMention;
+  const onStreamingCompleteRef = (0, import_react.useRef)(onStreamingComplete);
+  onStreamingCompleteRef.current = onStreamingComplete;
+  const streamingRef = (0, import_react.useRef)(streaming);
+  streamingRef.current = streaming;
+  const prevStreamingRef = (0, import_react.useRef)(streaming);
+  const throttleTimerRef = (0, import_react.useRef)(null);
+  const pendingOutputRef = (0, import_react.useRef)(null);
+  const internalMarkdownRef = (0, import_react.useRef)(null);
   const initialContent = (0, import_react.useMemo)(() => {
     if (!value) return void 0;
     return parseFromMarkdown(value);
@@ -477,16 +686,36 @@ function useMentionsEditor({
     [triggersKey]
   );
   const suggestionExtension = (0, import_react.useMemo)(
-    () => createSuggestionExtension(triggers, callbacksRef),
+    () => createSuggestionExtension(
+      triggers,
+      callbacksRef,
+      allowTriggerRef,
+      streamingRef
+    ),
     // eslint-disable-next-line react-hooks/exhaustive-deps
     [triggersKey]
   );
   const submitExt = (0, import_react.useMemo)(
-    () => createSubmitExtension(onSubmitRef, clearOnSubmitRef),
+    () => createSubmitExtension(onSubmitRef, clearOnSubmitRef, submitKeyRef),
     []
   );
   const enterExt = (0, import_react.useMemo)(
-    () => createEnterExtension(onSubmitRef, clearOnSubmitRef),
+    () => createEnterExtension(onSubmitRef, clearOnSubmitRef, submitKeyRef),
+    []
+  );
+  const mentionRemoveExt = (0, import_react.useMemo)(
+    () => createMentionRemoveExtension(onMentionRemoveRef),
+    []
+  );
+  const streamingBlockExt = (0, import_react.useMemo)(
+    () => createStreamingBlockExtension(streamingRef),
+    []
+  );
+  const mentionNodeExt = (0, import_react.useMemo)(
+    () => MentionNode.configure({
+      onClickRef: onMentionClickRef,
+      onHoverRef: onMentionHoverRef
+    }),
     []
   );
   const editor = (0, import_react2.useEditor)({
@@ -505,10 +734,12 @@ function useMentionsEditor({
         placeholder: ({ editor: editor2 }) => editor2.isEmpty ? placeholder ?? "Type a message..." : "",
         showOnlyCurrent: true
       }),
-      MentionNode,
+      mentionNodeExt,
       suggestionExtension,
       submitExt,
-      enterExt
+      enterExt,
+      mentionRemoveExt,
+      streamingBlockExt
     ],
     content: initialContent,
     autofocus: autoFocus ? "end" : false,
@@ -519,14 +750,85 @@ function useMentionsEditor({
       }
     },
     onUpdate: ({ editor: editor2 }) => {
-      onChangeRef.current?.(buildOutput(editor2));
+      const output = buildOutput(editor2);
+      internalMarkdownRef.current = output.markdown;
+      if (streamingRef.current) {
+        pendingOutputRef.current = output;
+        if (!throttleTimerRef.current) {
+          throttleTimerRef.current = setTimeout(() => {
+            throttleTimerRef.current = null;
+            if (pendingOutputRef.current) {
+              onChangeRef.current?.(pendingOutputRef.current);
+              pendingOutputRef.current = null;
+            }
+          }, 150);
+        }
+      } else {
+        onChangeRef.current?.(output);
+      }
+    },
+    onFocus: () => {
+      onFocusRef.current?.();
+    },
+    onBlur: () => {
+      onBlurRef.current?.();
     }
   });
+  (0, import_react.useEffect)(() => {
+    if (prevStreamingRef.current && !streaming && editor) {
+      if (throttleTimerRef.current) {
+        clearTimeout(throttleTimerRef.current);
+        throttleTimerRef.current = null;
+      }
+      const output = buildOutput(editor);
+      onChangeRef.current?.(output);
+      onStreamingCompleteRef.current?.(output);
+      pendingOutputRef.current = null;
+    }
+    prevStreamingRef.current = streaming;
+  }, [streaming, editor]);
+  (0, import_react.useEffect)(() => {
+    return () => {
+      if (throttleTimerRef.current) {
+        clearTimeout(throttleTimerRef.current);
+      }
+    };
+  }, []);
   (0, import_react.useEffect)(() => {
     if (editor && editor.isEditable !== editable) {
       editor.setEditable(editable);
     }
   }, [editor, editable]);
+  (0, import_react.useEffect)(() => {
+    if (!editor || value === void 0) return;
+    if (value === internalMarkdownRef.current) return;
+    const doc = parseFromMarkdown(value);
+    editor.commands.setContent(doc);
+    internalMarkdownRef.current = value;
+  }, [editor, value]);
+  (0, import_react.useEffect)(() => {
+    if (!editor || !validateMention) return;
+    const runValidation = async () => {
+      const doc = editor.getJSON();
+      const tokens = collectMentionTokens(doc);
+      const invalidIds = /* @__PURE__ */ new Set();
+      await Promise.all(
+        tokens.map(async (token) => {
+          const valid = await validateMention(token);
+          if (!valid) invalidIds.add(token.id);
+        })
+      );
+      editor.view.dom.querySelectorAll("[data-mention]").forEach((el) => {
+        const id = el.getAttribute("data-id");
+        if (id && invalidIds.has(id)) {
+          el.setAttribute("data-mention-invalid", "");
+        } else {
+          el.removeAttribute("data-mention-invalid");
+        }
+      });
+    };
+    runValidation();
+  }, [editor, validateMention]);
   const clear = (0, import_react.useCallback)(() => {
     editor?.commands.clearContent(true);
   }, [editor]);
@@ -535,6 +837,21 @@ function useMentionsEditor({
       if (!editor) return;
       const doc = parseFromMarkdown(markdown);
       editor.commands.setContent(doc);
+      internalMarkdownRef.current = markdown;
+      if (streamingRef.current) {
+        editor.commands.focus("end");
+      }
+    },
+    [editor]
+  );
+  const appendText = (0, import_react.useCallback)(
+    (text) => {
+      if (!editor) return;
+      const endPos = editor.state.doc.content.size - 1;
+      editor.commands.insertContentAt(endPos, text);
+      if (streamingRef.current) {
+        editor.commands.focus("end");
+      }
     },
     [editor]
   );
@@ -545,11 +862,32 @@ function useMentionsEditor({
     if (!editor) return null;
     return buildOutput(editor);
   }, [editor]);
-  return { editor, getOutput, clear, setContent, focus };
+  return { editor, getOutput, clear, setContent, appendText, focus };
 }
 
 // src/hooks/useSuggestion.ts
 var import_react3 = require("react");
+
+// src/utils/debounce.ts
+function debounce(fn, ms) {
+  let timer = null;
+  const debounced = ((...args) => {
+    if (timer != null) clearTimeout(timer);
+    timer = setTimeout(() => {
+      timer = null;
+      fn(...args);
+    }, ms);
+  });
+  debounced.cancel = () => {
+    if (timer != null) {
+      clearTimeout(timer);
+      timer = null;
+    }
+  };
+  return debounced;
+}
+
+// src/hooks/useSuggestion.ts
 var IDLE_STATE = {
   state: "idle",
   items: [],
@@ -560,16 +898,24 @@ var IDLE_STATE = {
   trigger: null,
   query: ""
 };
-function useSuggestion(providers) {
+function useSuggestion(providers, options = {}) {
   const [uiState, setUIState] = (0, import_react3.useState)(IDLE_STATE);
   const stateRef = (0, import_react3.useRef)(uiState);
   stateRef.current = uiState;
   const providersRef = (0, import_react3.useRef)(providers);
   providersRef.current = providers;
+  const onMentionAddRef = (0, import_react3.useRef)(options.onMentionAdd);
+  onMentionAddRef.current = options.onMentionAdd;
   const commandRef = (0, import_react3.useRef)(
     null
   );
   const providerRef = (0, import_react3.useRef)(null);
+  const debouncedFetchRef = (0, import_react3.useRef)(null);
+  (0, import_react3.useEffect)(() => {
+    return () => {
+      debouncedFetchRef.current?.cancel();
+    };
+  }, []);
   const fetchItems = (0, import_react3.useCallback)(
     async (provider, query, parent, useSearchAll) => {
       setUIState((prev) => ({ ...prev, loading: true, state: "loading" }));
@@ -600,6 +946,23 @@ function useSuggestion(providers) {
     },
     []
   );
+  const scheduleFetch = (0, import_react3.useCallback)(
+    (provider, query, parent, useSearchAll) => {
+      debouncedFetchRef.current?.cancel();
+      const ms = provider.debounceMs;
+      if (ms && ms > 0) {
+        setUIState((prev) => ({ ...prev, loading: true }));
+        const debouncedFn = debounce(() => {
+          fetchItems(provider, query, parent, useSearchAll);
+        }, ms);
+        debouncedFetchRef.current = debouncedFn;
+        debouncedFn();
+      } else {
+        fetchItems(provider, query, parent, useSearchAll);
+      }
+    },
+    [fetchItems]
+  );
   const onStart = (0, import_react3.useCallback)(
     (props) => {
       const provider = providersRef.current.find(
@@ -618,13 +981,31 @@ function useSuggestion(providers) {
         trigger: props.trigger,
         query: props.query
       });
+      if (!props.query.trim() && provider.getRecentItems) {
+        provider.getRecentItems().then((recentItems) => {
+          const tagged = recentItems.map((item) => ({
+            ...item,
+            group: item.group ?? "Recent"
+          }));
+          setUIState((prev) => ({
+            ...prev,
+            items: tagged,
+            loading: false,
+            state: "showing",
+            activeIndex: 0
+          }));
+        }).catch(() => {
+          scheduleFetch(provider, props.query);
+        });
+        return;
+      }
       if (props.query.trim() && provider.searchAll) {
-        fetchItems(provider, props.query, void 0, true);
+        scheduleFetch(provider, props.query, void 0, true);
       } else {
-        fetchItems(provider, props.query);
+        scheduleFetch(provider, props.query);
       }
     },
-    [fetchItems]
+    [scheduleFetch]
   );
   const onUpdate = (0, import_react3.useCallback)(
     (props) => {
@@ -648,14 +1029,31 @@ function useSuggestion(providers) {
         }));
       }
       if (props.query.trim() && provider.searchAll) {
-        fetchItems(provider, props.query, void 0, true);
+        scheduleFetch(provider, props.query, void 0, true);
+      } else if (!props.query.trim() && provider.getRecentItems) {
+        provider.getRecentItems().then((recentItems) => {
+          const tagged = recentItems.map((item) => ({
+            ...item,
+            group: item.group ?? "Recent"
+          }));
+          setUIState((prev) => ({
+            ...prev,
+            items: tagged,
+            loading: false,
+            state: "showing",
+            activeIndex: 0
+          }));
+        }).catch(() => {
+          scheduleFetch(provider, props.query);
+        });
       } else {
-        fetchItems(provider, props.query);
+        scheduleFetch(provider, props.query);
       }
     },
-    [fetchItems]
+    [scheduleFetch]
   );
   const onExit = (0, import_react3.useCallback)(() => {
+    debouncedFetchRef.current?.cancel();
     providerRef.current = null;
     commandRef.current = null;
     setUIState(IDLE_STATE);
@@ -690,8 +1088,8 @@ function useSuggestion(providers) {
         fetchItems(provider, "", selected);
         return;
       }
+      const rootLabel = current.breadcrumbs.length > 0 ? current.breadcrumbs[0].label : selected.rootLabel ?? null;
       if (commandRef.current) {
-        const rootLabel = current.breadcrumbs.length > 0 ? current.breadcrumbs[0].label : selected.rootLabel ?? null;
         commandRef.current({
           id: selected.id,
           label: selected.label,
@@ -699,6 +1097,11 @@ function useSuggestion(providers) {
           rootLabel
         });
       }
+      onMentionAddRef.current?.({
+        id: selected.id,
+        type: selected.type,
+        label: selected.label
+      });
     },
     [fetchItems]
   );
@@ -723,6 +1126,7 @@ function useSuggestion(providers) {
     });
   }, [fetchItems]);
   const close = (0, import_react3.useCallback)(() => {
+    debouncedFetchRef.current?.cancel();
     setUIState(IDLE_STATE);
   }, []);
   const searchNested = (0, import_react3.useCallback)(
@@ -732,10 +1136,10 @@ function useSuggestion(providers) {
       const current = stateRef.current;
       const parent = current.breadcrumbs[current.breadcrumbs.length - 1];
       if (parent) {
-        fetchItems(provider, query, parent);
+        scheduleFetch(provider, query, parent);
       }
     },
-    [fetchItems]
+    [scheduleFetch]
   );
   const onKeyDown = (0, import_react3.useCallback)(
     ({ event }) => {
@@ -758,6 +1162,14 @@ function useSuggestion(providers) {
           }
           return true;
         }
+        case "Tab": {
+          event.preventDefault();
+          const selectedItem = current.items[current.activeIndex];
+          if (selectedItem) {
+            select(selectedItem);
+          }
+          return true;
+        }
         case "ArrowRight": {
           const activeItem = current.items[current.activeIndex];
           if (activeItem?.hasChildren) {
@@ -832,13 +1244,13 @@ function optionAttrs(id, selected, index) {
 
 // src/components/SuggestionList.tsx
 var import_jsx_runtime = require("react/jsx-runtime");
-var LISTBOX_ID = "mentions-suggestion-listbox";
 function SuggestionList({
   items,
   activeIndex,
   breadcrumbs,
   loading,
   trigger,
+  query,
   clientRect,
   onSelect,
   onHover,
@@ -847,7 +1259,12 @@ function SuggestionList({
   onNavigateUp,
   onNavigateDown,
   onClose,
-  renderItem
+  onFocusEditor,
+  renderItem,
+  renderEmpty,
+  renderLoading,
+  renderGroupHeader,
+  listboxId
 }) {
   const listRef = (0, import_react4.useRef)(null);
   const searchInputRef = (0, import_react4.useRef)(null);
@@ -861,18 +1278,24 @@ function SuggestionList({
       prevBreadcrumbKey.current = breadcrumbKey;
     }
   }, [breadcrumbKey]);
+  const prevBreadcrumbsLen = (0, import_react4.useRef)(breadcrumbs.length);
   (0, import_react4.useEffect)(() => {
-    if (breadcrumbs.length > 0 && searchInputRef.current) {
+    if (prevBreadcrumbsLen.current > 0 && breadcrumbs.length === 0) {
+      onFocusEditor?.();
+    } else if (breadcrumbs.length > 0 && searchInputRef.current) {
       requestAnimationFrame(() => searchInputRef.current?.focus());
     }
-  }, [breadcrumbKey, breadcrumbs.length]);
+    prevBreadcrumbsLen.current = breadcrumbs.length;
+  }, [breadcrumbKey, breadcrumbs.length, onFocusEditor]);
   (0, import_react4.useEffect)(() => {
     if (!listRef.current) return;
     const active = listRef.current.querySelector('[aria-selected="true"]');
     active?.scrollIntoView({ block: "nearest" });
   }, [activeIndex]);
-  const style = usePopoverPosition(clientRect);
-  if (items.length === 0 && !loading) return null;
+  const { style, position } = usePopoverPosition(clientRect);
+  const activeQuery = breadcrumbs.length > 0 ? nestedQuery : query;
+  const showEmpty = !loading && items.length === 0 && activeQuery.trim().length > 0;
+  if (items.length === 0 && !loading && !showEmpty) return null;
   const handleSearchKeyDown = (e) => {
     switch (e.key) {
       case "ArrowDown":
@@ -892,8 +1315,23 @@ function SuggestionList({
       }
       case "Escape":
         e.preventDefault();
+        onFocusEditor?.();
         onClose?.();
         break;
+      case "ArrowLeft":
+        if (nestedQuery === "" || e.currentTarget.selectionStart === 0) {
+          e.preventDefault();
+          onGoBack();
+        }
+        break;
+      case "ArrowRight": {
+        const item = items[activeIndex];
+        if (item?.hasChildren) {
+          e.preventDefault();
+          onSelect(item);
+        }
+        break;
+      }
       case "Backspace":
         if (nestedQuery === "") {
           e.preventDefault();
@@ -902,11 +1340,13 @@ function SuggestionList({
         break;
     }
   };
+  const hasGroups = items.some((item) => item.group);
   return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(
     "div",
     {
       "data-suggestions": "",
       "data-trigger": trigger,
+      "data-suggestions-position": position,
       style,
       ref: listRef,
       children: [
@@ -944,28 +1384,76 @@ function SuggestionList({
             spellCheck: false
           }
         ) }),
-        loading && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { "data-suggestion-loading": "", children: "Loading..." }),
-        !loading && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { ...listboxAttrs(LISTBOX_ID, `${trigger ?? ""} suggestions`), children: items.map((item, index) => {
-          const isActive = index === activeIndex;
-          const itemId = `mention-option-${item.id}`;
-          return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
-            "div",
-            {
-              ...optionAttrs(itemId, isActive, index),
-              "data-suggestion-item": "",
-              "data-suggestion-item-active": isActive ? "" : void 0,
-              "data-has-children": item.hasChildren ? "" : void 0,
-              onMouseEnter: () => onHover(index),
-              onClick: () => onSelect(item),
-              children: renderItem ? renderItem(item, depth) : /* @__PURE__ */ (0, import_jsx_runtime.jsx)(DefaultSuggestionItem, { item })
-            },
-            item.id
-          );
-        }) })
+        loading && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { "data-suggestion-loading": "", children: renderLoading ? renderLoading() : "Loading..." }),
+        showEmpty && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { "data-suggestion-empty": "", children: renderEmpty ? renderEmpty(activeQuery) : "No results" }),
+        !loading && items.length > 0 && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { ...listboxAttrs(listboxId, `${trigger ?? ""} suggestions`), children: hasGroups ? renderGroupedItems(items, activeIndex, depth, onSelect, onHover, renderItem, renderGroupHeader) : items.map((item, index) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+          SuggestionItem,
+          {
+            item,
+            index,
+            isActive: index === activeIndex,
+            depth,
+            onSelect,
+            onHover,
+            renderItem
+          },
+          item.id
+        )) })
       ]
     }
   );
 }
+function renderGroupedItems(items, activeIndex, depth, onSelect, onHover, renderItem, renderGroupHeader) {
+  const elements = [];
+  let lastGroup;
+  items.forEach((item, index) => {
+    if (item.group && item.group !== lastGroup) {
+      lastGroup = item.group;
+      elements.push(
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { "data-suggestion-group-header": "", children: renderGroupHeader ? renderGroupHeader(item.group) : item.group }, `group-${item.group}`)
+      );
+    }
+    elements.push(
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        SuggestionItem,
+        {
+          item,
+          index,
+          isActive: index === activeIndex,
+          depth,
+          onSelect,
+          onHover,
+          renderItem
+        },
+        item.id
+      )
+    );
+  });
+  return elements;
+}
+function SuggestionItem({
+  item,
+  index,
+  isActive,
+  depth,
+  onSelect,
+  onHover,
+  renderItem
+}) {
+  const itemId = `mention-option-${item.id}`;
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    "div",
+    {
+      ...optionAttrs(itemId, isActive, index),
+      "data-suggestion-item": "",
+      "data-suggestion-item-active": isActive ? "" : void 0,
+      "data-has-children": item.hasChildren ? "" : void 0,
+      onMouseEnter: () => onHover(index),
+      onClick: () => onSelect(item),
+      children: renderItem ? renderItem(item, depth) : /* @__PURE__ */ (0, import_jsx_runtime.jsx)(DefaultSuggestionItem, { item })
+    }
+  );
+}
 function DefaultSuggestionItem({ item }) {
   return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_jsx_runtime.Fragment, { children: [
     item.icon && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { "data-suggestion-item-icon": "", children: item.icon }),
@@ -974,25 +1462,48 @@ function DefaultSuggestionItem({ item }) {
     item.hasChildren && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { "data-suggestion-item-chevron": "", "aria-hidden": "true", children: "\u203A" })
   ] });
 }
+var POPOVER_HEIGHT_ESTIMATE = 280;
+var POPOVER_WIDTH_ESTIMATE = 360;
 function usePopoverPosition(clientRect) {
   if (!clientRect) {
-    return { display: "none" };
+    return { style: { display: "none" }, position: "below" };
   }
   const rect = clientRect();
   if (!rect) {
-    return { display: "none" };
+    return { style: { display: "none" }, position: "below" };
+  }
+  const viewportH = typeof window !== "undefined" ? window.innerHeight : 800;
+  const viewportW = typeof window !== "undefined" ? window.innerWidth : 1200;
+  const spaceBelow = viewportH - rect.bottom;
+  const shouldFlip = spaceBelow < POPOVER_HEIGHT_ESTIMATE && rect.top > spaceBelow;
+  let left = rect.left;
+  if (left + POPOVER_WIDTH_ESTIMATE > viewportW) {
+    left = Math.max(0, viewportW - POPOVER_WIDTH_ESTIMATE);
+  }
+  if (shouldFlip) {
+    return {
+      style: {
+        position: "fixed",
+        left: `${left}px`,
+        bottom: `${viewportH - rect.top + 4}px`,
+        zIndex: 50
+      },
+      position: "above"
+    };
   }
   return {
-    position: "fixed",
-    left: `${rect.left}px`,
-    top: `${rect.bottom + 4}px`,
-    zIndex: 50
+    style: {
+      position: "fixed",
+      left: `${left}px`,
+      top: `${rect.bottom + 4}px`,
+      zIndex: 50
+    },
+    position: "below"
   };
 }
 
 // src/components/MentionsInput.tsx
 var import_jsx_runtime2 = require("react/jsx-runtime");
-var LISTBOX_ID2 = "mentions-suggestion-listbox";
 var MentionsInput = (0, import_react5.forwardRef)(
   function MentionsInput2({
     value,
@@ -1006,10 +1517,31 @@ var MentionsInput = (0, import_react5.forwardRef)(
     clearOnSubmit = true,
     maxLength,
     renderItem,
-    renderChip
+    renderChip,
+    renderEmpty,
+    renderLoading,
+    renderGroupHeader,
+    onFocus,
+    onBlur,
+    onMentionAdd,
+    onMentionRemove,
+    onMentionClick,
+    onMentionHover,
+    minHeight,
+    maxHeight,
+    submitKey = "enter",
+    allowTrigger,
+    validateMention,
+    portalContainer,
+    streaming,
+    onStreamingComplete
   }, ref) {
-    const { uiState, actions, callbacksRef } = useSuggestion(providers);
-    const { editor, clear, setContent, focus } = useMentionsEditor({
+    const instanceId = (0, import_react5.useId)();
+    const listboxId = `mentions-listbox-${instanceId}`;
+    const { uiState, actions, callbacksRef } = useSuggestion(providers, {
+      onMentionAdd
+    });
+    const { editor, getOutput, clear, setContent, appendText, focus } = useMentionsEditor({
       providers,
       value,
       onChange,
@@ -1018,46 +1550,72 @@ var MentionsInput = (0, import_react5.forwardRef)(
       placeholder,
       autoFocus,
       editable: !disabled,
-      callbacksRef
+      callbacksRef,
+      onFocus,
+      onBlur,
+      submitKey,
+      onMentionRemove,
+      onMentionClick,
+      onMentionHover,
+      allowTrigger,
+      validateMention,
+      streaming,
+      onStreamingComplete
     });
     (0, import_react5.useImperativeHandle)(
       ref,
-      () => ({ clear, setContent, focus }),
-      [clear, setContent, focus]
+      () => ({ clear, setContent, appendText, focus, getOutput }),
+      [clear, setContent, appendText, focus, getOutput]
     );
     const isExpanded = uiState.state !== "idle";
     const handleHover = (0, import_react5.useCallback)((index) => {
       void index;
     }, []);
+    const handleFocusEditor = (0, import_react5.useCallback)(() => {
+      editor?.commands.focus();
+    }, [editor]);
+    const editorStyle = {};
+    if (minHeight != null) editorStyle.minHeight = `${minHeight}px`;
+    if (maxHeight != null) {
+      editorStyle.maxHeight = `${maxHeight}px`;
+      editorStyle.overflowY = "auto";
+    }
+    const suggestionList = isExpanded ? /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+      SuggestionList,
+      {
+        items: uiState.items,
+        activeIndex: uiState.activeIndex,
+        breadcrumbs: uiState.breadcrumbs,
+        loading: uiState.loading,
+        trigger: uiState.trigger,
+        query: uiState.query,
+        clientRect: uiState.clientRect,
+        onSelect: (item) => actions.select(item),
+        onHover: handleHover,
+        onGoBack: actions.goBack,
+        onSearchNested: actions.searchNested,
+        onNavigateUp: actions.navigateUp,
+        onNavigateDown: actions.navigateDown,
+        onClose: actions.close,
+        onFocusEditor: handleFocusEditor,
+        renderItem,
+        renderEmpty,
+        renderLoading,
+        renderGroupHeader,
+        listboxId
+      }
+    ) : null;
     return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(
       "div",
       {
         className,
         "data-mentions-input": "",
         "data-disabled": disabled ? "" : void 0,
-        ...comboboxAttrs(isExpanded, LISTBOX_ID2),
+        ...comboboxAttrs(isExpanded, listboxId),
         "aria-activedescendant": isExpanded && uiState.items[uiState.activeIndex] ? `mention-option-${uiState.items[uiState.activeIndex].id}` : void 0,
         children: [
-          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react6.EditorContent, { editor }),
-          isExpanded && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
-            SuggestionList,
-            {
-              items: uiState.items,
-              activeIndex: uiState.activeIndex,
-              breadcrumbs: uiState.breadcrumbs,
-              loading: uiState.loading,
-              trigger: uiState.trigger,
-              clientRect: uiState.clientRect,
-              onSelect: (item) => actions.select(item),
-              onHover: handleHover,
-              onGoBack: actions.goBack,
-              onSearchNested: actions.searchNested,
-              onNavigateUp: actions.navigateUp,
-              onNavigateDown: actions.navigateDown,
-              onClose: actions.close,
-              renderItem
-            }
-          )
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { style: editorStyle, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react6.EditorContent, { editor }) }),
+          portalContainer ? suggestionList && (0, import_react_dom.createPortal)(suggestionList, portalContainer) : suggestionList
         ]
       }
     );