@payloadcms/richtext-lexical 3.0.0-beta.35 → 3.0.0-beta.37

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

@@ -1 +1 @@
-{"version":3,"file":"LexicalEditor.d.ts","sourceRoot":"","sources":["../../../src/field/lexical/LexicalEditor.tsx"],"names":[],"mappings":"AASA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAG9B,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAA;AAIhE,OAAO,sBAAsB,CAAA;AAQ7B,eAAO,MAAM,aAAa,EAAE,KAAK,CAAC,EAAE,CAAC,IAAI,CAAC,oBAAoB,EAAE,cAAc,GAAG,UAAU,CAAC,CAiK3F,CAAA"}
+{"version":3,"file":"LexicalEditor.d.ts","sourceRoot":"","sources":["../../../src/field/lexical/LexicalEditor.tsx"],"names":[],"mappings":"AAUA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAG9B,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAA;AAIhE,OAAO,sBAAsB,CAAA;AAQ7B,eAAO,MAAM,aAAa,EAAE,KAAK,CAAC,EAAE,CAAC,IAAI,CAAC,oBAAoB,EAAE,cAAc,GAAG,UAAU,CAAC,CA8J3F,CAAA"}

package/dist/field/lexical/LexicalEditor.js

@@ -1,4 +1,5 @@
 'use client';
+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';
@@ -6,6 +7,7 @@ import { OnChangePlugin } from '@lexical/react/LexicalOnChangePlugin.js';
 import { RichTextPlugin } from '@lexical/react/LexicalRichTextPlugin.js';
 import { TabIndentationPlugin } from '@lexical/react/LexicalTabIndentationPlugin.js';
 import { mergeRegister } from '@lexical/utils';
