@payloadcms/richtext-lexical 3.0.0-canary.fb81f02 → 3.0.0

package/dist/lexical/LexicalProvider.js

@@ -1,98 +1,92 @@
 'use client';
+
 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, useEditorConfigContext } from './config/client/EditorConfigProvider.js';
+import { LexicalEditor as LexicalEditorComponent } from './LexicalEditor.js';
 import { getEnabledNodes } from './nodes/index.js';
-const NestProviders = ({ children, providers })=>{
-    if (!providers?.length) {
-        return children;
-    }
-    const Component = providers[0];
-    if (providers.length > 1) {
-        return /*#__PURE__*/ _jsx(Component, {
-            children: /*#__PURE__*/ _jsx(NestProviders, {
-                providers: providers.slice(1),
-                children: children
-            })
-        });
-    }
-    return /*#__PURE__*/ _jsx(Component, {
+const NestProviders = ({
+  children,
+  providers
+}) => {
+  if (!providers?.length) {
+    return children;
+  }
+  const Component = providers[0];
+  if (providers.length > 1) {
+    return /*#__PURE__*/_jsx(Component, {
+      children: /*#__PURE__*/_jsx(NestProviders, {
+        providers: providers.slice(1),
         children: children
+      })
     });
+  }
+  return /*#__PURE__*/_jsx(Component, {
+    children: children
+  });
 };
-export const LexicalProvider = (props)=>{
-    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. The data structure is different, thus you will have to migrate your data. We offer a one-line migration script which migrates all your rich text fields: https://payloadcms.com/docs/beta/lexical/migration#migration-via-migration-script-recommended');
-        }
-        if (processedValue && 'jsonContent' in processedValue) {
-            throw new Error('You have tried to pass in data from payload-plugin-lexical. The data structure is different, thus you will have to migrate your data. Migration guide: https://payloadcms.com/docs/beta/lexical/migration#migrating-from-payload-plugin-lexical');
-        }
-        return {
-            editable: readOnly !== true,
-            editorState: processedValue != null ? JSON.stringify(processedValue) : undefined,
-            namespace: editorConfig.lexical.namespace,
-            nodes: [
-                ...getEnabledNodes({
-                    editorConfig
-                })
-            ],
-            onError: (error)=>{
-                throw error;
-            },
-            theme: editorConfig.lexical.theme
-        };
-    }, [
-        editorConfig,
-        processedValue,
-        readOnly
-    ]);
-    if (!initialConfig) {
-        return /*#__PURE__*/ _jsx("p", {
-            children: "Loading..."
-        });
+export const LexicalProvider = props => {
+  const {
+    composerKey,
+    editorConfig,
+    fieldProps,
+    onChange,
+    readOnly,
+    value
+  } = props;
+  const parentContext = useEditorConfigContext();
+  const editorContainerRef = React.useRef(null);
+  // useMemo for the initialConfig that depends on readOnly and value
+  const initialConfig = useMemo(() => {
+    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));
     }
-    return /*#__PURE__*/ _jsx(LexicalComposer, {
-        initialConfig: initialConfig,
-        children: /*#__PURE__*/ _jsx(EditorConfigProvider, {
-            editorConfig: editorConfig,
-            editorContainerRef: editorContainerRef,
-            fieldProps: fieldProps,
-            parentContext: parentContext,
-            children: /*#__PURE__*/ _jsx(NestProviders, {
-                providers: editorConfig.features.providers,
-                children: /*#__PURE__*/ _jsx(LexicalEditorComponent, {
-                    editorConfig: editorConfig,
-                    editorContainerRef: editorContainerRef,
-                    onChange: onChange
-                })
-            })
+    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. The data structure is different, thus you will have to migrate your data. We offer a one-line migration script which migrates all your rich text fields: https://payloadcms.com/docs/beta/lexical/migration#migration-via-migration-script-recommended');
+    }
+    if (value && 'jsonContent' in value) {
+      throw new Error('You have tried to pass in data from payload-plugin-lexical. The data structure is different, thus you will have to migrate your data. Migration guide: https://payloadcms.com/docs/beta/lexical/migration#migrating-from-payload-plugin-lexical');
+    }
+    return {
+      editable: readOnly !== true,
+      editorState: value != null ? JSON.stringify(value) : undefined,
+      namespace: editorConfig.lexical.namespace,
+      nodes: getEnabledNodes({
+        editorConfig
+      }),
+      onError: error => {
+        throw error;
+      },
+      theme: editorConfig.lexical.theme
+    };
+    // Important: do not add readOnly and value to the dependencies array. This will cause the entire lexical editor to re-render if the document is saved, which will
+    // cause the editor to lose focus.
+  }, [editorConfig]);
+  if (!initialConfig) {
+    return /*#__PURE__*/_jsx("p", {
+      children: "Loading..."
+    });
+  }
+  // We need to add initialConfig.editable to the key to force a re-render when the readOnly prop changes.
+  // Without it, there were cases where lexical editors inside drawers turn readOnly initially - a few miliseconds later they turn editable, but the editor does not re-render and stays readOnly.
+  return /*#__PURE__*/_jsx(LexicalComposer, {
+    initialConfig: initialConfig,
+    children: /*#__PURE__*/_jsx(EditorConfigProvider, {
+      editorConfig: editorConfig,
+      editorContainerRef: editorContainerRef,
+      fieldProps: fieldProps,
+      parentContext: parentContext,
+      children: /*#__PURE__*/_jsx(NestProviders, {
+        providers: editorConfig.features.providers,
+        children: /*#__PURE__*/_jsx(LexicalEditorComponent, {
+          editorConfig: editorConfig,
+          editorContainerRef: editorContainerRef,
+          onChange: onChange
         })
-    }, path);
+      })
+    })
+  }, composerKey + initialConfig.editable);
 };
