@payloadcms/richtext-lexical 3.0.0-beta.4 → 3.0.0-beta.41

package/dist/field/lexical/LexicalEditor.js

@@ -1,38 +1,69 @@
 'use client';
-import lexicalComposerContextImport from '@lexical/react/LexicalComposerContext.js';
-const { useLexicalComposerContext } = lexicalComposerContextImport;
-import LexicalErrorBoundary from '@lexical/react/LexicalErrorBoundary.js';
-import lexicalHistoryPluginImport from '@lexical/react/LexicalHistoryPlugin.js';
-const { HistoryPlugin } = lexicalHistoryPluginImport;
-import lexicalOnChangePluginImport from '@lexical/react/LexicalOnChangePlugin.js';
-const { OnChangePlugin } = lexicalOnChangePluginImport;
-import lexicalRichTextPluginImport from '@lexical/react/LexicalRichTextPlugin.js';
-const { RichTextPlugin } = lexicalRichTextPluginImport;
-import lexicalTabIndentationPluginImport from '@lexical/react/LexicalTabIndentationPlugin.js';
-const { TabIndentationPlugin } = lexicalTabIndentationPluginImport;
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext.js';
+import { LexicalErrorBoundary } from '@lexical/react/LexicalErrorBoundary.js';
+import { HistoryPlugin } from '@lexical/react/LexicalHistoryPlugin.js';
+import { OnChangePlugin } from '@lexical/react/LexicalOnChangePlugin.js';
+import { RichTextPlugin } from '@lexical/react/LexicalRichTextPlugin.js';
+import { TabIndentationPlugin } from '@lexical/react/LexicalTabIndentationPlugin.js';
+import { useTranslation } from '@payloadcms/ui/providers/Translation';
+import { BLUR_COMMAND, COMMAND_PRIORITY_LOW, FOCUS_COMMAND } from 'lexical';
 import * as React from 'react';
 import { useEffect, useState } from 'react';
 import { EditorPlugin } from './EditorPlugin.js';
 import './LexicalEditor.scss';
