mentionize 0.0.6 → 0.0.7

package/dist/cjs/index.js

@@ -1,51 +1,962 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-function __accessProp(key) {
-  return this[key];
-}
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __moduleCache = /* @__PURE__ */ new WeakMap;
 var __toCommonJS = (from) => {
-  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  var entry = __moduleCache.get(from), desc;
   if (entry)
     return entry;
   entry = __defProp({}, "__esModule", { value: true });
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (var key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(entry, key))
-        __defProp(entry, key, {
-          get: __accessProp.bind(from, key),
-          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-        });
-  }
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
   __moduleCache.set(from, entry);
   return entry;
 };
-var __moduleCache;
-var __returnValue = (v) => v;
-function __exportSetter(name, newValue) {
-  this[name] = __returnValue.bind(null, newValue);
-}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: __exportSetter.bind(all, name)
+      set: (newValue) => all[name] = () => newValue
     });
 };
 
 // src/index.ts
 var exports_src = {};
 __export(exports_src, {
-  useMentionEngine: () => import_useMentionEngine.useMentionEngine,
-  useCaretPosition: () => import_useCaretPosition.useCaretPosition,
-  MentionInput: () => import_MentionInput.MentionInput,
-  MentionHighlighter: () => import_MentionHighlighter.MentionHighlighter,
-  MentionDropdown: () => import_MentionDropdown.MentionDropdown
+  useMentionEngine: () => useMentionEngine,
+  useCaretPosition: () => useCaretPosition,
+  MentionInput: () => MentionInput,
+  MentionHighlighter: () => MentionHighlighter,
+  MentionDropdown: () => MentionDropdown
 });
 module.exports = __toCommonJS(exports_src);
 