-
 //# sourceMappingURL=LexicalProvider.js.map

package/dist/lexical/LexicalProvider.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/lexical/LexicalProvider.tsx"],"sourcesContent":["'use client'\nimport type { InitialConfigType } from '@lexical/react/LexicalComposer.js'\nimport type { EditorState, LexicalEditor, SerializedEditorState } from 'lexical'\nimport type { FormFieldBase } from 'payload'\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: {\n    editorConfig: SanitizedClientEditorConfig // With rendered features n stuff\n    name: string\n    richTextComponentMap: Map<string, React.ReactNode>\n  } & FormFieldBase\n  onChange: (editorState: EditorState, editor: LexicalEditor, tags: Set<string>) => void\n  path: string\n  readOnly: boolean\n  value: SerializedEditorState\n}\n\nconst NestProviders = ({ children, providers }) => {\n  if (!providers?.length) {\n    return children\n  }\n  const Component = providers[0]\n  if (providers.length > 1) {\n    return (\n      <Component>\n        <NestProviders providers={providers.slice(1)}>{children}</NestProviders>\n      </Component>\n    )\n  }\n  return <Component>{children}</Component>\n}\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. The data structure is different, thus you will have to migrate your data. We offer a one-line migration script which migrates all your rich text fields: https://payloadcms.com/docs/beta/lexical/migration#migration-via-migration-script-recommended',\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. The data structure is different, thus you will have to migrate your data. Migration guide: https://payloadcms.com/docs/beta/lexical/migration#migrating-from-payload-plugin-lexical',\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        <NestProviders providers={editorConfig.features.providers}>\n          <LexicalEditorComponent\n            editorConfig={editorConfig}\n            editorContainerRef={editorContainerRef}\n            onChange={onChange}\n          />\n        </NestProviders>\n      </EditorConfigProvider>\n    </LexicalComposer>\n  )\n}\n"],"names":["LexicalComposer","React","useMemo","LexicalEditor","LexicalEditorComponent","EditorConfigProvider","useEditorConfigContext","getEnabledNodes","NestProviders","children","providers","length","Component","slice","LexicalProvider","props","editorConfig","fieldProps","onChange","path","readOnly","value","parentContext","editorContainerRef","useRef","processedValue","processed","features","hooks","load","forEach","hook","incomingEditorState","initialConfig","Error","JSON","stringify","Array","isArray","editable","editorState","undefined","namespace","lexical","nodes","onError","error","theme","p"],"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;AAelD,MAAMC,gBAAgB,CAAC,EAAEC,QAAQ,EAAEC,SAAS,EAAE;IAC5C,IAAI,CAACA,WAAWC,QAAQ;QACtB,OAAOF;IACT;IACA,MAAMG,YAAYF,SAAS,CAAC,EAAE;IAC9B,IAAIA,UAAUC,MAAM,GAAG,GAAG;QACxB,qBACE,KAACC;sBACC,cAAA,KAACJ;gBAAcE,WAAWA,UAAUG,KAAK,CAAC;0BAAKJ;;;IAGrD;IACA,qBAAO,KAACG;kBAAWH;;AACrB;AAEA,OAAO,MAAMK,kBAAkD,CAACC;IAC9D,MAAM,EAAEC,YAAY,EAAEC,UAAU,EAAEC,QAAQ,EAAEC,IAAI,EAAEC,QAAQ,EAAEC,KAAK,EAAE,GAAGN;IAEtE,MAAMO,gBAAgBhB;IAEtB,MAAMiB,qBAAqBtB,MAAMuB,MAAM,CAAiB;IAExD,MAAMC,iBAAiBvB,QAAQ;QAC7B,IAAIwB,YAAYL;QAChB,IAAIL,cAAcW,UAAUC,OAAOC,MAAMlB,QAAQ;YAC/CK,aAAaW,QAAQ,CAACC,KAAK,CAACC,IAAI,CAACC,OAAO,CAAC,CAACC;gBACxCL,YAAYK,KAAK;oBAAEC,qBAAqBN;gBAAU;YACpD;QACF;QACA,OAAOA;IACT,GAAG;QAACV;QAAcK;KAAM;IAExB,4EAA4E;IAC5E,MAAMY,gBAAgB/B,QAA2B;QAC/C,IAAIuB,kBAAkB,OAAOA,mBAAmB,UAAU;YACxD,MAAM,IAAIS,MACR,kLACEC,KAAKC,SAAS,CAACX;QAErB;QAEA,IAAIA,kBAAkBY,MAAMC,OAAO,CAACb,mBAAmB,CAAE,CAAA,UAAUA,cAAa,GAAI;YAClF,MAAM,IAAIS,MACR;QAEJ;QAEA,IAAIT,kBAAkB,iBAAiBA,gBAAgB;YACrD,MAAM,IAAIS,MACR;QAEJ;QAEA,OAAO;YACLK,UAAUnB,aAAa;YACvBoB,aAAaf,kBAAkB,OAAOU,KAAKC,SAAS,CAACX,kBAAkBgB;YACvEC,WAAW1B,aAAa2B,OAAO,CAACD,SAAS;YACzCE,OAAO;mBAAIrC,gBAAgB;oBAAES;gBAAa;aAAG;YAC7C6B,SAAS,CAACC;gBACR,MAAMA;YACR;YACAC,OAAO/B,aAAa2B,OAAO,CAACI,KAAK;QACnC;IACF,GAAG;QAAC/B;QAAcS;QAAgBL;KAAS;IAE3C,IAAI,CAACa,eAAe;QAClB,qBAAO,KAACe;sBAAE;;IACZ;IAEA,qBACE,KAAChD;QAAgBiC,eAAeA;kBAC9B,cAAA,KAAC5B;YACCW,cAAcA;YACdO,oBAAoBA;YACpBN,YAAYA;YACZK,eAAeA;sBAEf,cAAA,KAACd;gBAAcE,WAAWM,aAAaW,QAAQ,CAACjB,SAAS;0BACvD,cAAA,KAACN;oBACCY,cAAcA;oBACdO,oBAAoBA;oBACpBL,UAAUA;;;;OAXkCC;AAiBxD,EAAC"}
+{"version":3,"file":"LexicalProvider.js","names":["LexicalComposer","React","useMemo","EditorConfigProvider","useEditorConfigContext","LexicalEditor","LexicalEditorComponent","getEnabledNodes","NestProviders","children","providers","length","Component","_jsx","slice","LexicalProvider","props","composerKey","editorConfig","fieldProps","onChange","readOnly","value","parentContext","editorContainerRef","useRef","initialConfig","Error","JSON","stringify","Array","isArray","editable","editorState","undefined","namespace","lexical","nodes","onError","error","theme","features"],"sources":["../../src/lexical/LexicalProvider.tsx"],"sourcesContent":["'use client'\nimport type { InitialConfigType } from '@lexical/react/LexicalComposer.js'\nimport type { EditorState, LexicalEditor, SerializedEditorState } from 'lexical'\nimport type { ClientField } from 'payload'\n\nimport { LexicalComposer } from '@lexical/react/LexicalComposer.js'\nimport * as React from 'react'\nimport { useMemo } from 'react'\n\nimport type { LexicalRichTextFieldProps } from '../types.js'\nimport type { SanitizedClientEditorConfig } from './config/types.js'\n\nimport {\n  EditorConfigProvider,\n  useEditorConfigContext,\n} from './config/client/EditorConfigProvider.js'\nimport { LexicalEditor as LexicalEditorComponent } from './LexicalEditor.js'\nimport { getEnabledNodes } from './nodes/index.js'\n\nexport type LexicalProviderProps = {\n  composerKey: string\n  editorConfig: SanitizedClientEditorConfig\n  fieldProps: LexicalRichTextFieldProps\n  onChange: (editorState: EditorState, editor: LexicalEditor, tags: Set<string>) => void\n  readOnly: boolean\n  value: SerializedEditorState\n}\n\nconst NestProviders = ({ children, providers }) => {\n  if (!providers?.length) {\n    return children\n  }\n  const Component = providers[0]\n  if (providers.length > 1) {\n    return (\n      <Component>\n        <NestProviders providers={providers.slice(1)}>{children}</NestProviders>\n      </Component>\n    )\n  }\n  return <Component>{children}</Component>\n}\n\nexport const LexicalProvider: React.FC<LexicalProviderProps> = (props) => {\n  const { composerKey, editorConfig, fieldProps, onChange, readOnly, value } = props\n\n  const parentContext = useEditorConfigContext()\n\n  const editorContainerRef = React.useRef<HTMLDivElement>(null)\n\n  // useMemo for the initialConfig that depends on readOnly and value\n  const initialConfig = useMemo<InitialConfigType>(() => {\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. The data structure is different, thus you will have to migrate your data. We offer a one-line migration script which migrates all your rich text fields: https://payloadcms.com/docs/beta/lexical/migration#migration-via-migration-script-recommended',\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. The data structure is different, thus you will have to migrate your data. Migration guide: https://payloadcms.com/docs/beta/lexical/migration#migrating-from-payload-plugin-lexical',\n      )\n    }\n\n    return {\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    // Important: do not add readOnly and value to the dependencies array. This will cause the entire lexical editor to re-render if the document is saved, which will\n    // cause the editor to lose focus.\n  }, [editorConfig])\n\n  if (!initialConfig) {\n    return <p>Loading...</p>\n  }\n\n  // We need to add initialConfig.editable to the key to force a re-render when the readOnly prop changes.\n  // Without it, there were cases where lexical editors inside drawers turn readOnly initially - a few miliseconds later they turn editable, but the editor does not re-render and stays readOnly.\n  return (\n    <LexicalComposer initialConfig={initialConfig} key={composerKey + initialConfig.editable}>\n      <EditorConfigProvider\n        editorConfig={editorConfig}\n        editorContainerRef={editorContainerRef}\n        fieldProps={fieldProps}\n        parentContext={parentContext}\n      >\n        <NestProviders providers={editorConfig.features.providers}>\n          <LexicalEditorComponent\n            editorConfig={editorConfig}\n            editorContainerRef={editorContainerRef}\n            onChange={onChange}\n          />\n        </NestProviders>\n      </EditorConfigProvider>\n    </LexicalComposer>\n  )\n}\n"],"mappings":"AAAA;;;AAKA,SAASA,eAAe,QAAQ;AAChC,YAAYC,KAAA,MAAW;AACvB,SAASC,OAAO,QAAQ;AAKxB,SACEC,oBAAoB,EACpBC,sBAAsB,QACjB;AACP,SAASC,aAAA,IAAiBC,sBAAsB,QAAQ;AACxD,SAASC,eAAe,QAAQ;AAWhC,MAAMC,aAAA,GAAgBA,CAAC;EAAEC,QAAQ;EAAEC;AAAS,CAAE;EAC5C,IAAI,CAACA,SAAA,EAAWC,MAAA,EAAQ;IACtB,OAAOF,QAAA;EACT;EACA,MAAMG,SAAA,GAAYF,SAAS,CAAC,EAAE;EAC9B,IAAIA,SAAA,CAAUC,MAAM,GAAG,GAAG;IACxB,oBACEE,IAAA,CAACD,SAAA;gBACC,aAAAC,IAAA,CAACL,aAAA;QAAcE,SAAA,EAAWA,SAAA,CAAUI,KAAK,CAAC;kBAAKL;;;EAGrD;EACA,oBAAOI,IAAA,CAACD,SAAA;cAAWH;;AACrB;AAEA,OAAO,MAAMM,eAAA,GAAmDC,KAAA;EAC9D,MAAM;IAAEC,WAAW;IAAEC,YAAY;IAAEC,UAAU;IAAEC,QAAQ;IAAEC,QAAQ;IAAEC;EAAK,CAAE,GAAGN,KAAA;EAE7E,MAAMO,aAAA,GAAgBnB,sBAAA;EAEtB,MAAMoB,kBAAA,GAAqBvB,KAAA,CAAMwB,MAAM,CAAiB;EAExD;EACA,MAAMC,aAAA,GAAgBxB,OAAA,CAA2B;IAC/C,IAAIoB,KAAA,IAAS,OAAOA,KAAA,KAAU,UAAU;MACtC,MAAM,IAAIK,KAAA,CACR,kLACEC,IAAA,CAAKC,SAAS,CAACP,KAAA;IAErB;IAEA,IAAIA,KAAA,IAASQ,KAAA,CAAMC,OAAO,CAACT,KAAA,KAAU,EAAE,UAAUA,KAAI,GAAI;MACvD,MAAM,IAAIK,KAAA,CACR;IAEJ;IAEA,IAAIL,KAAA,IAAS,iBAAiBA,KAAA,EAAO;MACnC,MAAM,IAAIK,KAAA,CACR;IAEJ;IAEA,OAAO;MACLK,QAAA,EAAUX,QAAA,KAAa;MACvBY,WAAA,EAAaX,KAAA,IAAS,OAAOM,IAAA,CAAKC,SAAS,CAACP,KAAA,IAASY,SAAA;MACrDC,SAAA,EAAWjB,YAAA,CAAakB,OAAO,CAACD,SAAS;MACzCE,KAAA,EAAO9B,eAAA,CAAgB;QAAEW;MAAa;MACtCoB,OAAA,EAAUC,KAAA;QACR,MAAMA,KAAA;MACR;MACAC,KAAA,EAAOtB,YAAA,CAAakB,OAAO,CAACI;IAC9B;IACA;IACA;EACF,GAAG,CAACtB,YAAA,CAAa;EAEjB,IAAI,CAACQ,aAAA,EAAe;IAClB,oBAAOb,IAAA,CAAC;gBAAE;;EACZ;EAEA;EACA;EACA,oBACEA,IAAA,CAACb,eAAA;IAAgB0B,aAAA,EAAeA,aAAA;cAC9B,aAAAb,IAAA,CAACV,oBAAA;MACCe,YAAA,EAAcA,YAAA;MACdM,kBAAA,EAAoBA,kBAAA;MACpBL,UAAA,EAAYA,UAAA;MACZI,aAAA,EAAeA,aAAA;gBAEf,aAAAV,IAAA,CAACL,aAAA;QAAcE,SAAA,EAAWQ,YAAA,CAAauB,QAAQ,CAAC/B,SAAS;kBACvD,aAAAG,IAAA,CAACP,sBAAA;UACCY,YAAA,EAAcA,YAAA;UACdM,kBAAA,EAAoBA,kBAAA;UACpBJ,QAAA,EAAUA;;;;KAXkCH,WAAA,GAAcS,aAAA,CAAcM,QAAQ;AAiB5F","ignoreList":[]}

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

@@ -1,6 +1,7 @@
 import type { LexicalEditor } from 'lexical';
-import type { FormFieldBase } from 'payload';
+import type { MarkRequired } from 'ts-essentials';
 import * as React from 'react';
+import type { LexicalRichTextFieldProps } from '../../../types.js';
 import type { SanitizedClientEditorConfig } from '../types.js';
 export interface EditorConfigContextType {
     blurEditor: (editorContext: EditorConfigContextType) => void;
@@ -8,13 +9,9 @@ export interface EditorConfigContextType {
     editor: LexicalEditor;
     editorConfig: SanitizedClientEditorConfig;
     editorContainerRef: React.RefObject<HTMLDivElement>;
-    field: {
-        editorConfig: SanitizedClientEditorConfig;
-        name: string;
-        richTextComponentMap: Map<string, React.ReactNode>;
-    } & FormFieldBase;
-    focusEditor: (editorContext: EditorConfigContextType) => void;
+    fieldProps: MarkRequired<LexicalRichTextFieldProps, 'path' | 'schemaPath'>;
     focusedEditor: EditorConfigContextType | null;
+    focusEditor: (editorContext: EditorConfigContextType) => void;
     parentEditor: EditorConfigContextType;
     registerChild: (uuid: string, editorContext: EditorConfigContextType) => void;
     unregisterChild?: (uuid: string) => void;
@@ -23,12 +20,8 @@ export interface EditorConfigContextType {
 export declare const EditorConfigProvider: ({ children, editorConfig, editorContainerRef, fieldProps, parentContext, }: {
     children: React.ReactNode;
     editorConfig: SanitizedClientEditorConfig;
-    editorContainerRef: React.RefObject<HTMLDivElement>;
-    fieldProps: {
-        editorConfig: SanitizedClientEditorConfig;
-        name: string;
-        richTextComponentMap: Map<string, React.ReactNode>;
-    } & FormFieldBase;
+    editorContainerRef: React.RefObject<HTMLDivElement | null>;
+    fieldProps: LexicalRichTextFieldProps;
     parentContext?: EditorConfigContextType;
 }) => React.ReactNode;
 export declare const useEditorConfigContext: () => EditorConfigContextType;

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

@@ -1 +1 @@
-{"version":3,"file":"EditorConfigProvider.d.ts","sourceRoot":"","sources":["../../../../src/lexical/config/client/EditorConfigProvider.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAC5C,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;QACL,YAAY,EAAE,2BAA2B,CAAA;QACzC,IAAI,EAAE,MAAM,CAAA;QACZ,oBAAoB,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,SAAS,CAAC,CAAA;KACnD,GAAG,aAAa,CAAA;IAEjB,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,KAAK,CAAC,SAAS,CAAA;IACzB,YAAY,EAAE,2BAA2B,CAAA;IACzC,kBAAkB,EAAE,KAAK,CAAC,SAAS,CAAC,cAAc,CAAC,CAAA;IACnD,UAAU,EAAE;QACV,YAAY,EAAE,2BAA2B,CAAA;QACzC,IAAI,EAAE,MAAM,CAAA;QACZ,oBAAoB,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,SAAS,CAAC,CAAA;KACnD,GAAG,aAAa,CAAA;IACjB,aAAa,CAAC,EAAE,uBAAuB,CAAA;CACxC,KAAG,KAAK,CAAC,SA2ET,CAAA;AAED,eAAO,MAAM,sBAAsB,QAAO,uBAMzC,CAAA"}
+{"version":3,"file":"EditorConfigProvider.d.ts","sourceRoot":"","sources":["../../../../src/lexical/config/client/EditorConfigProvider.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAC5C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAA;AAGjD,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAG9B,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,mBAAmB,CAAA;AAClE,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;IAEnD,UAAU,EAAE,YAAY,CAAC,yBAAyB,EAAE,MAAM,GAAG,YAAY,CAAC,CAAA;IAC1E,aAAa,EAAE,uBAAuB,GAAG,IAAI,CAAA;IAE7C,WAAW,EAAE,CAAC,aAAa,EAAE,uBAAuB,KAAK,IAAI,CAAA;IAC7D,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;AASD,eAAO,MAAM,oBAAoB,+EAM9B;IACD,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAA;IACzB,YAAY,EAAE,2BAA2B,CAAA;IACzC,kBAAkB,EAAE,KAAK,CAAC,SAAS,CAAC,cAAc,GAAG,IAAI,CAAC,CAAA;IAE1D,UAAU,EAAE,yBAAyB,CAAA;IACrC,aAAa,CAAC,EAAE,uBAAuB,CAAA;CACxC,KAAG,KAAK,CAAC,SA2ET,CAAA;AAED,eAAO,MAAM,sBAAsB,QAAO,uBAMzC,CAAA"}

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

@@ -1,91 +1,89 @@
 '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, 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);
+  return Math.random().toString(36).substring(2, 12) + Math.random().toString(36).substring(2, 12);
 }
-const Context = /*#__PURE__*/ createContext({
-    editorConfig: null,
-    field: null,
-    uuid: null
+// @ts-expect-error: TODO: Fix this
+const Context = /*#__PURE__*/createContext({
+  editorConfig: null,
+  fieldProps: null,
+  uuid: null
 });
-export const EditorConfigProvider = ({ children, editorConfig, editorContainerRef, fieldProps, parentContext })=>{
-    const [editor] = useLexicalComposerContext();
-    // State to store the UUID
-    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__*/ _jsx(Context.Provider, {
-        value: editorContext,
-        children: children
-    });
+export const EditorConfigProvider = ({
+  children,
+  editorConfig,
+  editorContainerRef,
+  fieldProps,
+  parentContext
+}) => {
+  const [editor] = useLexicalComposerContext();
+  // State to store the UUID
+  const [uuid] = useState(generateQuickGuid());
+  const childrenEditors = useRef(new Map());
+  const [focusedEditor, setFocusedEditor] = useState(null);
+  const focusHistory = useRef(new Set());
+  const editorContext_1 = useMemo(() => ({
+    blurEditor: editorContext => {
+      //setFocusedEditor(null) // Clear focused editor
+      focusHistory.current.clear() // Reset focus history when focus is lost
+      ;
+    },
+    childrenEditors,
+    editor,
+    editorConfig,
+    editorContainerRef,
+    fieldProps,
+    focusedEditor,
+    focusEditor: editorContext_0 => {
+      const editorUUID = editorContext_0.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_0);
+      // Propagate focus event to parent and children, ensuring they do not refocus this editor
+      if (parentContext?.uuid) {
+        parentContext.focusEditor(editorContext_0);
+      }
+      childrenEditors.current.forEach(childEditor => {
+        childEditor.focusEditor(editorContext_0);
+      });
+      focusHistory.current.clear();
+    },
+    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_0 => {
+      if (childrenEditors.current.has(childUUID_0)) {
+        const newMap_0 = new Map(childrenEditors.current);
+        newMap_0.delete(childUUID_0);
+        childrenEditors.current = newMap_0;
+      }
+    },
+    uuid
+  }), [editor, childrenEditors, editorConfig, editorContainerRef, fieldProps, focusedEditor, parentContext, uuid]);
+  return /*#__PURE__*/_jsx(Context.Provider, {
+    value: editorContext_1,
+    children: children
+  });
 };
-export const useEditorConfigContext = ()=>{
-    const context = useContext(Context);
-    if (context === undefined) {
-        throw new Error('useEditorConfigContext must be used within an EditorConfigProvider');
-    }
-    return context;
+export const useEditorConfigContext = () => {
+  const context = useContext(Context);
+  if (context === undefined) {
+    throw new Error("useEditorConfigContext must be used within an EditorConfigProvider");
+  }
+  return context;
 };
-
 //# sourceMappingURL=EditorConfigProvider.js.map

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/lexical/config/client/EditorConfigProvider.tsx"],"sourcesContent":["'use client'\n\nimport type { LexicalEditor } from 'lexical'\nimport type { FormFieldBase } from 'payload'\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: {\n    editorConfig: SanitizedClientEditorConfig // With rendered features n stuff\n    name: string\n    richTextComponentMap: Map<string, React.ReactNode>\n  } & FormFieldBase\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: {\n    editorConfig: SanitizedClientEditorConfig // With rendered features n stuff\n    name: string\n    richTextComponentMap: Map<string, React.ReactNode>\n  } & FormFieldBase\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"],"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"}
+{"version":3,"file":"EditorConfigProvider.js","names":["useLexicalComposerContext","React","createContext","useContext","useMemo","useRef","useState","generateQuickGuid","Math","random","toString","substring","Context","editorConfig","fieldProps","uuid","EditorConfigProvider","children","editorContainerRef","parentContext","editor","childrenEditors","Map","focusedEditor","setFocusedEditor","focusHistory","Set","editorContext","blurEditor","current","clear","focusEditor","editorUUID","has","add","forEach","childEditor","parentEditor","registerChild","childUUID","childEditorContext","newMap","set","unregisterChild","delete","_jsx","Provider","value","useEditorConfigContext","context","undefined","Error"],"sources":["../../../../src/lexical/config/client/EditorConfigProvider.tsx"],"sourcesContent":["'use client'\n\nimport type { LexicalEditor } from 'lexical'\nimport type { MarkRequired } from 'ts-essentials'\n\nimport { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext.js'\nimport * as React from 'react'\nimport { createContext, useContext, useMemo, useRef, useState } from 'react'\n\nimport type { LexicalRichTextFieldProps } from '../../../types.js'\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\n  fieldProps: MarkRequired<LexicalRichTextFieldProps, 'path' | 'schemaPath'>\n  focusedEditor: EditorConfigContextType | null\n  // Editor focus handling\n  focusEditor: (editorContext: EditorConfigContextType) => void\n  parentEditor: EditorConfigContextType\n  registerChild: (uuid: string, editorContext: EditorConfigContextType) => void\n  unregisterChild?: (uuid: string) => void\n  uuid: string\n}\n\n// @ts-expect-error: TODO: Fix this\nconst Context: React.Context<EditorConfigContextType> = createContext({\n  editorConfig: null,\n  fieldProps: 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 | null>\n\n  fieldProps: LexicalRichTextFieldProps\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        fieldProps,\n        focusedEditor,\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) => {\n            childEditor.focusEditor(editorContext)\n          })\n\n          focusHistory.current.clear()\n        },\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"],"mappings":"AAAA;;;AAKA,SAASA,yBAAyB,QAAQ;AAC1C,YAAYC,KAAA,MAAW;AACvB,SAASC,aAAa,EAAEC,UAAU,EAAEC,OAAO,EAAEC,MAAM,EAAEC,QAAQ,QAAQ;AAKrE;AACA,SAASC,kBAAA;EACP,OAAOC,IAAA,CAAKC,MAAM,GAAGC,QAAQ,CAAC,IAAIC,SAAS,CAAC,GAAG,MAAMH,IAAA,CAAKC,MAAM,GAAGC,QAAQ,CAAC,IAAIC,SAAS,CAAC,GAAG;AAC/F;AAoBA;AACA,MAAMC,OAAA,gBAAkDV,aAAA,CAAc;EACpEW,YAAA,EAAc;EACdC,UAAA,EAAY;EACZC,IAAA,EAAM;AACR;AAEA,OAAO,MAAMC,oBAAA,GAAuBA,CAAC;EACnCC,QAAQ;EACRJ,YAAY;EACZK,kBAAkB;EAClBJ,UAAU;EACVK;AAAa,CAQd;EACC,MAAM,CAACC,MAAA,CAAO,GAAGpB,yBAAA;EACjB;EACA,MAAM,CAACe,IAAA,CAAK,GAAGT,QAAA,CAASC,iBAAA;EAExB,MAAMc,eAAA,GAAkBhB,MAAA,CAA6C,IAAIiB,GAAA;EACzE,MAAM,CAACC,aAAA,EAAeC,gBAAA,CAAiB,GAAGlB,QAAA,CAAyC;EACnF,MAAMmB,YAAA,GAAepB,MAAA,CAAoB,IAAIqB,GAAA;EAE7C,MAAMC,eAAA,GAAgBvB,OAAA,CACpB,OACG;IACCwB,UAAA,EAAaD,aAAA;MACX;MACAF,YAAA,CAAaI,OAAO,CAACC,KAAK,GAAG;MAAA;IAC/B;IACAT,eAAA;IACAD,MAAA;IACAP,YAAA;IACAK,kBAAA;IACAJ,UAAA;IACAS,aAAA;IACAQ,WAAA,EAAcJ,eAAA;MACZ,MAAMK,UAAA,GAAaL,eAAA,CAAcZ,IAAI;MAErC;MACA,IAAIU,YAAA,CAAaI,OAAO,CAACI,GAAG,CAACD,UAAA,GAAa;QACxC;MACF;MAEA;MACAP,YAAA,CAAaI,OAAO,CAACK,GAAG,CAACF,UAAA;MACzBR,gBAAA,CAAiBG,eAAA;MAEjB;MACA,IAAIR,aAAA,EAAeJ,IAAA,EAAM;QACvBI,aAAA,CAAcY,WAAW,CAACJ,eAAA;MAC5B;MACAN,eAAA,CAAgBQ,OAAO,CAACM,OAAO,CAAEC,WAAA;QAC/BA,WAAA,CAAYL,WAAW,CAACJ,eAAA;MAC1B;MAEAF,YAAA,CAAaI,OAAO,CAACC,KAAK;IAC5B;IACAO,YAAA,EAAclB,aAAA;IACdmB,aAAA,EAAeA,CAACC,SAAA,EAAWC,kBAAA;MACzB,IAAI,CAACnB,eAAA,CAAgBQ,OAAO,CAACI,GAAG,CAACM,SAAA,GAAY;QAC3C,MAAME,MAAA,GAAS,IAAInB,GAAA,CAAID,eAAA,CAAgBQ,OAAO;QAC9CY,MAAA,CAAOC,GAAG,CAACH,SAAA,EAAWC,kBAAA;QACtBnB,eAAA,CAAgBQ,OAAO,GAAGY,MAAA;MAC5B;IACF;IACAE,eAAA,EAAkBJ,WAAA;MAChB,IAAIlB,eAAA,CAAgBQ,OAAO,CAACI,GAAG,CAACM,WAAA,GAAY;QAC1C,MAAME,QAAA,GAAS,IAAInB,GAAA,CAAID,eAAA,CAAgBQ,OAAO;QAC9CY,QAAA,CAAOG,MAAM,CAACL,WAAA;QACdlB,eAAA,CAAgBQ,OAAO,GAAGY,QAAA;MAC5B;IACF;IAEA1B;EACF,IACF,CACEK,MAAA,EACAC,eAAA,EACAR,YAAA,EACAK,kBAAA,EACAJ,UAAA,EACAS,aAAA,EACAJ,aAAA,EACAJ,IAAA,CACD;EAGH,oBAAO8B,IAAA,CAACjC,OAAA,CAAQkC,QAAQ;IAACC,KAAA,EAAOpB,eAAA;cAAgBV;;AAClD;AAEA,OAAO,MAAM+B,sBAAA,GAAyBA,CAAA;EACpC,MAAAC,OAAA,GAAgB9C,UAAA,CAAAS,OAAW;EAAA,IACvBqC,OAAA,KAAAC,SAAY;IAAA,UAAAC,KAAA,CACE;EAAA;EAAA,OAEXF,OAAA;AAAA,CACT","ignoreList":[]}

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

@@ -1,8 +1,8 @@
 'use client';
+
 import { LexicalEditorTheme } from '../../theme/EditorTheme.js';
 export const defaultEditorLexicalConfig = {
-    namespace: 'lexical',
-    theme: LexicalEditorTheme
+  namespace: 'lexical',
+  theme: LexicalEditorTheme
 };
-
 //# sourceMappingURL=default.js.map

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/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"],"mappings":"AAAA;AAGA,SAASA,kBAAkB,QAAQ,6BAA4B;AAE/D,OAAO,MAAMC,6BAAkD;IAC7DC,WAAW;IACXC,OAAOH;AACT,EAAC"}
+{"version":3,"file":"default.js","names":["LexicalEditorTheme","defaultEditorLexicalConfig","namespace","theme"],"sources":["../../../../src/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"],"mappings":"AAAA;;AAGA,SAASA,kBAAkB,QAAQ;AAEnC,OAAO,MAAMC,0BAAA,GAAkD;EAC7DC,SAAA,EAAW;EACXC,KAAA,EAAOH;AACT","ignoreList":[]}

package/dist/lexical/config/client/loader.d.ts

@@ -1,11 +1,14 @@
+import type { RichTextFieldClient } from 'payload';
 import type { ResolvedClientFeatureMap } from '../../../features/typesClient.js';
+import type { FeatureClientSchemaMap } from '../../../types.js';
 import type { ClientEditorConfig } from '../types.js';
 /**
  * This function expects client functions to ALREADY be ordered & dependencies checked on the server
  * @param unSanitizedEditorConfig
  */
-export declare function loadClientFeatures({ clientFunctions, schemaPath, unSanitizedEditorConfig, }: {
-    clientFunctions?: Record<string, any>;
+export declare function loadClientFeatures({ featureClientSchemaMap, field, schemaPath, unSanitizedEditorConfig, }: {
+    featureClientSchemaMap: FeatureClientSchemaMap;
+    field?: RichTextFieldClient;
     schemaPath: string;
     unSanitizedEditorConfig: ClientEditorConfig;
 }): ResolvedClientFeatureMap;

package/dist/lexical/config/client/loader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../../../../src/lexical/config/client/loader.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAGV,wBAAwB,EACzB,MAAM,kCAAkC,CAAA;AACzC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AAErD;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,EACjC,eAAe,EACf,UAAU,EACV,uBAAuB,GACxB,EAAE;IACD,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;IACrC,UAAU,EAAE,MAAM,CAAA;IAClB,uBAAuB,EAAE,kBAAkB,CAAA;CAC5C,GAAG,wBAAwB,CAmE3B"}
+{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../../../../src/lexical/config/client/loader.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAA;AAElD,OAAO,KAAK,EAGV,wBAAwB,EACzB,MAAM,kCAAkC,CAAA;AACzC,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAA;AAC/D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AAErD;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,EACjC,sBAAsB,EACtB,KAAK,EACL,UAAU,EACV,uBAAuB,GACxB,EAAE;IACD,sBAAsB,EAAE,sBAAsB,CAAA;IAC9C,KAAK,CAAC,EAAE,mBAAmB,CAAA;IAC3B,UAAU,EAAE,MAAM,CAAA;IAClB,uBAAuB,EAAE,kBAAkB,CAAA;CAC5C,GAAG,wBAAwB,CAoD3B"}

package/dist/lexical/config/client/loader.js

@@ -1,46 +1,43 @@
 'use client';
+
 /**
  * This function expects client functions to ALREADY be ordered & dependencies checked on the server
  * @param unSanitizedEditorConfig
- */ export function loadClientFeatures({ clientFunctions, schemaPath, unSanitizedEditorConfig }) {
-    for (const featureProvider of unSanitizedEditorConfig.features){
-        if (!featureProvider?.clientFeatureProps?.featureKey || featureProvider?.clientFeatureProps?.order === undefined || featureProvider?.clientFeatureProps?.order === null) {
-            throw new Error('A Feature you have installed does not return the client props as clientFeatureProps. Please make sure to always return those props, even if they are null, as other important props like order and featureKey are later on injected.');
-        }
-    }
-    // sort unSanitizedEditorConfig.features by order
-    unSanitizedEditorConfig.features = unSanitizedEditorConfig.features.sort((a, b)=>a.clientFeatureProps.order - b.clientFeatureProps.order);
-    const featureProviderMap = new Map(unSanitizedEditorConfig.features.map((f)=>[
-            f.clientFeatureProps.featureKey,
-            f
-        ]));
-    const resolvedFeatures = new Map();
-    // Make sure all dependencies declared in the respective features exist
-    let loaded = 0;
-    for (const featureProvider of unSanitizedEditorConfig.features){
-        /**
-     * Load relevant clientFunctions scoped to this feature and then pass them to the client feature
-     */ const relevantClientFunctions = {};
-        Object.entries(clientFunctions).forEach(([key, plugin])=>{
-            if (key.startsWith(`lexicalFeature.${schemaPath}.${featureProvider.clientFeatureProps.featureKey}.components.`)) {
-                const featureComponentKey = key.split(`${schemaPath}.${featureProvider.clientFeatureProps.featureKey}.components.`)[1];
-                relevantClientFunctions[featureComponentKey] = plugin;
-            }
-        });
-        const feature = typeof featureProvider.feature === 'function' ? featureProvider.feature({
-            clientFunctions: relevantClientFunctions,
-            featureProviderMap,
-            resolvedFeatures,
-            unSanitizedEditorConfig
-        }) : featureProvider.feature;
-        resolvedFeatures.set(featureProvider.clientFeatureProps.featureKey, {
-            ...feature,
-            key: featureProvider.clientFeatureProps.featureKey,
-            order: loaded
-        });
-        loaded++;
+ */
+export function loadClientFeatures({
+  featureClientSchemaMap,
+  field,
+  schemaPath,
+  unSanitizedEditorConfig
+}) {
+  for (const featureProvider of unSanitizedEditorConfig.features) {
+    if (!featureProvider?.clientFeatureProps?.featureKey || featureProvider?.clientFeatureProps?.order === undefined || featureProvider?.clientFeatureProps?.order === null) {
+      throw new Error('A Feature you have installed does not return the client props as clientFeatureProps. Please make sure to always return those props, even if they are null, as other important props like order and featureKey are later on injected.');
     }
-    return resolvedFeatures;
+  }
+  // sort unSanitizedEditorConfig.features by order
+  unSanitizedEditorConfig.features = unSanitizedEditorConfig.features.sort((a, b) => a.clientFeatureProps.order - b.clientFeatureProps.order);
+  const featureProviderMap = new Map();
+  for (const feature of unSanitizedEditorConfig.features) {
+    featureProviderMap.set(feature.clientFeatureProps.featureKey, feature);
+  }
+  const resolvedFeatures = new Map();
+  // Make sure all dependencies declared in the respective features exist
+  let loaded = 0;
+  for (const featureProvider of unSanitizedEditorConfig.features) {
+    const feature = typeof featureProvider.feature === 'function' ? featureProvider.feature({
+      featureClientSchemaMap,
+      featureProviderMap,
+      field,
+      resolvedFeatures,
+      schemaPath,
+      unSanitizedEditorConfig
+    }) : featureProvider.feature;
+    feature.key = featureProvider.clientFeatureProps.featureKey;
+    feature.order = loaded;
+    resolvedFeatures.set(featureProvider.clientFeatureProps.featureKey, feature);
+    loaded++;
+  }
+  return resolvedFeatures;
 }
-
 //# sourceMappingURL=loader.js.map