@payloadcms/richtext-lexical 0.1.0-beta.0

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

@@ -0,0 +1,272 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "FloatingSelectToolbarPlugin", {
+    enumerable: true,
+    get: function() {
+        return FloatingSelectToolbarPlugin;
+    }
+});
+const _LexicalComposerContext = require("@lexical/react/LexicalComposerContext");
+const _utils = require("@lexical/utils");
+const _lexical = require("lexical");
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _reactdom = require("react-dom");
+const _EditorConfigProvider = require("../../config/EditorConfigProvider");
+const _getDOMRangeRect = require("../../utils/getDOMRangeRect");
+const _setFloatingElemPosition = require("../../utils/setFloatingElemPosition");
+const _ToolbarButton = require("./ToolbarButton");
+const _ToolbarDropdown = require("./ToolbarDropdown");
+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 FloatingSelectToolbar({ anchorElem, editor }) {
+    const popupCharStylesEditorRef = (0, _react.useRef)(null);
+    const caretRef = (0, _react.useRef)(null);
+    const { editorConfig } = (0, _EditorConfigProvider.useEditorConfigContext)();
+    function mouseMoveListener(e) {
+        if (popupCharStylesEditorRef?.current && (e.buttons === 1 || e.buttons === 3)) {
+            const isOpacityZero = popupCharStylesEditorRef.current.style.opacity === '0';
+            const isPointerEventsNone = popupCharStylesEditorRef.current.style.pointerEvents === 'none';
+            if (!isOpacityZero || !isPointerEventsNone) {
+                // Check if the mouse is not over the popup
+                const x = e.clientX;
+                const y = e.clientY;
+                const elementUnderMouse = document.elementFromPoint(x, y);
+                if (!popupCharStylesEditorRef.current.contains(elementUnderMouse)) {
+                    // Mouse is not over the target element => not a normal click, but probably a drag
+                    if (!isOpacityZero) {
+                        popupCharStylesEditorRef.current.style.opacity = '0';
+                    }
+                    if (!isPointerEventsNone) {
+                        popupCharStylesEditorRef.current.style.pointerEvents = 'none';
+                    }
+                }
+            }
+        }
+    }
+    function mouseUpListener(e) {
+        if (popupCharStylesEditorRef?.current) {
+            if (popupCharStylesEditorRef.current.style.opacity !== '1') {
+                popupCharStylesEditorRef.current.style.opacity = '1';
+            }
+            if (popupCharStylesEditorRef.current.style.pointerEvents !== 'auto') {
+                popupCharStylesEditorRef.current.style.pointerEvents = 'auto';
+            }
+        }
+    }
+    (0, _react.useEffect)(()=>{
+        document.addEventListener('mousemove', mouseMoveListener);
+        document.addEventListener('mouseup', mouseUpListener);
+        return ()=>{
+            document.removeEventListener('mousemove', mouseMoveListener);
+            document.removeEventListener('mouseup', mouseUpListener);
+        };
+    }, [
+        popupCharStylesEditorRef
+    ]);
+    const updateTextFormatFloatingToolbar = (0, _react.useCallback)(()=>{
+        const selection = (0, _lexical.$getSelection)();
+        const popupCharStylesEditorElem = popupCharStylesEditorRef.current;
+        const nativeSelection = window.getSelection();
+        if (popupCharStylesEditorElem === null) {
+            return;
+        }
+        const rootElement = editor.getRootElement();
+        if (selection !== null && nativeSelection !== null && !nativeSelection.isCollapsed && rootElement !== null && rootElement.contains(nativeSelection.anchorNode)) {
+            const rangeRect = (0, _getDOMRangeRect.getDOMRangeRect)(nativeSelection, rootElement);
+            (0, _setFloatingElemPosition.setFloatingElemPosition)(rangeRect, popupCharStylesEditorElem, anchorElem, 'center');
+            if (caretRef.current) {
+                (0, _setFloatingElemPosition.setFloatingElemPosition)(rangeRect, caretRef.current, popupCharStylesEditorElem, 'center');
+            }
+        }
+    }, [
+        editor,
+        anchorElem
+    ]);
+    (0, _react.useEffect)(()=>{
+        const scrollerElem = anchorElem.parentElement;
+        const update = ()=>{
+            editor.getEditorState().read(()=>{
+                updateTextFormatFloatingToolbar();
+            });
+        };
+        window.addEventListener('resize', update);
+        if (scrollerElem) {
+            scrollerElem.addEventListener('scroll', update);
+        }
+        return ()=>{
+            window.removeEventListener('resize', update);
+            if (scrollerElem) {
+                scrollerElem.removeEventListener('scroll', update);
+            }
+        };
+    }, [
+        editor,
+        updateTextFormatFloatingToolbar,
+        anchorElem
+    ]);
+    (0, _react.useEffect)(()=>{
+        editor.getEditorState().read(()=>{
+            updateTextFormatFloatingToolbar();
+        });
+        return (0, _utils.mergeRegister)(editor.registerUpdateListener(({ editorState })=>{
+            editorState.read(()=>{
+                updateTextFormatFloatingToolbar();
+            });
+        }), editor.registerCommand(_lexical.SELECTION_CHANGE_COMMAND, ()=>{
+            updateTextFormatFloatingToolbar();
+            return false;
+        }, _lexical.COMMAND_PRIORITY_LOW));
+    }, [
+        editor,
+        updateTextFormatFloatingToolbar
+    ]);
+    return /*#__PURE__*/ _react.createElement("div", {
+        className: "floating-select-toolbar-popup",
+        ref: popupCharStylesEditorRef
+    }, /*#__PURE__*/ _react.createElement("div", {
+        className: "caret",
+        ref: caretRef
+    }), editor.isEditable() && /*#__PURE__*/ _react.createElement(_react.Fragment, null, editorConfig?.features && editorConfig.features?.floatingSelectToolbar?.sections.map((section, i)=>{
+        return /*#__PURE__*/ _react.createElement("div", {
+            className: `floating-select-toolbar-popup__section floating-select-toolbar-popup__section-${section.key}`,
+            key: section.key
+        }, section.type === 'dropdown' && section.entries.length && /*#__PURE__*/ _react.createElement(_ToolbarDropdown.ToolbarDropdown, {
+            Icon: section.ChildComponent,
+            entries: section.entries
+        }), section.type === 'buttons' && section.entries.length && section.entries.map((entry)=>{
+            if (entry.Component) {
+                return /*#__PURE__*/ _react.createElement(entry.Component, {
+                    anchorElem: anchorElem,
+                    editor: editor,
+                    entry: entry,
+                    key: entry.key
+                });
+            }
+            return /*#__PURE__*/ _react.createElement(_ToolbarButton.ToolbarButton, {
+                entry: entry,
+                key: entry.key
+            }, /*#__PURE__*/ _react.createElement(entry.ChildComponent, null));
+        }), i < editorConfig.features.floatingSelectToolbar?.sections.length - 1 && /*#__PURE__*/ _react.createElement("div", {
+            className: "divider"
+        }));
+    })));
+}
+function useFloatingTextFormatToolbar(editor, anchorElem) {
+    const [isText, setIsText] = (0, _react.useState)(false);
+    const updatePopup = (0, _react.useCallback)(()=>{
+        editor.getEditorState().read(()=>{
+            // Should not to pop up the floating toolbar when using IME input
+            if (editor.isComposing()) {
+                return;
+            }
+            const selection = (0, _lexical.$getSelection)();
+            const nativeSelection = window.getSelection();
+            const rootElement = editor.getRootElement();
+            if (nativeSelection !== null && (!(0, _lexical.$isRangeSelection)(selection) || rootElement === null || !rootElement.contains(nativeSelection.anchorNode))) {
+                setIsText(false);
+                return;
+            }
+            if (!(0, _lexical.$isRangeSelection)(selection)) {
+                return;
+            }
+            if (selection.getTextContent() !== '') {
+                const nodes = selection.getNodes();
+                let foundNodeWithText = false;
+                for (const node of nodes){
+                    if ((0, _lexical.$isTextNode)(node)) {
+                        setIsText(true);
+                        foundNodeWithText = true;
+                        break;
+                    }
+                }
+                if (!foundNodeWithText) {
+                    setIsText(false);
+                }
+            } else {
+                setIsText(false);
+            }
+            const rawTextContent = selection.getTextContent().replace(/\n/g, '');
+            if (!selection.isCollapsed() && rawTextContent === '') {
+                setIsText(false);
+                return;
+            }
+        });
+    }, [
+        editor
+    ]);
+    (0, _react.useEffect)(()=>{
+        document.addEventListener('selectionchange', updatePopup);
+        document.addEventListener('mouseup', updatePopup);
+        return ()=>{
+            document.removeEventListener('selectionchange', updatePopup);
+            document.removeEventListener('mouseup', updatePopup);
+        };
+    }, [
+        updatePopup
+    ]);
+    (0, _react.useEffect)(()=>{
+        return (0, _utils.mergeRegister)(editor.registerUpdateListener(()=>{
+            updatePopup();
+        }), editor.registerRootListener(()=>{
+            if (editor.getRootElement() === null) {
+                setIsText(false);
+            }
+        }));
+    }, [
+        editor,
+        updatePopup
+    ]);
+    if (!isText) {
+        return null;
+    }
+    return /*#__PURE__*/ (0, _reactdom.createPortal)(/*#__PURE__*/ _react.createElement(FloatingSelectToolbar, {
+        anchorElem: anchorElem,
+        editor: editor
+    }), anchorElem);
+}
+function FloatingSelectToolbarPlugin({ anchorElem = document.body }) {
+    const [editor] = (0, _LexicalComposerContext.useLexicalComposerContext)();
+    return useFloatingTextFormatToolbar(editor, anchorElem);
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../../src/field/lexical/plugins/FloatingSelectToolbar/index.tsx"],"sourcesContent":["import type { LexicalEditor } 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  SELECTION_CHANGE_COMMAND,\n} from 'lexical'\nimport { useCallback, useEffect, useRef, useState } from 'react'\nimport * as React from 'react'\nimport { createPortal } from 'react-dom'\n\nimport { useEditorConfigContext } from '../../config/EditorConfigProvider'\nimport { getDOMRangeRect } from '../../utils/getDOMRangeRect'\nimport { getSelectedNode } from '../../utils/getSelectedNode'\nimport { setFloatingElemPosition } from '../../utils/setFloatingElemPosition'\nimport { ToolbarButton } from './ToolbarButton'\nimport { ToolbarDropdown } from './ToolbarDropdown'\nimport './index.scss'\n\nfunction FloatingSelectToolbar({\n  anchorElem,\n  editor,\n}: {\n  anchorElem: HTMLElement\n  editor: LexicalEditor\n}): JSX.Element {\n  const popupCharStylesEditorRef = useRef<HTMLDivElement | null>(null)\n  const caretRef = useRef<HTMLDivElement | null>(null)\n\n  const { editorConfig } = useEditorConfigContext()\n\n  function mouseMoveListener(e: MouseEvent) {\n    if (popupCharStylesEditorRef?.current && (e.buttons === 1 || e.buttons === 3)) {\n      const isOpacityZero = popupCharStylesEditorRef.current.style.opacity === '0'\n      const isPointerEventsNone = popupCharStylesEditorRef.current.style.pointerEvents === 'none'\n      if (!isOpacityZero || !isPointerEventsNone) {\n        // Check if the mouse is not over the popup\n        const x = e.clientX\n        const y = e.clientY\n        const elementUnderMouse = document.elementFromPoint(x, y)\n        if (!popupCharStylesEditorRef.current.contains(elementUnderMouse)) {\n          // Mouse is not over the target element => not a normal click, but probably a drag\n          if (!isOpacityZero) {\n            popupCharStylesEditorRef.current.style.opacity = '0'\n          }\n          if (!isPointerEventsNone) {\n            popupCharStylesEditorRef.current.style.pointerEvents = 'none'\n          }\n        }\n      }\n    }\n  }\n  function mouseUpListener(e: MouseEvent) {\n    if (popupCharStylesEditorRef?.current) {\n      if (popupCharStylesEditorRef.current.style.opacity !== '1') {\n        popupCharStylesEditorRef.current.style.opacity = '1'\n      }\n      if (popupCharStylesEditorRef.current.style.pointerEvents !== 'auto') {\n        popupCharStylesEditorRef.current.style.pointerEvents = 'auto'\n      }\n    }\n  }\n\n  useEffect(() => {\n    document.addEventListener('mousemove', mouseMoveListener)\n    document.addEventListener('mouseup', mouseUpListener)\n\n    return () => {\n      document.removeEventListener('mousemove', mouseMoveListener)\n      document.removeEventListener('mouseup', mouseUpListener)\n    }\n  }, [popupCharStylesEditorRef])\n\n  const updateTextFormatFloatingToolbar = useCallback(() => {\n    const selection = $getSelection()\n\n    const popupCharStylesEditorElem = popupCharStylesEditorRef.current\n    const nativeSelection = window.getSelection()\n\n    if (popupCharStylesEditorElem === null) {\n      return\n    }\n\n    const rootElement = editor.getRootElement()\n    if (\n      selection !== null &&\n      nativeSelection !== null &&\n      !nativeSelection.isCollapsed &&\n      rootElement !== null &&\n      rootElement.contains(nativeSelection.anchorNode)\n    ) {\n      const rangeRect = getDOMRangeRect(nativeSelection, rootElement)\n\n      setFloatingElemPosition(rangeRect, popupCharStylesEditorElem, anchorElem, 'center')\n\n      if (caretRef.current) {\n        setFloatingElemPosition(rangeRect, caretRef.current, popupCharStylesEditorElem, 'center')\n      }\n    }\n  }, [editor, anchorElem])\n\n  useEffect(() => {\n    const scrollerElem = anchorElem.parentElement\n\n    const update = () => {\n      editor.getEditorState().read(() => {\n        updateTextFormatFloatingToolbar()\n      })\n    }\n\n    window.addEventListener('resize', update)\n    if (scrollerElem) {\n      scrollerElem.addEventListener('scroll', update)\n    }\n\n    return () => {\n      window.removeEventListener('resize', update)\n      if (scrollerElem) {\n        scrollerElem.removeEventListener('scroll', update)\n      }\n    }\n  }, [editor, updateTextFormatFloatingToolbar, anchorElem])\n\n  useEffect(() => {\n    editor.getEditorState().read(() => {\n      updateTextFormatFloatingToolbar()\n    })\n    return mergeRegister(\n      editor.registerUpdateListener(({ editorState }) => {\n        editorState.read(() => {\n          updateTextFormatFloatingToolbar()\n        })\n      }),\n\n      editor.registerCommand(\n        SELECTION_CHANGE_COMMAND,\n        () => {\n          updateTextFormatFloatingToolbar()\n          return false\n        },\n        COMMAND_PRIORITY_LOW,\n      ),\n    )\n  }, [editor, updateTextFormatFloatingToolbar])\n\n  return (\n    <div className=\"floating-select-toolbar-popup\" ref={popupCharStylesEditorRef}>\n      <div className=\"caret\" ref={caretRef} />\n      {editor.isEditable() && (\n        <React.Fragment>\n          {editorConfig?.features &&\n            editorConfig.features?.floatingSelectToolbar?.sections.map((section, i) => {\n              return (\n                <div\n                  className={`floating-select-toolbar-popup__section floating-select-toolbar-popup__section-${section.key}`}\n                  key={section.key}\n                >\n                  {section.type === 'dropdown' && section.entries.length && (\n                    <ToolbarDropdown Icon={section.ChildComponent} entries={section.entries} />\n                  )}\n                  {section.type === 'buttons' &&\n                    section.entries.length &&\n                    section.entries.map((entry) => {\n                      if (entry.Component) {\n                        return (\n                          <entry.Component\n                            anchorElem={anchorElem}\n                            editor={editor}\n                            entry={entry}\n                            key={entry.key}\n                          />\n                        )\n                      }\n                      return (\n                        <ToolbarButton entry={entry} key={entry.key}>\n                          <entry.ChildComponent />\n                        </ToolbarButton>\n                      )\n                    })}\n                  {i < editorConfig.features.floatingSelectToolbar?.sections.length - 1 && (\n                    <div className=\"divider\" />\n                  )}\n                </div>\n              )\n            })}\n        </React.Fragment>\n      )}\n    </div>\n  )\n}\n\nfunction useFloatingTextFormatToolbar(\n  editor: LexicalEditor,\n  anchorElem: HTMLElement,\n): JSX.Element | null {\n  const [isText, setIsText] = useState(false)\n\n  const updatePopup = useCallback(() => {\n    editor.getEditorState().read(() => {\n      // Should not to pop up the floating toolbar when using IME input\n      if (editor.isComposing()) {\n        return\n      }\n      const selection = $getSelection()\n      const nativeSelection = window.getSelection()\n      const rootElement = editor.getRootElement()\n\n      if (\n        nativeSelection !== null &&\n        (!$isRangeSelection(selection) ||\n          rootElement === null ||\n          !rootElement.contains(nativeSelection.anchorNode))\n      ) {\n        setIsText(false)\n        return\n      }\n\n      if (!$isRangeSelection(selection)) {\n        return\n      }\n\n      if (selection.getTextContent() !== '') {\n        const nodes = selection.getNodes()\n        let foundNodeWithText = false\n        for (const node of nodes) {\n          if ($isTextNode(node)) {\n            setIsText(true)\n            foundNodeWithText = true\n            break\n          }\n        }\n        if (!foundNodeWithText) {\n          setIsText(false)\n        }\n      } else {\n        setIsText(false)\n      }\n\n      const rawTextContent = selection.getTextContent().replace(/\\n/g, '')\n      if (!selection.isCollapsed() && rawTextContent === '') {\n        setIsText(false)\n        return\n      }\n    })\n  }, [editor])\n\n  useEffect(() => {\n    document.addEventListener('selectionchange', updatePopup)\n    document.addEventListener('mouseup', updatePopup)\n    return () => {\n      document.removeEventListener('selectionchange', updatePopup)\n      document.removeEventListener('mouseup', updatePopup)\n    }\n  }, [updatePopup])\n\n  useEffect(() => {\n    return mergeRegister(\n      editor.registerUpdateListener(() => {\n        updatePopup()\n      }),\n      editor.registerRootListener(() => {\n        if (editor.getRootElement() === null) {\n          setIsText(false)\n        }\n      }),\n    )\n  }, [editor, updatePopup])\n\n  if (!isText) {\n    return null\n  }\n\n  return createPortal(<FloatingSelectToolbar anchorElem={anchorElem} editor={editor} />, anchorElem)\n}\n\nexport function FloatingSelectToolbarPlugin({\n  anchorElem = document.body,\n}: {\n  anchorElem?: HTMLElement\n}): JSX.Element | null {\n  const [editor] = useLexicalComposerContext()\n  return useFloatingTextFormatToolbar(editor, anchorElem)\n}\n"],"names":["FloatingSelectToolbarPlugin","FloatingSelectToolbar","anchorElem","editor","popupCharStylesEditorRef","useRef","caretRef","editorConfig","useEditorConfigContext","mouseMoveListener","e","current","buttons","isOpacityZero","style","opacity","isPointerEventsNone","pointerEvents","x","clientX","y","clientY","elementUnderMouse","document","elementFromPoint","contains","mouseUpListener","useEffect","addEventListener","removeEventListener","updateTextFormatFloatingToolbar","useCallback","selection","$getSelection","popupCharStylesEditorElem","nativeSelection","window","getSelection","rootElement","getRootElement","isCollapsed","anchorNode","rangeRect","getDOMRangeRect","setFloatingElemPosition","scrollerElem","parentElement","update","getEditorState","read","mergeRegister","registerUpdateListener","editorState","registerCommand","SELECTION_CHANGE_COMMAND","COMMAND_PRIORITY_LOW","div","className","ref","isEditable","React","Fragment","features","floatingSelectToolbar","sections","map","section","i","key","type","entries","length","ToolbarDropdown","Icon","ChildComponent","entry","Component","ToolbarButton","useFloatingTextFormatToolbar","isText","setIsText","useState","updatePopup","isComposing","$isRangeSelection","getTextContent","nodes","getNodes","foundNodeWithText","node","$isTextNode","rawTextContent","replace","registerRootListener","createPortal","body","useLexicalComposerContext"],"mappings":"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"}

package/dist/field/lexical/plugins/FloatingSelectToolbar/types.d.ts

@@ -0,0 +1,40 @@
+/// <reference types="react" />
+import type { BaseSelection, LexicalEditor } from 'lexical';
+export type FloatingToolbarSection = {
+    ChildComponent?: React.FC;
+    entries: Array<FloatingToolbarSectionEntry>;
+    key: string;
+    order?: number;
+    type: 'dropdown';
+} | {
+    entries: Array<FloatingToolbarSectionEntry>;
+    key: string;
+    order?: number;
+    type: 'buttons';
+};
+export type FloatingToolbarSectionEntry = {
+    ChildComponent?: React.FC;
+    /** Use component to ignore the children and onClick properties. It does not use the default, pre-defined format Button component */
+    Component?: React.FC<{
+        anchorElem: HTMLElement;
+        editor: LexicalEditor;
+        entry: FloatingToolbarSectionEntry;
+    }>;
+    isActive?: ({ editor, selection }: {
+        editor: LexicalEditor;
+        selection: BaseSelection;
+    }) => boolean;
+    isEnabled?: ({ editor, selection, }: {
+        editor: LexicalEditor;
+        selection: BaseSelection;
+    }) => boolean;
+    key: string;
+    /** The label is displayed as text if the entry is part of a dropdown section */
+    label?: string;
+    onClick?: ({ editor, isActive }: {
+        editor: LexicalEditor;
+        isActive: boolean;
+    }) => void;
+    order?: number;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/field/lexical/plugins/FloatingSelectToolbar/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/field/lexical/plugins/FloatingSelectToolbar/types.ts"],"names":[],"mappings":";AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAE3D,MAAM,MAAM,sBAAsB,GAC9B;IACE,cAAc,CAAC,EAAE,KAAK,CAAC,EAAE,CAAA;IACzB,OAAO,EAAE,KAAK,CAAC,2BAA2B,CAAC,CAAA;IAC3C,GAAG,EAAE,MAAM,CAAA;IACX,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,UAAU,CAAA;CACjB,GACD;IACE,OAAO,EAAE,KAAK,CAAC,2BAA2B,CAAC,CAAA;IAC3C,GAAG,EAAE,MAAM,CAAA;IACX,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,SAAS,CAAA;CAChB,CAAA;AAEL,MAAM,MAAM,2BAA2B,GAAG;IACxC,cAAc,CAAC,EAAE,KAAK,CAAC,EAAE,CAAA;IACzB,oIAAoI;IACpI,SAAS,CAAC,EAAE,KAAK,CAAC,EAAE,CAAC;QACnB,UAAU,EAAE,WAAW,CAAA;QACvB,MAAM,EAAE,aAAa,CAAA;QACrB,KAAK,EAAE,2BAA2B,CAAA;KACnC,CAAC,CAAA;IACF,QAAQ,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,SAAS,EAAE,EAAE;QAAE,MAAM,EAAE,aAAa,CAAC;QAAC,SAAS,EAAE,aAAa,CAAA;KAAE,KAAK,OAAO,CAAA;IAClG,SAAS,CAAC,EAAE,CAAC,EACX,MAAM,EACN,SAAS,GACV,EAAE;QACD,MAAM,EAAE,aAAa,CAAA;QACrB,SAAS,EAAE,aAAa,CAAA;KACzB,KAAK,OAAO,CAAA;IACb,GAAG,EAAE,MAAM,CAAA;IACX,gFAAgF;IAChF,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,OAAO,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,EAAE;QAAE,MAAM,EAAE,aAAa,CAAC;QAAC,QAAQ,EAAE,OAAO,CAAA;KAAE,KAAK,IAAI,CAAA;IACtF,KAAK,CAAC,EAAE,MAAM,CAAA;CACf,CAAA"}

package/dist/field/lexical/plugins/FloatingSelectToolbar/types.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

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

@@ -0,0 +1,10 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+import * as React from 'react';
+export declare const MarkdownShortcutPlugin: React.FC;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/field/lexical/plugins/MarkdownShortcut/index.tsx"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAI9B,eAAO,MAAM,sBAAsB,EAAE,KAAK,CAAC,EAI1C,CAAA"}

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

@@ -0,0 +1,66 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "MarkdownShortcutPlugin", {
+    enumerable: true,
+    get: function() {
+        return MarkdownShortcutPlugin;
+    }
+});
+const _LexicalMarkdownShortcutPlugin = require("@lexical/react/LexicalMarkdownShortcutPlugin");
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _EditorConfigProvider = require("../../config/EditorConfigProvider");
+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 MarkdownShortcutPlugin = ()=>{
+    const { editorConfig } = (0, _EditorConfigProvider.useEditorConfigContext)();
+    return /*#__PURE__*/ _react.createElement(_LexicalMarkdownShortcutPlugin.MarkdownShortcutPlugin, {
+        transformers: editorConfig.features.markdownTransformers
+    });
+};
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9maWVsZC9sZXhpY2FsL3BsdWdpbnMvTWFya2Rvd25TaG9ydGN1dC9pbmRleC50c3giXSwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBDb3B5cmlnaHQgKGMpIE1ldGEgUGxhdGZvcm1zLCBJbmMuIGFuZCBhZmZpbGlhdGVzLlxuICpcbiAqIFRoaXMgc291cmNlIGNvZGUgaXMgbGljZW5zZWQgdW5kZXIgdGhlIE1JVCBsaWNlbnNlIGZvdW5kIGluIHRoZVxuICogTElDRU5TRSBmaWxlIGluIHRoZSByb290IGRpcmVjdG9yeSBvZiB0aGlzIHNvdXJjZSB0cmVlLlxuICpcbiAqL1xuXG5pbXBvcnQgeyBNYXJrZG93blNob3J0Y3V0UGx1Z2luIGFzIExleGljYWxNYXJrZG93blNob3J0Y3V0UGx1Z2luIH0gZnJvbSAnQGxleGljYWwvcmVhY3QvTGV4aWNhbE1hcmtkb3duU2hvcnRjdXRQbHVnaW4nXG5pbXBvcnQgKiBhcyBSZWFjdCBmcm9tICdyZWFjdCdcblxuaW1wb3J0IHsgdXNlRWRpdG9yQ29uZmlnQ29udGV4dCB9IGZyb20gJy4uLy4uL2NvbmZpZy9FZGl0b3JDb25maWdQcm92aWRlcidcblxuZXhwb3J0IGNvbnN0IE1hcmtkb3duU2hvcnRjdXRQbHVnaW46IFJlYWN0LkZDID0gKCkgPT4ge1xuICBjb25zdCB7IGVkaXRvckNvbmZpZyB9ID0gdXNlRWRpdG9yQ29uZmlnQ29udGV4dCgpXG5cbiAgcmV0dXJuIDxMZXhpY2FsTWFya2Rvd25TaG9ydGN1dFBsdWdpbiB0cmFuc2Zvcm1lcnM9e2VkaXRvckNvbmZpZy5mZWF0dXJlcy5tYXJrZG93blRyYW5zZm9ybWVyc30gLz5cbn1cbiJdLCJuYW1lcyI6WyJNYXJrZG93blNob3J0Y3V0UGx1Z2luIiwiZWRpdG9yQ29uZmlnIiwidXNlRWRpdG9yQ29uZmlnQ29udGV4dCIsIkxleGljYWxNYXJrZG93blNob3J0Y3V0UGx1Z2luIiwidHJhbnNmb3JtZXJzIiwiZmVhdHVyZXMiLCJtYXJrZG93blRyYW5zZm9ybWVycyJdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztDQU1DOzs7OytCQU9ZQTs7O2VBQUFBOzs7K0NBTDJEOytEQUNqRDtzQ0FFZ0I7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFFaEMsTUFBTUEseUJBQW1DO0lBQzlDLE1BQU0sRUFBRUMsWUFBWSxFQUFFLEdBQUdDLElBQUFBLDRDQUFzQjtJQUUvQyxxQkFBTyxxQkFBQ0MscURBQTZCO1FBQUNDLGNBQWNILGFBQWFJLFFBQVEsQ0FBQ0Msb0JBQW9COztBQUNoRyJ9

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

@@ -0,0 +1,63 @@
+import type { LexicalCommand, LexicalEditor, TextNode } from 'lexical';
+import type { MutableRefObject, ReactPortal } from 'react';
+export type MenuTextMatch = {
+    leadOffset: number;
+    matchingString: string;
+    replaceableString: string;
+};
+export type MenuResolution = {
+    getRect: () => DOMRect;
+    match?: MenuTextMatch;
+};
+export declare const PUNCTUATION = "\\.,\\+\\*\\?\\$\\@\\|#{}\\(\\)\\^\\-\\[\\]\\\\/!%'\"~=<>_:;";
+export declare class SlashMenuGroup {
+    options: Array<SlashMenuOption>;
+    title: string;
+}
+export declare class SlashMenuOption {
+    Icon: React.FC;
+    key: string;
+    keyboardShortcut?: string;
+    keywords: Array<string>;
+    onSelect: ({ editor, queryString }: {
+        editor: LexicalEditor;
+        queryString: string;
+    }) => void;
+    ref?: MutableRefObject<HTMLElement | null>;
+    title: string;
+    constructor(title: string, options: {
+        Icon: React.FC;
+        keyboardShortcut?: string;
+        keywords?: Array<string>;
+        onSelect: ({ editor, queryString }: {
+            editor: LexicalEditor;
+            queryString: string;
+        }) => void;
+    });
+    setRefElement(element: HTMLElement | null): void;
+}
+export type MenuRenderFn = (anchorElementRef: MutableRefObject<HTMLElement | null>, itemProps: {
+    groupsWithOptions: Array<SlashMenuGroup>;
+    selectOptionAndCleanUp: (selectedOption: SlashMenuOption) => void;
+    selectedOptionKey: null | string;
+    setSelectedOptionKey: (optionKey: string) => void;
+}, matchingString: null | string) => JSX.Element | ReactPortal | null;
+export declare function getScrollParent(element: HTMLElement, includeHidden: boolean): HTMLBodyElement | HTMLElement;
+export declare function useDynamicPositioning(resolution: MenuResolution | null, targetElement: HTMLElement | null, onReposition: () => void, onVisibilityChange?: (isInView: boolean) => void): void;
+export declare const SCROLL_TYPEAHEAD_OPTION_INTO_VIEW_COMMAND: LexicalCommand<{
+    index: number;
+    option: SlashMenuOption;
+}>;
+export declare function LexicalMenu({ anchorElementRef, close, editor, groupsWithOptions, menuRenderFn, onSelectOption, resolution, shouldSplitNodeWithQuery, }: {
+    anchorElementRef: MutableRefObject<HTMLElement>;
+    close: () => void;
+    editor: LexicalEditor;
+    groupsWithOptions: Array<SlashMenuGroup>;
+    menuRenderFn: MenuRenderFn;
+    onSelectOption: (option: SlashMenuOption, textNodeContainingQuery: TextNode | null, closeMenu: () => void, matchingString: string) => void;
+    resolution: MenuResolution;
+    shouldSplitNodeWithQuery?: boolean;
+}): JSX.Element | null;
+export declare function useMenuAnchorRef(resolution: MenuResolution | null, setResolution: (r: MenuResolution | null) => void, className?: string): MutableRefObject<HTMLElement>;
+export type TriggerFn = (text: string, editor: LexicalEditor) => MenuTextMatch | null;
+//# sourceMappingURL=LexicalMenu.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"LexicalMenu.d.ts","sourceRoot":"","sources":["../../../../../../src/field/lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/LexicalMenu.tsx"],"names":[],"mappings":"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"}