-//# debugId=00144F398F840CEA64756E2164756E21
+// src/MentionInput.tsx
+var import_react5 = require("react");
+
+// src/MentionDropdown.tsx
+var import_react = require("react");
+var jsx_dev_runtime = require("react/jsx-dev-runtime");
+var MentionDropdown = ({
+  items,
+  trigger,
+  highlightedIndex,
+  onHighlight,
+  onSelect,
+  onLoadMore,
+  loading,
+  loadingContent,
+  position,
+  width,
+  className,
+  positionStrategy = "fixed",
+  containerEl
+}) => {
+  const listRef = import_react.useRef(null);
+  const sentinelRef = import_react.useRef(null);
+  import_react.useEffect(() => {
+    if (!onLoadMore || !sentinelRef.current)
+      return;
+    const sentinel = sentinelRef.current;
+    const observer = new IntersectionObserver((entries) => {
+      if (entries[0]?.isIntersecting) {
+        onLoadMore();
+      }
+    }, { root: listRef.current, threshold: 0.1 });
+    observer.observe(sentinel);
+    return () => observer.disconnect();
+  }, [onLoadMore]);
+  import_react.useEffect(() => {
+    const container = listRef.current;
+    if (!container)
+      return;
+    const highlighted = container.querySelector(`[data-mentionize-option-index="${highlightedIndex}"]`);
+    if (highlighted) {
+      highlighted.scrollIntoView({ block: "nearest" });
+    }
+  }, [highlightedIndex]);
+  const maxHeight = 240;
+  const gap = 4;
+  const spaceBelow = window.innerHeight - position.top - gap;
+  const flipAbove = spaceBelow < maxHeight && position.top > maxHeight;
+  let style;
+  if (positionStrategy === "absolute" && containerEl) {
+    const rect = containerEl.getBoundingClientRect();
+    const relLeft = position.left - rect.left;
+    const relTop = flipAbove ? position.top - gap - maxHeight - rect.top : position.top + gap - rect.top;
+    style = {
+      position: "absolute",
+      width,
+      maxHeight,
+      overflowY: "auto",
+      zIndex: 50,
+      top: relTop,
+      left: relLeft
+    };
+  } else {
+    style = {
+      position: "fixed",
+      width,
+      maxHeight,
+      overflowY: "auto",
+      zIndex: 50,
+      ...flipAbove ? { bottom: window.innerHeight - position.top + gap, left: position.left } : { top: position.top + gap, left: position.left }
+    };
+  }
+  const handleMouseDown = import_react.useCallback((e) => {
+    e.preventDefault();
+  }, []);
+  if (!items.length && !loading)
+    return null;
+  return /* @__PURE__ */ jsx_dev_runtime.jsxDEV("div", {
+    ref: listRef,
+    role: "listbox",
+    className,
+    style,
+    "data-mentionize-dropdown": "",
+    onMouseDown: handleMouseDown,
+    children: [
+      items.map((item, i) => {
+        const isHighlighted = i === highlightedIndex;
+        const optCls = typeof trigger.optionClassName === "function" ? trigger.optionClassName(item) : trigger.optionClassName;
+        if (trigger.renderOption) {
+          return /* @__PURE__ */ jsx_dev_runtime.jsxDEV("div", {
+            role: "option",
+            "aria-selected": isHighlighted,
+            className: optCls,
+            "data-mentionize-option-index": i,
+            "data-mentionize-option-highlighted": isHighlighted || undefined,
+            onMouseEnter: () => onHighlight(i),
+            onClick: () => onSelect(item),
+            children: trigger.renderOption(item, isHighlighted)
+          }, i, false, undefined, this);
+        }
+        return /* @__PURE__ */ jsx_dev_runtime.jsxDEV("div", {
+          role: "option",
+          "aria-selected": isHighlighted,
+          className: optCls,
+          "data-mentionize-option-index": i,
+          "data-mentionize-option": "",
+          "data-mentionize-option-highlighted": isHighlighted || undefined,
+          onMouseEnter: () => onHighlight(i),
+          onClick: () => onSelect(item),
+          children: trigger.displayText(item)
+        }, i, false, undefined, this);
+      }),
+      loading && /* @__PURE__ */ jsx_dev_runtime.jsxDEV("div", {
+        "data-mentionize-loading": "",
+        children: loadingContent ?? "Loading..."
+      }, undefined, false, undefined, this),
+      onLoadMore && !loading && /* @__PURE__ */ jsx_dev_runtime.jsxDEV("div", {
+        ref: sentinelRef,
+        style: { height: 1 },
+        "aria-hidden": true
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+};
+
+// src/MentionHighlighter.tsx
+var import_react2 = __toESM(require("react"));
+function textToNodes(text) {
+  const parts = text.split(`
+`);
+  const nodes = [];
+  for (let i = 0;i < parts.length; i++) {
+    if (i > 0)
+      nodes.push(import_react2.default.createElement("br", { key: `br-${i}` }));
+    if (parts[i])
+      nodes.push(parts[i]);
+  }
+  return nodes;
+}
+var MentionHighlighter = ({
+  visible,
+  mentions,
+  triggers,
+  textareaRef,
+  getItemForMention,
+  className,
+  style
+}) => {
+  const ref = import_react2.useRef(null);
+  import_react2.useEffect(() => {
+    const textarea = textareaRef.current;
+    const highlighter = ref.current;
+    if (!textarea || !highlighter)
+      return;
+    const onScroll = () => {
+      highlighter.scrollTop = textarea.scrollTop;
+      highlighter.scrollLeft = textarea.scrollLeft;
+    };
+    textarea.addEventListener("scroll", onScroll);
+    return () => textarea.removeEventListener("scroll", onScroll);
+  }, [textareaRef]);
+  const children = import_react2.useMemo(() => {
+    const sorted = mentions.slice().sort((a, b) => a.start - b.start);
+    if (!sorted.length)
+      return textToNodes(visible);
+    const triggerMap = new Map;
+    for (const t of triggers) {
+      triggerMap.set(t.trigger, t);
+    }
+    const nodes = [];
+    let last = 0;
+    for (let i = 0;i < sorted.length; i++) {
+      const m = sorted[i];
+      if (last < m.start) {
+        nodes.push(...textToNodes(visible.slice(last, m.start)));
+      }
+      const mentionText = visible.slice(m.start, m.end);
+      const t = triggerMap.get(m.trigger);
+      let cls = "mentionize-mention";
+      if (t) {
+        if (typeof t.mentionClassName === "function") {
+          const item = getItemForMention?.(m.trigger, m.key) ?? null;
+          cls = t.mentionClassName({
+            key: m.key,
+            displayText: m.displayText,
+            trigger: m.trigger,
+            item
+          });
+        } else if (t.mentionClassName) {
+          cls = t.mentionClassName;
+        }
+      }
+      nodes.push(import_react2.default.createElement("span", {
+        key: `mention-${i}`,
+        className: cls,
+        "data-mentionize-trigger": m.trigger,
+        "data-mentionize-key": m.key
+      }, mentionText));
+      last = m.end;
+    }
+    if (last < visible.length) {
+      nodes.push(...textToNodes(visible.slice(last)));
+    }
+    return nodes;
+  }, [visible, mentions, triggers, getItemForMention]);
+  import_react2.useLayoutEffect(() => {
+    const el = ref.current;
+    if (!el)
+      return;
+    const spans = el.querySelectorAll("[data-mentionize-trigger]");
+    for (let i = 0;i < spans.length; i++) {
+      const span = spans[i];
+      span.style.marginLeft = "";
+      span.style.marginRight = "";
+      const cs = getComputedStyle(span);
+      const extraLeft = parseFloat(cs.paddingLeft) + parseFloat(cs.borderLeftWidth) + parseFloat(cs.marginLeft);
+      const extraRight = parseFloat(cs.paddingRight) + parseFloat(cs.borderRightWidth) + parseFloat(cs.marginRight);
+      if (extraLeft)
+        span.style.marginLeft = `${-extraLeft}px`;
+      if (extraRight)
+        span.style.marginRight = `${-extraRight}px`;
+    }
+  });
+  return import_react2.default.createElement("div", {
+    ref,
+    className,
+    style: {
+      position: "absolute",
+      inset: 0,
+      pointerEvents: "none",
+      overflow: "auto",
+      ...style
+    },
+    "aria-hidden": true,
+    "data-mentionize-highlighter": ""
+  }, ...children);
+};
+
+// src/useCaretPosition.ts
+var import_react3 = require("react");
+var SHARED_STYLE_PROPS = [
+  "whiteSpace",
+  "overflowWrap",
+  "wordBreak",
+  "padding",
+  "paddingTop",
+  "paddingRight",
+  "paddingBottom",
+  "paddingLeft",
+  "fontFamily",
+  "fontSize",
+  "fontWeight",
+  "lineHeight",
+  "letterSpacing",
+  "tabSize",
+  "boxSizing",
+  "borderWidth",
+  "borderStyle"
+];
+function useCaretPosition(dropdownWidth) {
+  const mirrorRef = import_react3.useRef(null);
+  const getCaretPosition = import_react3.useCallback((textarea, caretIndex, textOverride) => {
+    const mirror = mirrorRef.current;
+    if (!mirror)
+      return null;
+    const caret = caretIndex ?? textarea.selectionStart;
+    const source = textOverride ?? textarea.value;
+    const before = source.slice(0, caret);
+    const computed = getComputedStyle(textarea);
+    for (const prop of SHARED_STYLE_PROPS) {
+      mirror.style[prop] = computed[prop];
+    }
+    mirror.style.width = `${textarea.offsetWidth}px`;
+    mirror.textContent = before;
+    const span = document.createElement("span");
+    span.textContent = "​";
+    mirror.appendChild(span);
+    mirror.scrollTop = textarea.scrollTop;
+    const spanRect = span.getBoundingClientRect();
+    const mirrorRect = mirror.getBoundingClientRect();
+    const textareaRect = textarea.getBoundingClientRect();
+    const top = textareaRect.top + (spanRect.top - mirrorRect.top) - textarea.scrollTop + span.offsetHeight;
+    let left = textareaRect.left + (spanRect.left - mirrorRect.left);
+    if (left + dropdownWidth > window.innerWidth - 8) {
+      left = window.innerWidth - dropdownWidth - 8;
+    }
+    if (left < 8)
+      left = 8;
+    mirror.innerHTML = "";
+    return {
+      top: Math.min(Math.max(top, 8), window.innerHeight - 8),
+      left
+    };
+  }, [dropdownWidth]);
+  return { mirrorRef, getCaretPosition };
+}
+
+// src/useMentionEngine.ts
+var import_react4 = require("react");
+
+// src/utils.ts
+function escapeRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/useMentionEngine.ts
+function detectMentionsInText(visibleText, triggers, getCache) {
+  const all = [];
+  for (const t of triggers) {
+    const triggerChar = t.trigger;
+    if (!visibleText.includes(triggerChar))
+      continue;
+    const cache = getCache(triggerChar);
+    const knownItems = [];
+    if (t.options) {
+      for (const item of t.options) {
+        knownItems.push({
+          displayText: t.displayText(item),
+          key: getItemKey(t, item),
+          item
+        });
+      }
+    }
+    for (const [key, item] of cache.entries()) {
+      if (item !== null) {
+        const dt = t.displayText(item);
+        if (!knownItems.some((k) => k.key === key)) {
+          knownItems.push({ displayText: dt, key, item });
+        }
+      }
+    }
+    if (!knownItems.length)
+      continue;
+    const compiled = knownItems.map((ki) => {
+      const pat = "^" + escapeRegex(ki.displayText).replace(/\s+/g, "\\s+");
+      return { ...ki, re: new RegExp(pat, "i") };
+    });
+    const positions = [];
+    let idx = visibleText.indexOf(triggerChar);
+    while (idx !== -1) {
+      positions.push(idx);
+      idx = visibleText.indexOf(triggerChar, idx + 1);
+    }
+    const candidates = [];
+    for (const pos of positions) {
+      const after = visibleText.slice(pos + triggerChar.length);
+      for (const c of compiled) {
+        const match = c.re.exec(after);
+        if (!match)
+          continue;
+        const matched = match[0];
+        const end = pos + triggerChar.length + matched.length;
+        const next = visibleText[end];
+        if (next && !/[\s,.:;!?)}\]]/.test(next))
+          continue;
+        candidates.push({
+          trigger: triggerChar,
+          displayText: matched,
+          key: c.key,
+          start: pos,
+          end
+        });
+      }
+    }
+    candidates.sort((a, b) => a.start !== b.start ? a.start - b.start : b.end - b.start - (a.end - a.start));
+    for (const c of candidates) {
+      const overlaps = all.some((f) => Math.max(f.start, c.start) < Math.min(f.end, c.end));
+      if (!overlaps)
+        all.push(c);
+    }
+  }
+  return all;
+}
+function mentionsEqual(a, b) {
+  if (a.length !== b.length)
+    return false;
+  for (let i = 0;i < a.length; i++) {
+    const ai = a[i];
+    const bi = b[i];
+    if (ai.start !== bi.start || ai.end !== bi.end || ai.key !== bi.key)
+      return false;
+  }
+  return true;
+}
+function useMentionEngine(options) {
+  const {
+    triggers,
+    value: controlledValue,
+    defaultValue,
+    onChange,
+    onMentionsChange
+  } = options;
+  const lastRawRef = import_react4.useRef(controlledValue ?? defaultValue ?? "");
+  const suppressEmitRef = import_react4.useRef(false);
+  const caretPosRef = import_react4.useRef(null);
+  const prevMentionsRef = import_react4.useRef([]);
+  const cacheRef = import_react4.useRef(new Map);
+  function getCache(triggerChar) {
+    let map = cacheRef.current.get(triggerChar);
+    if (!map) {
+      map = new Map;
+      cacheRef.current.set(triggerChar, map);
+    }
+    return map;
+  }
+  import_react4.useEffect(() => {
+    for (const t of triggers) {
+      if (t.options) {
+        const cache = getCache(t.trigger);
+        for (const item of t.options) {
+          const serialized = t.serialize(item);
+          const re = new RegExp(t.pattern.source, t.pattern.flags.replace("g", ""));
+          const m = re.exec(serialized);
+          if (m) {
+            const { key } = t.parseMatch(m);
+            cache.set(key, item);
+          }
+        }
+      }
+    }
+  }, [triggers]);
+  const rawToVisible = import_react4.useCallback((raw) => {
+    let result = raw;
+    for (const t of triggers) {
+      const globalRe = new RegExp(t.pattern.source, t.pattern.flags.includes("g") ? t.pattern.flags : t.pattern.flags + "g");
+      const parts = [];
+      let lastIndex = 0;
+      let m;
+      globalRe.lastIndex = 0;
+      while ((m = globalRe.exec(result)) !== null) {
+        parts.push(result.slice(lastIndex, m.index));
+        const parsed = t.parseMatch(m);
+        const cache = getCache(t.trigger);
+        if (parsed.item !== undefined) {
+          if (!cache.has(parsed.key) || cache.get(parsed.key) === null) {
+            cache.set(parsed.key, parsed.item);
+          }
+        } else if (!cache.has(parsed.key)) {
+          cache.set(parsed.key, null);
+        }
+        parts.push(t.trigger + parsed.displayText);
+        lastIndex = m.index + m[0].length;
+        if (!t.pattern.flags.includes("g"))
+          break;
+      }
+      parts.push(result.slice(lastIndex));
+      result = parts.join("");
+    }
+    return result;
+  }, [triggers]);
+  const [visible, setVisible] = import_react4.useState(() => rawToVisible(controlledValue ?? defaultValue ?? ""));
+  const mentions = import_react4.useMemo(() => {
+    const newMentions = detectMentionsInText(visible, triggers, getCache);
+    if (mentionsEqual(prevMentionsRef.current, newMentions)) {
+      return prevMentionsRef.current;
+    }
+    prevMentionsRef.current = newMentions;
+    return newMentions;
+  }, [visible, triggers]);
+  const visibleToRaw = import_react4.useCallback((vis, mentionsList) => {
+    if (!mentionsList.length)
+      return vis;
+    const ordered = mentionsList.slice().sort((a, b) => a.start - b.start);
+    let raw = "";
+    let last = 0;
+    for (const m of ordered) {
+      raw += vis.slice(last, m.start);
+      const t = triggers.find((tr) => tr.trigger === m.trigger);
+      if (t) {
+        const cache = getCache(t.trigger);
+        const item = cache.get(m.key);
+        if (item !== null && item !== undefined) {
+          raw += t.serialize(item);
+        } else {
+          raw += vis.slice(m.start, m.end);
+        }
+      } else {
+        raw += vis.slice(m.start, m.end);
+      }
+      last = m.end;
+    }
+    raw += vis.slice(last);
+    return raw;
+  }, [triggers]);
+  const emitSync = import_react4.useCallback((newVisible) => {
+    const newMentions = detectMentionsInText(newVisible, triggers, getCache);
+    if (!mentionsEqual(prevMentionsRef.current, newMentions)) {
+      prevMentionsRef.current = newMentions;
+    }
+    const raw = visibleToRaw(newVisible, prevMentionsRef.current);
+    if (raw !== lastRawRef.current) {
+      lastRawRef.current = raw;
+      onChange?.(raw);
+    }
+    onMentionsChange?.(prevMentionsRef.current);
+  }, [triggers, visibleToRaw, onChange, onMentionsChange]);
+  import_react4.useEffect(() => {
+    if (controlledValue === undefined)
+      return;
+    if (controlledValue === lastRawRef.current)
+      return;
+    lastRawRef.current = controlledValue;
+    suppressEmitRef.current = true;
+    setVisible(rawToVisible(controlledValue));
+  }, [controlledValue, rawToVisible]);
+  const [activeTrigger, setActiveTrigger] = import_react4.useState(null);
+  const [searchState, setSearchState] = import_react4.useState({
+    items: [],
+    page: 0,
+    hasMore: false,
+    loading: false
+  });
+  const [highlightIndex, setHighlightIndex] = import_react4.useState(0);
+  const searchAbortRef = import_react4.useRef(null);
+  const detectActiveTrigger = import_react4.useCallback((text, caretPos) => {
+    const prefix = text.slice(0, caretPos);
+    for (const t of triggers) {
+      const triggerChar = t.trigger;
+      const re = new RegExp(escapeRegex(triggerChar) + "([^\\n" + escapeRegex(triggerChar) + "]*)$");
+      const match = re.exec(prefix);
+      if (match && match[1] !== undefined) {
+        const query = match[1];
+        if (/\s/.test(query))
+          continue;
+        return {
+          trigger: t,
+          query,
+          startPos: match.index
+        };
+      }
+    }
+    return null;
+  }, [triggers]);
+  const filteredOptions = import_react4.useMemo(() => {
+    if (!activeTrigger)
+      return [];
+    const t = activeTrigger.trigger;
+    const q = activeTrigger.query.toLowerCase();
+    if (t.onSearch) {
+      return searchState.items;
+    }
+    if (t.options) {
+      if (!q)
+        return t.options;
+      return t.options.filter((item) => t.displayText(item).toLowerCase().includes(q));
+    }
+    return [];
+  }, [activeTrigger, searchState.items]);
+  import_react4.useEffect(() => {
+    if (!activeTrigger?.trigger.onSearch)
+      return;
+    const t = activeTrigger.trigger;
+    const query = activeTrigger.query;
+    searchAbortRef.current?.abort();
+    const controller = new AbortController;
+    searchAbortRef.current = controller;
+    setSearchState((s) => ({ ...s, loading: true, page: 0 }));
+    const timer = setTimeout(async () => {
+      try {
+        const result = await t.onSearch(query, 0);
+        if (controller.signal.aborted)
+          return;
+        setSearchState({
+          items: result.items,
+          page: 0,
+          hasMore: result.hasMore,
+          loading: false
+        });
+      } catch {
+        if (controller.signal.aborted)
+          return;
+        setSearchState((s) => ({ ...s, loading: false }));
+      }
+    }, 150);
+    return () => {
+      clearTimeout(timer);
+      controller.abort();
+    };
+  }, [activeTrigger?.trigger, activeTrigger?.query]);
+  const loadMore = import_react4.useCallback(async () => {
+    if (!activeTrigger?.trigger.onSearch || searchState.loading || !searchState.hasMore)
+      return;
+    const t = activeTrigger.trigger;
+    const nextPage = searchState.page + 1;
+    setSearchState((s) => ({ ...s, loading: true }));
+    try {
+      const result = await t.onSearch(activeTrigger.query, nextPage);
+      setSearchState((s) => ({
+        items: [...s.items, ...result.items],
+        page: nextPage,
+        hasMore: result.hasMore,
+        loading: false
+      }));
+    } catch {
+      setSearchState((s) => ({ ...s, loading: false }));
+    }
+  }, [activeTrigger, searchState]);
+  const handleTextChange = import_react4.useCallback((newText, caretPos) => {
+    caretPosRef.current = caretPos;
+    setVisible(newText);
+    emitSync(newText);
+    const detected = detectActiveTrigger(newText, caretPos);
+    if (detected) {
+      setActiveTrigger(detected);
+      setHighlightIndex(0);
+    } else {
+      setActiveTrigger(null);
+    }
+  }, [detectActiveTrigger, emitSync]);
+  const getItemForMention = import_react4.useCallback((triggerChar, key) => {
+    const cache = getCache(triggerChar);
+    return cache.get(key) ?? null;
+  }, []);
+  const selectOption = import_react4.useCallback((item, textarea) => {
+    if (!activeTrigger)
+      return;
+    const t = activeTrigger.trigger;
+    if (t.onSelect) {
+      const before2 = visible.slice(0, activeTrigger.startPos);
+      const after2 = visible.slice(textarea.selectionStart);
+      const savedStartPos = activeTrigger.startPos;
+      setActiveTrigger(null);
+      const result = t.onSelect(item);
+      const applyResult = (value) => {
+        if (value !== null) {
+          const newVis2 = before2 + value + after2;
+          const pos2 = savedStartPos + value.length;
+          caretPosRef.current = pos2;
+          setVisible(newVis2);
+          emitSync(newVis2);
+        } else {
+          const newVis2 = before2 + after2;
+          caretPosRef.current = savedStartPos;
+          setVisible(newVis2);
+          emitSync(newVis2);
+        }
+      };
+      if (result instanceof Promise) {
+        result.then(applyResult);
+      } else {
+        applyResult(result);
+      }
+      return;
+    }
+    const cache = getCache(t.trigger);
+    const key = getItemKey(t, item);
+    cache.set(key, item);
+    const displayText = t.displayText(item);
+    const mentionText = t.trigger + displayText;
+    const before = visible.slice(0, activeTrigger.startPos);
+    const after = visible.slice(textarea.selectionStart);
+    const newVis = before + mentionText + " " + after;
+    const pos = before.length + mentionText.length + 1;
+    caretPosRef.current = pos;
+    setVisible(newVis);
+    emitSync(newVis);
+    setActiveTrigger(null);
+  }, [activeTrigger, visible, emitSync]);
+  const closeSuggestions = import_react4.useCallback(() => {
+    setActiveTrigger(null);
+    setSearchState({ items: [], page: 0, hasMore: false, loading: false });
+  }, []);
+  const handleKeyDown = import_react4.useCallback((e, textarea) => {
+    if (!activeTrigger)
+      return false;
+    const len = filteredOptions.length;
+    if (!len && !searchState.loading)
+      return false;
+    if (e.key === "ArrowDown") {
+      e.preventDefault();
+      const next = (highlightIndex + 1) % Math.max(len, 1);
+      setHighlightIndex(next);
+      if (len - 1 - next <= 3 && searchState.hasMore && !searchState.loading) {
+        loadMore();
+      }
+      return true;
+    }
+    if (e.key === "ArrowUp") {
+      e.preventDefault();
+      setHighlightIndex((highlightIndex - 1 + Math.max(len, 1)) % Math.max(len, 1));
+      return true;
+    }
+    if (e.key === "Enter") {
+      e.preventDefault();
+      const item = filteredOptions[highlightIndex];
+      if (item)
+        selectOption(item, textarea);
+      return true;
+    }
+    if (e.key === "Escape") {
+      e.preventDefault();
+      closeSuggestions();
+      return true;
+    }
+    return false;
+  }, [
+    activeTrigger,
+    filteredOptions,
+    highlightIndex,
+    searchState,
+    selectOption,
+    closeSuggestions,
+    loadMore
+  ]);
+  return {
+    visible,
+    setVisible,
+    mentions,
+    activeTrigger,
+    filteredOptions,
+    highlightIndex,
+    setHighlightIndex,
+    searchLoading: searchState.loading,
+    searchHasMore: searchState.hasMore,
+    handleTextChange,
+    handleKeyDown,
+    selectOption,
+    closeSuggestions,
+    loadMore,
+    rawToVisible,
+    visibleToRaw,
+    caretPosRef,
+    getItemForMention
+  };
+}
+function getItemKey(trigger, item) {
+  const serialized = trigger.serialize(item);
+  const re = new RegExp(trigger.pattern.source, trigger.pattern.flags.replace("g", ""));
+  const m = re.exec(serialized);
+  if (m) {
+    return trigger.parseMatch(m).key;
+  }
+  return serialized;
+}
+
+// src/MentionInput.tsx
+var jsx_dev_runtime2 = require("react/jsx-dev-runtime");
+var SHARED_STYLE = {
+  whiteSpace: "pre-wrap",
+  overflowWrap: "anywhere",
+  wordBreak: "break-word",
+  padding: "0.5rem 0.75rem",
+  fontFamily: "inherit",
+  fontSize: "inherit",
+  lineHeight: "inherit",
+  letterSpacing: "normal",
+  boxSizing: "border-box"
+};
+var MentionInput = import_react5.forwardRef(({
+  triggers,
+  value,
+  defaultValue,
+  onChange,
+  onMentionsChange,
+  placeholder,
+  disabled,
+  rows = 4,
+  className,
+  inputClassName,
+  highlighterClassName,
+  dropdownClassName,
+  dropdownWidth = 250,
+  loadingContent,
+  renderDropdown,
+  dropdownPositionStrategy = "fixed",
+  "aria-label": ariaLabel,
+  "aria-describedby": ariaDescribedBy
+}, ref) => {
+  const textareaRef = import_react5.useRef(null);
+  const containerRef = import_react5.useRef(null);
+  import_react5.useImperativeHandle(ref, () => textareaRef.current);
+  const engine = useMentionEngine({
+    triggers,
+    value,
+    defaultValue,
+    onChange,
+    onMentionsChange
+  });
+  import_react5.useLayoutEffect(() => {
+    const pos = engine.caretPosRef.current;
+    const ta = textareaRef.current;
+    if (pos !== null && ta && document.activeElement === ta) {
+      ta.setSelectionRange(pos, pos);
+      engine.caretPosRef.current = null;
+    }
+  });
+  const { mirrorRef, getCaretPosition } = useCaretPosition(dropdownWidth);
+  const [dropdownPos, setDropdownPos] = import_react5.useState(null);
+  import_react5.useEffect(() => {
+    if (engine.activeTrigger && textareaRef.current) {
+      requestAnimationFrame(() => {
+        const pos = getCaretPosition(textareaRef.current);
+        if (pos)
+          setDropdownPos(pos);
+      });
+    } else {
+      setDropdownPos(null);
+    }
+  }, [engine.activeTrigger, engine.visible, getCaretPosition]);
+  const handleChange = import_react5.useCallback((e) => {
+    engine.handleTextChange(e.target.value, e.target.selectionStart);
+  }, [engine.handleTextChange]);
+  const handleKeyDown = import_react5.useCallback((e) => {
+    if (textareaRef.current) {
+      engine.handleKeyDown(e, textareaRef.current);
+    }
+  }, [engine.handleKeyDown]);
+  const handlePaste = import_react5.useCallback((e) => {
+    const ta = textareaRef.current;
+    if (!ta)
+      return;
+    const txt = e.clipboardData.getData("text");
+    const start = ta.selectionStart;
+    const end = ta.selectionEnd;
+    const newText = engine.visible.slice(0, start) + txt + engine.visible.slice(end);
+    e.preventDefault();
+    engine.handleTextChange(newText, start + txt.length);
+  }, [engine.visible, engine.handleTextChange]);
+  const handleBlur = import_react5.useCallback(() => {
+    setTimeout(() => engine.closeSuggestions(), 150);
+  }, [engine.closeSuggestions]);
+  const handleSelect = import_react5.useCallback((item) => {
+    if (textareaRef.current) {
+      engine.selectOption(item, textareaRef.current);
+    }
+  }, [engine.selectOption]);
+  const showDropdown = engine.activeTrigger !== null && dropdownPos !== null;
+  return /* @__PURE__ */ jsx_dev_runtime2.jsxDEV("div", {
+    ref: containerRef,
+    className,
+    style: { position: "relative" },
+    "data-mentionize-container": "",
+    children: [
+      /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(MentionHighlighter, {
+        visible: engine.visible,
+        mentions: engine.mentions,
+        triggers,
+        textareaRef,
+        getItemForMention: engine.getItemForMention,
+        className: highlighterClassName,
+        style: SHARED_STYLE
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsx_dev_runtime2.jsxDEV("textarea", {
+        ref: textareaRef,
+        value: engine.visible,
+        onChange: handleChange,
+        onKeyDown: handleKeyDown,
+        onPaste: handlePaste,
+        onBlur: handleBlur,
+        rows,
+        placeholder,
+        disabled,
+        "aria-label": ariaLabel,
+        "aria-describedby": ariaDescribedBy,
+        "aria-autocomplete": "list",
+        "aria-expanded": showDropdown,
+        className: inputClassName,
+        style: {
+          ...SHARED_STYLE,
+          position: "relative",
+          width: "100%",
+          resize: "vertical",
+          background: "transparent",
+          color: "transparent",
+          caretColor: "CanvasText",
+          zIndex: 10
+        },
+        "data-mentionize-input": ""
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsx_dev_runtime2.jsxDEV("div", {
+        ref: mirrorRef,
+        "aria-hidden": true,
+        style: {
+          position: "absolute",
+          top: 0,
+          left: -9999,
+          visibility: "hidden",
+          ...SHARED_STYLE
+        },
+        "data-mentionize-mirror": ""
+      }, undefined, false, undefined, this),
+      showDropdown && engine.activeTrigger && (renderDropdown ? renderDropdown({
+        items: engine.filteredOptions,
+        highlightedIndex: engine.highlightIndex,
+        onSelect: handleSelect,
+        onHighlight: engine.setHighlightIndex,
+        loading: engine.searchLoading,
+        onLoadMore: engine.searchHasMore ? engine.loadMore : undefined
+      }) : /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(MentionDropdown, {
+        items: engine.filteredOptions,
+        trigger: engine.activeTrigger.trigger,
+        highlightedIndex: engine.highlightIndex,
+        onHighlight: engine.setHighlightIndex,
+        onSelect: handleSelect,
+        onLoadMore: engine.searchHasMore ? engine.loadMore : undefined,
+        loading: engine.searchLoading,
+        loadingContent,
+        position: dropdownPos,
+        width: dropdownWidth,
+        className: dropdownClassName,
+        positionStrategy: dropdownPositionStrategy,
+        containerEl: dropdownPositionStrategy === "absolute" ? containerRef.current : undefined
+      }, undefined, false, undefined, this))
+    ]
+  }, undefined, true, undefined, this);
+});
+MentionInput.displayName = "MentionInput";
+
+//# debugId=B75C97134089AEDC64756E2164756E21
 //# sourceMappingURL=index.js.map