@payloadcms/richtext-lexical 0.1.0-beta.0

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

@@ -0,0 +1,281 @@
+"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;
+    },
+    getScrollParent: function() {
+        return getScrollParent;
+    },
+    useDynamicPositioning: function() {
+        return _LexicalMenu.useDynamicPositioning;
+    },
+    useBasicTypeaheadTriggerMatch: function() {
+        return useBasicTypeaheadTriggerMatch;
+    },
+    ENABLE_SLASH_MENU_COMMAND: function() {
+        return ENABLE_SLASH_MENU_COMMAND;
+    },
+    LexicalTypeaheadMenuPlugin: function() {
+        return LexicalTypeaheadMenuPlugin;
+    }
+});
+const _LexicalComposerContext = require("@lexical/react/LexicalComposerContext");
+const _utils = require("@lexical/utils");
+const _lexical = require("lexical");
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _LexicalMenu = require("./LexicalMenu");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const PUNCTUATION = '\\.,\\+\\*\\?\\$\\@\\|#{}\\(\\)\\^\\-\\[\\]\\\\/!%\'"~=<>_:;';
+function getTextUpToAnchor(selection) {
+    const anchor = selection.anchor;
+    if (anchor.type !== 'text') {
+        return null;
+    }
+    const anchorNode = anchor.getNode();
+    if (!anchorNode.isSimpleText()) {
+        return null;
+    }
+    const anchorOffset = anchor.offset;
+    return anchorNode.getTextContent().slice(0, anchorOffset);
+}
+function tryToPositionRange(leadOffset, range, editorWindow) {
+    const domSelection = editorWindow.getSelection();
+    if (domSelection === null || !domSelection.isCollapsed) {
+        return false;
+    }
+    const anchorNode = domSelection.anchorNode;
+    const startOffset = leadOffset;
+    const endOffset = domSelection.anchorOffset;
+    if (anchorNode == null || endOffset == null) {
+        return false;
+    }
+    try {
+        range.setStart(anchorNode, startOffset);
+        range.setEnd(anchorNode, endOffset);
+    } catch (error) {
+        return false;
+    }
+    return true;
+}
+function getQueryTextForSearch(editor) {
+    let text = null;
+    editor.getEditorState().read(()=>{
+        const selection = (0, _lexical.$getSelection)();
+        if (!(0, _lexical.$isRangeSelection)(selection)) {
+            return;
+        }
+        text = getTextUpToAnchor(selection);
+    });
+    return text;
+}
+function isSelectionOnEntityBoundary(editor, offset) {
+    if (offset !== 0) {
+        return false;
+    }
+    return editor.getEditorState().read(()=>{
+        const selection = (0, _lexical.$getSelection)();
+        if ((0, _lexical.$isRangeSelection)(selection)) {
+            const anchor = selection.anchor;
+            const anchorNode = anchor.getNode();
+            const prevSibling = anchorNode.getPreviousSibling();
+            return (0, _lexical.$isTextNode)(prevSibling) && prevSibling.isTextEntity();
+        }
+        return false;
+    });
+}
+function startTransition(callback) {
+    if (_react.startTransition) {
+        _react.startTransition(callback);
+    } else {
+        callback();
+    }
+}
+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 useBasicTypeaheadTriggerMatch(trigger, { maxLength = 75, minLength = 1 }) {
+    return (0, _react.useCallback)((text)=>{
+        const validChars = '[^' + trigger + PUNCTUATION + '\\s]';
+        const TypeaheadTriggerRegex = new RegExp('(^|\\s|\\()(' + '[' + trigger + ']' + '((?:' + validChars + '){0,' + maxLength + '})' + ')$');
+        const match = TypeaheadTriggerRegex.exec(text);
+        if (match !== null) {
+            const maybeLeadingWhitespace = match[1];
+            const matchingString = match[3];
+            if (matchingString.length >= minLength) {
+                return {
+                    leadOffset: match.index + maybeLeadingWhitespace.length,
+                    matchingString,
+                    replaceableString: match[2]
+                };
+            }
+        }
+        return null;
+    }, [
+        maxLength,
+        minLength,
+        trigger
+    ]);
+}
+const ENABLE_SLASH_MENU_COMMAND = (0, _lexical.createCommand)('ENABLE_SLASH_MENU_COMMAND');
+function LexicalTypeaheadMenuPlugin({ anchorClassName, groupsWithOptions, menuRenderFn, onClose, onOpen, onQueryChange, onSelectOption, triggerFn }) {
+    const [editor] = (0, _LexicalComposerContext.useLexicalComposerContext)();
+    const [resolution, setResolution] = (0, _react.useState)(null);
+    const anchorElementRef = (0, _LexicalMenu.useMenuAnchorRef)(resolution, setResolution, anchorClassName);
+    const closeTypeahead = (0, _react.useCallback)(()=>{
+        setResolution(null);
+        if (onClose != null && resolution !== null) {
+            onClose();
+        }
+    }, [
+        onClose,
+        resolution
+    ]);
+    const openTypeahead = (0, _react.useCallback)((res)=>{
+        setResolution(res);
+        if (onOpen != null && resolution === null) {
+            onOpen(res);
+        }
+    }, [
+        onOpen,
+        resolution
+    ]);
+    // This is mainly used for the AddBlockHandlePlugin, so that the slash menu can be opened from there
+    (0, _react.useEffect)(()=>{
+        return (0, _utils.mergeRegister)(editor.registerCommand(ENABLE_SLASH_MENU_COMMAND, ({ rect })=>{
+            editor.getEditorState().read(()=>{
+                const match = {
+                    leadOffset: 0,
+                    matchingString: '',
+                    replaceableString: ''
+                };
+                if (match !== null && !isSelectionOnEntityBoundary(editor, match.leadOffset)) {
+                    if (rect !== null) {
+                        startTransition(()=>openTypeahead({
+                                getRect: ()=>{
+                                    return rect;
+                                },
+                                match
+                            }));
+                        return;
+                    }
+                }
+            });
+            return true;
+        }, _lexical.COMMAND_PRIORITY_LOW));
+    }, [
+        editor,
+        openTypeahead
+    ]);
+    (0, _react.useEffect)(()=>{
+        const updateListener = ()=>{
+            editor.getEditorState().read(()=>{
+                const editorWindow = editor._window ?? window;
+                const range = editorWindow.document.createRange();
+                const selection = (0, _lexical.$getSelection)();
+                const text = getQueryTextForSearch(editor);
+                if (!(0, _lexical.$isRangeSelection)(selection) || !selection.isCollapsed() || text === null || range === null) {
+                    closeTypeahead();
+                    return;
+                }
+                const match = triggerFn(text, editor);
+                onQueryChange(match ? match.matchingString : null);
+                if (match !== null && !isSelectionOnEntityBoundary(editor, match.leadOffset)) {
+                    const isRangePositioned = tryToPositionRange(match.leadOffset, range, editorWindow);
+                    if (isRangePositioned !== null) {
+                        startTransition(()=>openTypeahead({
+                                getRect: ()=>range.getBoundingClientRect(),
+                                match
+                            }));
+                        return;
+                    }
+                }
+                closeTypeahead();
+            });
+        };
+        const removeUpdateListener = editor.registerUpdateListener(updateListener);
+        return ()=>{
+            removeUpdateListener();
+        };
+    }, [
+        editor,
+        triggerFn,
+        onQueryChange,
+        resolution,
+        closeTypeahead,
+        openTypeahead
+    ]);
+    return resolution === null || editor === null ? null : /*#__PURE__*/ _react.createElement(_LexicalMenu.LexicalMenu, {
+        anchorElementRef: anchorElementRef,
+        close: closeTypeahead,
+        editor: editor,
+        groupsWithOptions: groupsWithOptions,
+        menuRenderFn: menuRenderFn,
+        onSelectOption: onSelectOption,
+        resolution: resolution,
+        shouldSplitNodeWithQuery: true
+    });
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../../../src/field/lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/index.tsx"],"sourcesContent":["import type { LexicalCommand, LexicalEditor, RangeSelection, TextNode } from 'lexical'\n\nimport { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext'\nimport { mergeRegister } from '@lexical/utils'\nimport {\n  $getSelection,\n  $isRangeSelection,\n  $isTextNode,\n  COMMAND_PRIORITY_LOW,\n  createCommand,\n} from 'lexical'\nimport { useCallback, useEffect, useState } from 'react'\nimport * as React from 'react'\n\nimport type {\n  MenuRenderFn,\n  MenuResolution,\n  MenuTextMatch,\n  SlashMenuGroup,\n  SlashMenuOption,\n  TriggerFn,\n} from './LexicalMenu'\n\nimport { LexicalMenu, useMenuAnchorRef } from './LexicalMenu'\n\nexport const PUNCTUATION = '\\\\.,\\\\+\\\\*\\\\?\\\\$\\\\@\\\\|#{}\\\\(\\\\)\\\\^\\\\-\\\\[\\\\]\\\\\\\\/!%\\'\"~=<>_:;'\n\nfunction getTextUpToAnchor(selection: RangeSelection): null | string {\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 anchorOffset = anchor.offset\n  return anchorNode.getTextContent().slice(0, anchorOffset)\n}\n\nfunction tryToPositionRange(leadOffset: number, range: Range, editorWindow: Window): boolean {\n  const domSelection = editorWindow.getSelection()\n  if (domSelection === null || !domSelection.isCollapsed) {\n    return false\n  }\n  const anchorNode = domSelection.anchorNode\n  const startOffset = leadOffset\n  const endOffset = domSelection.anchorOffset\n\n  if (anchorNode == null || endOffset == null) {\n    return false\n  }\n\n  try {\n    range.setStart(anchorNode, startOffset)\n    range.setEnd(anchorNode, endOffset)\n  } catch (error) {\n    return false\n  }\n\n  return true\n}\n\nfunction getQueryTextForSearch(editor: LexicalEditor): null | string {\n  let text = null\n  editor.getEditorState().read(() => {\n    const selection = $getSelection()\n    if (!$isRangeSelection(selection)) {\n      return\n    }\n    text = getTextUpToAnchor(selection)\n  })\n  return text\n}\n\nfunction isSelectionOnEntityBoundary(editor: LexicalEditor, offset: number): boolean {\n  if (offset !== 0) {\n    return false\n  }\n  return editor.getEditorState().read(() => {\n    const selection = $getSelection()\n    if ($isRangeSelection(selection)) {\n      const anchor = selection.anchor\n      const anchorNode = anchor.getNode()\n      const prevSibling = anchorNode.getPreviousSibling()\n      return $isTextNode(prevSibling) && prevSibling.isTextEntity()\n    }\n    return false\n  })\n}\n\nfunction startTransition(callback: () => void) {\n  if (React.startTransition) {\n    React.startTransition(callback)\n  } else {\n    callback()\n  }\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\nexport { useDynamicPositioning } from './LexicalMenu'\n\nexport function useBasicTypeaheadTriggerMatch(\n  trigger: string,\n  { maxLength = 75, minLength = 1 }: { maxLength?: number; minLength?: number },\n): TriggerFn {\n  return useCallback(\n    (text: string) => {\n      const validChars = '[^' + trigger + PUNCTUATION + '\\\\s]'\n      const TypeaheadTriggerRegex = new RegExp(\n        '(^|\\\\s|\\\\()(' +\n          '[' +\n          trigger +\n          ']' +\n          '((?:' +\n          validChars +\n          '){0,' +\n          maxLength +\n          '})' +\n          ')$',\n      )\n      const match = TypeaheadTriggerRegex.exec(text)\n      if (match !== null) {\n        const maybeLeadingWhitespace = match[1]\n        const matchingString = match[3]\n        if (matchingString.length >= minLength) {\n          return {\n            leadOffset: match.index + maybeLeadingWhitespace.length,\n            matchingString,\n            replaceableString: match[2],\n          }\n        }\n      }\n      return null\n    },\n    [maxLength, minLength, trigger],\n  )\n}\n\nexport type TypeaheadMenuPluginProps = {\n  anchorClassName?: string\n  groupsWithOptions: Array<SlashMenuGroup>\n  menuRenderFn: MenuRenderFn\n  onClose?: () => void\n  onOpen?: (resolution: MenuResolution) => void\n  onQueryChange: (matchingString: null | string) => void\n  onSelectOption: (\n    option: SlashMenuOption,\n    textNodeContainingQuery: TextNode | null,\n    closeMenu: () => void,\n    matchingString: string,\n  ) => void\n  triggerFn: TriggerFn\n}\n\nexport const ENABLE_SLASH_MENU_COMMAND: LexicalCommand<{\n  rect: DOMRect\n}> = createCommand('ENABLE_SLASH_MENU_COMMAND')\n\nexport function LexicalTypeaheadMenuPlugin({\n  anchorClassName,\n  groupsWithOptions,\n  menuRenderFn,\n  onClose,\n  onOpen,\n  onQueryChange,\n  onSelectOption,\n  triggerFn,\n}: TypeaheadMenuPluginProps): JSX.Element | null {\n  const [editor] = useLexicalComposerContext()\n  const [resolution, setResolution] = useState<MenuResolution | null>(null)\n  const anchorElementRef = useMenuAnchorRef(resolution, setResolution, anchorClassName)\n\n  const closeTypeahead = useCallback(() => {\n    setResolution(null)\n    if (onClose != null && resolution !== null) {\n      onClose()\n    }\n  }, [onClose, resolution])\n\n  const openTypeahead = useCallback(\n    (res: MenuResolution) => {\n      setResolution(res)\n      if (onOpen != null && resolution === null) {\n        onOpen(res)\n      }\n    },\n    [onOpen, resolution],\n  )\n\n  // This is mainly used for the AddBlockHandlePlugin, so that the slash menu can be opened from there\n  useEffect(() => {\n    return mergeRegister(\n      editor.registerCommand(\n        ENABLE_SLASH_MENU_COMMAND,\n        ({ rect }) => {\n          editor.getEditorState().read(() => {\n            const match: MenuTextMatch = {\n              leadOffset: 0,\n              matchingString: '',\n              replaceableString: '',\n            }\n            if (match !== null && !isSelectionOnEntityBoundary(editor, match.leadOffset)) {\n              if (rect !== null) {\n                startTransition(() =>\n                  openTypeahead({\n                    getRect: () => {\n                      return rect\n                    },\n                    match,\n                  }),\n                )\n                return\n              }\n            }\n          })\n\n          return true\n        },\n        COMMAND_PRIORITY_LOW,\n      ),\n    )\n  }, [editor, openTypeahead])\n\n  useEffect(() => {\n    const updateListener = () => {\n      editor.getEditorState().read(() => {\n        const editorWindow = editor._window ?? window\n        const range = editorWindow.document.createRange()\n        const selection = $getSelection()\n        const text = getQueryTextForSearch(editor)\n\n        if (\n          !$isRangeSelection(selection) ||\n          !selection.isCollapsed() ||\n          text === null ||\n          range === null\n        ) {\n          closeTypeahead()\n          return\n        }\n\n        const match = triggerFn(text, editor)\n        onQueryChange(match ? match.matchingString : null)\n\n        if (match !== null && !isSelectionOnEntityBoundary(editor, match.leadOffset)) {\n          const isRangePositioned = tryToPositionRange(match.leadOffset, range, editorWindow)\n          if (isRangePositioned !== null) {\n            startTransition(() =>\n              openTypeahead({\n                getRect: () => range.getBoundingClientRect(),\n                match,\n              }),\n            )\n            return\n          }\n        }\n        closeTypeahead()\n      })\n    }\n\n    const removeUpdateListener = editor.registerUpdateListener(updateListener)\n\n    return () => {\n      removeUpdateListener()\n    }\n  }, [editor, triggerFn, onQueryChange, resolution, closeTypeahead, openTypeahead])\n\n  return resolution === null || editor === null ? null : (\n    <LexicalMenu\n      anchorElementRef={anchorElementRef}\n      close={closeTypeahead}\n      editor={editor}\n      groupsWithOptions={groupsWithOptions}\n      menuRenderFn={menuRenderFn}\n      onSelectOption={onSelectOption}\n      resolution={resolution}\n      shouldSplitNodeWithQuery\n    />\n  )\n}\n\nexport { MenuRenderFn, MenuResolution, MenuTextMatch, TriggerFn }\n"],"names":["PUNCTUATION","getScrollParent","useDynamicPositioning","useBasicTypeaheadTriggerMatch","ENABLE_SLASH_MENU_COMMAND","LexicalTypeaheadMenuPlugin","getTextUpToAnchor","selection","anchor","type","anchorNode","getNode","isSimpleText","anchorOffset","offset","getTextContent","slice","tryToPositionRange","leadOffset","range","editorWindow","domSelection","getSelection","isCollapsed","startOffset","endOffset","setStart","setEnd","error","getQueryTextForSearch","editor","text","getEditorState","read","$getSelection","$isRangeSelection","isSelectionOnEntityBoundary","prevSibling","getPreviousSibling","$isTextNode","isTextEntity","startTransition","callback","React","element","includeHidden","style","getComputedStyle","excludeStaticParent","position","overflowRegex","document","body","parent","parentElement","test","overflow","overflowY","overflowX","trigger","maxLength","minLength","useCallback","validChars","TypeaheadTriggerRegex","RegExp","match","exec","maybeLeadingWhitespace","matchingString","length","index","replaceableString","createCommand","anchorClassName","groupsWithOptions","menuRenderFn","onClose","onOpen","onQueryChange","onSelectOption","triggerFn","useLexicalComposerContext","resolution","setResolution","useState","anchorElementRef","useMenuAnchorRef","closeTypeahead","openTypeahead","res","useEffect","mergeRegister","registerCommand","rect","getRect","COMMAND_PRIORITY_LOW","updateListener","_window","window","createRange","isRangePositioned","getBoundingClientRect","removeUpdateListener","registerUpdateListener","LexicalMenu","close","shouldSplitNodeWithQuery"],"mappings":";;;;;;;;;;;IAyBaA,WAAW;eAAXA;;IA2EGC,eAAe;eAAfA;;IAsBPC,qBAAqB;eAArBA,kCAAqB;;IAEdC,6BAA6B;eAA7BA;;IAqDHC,yBAAyB;eAAzBA;;IAIGC,0BAA0B;eAA1BA;;;wCAnL0B;uBACZ;yBAOvB;+DAC0C;6BAYH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEvC,MAAML,cAAc;AAE3B,SAASM,kBAAkBC,SAAyB;IAClD,MAAMC,SAASD,UAAUC,MAAM;IAC/B,IAAIA,OAAOC,IAAI,KAAK,QAAQ;QAC1B,OAAO;IACT;IACA,MAAMC,aAAaF,OAAOG,OAAO;IACjC,IAAI,CAACD,WAAWE,YAAY,IAAI;QAC9B,OAAO;IACT;IACA,MAAMC,eAAeL,OAAOM,MAAM;IAClC,OAAOJ,WAAWK,cAAc,GAAGC,KAAK,CAAC,GAAGH;AAC9C;AAEA,SAASI,mBAAmBC,UAAkB,EAAEC,KAAY,EAAEC,YAAoB;IAChF,MAAMC,eAAeD,aAAaE,YAAY;IAC9C,IAAID,iBAAiB,QAAQ,CAACA,aAAaE,WAAW,EAAE;QACtD,OAAO;IACT;IACA,MAAMb,aAAaW,aAAaX,UAAU;IAC1C,MAAMc,cAAcN;IACpB,MAAMO,YAAYJ,aAAaR,YAAY;IAE3C,IAAIH,cAAc,QAAQe,aAAa,MAAM;QAC3C,OAAO;IACT;IAEA,IAAI;QACFN,MAAMO,QAAQ,CAAChB,YAAYc;QAC3BL,MAAMQ,MAAM,CAACjB,YAAYe;IAC3B,EAAE,OAAOG,OAAO;QACd,OAAO;IACT;IAEA,OAAO;AACT;AAEA,SAASC,sBAAsBC,MAAqB;IAClD,IAAIC,OAAO;IACXD,OAAOE,cAAc,GAAGC,IAAI,CAAC;QAC3B,MAAM1B,YAAY2B,IAAAA,sBAAa;QAC/B,IAAI,CAACC,IAAAA,0BAAiB,EAAC5B,YAAY;YACjC;QACF;QACAwB,OAAOzB,kBAAkBC;IAC3B;IACA,OAAOwB;AACT;AAEA,SAASK,4BAA4BN,MAAqB,EAAEhB,MAAc;IACxE,IAAIA,WAAW,GAAG;QAChB,OAAO;IACT;IACA,OAAOgB,OAAOE,cAAc,GAAGC,IAAI,CAAC;QAClC,MAAM1B,YAAY2B,IAAAA,sBAAa;QAC/B,IAAIC,IAAAA,0BAAiB,EAAC5B,YAAY;YAChC,MAAMC,SAASD,UAAUC,MAAM;YAC/B,MAAME,aAAaF,OAAOG,OAAO;YACjC,MAAM0B,cAAc3B,WAAW4B,kBAAkB;YACjD,OAAOC,IAAAA,oBAAW,EAACF,gBAAgBA,YAAYG,YAAY;QAC7D;QACA,OAAO;IACT;AACF;AAEA,SAASC,gBAAgBC,QAAoB;IAC3C,IAAIC,OAAMF,eAAe,EAAE;QACzBE,OAAMF,eAAe,CAACC;IACxB,OAAO;QACLA;IACF;AACF;AAGO,SAASzC,gBACd2C,OAAoB,EACpBC,aAAsB;IAEtB,IAAIC,QAAQC,iBAAiBH;IAC7B,MAAMI,sBAAsBF,MAAMG,QAAQ,KAAK;IAC/C,MAAMC,gBAAgBL,gBAAgB,yBAAyB;IAC/D,IAAIC,MAAMG,QAAQ,KAAK,SAAS;QAC9B,OAAOE,SAASC,IAAI;IACtB;IACA,IAAK,IAAIC,SAA6BT,SAAUS,SAASA,OAAOC,aAAa,EAAK;QAChFR,QAAQC,iBAAiBM;QACzB,IAAIL,uBAAuBF,MAAMG,QAAQ,KAAK,UAAU;YACtD;QACF;QACA,IAAIC,cAAcK,IAAI,CAACT,MAAMU,QAAQ,GAAGV,MAAMW,SAAS,GAAGX,MAAMY,SAAS,GAAG;YAC1E,OAAOL;QACT;IACF;IACA,OAAOF,SAASC,IAAI;AACtB;AAIO,SAASjD,8BACdwD,OAAe,EACf,EAAEC,YAAY,EAAE,EAAEC,YAAY,CAAC,EAA8C;IAE7E,OAAOC,IAAAA,kBAAW,EAChB,CAAC/B;QACC,MAAMgC,aAAa,OAAOJ,UAAU3D,cAAc;QAClD,MAAMgE,wBAAwB,IAAIC,OAChC,iBACE,MACAN,UACA,MACA,SACAI,aACA,SACAH,YACA,OACA;QAEJ,MAAMM,QAAQF,sBAAsBG,IAAI,CAACpC;QACzC,IAAImC,UAAU,MAAM;YAClB,MAAME,yBAAyBF,KAAK,CAAC,EAAE;YACvC,MAAMG,iBAAiBH,KAAK,CAAC,EAAE;YAC/B,IAAIG,eAAeC,MAAM,IAAIT,WAAW;gBACtC,OAAO;oBACL3C,YAAYgD,MAAMK,KAAK,GAAGH,uBAAuBE,MAAM;oBACvDD;oBACAG,mBAAmBN,KAAK,CAAC,EAAE;gBAC7B;YACF;QACF;QACA,OAAO;IACT,GACA;QAACN;QAAWC;QAAWF;KAAQ;AAEnC;AAkBO,MAAMvD,4BAERqE,IAAAA,sBAAa,EAAC;AAEZ,SAASpE,2BAA2B,EACzCqE,eAAe,EACfC,iBAAiB,EACjBC,YAAY,EACZC,OAAO,EACPC,MAAM,EACNC,aAAa,EACbC,cAAc,EACdC,SAAS,EACgB;IACzB,MAAM,CAACnD,OAAO,GAAGoD,IAAAA,iDAAyB;IAC1C,MAAM,CAACC,YAAYC,cAAc,GAAGC,IAAAA,eAAQ,EAAwB;IACpE,MAAMC,mBAAmBC,IAAAA,6BAAgB,EAACJ,YAAYC,eAAeV;IAErE,MAAMc,iBAAiB1B,IAAAA,kBAAW,EAAC;QACjCsB,cAAc;QACd,IAAIP,WAAW,QAAQM,eAAe,MAAM;YAC1CN;QACF;IACF,GAAG;QAACA;QAASM;KAAW;IAExB,MAAMM,gBAAgB3B,IAAAA,kBAAW,EAC/B,CAAC4B;QACCN,cAAcM;QACd,IAAIZ,UAAU,QAAQK,eAAe,MAAM;YACzCL,OAAOY;QACT;IACF,GACA;QAACZ;QAAQK;KAAW;IAGtB,oGAAoG;IACpGQ,IAAAA,gBAAS,EAAC;QACR,OAAOC,IAAAA,oBAAa,EAClB9D,OAAO+D,eAAe,CACpBzF,2BACA,CAAC,EAAE0F,IAAI,EAAE;YACPhE,OAAOE,cAAc,GAAGC,IAAI,CAAC;gBAC3B,MAAMiC,QAAuB;oBAC3BhD,YAAY;oBACZmD,gBAAgB;oBAChBG,mBAAmB;gBACrB;gBACA,IAAIN,UAAU,QAAQ,CAAC9B,4BAA4BN,QAAQoC,MAAMhD,UAAU,GAAG;oBAC5E,IAAI4E,SAAS,MAAM;wBACjBrD,gBAAgB,IACdgD,cAAc;gCACZM,SAAS;oCACP,OAAOD;gCACT;gCACA5B;4BACF;wBAEF;oBACF;gBACF;YACF;YAEA,OAAO;QACT,GACA8B,6BAAoB;IAG1B,GAAG;QAAClE;QAAQ2D;KAAc;IAE1BE,IAAAA,gBAAS,EAAC;QACR,MAAMM,iBAAiB;YACrBnE,OAAOE,cAAc,GAAGC,IAAI,CAAC;gBAC3B,MAAMb,eAAeU,OAAOoE,OAAO,IAAIC;gBACvC,MAAMhF,QAAQC,aAAa+B,QAAQ,CAACiD,WAAW;gBAC/C,MAAM7F,YAAY2B,IAAAA,sBAAa;gBAC/B,MAAMH,OAAOF,sBAAsBC;gBAEnC,IACE,CAACK,IAAAA,0BAAiB,EAAC5B,cACnB,CAACA,UAAUgB,WAAW,MACtBQ,SAAS,QACTZ,UAAU,MACV;oBACAqE;oBACA;gBACF;gBAEA,MAAMtB,QAAQe,UAAUlD,MAAMD;gBAC9BiD,cAAcb,QAAQA,MAAMG,cAAc,GAAG;gBAE7C,IAAIH,UAAU,QAAQ,CAAC9B,4BAA4BN,QAAQoC,MAAMhD,UAAU,GAAG;oBAC5E,MAAMmF,oBAAoBpF,mBAAmBiD,MAAMhD,UAAU,EAAEC,OAAOC;oBACtE,IAAIiF,sBAAsB,MAAM;wBAC9B5D,gBAAgB,IACdgD,cAAc;gCACZM,SAAS,IAAM5E,MAAMmF,qBAAqB;gCAC1CpC;4BACF;wBAEF;oBACF;gBACF;gBACAsB;YACF;QACF;QAEA,MAAMe,uBAAuBzE,OAAO0E,sBAAsB,CAACP;QAE3D,OAAO;YACLM;QACF;IACF,GAAG;QAACzE;QAAQmD;QAAWF;QAAeI;QAAYK;QAAgBC;KAAc;IAEhF,OAAON,eAAe,QAAQrD,WAAW,OAAO,qBAC9C,qBAAC2E,wBAAW;QACVnB,kBAAkBA;QAClBoB,OAAOlB;QACP1D,QAAQA;QACR6C,mBAAmBA;QACnBC,cAAcA;QACdI,gBAAgBA;QAChBG,YAAYA;QACZwB,0BAAAA;;AAGN"}

package/dist/field/lexical/plugins/SlashMenu/defaultGroups.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=defaultGroups.d.ts.map

package/dist/field/lexical/plugins/SlashMenu/defaultGroups.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaultGroups.d.ts","sourceRoot":"","sources":["../../../../../src/field/lexical/plugins/SlashMenu/defaultGroups.ts"],"names":[],"mappings":""}

package/dist/field/lexical/plugins/SlashMenu/defaultGroups.js

@@ -0,0 +1,3 @@
+"use strict";
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

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

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import './index.scss';
+export declare function SlashMenuPlugin(): JSX.Element;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/field/lexical/plugins/SlashMenu/index.tsx"],"names":[],"mappings":";AAeA,OAAO,cAAc,CAAA;AAsCrB,wBAAgB,eAAe,IAAI,GAAG,CAAC,OAAO,CAyI7C"}

package/dist/field/lexical/plugins/SlashMenu/index.js

@@ -0,0 +1,187 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "SlashMenuPlugin", {
+    enumerable: true,
+    get: function() {
+        return SlashMenuPlugin;
+    }
+});
+const _LexicalComposerContext = require("@lexical/react/LexicalComposerContext");
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _reactdom = /*#__PURE__*/ _interop_require_wildcard(require("react-dom"));
+const _EditorConfigProvider = require("../../config/EditorConfigProvider");
+const _LexicalTypeaheadMenuPlugin = require("./LexicalTypeaheadMenuPlugin");
+require("./index.scss");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+function SlashMenuItem({ index, isSelected, onClick, onMouseEnter, option }) {
+    let className = 'item';
+    if (isSelected) {
+        className += ' selected';
+    }
+    return /*#__PURE__*/ _react.createElement("button", {
+        "aria-selected": isSelected,
+        className: className,
+        id: 'typeahead-item-' + index,
+        key: option.key,
+        onClick: onClick,
+        onMouseEnter: onMouseEnter,
+        ref: option.setRefElement,
+        role: "option",
+        tabIndex: -1,
+        type: "button"
+    }, /*#__PURE__*/ _react.createElement(option.Icon, null), /*#__PURE__*/ _react.createElement("span", {
+        className: "text"
+    }, option.title));
+}
+function SlashMenuPlugin() {
+    const [editor] = (0, _LexicalComposerContext.useLexicalComposerContext)();
+    const [queryString, setQueryString] = (0, _react.useState)(null);
+    const { editorConfig } = (0, _EditorConfigProvider.useEditorConfigContext)();
+    const checkForTriggerMatch = (0, _LexicalTypeaheadMenuPlugin.useBasicTypeaheadTriggerMatch)('/', {
+        minLength: 0
+    });
+    const getDynamicOptions = (0, _react.useCallback)(()=>{
+        let groupWithOptions = [];
+        for (const dynamicOption of editorConfig?.features.slashMenu.dynamicOptions){
+            const dynamicGroupWithOptions = dynamicOption({
+                editor,
+                queryString
+            });
+            groupWithOptions = groupWithOptions.concat(dynamicGroupWithOptions);
+        }
+        return groupWithOptions;
+    }, [
+        editor,
+        queryString,
+        editorConfig?.features
+    ]);
+    const groups = (0, _react.useMemo)(()=>{
+        let groupsWithOptions = [];
+        for (const groupWithOption of editorConfig?.features.slashMenu.groupsWithOptions ?? []){
+            groupsWithOptions.push(groupWithOption);
+        }
+        if (queryString) {
+            // Filter current groups first
+            groupsWithOptions = groupsWithOptions.map((group)=>{
+                const filteredOptions = group.options.filter((option)=>{
+                    return new RegExp(queryString, 'gi').exec(option.title) || option.keywords != null ? option.keywords.some((keyword)=>new RegExp(queryString, 'gi').exec(keyword)) : false;
+                });
+                if (filteredOptions.length) {
+                    return {
+                        ...group,
+                        options: filteredOptions
+                    };
+                }
+                return null;
+            });
+            groupsWithOptions = groupsWithOptions.filter((group)=>group != null);
+            // Now add dynamic groups
+            const dynamicOptionGroups = getDynamicOptions();
+            // merge dynamic options into groups
+            for (const dynamicGroup of dynamicOptionGroups){
+                // 1. find the group with the same name or create new one
+                let group = groupsWithOptions.find((group)=>group.title === dynamicGroup.title);
+                if (!group) {
+                    group = {
+                        ...dynamicGroup,
+                        options: []
+                    };
+                } else {
+                    groupsWithOptions = groupsWithOptions.filter((group)=>group.title !== dynamicGroup.title);
+                }
+                // 2. Add options to group options array and add to sanitized.slashMenu.groupsWithOptions
+                if (group?.options?.length) {
+                    group.options = group.options.concat(group.options);
+                }
+                groupsWithOptions.push(group);
+            }
+        }
+        return groupsWithOptions;
+    }, [
+        getDynamicOptions,
+        queryString,
+        editorConfig?.features
+    ]);
+    const onSelectOption = (0, _react.useCallback)((selectedOption, nodeToRemove, closeMenu, matchingString)=>{
+        editor.update(()=>{
+            if (nodeToRemove) {
+                nodeToRemove.remove();
+            }
+            selectedOption.onSelect({
+                editor,
+                queryString: matchingString
+            });
+            closeMenu();
+        });
+    }, [
+        editor
+    ]);
+    return /*#__PURE__*/ _react.createElement(_react.Fragment, null, /*#__PURE__*/ _react.createElement(_LexicalTypeaheadMenuPlugin.LexicalTypeaheadMenuPlugin, {
+        groupsWithOptions: groups,
+        menuRenderFn: (anchorElementRef, { selectOptionAndCleanUp, selectedOptionKey, setSelectedOptionKey })=>anchorElementRef.current && groups.length ? /*#__PURE__*/ _reactdom.createPortal(/*#__PURE__*/ _react.createElement("div", {
+                className: "typeahead-popover slash-menu"
+            }, groups.map((group)=>/*#__PURE__*/ _react.createElement("div", {
+                    className: "group",
+                    key: group.title
+                }, /*#__PURE__*/ _react.createElement("div", {
+                    className: "group-title"
+                }, group.title), group.options.map((option, oi)=>/*#__PURE__*/ _react.createElement(SlashMenuItem, {
+                        index: oi,
+                        isSelected: selectedOptionKey === option.key,
+                        key: option.key,
+                        onClick: ()=>{
+                            setSelectedOptionKey(option.key);
+                            selectOptionAndCleanUp(option);
+                        },
+                        onMouseEnter: ()=>{
+                            setSelectedOptionKey(option.key);
+                        },
+                        option: option
+                    }))))), anchorElementRef.current) : null,
+        onQueryChange: setQueryString,
+        onSelectOption: onSelectOption,
+        triggerFn: checkForTriggerMatch
+    }));
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../../src/field/lexical/plugins/SlashMenu/index.tsx"],"sourcesContent":["import type { TextNode } from 'lexical'\n\nimport { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext'\nimport { useCallback, useMemo, useState } from 'react'\nimport * as React from 'react'\nimport * as ReactDOM from 'react-dom'\n\nimport type { SlashMenuGroup } from './LexicalTypeaheadMenuPlugin/LexicalMenu'\nimport type { SlashMenuOption } from './LexicalTypeaheadMenuPlugin/LexicalMenu'\n\nimport { useEditorConfigContext } from '../../config/EditorConfigProvider'\nimport {\n  LexicalTypeaheadMenuPlugin,\n  useBasicTypeaheadTriggerMatch,\n} from './LexicalTypeaheadMenuPlugin'\nimport './index.scss'\n\nfunction SlashMenuItem({\n  index,\n  isSelected,\n  onClick,\n  onMouseEnter,\n  option,\n}: {\n  index: number\n  isSelected: boolean\n  onClick: () => void\n  onMouseEnter: () => void\n  option: SlashMenuOption\n}) {\n  let className = 'item'\n  if (isSelected) {\n    className += ' selected'\n  }\n  return (\n    <button\n      aria-selected={isSelected}\n      className={className}\n      id={'typeahead-item-' + index}\n      key={option.key}\n      onClick={onClick}\n      onMouseEnter={onMouseEnter}\n      ref={option.setRefElement}\n      role=\"option\"\n      tabIndex={-1}\n      type=\"button\"\n    >\n      <option.Icon />\n      <span className=\"text\">{option.title}</span>\n    </button>\n  )\n}\n\nexport function SlashMenuPlugin(): JSX.Element {\n  const [editor] = useLexicalComposerContext()\n  const [queryString, setQueryString] = useState<null | string>(null)\n  const { editorConfig } = useEditorConfigContext()\n\n  const checkForTriggerMatch = useBasicTypeaheadTriggerMatch('/', {\n    minLength: 0,\n  })\n\n  const getDynamicOptions = useCallback(() => {\n    let groupWithOptions: Array<SlashMenuGroup> = []\n\n    for (const dynamicOption of editorConfig?.features.slashMenu.dynamicOptions) {\n      const dynamicGroupWithOptions = dynamicOption({\n        editor,\n        queryString,\n      })\n      groupWithOptions = groupWithOptions.concat(dynamicGroupWithOptions)\n    }\n\n    return groupWithOptions\n  }, [editor, queryString, editorConfig?.features])\n\n  const groups: SlashMenuGroup[] = useMemo(() => {\n    let groupsWithOptions: SlashMenuGroup[] = []\n    for (const groupWithOption of editorConfig?.features.slashMenu.groupsWithOptions ?? []) {\n      groupsWithOptions.push(groupWithOption)\n    }\n\n    if (queryString) {\n      // Filter current groups first\n      groupsWithOptions = groupsWithOptions.map((group) => {\n        const filteredOptions = group.options.filter((option) => {\n          return new RegExp(queryString, 'gi').exec(option.title) || option.keywords != null\n            ? option.keywords.some((keyword) => new RegExp(queryString, 'gi').exec(keyword))\n            : false\n        })\n        if (filteredOptions.length) {\n          return {\n            ...group,\n            options: filteredOptions,\n          }\n        }\n        return null\n      })\n\n      groupsWithOptions = groupsWithOptions.filter((group) => group != null)\n\n      // Now add dynamic groups\n      const dynamicOptionGroups = getDynamicOptions()\n\n      // merge dynamic options into groups\n      for (const dynamicGroup of dynamicOptionGroups) {\n        // 1. find the group with the same name or create new one\n        let group = groupsWithOptions.find((group) => group.title === dynamicGroup.title)\n        if (!group) {\n          group = {\n            ...dynamicGroup,\n            options: [],\n          }\n        } else {\n          groupsWithOptions = groupsWithOptions.filter(\n            (group) => group.title !== dynamicGroup.title,\n          )\n        }\n\n        // 2. Add options to group options array and add to sanitized.slashMenu.groupsWithOptions\n        if (group?.options?.length) {\n          group.options = group.options.concat(group.options)\n        }\n        groupsWithOptions.push(group)\n      }\n    }\n\n    return groupsWithOptions\n  }, [getDynamicOptions, queryString, editorConfig?.features])\n\n  const onSelectOption = useCallback(\n    (\n      selectedOption: SlashMenuOption,\n      nodeToRemove: TextNode | null,\n      closeMenu: () => void,\n      matchingString: string,\n    ) => {\n      editor.update(() => {\n        if (nodeToRemove) {\n          nodeToRemove.remove()\n        }\n        selectedOption.onSelect({ editor, queryString: matchingString })\n        closeMenu()\n      })\n    },\n    [editor],\n  )\n\n  return (\n    <React.Fragment>\n      <LexicalTypeaheadMenuPlugin\n        groupsWithOptions={groups}\n        menuRenderFn={(\n          anchorElementRef,\n          { selectOptionAndCleanUp, selectedOptionKey, setSelectedOptionKey },\n        ) =>\n          anchorElementRef.current && groups.length\n            ? ReactDOM.createPortal(\n                <div className=\"typeahead-popover slash-menu\">\n                  {groups.map((group) => (\n                    <div className=\"group\" key={group.title}>\n                      <div className=\"group-title\">{group.title}</div>\n                      {group.options.map((option, oi: number) => (\n                        <SlashMenuItem\n                          index={oi}\n                          isSelected={selectedOptionKey === option.key}\n                          key={option.key}\n                          onClick={() => {\n                            setSelectedOptionKey(option.key)\n                            selectOptionAndCleanUp(option)\n                          }}\n                          onMouseEnter={() => {\n                            setSelectedOptionKey(option.key)\n                          }}\n                          option={option}\n                        />\n                      ))}\n                    </div>\n                  ))}\n                </div>,\n                anchorElementRef.current,\n              )\n            : null\n        }\n        onQueryChange={setQueryString}\n        onSelectOption={onSelectOption}\n        triggerFn={checkForTriggerMatch}\n      />\n    </React.Fragment>\n  )\n}\n"],"names":["SlashMenuPlugin","SlashMenuItem","index","isSelected","onClick","onMouseEnter","option","className","button","aria-selected","id","key","ref","setRefElement","role","tabIndex","type","Icon","span","title","editor","useLexicalComposerContext","queryString","setQueryString","useState","editorConfig","useEditorConfigContext","checkForTriggerMatch","useBasicTypeaheadTriggerMatch","minLength","getDynamicOptions","useCallback","groupWithOptions","dynamicOption","features","slashMenu","dynamicOptions","dynamicGroupWithOptions","concat","groups","useMemo","groupsWithOptions","groupWithOption","push","map","group","filteredOptions","options","filter","RegExp","exec","keywords","some","keyword","length","dynamicOptionGroups","dynamicGroup","find","onSelectOption","selectedOption","nodeToRemove","closeMenu","matchingString","update","remove","onSelect","React","Fragment","LexicalTypeaheadMenuPlugin","menuRenderFn","anchorElementRef","selectOptionAndCleanUp","selectedOptionKey","setSelectedOptionKey","current","ReactDOM","createPortal","div","oi","onQueryChange","triggerFn"],"mappings":"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"}

package/dist/field/lexical/plugins/handles/AddBlockHandlePlugin/index.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+import './index.scss';
+export declare function AddBlockHandlePlugin({ anchorElem, }: {
+    anchorElem?: HTMLElement;
+}): JSX.Element;
+//# sourceMappingURL=index.d.ts.map

package/dist/field/lexical/plugins/handles/AddBlockHandlePlugin/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/field/lexical/plugins/handles/AddBlockHandlePlugin/index.tsx"],"names":[],"mappings":";AA4BA,OAAO,cAAc,CAAA;AAkQrB,wBAAgB,oBAAoB,CAAC,EACnC,UAA0B,GAC3B,EAAE;IACD,UAAU,CAAC,EAAE,WAAW,CAAA;CACzB,GAAG,GAAG,CAAC,OAAO,CAGd"}