-import { FloatingSelectToolbarPlugin } from './plugins/FloatingSelectToolbar/index.js';
+import { useEditorConfigContext } from './config/client/EditorConfigProvider.js';
 import { MarkdownShortcutPlugin } from './plugins/MarkdownShortcut/index.js';
 import { SlashMenuPlugin } from './plugins/SlashMenu/index.js';
 import { AddBlockHandlePlugin } from './plugins/handles/AddBlockHandlePlugin/index.js';
 import { DraggableBlockPlugin } from './plugins/handles/DraggableBlockPlugin/index.js';
 import { LexicalContentEditable } from './ui/ContentEditable.js';
 export const LexicalEditor = (props)=>{
-    const { editorConfig, onChange } = props;
+    const { editorConfig, editorContainerRef, onChange } = props;
+    const editorConfigContext = useEditorConfigContext();
     const [editor] = useLexicalComposerContext();
+    const { t } = useTranslation();
     const [floatingAnchorElem, setFloatingAnchorElem] = useState(null);
     const onRef = (_floatingAnchorElem)=>{
         if (_floatingAnchorElem !== null) {
             setFloatingAnchorElem(_floatingAnchorElem);
         }
     };
+    useEffect(()=>{
+        if (!editorConfigContext?.uuid) {
+            console.error('Lexical Editor must be used within an EditorConfigProvider');
+            return;
+        }
+        if (editorConfigContext?.parentEditor?.uuid) {
+            editorConfigContext.parentEditor?.registerChild(editorConfigContext.uuid, editorConfigContext);
+        }
+        const handleFocus = ()=>{
+            editorConfigContext.focusEditor(editorConfigContext);
+        };
+        const handleBlur = ()=>{
+            editorConfigContext.blurEditor(editorConfigContext);
+        };
+        const unregisterFocus = editor.registerCommand(FOCUS_COMMAND, ()=>{
+            handleFocus();
+            return true;
+        }, COMMAND_PRIORITY_LOW);
+        const unregisterBlur = editor.registerCommand(BLUR_COMMAND, ()=>{
+            handleBlur();
+            return true;
+        }, COMMAND_PRIORITY_LOW);
+        return ()=>{
+            unregisterFocus();
+            unregisterBlur();
+            editorConfigContext.parentEditor?.unregisterChild?.(editorConfigContext.uuid);
+        };
+    }, [
+        editor,
+        editorConfigContext
+    ]);
     const [isSmallWidthViewport, setIsSmallWidthViewport] = useState(false);
     useEffect(()=>{
         const updateViewPortWidth = ()=>{
-            const isNextSmallWidthViewport = window.matchMedia('(max-width: 1025px)').matches;
+            const isNextSmallWidthViewport = window.matchMedia('(max-width: 768px)').matches;
             if (isNextSmallWidthViewport !== isSmallWidthViewport) {
                 setIsSmallWidthViewport(isNextSmallWidthViewport);
             }
@@ -45,68 +76,118 @@ export const LexicalEditor = (props)=>{
     }, [
         isSmallWidthViewport
     ]);
-    const ErrorBoundaryComponent = LexicalErrorBoundary.default || LexicalErrorBoundary;
-    return /*#__PURE__*/ React.createElement(React.Fragment, null, editorConfig.features.plugins.map((plugin)=>{
-        if (plugin.position === 'top') {
-            return /*#__PURE__*/ React.createElement(EditorPlugin, {
-                key: plugin.key,
-                plugin: plugin
-            });
-        }
-    }), /*#__PURE__*/ React.createElement(RichTextPlugin, {
-        //@ts-expect-error ts being dumb
-        ErrorBoundary: ErrorBoundaryComponent,
-        contentEditable: /*#__PURE__*/ React.createElement("div", {
-            className: "editor-scroller"
-        }, /*#__PURE__*/ React.createElement("div", {
-            className: "editor",
-            ref: onRef
-        }, /*#__PURE__*/ React.createElement(LexicalContentEditable, null))),
-        placeholder: /*#__PURE__*/ React.createElement("p", {
-            className: "editor-placeholder"
-        }, "Start typing, or press '/' for commands...")
-    }), /*#__PURE__*/ React.createElement(OnChangePlugin, {
-        // Selection changes can be ignored here, reducing the
-        // frequency that the FieldComponent and Payload receive updates.
-        // Selection changes are only needed if you are saving selection state
-        ignoreSelectionChange: true,
-        onChange: (editorState, editor, tags)=>{
-            // Ignore any onChange event triggered by focus only
-            if (!tags.has('focus') || tags.size > 1) {
-                if (onChange != null) onChange(editorState, editor, tags);
-            }
-        }
-    }), floatingAnchorElem && /*#__PURE__*/ React.createElement(React.Fragment, null, !isSmallWidthViewport && editor.isEditable() && /*#__PURE__*/ React.createElement(React.Fragment, null, /*#__PURE__*/ React.createElement(DraggableBlockPlugin, {
-        anchorElem: floatingAnchorElem
-    }), /*#__PURE__*/ React.createElement(AddBlockHandlePlugin, {
-        anchorElem: floatingAnchorElem
-    })), editorConfig.features.plugins.map((plugin)=>{
-        if (plugin.position === 'floatingAnchorElem' && !(plugin.desktopOnly === true && isSmallWidthViewport)) {
-            return /*#__PURE__*/ React.createElement(EditorPlugin, {
-                anchorElem: floatingAnchorElem,
-                key: plugin.key,
-                plugin: plugin
-            });
-        }
-    }), editor.isEditable() && /*#__PURE__*/ React.createElement(React.Fragment, null, /*#__PURE__*/ React.createElement(FloatingSelectToolbarPlugin, {
-        anchorElem: floatingAnchorElem
-    }), /*#__PURE__*/ React.createElement(SlashMenuPlugin, {
-        anchorElem: floatingAnchorElem
-    }))), editor.isEditable() && /*#__PURE__*/ React.createElement(React.Fragment, null, /*#__PURE__*/ React.createElement(HistoryPlugin, null), editorConfig?.features?.markdownTransformers?.length > 0 && /*#__PURE__*/ React.createElement(MarkdownShortcutPlugin, null)), /*#__PURE__*/ React.createElement(TabIndentationPlugin, null), editorConfig.features.plugins.map((plugin)=>{
-        if (plugin.position === 'normal') {
-            return /*#__PURE__*/ React.createElement(EditorPlugin, {
-                key: plugin.key,
-                plugin: plugin
-            });
-        }
-    }), editorConfig.features.plugins.map((plugin)=>{
-        if (plugin.position === 'bottom') {
-            return /*#__PURE__*/ React.createElement(EditorPlugin, {
-                key: plugin.key,
-                plugin: plugin
-            });
-        }
-    }));
+    return /*#__PURE__*/ _jsxs(React.Fragment, {
+        children: [
+            editorConfig.features.plugins.map((plugin)=>{
+                if (plugin.position === 'aboveContainer') {
+                    return /*#__PURE__*/ _jsx(EditorPlugin, {
+                        clientProps: plugin.clientProps,
+                        plugin: plugin
+                    }, plugin.key);
+                }
+            }),
+            /*#__PURE__*/ _jsxs("div", {
+                className: "editor-container",
+                ref: editorContainerRef,
+                children: [
+                    editorConfig.features.plugins.map((plugin)=>{
+                        if (plugin.position === 'top') {
+                            return /*#__PURE__*/ _jsx(EditorPlugin, {
+                                clientProps: plugin.clientProps,
+                                plugin: plugin
+                            }, plugin.key);
+                        }
+                    }),
+                    /*#__PURE__*/ _jsx(RichTextPlugin, {
+                        ErrorBoundary: LexicalErrorBoundary,
+                        contentEditable: /*#__PURE__*/ _jsx("div", {
+                            className: "editor-scroller",
+                            children: /*#__PURE__*/ _jsx("div", {
+                                className: "editor",
+                                ref: onRef,
+                                children: /*#__PURE__*/ _jsx(LexicalContentEditable, {})
+                            })
+                        }),
+                        placeholder: /*#__PURE__*/ _jsx("p", {
+                            className: "editor-placeholder",
+                            children: t('lexical:general:placeholder')
+                        })
+                    }),
+                    /*#__PURE__*/ _jsx(OnChangePlugin, {
+                        // Selection changes can be ignored here, reducing the
+                        // frequency that the FieldComponent and Payload receive updates.
+                        // Selection changes are only needed if you are saving selection state
+                        ignoreSelectionChange: true,
+                        onChange: (editorState, editor, tags)=>{
+                            // Ignore any onChange event triggered by focus only
+                            if (!tags.has('focus') || tags.size > 1) {
+                                if (onChange != null) onChange(editorState, editor, tags);
+                            }
+                        }
+                    }),
+                    floatingAnchorElem && /*#__PURE__*/ _jsxs(React.Fragment, {
+                        children: [
+                            !isSmallWidthViewport && editor.isEditable() && /*#__PURE__*/ _jsxs(React.Fragment, {
+                                children: [
+                                    /*#__PURE__*/ _jsx(DraggableBlockPlugin, {
+                                        anchorElem: floatingAnchorElem
+                                    }),
+                                    /*#__PURE__*/ _jsx(AddBlockHandlePlugin, {
+                                        anchorElem: floatingAnchorElem
+                                    })
+                                ]
+                            }),
+                            editorConfig.features.plugins.map((plugin)=>{
+                                if (plugin.position === 'floatingAnchorElem' && !(plugin.desktopOnly === true && isSmallWidthViewport)) {
+                                    return /*#__PURE__*/ _jsx(EditorPlugin, {
+                                        anchorElem: floatingAnchorElem,
+                                        clientProps: plugin.clientProps,
+                                        plugin: plugin
+                                    }, plugin.key);
+                                }
+                            }),
+                            editor.isEditable() && /*#__PURE__*/ _jsx(React.Fragment, {
+                                children: /*#__PURE__*/ _jsx(SlashMenuPlugin, {
+                                    anchorElem: floatingAnchorElem
+                                })
+                            })
+                        ]
+                    }),
+                    editor.isEditable() && /*#__PURE__*/ _jsxs(React.Fragment, {
+                        children: [
+                            /*#__PURE__*/ _jsx(HistoryPlugin, {}),
+                            editorConfig?.features?.markdownTransformers?.length > 0 && /*#__PURE__*/ _jsx(MarkdownShortcutPlugin, {})
+                        ]
+                    }),
+                    /*#__PURE__*/ _jsx(TabIndentationPlugin, {}),
+                    editorConfig.features.plugins.map((plugin)=>{
+                        if (plugin.position === 'normal') {
+                            return /*#__PURE__*/ _jsx(EditorPlugin, {
+                                clientProps: plugin.clientProps,
+                                plugin: plugin
+                            }, plugin.key);
+                        }
+                    }),
+                    editorConfig.features.plugins.map((plugin)=>{
+                        if (plugin.position === 'bottom') {
+                            return /*#__PURE__*/ _jsx(EditorPlugin, {
+                                clientProps: plugin.clientProps,
+                                plugin: plugin
+                            }, plugin.key);
+                        }
+                    })
+                ]
+            }),
+            editorConfig.features.plugins.map((plugin)=>{
+                if (plugin.position === 'belowContainer') {
+                    return /*#__PURE__*/ _jsx(EditorPlugin, {
+                        clientProps: plugin.clientProps,
+                        plugin: plugin
+                    }, plugin.key);
+                }
+            })
+        ]
+    });
 };
 
 //# sourceMappingURL=LexicalEditor.js.map

package/dist/field/lexical/LexicalEditor.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/field/lexical/LexicalEditor.tsx"],"sourcesContent":["'use client'\nimport lexicalComposerContextImport from '@lexical/react/LexicalComposerContext.js'\nconst { useLexicalComposerContext } = lexicalComposerContextImport\n\nimport LexicalErrorBoundary from '@lexical/react/LexicalErrorBoundary.js'\nimport lexicalHistoryPluginImport from '@lexical/react/LexicalHistoryPlugin.js'\nconst { HistoryPlugin } = lexicalHistoryPluginImport\n\nimport lexicalOnChangePluginImport from '@lexical/react/LexicalOnChangePlugin.js'\nconst { OnChangePlugin } = lexicalOnChangePluginImport\n\nimport lexicalRichTextPluginImport from '@lexical/react/LexicalRichTextPlugin.js'\nconst { RichTextPlugin } = lexicalRichTextPluginImport\n\nimport lexicalTabIndentationPluginImport from '@lexical/react/LexicalTabIndentationPlugin.js'\nconst { TabIndentationPlugin } = lexicalTabIndentationPluginImport\n\nimport * as React from 'react'\nimport { useEffect, useState } from 'react'\n\nimport type { LexicalProviderProps } from './LexicalProvider.js'\n\nimport { EditorPlugin } from './EditorPlugin.js'\nimport './LexicalEditor.scss'\nimport { FloatingSelectToolbarPlugin } from './plugins/FloatingSelectToolbar/index.js'\nimport { MarkdownShortcutPlugin } from './plugins/MarkdownShortcut/index.js'\nimport { SlashMenuPlugin } from './plugins/SlashMenu/index.js'\nimport { AddBlockHandlePlugin } from './plugins/handles/AddBlockHandlePlugin/index.js'\nimport { DraggableBlockPlugin } from './plugins/handles/DraggableBlockPlugin/index.js'\nimport { LexicalContentEditable } from './ui/ContentEditable.js'\n\nexport const LexicalEditor: React.FC<Pick<LexicalProviderProps, 'editorConfig' | 'onChange'>> = (\n  props,\n) => {\n  const { editorConfig, onChange } = props\n  const [editor] = useLexicalComposerContext()\n\n  const [floatingAnchorElem, setFloatingAnchorElem] = useState<HTMLDivElement | null>(null)\n  const onRef = (_floatingAnchorElem: HTMLDivElement) => {\n    if (_floatingAnchorElem !== null) {\n      setFloatingAnchorElem(_floatingAnchorElem)\n    }\n  }\n\n  const [isSmallWidthViewport, setIsSmallWidthViewport] = useState<boolean>(false)\n\n  useEffect(() => {\n    const updateViewPortWidth = () => {\n      const isNextSmallWidthViewport = window.matchMedia('(max-width: 1025px)').matches\n\n      if (isNextSmallWidthViewport !== isSmallWidthViewport) {\n        setIsSmallWidthViewport(isNextSmallWidthViewport)\n      }\n    }\n    updateViewPortWidth()\n    window.addEventListener('resize', updateViewPortWidth)\n\n    return () => {\n      window.removeEventListener('resize', updateViewPortWidth)\n    }\n  }, [isSmallWidthViewport])\n\n  const ErrorBoundaryComponent = LexicalErrorBoundary.default || LexicalErrorBoundary\n\n  return (\n    <React.Fragment>\n      {editorConfig.features.plugins.map((plugin) => {\n        if (plugin.position === 'top') {\n          return <EditorPlugin key={plugin.key} plugin={plugin} />\n        }\n      })}\n      <RichTextPlugin\n        //@ts-expect-error ts being dumb\n        ErrorBoundary={ErrorBoundaryComponent}\n        contentEditable={\n          <div className=\"editor-scroller\">\n            <div className=\"editor\" ref={onRef}>\n              <LexicalContentEditable />\n            </div>\n          </div>\n        }\n        placeholder={\n          <p className=\"editor-placeholder\">Start typing, or press '/' for commands...</p>\n        }\n      />\n      <OnChangePlugin\n        // Selection changes can be ignored here, reducing the\n        // frequency that the FieldComponent and Payload receive updates.\n        // Selection changes are only needed if you are saving selection state\n        ignoreSelectionChange\n        onChange={(editorState, editor, tags) => {\n          // Ignore any onChange event triggered by focus only\n          if (!tags.has('focus') || tags.size > 1) {\n            if (onChange != null) onChange(editorState, editor, tags)\n          }\n        }}\n      />\n      {floatingAnchorElem && (\n        <React.Fragment>\n          {!isSmallWidthViewport && editor.isEditable() && (\n            <React.Fragment>\n              <DraggableBlockPlugin anchorElem={floatingAnchorElem} />\n              <AddBlockHandlePlugin anchorElem={floatingAnchorElem} />\n            </React.Fragment>\n          )}\n          {editorConfig.features.plugins.map((plugin) => {\n            if (\n              plugin.position === 'floatingAnchorElem' &&\n              !(plugin.desktopOnly === true && isSmallWidthViewport)\n            ) {\n              return (\n                <EditorPlugin anchorElem={floatingAnchorElem} key={plugin.key} plugin={plugin} />\n              )\n            }\n          })}\n          {editor.isEditable() && (\n            <React.Fragment>\n              <FloatingSelectToolbarPlugin anchorElem={floatingAnchorElem} />\n              <SlashMenuPlugin anchorElem={floatingAnchorElem} />\n            </React.Fragment>\n          )}\n        </React.Fragment>\n      )}\n      {editor.isEditable() && (\n        <React.Fragment>\n          <HistoryPlugin />\n          {editorConfig?.features?.markdownTransformers?.length > 0 && <MarkdownShortcutPlugin />}\n        </React.Fragment>\n      )}\n\n      <TabIndentationPlugin />\n      {editorConfig.features.plugins.map((plugin) => {\n        if (plugin.position === 'normal') {\n          return <EditorPlugin key={plugin.key} plugin={plugin} />\n        }\n      })}\n      {editorConfig.features.plugins.map((plugin) => {\n        if (plugin.position === 'bottom') {\n          return <EditorPlugin key={plugin.key} plugin={plugin} />\n        }\n      })}\n    </React.Fragment>\n  )\n}\n"],"names":["lexicalComposerContextImport","useLexicalComposerContext","LexicalErrorBoundary","lexicalHistoryPluginImport","HistoryPlugin","lexicalOnChangePluginImport","OnChangePlugin","lexicalRichTextPluginImport","RichTextPlugin","lexicalTabIndentationPluginImport","TabIndentationPlugin","React","useEffect","useState","EditorPlugin","FloatingSelectToolbarPlugin","MarkdownShortcutPlugin","SlashMenuPlugin","AddBlockHandlePlugin","DraggableBlockPlugin","LexicalContentEditable","LexicalEditor","props","editorConfig","onChange","editor","floatingAnchorElem","setFloatingAnchorElem","onRef","_floatingAnchorElem","isSmallWidthViewport","setIsSmallWidthViewport","updateViewPortWidth","isNextSmallWidthViewport","window","matchMedia","matches","addEventListener","removeEventListener","ErrorBoundaryComponent","default","Fragment","features","plugins","map","plugin","position","key","ErrorBoundary","contentEditable","div","className","ref","placeholder","p","ignoreSelectionChange","editorState","tags","has","size","isEditable","anchorElem","desktopOnly","markdownTransformers","length"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}
+{"version":3,"sources":["../../../src/field/lexical/LexicalEditor.tsx"],"sourcesContent":["'use client'\nimport { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext.js'\nimport { LexicalErrorBoundary } from '@lexical/react/LexicalErrorBoundary.js'\nimport { HistoryPlugin } from '@lexical/react/LexicalHistoryPlugin.js'\nimport { OnChangePlugin } from '@lexical/react/LexicalOnChangePlugin.js'\nimport { RichTextPlugin } from '@lexical/react/LexicalRichTextPlugin.js'\nimport { TabIndentationPlugin } from '@lexical/react/LexicalTabIndentationPlugin.js'\nimport { useTranslation } from '@payloadcms/ui/providers/Translation'\nimport { BLUR_COMMAND, COMMAND_PRIORITY_LOW, FOCUS_COMMAND } from 'lexical'\nimport * as React from 'react'\nimport { useEffect, useState } from 'react'\n\nimport type { LexicalProviderProps } from './LexicalProvider.js'\n\nimport { EditorPlugin } from './EditorPlugin.js'\nimport './LexicalEditor.scss'\nimport { useEditorConfigContext } from './config/client/EditorConfigProvider.js'\nimport { MarkdownShortcutPlugin } from './plugins/MarkdownShortcut/index.js'\nimport { SlashMenuPlugin } from './plugins/SlashMenu/index.js'\nimport { AddBlockHandlePlugin } from './plugins/handles/AddBlockHandlePlugin/index.js'\nimport { DraggableBlockPlugin } from './plugins/handles/DraggableBlockPlugin/index.js'\nimport { LexicalContentEditable } from './ui/ContentEditable.js'\n\nexport const LexicalEditor: React.FC<\n  Pick<LexicalProviderProps, 'editorConfig' | 'onChange'> & {\n    editorContainerRef: React.RefObject<HTMLDivElement>\n  }\n> = (props) => {\n  const { editorConfig, editorContainerRef, onChange } = props\n  const editorConfigContext = useEditorConfigContext()\n  const [editor] = useLexicalComposerContext()\n  const { t } = useTranslation<{}, string>()\n\n  const [floatingAnchorElem, setFloatingAnchorElem] = useState<HTMLDivElement | null>(null)\n  const onRef = (_floatingAnchorElem: HTMLDivElement) => {\n    if (_floatingAnchorElem !== null) {\n      setFloatingAnchorElem(_floatingAnchorElem)\n    }\n  }\n\n  useEffect(() => {\n    if (!editorConfigContext?.uuid) {\n      console.error('Lexical Editor must be used within an EditorConfigProvider')\n      return\n    }\n    if (editorConfigContext?.parentEditor?.uuid) {\n      editorConfigContext.parentEditor?.registerChild(editorConfigContext.uuid, editorConfigContext)\n    }\n\n    const handleFocus = () => {\n      editorConfigContext.focusEditor(editorConfigContext)\n    }\n\n    const handleBlur = () => {\n      editorConfigContext.blurEditor(editorConfigContext)\n    }\n\n    const unregisterFocus = editor.registerCommand<MouseEvent>(\n      FOCUS_COMMAND,\n      () => {\n        handleFocus()\n        return true\n      },\n      COMMAND_PRIORITY_LOW,\n    )\n\n    const unregisterBlur = editor.registerCommand<MouseEvent>(\n      BLUR_COMMAND,\n      () => {\n        handleBlur()\n        return true\n      },\n      COMMAND_PRIORITY_LOW,\n    )\n\n    return () => {\n      unregisterFocus()\n      unregisterBlur()\n      editorConfigContext.parentEditor?.unregisterChild?.(editorConfigContext.uuid)\n    }\n  }, [editor, editorConfigContext])\n\n  const [isSmallWidthViewport, setIsSmallWidthViewport] = useState<boolean>(false)\n\n  useEffect(() => {\n    const updateViewPortWidth = () => {\n      const isNextSmallWidthViewport = window.matchMedia('(max-width: 768px)').matches\n\n      if (isNextSmallWidthViewport !== isSmallWidthViewport) {\n        setIsSmallWidthViewport(isNextSmallWidthViewport)\n      }\n    }\n    updateViewPortWidth()\n    window.addEventListener('resize', updateViewPortWidth)\n\n    return () => {\n      window.removeEventListener('resize', updateViewPortWidth)\n    }\n  }, [isSmallWidthViewport])\n\n  return (\n    <React.Fragment>\n      {editorConfig.features.plugins.map((plugin) => {\n        if (plugin.position === 'aboveContainer') {\n          return <EditorPlugin clientProps={plugin.clientProps} key={plugin.key} plugin={plugin} />\n        }\n      })}\n      <div className=\"editor-container\" ref={editorContainerRef}>\n        {editorConfig.features.plugins.map((plugin) => {\n          if (plugin.position === 'top') {\n            return (\n              <EditorPlugin clientProps={plugin.clientProps} key={plugin.key} plugin={plugin} />\n            )\n          }\n        })}\n        <RichTextPlugin\n          ErrorBoundary={LexicalErrorBoundary}\n          contentEditable={\n            <div className=\"editor-scroller\">\n              <div className=\"editor\" ref={onRef}>\n                <LexicalContentEditable />\n              </div>\n            </div>\n          }\n          placeholder={<p className=\"editor-placeholder\">{t('lexical:general:placeholder')}</p>}\n        />\n        <OnChangePlugin\n          // Selection changes can be ignored here, reducing the\n          // frequency that the FieldComponent and Payload receive updates.\n          // Selection changes are only needed if you are saving selection state\n          ignoreSelectionChange\n          onChange={(editorState, editor, tags) => {\n            // Ignore any onChange event triggered by focus only\n            if (!tags.has('focus') || tags.size > 1) {\n              if (onChange != null) onChange(editorState, editor, tags)\n            }\n          }}\n        />\n        {floatingAnchorElem && (\n          <React.Fragment>\n            {!isSmallWidthViewport && editor.isEditable() && (\n              <React.Fragment>\n                <DraggableBlockPlugin anchorElem={floatingAnchorElem} />\n                <AddBlockHandlePlugin anchorElem={floatingAnchorElem} />\n              </React.Fragment>\n            )}\n            {editorConfig.features.plugins.map((plugin) => {\n              if (\n                plugin.position === 'floatingAnchorElem' &&\n                !(plugin.desktopOnly === true && isSmallWidthViewport)\n              ) {\n                return (\n                  <EditorPlugin\n                    anchorElem={floatingAnchorElem}\n                    clientProps={plugin.clientProps}\n                    key={plugin.key}\n                    plugin={plugin}\n                  />\n                )\n              }\n            })}\n            {editor.isEditable() && (\n              <React.Fragment>\n                <SlashMenuPlugin anchorElem={floatingAnchorElem} />\n              </React.Fragment>\n            )}\n          </React.Fragment>\n        )}\n        {editor.isEditable() && (\n          <React.Fragment>\n            <HistoryPlugin />\n            {editorConfig?.features?.markdownTransformers?.length > 0 && <MarkdownShortcutPlugin />}\n          </React.Fragment>\n        )}\n\n        <TabIndentationPlugin />\n        {editorConfig.features.plugins.map((plugin) => {\n          if (plugin.position === 'normal') {\n            return (\n              <EditorPlugin clientProps={plugin.clientProps} key={plugin.key} plugin={plugin} />\n            )\n          }\n        })}\n        {editorConfig.features.plugins.map((plugin) => {\n          if (plugin.position === 'bottom') {\n            return (\n              <EditorPlugin clientProps={plugin.clientProps} key={plugin.key} plugin={plugin} />\n            )\n          }\n        })}\n      </div>\n      {editorConfig.features.plugins.map((plugin) => {\n        if (plugin.position === 'belowContainer') {\n          return <EditorPlugin clientProps={plugin.clientProps} key={plugin.key} plugin={plugin} />\n        }\n      })}\n    </React.Fragment>\n  )\n}\n"],"names":["useLexicalComposerContext","LexicalErrorBoundary","HistoryPlugin","OnChangePlugin","RichTextPlugin","TabIndentationPlugin","useTranslation","BLUR_COMMAND","COMMAND_PRIORITY_LOW","FOCUS_COMMAND","React","useEffect","useState","EditorPlugin","useEditorConfigContext","MarkdownShortcutPlugin","SlashMenuPlugin","AddBlockHandlePlugin","DraggableBlockPlugin","LexicalContentEditable","LexicalEditor","props","editorConfig","editorContainerRef","onChange","editorConfigContext","editor","t","floatingAnchorElem","setFloatingAnchorElem","onRef","_floatingAnchorElem","uuid","console","error","parentEditor","registerChild","handleFocus","focusEditor","handleBlur","blurEditor","unregisterFocus","registerCommand","unregisterBlur","unregisterChild","isSmallWidthViewport","setIsSmallWidthViewport","updateViewPortWidth","isNextSmallWidthViewport","window","matchMedia","matches","addEventListener","removeEventListener","Fragment","features","plugins","map","plugin","position","clientProps","key","div","className","ref","ErrorBoundary","contentEditable","placeholder","p","ignoreSelectionChange","editorState","tags","has","size","isEditable","anchorElem","desktopOnly","markdownTransformers","length"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/dist/field/lexical/LexicalEditor.scss

@@ -1,9 +1,11 @@
+@import '../../scss/styles';
+
 .rich-text-lexical {
   .editor {
     position: relative;
   }
 
-  .editor-shell {
+  .editor-container {
     position: relative;
 
     font-family: var(--font-serif);
@@ -20,10 +22,19 @@
     }
   }
 
+  &--show-gutter  {
+    > .rich-text-lexical__wrap > .editor-container > .editor-placeholder {
+      left: 3rem;
+    }
+  }
+
+  &:not(&--show-gutter) > .rich-text-lexical__wrap > .editor-container > .editor-placeholder {
+    left: 0;
+  }
+
   .editor-placeholder {
     position: absolute;
     top: 8px;
-    left: 0px;
     font-size: 15px;
     color: var(--theme-elevation-500);
     /* Prevent text selection */
@@ -36,21 +47,3 @@
     pointer-events: none;
   }
 }
-
-.floating-select-toolbar-popup__section-dropdown-align {
-  display: flex;
-  gap: 2px;
-}
-.floating-select-toolbar-popup__section-features {
-  display: flex;
-  gap: 2px;
-}
-.floating-select-toolbar-popup__section-dropdown-text {
-  display: flex;
-  gap: 2px;
-}
-
-.floating-select-toolbar-popup__section-format {
-  display: flex;
-  gap: 2px;
-}

package/dist/field/lexical/LexicalProvider.d.ts

@@ -1,6 +1,6 @@
+import type { FormFieldBase } from '@payloadcms/ui/fields/shared';
 import type { EditorState, SerializedEditorState } from 'lexical';
 import type { LexicalEditor } from 'lexical';
-import type { FormFieldBase } from '@payloadcms/ui/fields/shared';
 import * as React from 'react';
 import type { SanitizedClientEditorConfig } from './config/types.js';
 export type LexicalProviderProps = {

package/dist/field/lexical/LexicalProvider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"LexicalProvider.d.ts","sourceRoot":"","sources":["../../../src/field/lexical/LexicalProvider.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AACjE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAM5C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAA;AAEjE,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,mBAAmB,CAAA;AAMpE,MAAM,MAAM,oBAAoB,GAAG;IACjC,YAAY,EAAE,2BAA2B,CAAA;IACzC,UAAU,EAAE,aAAa,GAAG;QAC1B,YAAY,EAAE,2BAA2B,CAAA;QACzC,IAAI,EAAE,MAAM,CAAA;QACZ,oBAAoB,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,SAAS,CAAC,CAAA;KACnD,CAAA;IACD,QAAQ,EAAE,CAAC,WAAW,EAAE,WAAW,EAAE,MAAM,EAAE,aAAa,EAAE,IAAI,EAAE,GAAG,CAAC,MAAM,CAAC,KAAK,IAAI,CAAA;IACtF,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,OAAO,CAAA;IACjB,KAAK,EAAE,qBAAqB,CAAA;CAC7B,CAAA;AACD,eAAO,MAAM,eAAe,EAAE,KAAK,CAAC,EAAE,CAAC,oBAAoB,CA2D1D,CAAA"}
+{"version":3,"file":"LexicalProvider.d.ts","sourceRoot":"","sources":["../../../src/field/lexical/LexicalProvider.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAA;AACjE,OAAO,KAAK,EAAE,WAAW,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AACjE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAG5C,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAG9B,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,mBAAmB,CAAA;AASpE,MAAM,MAAM,oBAAoB,GAAG;IACjC,YAAY,EAAE,2BAA2B,CAAA;IACzC,UAAU,EAAE,aAAa,GAAG;QAC1B,YAAY,EAAE,2BAA2B,CAAA;QACzC,IAAI,EAAE,MAAM,CAAA;QACZ,oBAAoB,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,SAAS,CAAC,CAAA;KACnD,CAAA;IACD,QAAQ,EAAE,CAAC,WAAW,EAAE,WAAW,EAAE,MAAM,EAAE,aAAa,EAAE,IAAI,EAAE,GAAG,CAAC,MAAM,CAAC,KAAK,IAAI,CAAA;IACtF,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,OAAO,CAAA;IACjB,KAAK,EAAE,qBAAqB,CAAA;CAC7B,CAAA;AACD,eAAO,MAAM,eAAe,EAAE,KAAK,CAAC,EAAE,CAAC,oBAAoB,CAuE1D,CAAA"}

package/dist/field/lexical/LexicalProvider.js

@@ -1,19 +1,43 @@
 'use client';
-import lexicalComposerImport from '@lexical/react/LexicalComposer.js';
-const { LexicalComposer } = lexicalComposerImport;
+import { jsx as _jsx } from "react/jsx-runtime";
+import { LexicalComposer } from '@lexical/react/LexicalComposer.js';
 import * as React from 'react';
+import { useMemo } from 'react';
 import { LexicalEditor as LexicalEditorComponent } from './LexicalEditor.js';
-import { EditorConfigProvider } from './config/client/EditorConfigProvider.js';
+import { EditorConfigProvider, useEditorConfigContext } from './config/client/EditorConfigProvider.js';
 import { getEnabledNodes } from './nodes/index.js';
 export const LexicalProvider = (props)=>{
-    const { editorConfig, fieldProps, onChange, path, readOnly } = props;
-    let { value } = props;
-    const [initialConfig, setInitialConfig] = React.useState(null);
-    // set lexical config in useEffect: // TODO: Is this the most performant way to do this? Prob not
-    React.useEffect(()=>{
-        const newInitialConfig = {
+    const { editorConfig, fieldProps, value, onChange, path, readOnly } = props;
+    const parentContext = useEditorConfigContext();
+    const editorContainerRef = React.useRef(null);
+    const processedValue = useMemo(()=>{
+        let processed = value;
+        if (editorConfig?.features?.hooks?.load?.length) {
+            editorConfig.features.hooks.load.forEach((hook)=>{
+                processed = hook({
+                    incomingEditorState: processed
+                });
+            });
+        }
+        return processed;
+    }, [
+        editorConfig,
+        value
+    ]);
+    // useMemo for the initialConfig that depends on readOnly and processedValue
+    const initialConfig = useMemo(()=>{
+        if (processedValue && typeof processedValue !== 'object') {
+            throw new Error('The value passed to the Lexical editor is not an object. This is not supported. Please remove the data from the field and start again. This is the value that was passed in: ' + JSON.stringify(processedValue));
+        }
+        if (processedValue && Array.isArray(processedValue) && !('root' in processedValue)) {
+            throw new Error('You have tried to pass in data from the old, Slate editor, to the new, Lexical editor. This is not supported. There is no automatic conversion from Slate to Lexical data available yet (coming soon). Please remove the data from the field and start again.');
+        }
+        if (processedValue && 'jsonContent' in processedValue) {
+            throw new Error('You have tried to pass in data from payload-plugin-lexical. This is not supported. The data structure has changed in this editor, compared to the plugin, and there is no automatic conversion available yet (coming soon). Please remove the data from the field and start again.');
+        }
+        return {
             editable: readOnly !== true,
-            editorState: value != null ? JSON.stringify(value) : undefined,
+            editorState: processedValue != null ? JSON.stringify(processedValue) : undefined,
             namespace: editorConfig.lexical.namespace,
             nodes: [
                 ...getEnabledNodes({
@@ -25,43 +49,30 @@ export const LexicalProvider = (props)=>{
             },
             theme: editorConfig.lexical.theme
         };
-        setInitialConfig(newInitialConfig);
     }, [
         editorConfig,
-        readOnly,
-        value
+        processedValue,
+        readOnly
     ]);
-    if (editorConfig?.features?.hooks?.load?.length) {
-        editorConfig.features.hooks.load.forEach((hook)=>{
-            value = hook({
-                incomingEditorState: value
-            });
-        });
-    }
-    if (value && typeof value !== 'object') {
-        throw new Error('The value passed to the Lexical editor is not an object. This is not supported. Please remove the data from the field and start again. This is the value that was passed in: ' + JSON.stringify(value));
-    }
-    if (value && Array.isArray(value) && !('root' in value)) {
-        throw new Error('You have tried to pass in data from the old, Slate editor, to the new, Lexical editor. This is not supported. There is no automatic conversion from Slate to Lexical data available yet (coming soon). Please remove the data from the field and start again.');
-    }
-    if (value && 'jsonContent' in value) {
-        throw new Error('You have tried to pass in data from payload-plugin-lexical. This is not supported. The data structure has changed in this editor, compared to the plugin, and there is no automatic conversion available yet (coming soon). Please remove the data from the field and start again.');
-    }
     if (!initialConfig) {
-        return /*#__PURE__*/ React.createElement("p", null, "Loading...");
+        return /*#__PURE__*/ _jsx("p", {
+            children: "Loading..."
+        });
     }
-    return /*#__PURE__*/ React.createElement(LexicalComposer, {
+    return /*#__PURE__*/ _jsx(LexicalComposer, {
         initialConfig: initialConfig,
-        key: path
-    }, /*#__PURE__*/ React.createElement(EditorConfigProvider, {
-        editorConfig: editorConfig,
-        fieldProps: fieldProps
-    }, /*#__PURE__*/ React.createElement("div", {
-        className: "editor-shell"
-    }, /*#__PURE__*/ React.createElement(LexicalEditorComponent, {
-        editorConfig: editorConfig,
-        onChange: onChange
-    }))));
+        children: /*#__PURE__*/ _jsx(EditorConfigProvider, {
+            editorConfig: editorConfig,
+            editorContainerRef: editorContainerRef,
+            fieldProps: fieldProps,
+            parentContext: parentContext,
+            children: /*#__PURE__*/ _jsx(LexicalEditorComponent, {
+                editorConfig: editorConfig,
+                editorContainerRef: editorContainerRef,
+                onChange: onChange
+            })
+        })
+    }, path);
 };
 
 //# sourceMappingURL=LexicalProvider.js.map

package/dist/field/lexical/LexicalProvider.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/field/lexical/LexicalProvider.tsx"],"sourcesContent":["'use client'\nimport type { EditorState, SerializedEditorState } from 'lexical'\nimport type { LexicalEditor } from 'lexical'\n\nimport lexicalComposerImport from '@lexical/react/LexicalComposer.js'\nconst { LexicalComposer } = lexicalComposerImport\n\nimport type { InitialConfigType } from '@lexical/react/LexicalComposer.js'\nimport type { FormFieldBase } from '@payloadcms/ui/fields/shared'\n\nimport * as React from 'react'\n\nimport type { SanitizedClientEditorConfig } from './config/types.js'\n\nimport { LexicalEditor as LexicalEditorComponent } from './LexicalEditor.js'\nimport { EditorConfigProvider } from './config/client/EditorConfigProvider.js'\nimport { getEnabledNodes } from './nodes/index.js'\n\nexport type LexicalProviderProps = {\n  editorConfig: SanitizedClientEditorConfig\n  fieldProps: FormFieldBase & {\n    editorConfig: SanitizedClientEditorConfig // With rendered features n stuff\n    name: string\n    richTextComponentMap: Map<string, React.ReactNode>\n  }\n  onChange: (editorState: EditorState, editor: LexicalEditor, tags: Set<string>) => void\n  path: string\n  readOnly: boolean\n  value: SerializedEditorState\n}\nexport const LexicalProvider: React.FC<LexicalProviderProps> = (props) => {\n  const { editorConfig, fieldProps, onChange, path, readOnly } = props\n  let { value } = props\n\n  const [initialConfig, setInitialConfig] = React.useState<InitialConfigType | null>(null)\n\n  // set lexical config in useEffect: // TODO: Is this the most performant way to do this? Prob not\n  React.useEffect(() => {\n    const newInitialConfig: InitialConfigType = {\n      editable: readOnly !== true,\n      editorState: value != null ? JSON.stringify(value) : undefined,\n      namespace: editorConfig.lexical.namespace,\n      nodes: [...getEnabledNodes({ editorConfig })],\n      onError: (error: Error) => {\n        throw error\n      },\n      theme: editorConfig.lexical.theme,\n    }\n    setInitialConfig(newInitialConfig)\n  }, [editorConfig, readOnly, value])\n\n  if (editorConfig?.features?.hooks?.load?.length) {\n    editorConfig.features.hooks.load.forEach((hook) => {\n      value = hook({ incomingEditorState: value })\n    })\n  }\n\n  if (value && typeof value !== 'object') {\n    throw new Error(\n      'The value passed to the Lexical editor is not an object. This is not supported. Please remove the data from the field and start again. This is the value that was passed in: ' +\n        JSON.stringify(value),\n    )\n  }\n\n  if (value && Array.isArray(value) && !('root' in value)) {\n    throw new Error(\n      'You have tried to pass in data from the old, Slate editor, to the new, Lexical editor. This is not supported. There is no automatic conversion from Slate to Lexical data available yet (coming soon). Please remove the data from the field and start again.',\n    )\n  }\n\n  if (value && 'jsonContent' in value) {\n    throw new Error(\n      'You have tried to pass in data from payload-plugin-lexical. This is not supported. The data structure has changed in this editor, compared to the plugin, and there is no automatic conversion available yet (coming soon). Please remove the data from the field and start again.',\n    )\n  }\n\n  if (!initialConfig) {\n    return <p>Loading...</p>\n  }\n\n  return (\n    <LexicalComposer initialConfig={initialConfig} key={path}>\n      <EditorConfigProvider editorConfig={editorConfig} fieldProps={fieldProps}>\n        <div className=\"editor-shell\">\n          <LexicalEditorComponent editorConfig={editorConfig} onChange={onChange} />\n        </div>\n      </EditorConfigProvider>\n    </LexicalComposer>\n  )\n}\n"],"names":["lexicalComposerImport","LexicalComposer","React","LexicalEditor","LexicalEditorComponent","EditorConfigProvider","getEnabledNodes","LexicalProvider","props","editorConfig","fieldProps","onChange","path","readOnly","value","initialConfig","setInitialConfig","useState","useEffect","newInitialConfig","editable","editorState","JSON","stringify","undefined","namespace","lexical","nodes","onError","error","theme","features","hooks","load","length","forEach","hook","incomingEditorState","Error","Array","isArray","p","key","div","className"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA;AAIA,OAAOA,2BAA2B,oCAAmC;AACrE,MAAM,EAAEC,eAAe,EAAE,GAAGD;AAK5B,YAAYE,WAAW,QAAO;AAI9B,SAASC,iBAAiBC,sBAAsB,QAAQ,qBAAoB;AAC5E,SAASC,oBAAoB,QAAQ,0CAAyC;AAC9E,SAASC,eAAe,QAAQ,mBAAkB;AAclD,OAAO,MAAMC,kBAAkD,CAACC;IAC9D,MAAM,EAAEC,YAAY,EAAEC,UAAU,EAAEC,QAAQ,EAAEC,IAAI,EAAEC,QAAQ,EAAE,GAAGL;IAC/D,IAAI,EAAEM,KAAK,EAAE,GAAGN;IAEhB,MAAM,CAACO,eAAeC,iBAAiB,GAAGd,MAAMe,QAAQ,CAA2B;IAEnF,iGAAiG;IACjGf,MAAMgB,SAAS,CAAC;QACd,MAAMC,mBAAsC;YAC1CC,UAAUP,aAAa;YACvBQ,aAAaP,SAAS,OAAOQ,KAAKC,SAAS,CAACT,SAASU;YACrDC,WAAWhB,aAAaiB,OAAO,CAACD,SAAS;YACzCE,OAAO;mBAAIrB,gBAAgB;oBAAEG;gBAAa;aAAG;YAC7CmB,SAAS,CAACC;gBACR,MAAMA;YACR;YACAC,OAAOrB,aAAaiB,OAAO,CAACI,KAAK;QACnC;QACAd,iBAAiBG;IACnB,GAAG;QAACV;QAAcI;QAAUC;KAAM;IAElC,IAAIL,cAAcsB,UAAUC,OAAOC,MAAMC,QAAQ;QAC/CzB,aAAasB,QAAQ,CAACC,KAAK,CAACC,IAAI,CAACE,OAAO,CAAC,CAACC;YACxCtB,QAAQsB,KAAK;gBAAEC,qBAAqBvB;YAAM;QAC5C;IACF;IAEA,IAAIA,SAAS,OAAOA,UAAU,UAAU;QACtC,MAAM,IAAIwB,MACR,kLACEhB,KAAKC,SAAS,CAACT;IAErB;IAEA,IAAIA,SAASyB,MAAMC,OAAO,CAAC1B,UAAU,CAAE,CAAA,UAAUA,KAAI,GAAI;QACvD,MAAM,IAAIwB,MACR;IAEJ;IAEA,IAAIxB,SAAS,iBAAiBA,OAAO;QACnC,MAAM,IAAIwB,MACR;IAEJ;IAEA,IAAI,CAACvB,eAAe;QAClB,qBAAO,oBAAC0B,WAAE;IACZ;IAEA,qBACE,oBAACxC;QAAgBc,eAAeA;QAAe2B,KAAK9B;qBAClD,oBAACP;QAAqBI,cAAcA;QAAcC,YAAYA;qBAC5D,oBAACiC;QAAIC,WAAU;qBACb,oBAACxC;QAAuBK,cAAcA;QAAcE,UAAUA;;AAKxE,EAAC"}
+{"version":3,"sources":["../../../src/field/lexical/LexicalProvider.tsx"],"sourcesContent":["'use client'\nimport type { InitialConfigType } from '@lexical/react/LexicalComposer.js'\nimport type { FormFieldBase } from '@payloadcms/ui/fields/shared'\nimport type { EditorState, SerializedEditorState } from 'lexical'\nimport type { LexicalEditor } from 'lexical'\n\nimport { LexicalComposer } from '@lexical/react/LexicalComposer.js'\nimport * as React from 'react'\nimport { useMemo } from 'react'\n\nimport type { SanitizedClientEditorConfig } from './config/types.js'\n\nimport { LexicalEditor as LexicalEditorComponent } from './LexicalEditor.js'\nimport {\n  EditorConfigProvider,\n  useEditorConfigContext,\n} from './config/client/EditorConfigProvider.js'\nimport { getEnabledNodes } from './nodes/index.js'\n\nexport type LexicalProviderProps = {\n  editorConfig: SanitizedClientEditorConfig\n  fieldProps: FormFieldBase & {\n    editorConfig: SanitizedClientEditorConfig // With rendered features n stuff\n    name: string\n    richTextComponentMap: Map<string, React.ReactNode>\n  }\n  onChange: (editorState: EditorState, editor: LexicalEditor, tags: Set<string>) => void\n  path: string\n  readOnly: boolean\n  value: SerializedEditorState\n}\nexport const LexicalProvider: React.FC<LexicalProviderProps> = (props) => {\n  const { editorConfig, fieldProps, value, onChange, path, readOnly } = props\n\n  const parentContext = useEditorConfigContext()\n\n  const editorContainerRef = React.useRef<HTMLDivElement>(null)\n\n\n  const processedValue = useMemo(() => {\n    let processed = value\n    if (editorConfig?.features?.hooks?.load?.length) {\n      editorConfig.features.hooks.load.forEach((hook) => {\n        processed = hook({ incomingEditorState: processed })\n      })\n    }\n    return processed\n  }, [editorConfig, value])\n\n  // useMemo for the initialConfig that depends on readOnly and processedValue\n  const initialConfig = useMemo<InitialConfigType>(() => {\n    if (processedValue && typeof processedValue !== 'object') {\n      throw new Error(\n        'The value passed to the Lexical editor is not an object. This is not supported. Please remove the data from the field and start again. This is the value that was passed in: ' +\n          JSON.stringify(processedValue),\n      )\n    }\n\n    if (processedValue && Array.isArray(processedValue) && !('root' in processedValue)) {\n      throw new Error(\n        'You have tried to pass in data from the old, Slate editor, to the new, Lexical editor. This is not supported. There is no automatic conversion from Slate to Lexical data available yet (coming soon). Please remove the data from the field and start again.',\n      )\n    }\n\n    if (processedValue && 'jsonContent' in processedValue) {\n      throw new Error(\n        'You have tried to pass in data from payload-plugin-lexical. This is not supported. The data structure has changed in this editor, compared to the plugin, and there is no automatic conversion available yet (coming soon). Please remove the data from the field and start again.',\n      )\n    }\n\n    return {\n      editable: readOnly !== true,\n      editorState: processedValue != null ? JSON.stringify(processedValue) : undefined,\n      namespace: editorConfig.lexical.namespace,\n      nodes: [...getEnabledNodes({ editorConfig })],\n      onError: (error: Error) => {\n        throw error\n      },\n      theme: editorConfig.lexical.theme,\n    }\n  }, [editorConfig, processedValue, readOnly])\n\n  if (!initialConfig) {\n    return <p>Loading...</p>\n  }\n\n  return (\n    <LexicalComposer initialConfig={initialConfig} key={path}>\n      <EditorConfigProvider\n        editorConfig={editorConfig}\n        editorContainerRef={editorContainerRef}\n        fieldProps={fieldProps}\n        parentContext={parentContext}\n      >\n        <LexicalEditorComponent\n          editorConfig={editorConfig}\n          editorContainerRef={editorContainerRef}\n          onChange={onChange}\n        />\n      </EditorConfigProvider>\n    </LexicalComposer>\n  )\n}\n"],"names":["LexicalComposer","React","useMemo","LexicalEditor","LexicalEditorComponent","EditorConfigProvider","useEditorConfigContext","getEnabledNodes","LexicalProvider","props","editorConfig","fieldProps","value","onChange","path","readOnly","parentContext","editorContainerRef","useRef","processedValue","processed","features","hooks","load","length","forEach","hook","incomingEditorState","initialConfig","Error","JSON","stringify","Array","isArray","editable","editorState","undefined","namespace","lexical","nodes","onError","error","theme","p"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA;;AAMA,SAASA,eAAe,QAAQ,oCAAmC;AACnE,YAAYC,WAAW,QAAO;AAC9B,SAASC,OAAO,QAAQ,QAAO;AAI/B,SAASC,iBAAiBC,sBAAsB,QAAQ,qBAAoB;AAC5E,SACEC,oBAAoB,EACpBC,sBAAsB,QACjB,0CAAyC;AAChD,SAASC,eAAe,QAAQ,mBAAkB;AAclD,OAAO,MAAMC,kBAAkD,CAACC;IAC9D,MAAM,EAAEC,YAAY,EAAEC,UAAU,EAAEC,KAAK,EAAEC,QAAQ,EAAEC,IAAI,EAAEC,QAAQ,EAAE,GAAGN;IAEtE,MAAMO,gBAAgBV;IAEtB,MAAMW,qBAAqBhB,MAAMiB,MAAM,CAAiB;IAGxD,MAAMC,iBAAiBjB,QAAQ;QAC7B,IAAIkB,YAAYR;QAChB,IAAIF,cAAcW,UAAUC,OAAOC,MAAMC,QAAQ;YAC/Cd,aAAaW,QAAQ,CAACC,KAAK,CAACC,IAAI,CAACE,OAAO,CAAC,CAACC;gBACxCN,YAAYM,KAAK;oBAAEC,qBAAqBP;gBAAU;YACpD;QACF;QACA,OAAOA;IACT,GAAG;QAACV;QAAcE;KAAM;IAExB,4EAA4E;IAC5E,MAAMgB,gBAAgB1B,QAA2B;QAC/C,IAAIiB,kBAAkB,OAAOA,mBAAmB,UAAU;YACxD,MAAM,IAAIU,MACR,kLACEC,KAAKC,SAAS,CAACZ;QAErB;QAEA,IAAIA,kBAAkBa,MAAMC,OAAO,CAACd,mBAAmB,CAAE,CAAA,UAAUA,cAAa,GAAI;YAClF,MAAM,IAAIU,MACR;QAEJ;QAEA,IAAIV,kBAAkB,iBAAiBA,gBAAgB;YACrD,MAAM,IAAIU,MACR;QAEJ;QAEA,OAAO;YACLK,UAAUnB,aAAa;YACvBoB,aAAahB,kBAAkB,OAAOW,KAAKC,SAAS,CAACZ,kBAAkBiB;YACvEC,WAAW3B,aAAa4B,OAAO,CAACD,SAAS;YACzCE,OAAO;mBAAIhC,gBAAgB;oBAAEG;gBAAa;aAAG;YAC7C8B,SAAS,CAACC;gBACR,MAAMA;YACR;YACAC,OAAOhC,aAAa4B,OAAO,CAACI,KAAK;QACnC;IACF,GAAG;QAAChC;QAAcS;QAAgBJ;KAAS;IAE3C,IAAI,CAACa,eAAe;QAClB,qBAAO,KAACe;sBAAE;;IACZ;IAEA,qBACE,KAAC3C;QAAgB4B,eAAeA;kBAC9B,cAAA,KAACvB;YACCK,cAAcA;YACdO,oBAAoBA;YACpBN,YAAYA;YACZK,eAAeA;sBAEf,cAAA,KAACZ;gBACCM,cAAcA;gBACdO,oBAAoBA;gBACpBJ,UAAUA;;;OAVoCC;AAexD,EAAC"}

package/dist/field/lexical/config/client/EditorConfigProvider.d.ts

@@ -1,24 +1,35 @@
 import type { FormFieldBase } from '@payloadcms/ui/fields/shared';
+import type { LexicalEditor } from 'lexical';
 import * as React from 'react';
 import type { SanitizedClientEditorConfig } from '../types.js';
-interface ContextType {
+export interface EditorConfigContextType {
+    blurEditor: (editorContext: EditorConfigContextType) => void;
+    childrenEditors: React.RefObject<Map<string, EditorConfigContextType>>;
+    editor: LexicalEditor;
     editorConfig: SanitizedClientEditorConfig;
+    editorContainerRef: React.RefObject<HTMLDivElement>;
     field: FormFieldBase & {
         editorConfig: SanitizedClientEditorConfig;
         name: string;
         richTextComponentMap: Map<string, React.ReactNode>;
     };
+    focusEditor: (editorContext: EditorConfigContextType) => void;
+    focusedEditor: EditorConfigContextType | null;
+    parentEditor: EditorConfigContextType;
+    registerChild: (uuid: string, editorContext: EditorConfigContextType) => void;
+    unregisterChild?: (uuid: string) => void;
     uuid: string;
 }
-export declare const EditorConfigProvider: ({ children, editorConfig, fieldProps, }: {
+export declare const EditorConfigProvider: ({ children, editorConfig, editorContainerRef, fieldProps, parentContext, }: {
     children: React.ReactNode;
     editorConfig: SanitizedClientEditorConfig;
+    editorContainerRef: React.RefObject<HTMLDivElement>;
     fieldProps: FormFieldBase & {
         editorConfig: SanitizedClientEditorConfig;
         name: string;
         richTextComponentMap: Map<string, React.ReactNode>;
     };
+    parentContext?: EditorConfigContextType;
 }) => React.ReactNode;
-export declare const useEditorConfigContext: () => ContextType;
-export {};
+export declare const useEditorConfigContext: () => EditorConfigContextType;
 //# sourceMappingURL=EditorConfigProvider.d.ts.map

package/dist/field/lexical/config/client/EditorConfigProvider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EditorConfigProvider.d.ts","sourceRoot":"","sources":["../../../../../src/field/lexical/config/client/EditorConfigProvider.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAA;AAEjE,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAG9B,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,aAAa,CAAA;AAM9D,UAAU,WAAW;IACnB,YAAY,EAAE,2BAA2B,CAAA;IACzC,KAAK,EAAE,aAAa,GAAG;QACrB,YAAY,EAAE,2BAA2B,CAAA;QACzC,IAAI,EAAE,MAAM,CAAA;QACZ,oBAAoB,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,SAAS,CAAC,CAAA;KACnD,CAAA;IACD,IAAI,EAAE,MAAM,CAAA;CACb;AAQD,eAAO,MAAM,oBAAoB,4CAI9B;IACD,QAAQ,EAAE,MAAM,SAAS,CAAA;IACzB,YAAY,EAAE,2BAA2B,CAAA;IACzC,UAAU,EAAE,aAAa,GAAG;QAC1B,YAAY,EAAE,2BAA2B,CAAA;QACzC,IAAI,EAAE,MAAM,CAAA;QACZ,oBAAoB,EAAE,IAAI,MAAM,EAAE,MAAM,SAAS,CAAC,CAAA;KACnD,CAAA;CACF,KAAG,MAAM,SAeT,CAAA;AAED,eAAO,MAAM,sBAAsB,QAAO,WAMzC,CAAA"}
+{"version":3,"file":"EditorConfigProvider.d.ts","sourceRoot":"","sources":["../../../../../src/field/lexical/config/client/EditorConfigProvider.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAA;AACjE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAG5C,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAG9B,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,aAAa,CAAA;AAO9D,MAAM,WAAW,uBAAuB;IAEtC,UAAU,EAAE,CAAC,aAAa,EAAE,uBAAuB,KAAK,IAAI,CAAA;IAC5D,eAAe,EAAE,KAAK,CAAC,SAAS,CAAC,GAAG,CAAC,MAAM,EAAE,uBAAuB,CAAC,CAAC,CAAA;IACtE,MAAM,EAAE,aAAa,CAAA;IACrB,YAAY,EAAE,2BAA2B,CAAA;IACzC,kBAAkB,EAAE,KAAK,CAAC,SAAS,CAAC,cAAc,CAAC,CAAA;IACnD,KAAK,EAAE,aAAa,GAAG;QACrB,YAAY,EAAE,2BAA2B,CAAA;QACzC,IAAI,EAAE,MAAM,CAAA;QACZ,oBAAoB,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,SAAS,CAAC,CAAA;KACnD,CAAA;IAED,WAAW,EAAE,CAAC,aAAa,EAAE,uBAAuB,KAAK,IAAI,CAAA;IAC7D,aAAa,EAAE,uBAAuB,GAAG,IAAI,CAAA;IAC7C,YAAY,EAAE,uBAAuB,CAAA;IACrC,aAAa,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,aAAa,EAAE,uBAAuB,KAAK,IAAI,CAAA;IAC7E,eAAe,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;IACxC,IAAI,EAAE,MAAM,CAAA;CACb;AAQD,eAAO,MAAM,oBAAoB,+EAM9B;IACD,QAAQ,EAAE,MAAM,SAAS,CAAA;IACzB,YAAY,EAAE,2BAA2B,CAAA;IACzC,kBAAkB,EAAE,MAAM,SAAS,CAAC,cAAc,CAAC,CAAA;IACnD,UAAU,EAAE,aAAa,GAAG;QAC1B,YAAY,EAAE,2BAA2B,CAAA;QACzC,IAAI,EAAE,MAAM,CAAA;QACZ,oBAAoB,EAAE,IAAI,MAAM,EAAE,MAAM,SAAS,CAAC,CAAA;KACnD,CAAA;IACD,aAAa,CAAC,EAAE,uBAAuB,CAAA;CACxC,KAAG,MAAM,SA2ET,CAAA;AAED,eAAO,MAAM,sBAAsB,QAAO,uBAMzC,CAAA"}