@payloadcms/richtext-lexical 3.0.0-beta.5 → 3.0.0-beta.50

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, LexicalEditor, SerializedEditorState } 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, onChange, path, readOnly, value } = props\n\n  const parentContext = useEditorConfigContext()\n\n  const editorContainerRef = React.useRef<HTMLDivElement>(null)\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","onChange","path","readOnly","value","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;;AAKA,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,QAAQ,EAAEC,IAAI,EAAEC,QAAQ,EAAEC,KAAK,EAAE,GAAGN;IAEtE,MAAMO,gBAAgBV;IAEtB,MAAMW,qBAAqBhB,MAAMiB,MAAM,CAAiB;IAExD,MAAMC,iBAAiBjB,QAAQ;QAC7B,IAAIkB,YAAYL;QAChB,IAAIL,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;QAAcK;KAAM;IAExB,4EAA4E;IAC5E,MAAMa,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,UAAUpB,aAAa;YACvBqB,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;QAAgBL;KAAS;IAE3C,IAAI,CAACc,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;gBACpBL,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"}

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

@@ -1,6 +1,8 @@
 'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext.js';
 import * as React from 'react';
-import { createContext, useContext, useEffect, useMemo, useState } from 'react';
+import { createContext, useContext, useMemo, useRef, useState } from 'react';
 // Should always produce a 20 character pseudo-random string
 function generateQuickGuid() {
     return Math.random().toString(36).substring(2, 12) + Math.random().toString(36).substring(2, 12);
@@ -8,27 +10,75 @@ function generateQuickGuid() {
 const Context = /*#__PURE__*/ createContext({
     editorConfig: null,
     field: null,
-    uuid: generateQuickGuid()
+    uuid: null
 });
-export const EditorConfigProvider = ({ children, editorConfig, fieldProps })=>{
+export const EditorConfigProvider = ({ children, editorConfig, editorContainerRef, fieldProps, parentContext })=>{
+    const [editor] = useLexicalComposerContext();
     // State to store the UUID
-    const [uuid, setUuid] = useState(generateQuickGuid());
-    // When the component mounts, generate a new UUID only once
-    useEffect(()=>{
-        setUuid(generateQuickGuid());
-    }, []);
+    const [uuid] = useState(generateQuickGuid());
+    const childrenEditors = useRef(new Map());
+    const [focusedEditor, setFocusedEditor] = useState(null);
+    const focusHistory = useRef(new Set());
     const editorContext = useMemo(()=>({
+            blurEditor: (editorContext)=>{
+                //setFocusedEditor(null) // Clear focused editor
+                focusHistory.current.clear() // Reset focus history when focus is lost
+                ;
+            },
+            childrenEditors,
+            editor,
             editorConfig,
+            editorContainerRef,
             field: fieldProps,
+            focusEditor: (editorContext)=>{
+                const editorUUID = editorContext.uuid;
+                // Avoid recursion by checking if this editor is already focused in this cycle
+                if (focusHistory.current.has(editorUUID)) {
+                    return;
+                }
+                // Add this editor to the history to prevent future recursions in this cycle
+                focusHistory.current.add(editorUUID);
+                setFocusedEditor(editorContext);
+                // Propagate focus event to parent and children, ensuring they do not refocus this editor
+                if (parentContext?.uuid) {
+                    parentContext.focusEditor(editorContext);
+                }
+                childrenEditors.current.forEach((childEditor, childUUID)=>{
+                    childEditor.focusEditor(editorContext);
+                });
+                focusHistory.current.clear();
+            },
+            focusedEditor,
+            parentEditor: parentContext,
+            registerChild: (childUUID, childEditorContext)=>{
+                if (!childrenEditors.current.has(childUUID)) {
+                    const newMap = new Map(childrenEditors.current);
+                    newMap.set(childUUID, childEditorContext);
+                    childrenEditors.current = newMap;
+                }
+            },
+            unregisterChild: (childUUID)=>{
+                if (childrenEditors.current.has(childUUID)) {
+                    const newMap = new Map(childrenEditors.current);
+                    newMap.delete(childUUID);
+                    childrenEditors.current = newMap;
+                }
+            },
             uuid
         }), [
+        editor,
+        childrenEditors,
         editorConfig,
+        editorContainerRef,
         fieldProps,
+        focusedEditor,
+        parentContext,
         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}\ninterface ContextType {\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<ContextType> = 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 = (): ContextType => {\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,wBAAsCV,cAAc;IACxDW,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'\nimport type { LexicalEditor } from 'lexical'\n\nimport { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext.js'\nimport * as React from 'react'\nimport { createContext, useContext, useMemo, useRef, 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}\n\nexport interface EditorConfigContextType {\n  // Editor focus handling\n  blurEditor: (editorContext: EditorConfigContextType) => void\n  childrenEditors: React.RefObject<Map<string, EditorConfigContextType>>\n  editor: LexicalEditor\n  editorConfig: SanitizedClientEditorConfig\n  editorContainerRef: React.RefObject<HTMLDivElement>\n  field: FormFieldBase & {\n    editorConfig: SanitizedClientEditorConfig // With rendered features n stuff\n    name: string\n    richTextComponentMap: Map<string, React.ReactNode>\n  }\n  // Editor focus handling\n  focusEditor: (editorContext: EditorConfigContextType) => void\n  focusedEditor: EditorConfigContextType | null\n  parentEditor: EditorConfigContextType\n  registerChild: (uuid: string, editorContext: EditorConfigContextType) => void\n  unregisterChild?: (uuid: string) => void\n  uuid: string\n}\n\nconst Context: React.Context<EditorConfigContextType> = createContext({\n  editorConfig: null,\n  field: null,\n  uuid: null,\n})\n\nexport const EditorConfigProvider = ({\n  children,\n  editorConfig,\n  editorContainerRef,\n  fieldProps,\n  parentContext,\n}: {\n  children: React.ReactNode\n  editorConfig: SanitizedClientEditorConfig\n  editorContainerRef: React.RefObject<HTMLDivElement>\n  fieldProps: FormFieldBase & {\n    editorConfig: SanitizedClientEditorConfig // With rendered features n stuff\n    name: string\n    richTextComponentMap: Map<string, React.ReactNode>\n  }\n  parentContext?: EditorConfigContextType\n}): React.ReactNode => {\n  const [editor] = useLexicalComposerContext()\n  // State to store the UUID\n  const [uuid] = useState(generateQuickGuid())\n\n  const childrenEditors = useRef<Map<string, EditorConfigContextType>>(new Map())\n  const [focusedEditor, setFocusedEditor] = useState<EditorConfigContextType | null>(null)\n  const focusHistory = useRef<Set<string>>(new Set())\n\n  const editorContext = useMemo(\n    () =>\n      ({\n        blurEditor: (editorContext: EditorConfigContextType) => {\n          //setFocusedEditor(null) // Clear focused editor\n          focusHistory.current.clear() // Reset focus history when focus is lost\n        },\n        childrenEditors,\n        editor,\n        editorConfig,\n        editorContainerRef,\n        field: fieldProps,\n        focusEditor: (editorContext: EditorConfigContextType) => {\n          const editorUUID = editorContext.uuid\n\n          // Avoid recursion by checking if this editor is already focused in this cycle\n          if (focusHistory.current.has(editorUUID)) {\n            return\n          }\n\n          // Add this editor to the history to prevent future recursions in this cycle\n          focusHistory.current.add(editorUUID)\n          setFocusedEditor(editorContext)\n\n          // Propagate focus event to parent and children, ensuring they do not refocus this editor\n          if (parentContext?.uuid) {\n            parentContext.focusEditor(editorContext)\n          }\n          childrenEditors.current.forEach((childEditor, childUUID) => {\n            childEditor.focusEditor(editorContext)\n          })\n\n          focusHistory.current.clear()\n        },\n        focusedEditor,\n        parentEditor: parentContext,\n        registerChild: (childUUID, childEditorContext) => {\n          if (!childrenEditors.current.has(childUUID)) {\n            const newMap = new Map(childrenEditors.current)\n            newMap.set(childUUID, childEditorContext)\n            childrenEditors.current = newMap\n          }\n        },\n        unregisterChild: (childUUID) => {\n          if (childrenEditors.current.has(childUUID)) {\n            const newMap = new Map(childrenEditors.current)\n            newMap.delete(childUUID)\n            childrenEditors.current = newMap\n          }\n        },\n\n        uuid,\n      }) as EditorConfigContextType,\n    [\n      editor,\n      childrenEditors,\n      editorConfig,\n      editorContainerRef,\n      fieldProps,\n      focusedEditor,\n      parentContext,\n      uuid,\n    ],\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":["useLexicalComposerContext","React","createContext","useContext","useMemo","useRef","useState","generateQuickGuid","Math","random","toString","substring","Context","editorConfig","field","uuid","EditorConfigProvider","children","editorContainerRef","fieldProps","parentContext","editor","childrenEditors","Map","focusedEditor","setFocusedEditor","focusHistory","Set","editorContext","blurEditor","current","clear","focusEditor","editorUUID","has","add","forEach","childEditor","childUUID","parentEditor","registerChild","childEditorContext","newMap","set","unregisterChild","delete","Provider","value","useEditorConfigContext","context","undefined","Error"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA;;AAKA,SAASA,yBAAyB,QAAQ,2CAA0C;AACpF,YAAYC,WAAW,QAAO;AAC9B,SAASC,aAAa,EAAEC,UAAU,EAAEC,OAAO,EAAEC,MAAM,EAAEC,QAAQ,QAAQ,QAAO;AAI5E,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;AAuBA,MAAMC,wBAAkDV,cAAc;IACpEW,cAAc;IACdC,OAAO;IACPC,MAAM;AACR;AAEA,OAAO,MAAMC,uBAAuB,CAAC,EACnCC,QAAQ,EACRJ,YAAY,EACZK,kBAAkB,EAClBC,UAAU,EACVC,aAAa,EAWd;IACC,MAAM,CAACC,OAAO,GAAGrB;IACjB,0BAA0B;IAC1B,MAAM,CAACe,KAAK,GAAGT,SAASC;IAExB,MAAMe,kBAAkBjB,OAA6C,IAAIkB;IACzE,MAAM,CAACC,eAAeC,iBAAiB,GAAGnB,SAAyC;IACnF,MAAMoB,eAAerB,OAAoB,IAAIsB;IAE7C,MAAMC,gBAAgBxB,QACpB,IACG,CAAA;YACCyB,YAAY,CAACD;gBACX,gDAAgD;gBAChDF,aAAaI,OAAO,CAACC,KAAK,GAAG,yCAAyC;;YACxE;YACAT;YACAD;YACAR;YACAK;YACAJ,OAAOK;YACPa,aAAa,CAACJ;gBACZ,MAAMK,aAAaL,cAAcb,IAAI;gBAErC,8EAA8E;gBAC9E,IAAIW,aAAaI,OAAO,CAACI,GAAG,CAACD,aAAa;oBACxC;gBACF;gBAEA,4EAA4E;gBAC5EP,aAAaI,OAAO,CAACK,GAAG,CAACF;gBACzBR,iBAAiBG;gBAEjB,yFAAyF;gBACzF,IAAIR,eAAeL,MAAM;oBACvBK,cAAcY,WAAW,CAACJ;gBAC5B;gBACAN,gBAAgBQ,OAAO,CAACM,OAAO,CAAC,CAACC,aAAaC;oBAC5CD,YAAYL,WAAW,CAACJ;gBAC1B;gBAEAF,aAAaI,OAAO,CAACC,KAAK;YAC5B;YACAP;YACAe,cAAcnB;YACdoB,eAAe,CAACF,WAAWG;gBACzB,IAAI,CAACnB,gBAAgBQ,OAAO,CAACI,GAAG,CAACI,YAAY;oBAC3C,MAAMI,SAAS,IAAInB,IAAID,gBAAgBQ,OAAO;oBAC9CY,OAAOC,GAAG,CAACL,WAAWG;oBACtBnB,gBAAgBQ,OAAO,GAAGY;gBAC5B;YACF;YACAE,iBAAiB,CAACN;gBAChB,IAAIhB,gBAAgBQ,OAAO,CAACI,GAAG,CAACI,YAAY;oBAC1C,MAAMI,SAAS,IAAInB,IAAID,gBAAgBQ,OAAO;oBAC9CY,OAAOG,MAAM,CAACP;oBACdhB,gBAAgBQ,OAAO,GAAGY;gBAC5B;YACF;YAEA3B;QACF,CAAA,GACF;QACEM;QACAC;QACAT;QACAK;QACAC;QACAK;QACAJ;QACAL;KACD;IAGH,qBAAO,KAACH,QAAQkC,QAAQ;QAACC,OAAOnB;kBAAgBX;;AAClD,EAAC;AAED,OAAO,MAAM+B,yBAAyB;IACpC,MAAMC,UAAU9C,WAAWS;IAC3B,IAAIqC,YAAYC,WAAW;QACzB,MAAM,IAAIC,MAAM;IAClB;IACA,OAAOF;AACT,EAAC"}

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

@@ -1,3 +1,3 @@
-import type { EditorConfig as LexicalEditorConfig } from 'lexical/LexicalEditor.js';
+import type { EditorConfig as LexicalEditorConfig } from 'lexical';
 export declare const defaultEditorLexicalConfig: LexicalEditorConfig;
 //# sourceMappingURL=default.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"default.d.ts","sourceRoot":"","sources":["../../../../../src/field/lexical/config/client/default.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,IAAI,mBAAmB,EAAE,MAAM,0BAA0B,CAAA;AAInF,eAAO,MAAM,0BAA0B,EAAE,mBAGxC,CAAA"}
+{"version":3,"file":"default.d.ts","sourceRoot":"","sources":["../../../../../src/field/lexical/config/client/default.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,IAAI,mBAAmB,EAAE,MAAM,SAAS,CAAA;AAIlE,eAAO,MAAM,0BAA0B,EAAE,mBAGxC,CAAA"}

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../src/field/lexical/config/client/default.ts"],"sourcesContent":["'use client'\nimport type { EditorConfig as LexicalEditorConfig } from 'lexical/LexicalEditor.js'\n\nimport { LexicalEditorTheme } from '../../theme/EditorTheme.js'\n\nexport const defaultEditorLexicalConfig: LexicalEditorConfig = {\n  namespace: 'lexical',\n  theme: LexicalEditorTheme,\n}\n"],"names":["LexicalEditorTheme","defaultEditorLexicalConfig","namespace","theme"],"rangeMappings":";;;;;","mappings":"AAAA;AAGA,SAASA,kBAAkB,QAAQ,6BAA4B;AAE/D,OAAO,MAAMC,6BAAkD;IAC7DC,WAAW;IACXC,OAAOH;AACT,EAAC"}
+{"version":3,"sources":["../../../../../src/field/lexical/config/client/default.ts"],"sourcesContent":["'use client'\nimport type { EditorConfig as LexicalEditorConfig } from 'lexical'\n\nimport { LexicalEditorTheme } from '../../theme/EditorTheme.js'\n\nexport const defaultEditorLexicalConfig: LexicalEditorConfig = {\n  namespace: 'lexical',\n  theme: LexicalEditorTheme,\n}\n"],"names":["LexicalEditorTheme","defaultEditorLexicalConfig","namespace","theme"],"rangeMappings":";;;;;","mappings":"AAAA;AAGA,SAASA,kBAAkB,QAAQ,6BAA4B;AAE/D,OAAO,MAAMC,6BAAkD;IAC7DC,WAAW;IACXC,OAAOH;AACT,EAAC"}

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

@@ -1,6 +1,7 @@
-import type { EditorConfig as LexicalEditorConfig } from 'lexical/LexicalEditor.js';
+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,0BAA0B,CAAA;AAEnF,OAAO,KAAK,EAAE,wBAAwB,EAAE,uBAAuB,EAAE,MAAM,4BAA4B,CAAA;AACnG,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,aAAa,CAAA;AAE9D,eAAO,MAAM,sBAAsB,0CAEhC,uBA4IF,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

@@ -2,9 +2,6 @@
 export const sanitizeClientFeatures = (features)=>{
     const sanitized = {
         enabledFeatures: [],
-        floatingSelectToolbar: {
-            sections: []
-        },
         hooks: {
             load: [],
             save: []
@@ -13,8 +10,14 @@ export const sanitizeClientFeatures = (features)=>{
         nodes: [],
         plugins: [],
         slashMenu: {
-            dynamicOptions: [],
-            groupsWithOptions: []
+            dynamicGroups: [],
+            groups: []
+        },
+        toolbarFixed: {
+            groups: []
+        },
+        toolbarInline: {
+            groups: []
         }
     };
     if (!features?.size) {
@@ -36,50 +39,70 @@ export const sanitizeClientFeatures = (features)=>{
             feature.plugins.forEach((plugin, i)=>{
                 sanitized.plugins.push({
                     Component: plugin.Component,
+                    clientProps: feature.clientFeatureProps,
                     key: feature.key + i,
                     position: plugin.position
                 });
             });
         }
-        if (feature.floatingSelectToolbar?.sections?.length) {
-            for (const section of feature.floatingSelectToolbar.sections){
-                // 1. find the section with the same key or create new one
-                let foundSection = sanitized.floatingSelectToolbar.sections.find((sanitizedSection)=>sanitizedSection.key === section.key);
-                if (!foundSection) {
-                    foundSection = {
-                        ...section,
-                        entries: []
+        if (feature.toolbarInline?.groups?.length) {
+            for (const group of feature.toolbarInline.groups){
+                // 1. find the group with the same key or create new one
+                let foundGroup = sanitized.toolbarInline.groups.find((sanitizedGroup)=>sanitizedGroup.key === group.key);
+                if (!foundGroup) {
+                    foundGroup = {
+                        ...group,
+                        items: []
+                    };
+                } else {
+                    sanitized.toolbarInline.groups = sanitized.toolbarInline.groups.filter((sanitizedGroup)=>sanitizedGroup.key !== group.key);
+                }
+                // 2. Add options to group options array and add to sanitized.slashMenu.groupsWithOptions
+                if (group?.items?.length) {
+                    foundGroup.items = foundGroup.items.concat(group.items);
+                }
+                sanitized.toolbarInline?.groups.push(foundGroup);
+            }
+        }
+        if (feature.toolbarFixed?.groups?.length) {
+            for (const group of feature.toolbarFixed.groups){
+                // 1. find the group with the same key or create new one
+                let foundGroup = sanitized.toolbarFixed.groups.find((sanitizedGroup)=>sanitizedGroup.key === group.key);
+                if (!foundGroup) {
+                    foundGroup = {
+                        ...group,
+                        items: []
                     };
                 } else {
-                    sanitized.floatingSelectToolbar.sections = sanitized.floatingSelectToolbar.sections.filter((sanitizedSection)=>sanitizedSection.key !== section.key);
+                    sanitized.toolbarFixed.groups = sanitized.toolbarFixed.groups.filter((sanitizedGroup)=>sanitizedGroup.key !== group.key);
                 }
                 // 2. Add options to group options array and add to sanitized.slashMenu.groupsWithOptions
-                if (section?.entries?.length) {
-                    foundSection.entries = foundSection.entries.concat(section.entries);
+                if (group?.items?.length) {
+                    foundGroup.items = foundGroup.items.concat(group.items);
                 }
-                sanitized.floatingSelectToolbar?.sections.push(foundSection);
+                sanitized.toolbarFixed?.groups.push(foundGroup);
             }
         }
-        if (feature.slashMenu?.options) {
-            if (feature.slashMenu.dynamicOptions?.length) {
-                sanitized.slashMenu.dynamicOptions = sanitized.slashMenu.dynamicOptions.concat(feature.slashMenu.dynamicOptions);
+        if (feature.slashMenu?.groups) {
+            if (feature.slashMenu.dynamicGroups?.length) {
+                sanitized.slashMenu.dynamicGroups = sanitized.slashMenu.dynamicGroups.concat(feature.slashMenu.dynamicGroups);
             }
-            for (const optionGroup of feature.slashMenu.options){
+            for (const optionGroup of feature.slashMenu.groups){
                 // 1. find the group with the same name or create new one
-                let group = sanitized.slashMenu.groupsWithOptions.find((group)=>group.key === optionGroup.key);
+                let group = sanitized.slashMenu.groups.find((group)=>group.key === optionGroup.key);
                 if (!group) {
                     group = {
                         ...optionGroup,
-                        options: []
+                        items: []
                     };
                 } else {
-                    sanitized.slashMenu.groupsWithOptions = sanitized.slashMenu.groupsWithOptions.filter((group)=>group.key !== optionGroup.key);
+                    sanitized.slashMenu.groups = sanitized.slashMenu.groups.filter((group)=>group.key !== optionGroup.key);
                 }
                 // 2. Add options to group options array and add to sanitized.slashMenu.groupsWithOptions
-                if (optionGroup?.options?.length) {
-                    group.options = group.options.concat(optionGroup.options);
+                if (optionGroup?.items?.length) {
+                    group.items = group.items.concat(optionGroup.items);
                 }
-                sanitized.slashMenu.groupsWithOptions.push(group);
+                sanitized.slashMenu.groups.push(group);
             }
         }
         if (feature.markdownTransformers?.length) {
@@ -87,8 +110,8 @@ export const sanitizeClientFeatures = (features)=>{
         }
         sanitized.enabledFeatures.push(feature.key);
     });
-    // Sort sanitized.floatingSelectToolbar.sections by order property
-    sanitized.floatingSelectToolbar.sections.sort((a, b)=>{
+    // Sort sanitized.toolbarInline.groups by order property
+    sanitized.toolbarInline.groups.sort((a, b)=>{
         if (a.order && b.order) {
             return a.order - b.order;
         } else if (a.order) {
@@ -99,9 +122,35 @@ export const sanitizeClientFeatures = (features)=>{
             return 0;
         }
     });
-    // Sort sanitized.floatingSelectToolbar.sections.[section].entries by order property
-    for (const section of sanitized.floatingSelectToolbar.sections){
-        section.entries.sort((a, b)=>{
+    // Sort sanitized.toolbarFixed.groups by order property
+    sanitized.toolbarFixed.groups.sort((a, b)=>{
+        if (a.order && b.order) {
+            return a.order - b.order;
+        } else if (a.order) {
+            return -1;
+        } else if (b.order) {
+            return 1;
+        } else {
+            return 0;
+        }
+    });
+    // Sort sanitized.toolbarInline.groups.[group].entries by order property
+    for (const group of sanitized.toolbarInline.groups){
+        group.items.sort((a, b)=>{
+            if (a.order && b.order) {
+                return a.order - b.order;
+            } else if (a.order) {
+                return -1;
+            } else if (b.order) {
+                return 1;
+            } else {
+                return 0;
+            }
+        });
+    }
+    // Sort sanitized.toolbarFixed.groups.[group].entries by order property
+    for (const group of sanitized.toolbarFixed.groups){
+        group.items.sort((a, b)=>{
             if (a.order && b.order) {
                 return a.order - b.order;
             } else if (a.order) {
@@ -115,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/LexicalEditor.js'\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    floatingSelectToolbar: {\n      sections: [],\n    },\n    hooks: {\n      load: [],\n      save: [],\n    },\n    markdownTransformers: [],\n    nodes: [],\n    plugins: [],\n    slashMenu: {\n      dynamicOptions: [],\n      groupsWithOptions: [],\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          key: feature.key + i,\n          position: plugin.position,\n        })\n      })\n    }\n\n    if (feature.floatingSelectToolbar?.sections?.length) {\n      for (const section of feature.floatingSelectToolbar.sections) {\n        // 1. find the section with the same key or create new one\n        let foundSection = sanitized.floatingSelectToolbar.sections.find(\n          (sanitizedSection) => sanitizedSection.key === section.key,\n        )\n        if (!foundSection) {\n          foundSection = {\n            ...section,\n            entries: [],\n          }\n        } else {\n          sanitized.floatingSelectToolbar.sections =\n            sanitized.floatingSelectToolbar.sections.filter(\n              (sanitizedSection) => sanitizedSection.key !== section.key,\n            )\n        }\n\n        // 2. Add options to group options array and add to sanitized.slashMenu.groupsWithOptions\n        if (section?.entries?.length) {\n          foundSection.entries = foundSection.entries.concat(section.entries)\n        }\n        sanitized.floatingSelectToolbar?.sections.push(foundSection)\n      }\n    }\n\n    if (feature.slashMenu?.options) {\n      if (feature.slashMenu.dynamicOptions?.length) {\n        sanitized.slashMenu.dynamicOptions = sanitized.slashMenu.dynamicOptions.concat(\n          feature.slashMenu.dynamicOptions,\n        )\n      }\n\n      for (const optionGroup of feature.slashMenu.options) {\n        // 1. find the group with the same name or create new one\n        let group = sanitized.slashMenu.groupsWithOptions.find(\n          (group) => group.key === optionGroup.key,\n        )\n        if (!group) {\n          group = {\n            ...optionGroup,\n            options: [],\n          }\n        } else {\n          sanitized.slashMenu.groupsWithOptions = sanitized.slashMenu.groupsWithOptions.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?.options?.length) {\n          group.options = group.options.concat(optionGroup.options)\n        }\n        sanitized.slashMenu.groupsWithOptions.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.floatingSelectToolbar.sections by order property\n  sanitized.floatingSelectToolbar.sections.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.floatingSelectToolbar.sections.[section].entries by order property\n  for (const section of sanitized.floatingSelectToolbar.sections) {\n    section.entries.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","floatingSelectToolbar","sections","hooks","load","save","markdownTransformers","nodes","plugins","slashMenu","dynamicOptions","groupsWithOptions","size","forEach","feature","length","concat","plugin","i","push","Component","key","position","section","foundSection","find","sanitizedSection","entries","filter","options","optionGroup","group","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/default.d.ts

@@ -1,8 +1,7 @@
-import type { EditorConfig as LexicalEditorConfig } from 'lexical/LexicalEditor.js';
+import type { EditorConfig as LexicalEditorConfig } from 'lexical';
 import type { FeatureProviderServer } from '../../../features/types.js';
-import type { SanitizedServerEditorConfig, ServerEditorConfig } from '../types.js';
+import type { ServerEditorConfig } from '../types.js';
 export declare const defaultEditorLexicalConfig: LexicalEditorConfig;
 export declare const defaultEditorFeatures: FeatureProviderServer<unknown, unknown>[];
 export declare const defaultEditorConfig: ServerEditorConfig;
-export declare const defaultSanitizedServerEditorConfig: SanitizedServerEditorConfig;
 //# sourceMappingURL=default.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"default.d.ts","sourceRoot":"","sources":["../../../../../src/field/lexical/config/server/default.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,IAAI,mBAAmB,EAAE,MAAM,0BAA0B,CAAA;AAEnF,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAA;AACvE,OAAO,KAAK,EAAE,2BAA2B,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AAuBlF,eAAO,MAAM,0BAA0B,EAAE,mBAGxC,CAAA;AAED,eAAO,MAAM,qBAAqB,EAAE,qBAAqB,CAAC,OAAO,EAAE,OAAO,CAAC,EAmB1E,CAAA;AAED,eAAO,MAAM,mBAAmB,EAAE,kBAGjC,CAAA;AAED,eAAO,MAAM,kCAAkC,EAAE,2BACA,CAAA"}
+{"version":3,"file":"default.d.ts","sourceRoot":"","sources":["../../../../../src/field/lexical/config/server/default.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,IAAI,mBAAmB,EAAE,MAAM,SAAS,CAAA;AAElE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAA;AACvE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AAwBrD,eAAO,MAAM,0BAA0B,EAAE,mBAGxC,CAAA;AAED,eAAO,MAAM,qBAAqB,EAAE,qBAAqB,CAAC,OAAO,EAAE,OAAO,CAAC,EAqB1E,CAAA;AAED,eAAO,MAAM,mBAAmB,EAAE,kBAGjC,CAAA"}

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

@@ -1,23 +1,24 @@
 import { AlignFeature } from '../../../features/align/feature.server.js';
-import { BlockQuoteFeature } from '../../../features/blockquote/feature.server.js';
+import { BlockquoteFeature } from '../../../features/blockquote/feature.server.js';
 import { BoldFeature } from '../../../features/format/bold/feature.server.js';
-import { InlineCodeFeature } from '../../../features/format/inlinecode/feature.server.js';
+import { InlineCodeFeature } from '../../../features/format/inlineCode/feature.server.js';
 import { ItalicFeature } from '../../../features/format/italic/feature.server.js';
 import { StrikethroughFeature } from '../../../features/format/strikethrough/feature.server.js';
 import { SubscriptFeature } from '../../../features/format/subscript/feature.server.js';
 import { SuperscriptFeature } from '../../../features/format/superscript/feature.server.js';
 import { UnderlineFeature } from '../../../features/format/underline/feature.server.js';
 import { HeadingFeature } from '../../../features/heading/feature.server.js';
+import { HorizontalRuleFeature } from '../../../features/horizontalRule/feature.server.js';
 import { IndentFeature } from '../../../features/indent/feature.server.js';
 import { LinkFeature } from '../../../features/link/feature.server.js';
-import { CheckListFeature } from '../../../features/lists/checklist/feature.server.js';
-import { OrderedListFeature } from '../../../features/lists/orderedlist/feature.server.js';
-import { UnorderedListFeature } from '../../../features/lists/unorderedlist/feature.server.js';
+import { ChecklistFeature } from '../../../features/lists/checklist/feature.server.js';
+import { OrderedListFeature } from '../../../features/lists/orderedList/feature.server.js';
+import { UnorderedListFeature } from '../../../features/lists/unorderedList/feature.server.js';
 import { ParagraphFeature } from '../../../features/paragraph/feature.server.js';
 import { RelationshipFeature } from '../../../features/relationship/feature.server.js';
+import { InlineToolbarFeature } from '../../../features/toolbars/inline/feature.server.js';
 import { UploadFeature } from '../../../features/upload/feature.server.js';
 import { LexicalEditorTheme } from '../../theme/EditorTheme.js';
-import { sanitizeServerEditorConfig } from './sanitize.js';
 export const defaultEditorLexicalConfig = {
     namespace: 'lexical',
     theme: LexicalEditorTheme
@@ -36,16 +37,17 @@ export const defaultEditorFeatures = [
     IndentFeature(),
     UnorderedListFeature(),
     OrderedListFeature(),
-    CheckListFeature(),
+    ChecklistFeature(),
     LinkFeature(),
     RelationshipFeature(),
-    BlockQuoteFeature(),
-    UploadFeature()
+    BlockquoteFeature(),
+    UploadFeature(),
+    HorizontalRuleFeature(),
+    InlineToolbarFeature()
 ];
 export const defaultEditorConfig = {
     features: defaultEditorFeatures,
     lexical: defaultEditorLexicalConfig
 };
-export const defaultSanitizedServerEditorConfig = sanitizeServerEditorConfig(defaultEditorConfig);
 
 //# sourceMappingURL=default.js.map

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../src/field/lexical/config/server/default.ts"],"sourcesContent":["import type { EditorConfig as LexicalEditorConfig } from 'lexical/LexicalEditor.js'\n\nimport type { FeatureProviderServer } from '../../../features/types.js'\nimport type { SanitizedServerEditorConfig, ServerEditorConfig } from '../types.js'\n\nimport { AlignFeature } from '../../../features/align/feature.server.js'\nimport { BlockQuoteFeature } from '../../../features/blockquote/feature.server.js'\nimport { BoldFeature } from '../../../features/format/bold/feature.server.js'\nimport { InlineCodeFeature } from '../../../features/format/inlinecode/feature.server.js'\nimport { ItalicFeature } from '../../../features/format/italic/feature.server.js'\nimport { StrikethroughFeature } from '../../../features/format/strikethrough/feature.server.js'\nimport { SubscriptFeature } from '../../../features/format/subscript/feature.server.js'\nimport { SuperscriptFeature } from '../../../features/format/superscript/feature.server.js'\nimport { UnderlineFeature } from '../../../features/format/underline/feature.server.js'\nimport { HeadingFeature } from '../../../features/heading/feature.server.js'\nimport { IndentFeature } from '../../../features/indent/feature.server.js'\nimport { LinkFeature } from '../../../features/link/feature.server.js'\nimport { CheckListFeature } from '../../../features/lists/checklist/feature.server.js'\nimport { OrderedListFeature } from '../../../features/lists/orderedlist/feature.server.js'\nimport { UnorderedListFeature } from '../../../features/lists/unorderedlist/feature.server.js'\nimport { ParagraphFeature } from '../../../features/paragraph/feature.server.js'\nimport { RelationshipFeature } from '../../../features/relationship/feature.server.js'\nimport { UploadFeature } from '../../../features/upload/feature.server.js'\nimport { LexicalEditorTheme } from '../../theme/EditorTheme.js'\nimport { sanitizeServerEditorConfig } from './sanitize.js'\n\nexport const defaultEditorLexicalConfig: LexicalEditorConfig = {\n  namespace: 'lexical',\n  theme: LexicalEditorTheme,\n}\n\nexport const defaultEditorFeatures: FeatureProviderServer<unknown, unknown>[] = [\n  BoldFeature(),\n  ItalicFeature(),\n  UnderlineFeature(),\n  StrikethroughFeature(),\n  SubscriptFeature(),\n  SuperscriptFeature(),\n  InlineCodeFeature(),\n  ParagraphFeature(),\n  HeadingFeature(),\n  AlignFeature(),\n  IndentFeature(),\n  UnorderedListFeature(),\n  OrderedListFeature(),\n  CheckListFeature(),\n  LinkFeature(),\n  RelationshipFeature(),\n  BlockQuoteFeature(),\n  UploadFeature(),\n]\n\nexport const defaultEditorConfig: ServerEditorConfig = {\n  features: defaultEditorFeatures,\n  lexical: defaultEditorLexicalConfig,\n}\n\nexport const defaultSanitizedServerEditorConfig: SanitizedServerEditorConfig =\n  sanitizeServerEditorConfig(defaultEditorConfig)\n"],"names":["AlignFeature","BlockQuoteFeature","BoldFeature","InlineCodeFeature","ItalicFeature","StrikethroughFeature","SubscriptFeature","SuperscriptFeature","UnderlineFeature","HeadingFeature","IndentFeature","LinkFeature","CheckListFeature","OrderedListFeature","UnorderedListFeature","ParagraphFeature","RelationshipFeature","UploadFeature","LexicalEditorTheme","sanitizeServerEditorConfig","defaultEditorLexicalConfig","namespace","theme","defaultEditorFeatures","defaultEditorConfig","features","lexical","defaultSanitizedServerEditorConfig"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAKA,SAASA,YAAY,QAAQ,4CAA2C;AACxE,SAASC,iBAAiB,QAAQ,iDAAgD;AAClF,SAASC,WAAW,QAAQ,kDAAiD;AAC7E,SAASC,iBAAiB,QAAQ,wDAAuD;AACzF,SAASC,aAAa,QAAQ,oDAAmD;AACjF,SAASC,oBAAoB,QAAQ,2DAA0D;AAC/F,SAASC,gBAAgB,QAAQ,uDAAsD;AACvF,SAASC,kBAAkB,QAAQ,yDAAwD;AAC3F,SAASC,gBAAgB,QAAQ,uDAAsD;AACvF,SAASC,cAAc,QAAQ,8CAA6C;AAC5E,SAASC,aAAa,QAAQ,6CAA4C;AAC1E,SAASC,WAAW,QAAQ,2CAA0C;AACtE,SAASC,gBAAgB,QAAQ,sDAAqD;AACtF,SAASC,kBAAkB,QAAQ,wDAAuD;AAC1F,SAASC,oBAAoB,QAAQ,0DAAyD;AAC9F,SAASC,gBAAgB,QAAQ,gDAA+C;AAChF,SAASC,mBAAmB,QAAQ,mDAAkD;AACtF,SAASC,aAAa,QAAQ,6CAA4C;AAC1E,SAASC,kBAAkB,QAAQ,6BAA4B;AAC/D,SAASC,0BAA0B,QAAQ,gBAAe;AAE1D,OAAO,MAAMC,6BAAkD;IAC7DC,WAAW;IACXC,OAAOJ;AACT,EAAC;AAED,OAAO,MAAMK,wBAAmE;IAC9ErB;IACAE;IACAI;IACAH;IACAC;IACAC;IACAJ;IACAY;IACAN;IACAT;IACAU;IACAI;IACAD;IACAD;IACAD;IACAK;IACAf;IACAgB;CACD,CAAA;AAED,OAAO,MAAMO,sBAA0C;IACrDC,UAAUF;IACVG,SAASN;AACX,EAAC;AAED,OAAO,MAAMO,qCACXR,2BAA2BK,qBAAoB"}
+{"version":3,"sources":["../../../../../src/field/lexical/config/server/default.ts"],"sourcesContent":["import type { EditorConfig as LexicalEditorConfig } from 'lexical'\n\nimport type { FeatureProviderServer } from '../../../features/types.js'\nimport type { ServerEditorConfig } from '../types.js'\n\nimport { AlignFeature } from '../../../features/align/feature.server.js'\nimport { BlockquoteFeature } from '../../../features/blockquote/feature.server.js'\nimport { BoldFeature } from '../../../features/format/bold/feature.server.js'\nimport { InlineCodeFeature } from '../../../features/format/inlineCode/feature.server.js'\nimport { ItalicFeature } from '../../../features/format/italic/feature.server.js'\nimport { StrikethroughFeature } from '../../../features/format/strikethrough/feature.server.js'\nimport { SubscriptFeature } from '../../../features/format/subscript/feature.server.js'\nimport { SuperscriptFeature } from '../../../features/format/superscript/feature.server.js'\nimport { UnderlineFeature } from '../../../features/format/underline/feature.server.js'\nimport { HeadingFeature } from '../../../features/heading/feature.server.js'\nimport { HorizontalRuleFeature } from '../../../features/horizontalRule/feature.server.js'\nimport { IndentFeature } from '../../../features/indent/feature.server.js'\nimport { LinkFeature } from '../../../features/link/feature.server.js'\nimport { ChecklistFeature } from '../../../features/lists/checklist/feature.server.js'\nimport { OrderedListFeature } from '../../../features/lists/orderedList/feature.server.js'\nimport { UnorderedListFeature } from '../../../features/lists/unorderedList/feature.server.js'\nimport { ParagraphFeature } from '../../../features/paragraph/feature.server.js'\nimport { RelationshipFeature } from '../../../features/relationship/feature.server.js'\nimport { InlineToolbarFeature } from '../../../features/toolbars/inline/feature.server.js'\nimport { UploadFeature } from '../../../features/upload/feature.server.js'\nimport { LexicalEditorTheme } from '../../theme/EditorTheme.js'\n\nexport const defaultEditorLexicalConfig: LexicalEditorConfig = {\n  namespace: 'lexical',\n  theme: LexicalEditorTheme,\n}\n\nexport const defaultEditorFeatures: FeatureProviderServer<unknown, unknown>[] = [\n  BoldFeature(),\n  ItalicFeature(),\n  UnderlineFeature(),\n  StrikethroughFeature(),\n  SubscriptFeature(),\n  SuperscriptFeature(),\n  InlineCodeFeature(),\n  ParagraphFeature(),\n  HeadingFeature(),\n  AlignFeature(),\n  IndentFeature(),\n  UnorderedListFeature(),\n  OrderedListFeature(),\n  ChecklistFeature(),\n  LinkFeature(),\n  RelationshipFeature(),\n  BlockquoteFeature(),\n  UploadFeature(),\n  HorizontalRuleFeature(),\n  InlineToolbarFeature(),\n]\n\nexport const defaultEditorConfig: ServerEditorConfig = {\n  features: defaultEditorFeatures,\n  lexical: defaultEditorLexicalConfig,\n}\n"],"names":["AlignFeature","BlockquoteFeature","BoldFeature","InlineCodeFeature","ItalicFeature","StrikethroughFeature","SubscriptFeature","SuperscriptFeature","UnderlineFeature","HeadingFeature","HorizontalRuleFeature","IndentFeature","LinkFeature","ChecklistFeature","OrderedListFeature","UnorderedListFeature","ParagraphFeature","RelationshipFeature","InlineToolbarFeature","UploadFeature","LexicalEditorTheme","defaultEditorLexicalConfig","namespace","theme","defaultEditorFeatures","defaultEditorConfig","features","lexical"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAKA,SAASA,YAAY,QAAQ,4CAA2C;AACxE,SAASC,iBAAiB,QAAQ,iDAAgD;AAClF,SAASC,WAAW,QAAQ,kDAAiD;AAC7E,SAASC,iBAAiB,QAAQ,wDAAuD;AACzF,SAASC,aAAa,QAAQ,oDAAmD;AACjF,SAASC,oBAAoB,QAAQ,2DAA0D;AAC/F,SAASC,gBAAgB,QAAQ,uDAAsD;AACvF,SAASC,kBAAkB,QAAQ,yDAAwD;AAC3F,SAASC,gBAAgB,QAAQ,uDAAsD;AACvF,SAASC,cAAc,QAAQ,8CAA6C;AAC5E,SAASC,qBAAqB,QAAQ,qDAAoD;AAC1F,SAASC,aAAa,QAAQ,6CAA4C;AAC1E,SAASC,WAAW,QAAQ,2CAA0C;AACtE,SAASC,gBAAgB,QAAQ,sDAAqD;AACtF,SAASC,kBAAkB,QAAQ,wDAAuD;AAC1F,SAASC,oBAAoB,QAAQ,0DAAyD;AAC9F,SAASC,gBAAgB,QAAQ,gDAA+C;AAChF,SAASC,mBAAmB,QAAQ,mDAAkD;AACtF,SAASC,oBAAoB,QAAQ,sDAAqD;AAC1F,SAASC,aAAa,QAAQ,6CAA4C;AAC1E,SAASC,kBAAkB,QAAQ,6BAA4B;AAE/D,OAAO,MAAMC,6BAAkD;IAC7DC,WAAW;IACXC,OAAOH;AACT,EAAC;AAED,OAAO,MAAMI,wBAAmE;IAC9EtB;IACAE;IACAI;IACAH;IACAC;IACAC;IACAJ;IACAa;IACAP;IACAT;IACAW;IACAI;IACAD;IACAD;IACAD;IACAK;IACAhB;IACAkB;IACAT;IACAQ;CACD,CAAA;AAED,OAAO,MAAMO,sBAA0C;IACrDC,UAAUF;IACVG,SAASN;AACX,EAAC"}

package/dist/field/lexical/config/server/loader.d.ts

@@ -1,7 +1,10 @@
+import type { SanitizedConfig } from 'payload';
 import type { FeatureProviderServer, ResolvedServerFeatureMap } from '../../../features/types.js';
 import type { ServerEditorConfig } from '../types.js';
 export declare function sortFeaturesForOptimalLoading(featureProviders: FeatureProviderServer<unknown, unknown>[]): FeatureProviderServer<unknown, unknown>[];
-export declare function loadFeatures({ unSanitizedEditorConfig, }: {
+export declare function loadFeatures({ config, isRoot, unSanitizedEditorConfig, }: {
+    config: SanitizedConfig;
+    isRoot?: boolean;
     unSanitizedEditorConfig: ServerEditorConfig;
-}): ResolvedServerFeatureMap;
+}): Promise<ResolvedServerFeatureMap>;
 //# sourceMappingURL=loader.d.ts.map