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

package/dist/field/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/field/index.tsx"],"sourcesContent":["'use client'\nimport type { FormFieldBase } from '@payloadcms/ui/fields/shared'\nimport type { EditorConfig as LexicalEditorConfig } from 'lexical/LexicalEditor.js'\n\nimport { ShimmerEffect } from '@payloadcms/ui/elements/ShimmerEffect'\nimport { useFieldProps } from '@payloadcms/ui/forms/FieldPropsProvider'\nimport { useClientFunctions } from '@payloadcms/ui/providers/ClientFunction'\nimport React, { Suspense, lazy, useEffect, useState } from 'react'\n\nimport type { GeneratedFeatureProviderComponent } from '../types.js'\nimport type { FeatureProviderClient } from './features/types.js'\nimport type { SanitizedClientEditorConfig } from './lexical/config/types.js'\n\nimport { defaultEditorLexicalConfig } from './lexical/config/client/default.js'\nimport { loadClientFeatures } from './lexical/config/client/loader.js'\nimport { sanitizeClientEditorConfig } from './lexical/config/client/sanitize.js'\n\nconst RichTextEditor = lazy(() =>\n  import('./Field.js').then((module) => ({ default: module.RichText })),\n)\n\nexport const RichTextField: React.FC<\n  FormFieldBase & {\n    lexicalEditorConfig: LexicalEditorConfig\n    name: string\n    richTextComponentMap: Map<string, React.ReactNode>\n  }\n> = (props) => {\n  const { lexicalEditorConfig, richTextComponentMap } = props\n  const { schemaPath } = useFieldProps()\n  const clientFunctions = useClientFunctions()\n  const [hasLoadedFeatures, setHasLoadedFeatures] = useState(false)\n\n  const [featureProviders, setFeatureProviders] = useState<FeatureProviderClient<unknown>[]>([])\n\n  const [finalSanitizedEditorConfig, setFinalSanitizedEditorConfig] =\n    useState<SanitizedClientEditorConfig>(null)\n\n  let featureProviderComponents: GeneratedFeatureProviderComponent[] = richTextComponentMap.get(\n    'features',\n  ) as GeneratedFeatureProviderComponent[] // TODO: Type better\n  // order by order\n  featureProviderComponents = featureProviderComponents.sort((a, b) => a.order - b.order)\n\n  const featureComponentsWithFeaturesLength =\n    Array.from(richTextComponentMap.keys()).filter(\n      (key) => key.startsWith(`feature.`) && !key.includes('.fields.'),\n    ).length + featureProviderComponents.length\n\n  useEffect(() => {\n    if (!hasLoadedFeatures) {\n      const featureProvidersLocal: FeatureProviderClient<unknown>[] = []\n      let featureProvidersAndComponentsLoaded = 0\n\n      Object.entries(clientFunctions).forEach(([key, plugin]) => {\n        if (key.startsWith(`lexicalFeature.${schemaPath}.`)) {\n          if (!key.includes('.components.')) {\n            featureProvidersLocal.push(plugin)\n          }\n          featureProvidersAndComponentsLoaded++\n        }\n      })\n\n      if (featureProvidersAndComponentsLoaded === featureComponentsWithFeaturesLength) {\n        setFeatureProviders(featureProvidersLocal)\n        setHasLoadedFeatures(true)\n\n        /**\n         * Loaded feature provided => create the final sanitized editor config\n         */\n\n        const resolvedClientFeatures = loadClientFeatures({\n          clientFunctions,\n          schemaPath,\n          unSanitizedEditorConfig: {\n            features: featureProvidersLocal,\n            lexical: lexicalEditorConfig,\n          },\n        })\n\n        setFinalSanitizedEditorConfig(\n          sanitizeClientEditorConfig(\n            lexicalEditorConfig ? lexicalEditorConfig : defaultEditorLexicalConfig,\n            resolvedClientFeatures,\n          ),\n        )\n      }\n    }\n  }, [\n    hasLoadedFeatures,\n    clientFunctions,\n    schemaPath,\n    featureProviderComponents.length,\n    featureProviders,\n    finalSanitizedEditorConfig,\n    lexicalEditorConfig,\n    featureComponentsWithFeaturesLength,\n  ])\n\n  if (!hasLoadedFeatures) {\n    return (\n      <React.Fragment>\n        {Array.isArray(featureProviderComponents) &&\n          featureProviderComponents.map((featureProvider) => {\n            // get all components starting with key feature.${FeatureProvider.key}.components.{featureComponentKey}\n            const featureComponentKeys = Array.from(richTextComponentMap.keys()).filter((key) =>\n              key.startsWith(`feature.${featureProvider.key}.components.`),\n            )\n            const featureComponents: React.ReactNode[] = featureComponentKeys.map((key) => {\n              return richTextComponentMap.get(key)\n            }) // TODO: Type better\n\n            return (\n              <React.Fragment key={featureProvider.key}>\n                {featureComponents?.length\n                  ? featureComponents.map((FeatureComponent) => {\n                      return FeatureComponent\n                    })\n                  : null}\n                {featureProvider.ClientComponent}\n              </React.Fragment>\n            )\n          })}\n      </React.Fragment>\n    )\n  }\n\n  return (\n    <Suspense fallback={<ShimmerEffect height=\"35vh\" />}>\n      {finalSanitizedEditorConfig && (\n        <RichTextEditor {...props} editorConfig={finalSanitizedEditorConfig} />\n      )}\n    </Suspense>\n  )\n}\n"],"names":["ShimmerEffect","useFieldProps","useClientFunctions","React","Suspense","lazy","useEffect","useState","defaultEditorLexicalConfig","loadClientFeatures","sanitizeClientEditorConfig","RichTextEditor","then","module","default","RichText","RichTextField","props","lexicalEditorConfig","richTextComponentMap","schemaPath","clientFunctions","hasLoadedFeatures","setHasLoadedFeatures","featureProviders","setFeatureProviders","finalSanitizedEditorConfig","setFinalSanitizedEditorConfig","featureProviderComponents","get","sort","a","b","order","featureComponentsWithFeaturesLength","Array","from","keys","filter","key","startsWith","includes","length","featureProvidersLocal","featureProvidersAndComponentsLoaded","Object","entries","forEach","plugin","push","resolvedClientFeatures","unSanitizedEditorConfig","features","lexical","Fragment","isArray","map","featureProvider","featureComponentKeys","featureComponents","FeatureComponent","ClientComponent","fallback","height","editorConfig"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}
+{"version":3,"sources":["../../src/field/index.tsx"],"sourcesContent":["'use client'\nimport type { FormFieldBase } from '@payloadcms/ui/fields/shared'\nimport type { EditorConfig as LexicalEditorConfig } from 'lexical'\n\nimport { ShimmerEffect, useClientFunctions, useFieldProps } from '@payloadcms/ui/client'\nimport React, { Suspense, lazy, useEffect, useState } from 'react'\n\nimport type { GeneratedFeatureProviderComponent, LexicalFieldAdminProps } from '../types.js'\nimport type { FeatureProviderClient } from './features/types.js'\nimport type { SanitizedClientEditorConfig } from './lexical/config/types.js'\n\nimport { defaultEditorLexicalConfig } from './lexical/config/client/default.js'\nimport { loadClientFeatures } from './lexical/config/client/loader.js'\nimport { sanitizeClientEditorConfig } from './lexical/config/client/sanitize.js'\n\nconst RichTextEditor = lazy(() =>\n  import('./Field.js').then((module) => ({ default: module.RichText })),\n)\n\nexport const RichTextField: React.FC<\n  FormFieldBase & {\n    admin?: LexicalFieldAdminProps\n    lexicalEditorConfig: LexicalEditorConfig\n    name: string\n    richTextComponentMap: Map<string, React.ReactNode>\n  }\n> = (props) => {\n  const { admin, lexicalEditorConfig, richTextComponentMap } = props\n  const { schemaPath } = useFieldProps()\n  const clientFunctions = useClientFunctions()\n  const [hasLoadedFeatures, setHasLoadedFeatures] = useState(false)\n\n  const [featureProviders, setFeatureProviders] = useState<FeatureProviderClient<unknown>[]>([])\n\n  const [finalSanitizedEditorConfig, setFinalSanitizedEditorConfig] =\n    useState<SanitizedClientEditorConfig>(null)\n\n  let featureProviderComponents: GeneratedFeatureProviderComponent[] = richTextComponentMap.get(\n    'features',\n  ) as GeneratedFeatureProviderComponent[]\n  // order by order\n  featureProviderComponents = featureProviderComponents.sort((a, b) => a.order - b.order)\n\n  let featureProvidersAndComponentsToLoad = 0 // feature providers and components\n  for (const featureProvider of featureProviderComponents) {\n    const featureComponentKeys = Array.from(richTextComponentMap.keys()).filter((key) =>\n      key.startsWith(`feature.${featureProvider.key}.components.`),\n    )\n\n    featureProvidersAndComponentsToLoad += 1\n    featureProvidersAndComponentsToLoad += featureComponentKeys.length\n  }\n\n  useEffect(() => {\n    if (!hasLoadedFeatures) {\n      const featureProvidersLocal: FeatureProviderClient<unknown>[] = []\n      let featureProvidersAndComponentsLoaded = 0\n\n      Object.entries(clientFunctions).forEach(([key, plugin]) => {\n        if (key.startsWith(`lexicalFeature.${schemaPath}.`)) {\n          if (!key.includes('.components.')) {\n            featureProvidersLocal.push(plugin)\n          }\n          featureProvidersAndComponentsLoaded++\n        }\n      })\n\n      if (featureProvidersAndComponentsLoaded === featureProvidersAndComponentsToLoad) {\n        setFeatureProviders(featureProvidersLocal)\n        setHasLoadedFeatures(true)\n\n        /**\n         * Loaded feature provided => create the final sanitized editor config\n         */\n\n        const resolvedClientFeatures = loadClientFeatures({\n          clientFunctions,\n          schemaPath,\n          unSanitizedEditorConfig: {\n            features: featureProvidersLocal,\n            lexical: lexicalEditorConfig,\n          },\n        })\n\n        setFinalSanitizedEditorConfig(\n          sanitizeClientEditorConfig(\n            lexicalEditorConfig ? lexicalEditorConfig : defaultEditorLexicalConfig,\n            resolvedClientFeatures,\n            admin,\n          ),\n        )\n      }\n    }\n  }, [\n    admin,\n    hasLoadedFeatures,\n    clientFunctions,\n    schemaPath,\n    featureProviderComponents.length,\n    featureProviders,\n    finalSanitizedEditorConfig,\n    lexicalEditorConfig,\n    featureProvidersAndComponentsToLoad,\n  ])\n\n  if (!hasLoadedFeatures) {\n    return (\n      <React.Fragment>\n        {Array.isArray(featureProviderComponents) &&\n          featureProviderComponents.map((featureProvider) => {\n            // get all components starting with key feature.${FeatureProvider.key}.components.{featureComponentKey}\n            const featureComponentKeys = Array.from(richTextComponentMap.keys()).filter((key) =>\n              key.startsWith(`feature.${featureProvider.key}.components.`),\n            )\n            const featureComponents: React.ReactNode[] = featureComponentKeys.map((key) => {\n              return richTextComponentMap.get(key)\n            }) // TODO: Type better\n\n            return (\n              <React.Fragment key={featureProvider.key}>\n                {featureComponents?.length\n                  ? featureComponents.map((FeatureComponent) => {\n                      return FeatureComponent\n                    })\n                  : null}\n                {featureProvider.ClientComponent}\n              </React.Fragment>\n            )\n          })}\n      </React.Fragment>\n    )\n  }\n\n  return (\n    <Suspense fallback={<ShimmerEffect height=\"35vh\" />}>\n      {finalSanitizedEditorConfig && (\n        <RichTextEditor {...props} editorConfig={finalSanitizedEditorConfig} />\n      )}\n    </Suspense>\n  )\n}\n"],"names":["ShimmerEffect","useClientFunctions","useFieldProps","React","Suspense","lazy","useEffect","useState","defaultEditorLexicalConfig","loadClientFeatures","sanitizeClientEditorConfig","RichTextEditor","then","module","default","RichText","RichTextField","props","admin","lexicalEditorConfig","richTextComponentMap","schemaPath","clientFunctions","hasLoadedFeatures","setHasLoadedFeatures","featureProviders","setFeatureProviders","finalSanitizedEditorConfig","setFinalSanitizedEditorConfig","featureProviderComponents","get","sort","a","b","order","featureProvidersAndComponentsToLoad","featureProvider","featureComponentKeys","Array","from","keys","filter","key","startsWith","length","featureProvidersLocal","featureProvidersAndComponentsLoaded","Object","entries","forEach","plugin","includes","push","resolvedClientFeatures","unSanitizedEditorConfig","features","lexical","Fragment","isArray","map","featureComponents","FeatureComponent","ClientComponent","fallback","height","editorConfig"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

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

@@ -2,6 +2,7 @@ import * as React from 'react';
 import type { SanitizedPlugin } from '../features/types.js';
 export declare const EditorPlugin: React.FC<{
     anchorElem?: HTMLDivElement;
+    clientProps: any;
     plugin: SanitizedPlugin;
 }>;
 //# sourceMappingURL=EditorPlugin.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"EditorPlugin.d.ts","sourceRoot":"","sources":["../../../src/field/lexical/EditorPlugin.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAA;AAE3D,eAAO,MAAM,YAAY,EAAE,KAAK,CAAC,EAAE,CAAC;IAClC,UAAU,CAAC,EAAE,cAAc,CAAA;IAC3B,MAAM,EAAE,eAAe,CAAA;CACxB,CAMA,CAAA"}
+{"version":3,"file":"EditorPlugin.d.ts","sourceRoot":"","sources":["../../../src/field/lexical/EditorPlugin.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAA;AAE3D,eAAO,MAAM,YAAY,EAAE,KAAK,CAAC,EAAE,CAAC;IAClC,UAAU,CAAC,EAAE,cAAc,CAAA;IAC3B,WAAW,EAAE,GAAG,CAAA;IAChB,MAAM,EAAE,eAAe,CAAA;CACxB,CAQA,CAAA"}

package/dist/field/lexical/EditorPlugin.js

@@ -1,11 +1,15 @@
+import { jsx as _jsx } from "react/jsx-runtime";
 import * as React from 'react';
-export const EditorPlugin = ({ anchorElem, plugin })=>{
+export const EditorPlugin = ({ anchorElem, clientProps, plugin })=>{
     if (plugin.position === 'floatingAnchorElem') {
-        return plugin.Component && /*#__PURE__*/ React.createElement(plugin.Component, {
-            anchorElem: anchorElem
+        return plugin.Component && /*#__PURE__*/ _jsx(plugin.Component, {
+            anchorElem: anchorElem,
+            clientProps: clientProps
         });
     }
-    return plugin.Component && /*#__PURE__*/ React.createElement(plugin.Component, null);
+    return plugin.Component && /*#__PURE__*/ _jsx(plugin.Component, {
+        clientProps: clientProps
+    });
 };
 
 //# sourceMappingURL=EditorPlugin.js.map

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/field/lexical/EditorPlugin.tsx"],"sourcesContent":["import * as React from 'react'\n\nimport type { SanitizedPlugin } from '../features/types.js'\n\nexport const EditorPlugin: React.FC<{\n  anchorElem?: HTMLDivElement\n  plugin: SanitizedPlugin\n}> = ({ anchorElem, plugin }) => {\n  if (plugin.position === 'floatingAnchorElem') {\n    return plugin.Component && <plugin.Component anchorElem={anchorElem} />\n  }\n\n  return plugin.Component && <plugin.Component />\n}\n"],"names":["React","EditorPlugin","anchorElem","plugin","position","Component"],"rangeMappings":";;;;;;;;","mappings":"AAAA,YAAYA,WAAW,QAAO;AAI9B,OAAO,MAAMC,eAGR,CAAC,EAAEC,UAAU,EAAEC,MAAM,EAAE;IAC1B,IAAIA,OAAOC,QAAQ,KAAK,sBAAsB;QAC5C,OAAOD,OAAOE,SAAS,kBAAI,oBAACF,OAAOE,SAAS;YAACH,YAAYA;;IAC3D;IAEA,OAAOC,OAAOE,SAAS,kBAAI,oBAACF,OAAOE,SAAS;AAC9C,EAAC"}
+{"version":3,"sources":["../../../src/field/lexical/EditorPlugin.tsx"],"sourcesContent":["import * as React from 'react'\n\nimport type { SanitizedPlugin } from '../features/types.js'\n\nexport const EditorPlugin: React.FC<{\n  anchorElem?: HTMLDivElement\n  clientProps: any\n  plugin: SanitizedPlugin\n}> = ({ anchorElem, clientProps, plugin }) => {\n  if (plugin.position === 'floatingAnchorElem') {\n    return (\n      plugin.Component && <plugin.Component anchorElem={anchorElem} clientProps={clientProps} />\n    )\n  }\n\n  return plugin.Component && <plugin.Component clientProps={clientProps} />\n}\n"],"names":["React","EditorPlugin","anchorElem","clientProps","plugin","position","Component"],"rangeMappings":";;;;;;;;;;;;","mappings":";AAAA,YAAYA,WAAW,QAAO;AAI9B,OAAO,MAAMC,eAIR,CAAC,EAAEC,UAAU,EAAEC,WAAW,EAAEC,MAAM,EAAE;IACvC,IAAIA,OAAOC,QAAQ,KAAK,sBAAsB;QAC5C,OACED,OAAOE,SAAS,kBAAI,KAACF,OAAOE,SAAS;YAACJ,YAAYA;YAAYC,aAAaA;;IAE/E;IAEA,OAAOC,OAAOE,SAAS,kBAAI,KAACF,OAAOE,SAAS;QAACH,aAAaA;;AAC5D,EAAC"}

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

@@ -1,5 +1,7 @@
 import * as React from 'react';
 import type { LexicalProviderProps } from './LexicalProvider.js';
 import './LexicalEditor.scss';
-export declare const LexicalEditor: React.FC<Pick<LexicalProviderProps, 'editorConfig' | 'onChange'>>;
+export declare const LexicalEditor: React.FC<Pick<LexicalProviderProps, 'editorConfig' | 'onChange'> & {
+    editorContainerRef: React.RefObject<HTMLDivElement>;
+}>;
 //# sourceMappingURL=LexicalEditor.d.ts.map

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":"AAiBA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAG9B,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAA;AAGhE,OAAO,sBAAsB,CAAA;AAQ7B,eAAO,MAAM,aAAa,EAAE,KAAK,CAAC,EAAE,CAAC,IAAI,CAAC,oBAAoB,EAAE,cAAc,GAAG,UAAU,CAAC,CAgH3F,CAAA"}
+{"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;AAGhE,OAAO,sBAAsB,CAAA;AAQ7B,eAAO,MAAM,aAAa,EAAE,KAAK,CAAC,EAAE,CAClC,IAAI,CAAC,oBAAoB,EAAE,cAAc,GAAG,UAAU,CAAC,GAAG;IACxD,kBAAkB,EAAE,KAAK,CAAC,SAAS,CAAC,cAAc,CAAC,CAAA;CACpD,CA4KF,CAAA"}

package/dist/field/lexical/LexicalEditor.js

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

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

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

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

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

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

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

package/dist/field/lexical/LexicalProvider.js

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