+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';
@@ -23,6 +25,7 @@ export const LexicalEditor = (props)=>{
     const editorConfigContext = useEditorConfigContext();
     const [editor] = useLexicalComposerContext();
     const editorFocus = useEditorFocus();
+    const { t } = useTranslation();
     const [floatingAnchorElem, setFloatingAnchorElem] = useState(null);
     const onRef = (_floatingAnchorElem)=>{
         if (_floatingAnchorElem !== null) {
@@ -60,87 +63,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 === 'aboveContainer') {
-            return /*#__PURE__*/ React.createElement(EditorPlugin, {
-                clientProps: plugin.clientProps,
-                key: plugin.key,
-                plugin: plugin
-            });
-        }
-    }), /*#__PURE__*/ React.createElement("div", {
-        className: "editor-container"
-    }, editorConfig.features.plugins.map((plugin)=>{
-        if (plugin.position === 'top') {
-            return /*#__PURE__*/ React.createElement(EditorPlugin, {
-                clientProps: plugin.clientProps,
-                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,
-                clientProps: plugin.clientProps,
-                key: plugin.key,
-                plugin: plugin
-            });
-        }
-    }), editor.isEditable() && /*#__PURE__*/ React.createElement(React.Fragment, null, /*#__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, {
-                clientProps: plugin.clientProps,
-                key: plugin.key,
-                plugin: plugin
-            });
-        }
-    }), editorConfig.features.plugins.map((plugin)=>{
-        if (plugin.position === 'bottom') {
-            return /*#__PURE__*/ React.createElement(EditorPlugin, {
-                clientProps: plugin.clientProps,
-                key: plugin.key,
-                plugin: plugin
-            });
-        }
-    })), editorConfig.features.plugins.map((plugin)=>{
-        if (plugin.position === 'belowContainer') {
-            return /*#__PURE__*/ React.createElement(EditorPlugin, {
-                clientProps: plugin.clientProps,
-                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",
+                children: [
+                    editorConfig.features.plugins.map((plugin)=>{
+                        if (plugin.position === 'top') {
+                            return /*#__PURE__*/ _jsx(EditorPlugin, {
+                                clientProps: plugin.clientProps,
+                                plugin: plugin
+                            }, plugin.key);
+                        }
+                    }),
+                    /*#__PURE__*/ _jsx(RichTextPlugin, {
+                        //@ts-expect-error ts being dumb
+                        ErrorBoundary: ErrorBoundaryComponent,
+                        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 { 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 { mergeRegister } from '@lexical/utils'\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 { useEditorFocus } from './EditorFocusProvider.js'\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<Pick<LexicalProviderProps, 'editorConfig' | 'onChange'>> = (\n  props,\n) => {\n  const { editorConfig, onChange } = props\n  const editorConfigContext = useEditorConfigContext()\n  const [editor] = useLexicalComposerContext()\n  const editorFocus = useEditorFocus()\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    return mergeRegister(\n      editor.registerCommand<MouseEvent>(\n        FOCUS_COMMAND,\n        () => {\n          editorFocus.focusEditor(editor, editorConfigContext)\n          return true\n        },\n\n        COMMAND_PRIORITY_LOW,\n      ),\n      editor.registerCommand<MouseEvent>(\n        BLUR_COMMAND,\n        () => {\n          editorFocus.blurEditor()\n          return true\n        },\n\n        COMMAND_PRIORITY_LOW,\n      ),\n    )\n  }, [editor, editorConfig, editorConfigContext, editorFocus])\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  const ErrorBoundaryComponent = LexicalErrorBoundary.default || LexicalErrorBoundary\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\">\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          //@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\">\n              Start typing, or press &apos;/&apos; for commands...\n            </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\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","mergeRegister","BLUR_COMMAND","COMMAND_PRIORITY_LOW","FOCUS_COMMAND","React","useEffect","useState","useEditorFocus","EditorPlugin","useEditorConfigContext","MarkdownShortcutPlugin","SlashMenuPlugin","AddBlockHandlePlugin","DraggableBlockPlugin","LexicalContentEditable","LexicalEditor","props","editorConfig","onChange","editorConfigContext","editor","editorFocus","floatingAnchorElem","setFloatingAnchorElem","onRef","_floatingAnchorElem","registerCommand","focusEditor","blurEditor","isSmallWidthViewport","setIsSmallWidthViewport","updateViewPortWidth","isNextSmallWidthViewport","window","matchMedia","matches","addEventListener","removeEventListener","ErrorBoundaryComponent","default","Fragment","features","plugins","map","plugin","position","clientProps","key","div","className","ErrorBoundary","contentEditable","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 { mergeRegister } from '@lexical/utils'\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 { useEditorFocus } from './EditorFocusProvider.js'\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<Pick<LexicalProviderProps, 'editorConfig' | 'onChange'>> = (\n  props,\n) => {\n  const { editorConfig, onChange } = props\n  const editorConfigContext = useEditorConfigContext()\n  const [editor] = useLexicalComposerContext()\n  const editorFocus = useEditorFocus()\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    return mergeRegister(\n      editor.registerCommand<MouseEvent>(\n        FOCUS_COMMAND,\n        () => {\n          editorFocus.focusEditor(editor, editorConfigContext)\n          return true\n        },\n\n        COMMAND_PRIORITY_LOW,\n      ),\n      editor.registerCommand<MouseEvent>(\n        BLUR_COMMAND,\n        () => {\n          editorFocus.blurEditor()\n          return true\n        },\n\n        COMMAND_PRIORITY_LOW,\n      ),\n    )\n  }, [editor, editorConfig, editorConfigContext, editorFocus])\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  const ErrorBoundaryComponent = LexicalErrorBoundary.default || LexicalErrorBoundary\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\">\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          //@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={<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","mergeRegister","useTranslation","BLUR_COMMAND","COMMAND_PRIORITY_LOW","FOCUS_COMMAND","React","useEffect","useState","useEditorFocus","EditorPlugin","useEditorConfigContext","MarkdownShortcutPlugin","SlashMenuPlugin","AddBlockHandlePlugin","DraggableBlockPlugin","LexicalContentEditable","LexicalEditor","props","editorConfig","onChange","editorConfigContext","editor","editorFocus","t","floatingAnchorElem","setFloatingAnchorElem","onRef","_floatingAnchorElem","registerCommand","focusEditor","blurEditor","isSmallWidthViewport","setIsSmallWidthViewport","updateViewPortWidth","isNextSmallWidthViewport","window","matchMedia","matches","addEventListener","removeEventListener","ErrorBoundaryComponent","default","Fragment","features","plugins","map","plugin","position","clientProps","key","div","className","ErrorBoundary","contentEditable","ref","placeholder","p","ignoreSelectionChange","editorState","tags","has","size","isEditable","anchorElem","desktopOnly","markdownTransformers","length"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/dist/field/lexical/LexicalEditor.scss

@@ -22,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: 0;
     font-size: 15px;
     color: var(--theme-elevation-500);
     /* Prevent text selection */

package/dist/field/lexical/LexicalProvider.js

@@ -1,4 +1,5 @@
 'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
 import { LexicalComposer } from '@lexical/react/LexicalComposer.js';
 import * as React from 'react';
 import { EditorFocusProvider } from './EditorFocusProvider.js';
@@ -48,18 +49,23 @@ export const LexicalProvider = (props)=>{
         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(EditorFocusProvider, null, /*#__PURE__*/ React.createElement(EditorConfigProvider, {
-        editorConfig: editorConfig,
-        fieldProps: fieldProps
-    }, /*#__PURE__*/ React.createElement(LexicalEditorComponent, {
-        editorConfig: editorConfig,
-        onChange: onChange
-    }))));
+        children: /*#__PURE__*/ _jsx(EditorFocusProvider, {
+            children: /*#__PURE__*/ _jsx(EditorConfigProvider, {
+                editorConfig: editorConfig,
+                fieldProps: fieldProps,
+                children: /*#__PURE__*/ _jsx(LexicalEditorComponent, {
+                    editorConfig: editorConfig,
+                    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 { 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'\n\nimport type { SanitizedClientEditorConfig } from './config/types.js'\n\nimport { EditorFocusProvider } from './EditorFocusProvider.js'\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      <EditorFocusProvider>\n        <EditorConfigProvider editorConfig={editorConfig} fieldProps={fieldProps}>\n          <LexicalEditorComponent editorConfig={editorConfig} onChange={onChange} />\n        </EditorConfigProvider>\n      </EditorFocusProvider>\n    </LexicalComposer>\n  )\n}\n"],"names":["LexicalComposer","React","EditorFocusProvider","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"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA;AAMA,SAASA,eAAe,QAAQ,oCAAmC;AACnE,YAAYC,WAAW,QAAO;AAI9B,SAASC,mBAAmB,QAAQ,2BAA0B;AAC9D,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,GAAGf,MAAMgB,QAAQ,CAA2B;IAEnF,iGAAiG;IACjGhB,MAAMiB,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,oBAACzC;QAAgBe,eAAeA;QAAe2B,KAAK9B;qBAClD,oBAACV,yCACC,oBAACG;QAAqBI,cAAcA;QAAcC,YAAYA;qBAC5D,oBAACN;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'\n\nimport type { SanitizedClientEditorConfig } from './config/types.js'\n\nimport { EditorFocusProvider } from './EditorFocusProvider.js'\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      <EditorFocusProvider>\n        <EditorConfigProvider editorConfig={editorConfig} fieldProps={fieldProps}>\n          <LexicalEditorComponent editorConfig={editorConfig} onChange={onChange} />\n        </EditorConfigProvider>\n      </EditorFocusProvider>\n    </LexicalComposer>\n  )\n}\n"],"names":["LexicalComposer","React","EditorFocusProvider","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"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA;;AAMA,SAASA,eAAe,QAAQ,oCAAmC;AACnE,YAAYC,WAAW,QAAO;AAI9B,SAASC,mBAAmB,QAAQ,2BAA0B;AAC9D,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,GAAGf,MAAMgB,QAAQ,CAA2B;IAEnF,iGAAiG;IACjGhB,MAAMiB,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,KAAC0B;sBAAE;;IACZ;IAEA,qBACE,KAACzC;QAAgBe,eAAeA;kBAC9B,cAAA,KAACb;sBACC,cAAA,KAACG;gBAAqBI,cAAcA;gBAAcC,YAAYA;0BAC5D,cAAA,KAACN;oBAAuBK,cAAcA;oBAAcE,UAAUA;;;;OAHhBC;AAQxD,EAAC"}

package/dist/field/lexical/config/client/EditorConfigProvider.js

@@ -1,4 +1,5 @@
 'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
 import * as React from 'react';
 import { createContext, useContext, useEffect, useMemo, useState } from 'react';
 // Should always produce a 20 character pseudo-random string
@@ -26,9 +27,10 @@ export const EditorConfigProvider = ({ children, editorConfig, fieldProps })=>{
         fieldProps,
         uuid
     ]);
-    return /*#__PURE__*/ React.createElement(Context.Provider, {
-        value: editorContext
-    }, children);
+    return /*#__PURE__*/ _jsx(Context.Provider, {
+        value: editorContext,
+        children: children
+    });
 };
 export const useEditorConfigContext = ()=>{
     const context = useContext(Context);

package/dist/field/lexical/config/client/EditorConfigProvider.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../src/field/lexical/config/client/EditorConfigProvider.tsx"],"sourcesContent":["'use client'\n\nimport type { FormFieldBase } from '@payloadcms/ui/fields/shared'\n\nimport * as React from 'react'\nimport { createContext, useContext, useEffect, useMemo, useState } from 'react'\n\nimport type { SanitizedClientEditorConfig } from '../types.js'\n\n// Should always produce a 20 character pseudo-random string\nfunction generateQuickGuid(): string {\n  return Math.random().toString(36).substring(2, 12) + Math.random().toString(36).substring(2, 12)\n}\nexport interface EditorConfigContextType {\n  editorConfig: SanitizedClientEditorConfig\n  field: FormFieldBase & {\n    editorConfig: SanitizedClientEditorConfig // With rendered features n stuff\n    name: string\n    richTextComponentMap: Map<string, React.ReactNode>\n  }\n  uuid: string\n}\n\nconst Context: React.Context<EditorConfigContextType> = createContext({\n  editorConfig: null,\n  field: null,\n  uuid: generateQuickGuid(),\n})\n\nexport const EditorConfigProvider = ({\n  children,\n  editorConfig,\n  fieldProps,\n}: {\n  children: React.ReactNode\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}): React.ReactNode => {\n  // State to store the UUID\n  const [uuid, setUuid] = useState(generateQuickGuid())\n\n  // When the component mounts, generate a new UUID only once\n  useEffect(() => {\n    setUuid(generateQuickGuid())\n  }, [])\n\n  const editorContext = useMemo(\n    () => ({ editorConfig, field: fieldProps, uuid }),\n    [editorConfig, fieldProps, uuid],\n  )\n\n  return <Context.Provider value={editorContext}>{children}</Context.Provider>\n}\n\nexport const useEditorConfigContext = (): EditorConfigContextType => {\n  const context = useContext(Context)\n  if (context === undefined) {\n    throw new Error('useEditorConfigContext must be used within an EditorConfigProvider')\n  }\n  return context\n}\n"],"names":["React","createContext","useContext","useEffect","useMemo","useState","generateQuickGuid","Math","random","toString","substring","Context","editorConfig","field","uuid","EditorConfigProvider","children","fieldProps","setUuid","editorContext","Provider","value","useEditorConfigContext","context","undefined","Error"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA;AAIA,YAAYA,WAAW,QAAO;AAC9B,SAASC,aAAa,EAAEC,UAAU,EAAEC,SAAS,EAAEC,OAAO,EAAEC,QAAQ,QAAQ,QAAO;AAI/E,4DAA4D;AAC5D,SAASC;IACP,OAAOC,KAAKC,MAAM,GAAGC,QAAQ,CAAC,IAAIC,SAAS,CAAC,GAAG,MAAMH,KAAKC,MAAM,GAAGC,QAAQ,CAAC,IAAIC,SAAS,CAAC,GAAG;AAC/F;AAWA,MAAMC,wBAAkDV,cAAc;IACpEW,cAAc;IACdC,OAAO;IACPC,MAAMR;AACR;AAEA,OAAO,MAAMS,uBAAuB,CAAC,EACnCC,QAAQ,EACRJ,YAAY,EACZK,UAAU,EASX;IACC,0BAA0B;IAC1B,MAAM,CAACH,MAAMI,QAAQ,GAAGb,SAASC;IAEjC,2DAA2D;IAC3DH,UAAU;QACRe,QAAQZ;IACV,GAAG,EAAE;IAEL,MAAMa,gBAAgBf,QACpB,IAAO,CAAA;YAAEQ;YAAcC,OAAOI;YAAYH;QAAK,CAAA,GAC/C;QAACF;QAAcK;QAAYH;KAAK;IAGlC,qBAAO,oBAACH,QAAQS,QAAQ;QAACC,OAAOF;OAAgBH;AAClD,EAAC;AAED,OAAO,MAAMM,yBAAyB;IACpC,MAAMC,UAAUrB,WAAWS;IAC3B,IAAIY,YAAYC,WAAW;QACzB,MAAM,IAAIC,MAAM;IAClB;IACA,OAAOF;AACT,EAAC"}
+{"version":3,"sources":["../../../../../src/field/lexical/config/client/EditorConfigProvider.tsx"],"sourcesContent":["'use client'\n\nimport type { FormFieldBase } from '@payloadcms/ui/fields/shared'\n\nimport * as React from 'react'\nimport { createContext, useContext, useEffect, useMemo, useState } from 'react'\n\nimport type { SanitizedClientEditorConfig } from '../types.js'\n\n// Should always produce a 20 character pseudo-random string\nfunction generateQuickGuid(): string {\n  return Math.random().toString(36).substring(2, 12) + Math.random().toString(36).substring(2, 12)\n}\nexport interface EditorConfigContextType {\n  editorConfig: SanitizedClientEditorConfig\n  field: FormFieldBase & {\n    editorConfig: SanitizedClientEditorConfig // With rendered features n stuff\n    name: string\n    richTextComponentMap: Map<string, React.ReactNode>\n  }\n  uuid: string\n}\n\nconst Context: React.Context<EditorConfigContextType> = createContext({\n  editorConfig: null,\n  field: null,\n  uuid: generateQuickGuid(),\n})\n\nexport const EditorConfigProvider = ({\n  children,\n  editorConfig,\n  fieldProps,\n}: {\n  children: React.ReactNode\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}): React.ReactNode => {\n  // State to store the UUID\n  const [uuid, setUuid] = useState(generateQuickGuid())\n\n  // When the component mounts, generate a new UUID only once\n  useEffect(() => {\n    setUuid(generateQuickGuid())\n  }, [])\n\n  const editorContext = useMemo(\n    () => ({ editorConfig, field: fieldProps, uuid }),\n    [editorConfig, fieldProps, uuid],\n  )\n\n  return <Context.Provider value={editorContext}>{children}</Context.Provider>\n}\n\nexport const useEditorConfigContext = (): EditorConfigContextType => {\n  const context = useContext(Context)\n  if (context === undefined) {\n    throw new Error('useEditorConfigContext must be used within an EditorConfigProvider')\n  }\n  return context\n}\n"],"names":["React","createContext","useContext","useEffect","useMemo","useState","generateQuickGuid","Math","random","toString","substring","Context","editorConfig","field","uuid","EditorConfigProvider","children","fieldProps","setUuid","editorContext","Provider","value","useEditorConfigContext","context","undefined","Error"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA;;AAIA,YAAYA,WAAW,QAAO;AAC9B,SAASC,aAAa,EAAEC,UAAU,EAAEC,SAAS,EAAEC,OAAO,EAAEC,QAAQ,QAAQ,QAAO;AAI/E,4DAA4D;AAC5D,SAASC;IACP,OAAOC,KAAKC,MAAM,GAAGC,QAAQ,CAAC,IAAIC,SAAS,CAAC,GAAG,MAAMH,KAAKC,MAAM,GAAGC,QAAQ,CAAC,IAAIC,SAAS,CAAC,GAAG;AAC/F;AAWA,MAAMC,wBAAkDV,cAAc;IACpEW,cAAc;IACdC,OAAO;IACPC,MAAMR;AACR;AAEA,OAAO,MAAMS,uBAAuB,CAAC,EACnCC,QAAQ,EACRJ,YAAY,EACZK,UAAU,EASX;IACC,0BAA0B;IAC1B,MAAM,CAACH,MAAMI,QAAQ,GAAGb,SAASC;IAEjC,2DAA2D;IAC3DH,UAAU;QACRe,QAAQZ;IACV,GAAG,EAAE;IAEL,MAAMa,gBAAgBf,QACpB,IAAO,CAAA;YAAEQ;YAAcC,OAAOI;YAAYH;QAAK,CAAA,GAC/C;QAACF;QAAcK;QAAYH;KAAK;IAGlC,qBAAO,KAACH,QAAQS,QAAQ;QAACC,OAAOF;kBAAgBH;;AAClD,EAAC;AAED,OAAO,MAAMM,yBAAyB;IACpC,MAAMC,UAAUrB,WAAWS;IAC3B,IAAIY,YAAYC,WAAW;QACzB,MAAM,IAAIC,MAAM;IAClB;IACA,OAAOF;AACT,EAAC"}

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

@@ -1,6 +1,7 @@
 import type { EditorConfig as LexicalEditorConfig } from 'lexical';
+import type { LexicalFieldAdminProps } from '../../../../types.js';
 import type { ResolvedClientFeatureMap, SanitizedClientFeatures } from '../../../features/types.js';
 import type { SanitizedClientEditorConfig } from '../types.js';
 export declare const sanitizeClientFeatures: (features: ResolvedClientFeatureMap) => SanitizedClientFeatures;
-export declare function sanitizeClientEditorConfig(lexical: LexicalEditorConfig, resolvedClientFeatureMap: ResolvedClientFeatureMap): SanitizedClientEditorConfig;
+export declare function sanitizeClientEditorConfig(lexical: LexicalEditorConfig, resolvedClientFeatureMap: ResolvedClientFeatureMap, admin?: LexicalFieldAdminProps): SanitizedClientEditorConfig;
 //# sourceMappingURL=sanitize.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"sanitize.d.ts","sourceRoot":"","sources":["../../../../../src/field/lexical/config/client/sanitize.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,IAAI,mBAAmB,EAAE,MAAM,SAAS,CAAA;AAElE,OAAO,KAAK,EAAE,wBAAwB,EAAE,uBAAuB,EAAE,MAAM,4BAA4B,CAAA;AACnG,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,aAAa,CAAA;AAE9D,eAAO,MAAM,sBAAsB,0CAEhC,uBAiMF,CAAA;AAED,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,mBAAmB,EAC5B,wBAAwB,EAAE,wBAAwB,GACjD,2BAA2B,CAM7B"}
+{"version":3,"file":"sanitize.d.ts","sourceRoot":"","sources":["../../../../../src/field/lexical/config/client/sanitize.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,IAAI,mBAAmB,EAAE,MAAM,SAAS,CAAA;AAElE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAA;AAClE,OAAO,KAAK,EAAE,wBAAwB,EAAE,uBAAuB,EAAE,MAAM,4BAA4B,CAAA;AACnG,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,aAAa,CAAA;AAE9D,eAAO,MAAM,sBAAsB,0CAEhC,uBAiMF,CAAA;AAED,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,mBAAmB,EAC5B,wBAAwB,EAAE,wBAAwB,EAClD,KAAK,CAAC,EAAE,sBAAsB,GAC7B,2BAA2B,CAO7B"}

package/dist/field/lexical/config/client/sanitize.js

@@ -164,8 +164,9 @@ export const sanitizeClientFeatures = (features)=>{
     }
     return sanitized;
 };
-export function sanitizeClientEditorConfig(lexical, resolvedClientFeatureMap) {
+export function sanitizeClientEditorConfig(lexical, resolvedClientFeatureMap, admin) {
     return {
+        admin,
         features: sanitizeClientFeatures(resolvedClientFeatureMap),
         lexical,
         resolvedFeatureMap: resolvedClientFeatureMap

package/dist/field/lexical/config/client/sanitize.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../src/field/lexical/config/client/sanitize.ts"],"sourcesContent":["'use client'\n\nimport type { EditorConfig as LexicalEditorConfig } from 'lexical'\n\nimport type { ResolvedClientFeatureMap, SanitizedClientFeatures } from '../../../features/types.js'\nimport type { SanitizedClientEditorConfig } from '../types.js'\n\nexport const sanitizeClientFeatures = (\n  features: ResolvedClientFeatureMap,\n): SanitizedClientFeatures => {\n  const sanitized: SanitizedClientFeatures = {\n    enabledFeatures: [],\n    hooks: {\n      load: [],\n      save: [],\n    },\n    markdownTransformers: [],\n    nodes: [],\n    plugins: [],\n    slashMenu: {\n      dynamicGroups: [],\n      groups: [],\n    },\n    toolbarFixed: {\n      groups: [],\n    },\n    toolbarInline: {\n      groups: [],\n    },\n  }\n\n  if (!features?.size) {\n    return sanitized\n  }\n\n  features.forEach((feature) => {\n    if (feature.hooks) {\n      if (feature.hooks?.load?.length) {\n        sanitized.hooks.load = sanitized.hooks.load.concat(feature.hooks.load)\n      }\n      if (feature.hooks?.save?.length) {\n        sanitized.hooks.save = sanitized.hooks.save.concat(feature.hooks.save)\n      }\n    }\n\n    if (feature.nodes?.length) {\n      sanitized.nodes = sanitized.nodes.concat(feature.nodes)\n    }\n    if (feature.plugins?.length) {\n      feature.plugins.forEach((plugin, i) => {\n        sanitized.plugins.push({\n          Component: plugin.Component,\n          clientProps: feature.clientFeatureProps,\n          key: feature.key + i,\n          position: plugin.position,\n        })\n      })\n    }\n\n    if (feature.toolbarInline?.groups?.length) {\n      for (const group of feature.toolbarInline.groups) {\n        // 1. find the group with the same key or create new one\n        let foundGroup = sanitized.toolbarInline.groups.find(\n          (sanitizedGroup) => sanitizedGroup.key === group.key,\n        )\n        if (!foundGroup) {\n          foundGroup = {\n            ...group,\n            items: [],\n          }\n        } else {\n          sanitized.toolbarInline.groups = sanitized.toolbarInline.groups.filter(\n            (sanitizedGroup) => sanitizedGroup.key !== group.key,\n          )\n        }\n\n        // 2. Add options to group options array and add to sanitized.slashMenu.groupsWithOptions\n        if (group?.items?.length) {\n          foundGroup.items = foundGroup.items.concat(group.items)\n        }\n        sanitized.toolbarInline?.groups.push(foundGroup)\n      }\n    }\n\n    if (feature.toolbarFixed?.groups?.length) {\n      for (const group of feature.toolbarFixed.groups) {\n        // 1. find the group with the same key or create new one\n        let foundGroup = sanitized.toolbarFixed.groups.find(\n          (sanitizedGroup) => sanitizedGroup.key === group.key,\n        )\n        if (!foundGroup) {\n          foundGroup = {\n            ...group,\n            items: [],\n          }\n        } else {\n          sanitized.toolbarFixed.groups = sanitized.toolbarFixed.groups.filter(\n            (sanitizedGroup) => sanitizedGroup.key !== group.key,\n          )\n        }\n\n        // 2. Add options to group options array and add to sanitized.slashMenu.groupsWithOptions\n        if (group?.items?.length) {\n          foundGroup.items = foundGroup.items.concat(group.items)\n        }\n        sanitized.toolbarFixed?.groups.push(foundGroup)\n      }\n    }\n\n    if (feature.slashMenu?.groups) {\n      if (feature.slashMenu.dynamicGroups?.length) {\n        sanitized.slashMenu.dynamicGroups = sanitized.slashMenu.dynamicGroups.concat(\n          feature.slashMenu.dynamicGroups,\n        )\n      }\n\n      for (const optionGroup of feature.slashMenu.groups) {\n        // 1. find the group with the same name or create new one\n        let group = sanitized.slashMenu.groups.find((group) => group.key === optionGroup.key)\n        if (!group) {\n          group = {\n            ...optionGroup,\n            items: [],\n          }\n        } else {\n          sanitized.slashMenu.groups = sanitized.slashMenu.groups.filter(\n            (group) => group.key !== optionGroup.key,\n          )\n        }\n\n        // 2. Add options to group options array and add to sanitized.slashMenu.groupsWithOptions\n        if (optionGroup?.items?.length) {\n          group.items = group.items.concat(optionGroup.items)\n        }\n        sanitized.slashMenu.groups.push(group)\n      }\n    }\n\n    if (feature.markdownTransformers?.length) {\n      sanitized.markdownTransformers = sanitized.markdownTransformers.concat(\n        feature.markdownTransformers,\n      )\n    }\n    sanitized.enabledFeatures.push(feature.key)\n  })\n\n  // Sort sanitized.toolbarInline.groups by order property\n  sanitized.toolbarInline.groups.sort((a, b) => {\n    if (a.order && b.order) {\n      return a.order - b.order\n    } else if (a.order) {\n      return -1\n    } else if (b.order) {\n      return 1\n    } else {\n      return 0\n    }\n  })\n  // Sort sanitized.toolbarFixed.groups by order property\n  sanitized.toolbarFixed.groups.sort((a, b) => {\n    if (a.order && b.order) {\n      return a.order - b.order\n    } else if (a.order) {\n      return -1\n    } else if (b.order) {\n      return 1\n    } else {\n      return 0\n    }\n  })\n\n  // Sort sanitized.toolbarInline.groups.[group].entries by order property\n  for (const group of sanitized.toolbarInline.groups) {\n    group.items.sort((a, b) => {\n      if (a.order && b.order) {\n        return a.order - b.order\n      } else if (a.order) {\n        return -1\n      } else if (b.order) {\n        return 1\n      } else {\n        return 0\n      }\n    })\n  }\n\n  // Sort sanitized.toolbarFixed.groups.[group].entries by order property\n  for (const group of sanitized.toolbarFixed.groups) {\n    group.items.sort((a, b) => {\n      if (a.order && b.order) {\n        return a.order - b.order\n      } else if (a.order) {\n        return -1\n      } else if (b.order) {\n        return 1\n      } else {\n        return 0\n      }\n    })\n  }\n\n  return sanitized\n}\n\nexport function sanitizeClientEditorConfig(\n  lexical: LexicalEditorConfig,\n  resolvedClientFeatureMap: ResolvedClientFeatureMap,\n): SanitizedClientEditorConfig {\n  return {\n    features: sanitizeClientFeatures(resolvedClientFeatureMap),\n    lexical,\n    resolvedFeatureMap: resolvedClientFeatureMap,\n  }\n}\n"],"names":["sanitizeClientFeatures","features","sanitized","enabledFeatures","hooks","load","save","markdownTransformers","nodes","plugins","slashMenu","dynamicGroups","groups","toolbarFixed","toolbarInline","size","forEach","feature","length","concat","plugin","i","push","Component","clientProps","clientFeatureProps","key","position","group","foundGroup","find","sanitizedGroup","items","filter","optionGroup","sort","a","b","order","sanitizeClientEditorConfig","lexical","resolvedClientFeatureMap","resolvedFeatureMap"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}
+{"version":3,"sources":["../../../../../src/field/lexical/config/client/sanitize.ts"],"sourcesContent":["'use client'\n\nimport type { EditorConfig as LexicalEditorConfig } from 'lexical'\n\nimport type { LexicalFieldAdminProps } from '../../../../types.js'\nimport type { ResolvedClientFeatureMap, SanitizedClientFeatures } from '../../../features/types.js'\nimport type { SanitizedClientEditorConfig } from '../types.js'\n\nexport const sanitizeClientFeatures = (\n  features: ResolvedClientFeatureMap,\n): SanitizedClientFeatures => {\n  const sanitized: SanitizedClientFeatures = {\n    enabledFeatures: [],\n    hooks: {\n      load: [],\n      save: [],\n    },\n    markdownTransformers: [],\n    nodes: [],\n    plugins: [],\n    slashMenu: {\n      dynamicGroups: [],\n      groups: [],\n    },\n    toolbarFixed: {\n      groups: [],\n    },\n    toolbarInline: {\n      groups: [],\n    },\n  }\n\n  if (!features?.size) {\n    return sanitized\n  }\n\n  features.forEach((feature) => {\n    if (feature.hooks) {\n      if (feature.hooks?.load?.length) {\n        sanitized.hooks.load = sanitized.hooks.load.concat(feature.hooks.load)\n      }\n      if (feature.hooks?.save?.length) {\n        sanitized.hooks.save = sanitized.hooks.save.concat(feature.hooks.save)\n      }\n    }\n\n    if (feature.nodes?.length) {\n      sanitized.nodes = sanitized.nodes.concat(feature.nodes)\n    }\n    if (feature.plugins?.length) {\n      feature.plugins.forEach((plugin, i) => {\n        sanitized.plugins.push({\n          Component: plugin.Component,\n          clientProps: feature.clientFeatureProps,\n          key: feature.key + i,\n          position: plugin.position,\n        })\n      })\n    }\n\n    if (feature.toolbarInline?.groups?.length) {\n      for (const group of feature.toolbarInline.groups) {\n        // 1. find the group with the same key or create new one\n        let foundGroup = sanitized.toolbarInline.groups.find(\n          (sanitizedGroup) => sanitizedGroup.key === group.key,\n        )\n        if (!foundGroup) {\n          foundGroup = {\n            ...group,\n            items: [],\n          }\n        } else {\n          sanitized.toolbarInline.groups = sanitized.toolbarInline.groups.filter(\n            (sanitizedGroup) => sanitizedGroup.key !== group.key,\n          )\n        }\n\n        // 2. Add options to group options array and add to sanitized.slashMenu.groupsWithOptions\n        if (group?.items?.length) {\n          foundGroup.items = foundGroup.items.concat(group.items)\n        }\n        sanitized.toolbarInline?.groups.push(foundGroup)\n      }\n    }\n\n    if (feature.toolbarFixed?.groups?.length) {\n      for (const group of feature.toolbarFixed.groups) {\n        // 1. find the group with the same key or create new one\n        let foundGroup = sanitized.toolbarFixed.groups.find(\n          (sanitizedGroup) => sanitizedGroup.key === group.key,\n        )\n        if (!foundGroup) {\n          foundGroup = {\n            ...group,\n            items: [],\n          }\n        } else {\n          sanitized.toolbarFixed.groups = sanitized.toolbarFixed.groups.filter(\n            (sanitizedGroup) => sanitizedGroup.key !== group.key,\n          )\n        }\n\n        // 2. Add options to group options array and add to sanitized.slashMenu.groupsWithOptions\n        if (group?.items?.length) {\n          foundGroup.items = foundGroup.items.concat(group.items)\n        }\n        sanitized.toolbarFixed?.groups.push(foundGroup)\n      }\n    }\n\n    if (feature.slashMenu?.groups) {\n      if (feature.slashMenu.dynamicGroups?.length) {\n        sanitized.slashMenu.dynamicGroups = sanitized.slashMenu.dynamicGroups.concat(\n          feature.slashMenu.dynamicGroups,\n        )\n      }\n\n      for (const optionGroup of feature.slashMenu.groups) {\n        // 1. find the group with the same name or create new one\n        let group = sanitized.slashMenu.groups.find((group) => group.key === optionGroup.key)\n        if (!group) {\n          group = {\n            ...optionGroup,\n            items: [],\n          }\n        } else {\n          sanitized.slashMenu.groups = sanitized.slashMenu.groups.filter(\n            (group) => group.key !== optionGroup.key,\n          )\n        }\n\n        // 2. Add options to group options array and add to sanitized.slashMenu.groupsWithOptions\n        if (optionGroup?.items?.length) {\n          group.items = group.items.concat(optionGroup.items)\n        }\n        sanitized.slashMenu.groups.push(group)\n      }\n    }\n\n    if (feature.markdownTransformers?.length) {\n      sanitized.markdownTransformers = sanitized.markdownTransformers.concat(\n        feature.markdownTransformers,\n      )\n    }\n    sanitized.enabledFeatures.push(feature.key)\n  })\n\n  // Sort sanitized.toolbarInline.groups by order property\n  sanitized.toolbarInline.groups.sort((a, b) => {\n    if (a.order && b.order) {\n      return a.order - b.order\n    } else if (a.order) {\n      return -1\n    } else if (b.order) {\n      return 1\n    } else {\n      return 0\n    }\n  })\n  // Sort sanitized.toolbarFixed.groups by order property\n  sanitized.toolbarFixed.groups.sort((a, b) => {\n    if (a.order && b.order) {\n      return a.order - b.order\n    } else if (a.order) {\n      return -1\n    } else if (b.order) {\n      return 1\n    } else {\n      return 0\n    }\n  })\n\n  // Sort sanitized.toolbarInline.groups.[group].entries by order property\n  for (const group of sanitized.toolbarInline.groups) {\n    group.items.sort((a, b) => {\n      if (a.order && b.order) {\n        return a.order - b.order\n      } else if (a.order) {\n        return -1\n      } else if (b.order) {\n        return 1\n      } else {\n        return 0\n      }\n    })\n  }\n\n  // Sort sanitized.toolbarFixed.groups.[group].entries by order property\n  for (const group of sanitized.toolbarFixed.groups) {\n    group.items.sort((a, b) => {\n      if (a.order && b.order) {\n        return a.order - b.order\n      } else if (a.order) {\n        return -1\n      } else if (b.order) {\n        return 1\n      } else {\n        return 0\n      }\n    })\n  }\n\n  return sanitized\n}\n\nexport function sanitizeClientEditorConfig(\n  lexical: LexicalEditorConfig,\n  resolvedClientFeatureMap: ResolvedClientFeatureMap,\n  admin?: LexicalFieldAdminProps,\n): SanitizedClientEditorConfig {\n  return {\n    admin,\n    features: sanitizeClientFeatures(resolvedClientFeatureMap),\n    lexical,\n    resolvedFeatureMap: resolvedClientFeatureMap,\n  }\n}\n"],"names":["sanitizeClientFeatures","features","sanitized","enabledFeatures","hooks","load","save","markdownTransformers","nodes","plugins","slashMenu","dynamicGroups","groups","toolbarFixed","toolbarInline","size","forEach","feature","length","concat","plugin","i","push","Component","clientProps","clientFeatureProps","key","position","group","foundGroup","find","sanitizedGroup","items","filter","optionGroup","sort","a","b","order","sanitizeClientEditorConfig","lexical","resolvedClientFeatureMap","admin","resolvedFeatureMap"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/dist/field/lexical/config/server/sanitize.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sanitize.d.ts","sourceRoot":"","sources":["../../../../../src/field/lexical/config/server/sanitize.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAU,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAE7D,OAAO,KAAK,EAAE,wBAAwB,EAAE,uBAAuB,EAAE,MAAM,4BAA4B,CAAA;AACnG,OAAO,KAAK,EAAE,2BAA2B,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AAIlF,eAAO,MAAM,sBAAsB,0CAEhC,uBA0EF,CAAA;AAED,wBAAsB,0BAA0B,CAC9C,YAAY,EAAE,kBAAkB,EAChC,MAAM,EAAE,eAAe,GACtB,OAAO,CAAC,2BAA2B,CAAC,CAWtC"}
+{"version":3,"file":"sanitize.d.ts","sourceRoot":"","sources":["../../../../../src/field/lexical/config/server/sanitize.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAU,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAE7D,OAAO,KAAK,EAAE,wBAAwB,EAAE,uBAAuB,EAAE,MAAM,4BAA4B,CAAA;AACnG,OAAO,KAAK,EAAE,2BAA2B,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AAIlF,eAAO,MAAM,sBAAsB,0CAEhC,uBAsFF,CAAA;AAED,wBAAsB,0BAA0B,CAC9C,YAAY,EAAE,kBAAkB,EAChC,MAAM,EAAE,eAAe,GACtB,OAAO,CAAC,2BAA2B,CAAC,CAWtC"}

package/dist/field/lexical/config/server/sanitize.js

@@ -15,6 +15,7 @@ export const sanitizeServerFeatures = (features)=>{
             beforeDuplicate: new Map(),
             beforeValidate: new Map()
         },
+        i18n: {},
         markdownTransformers: [],
         nodes: [],
         populationPromises: new Map(),
@@ -27,6 +28,16 @@ export const sanitizeServerFeatures = (features)=>{
         if (feature?.generatedTypes?.modifyOutputSchema) {
             sanitized.generatedTypes.modifyOutputSchemas.push(feature.generatedTypes.modifyOutputSchema);
         }
+        if (feature?.i18n) {
+            for(const lang in feature.i18n){
+                if (!sanitized.i18n[lang]) {
+                    sanitized.i18n[lang] = {
+                        lexical: {}
+                    };
+                }
+                sanitized.i18n[lang].lexical[feature.key] = feature.i18n[lang];
+            }
+        }
         if (feature.nodes?.length) {
             sanitized.nodes = sanitized.nodes.concat(feature.nodes);
             feature.nodes.forEach((node)=>{

package/dist/field/lexical/config/server/sanitize.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../src/field/lexical/config/server/sanitize.ts"],"sourcesContent":["import type { Config, SanitizedConfig } from 'payload/config'\n\nimport type { ResolvedServerFeatureMap, SanitizedServerFeatures } from '../../../features/types.js'\nimport type { SanitizedServerEditorConfig, ServerEditorConfig } from '../types.js'\n\nimport { loadFeatures } from './loader.js'\n\nexport const sanitizeServerFeatures = (\n  features: ResolvedServerFeatureMap,\n): SanitizedServerFeatures => {\n  const sanitized: SanitizedServerFeatures = {\n    converters: {\n      html: [],\n    },\n    enabledFeatures: [],\n\n    generatedTypes: {\n      modifyOutputSchemas: [],\n    },\n    hooks: {\n      afterChange: new Map(),\n      afterRead: new Map(),\n      beforeChange: new Map(),\n      beforeDuplicate: new Map(),\n      beforeValidate: new Map(),\n    },\n    markdownTransformers: [],\n    nodes: [],\n    populationPromises: new Map(),\n\n    validations: new Map(),\n  }\n\n  if (!features?.size) {\n    return sanitized\n  }\n\n  features.forEach((feature) => {\n    if (feature?.generatedTypes?.modifyOutputSchema) {\n      sanitized.generatedTypes.modifyOutputSchemas.push(feature.generatedTypes.modifyOutputSchema)\n    }\n\n    if (feature.nodes?.length) {\n      sanitized.nodes = sanitized.nodes.concat(feature.nodes)\n      feature.nodes.forEach((node) => {\n        const nodeType = 'with' in node.node ? node.node.replace.getType() : node.node.getType() // TODO: Idk if this works for node replacements\n        if (node?.populationPromises?.length) {\n          sanitized.populationPromises.set(nodeType, node.populationPromises)\n        }\n        if (node?.validations?.length) {\n          sanitized.validations.set(nodeType, node.validations)\n        }\n        if (node?.converters?.html) {\n          sanitized.converters.html.push(node.converters.html)\n        }\n        if (node?.hooks?.afterChange) {\n          sanitized.hooks.afterChange.set(nodeType, node.hooks.afterChange)\n        }\n        if (node?.hooks?.afterRead) {\n          sanitized.hooks.afterRead.set(nodeType, node.hooks.afterRead)\n        }\n        if (node?.hooks?.beforeChange) {\n          sanitized.hooks.beforeChange.set(nodeType, node.hooks.beforeChange)\n        }\n        if (node?.hooks?.beforeDuplicate) {\n          sanitized.hooks.beforeDuplicate.set(nodeType, node.hooks.beforeDuplicate)\n        }\n        if (node?.hooks?.beforeValidate) {\n          sanitized.hooks.beforeValidate.set(nodeType, node.hooks.beforeValidate)\n        }\n      })\n    }\n\n    if (feature.markdownTransformers?.length) {\n      sanitized.markdownTransformers = sanitized.markdownTransformers.concat(\n        feature.markdownTransformers,\n      )\n    }\n\n    sanitized.enabledFeatures.push(feature.key)\n  })\n\n  return sanitized\n}\n\nexport async function sanitizeServerEditorConfig(\n  editorConfig: ServerEditorConfig,\n  config: SanitizedConfig,\n): Promise<SanitizedServerEditorConfig> {\n  const resolvedFeatureMap = await loadFeatures({\n    config,\n    unSanitizedEditorConfig: editorConfig,\n  })\n\n  return {\n    features: sanitizeServerFeatures(resolvedFeatureMap),\n    lexical: editorConfig.lexical,\n    resolvedFeatureMap,\n  }\n}\n"],"names":["loadFeatures","sanitizeServerFeatures","features","sanitized","converters","html","enabledFeatures","generatedTypes","modifyOutputSchemas","hooks","afterChange","Map","afterRead","beforeChange","beforeDuplicate","beforeValidate","markdownTransformers","nodes","populationPromises","validations","size","forEach","feature","modifyOutputSchema","push","length","concat","node","nodeType","replace","getType","set","key","sanitizeServerEditorConfig","editorConfig","config","resolvedFeatureMap","unSanitizedEditorConfig","lexical"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}
+{"version":3,"sources":["../../../../../src/field/lexical/config/server/sanitize.ts"],"sourcesContent":["import type { Config, SanitizedConfig } from 'payload/config'\n\nimport type { ResolvedServerFeatureMap, SanitizedServerFeatures } from '../../../features/types.js'\nimport type { SanitizedServerEditorConfig, ServerEditorConfig } from '../types.js'\n\nimport { loadFeatures } from './loader.js'\n\nexport const sanitizeServerFeatures = (\n  features: ResolvedServerFeatureMap,\n): SanitizedServerFeatures => {\n  const sanitized: SanitizedServerFeatures = {\n    converters: {\n      html: [],\n    },\n    enabledFeatures: [],\n    generatedTypes: {\n      modifyOutputSchemas: [],\n    },\n\n    hooks: {\n      afterChange: new Map(),\n      afterRead: new Map(),\n      beforeChange: new Map(),\n      beforeDuplicate: new Map(),\n      beforeValidate: new Map(),\n    },\n    i18n: {},\n    markdownTransformers: [],\n    nodes: [],\n    populationPromises: new Map(),\n\n    validations: new Map(),\n  }\n\n  if (!features?.size) {\n    return sanitized\n  }\n\n  features.forEach((feature) => {\n    if (feature?.generatedTypes?.modifyOutputSchema) {\n      sanitized.generatedTypes.modifyOutputSchemas.push(feature.generatedTypes.modifyOutputSchema)\n    }\n\n    if (feature?.i18n) {\n      for (const lang in feature.i18n) {\n        if (!sanitized.i18n[lang]) {\n          sanitized.i18n[lang] = {\n            lexical: {},\n          }\n        }\n        sanitized.i18n[lang].lexical[feature.key] = feature.i18n[lang]\n      }\n    }\n\n    if (feature.nodes?.length) {\n      sanitized.nodes = sanitized.nodes.concat(feature.nodes)\n      feature.nodes.forEach((node) => {\n        const nodeType = 'with' in node.node ? node.node.replace.getType() : node.node.getType() // TODO: Idk if this works for node replacements\n        if (node?.populationPromises?.length) {\n          sanitized.populationPromises.set(nodeType, node.populationPromises)\n        }\n        if (node?.validations?.length) {\n          sanitized.validations.set(nodeType, node.validations)\n        }\n        if (node?.converters?.html) {\n          sanitized.converters.html.push(node.converters.html)\n        }\n        if (node?.hooks?.afterChange) {\n          sanitized.hooks.afterChange.set(nodeType, node.hooks.afterChange)\n        }\n        if (node?.hooks?.afterRead) {\n          sanitized.hooks.afterRead.set(nodeType, node.hooks.afterRead)\n        }\n        if (node?.hooks?.beforeChange) {\n          sanitized.hooks.beforeChange.set(nodeType, node.hooks.beforeChange)\n        }\n        if (node?.hooks?.beforeDuplicate) {\n          sanitized.hooks.beforeDuplicate.set(nodeType, node.hooks.beforeDuplicate)\n        }\n        if (node?.hooks?.beforeValidate) {\n          sanitized.hooks.beforeValidate.set(nodeType, node.hooks.beforeValidate)\n        }\n      })\n    }\n\n    if (feature.markdownTransformers?.length) {\n      sanitized.markdownTransformers = sanitized.markdownTransformers.concat(\n        feature.markdownTransformers,\n      )\n    }\n\n    sanitized.enabledFeatures.push(feature.key)\n  })\n\n  return sanitized\n}\n\nexport async function sanitizeServerEditorConfig(\n  editorConfig: ServerEditorConfig,\n  config: SanitizedConfig,\n): Promise<SanitizedServerEditorConfig> {\n  const resolvedFeatureMap = await loadFeatures({\n    config,\n    unSanitizedEditorConfig: editorConfig,\n  })\n\n  return {\n    features: sanitizeServerFeatures(resolvedFeatureMap),\n    lexical: editorConfig.lexical,\n    resolvedFeatureMap,\n  }\n}\n"],"names":["loadFeatures","sanitizeServerFeatures","features","sanitized","converters","html","enabledFeatures","generatedTypes","modifyOutputSchemas","hooks","afterChange","Map","afterRead","beforeChange","beforeDuplicate","beforeValidate","i18n","markdownTransformers","nodes","populationPromises","validations","size","forEach","feature","modifyOutputSchema","push","lang","lexical","key","length","concat","node","nodeType","replace","getType","set","sanitizeServerEditorConfig","editorConfig","config","resolvedFeatureMap","unSanitizedEditorConfig"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/dist/field/lexical/config/types.d.ts

@@ -1,4 +1,5 @@
 import type { EditorConfig as LexicalEditorConfig } from 'lexical';
+import type { LexicalFieldAdminProps } from '../../../types.js';
 import type { FeatureProviderClient, FeatureProviderServer, ResolvedClientFeatureMap, ResolvedServerFeatureMap, SanitizedClientFeatures, SanitizedServerFeatures } from '../../features/types.js';
 export type ServerEditorConfig = {
     features: FeatureProviderServer<unknown, unknown>[];
@@ -14,6 +15,7 @@ export type ClientEditorConfig = {
     lexical?: LexicalEditorConfig;
 };
 export type SanitizedClientEditorConfig = {
+    admin?: LexicalFieldAdminProps;
     features: SanitizedClientFeatures;
     lexical: LexicalEditorConfig;
     resolvedFeatureMap: ResolvedClientFeatureMap;