@payloadcms/richtext-lexical 0.1.0-beta.0

package/dist/field/lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/LexicalMenu.js

@@ -0,0 +1,457 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    PUNCTUATION: function() {
+        return PUNCTUATION;
+    },
+    SlashMenuGroup: function() {
+        return SlashMenuGroup;
+    },
+    SlashMenuOption: function() {
+        return SlashMenuOption;
+    },
+    getScrollParent: function() {
+        return getScrollParent;
+    },
+    useDynamicPositioning: function() {
+        return useDynamicPositioning;
+    },
+    SCROLL_TYPEAHEAD_OPTION_INTO_VIEW_COMMAND: function() {
+        return SCROLL_TYPEAHEAD_OPTION_INTO_VIEW_COMMAND;
+    },
+    LexicalMenu: function() {
+        return LexicalMenu;
+    },
+    useMenuAnchorRef: function() {
+        return useMenuAnchorRef;
+    }
+});
+const _LexicalComposerContext = require("@lexical/react/LexicalComposerContext");
+const _utils = require("@lexical/utils");
+const _lexical = require("lexical");
+const _react = require("react");
+const PUNCTUATION = '\\.,\\+\\*\\?\\$\\@\\|#{}\\(\\)\\^\\-\\[\\]\\\\/!%\'"~=<>_:;';
+class SlashMenuGroup {
+    options;
+    title;
+}
+class SlashMenuOption {
+    Icon;
+    // Icon for display
+    key;
+    // TBD
+    keyboardShortcut;
+    // For extra searching.
+    keywords;
+    // What happens when you select this option?
+    onSelect;
+    ref;
+    // What shows up in the editor
+    title;
+    constructor(title, options){
+        this.key = title;
+        this.ref = {
+            current: null
+        };
+        this.setRefElement = this.setRefElement.bind(this);
+        this.title = title;
+        this.keywords = options.keywords || [];
+        this.Icon = options.Icon;
+        this.keyboardShortcut = options.keyboardShortcut;
+        this.onSelect = options.onSelect.bind(this);
+    }
+    setRefElement(element) {
+        this.ref = {
+            current: element
+        };
+    }
+}
+const scrollIntoViewIfNeeded = (target)=>{
+    const typeaheadContainerNode = document.getElementById('typeahead-menu');
+    if (!typeaheadContainerNode) return;
+    const typeaheadRect = typeaheadContainerNode.getBoundingClientRect();
+    if (typeaheadRect.top + typeaheadRect.height > window.innerHeight) {
+        typeaheadContainerNode.scrollIntoView({
+            block: 'center'
+        });
+    }
+    if (typeaheadRect.top < 0) {
+        typeaheadContainerNode.scrollIntoView({
+            block: 'center'
+        });
+    }
+    target.scrollIntoView({
+        block: 'nearest'
+    });
+};
+/**
+ * Walk backwards along user input and forward through entity title to try
+ * and replace more of the user's text with entity.
+ */ function getFullMatchOffset(documentText, entryText, offset) {
+    let triggerOffset = offset;
+    for(let i = triggerOffset; i <= entryText.length; i++){
+        if (documentText.substr(-i) === entryText.substr(0, i)) {
+            triggerOffset = i;
+        }
+    }
+    return triggerOffset;
+}
+/**
+ * Split Lexical TextNode and return a new TextNode only containing matched text.
+ * Common use cases include: removing the node, replacing with a new node.
+ */ function $splitNodeContainingQuery(match) {
+    const selection = (0, _lexical.$getSelection)();
+    if (!(0, _lexical.$isRangeSelection)(selection) || !selection.isCollapsed()) {
+        return null;
+    }
+    const anchor = selection.anchor;
+    if (anchor.type !== 'text') {
+        return null;
+    }
+    const anchorNode = anchor.getNode();
+    if (!anchorNode.isSimpleText()) {
+        return null;
+    }
+    const selectionOffset = anchor.offset;
+    const textContent = anchorNode.getTextContent().slice(0, selectionOffset);
+    const characterOffset = match.replaceableString.length;
+    const queryOffset = getFullMatchOffset(textContent, match.matchingString, characterOffset);
+    const startOffset = selectionOffset - queryOffset;
+    if (startOffset < 0) {
+        return null;
+    }
+    let newNode;
+    if (startOffset === 0) {
+        [newNode] = anchorNode.splitText(selectionOffset);
+    } else {
+        [, newNode] = anchorNode.splitText(startOffset, selectionOffset);
+    }
+    return newNode;
+}
+function getScrollParent(element, includeHidden) {
+    let style = getComputedStyle(element);
+    const excludeStaticParent = style.position === 'absolute';
+    const overflowRegex = includeHidden ? /(auto|scroll|hidden)/ : /(auto|scroll)/;
+    if (style.position === 'fixed') {
+        return document.body;
+    }
+    for(let parent = element; parent = parent.parentElement;){
+        style = getComputedStyle(parent);
+        if (excludeStaticParent && style.position === 'static') {
+            continue;
+        }
+        if (overflowRegex.test(style.overflow + style.overflowY + style.overflowX)) {
+            return parent;
+        }
+    }
+    return document.body;
+}
+function isTriggerVisibleInNearestScrollContainer(targetElement, containerElement) {
+    const tRect = targetElement.getBoundingClientRect();
+    const cRect = containerElement.getBoundingClientRect();
+    return tRect.top > cRect.top && tRect.top < cRect.bottom;
+}
+function useDynamicPositioning(resolution, targetElement, onReposition, onVisibilityChange) {
+    const [editor] = (0, _LexicalComposerContext.useLexicalComposerContext)();
+    (0, _react.useEffect)(()=>{
+        if (targetElement != null && resolution != null) {
+            const rootElement = editor.getRootElement();
+            const rootScrollParent = rootElement != null ? getScrollParent(rootElement, false) : document.body;
+            let ticking = false;
+            let previousIsInView = isTriggerVisibleInNearestScrollContainer(targetElement, rootScrollParent);
+            const handleScroll = function() {
+                if (!ticking) {
+                    window.requestAnimationFrame(function() {
+                        onReposition();
+                        ticking = false;
+                    });
+                    ticking = true;
+                }
+                const isInView = isTriggerVisibleInNearestScrollContainer(targetElement, rootScrollParent);
+                if (isInView !== previousIsInView) {
+                    previousIsInView = isInView;
+                    if (onVisibilityChange != null) {
+                        onVisibilityChange(isInView);
+                    }
+                }
+            };
+            const resizeObserver = new ResizeObserver(onReposition);
+            window.addEventListener('resize', onReposition);
+            document.addEventListener('scroll', handleScroll, {
+                capture: true,
+                passive: true
+            });
+            resizeObserver.observe(targetElement);
+            return ()=>{
+                resizeObserver.unobserve(targetElement);
+                window.removeEventListener('resize', onReposition);
+                document.removeEventListener('scroll', handleScroll, true);
+            };
+        }
+    }, [
+        targetElement,
+        editor,
+        onVisibilityChange,
+        onReposition,
+        resolution
+    ]);
+}
+const SCROLL_TYPEAHEAD_OPTION_INTO_VIEW_COMMAND = (0, _lexical.createCommand)('SCROLL_TYPEAHEAD_OPTION_INTO_VIEW_COMMAND');
+function LexicalMenu({ anchorElementRef, close, editor, // groupsWithOptions filtering is already handled in SlashMenu/index.tsx. Thus, groupsWithOptions always contains the matching options.
+groupsWithOptions, menuRenderFn, onSelectOption, resolution, shouldSplitNodeWithQuery = false }) {
+    const [selectedOptionKey, setSelectedOptionKey] = (0, _react.useState)(null);
+    const matchingString = resolution.match && resolution.match.matchingString || '';
+    const updateSelectedOption = (0, _react.useCallback)((option)=>{
+        const rootElem = editor.getRootElement();
+        if (rootElem !== null) {
+            rootElem.setAttribute('aria-activedescendant', 'typeahead-item-' + option.key);
+            setSelectedOptionKey(option.key);
+        }
+    }, [
+        editor
+    ]);
+    const setSelectedOptionKeyToFirstMatchingOption = (0, _react.useCallback)(()=>{
+        // set selected option to the first of the matching ones
+        if (groupsWithOptions !== null && matchingString != null) {
+            // groupsWithOptions filtering is already handled in SlashMenu/index.tsx. Thus, groupsWithOptions always contains the matching options.
+            const allOptions = groupsWithOptions.flatMap((group)=>group.options);
+            if (allOptions.length) {
+                const firstMatchingOption = allOptions[0];
+                updateSelectedOption(firstMatchingOption);
+            }
+        }
+    }, [
+        groupsWithOptions,
+        updateSelectedOption,
+        matchingString
+    ]);
+    (0, _react.useEffect)(()=>{
+        setSelectedOptionKeyToFirstMatchingOption();
+    }, [
+        matchingString,
+        setSelectedOptionKeyToFirstMatchingOption
+    ]);
+    const selectOptionAndCleanUp = (0, _react.useCallback)((selectedOption)=>{
+        editor.update(()=>{
+            const textNodeContainingQuery = resolution.match != null && shouldSplitNodeWithQuery ? $splitNodeContainingQuery(resolution.match) : null;
+            onSelectOption(selectedOption, textNodeContainingQuery, close, resolution.match ? resolution.match.matchingString : '');
+        });
+    }, [
+        editor,
+        shouldSplitNodeWithQuery,
+        resolution.match,
+        onSelectOption,
+        close
+    ]);
+    (0, _react.useEffect)(()=>{
+        return ()=>{
+            const rootElem = editor.getRootElement();
+            if (rootElem !== null) {
+                rootElem.removeAttribute('aria-activedescendant');
+            }
+        };
+    }, [
+        editor
+    ]);
+    (0, _react.useLayoutEffect)(()=>{
+        if (groupsWithOptions === null) {
+            setSelectedOptionKey(null);
+        } else if (selectedOptionKey === null) {
+            setSelectedOptionKeyToFirstMatchingOption();
+        }
+    }, [
+        groupsWithOptions,
+        selectedOptionKey,
+        updateSelectedOption,
+        setSelectedOptionKeyToFirstMatchingOption
+    ]);
+    (0, _react.useEffect)(()=>{
+        return (0, _utils.mergeRegister)(editor.registerCommand(SCROLL_TYPEAHEAD_OPTION_INTO_VIEW_COMMAND, ({ option })=>{
+            if (option.ref && option.ref.current != null) {
+                scrollIntoViewIfNeeded(option.ref.current);
+                return true;
+            }
+            return false;
+        }, _lexical.COMMAND_PRIORITY_LOW));
+    }, [
+        editor,
+        updateSelectedOption
+    ]);
+    (0, _react.useEffect)(()=>{
+        return (0, _utils.mergeRegister)(editor.registerCommand(_lexical.KEY_ARROW_DOWN_COMMAND, (payload)=>{
+            const event = payload;
+            if (groupsWithOptions !== null && groupsWithOptions.length && selectedOptionKey !== null) {
+                const allOptions = groupsWithOptions.flatMap((group)=>group.options);
+                const selectedIndex = allOptions.findIndex((option)=>option.key === selectedOptionKey);
+                const newSelectedIndex = selectedIndex !== allOptions.length - 1 ? selectedIndex + 1 : 0;
+                const newSelectedOption = allOptions[newSelectedIndex];
+                updateSelectedOption(newSelectedOption);
+                if (newSelectedOption.ref != null && newSelectedOption.ref.current) {
+                    editor.dispatchCommand(SCROLL_TYPEAHEAD_OPTION_INTO_VIEW_COMMAND, {
+                        index: newSelectedIndex,
+                        option: newSelectedOption
+                    });
+                }
+                event.preventDefault();
+                event.stopImmediatePropagation();
+            }
+            return true;
+        }, _lexical.COMMAND_PRIORITY_LOW), editor.registerCommand(_lexical.KEY_ARROW_UP_COMMAND, (payload)=>{
+            const event = payload;
+            if (groupsWithOptions !== null && groupsWithOptions.length && selectedOptionKey !== null) {
+                const allOptions = groupsWithOptions.flatMap((group)=>group.options);
+                const selectedIndex = allOptions.findIndex((option)=>option.key === selectedOptionKey);
+                const newSelectedIndex = selectedIndex !== 0 ? selectedIndex - 1 : allOptions.length - 1;
+                const newSelectedOption = allOptions[newSelectedIndex];
+                updateSelectedOption(newSelectedOption);
+                if (newSelectedOption.ref != null && newSelectedOption.ref.current) {
+                    scrollIntoViewIfNeeded(newSelectedOption.ref.current);
+                }
+                event.preventDefault();
+                event.stopImmediatePropagation();
+            }
+            return true;
+        }, _lexical.COMMAND_PRIORITY_LOW), editor.registerCommand(_lexical.KEY_ESCAPE_COMMAND, (payload)=>{
+            const event = payload;
+            event.preventDefault();
+            event.stopImmediatePropagation();
+            close();
+            return true;
+        }, _lexical.COMMAND_PRIORITY_LOW), editor.registerCommand(_lexical.KEY_TAB_COMMAND, (payload)=>{
+            const event = payload;
+            if (groupsWithOptions === null || selectedOptionKey === null) {
+                return false;
+            }
+            const allOptions = groupsWithOptions.flatMap((group)=>group.options);
+            const selectedOption = allOptions.find((option)=>option.key === selectedOptionKey);
+            if (!selectedOption) {
+                return false;
+            }
+            event.preventDefault();
+            event.stopImmediatePropagation();
+            selectOptionAndCleanUp(selectedOption);
+            return true;
+        }, _lexical.COMMAND_PRIORITY_LOW), editor.registerCommand(_lexical.KEY_ENTER_COMMAND, (event)=>{
+            if (groupsWithOptions === null || selectedOptionKey === null) {
+                return false;
+            }
+            const allOptions = groupsWithOptions.flatMap((group)=>group.options);
+            const selectedOption = allOptions.find((option)=>option.key === selectedOptionKey);
+            if (!selectedOption) {
+                return false;
+            }
+            if (event !== null) {
+                event.preventDefault();
+                event.stopImmediatePropagation();
+            }
+            selectOptionAndCleanUp(selectedOption);
+            return true;
+        }, _lexical.COMMAND_PRIORITY_LOW));
+    }, [
+        selectOptionAndCleanUp,
+        close,
+        editor,
+        groupsWithOptions,
+        selectedOptionKey,
+        updateSelectedOption
+    ]);
+    const listItemProps = (0, _react.useMemo)(()=>({
+            groupsWithOptions,
+            selectOptionAndCleanUp,
+            selectedOptionKey,
+            setSelectedOptionKey
+        }), [
+        selectOptionAndCleanUp,
+        selectedOptionKey,
+        groupsWithOptions
+    ]);
+    return menuRenderFn(anchorElementRef, listItemProps, resolution.match ? resolution.match.matchingString : '');
+}
+function useMenuAnchorRef(resolution, setResolution, className) {
+    const [editor] = (0, _LexicalComposerContext.useLexicalComposerContext)();
+    const anchorElementRef = (0, _react.useRef)(document.createElement('div'));
+    const positionMenu = (0, _react.useCallback)(()=>{
+        const rootElement = editor.getRootElement();
+        const containerDiv = anchorElementRef.current;
+        const VERTICAL_OFFSET = 32;
+        const menuEle = containerDiv.firstChild;
+        if (rootElement !== null && resolution !== null) {
+            const { height, left, top, width } = resolution.getRect();
+            containerDiv.style.top = `${top + window.scrollY + VERTICAL_OFFSET}px`;
+            containerDiv.style.left = `${left + window.scrollX}px`;
+            containerDiv.style.height = `${height}px`;
+            containerDiv.style.width = `${width}px`;
+            if (menuEle !== null) {
+                const menuRect = menuEle.getBoundingClientRect();
+                const menuHeight = menuRect.height;
+                const menuWidth = menuRect.width;
+                const rootElementRect = rootElement.getBoundingClientRect();
+                if (left + menuWidth > rootElementRect.right) {
+                    containerDiv.style.left = `${rootElementRect.right - menuWidth + window.scrollX}px`;
+                }
+                const margin = 10;
+                if ((top + menuHeight > window.innerHeight || top + menuHeight > rootElementRect.bottom) && top - rootElementRect.top > menuHeight) {
+                    containerDiv.style.top = `${top + VERTICAL_OFFSET - menuHeight + window.scrollY - (height + margin)}px`;
+                }
+            }
+            if (!containerDiv.isConnected) {
+                if (className != null) {
+                    containerDiv.className = className;
+                }
+                containerDiv.setAttribute('aria-label', 'Typeahead menu');
+                containerDiv.setAttribute('id', 'typeahead-menu');
+                containerDiv.setAttribute('role', 'listbox');
+                containerDiv.style.display = 'block';
+                containerDiv.style.position = 'absolute';
+                document.body.append(containerDiv);
+            }
+            anchorElementRef.current = containerDiv;
+            rootElement.setAttribute('aria-controls', 'typeahead-menu');
+        }
+    }, [
+        editor,
+        resolution,
+        className
+    ]);
+    (0, _react.useEffect)(()=>{
+        const rootElement = editor.getRootElement();
+        if (resolution !== null) {
+            positionMenu();
+            return ()=>{
+                if (rootElement !== null) {
+                    rootElement.removeAttribute('aria-controls');
+                }
+                const containerDiv = anchorElementRef.current;
+                if (containerDiv !== null && containerDiv.isConnected) {
+                    containerDiv.remove();
+                }
+            };
+        }
+    }, [
+        editor,
+        positionMenu,
+        resolution
+    ]);
+    const onVisibilityChange = (0, _react.useCallback)((isInView)=>{
+        if (resolution !== null) {
+            if (!isInView) {
+                setResolution(null);
+            }
+        }
+    }, [
+        resolution,
+        setResolution
+    ]);
+    useDynamicPositioning(resolution, anchorElementRef.current, positionMenu, onVisibilityChange);
+    return anchorElementRef;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../../../src/field/lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/LexicalMenu.tsx"],"sourcesContent":["import type { LexicalCommand, LexicalEditor, TextNode } from 'lexical'\nimport type { MutableRefObject, ReactPortal } from 'react'\n\nimport { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext'\nimport { mergeRegister } from '@lexical/utils'\nimport {\n  $getSelection,\n  $isRangeSelection,\n  COMMAND_PRIORITY_LOW,\n  KEY_ARROW_DOWN_COMMAND,\n  KEY_ARROW_UP_COMMAND,\n  KEY_ENTER_COMMAND,\n  KEY_ESCAPE_COMMAND,\n  KEY_TAB_COMMAND,\n  createCommand,\n} from 'lexical'\nimport { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from 'react'\n\nexport type MenuTextMatch = {\n  leadOffset: number\n  matchingString: string\n  replaceableString: string\n}\n\nexport type MenuResolution = {\n  getRect: () => DOMRect\n  match?: MenuTextMatch\n}\n\nexport const PUNCTUATION = '\\\\.,\\\\+\\\\*\\\\?\\\\$\\\\@\\\\|#{}\\\\(\\\\)\\\\^\\\\-\\\\[\\\\]\\\\\\\\/!%\\'\"~=<>_:;'\n\nexport class SlashMenuGroup {\n  options: Array<SlashMenuOption>\n  title: string\n}\n\nexport class SlashMenuOption {\n  Icon: React.FC\n\n  // Icon for display\n  key: string\n  // TBD\n  keyboardShortcut?: string\n  // For extra searching.\n  keywords: Array<string>\n  // What happens when you select this option?\n  onSelect: ({ editor, queryString }: { editor: LexicalEditor; queryString: string }) => void\n  ref?: MutableRefObject<HTMLElement | null>\n\n  // What shows up in the editor\n  title: string\n\n  constructor(\n    title: string,\n    options: {\n      Icon: React.FC\n      keyboardShortcut?: string\n      keywords?: Array<string>\n      onSelect: ({ editor, queryString }: { editor: LexicalEditor; queryString: string }) => void\n    },\n  ) {\n    this.key = title\n    this.ref = { current: null }\n    this.setRefElement = this.setRefElement.bind(this)\n\n    this.title = title\n    this.keywords = options.keywords || []\n    this.Icon = options.Icon\n    this.keyboardShortcut = options.keyboardShortcut\n    this.onSelect = options.onSelect.bind(this)\n  }\n\n  setRefElement(element: HTMLElement | null) {\n    this.ref = { current: element }\n  }\n}\n\nexport type MenuRenderFn = (\n  anchorElementRef: MutableRefObject<HTMLElement | null>,\n  itemProps: {\n    groupsWithOptions: Array<SlashMenuGroup>\n    selectOptionAndCleanUp: (selectedOption: SlashMenuOption) => void\n    selectedOptionKey: null | string\n    setSelectedOptionKey: (optionKey: string) => void\n  },\n  matchingString: null | string,\n) => JSX.Element | ReactPortal | null\n\nconst scrollIntoViewIfNeeded = (target: HTMLElement) => {\n  const typeaheadContainerNode = document.getElementById('typeahead-menu')\n  if (!typeaheadContainerNode) return\n\n  const typeaheadRect = typeaheadContainerNode.getBoundingClientRect()\n\n  if (typeaheadRect.top + typeaheadRect.height > window.innerHeight) {\n    typeaheadContainerNode.scrollIntoView({\n      block: 'center',\n    })\n  }\n\n  if (typeaheadRect.top < 0) {\n    typeaheadContainerNode.scrollIntoView({\n      block: 'center',\n    })\n  }\n\n  target.scrollIntoView({ block: 'nearest' })\n}\n\n/**\n * Walk backwards along user input and forward through entity title to try\n * and replace more of the user's text with entity.\n */\nfunction getFullMatchOffset(documentText: string, entryText: string, offset: number): number {\n  let triggerOffset = offset\n  for (let i = triggerOffset; i <= entryText.length; i++) {\n    if (documentText.substr(-i) === entryText.substr(0, i)) {\n      triggerOffset = i\n    }\n  }\n  return triggerOffset\n}\n\n/**\n * Split Lexical TextNode and return a new TextNode only containing matched text.\n * Common use cases include: removing the node, replacing with a new node.\n */\nfunction $splitNodeContainingQuery(match: MenuTextMatch): TextNode | null {\n  const selection = $getSelection()\n  if (!$isRangeSelection(selection) || !selection.isCollapsed()) {\n    return null\n  }\n  const anchor = selection.anchor\n  if (anchor.type !== 'text') {\n    return null\n  }\n  const anchorNode = anchor.getNode()\n  if (!anchorNode.isSimpleText()) {\n    return null\n  }\n  const selectionOffset = anchor.offset\n  const textContent = anchorNode.getTextContent().slice(0, selectionOffset)\n  const characterOffset = match.replaceableString.length\n  const queryOffset = getFullMatchOffset(textContent, match.matchingString, characterOffset)\n  const startOffset = selectionOffset - queryOffset\n  if (startOffset < 0) {\n    return null\n  }\n  let newNode\n  if (startOffset === 0) {\n    ;[newNode] = anchorNode.splitText(selectionOffset)\n  } else {\n    ;[, newNode] = anchorNode.splitText(startOffset, selectionOffset)\n  }\n\n  return newNode\n}\n\n// Got from https://stackoverflow.com/a/42543908/2013580\nexport function getScrollParent(\n  element: HTMLElement,\n  includeHidden: boolean,\n): HTMLBodyElement | HTMLElement {\n  let style = getComputedStyle(element)\n  const excludeStaticParent = style.position === 'absolute'\n  const overflowRegex = includeHidden ? /(auto|scroll|hidden)/ : /(auto|scroll)/\n  if (style.position === 'fixed') {\n    return document.body\n  }\n  for (let parent: HTMLElement | null = element; (parent = parent.parentElement); ) {\n    style = getComputedStyle(parent)\n    if (excludeStaticParent && style.position === 'static') {\n      continue\n    }\n    if (overflowRegex.test(style.overflow + style.overflowY + style.overflowX)) {\n      return parent\n    }\n  }\n  return document.body\n}\n\nfunction isTriggerVisibleInNearestScrollContainer(\n  targetElement: HTMLElement,\n  containerElement: HTMLElement,\n): boolean {\n  const tRect = targetElement.getBoundingClientRect()\n  const cRect = containerElement.getBoundingClientRect()\n  return tRect.top > cRect.top && tRect.top < cRect.bottom\n}\n\n// Reposition the menu on scroll, window resize, and element resize.\nexport function useDynamicPositioning(\n  resolution: MenuResolution | null,\n  targetElement: HTMLElement | null,\n  onReposition: () => void,\n  onVisibilityChange?: (isInView: boolean) => void,\n) {\n  const [editor] = useLexicalComposerContext()\n  useEffect(() => {\n    if (targetElement != null && resolution != null) {\n      const rootElement = editor.getRootElement()\n      const rootScrollParent =\n        rootElement != null ? getScrollParent(rootElement, false) : document.body\n      let ticking = false\n      let previousIsInView = isTriggerVisibleInNearestScrollContainer(\n        targetElement,\n        rootScrollParent,\n      )\n      const handleScroll = function () {\n        if (!ticking) {\n          window.requestAnimationFrame(function () {\n            onReposition()\n            ticking = false\n          })\n          ticking = true\n        }\n        const isInView = isTriggerVisibleInNearestScrollContainer(targetElement, rootScrollParent)\n        if (isInView !== previousIsInView) {\n          previousIsInView = isInView\n          if (onVisibilityChange != null) {\n            onVisibilityChange(isInView)\n          }\n        }\n      }\n      const resizeObserver = new ResizeObserver(onReposition)\n      window.addEventListener('resize', onReposition)\n      document.addEventListener('scroll', handleScroll, {\n        capture: true,\n        passive: true,\n      })\n      resizeObserver.observe(targetElement)\n      return () => {\n        resizeObserver.unobserve(targetElement)\n        window.removeEventListener('resize', onReposition)\n        document.removeEventListener('scroll', handleScroll, true)\n      }\n    }\n  }, [targetElement, editor, onVisibilityChange, onReposition, resolution])\n}\n\nexport const SCROLL_TYPEAHEAD_OPTION_INTO_VIEW_COMMAND: LexicalCommand<{\n  index: number\n  option: SlashMenuOption\n}> = createCommand('SCROLL_TYPEAHEAD_OPTION_INTO_VIEW_COMMAND')\n\nexport function LexicalMenu({\n  anchorElementRef,\n  close,\n  editor,\n  // groupsWithOptions filtering is already handled in SlashMenu/index.tsx. Thus, groupsWithOptions always contains the matching options.\n  groupsWithOptions,\n  menuRenderFn,\n  onSelectOption,\n  resolution,\n  shouldSplitNodeWithQuery = false,\n}: {\n  anchorElementRef: MutableRefObject<HTMLElement>\n  close: () => void\n  editor: LexicalEditor\n  groupsWithOptions: Array<SlashMenuGroup>\n  menuRenderFn: MenuRenderFn\n  onSelectOption: (\n    option: SlashMenuOption,\n    textNodeContainingQuery: TextNode | null,\n    closeMenu: () => void,\n    matchingString: string,\n  ) => void\n  resolution: MenuResolution\n  shouldSplitNodeWithQuery?: boolean\n}): JSX.Element | null {\n  const [selectedOptionKey, setSelectedOptionKey] = useState<null | string>(null)\n\n  const matchingString = (resolution.match && resolution.match.matchingString) || ''\n\n  const updateSelectedOption = useCallback(\n    (option: SlashMenuOption) => {\n      const rootElem = editor.getRootElement()\n      if (rootElem !== null) {\n        rootElem.setAttribute('aria-activedescendant', 'typeahead-item-' + option.key)\n        setSelectedOptionKey(option.key)\n      }\n    },\n    [editor],\n  )\n\n  const setSelectedOptionKeyToFirstMatchingOption = useCallback(() => {\n    // set selected option to the first of the matching ones\n    if (groupsWithOptions !== null && matchingString != null) {\n      // groupsWithOptions filtering is already handled in SlashMenu/index.tsx. Thus, groupsWithOptions always contains the matching options.\n      const allOptions = groupsWithOptions.flatMap((group) => group.options)\n\n      if (allOptions.length) {\n        const firstMatchingOption = allOptions[0]\n        updateSelectedOption(firstMatchingOption)\n      }\n    }\n  }, [groupsWithOptions, updateSelectedOption, matchingString])\n\n  useEffect(() => {\n    setSelectedOptionKeyToFirstMatchingOption()\n  }, [matchingString, setSelectedOptionKeyToFirstMatchingOption])\n\n  const selectOptionAndCleanUp = useCallback(\n    (selectedOption: SlashMenuOption) => {\n      editor.update(() => {\n        const textNodeContainingQuery =\n          resolution.match != null && shouldSplitNodeWithQuery\n            ? $splitNodeContainingQuery(resolution.match)\n            : null\n\n        onSelectOption(\n          selectedOption,\n          textNodeContainingQuery,\n          close,\n          resolution.match ? resolution.match.matchingString : '',\n        )\n      })\n    },\n    [editor, shouldSplitNodeWithQuery, resolution.match, onSelectOption, close],\n  )\n\n  useEffect(() => {\n    return () => {\n      const rootElem = editor.getRootElement()\n      if (rootElem !== null) {\n        rootElem.removeAttribute('aria-activedescendant')\n      }\n    }\n  }, [editor])\n\n  useLayoutEffect(() => {\n    if (groupsWithOptions === null) {\n      setSelectedOptionKey(null)\n    } else if (selectedOptionKey === null) {\n      setSelectedOptionKeyToFirstMatchingOption()\n    }\n  }, [\n    groupsWithOptions,\n    selectedOptionKey,\n    updateSelectedOption,\n    setSelectedOptionKeyToFirstMatchingOption,\n  ])\n\n  useEffect(() => {\n    return mergeRegister(\n      editor.registerCommand(\n        SCROLL_TYPEAHEAD_OPTION_INTO_VIEW_COMMAND,\n        ({ option }) => {\n          if (option.ref && option.ref.current != null) {\n            scrollIntoViewIfNeeded(option.ref.current)\n            return true\n          }\n\n          return false\n        },\n        COMMAND_PRIORITY_LOW,\n      ),\n    )\n  }, [editor, updateSelectedOption])\n\n  useEffect(() => {\n    return mergeRegister(\n      editor.registerCommand<KeyboardEvent>(\n        KEY_ARROW_DOWN_COMMAND,\n        (payload) => {\n          const event = payload\n          if (\n            groupsWithOptions !== null &&\n            groupsWithOptions.length &&\n            selectedOptionKey !== null\n          ) {\n            const allOptions = groupsWithOptions.flatMap((group) => group.options)\n            const selectedIndex = allOptions.findIndex((option) => option.key === selectedOptionKey)\n\n            const newSelectedIndex = selectedIndex !== allOptions.length - 1 ? selectedIndex + 1 : 0\n\n            const newSelectedOption = allOptions[newSelectedIndex]\n\n            updateSelectedOption(newSelectedOption)\n            if (newSelectedOption.ref != null && newSelectedOption.ref.current) {\n              editor.dispatchCommand(SCROLL_TYPEAHEAD_OPTION_INTO_VIEW_COMMAND, {\n                index: newSelectedIndex,\n                option: newSelectedOption,\n              })\n            }\n            event.preventDefault()\n            event.stopImmediatePropagation()\n          }\n          return true\n        },\n        COMMAND_PRIORITY_LOW,\n      ),\n      editor.registerCommand<KeyboardEvent>(\n        KEY_ARROW_UP_COMMAND,\n        (payload) => {\n          const event = payload\n          if (\n            groupsWithOptions !== null &&\n            groupsWithOptions.length &&\n            selectedOptionKey !== null\n          ) {\n            const allOptions = groupsWithOptions.flatMap((group) => group.options)\n            const selectedIndex = allOptions.findIndex((option) => option.key === selectedOptionKey)\n\n            const newSelectedIndex = selectedIndex !== 0 ? selectedIndex - 1 : allOptions.length - 1\n\n            const newSelectedOption = allOptions[newSelectedIndex]\n\n            updateSelectedOption(newSelectedOption)\n            if (newSelectedOption.ref != null && newSelectedOption.ref.current) {\n              scrollIntoViewIfNeeded(newSelectedOption.ref.current)\n            }\n            event.preventDefault()\n            event.stopImmediatePropagation()\n          }\n          return true\n        },\n        COMMAND_PRIORITY_LOW,\n      ),\n      editor.registerCommand<KeyboardEvent>(\n        KEY_ESCAPE_COMMAND,\n        (payload) => {\n          const event = payload\n          event.preventDefault()\n          event.stopImmediatePropagation()\n          close()\n          return true\n        },\n        COMMAND_PRIORITY_LOW,\n      ),\n      editor.registerCommand<KeyboardEvent>(\n        KEY_TAB_COMMAND,\n        (payload) => {\n          const event = payload\n\n          if (groupsWithOptions === null || selectedOptionKey === null) {\n            return false\n          }\n          const allOptions = groupsWithOptions.flatMap((group) => group.options)\n          const selectedOption = allOptions.find((option) => option.key === selectedOptionKey)\n          if (!selectedOption) {\n            return false\n          }\n\n          event.preventDefault()\n          event.stopImmediatePropagation()\n          selectOptionAndCleanUp(selectedOption)\n          return true\n        },\n        COMMAND_PRIORITY_LOW,\n      ),\n      editor.registerCommand(\n        KEY_ENTER_COMMAND,\n        (event: KeyboardEvent | null) => {\n          if (groupsWithOptions === null || selectedOptionKey === null) {\n            return false\n          }\n          const allOptions = groupsWithOptions.flatMap((group) => group.options)\n          const selectedOption = allOptions.find((option) => option.key === selectedOptionKey)\n          if (!selectedOption) {\n            return false\n          }\n\n          if (event !== null) {\n            event.preventDefault()\n            event.stopImmediatePropagation()\n          }\n          selectOptionAndCleanUp(selectedOption)\n          return true\n        },\n        COMMAND_PRIORITY_LOW,\n      ),\n    )\n  }, [\n    selectOptionAndCleanUp,\n    close,\n    editor,\n    groupsWithOptions,\n    selectedOptionKey,\n    updateSelectedOption,\n  ])\n\n  const listItemProps = useMemo(\n    () => ({\n      groupsWithOptions,\n      selectOptionAndCleanUp,\n      selectedOptionKey,\n      setSelectedOptionKey,\n    }),\n    [selectOptionAndCleanUp, selectedOptionKey, groupsWithOptions],\n  )\n\n  return menuRenderFn(\n    anchorElementRef,\n    listItemProps,\n    resolution.match ? resolution.match.matchingString : '',\n  )\n}\n\nexport function useMenuAnchorRef(\n  resolution: MenuResolution | null,\n  setResolution: (r: MenuResolution | null) => void,\n  className?: string,\n): MutableRefObject<HTMLElement> {\n  const [editor] = useLexicalComposerContext()\n  const anchorElementRef = useRef<HTMLElement>(document.createElement('div'))\n  const positionMenu = useCallback(() => {\n    const rootElement = editor.getRootElement()\n    const containerDiv = anchorElementRef.current\n\n    const VERTICAL_OFFSET = 32 as const\n\n    const menuEle = containerDiv.firstChild as Element\n    if (rootElement !== null && resolution !== null) {\n      const { height, left, top, width } = resolution.getRect()\n      containerDiv.style.top = `${top + window.scrollY + VERTICAL_OFFSET}px`\n      containerDiv.style.left = `${left + window.scrollX}px`\n      containerDiv.style.height = `${height}px`\n      containerDiv.style.width = `${width}px`\n      if (menuEle !== null) {\n        const menuRect = menuEle.getBoundingClientRect()\n        const menuHeight = menuRect.height\n        const menuWidth = menuRect.width\n\n        const rootElementRect = rootElement.getBoundingClientRect()\n\n        if (left + menuWidth > rootElementRect.right) {\n          containerDiv.style.left = `${rootElementRect.right - menuWidth + window.scrollX}px`\n        }\n        const margin = 10\n        if (\n          (top + menuHeight > window.innerHeight || top + menuHeight > rootElementRect.bottom) &&\n          top - rootElementRect.top > menuHeight\n        ) {\n          containerDiv.style.top = `${\n            top + VERTICAL_OFFSET - menuHeight + window.scrollY - (height + margin)\n          }px`\n        }\n      }\n\n      if (!containerDiv.isConnected) {\n        if (className != null) {\n          containerDiv.className = className\n        }\n        containerDiv.setAttribute('aria-label', 'Typeahead menu')\n        containerDiv.setAttribute('id', 'typeahead-menu')\n        containerDiv.setAttribute('role', 'listbox')\n        containerDiv.style.display = 'block'\n        containerDiv.style.position = 'absolute'\n        document.body.append(containerDiv)\n      }\n      anchorElementRef.current = containerDiv\n      rootElement.setAttribute('aria-controls', 'typeahead-menu')\n    }\n  }, [editor, resolution, className])\n\n  useEffect(() => {\n    const rootElement = editor.getRootElement()\n    if (resolution !== null) {\n      positionMenu()\n      return () => {\n        if (rootElement !== null) {\n          rootElement.removeAttribute('aria-controls')\n        }\n\n        const containerDiv = anchorElementRef.current\n        if (containerDiv !== null && containerDiv.isConnected) {\n          containerDiv.remove()\n        }\n      }\n    }\n  }, [editor, positionMenu, resolution])\n\n  const onVisibilityChange = useCallback(\n    (isInView: boolean) => {\n      if (resolution !== null) {\n        if (!isInView) {\n          setResolution(null)\n        }\n      }\n    },\n    [resolution, setResolution],\n  )\n\n  useDynamicPositioning(resolution, anchorElementRef.current, positionMenu, onVisibilityChange)\n\n  return anchorElementRef\n}\n\nexport type TriggerFn = (text: string, editor: LexicalEditor) => MenuTextMatch | null\n"],"names":["PUNCTUATION","SlashMenuGroup","SlashMenuOption","getScrollParent","useDynamicPositioning","SCROLL_TYPEAHEAD_OPTION_INTO_VIEW_COMMAND","LexicalMenu","useMenuAnchorRef","options","title","Icon","key","keyboardShortcut","keywords","onSelect","ref","constructor","current","setRefElement","bind","element","scrollIntoViewIfNeeded","target","typeaheadContainerNode","document","getElementById","typeaheadRect","getBoundingClientRect","top","height","window","innerHeight","scrollIntoView","block","getFullMatchOffset","documentText","entryText","offset","triggerOffset","i","length","substr","$splitNodeContainingQuery","match","selection","$getSelection","$isRangeSelection","isCollapsed","anchor","type","anchorNode","getNode","isSimpleText","selectionOffset","textContent","getTextContent","slice","characterOffset","replaceableString","queryOffset","matchingString","startOffset","newNode","splitText","includeHidden","style","getComputedStyle","excludeStaticParent","position","overflowRegex","body","parent","parentElement","test","overflow","overflowY","overflowX","isTriggerVisibleInNearestScrollContainer","targetElement","containerElement","tRect","cRect","bottom","resolution","onReposition","onVisibilityChange","editor","useLexicalComposerContext","useEffect","rootElement","getRootElement","rootScrollParent","ticking","previousIsInView","handleScroll","requestAnimationFrame","isInView","resizeObserver","ResizeObserver","addEventListener","capture","passive","observe","unobserve","removeEventListener","createCommand","anchorElementRef","close","groupsWithOptions","menuRenderFn","onSelectOption","shouldSplitNodeWithQuery","selectedOptionKey","setSelectedOptionKey","useState","updateSelectedOption","useCallback","option","rootElem","setAttribute","setSelectedOptionKeyToFirstMatchingOption","allOptions","flatMap","group","firstMatchingOption","selectOptionAndCleanUp","selectedOption","update","textNodeContainingQuery","removeAttribute","useLayoutEffect","mergeRegister","registerCommand","COMMAND_PRIORITY_LOW","KEY_ARROW_DOWN_COMMAND","payload","event","selectedIndex","findIndex","newSelectedIndex","newSelectedOption","dispatchCommand","index","preventDefault","stopImmediatePropagation","KEY_ARROW_UP_COMMAND","KEY_ESCAPE_COMMAND","KEY_TAB_COMMAND","find","KEY_ENTER_COMMAND","listItemProps","useMemo","setResolution","className","useRef","createElement","positionMenu","containerDiv","VERTICAL_OFFSET","menuEle","firstChild","left","width","getRect","scrollY","scrollX","menuRect","menuHeight","menuWidth","rootElementRect","right","margin","isConnected","display","append","remove"],"mappings":"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"}

package/dist/field/lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/index.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="react" />
+import type { LexicalCommand, TextNode } from 'lexical';
+import type { MenuRenderFn, MenuResolution, MenuTextMatch, SlashMenuGroup, SlashMenuOption, TriggerFn } from './LexicalMenu';
+export declare const PUNCTUATION = "\\.,\\+\\*\\?\\$\\@\\|#{}\\(\\)\\^\\-\\[\\]\\\\/!%'\"~=<>_:;";
+export declare function getScrollParent(element: HTMLElement, includeHidden: boolean): HTMLBodyElement | HTMLElement;
+export { useDynamicPositioning } from './LexicalMenu';
+export declare function useBasicTypeaheadTriggerMatch(trigger: string, { maxLength, minLength }: {
+    maxLength?: number;
+    minLength?: number;
+}): TriggerFn;
+export type TypeaheadMenuPluginProps = {
+    anchorClassName?: string;
+    groupsWithOptions: Array<SlashMenuGroup>;
+    menuRenderFn: MenuRenderFn;
+    onClose?: () => void;
+    onOpen?: (resolution: MenuResolution) => void;
+    onQueryChange: (matchingString: null | string) => void;
+    onSelectOption: (option: SlashMenuOption, textNodeContainingQuery: TextNode | null, closeMenu: () => void, matchingString: string) => void;
+    triggerFn: TriggerFn;
+};
+export declare const ENABLE_SLASH_MENU_COMMAND: LexicalCommand<{
+    rect: DOMRect;
+}>;
+export declare function LexicalTypeaheadMenuPlugin({ anchorClassName, groupsWithOptions, menuRenderFn, onClose, onOpen, onQueryChange, onSelectOption, triggerFn, }: TypeaheadMenuPluginProps): JSX.Element | null;
+export { MenuRenderFn, MenuResolution, MenuTextMatch, TriggerFn };
+//# sourceMappingURL=index.d.ts.map

package/dist/field/lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/field/lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/index.tsx"],"names":[],"mappings":";AAAA,OAAO,KAAK,EAAE,cAAc,EAAiC,QAAQ,EAAE,MAAM,SAAS,CAAA;AActF,OAAO,KAAK,EACV,YAAY,EACZ,cAAc,EACd,aAAa,EACb,cAAc,EACd,eAAe,EACf,SAAS,EACV,MAAM,eAAe,CAAA;AAItB,eAAO,MAAM,WAAW,iEAAiE,CAAA;AA2EzF,wBAAgB,eAAe,CAC7B,OAAO,EAAE,WAAW,EACpB,aAAa,EAAE,OAAO,GACrB,eAAe,GAAG,WAAW,CAiB/B;AAED,OAAO,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAA;AAErD,wBAAgB,6BAA6B,CAC3C,OAAO,EAAE,MAAM,EACf,EAAE,SAAc,EAAE,SAAa,EAAE,EAAE;IAAE,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,GAC5E,SAAS,CAgCX;AAED,MAAM,MAAM,wBAAwB,GAAG;IACrC,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,iBAAiB,EAAE,KAAK,CAAC,cAAc,CAAC,CAAA;IACxC,YAAY,EAAE,YAAY,CAAA;IAC1B,OAAO,CAAC,EAAE,MAAM,IAAI,CAAA;IACpB,MAAM,CAAC,EAAE,CAAC,UAAU,EAAE,cAAc,KAAK,IAAI,CAAA;IAC7C,aAAa,EAAE,CAAC,cAAc,EAAE,IAAI,GAAG,MAAM,KAAK,IAAI,CAAA;IACtD,cAAc,EAAE,CACd,MAAM,EAAE,eAAe,EACvB,uBAAuB,EAAE,QAAQ,GAAG,IAAI,EACxC,SAAS,EAAE,MAAM,IAAI,EACrB,cAAc,EAAE,MAAM,KACnB,IAAI,CAAA;IACT,SAAS,EAAE,SAAS,CAAA;CACrB,CAAA;AAED,eAAO,MAAM,yBAAyB,EAAE,cAAc,CAAC;IACrD,IAAI,EAAE,OAAO,CAAA;CACd,CAA8C,CAAA;AAE/C,wBAAgB,0BAA0B,CAAC,EACzC,eAAe,EACf,iBAAiB,EACjB,YAAY,EACZ,OAAO,EACP,MAAM,EACN,aAAa,EACb,cAAc,EACd,SAAS,GACV,EAAE,wBAAwB,GAAG,GAAG,CAAC,OAAO,GAAG,IAAI,CAgH/C;AAED,OAAO,EAAE,YAAY,EAAE,cAAc,EAAE,aAAa,EAAE,SAAS,EAAE,CAAA"}