@payloadcms/richtext-lexical 3.0.0-beta.13 → 3.0.0-beta.131

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

@@ -1,207 +0,0 @@
-'use client';
-import lexicalComposerContextImport from '@lexical/react/LexicalComposerContext.js';
-const { useLexicalComposerContext } = lexicalComposerContextImport;
-import lexicalUtilsImport from '@lexical/utils';
-const { mergeRegister } = lexicalUtilsImport;
-import lexicalImport from 'lexical';
-const { $getSelection, $isRangeSelection, $isTextNode, COMMAND_PRIORITY_LOW, createCommand } = lexicalImport;
-import { useCallback, useEffect, useState } from 'react';
-import * as React from 'react';
-import { LexicalMenu, useMenuAnchorRef } from './LexicalMenu.js';
-export 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);
-        // if endOffset is 0, positioning the range for when you click the plus button to open the slash menu will fial
-        range.setEnd(anchorNode, endOffset > 1 ? endOffset : 1);
-    } catch (error) {
-        return false;
-    }
-    return true;
-}
-function getQueryTextForSearch(editor) {
-    let text = null;
-    editor.getEditorState().read(()=>{
-        const selection = $getSelection();
-        if (!$isRangeSelection(selection)) {
-            return;
-        }
-        text = getTextUpToAnchor(selection);
-    });
-    return text;
-}
-function isSelectionOnEntityBoundary(editor, offset) {
-    if (offset !== 0) {
-        return false;
-    }
-    return editor.getEditorState().read(()=>{
-        const selection = $getSelection();
-        if ($isRangeSelection(selection)) {
-            const anchor = selection.anchor;
-            const anchorNode = anchor.getNode();
-            const prevSibling = anchorNode.getPreviousSibling();
-            return $isTextNode(prevSibling) && prevSibling.isTextEntity();
-        }
-        return false;
-    });
-}
-function startTransition(callback) {
-    if (React.startTransition) {
-        React.startTransition(callback);
-    } else {
-        callback();
-    }
-}
-// Got from https://stackoverflow.com/a/42543908/2013580
-export 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;
-}
-export { useDynamicPositioning } from './LexicalMenu.js';
-export const ENABLE_SLASH_MENU_COMMAND = createCommand('ENABLE_SLASH_MENU_COMMAND');
-export function LexicalTypeaheadMenuPlugin({ anchorClassName, anchorElem, groupsWithOptions, menuRenderFn, onClose, onOpen, onQueryChange, onSelectOption, triggerFn }) {
-    const [editor] = useLexicalComposerContext();
-    const [resolution, setResolution] = useState(null);
-    const anchorElementRef = useMenuAnchorRef(anchorElem, resolution, setResolution, anchorClassName);
-    const closeTypeahead = useCallback(()=>{
-        setResolution(null);
-        if (onClose != null && resolution !== null) {
-            onClose();
-        }
-    }, [
-        onClose,
-        resolution
-    ]);
-    const openTypeahead = 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
-    useEffect(()=>{
-        return mergeRegister(editor.registerCommand(ENABLE_SLASH_MENU_COMMAND, ({ node })=>{
-            editor.getEditorState().read(()=>{
-                const match = {
-                    leadOffset: 0,
-                    matchingString: '',
-                    replaceableString: ''
-                };
-                if (match !== null && !isSelectionOnEntityBoundary(editor, match.leadOffset)) {
-                    if (node !== null) {
-                        const editorWindow = editor._window ?? window;
-                        const range = editorWindow.document.createRange();
-                        const isRangePositioned = tryToPositionRange(match.leadOffset, range, editorWindow);
-                        if (isRangePositioned !== null) {
-                            startTransition(()=>openTypeahead({
-                                    getRect: ()=>{
-                                        return range.getBoundingClientRect();
-                                    },
-                                    match
-                                }));
-                        }
-                        return;
-                    }
-                }
-            });
-            return true;
-        }, COMMAND_PRIORITY_LOW));
-    }, [
-        editor,
-        openTypeahead
-    ]);
-    useEffect(()=>{
-        const updateListener = ()=>{
-            editor.getEditorState().read(()=>{
-                const editorWindow = editor._window ?? window;
-                const range = editorWindow.document.createRange();
-                const selection = $getSelection();
-                const text = getQueryTextForSearch(editor);
-                if (!$isRangeSelection(selection) || !selection.isCollapsed() || text === null || range === null) {
-                    closeTypeahead();
-                    return;
-                }
-                const match = triggerFn({
-                    editor,
-                    query: text
-                });
-                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: ()=>{
-                                    return 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, {
-        anchorElementRef: anchorElementRef,
-        close: closeTypeahead,
-        editor: editor,
-        groupsWithOptions: groupsWithOptions,
-        menuRenderFn: menuRenderFn,
-        onSelectOption: onSelectOption,
-        resolution: resolution,
-        shouldSplitNodeWithQuery: true
-    });
-}
-
-//# sourceMappingURL=index.js.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../../src/field/lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/index.tsx"],"sourcesContent":["'use client'\nimport type {\n  LexicalCommand,\n  LexicalEditor,\n  ParagraphNode,\n  RangeSelection,\n  TextNode,\n} from 'lexical'\n\nimport lexicalComposerContextImport from '@lexical/react/LexicalComposerContext.js'\nconst { useLexicalComposerContext } = lexicalComposerContextImport\n\nimport lexicalUtilsImport from '@lexical/utils'\nconst { mergeRegister } = lexicalUtilsImport\n\nimport lexicalImport from 'lexical'\nconst { $getSelection, $isRangeSelection, $isTextNode, COMMAND_PRIORITY_LOW, createCommand } =\n  lexicalImport\n\nimport { useCallback, useEffect, useState } from 'react'\nimport * as React from 'react'\n\nimport type { MenuTextMatch, TriggerFn } from '../useMenuTriggerMatch.js'\nimport type { MenuRenderFn, MenuResolution } from './LexicalMenu.js'\nimport type { SlashMenuGroup, SlashMenuOption } from './types.js'\n\nimport { LexicalMenu, useMenuAnchorRef } from './LexicalMenu.js'\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    // if endOffset is 0, positioning the range for when you click the plus button to open the slash menu will fial\n    range.setEnd(anchorNode, endOffset > 1 ? endOffset : 1)\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.js'\n\nexport type TypeaheadMenuPluginProps = {\n  anchorClassName?: string\n  anchorElem: HTMLElement\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  node: ParagraphNode\n}> = createCommand('ENABLE_SLASH_MENU_COMMAND')\n\nexport function LexicalTypeaheadMenuPlugin({\n  anchorClassName,\n  anchorElem,\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(anchorElem, 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        ({ node }) => {\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 (node !== null) {\n                const editorWindow = editor._window ?? window\n                const range = editorWindow.document.createRange()\n\n                const isRangePositioned = tryToPositionRange(match.leadOffset, range, editorWindow)\n                if (isRangePositioned !== null) {\n                  startTransition(() =>\n                    openTypeahead({\n                      getRect: () => {\n                        return range.getBoundingClientRect()\n                      },\n                      match,\n                    }),\n                  )\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({ editor, query: text })\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: () => {\n                  return range.getBoundingClientRect()\n                },\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 type { MenuRenderFn, MenuResolution, MenuTextMatch, TriggerFn }\n"],"names":["lexicalComposerContextImport","useLexicalComposerContext","lexicalUtilsImport","mergeRegister","lexicalImport","$getSelection","$isRangeSelection","$isTextNode","COMMAND_PRIORITY_LOW","createCommand","useCallback","useEffect","useState","React","LexicalMenu","useMenuAnchorRef","PUNCTUATION","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","isSelectionOnEntityBoundary","prevSibling","getPreviousSibling","isTextEntity","startTransition","callback","getScrollParent","element","includeHidden","style","getComputedStyle","excludeStaticParent","position","overflowRegex","document","body","parent","parentElement","test","overflow","overflowY","overflowX","useDynamicPositioning","ENABLE_SLASH_MENU_COMMAND","LexicalTypeaheadMenuPlugin","anchorClassName","anchorElem","groupsWithOptions","menuRenderFn","onClose","onOpen","onQueryChange","onSelectOption","triggerFn","resolution","setResolution","anchorElementRef","closeTypeahead","openTypeahead","res","registerCommand","node","match","matchingString","replaceableString","_window","window","createRange","isRangePositioned","getRect","getBoundingClientRect","updateListener","query","removeUpdateListener","registerUpdateListener","close","shouldSplitNodeWithQuery"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

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

@@ -1,39 +0,0 @@
-import type { I18n } from '@payloadcms/translations';
-import type { LexicalEditor } from 'lexical';
-import type { MutableRefObject } from 'react';
-import type React from 'react';
-export declare class SlashMenuOption {
-    Icon: React.FC;
-    displayName?: (({ i18n }: {
-        i18n: I18n;
-    }) => string) | string;
-    key: string;
-    keyboardShortcut?: string;
-    keywords: Array<string>;
-    onSelect: ({ editor, queryString }: {
-        editor: LexicalEditor;
-        queryString: string;
-    }) => void;
-    ref?: MutableRefObject<HTMLElement | null>;
-    constructor(key: string, options: {
-        Icon: React.FC;
-        displayName?: (({ i18n }: {
-            i18n: I18n;
-        }) => string) | string;
-        keyboardShortcut?: string;
-        keywords?: Array<string>;
-        onSelect: ({ editor, queryString }: {
-            editor: LexicalEditor;
-            queryString: string;
-        }) => void;
-    });
-    setRefElement(element: HTMLElement | null): void;
-}
-export declare class SlashMenuGroup {
-    displayName?: (({ i18n }: {
-        i18n: I18n;
-    }) => string) | string;
-    key: string;
-    options: Array<SlashMenuOption>;
-}
-//# sourceMappingURL=types.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../../src/field/lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,0BAA0B,CAAA;AACpD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAC5C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,OAAO,CAAA;AAC7C,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,qBAAa,eAAe;IAE1B,IAAI,EAAE,KAAK,CAAC,EAAE,CAAA;IAEd,WAAW,CAAC,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE;QAAE,IAAI,EAAE,IAAI,CAAA;KAAE,KAAK,MAAM,CAAC,GAAG,MAAM,CAAA;IAE7D,GAAG,EAAE,MAAM,CAAA;IAEX,gBAAgB,CAAC,EAAE,MAAM,CAAA;IAEzB,QAAQ,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;IAEvB,QAAQ,EAAE,CAAC,EAAE,MAAM,EAAE,WAAW,EAAE,EAAE;QAAE,MAAM,EAAE,aAAa,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,CAAA;IAE3F,GAAG,CAAC,EAAE,gBAAgB,CAAC,WAAW,GAAG,IAAI,CAAC,CAAA;gBAGxC,GAAG,EAAE,MAAM,EACX,OAAO,EAAE;QACP,IAAI,EAAE,KAAK,CAAC,EAAE,CAAA;QACd,WAAW,CAAC,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE;YAAE,IAAI,EAAE,IAAI,CAAA;SAAE,KAAK,MAAM,CAAC,GAAG,MAAM,CAAA;QAC7D,gBAAgB,CAAC,EAAE,MAAM,CAAA;QACzB,QAAQ,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;QACxB,QAAQ,EAAE,CAAC,EAAE,MAAM,EAAE,WAAW,EAAE,EAAE;YAAE,MAAM,EAAE,aAAa,CAAC;YAAC,WAAW,EAAE,MAAM,CAAA;SAAE,KAAK,IAAI,CAAA;KAC5F;IAaH,aAAa,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI;CAG1C;AAED,qBAAa,cAAc;IAEzB,WAAW,CAAC,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE;QAAE,IAAI,EAAE,IAAI,CAAA;KAAE,KAAK,MAAM,CAAC,GAAG,MAAM,CAAA;IAC7D,GAAG,EAAE,MAAM,CAAA;IACX,OAAO,EAAE,KAAK,CAAC,eAAe,CAAC,CAAA;CAChC"}

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

@@ -1,39 +0,0 @@
-export class SlashMenuOption {
-    // Icon for display
-    Icon;
-    displayName;
-    // Used for class names and, if displayName is not provided, for display.
-    key;
-    // TBD
-    keyboardShortcut;
-    // For extra searching.
-    keywords;
-    // What happens when you select this option?
-    onSelect;
-    ref;
-    constructor(key, options){
-        this.key = key;
-        this.ref = {
-            current: null
-        };
-        this.setRefElement = this.setRefElement.bind(this);
-        this.displayName = options.displayName;
-        this.keywords = options.keywords || [];
-        this.Icon = options.Icon;
-        this.keyboardShortcut = options.keyboardShortcut;
-        this.onSelect = options.onSelect.bind(this);
-    }
-    setRefElement(element) {
-        this.ref = {
-            current: element
-        };
-    }
-}
-export class SlashMenuGroup {
-    // Used for class names and, if displayName is not provided, for display.
-    displayName;
-    key;
-    options;
-}
-
-//# sourceMappingURL=types.js.map

package/dist/field/lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/types.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../../src/field/lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/types.ts"],"sourcesContent":["import type { I18n } from '@payloadcms/translations'\nimport type { LexicalEditor } from 'lexical'\nimport type { MutableRefObject } from 'react'\nimport type React from 'react'\n\nexport class SlashMenuOption {\n  // Icon for display\n  Icon: React.FC\n\n  displayName?: (({ i18n }: { i18n: I18n }) => string) | string\n  // Used for class names and, if displayName is not provided, 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\n  ref?: MutableRefObject<HTMLElement | null>\n\n  constructor(\n    key: string,\n    options: {\n      Icon: React.FC\n      displayName?: (({ i18n }: { i18n: I18n }) => string) | string\n      keyboardShortcut?: string\n      keywords?: Array<string>\n      onSelect: ({ editor, queryString }: { editor: LexicalEditor; queryString: string }) => void\n    },\n  ) {\n    this.key = key\n    this.ref = { current: null }\n    this.setRefElement = this.setRefElement.bind(this)\n\n    this.displayName = options.displayName\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 class SlashMenuGroup {\n  // Used for class names and, if displayName is not provided, for display.\n  displayName?: (({ i18n }: { i18n: I18n }) => string) | string\n  key: string\n  options: Array<SlashMenuOption>\n}\n"],"names":["SlashMenuOption","Icon","displayName","key","keyboardShortcut","keywords","onSelect","ref","constructor","options","current","setRefElement","bind","element","SlashMenuGroup"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAKA,OAAO,MAAMA;IACX,mBAAmB;IACnBC,KAAc;IAEdC,YAA6D;IAC7D,yEAAyE;IACzEC,IAAW;IACX,MAAM;IACNC,iBAAyB;IACzB,uBAAuB;IACvBC,SAAuB;IACvB,4CAA4C;IAC5CC,SAA2F;IAE3FC,IAA0C;IAE1CC,YACEL,GAAW,EACXM,OAMC,CACD;QACA,IAAI,CAACN,GAAG,GAAGA;QACX,IAAI,CAACI,GAAG,GAAG;YAAEG,SAAS;QAAK;QAC3B,IAAI,CAACC,aAAa,GAAG,IAAI,CAACA,aAAa,CAACC,IAAI,CAAC,IAAI;QAEjD,IAAI,CAACV,WAAW,GAAGO,QAAQP,WAAW;QACtC,IAAI,CAACG,QAAQ,GAAGI,QAAQJ,QAAQ,IAAI,EAAE;QACtC,IAAI,CAACJ,IAAI,GAAGQ,QAAQR,IAAI;QACxB,IAAI,CAACG,gBAAgB,GAAGK,QAAQL,gBAAgB;QAChD,IAAI,CAACE,QAAQ,GAAGG,QAAQH,QAAQ,CAACM,IAAI,CAAC,IAAI;IAC5C;IAEAD,cAAcE,OAA2B,EAAE;QACzC,IAAI,CAACN,GAAG,GAAG;YAAEG,SAASG;QAAQ;IAChC;AACF;AAEA,OAAO,MAAMC;IACX,yEAAyE;IACzEZ,YAA6D;IAC7DC,IAAW;IACXM,QAA+B;AACjC"}

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

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/field/lexical/plugins/SlashMenu/index.tsx"],"names":[],"mappings":";AAeA,OAAO,cAAc,CAAA;AAsDrB,wBAAgB,eAAe,CAAC,EAC9B,UAA0B,GAC3B,EAAE;IACD,UAAU,CAAC,EAAE,WAAW,CAAA;CACzB,GAAG,GAAG,CAAC,OAAO,CA8Jd"}

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

@@ -1,172 +0,0 @@
-'use client';
-import lexicalComposerContextImport from '@lexical/react/LexicalComposerContext.js';
-const { useLexicalComposerContext } = lexicalComposerContextImport;
-import { useTranslation } from '@payloadcms/ui/providers/Translation';
-import { useCallback, useMemo, useState } from 'react';
-import * as React from 'react';
-import * as ReactDOM from 'react-dom';
-import { useEditorConfigContext } from '../../config/client/EditorConfigProvider.js';
-import { LexicalTypeaheadMenuPlugin } from './LexicalTypeaheadMenuPlugin/index.js';
-import './index.scss';
-import { useMenuTriggerMatch } from './useMenuTriggerMatch.js';
-const baseClass = 'slash-menu-popup';
-function SlashMenuItem({ isSelected, onClick, onMouseEnter, option }) {
-    const { i18n } = useTranslation();
-    let className = `${baseClass}__item ${baseClass}__item-${option.key}`;
-    if (isSelected) {
-        className += ` ${baseClass}__item--selected`;
-    }
-    let title = option.key;
-    if (option.displayName) {
-        title = typeof option.displayName === 'function' ? option.displayName({
-            i18n
-        }) : option.displayName;
-    }
-    // Crop title to max. 50 characters
-    if (title.length > 25) {
-        title = title.substring(0, 25) + '...';
-    }
-    return /*#__PURE__*/ React.createElement("button", {
-        "aria-selected": isSelected,
-        className: className,
-        id: baseClass + '__item-' + option.key,
-        key: option.key,
-        onClick: onClick,
-        onMouseEnter: onMouseEnter,
-        ref: option.setRefElement,
-        role: "option",
-        tabIndex: -1,
-        type: "button"
-    }, option?.Icon && /*#__PURE__*/ React.createElement(option.Icon, null), /*#__PURE__*/ React.createElement("span", {
-        className: `${baseClass}__item-text`
-    }, title));
-}
-export function SlashMenuPlugin({ anchorElem = document.body }) {
-    const [editor] = useLexicalComposerContext();
-    const [queryString, setQueryString] = useState(null);
-    const { editorConfig } = useEditorConfigContext();
-    const { i18n } = useTranslation();
-    const checkForTriggerMatch = useMenuTriggerMatch('/', {
-        minLength: 0
-    });
-    const getDynamicOptions = 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 = 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)=>{
-                    let optionTitle = option.key;
-                    if (option.displayName) {
-                        optionTitle = typeof option.displayName === 'function' ? option.displayName({
-                            i18n
-                        }) : option.displayName;
-                    }
-                    return new RegExp(queryString, 'gi').exec(optionTitle) || 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.key === dynamicGroup.key);
-                if (!group) {
-                    group = {
-                        ...dynamicGroup,
-                        options: []
-                    };
-                } else {
-                    groupsWithOptions = groupsWithOptions.filter((group)=>group.key !== dynamicGroup.key);
-                }
-                // 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,
-        i18n
-    ]);
-    const onSelectOption = 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, {
-        anchorElem: anchorElem,
-        groupsWithOptions: groups,
-        menuRenderFn: (anchorElementRef, { selectOptionAndCleanUp, selectedOptionKey, setSelectedOptionKey })=>anchorElementRef.current && groups.length ? /*#__PURE__*/ ReactDOM.createPortal(/*#__PURE__*/ React.createElement("div", {
-                className: baseClass
-            }, groups.map((group)=>{
-                let groupTitle = group.key;
-                if (group.displayName) {
-                    groupTitle = typeof group.displayName === 'function' ? group.displayName({
-                        i18n
-                    }) : group.displayName;
-                }
-                return /*#__PURE__*/ React.createElement("div", {
-                    className: `${baseClass}__group ${baseClass}__group-${group.key}`,
-                    key: group.key
-                }, /*#__PURE__*/ React.createElement("div", {
-                    className: `${baseClass}__group-title`
-                }, groupTitle), 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=index.js.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../src/field/lexical/plugins/SlashMenu/index.tsx"],"sourcesContent":["'use client'\nimport type { TextNode } from 'lexical'\n\nimport lexicalComposerContextImport from '@lexical/react/LexicalComposerContext.js'\nconst { useLexicalComposerContext } = lexicalComposerContextImport\n\nimport { useTranslation } from '@payloadcms/ui/providers/Translation'\nimport { useCallback, useMemo, useState } from 'react'\nimport * as React from 'react'\nimport * as ReactDOM from 'react-dom'\n\nimport type { SlashMenuGroup, SlashMenuOption } from './LexicalTypeaheadMenuPlugin/types.js'\n\nimport { useEditorConfigContext } from '../../config/client/EditorConfigProvider.js'\nimport { LexicalTypeaheadMenuPlugin } from './LexicalTypeaheadMenuPlugin/index.js'\nimport './index.scss'\nimport { useMenuTriggerMatch } from './useMenuTriggerMatch.js'\n\nconst baseClass = 'slash-menu-popup'\n\nfunction SlashMenuItem({\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  const { i18n } = useTranslation()\n\n  let className = `${baseClass}__item ${baseClass}__item-${option.key}`\n  if (isSelected) {\n    className += ` ${baseClass}__item--selected`\n  }\n\n  let title = option.key\n  if (option.displayName) {\n    title =\n      typeof option.displayName === 'function' ? option.displayName({ i18n }) : option.displayName\n  }\n  // Crop title to max. 50 characters\n  if (title.length > 25) {\n    title = title.substring(0, 25) + '...'\n  }\n\n  return (\n    <button\n      aria-selected={isSelected}\n      className={className}\n      id={baseClass + '__item-' + option.key}\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 && <option.Icon />}\n\n      <span className={`${baseClass}__item-text`}>{title}</span>\n    </button>\n  )\n}\n\nexport function SlashMenuPlugin({\n  anchorElem = document.body,\n}: {\n  anchorElem?: HTMLElement\n}): JSX.Element {\n  const [editor] = useLexicalComposerContext()\n  const [queryString, setQueryString] = useState<null | string>(null)\n  const { editorConfig } = useEditorConfigContext()\n  const { i18n } = useTranslation()\n\n  const checkForTriggerMatch = useMenuTriggerMatch('/', {\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          let optionTitle = option.key\n          if (option.displayName) {\n            optionTitle =\n              typeof option.displayName === 'function'\n                ? option.displayName({ i18n })\n                : option.displayName\n          }\n\n          return new RegExp(queryString, 'gi').exec(optionTitle) || 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.key === dynamicGroup.key)\n        if (!group) {\n          group = {\n            ...dynamicGroup,\n            options: [],\n          }\n        } else {\n          groupsWithOptions = groupsWithOptions.filter((group) => group.key !== dynamicGroup.key)\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, i18n])\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        anchorElem={anchorElem}\n        groupsWithOptions={groups}\n        menuRenderFn={(\n          anchorElementRef,\n          { selectOptionAndCleanUp, selectedOptionKey, setSelectedOptionKey },\n        ) =>\n          anchorElementRef.current && groups.length\n            ? ReactDOM.createPortal(\n                <div className={baseClass}>\n                  {groups.map((group) => {\n                    let groupTitle = group.key\n                    if (group.displayName) {\n                      groupTitle =\n                        typeof group.displayName === 'function'\n                          ? group.displayName({ i18n })\n                          : group.displayName\n                    }\n\n                    return (\n                      <div\n                        className={`${baseClass}__group ${baseClass}__group-${group.key}`}\n                        key={group.key}\n                      >\n                        <div className={`${baseClass}__group-title`}>{groupTitle}</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                  })}\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":["lexicalComposerContextImport","useLexicalComposerContext","useTranslation","useCallback","useMemo","useState","React","ReactDOM","useEditorConfigContext","LexicalTypeaheadMenuPlugin","useMenuTriggerMatch","baseClass","SlashMenuItem","isSelected","onClick","onMouseEnter","option","i18n","className","key","title","displayName","length","substring","button","aria-selected","id","ref","setRefElement","role","tabIndex","type","Icon","span","SlashMenuPlugin","anchorElem","document","body","editor","queryString","setQueryString","editorConfig","checkForTriggerMatch","minLength","getDynamicOptions","groupWithOptions","dynamicOption","features","slashMenu","dynamicOptions","dynamicGroupWithOptions","concat","groups","groupsWithOptions","groupWithOption","push","map","group","filteredOptions","options","filter","optionTitle","RegExp","exec","keywords","some","keyword","dynamicOptionGroups","dynamicGroup","find","onSelectOption","selectedOption","nodeToRemove","closeMenu","matchingString","update","remove","onSelect","Fragment","menuRenderFn","anchorElementRef","selectOptionAndCleanUp","selectedOptionKey","setSelectedOptionKey","current","createPortal","div","groupTitle","oi","index","onQueryChange","triggerFn"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

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

@@ -1,61 +0,0 @@
-@import '../../../../scss/styles.scss';
-
-html[data-theme='light'] {
-  .slash-menu-popup {
-    @include shadow-m;
-  }
-}
-
-.slash-menu-popup {
-  background: var(--color-base-0);
-  width: 200px;
-  color: var(--color-base-800);
-  border-radius: 4px;
-  list-style: none;
-  font-family: var(--font-body);
-  max-height: 300px;
-  overflow-y: auto;
-  z-index: 10;
-  position: absolute;
-
-  &__group {
-    padding-bottom: 8px;
-  }
-
-  &__group-title {
-    padding-left: 10px;
-    color: var(--color-base-600);
-    font-size: 10px;
-  }
-
-  &__item {
-    all: unset;
-    padding-left: 12px;
-    font-size: 13px;
-    box-sizing: border-box;
-    background: none;
-    border: none;
-    color: var(--color-base-900);
-    display: flex;
-    align-items: center;
-    height: 30px;
-    width: 100%;
-    cursor: pointer;
-
-    &--selected {
-      background: var(--color-base-100);
-    }
-
-    &-text {
-      margin-left: 6px;
-      overflow: hidden;
-      white-space: nowrap;
-      text-overflow: ellipsis;
-    }
-
-    .icon {
-      color: var(--color-base-500);
-      min-width: fit-content;
-    }
-  }
-}

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

@@ -1 +0,0 @@
-{"version":3,"file":"useMenuTriggerMatch.d.ts","sourceRoot":"","sources":["../../../../../src/field/lexical/plugins/SlashMenu/useMenuTriggerMatch.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAM5C,MAAM,MAAM,SAAS,GAAG,CAAC,EACvB,MAAM,EACN,KAAK,GACN,EAAE;IACD,MAAM,EAAE,aAAa,CAAA;IACrB,qFAAqF;IACrF,KAAK,EAAE,MAAM,CAAA;CACd,KAAK,aAAa,GAAG,IAAI,CAAA;AAE1B,MAAM,MAAM,aAAa,GAAG;IAC1B,UAAU,EAAE,MAAM,CAAA;IAClB,cAAc,EAAE,MAAM,CAAA;IACtB,iBAAiB,EAAE,MAAM,CAAA;CAC1B,CAAA;AAED;;GAEG;AACH,wBAAgB,mBAAmB;AACjC;;GAEG;AACH,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,CAqCX"}

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

@@ -1,33 +0,0 @@
-import { useCallback } from 'react';
-import { PUNCTUATION } from './LexicalTypeaheadMenuPlugin/index.js';
-/**
- * Returns a function which checks if the trigger (e.g. '/') is present in the query and, if so, returns the matching string (text after the trigger)
- */ export function useMenuTriggerMatch(/**
-   * Text which triggers the menu. Everything after this text will be used as the query.
-   */ trigger, { maxLength = 75, minLength = 1 }) {
-    return useCallback(({ query })=>{
-        const validChars = '[^' + trigger + PUNCTUATION + '\\s]';
-        const TypeaheadTriggerRegex = new RegExp('(^|\\s|\\()(' + '[' + trigger + ']' + '((?:' + validChars + '){0,' + maxLength + '})' + ')$');
-        const match = TypeaheadTriggerRegex.exec(query);
-        if (match !== null) {
-            const maybeLeadingWhitespace = match[1];
-            /**
-         * matchingString is only the text AFTER the trigger text. (So everything after the /)
-         */ const matchingString = match[3];
-            if (matchingString.length >= minLength) {
-                return {
-                    leadOffset: match.index + maybeLeadingWhitespace.length,
-                    matchingString,
-                    replaceableString: match[2]
-                };
-            }
-        }
-        return null;
-    }, [
-        maxLength,
-        minLength,
-        trigger
-    ]);
-}
-
-//# sourceMappingURL=useMenuTriggerMatch.js.map