@payloadcms/richtext-lexical 3.68.0-internal-debug.56c9b68 → 3.68.0-internal-debug.185cc5f

package/dist/features/migrations/lexicalPluginToLexical/converter/converters/unknown/converter.js

@@ -1,28 +1,27 @@
 import { convertLexicalPluginNodesToLexical } from '../../index.js';
 export const UnknownConverter = {
-  converter({
-    converters,
-    lexicalPluginNode,
-    quiet
-  }) {
-    return {
-      type: 'unknownConverted',
-      children: convertLexicalPluginNodesToLexical({
-        converters,
-        lexicalPluginNodes: lexicalPluginNode.children,
-        parentNodeType: 'unknownConverted',
-        quiet
-      }),
-      data: {
-        nodeData: lexicalPluginNode,
-        nodeType: lexicalPluginNode.type
-      },
-      direction: 'ltr',
-      format: '',
-      indent: 0,
-      version: 1
-    };
-  },
-  nodeTypes: ['unknown']
+    converter ({ converters, lexicalPluginNode, quiet }) {
+        return {
+            type: 'unknownConverted',
+            children: convertLexicalPluginNodesToLexical({
+                converters,
+                lexicalPluginNodes: lexicalPluginNode.children,
+                parentNodeType: 'unknownConverted',
+                quiet
+            }),
+            data: {
+                nodeData: lexicalPluginNode,
+                nodeType: lexicalPluginNode.type
+            },
+            direction: 'ltr',
+            format: '',
+            indent: 0,
+            version: 1
+        };
+    },
+    nodeTypes: [
+        'unknown'
+    ]
 };
+
 //# sourceMappingURL=converter.js.map

package/dist/features/migrations/lexicalPluginToLexical/converter/converters/unknown/converter.js.map

@@ -1 +1 @@
-{"version":3,"file":"converter.js","names":["convertLexicalPluginNodesToLexical","UnknownConverter","converter","converters","lexicalPluginNode","quiet","type","children","lexicalPluginNodes","parentNodeType","data","nodeData","nodeType","direction","format","indent","version","nodeTypes"],"sources":["../../../../../../../src/features/migrations/lexicalPluginToLexical/converter/converters/unknown/converter.ts"],"sourcesContent":["import type { SerializedUnknownConvertedNode } from '../../../nodes/unknownConvertedNode/index.js'\nimport type { LexicalPluginNodeConverter } from '../../types.js'\n\nimport { convertLexicalPluginNodesToLexical } from '../../index.js'\n\nexport const UnknownConverter: LexicalPluginNodeConverter = {\n  converter({ converters, lexicalPluginNode, quiet }) {\n    return {\n      type: 'unknownConverted',\n      children: convertLexicalPluginNodesToLexical({\n        converters,\n        lexicalPluginNodes: lexicalPluginNode.children,\n        parentNodeType: 'unknownConverted',\n        quiet,\n      }),\n      data: {\n        nodeData: lexicalPluginNode,\n        nodeType: lexicalPluginNode.type,\n      },\n      direction: 'ltr',\n      format: '',\n      indent: 0,\n      version: 1,\n    } as const as SerializedUnknownConvertedNode\n  },\n  nodeTypes: ['unknown'],\n}\n"],"mappings":"AAGA,SAASA,kCAAkC,QAAQ;AAEnD,OAAO,MAAMC,gBAAA,GAA+C;EAC1DC,UAAU;IAAEC,UAAU;IAAEC,iBAAiB;IAAEC;EAAK,CAAE;IAChD,OAAO;MACLC,IAAA,EAAM;MACNC,QAAA,EAAUP,kCAAA,CAAmC;QAC3CG,UAAA;QACAK,kBAAA,EAAoBJ,iBAAA,CAAkBG,QAAQ;QAC9CE,cAAA,EAAgB;QAChBJ;MACF;MACAK,IAAA,EAAM;QACJC,QAAA,EAAUP,iBAAA;QACVQ,QAAA,EAAUR,iBAAA,CAAkBE;MAC9B;MACAO,SAAA,EAAW;MACXC,MAAA,EAAQ;MACRC,MAAA,EAAQ;MACRC,OAAA,EAAS;IACX;EACF;EACAC,SAAA,EAAW,CAAC;AACd","ignoreList":[]}
+{"version":3,"sources":["../../../../../../../src/features/migrations/lexicalPluginToLexical/converter/converters/unknown/converter.ts"],"sourcesContent":["import type { SerializedUnknownConvertedNode } from '../../../nodes/unknownConvertedNode/index.js'\nimport type { LexicalPluginNodeConverter } from '../../types.js'\n\nimport { convertLexicalPluginNodesToLexical } from '../../index.js'\n\nexport const UnknownConverter: LexicalPluginNodeConverter = {\n  converter({ converters, lexicalPluginNode, quiet }) {\n    return {\n      type: 'unknownConverted',\n      children: convertLexicalPluginNodesToLexical({\n        converters,\n        lexicalPluginNodes: lexicalPluginNode.children,\n        parentNodeType: 'unknownConverted',\n        quiet,\n      }),\n      data: {\n        nodeData: lexicalPluginNode,\n        nodeType: lexicalPluginNode.type,\n      },\n      direction: 'ltr',\n      format: '',\n      indent: 0,\n      version: 1,\n    } as const as SerializedUnknownConvertedNode\n  },\n  nodeTypes: ['unknown'],\n}\n"],"names":["convertLexicalPluginNodesToLexical","UnknownConverter","converter","converters","lexicalPluginNode","quiet","type","children","lexicalPluginNodes","parentNodeType","data","nodeData","nodeType","direction","format","indent","version","nodeTypes"],"mappings":"AAGA,SAASA,kCAAkC,QAAQ,iBAAgB;AAEnE,OAAO,MAAMC,mBAA+C;IAC1DC,WAAU,EAAEC,UAAU,EAAEC,iBAAiB,EAAEC,KAAK,EAAE;QAChD,OAAO;YACLC,MAAM;YACNC,UAAUP,mCAAmC;gBAC3CG;gBACAK,oBAAoBJ,kBAAkBG,QAAQ;gBAC9CE,gBAAgB;gBAChBJ;YACF;YACAK,MAAM;gBACJC,UAAUP;gBACVQ,UAAUR,kBAAkBE,IAAI;YAClC;YACAO,WAAW;YACXC,QAAQ;YACRC,QAAQ;YACRC,SAAS;QACX;IACF;IACAC,WAAW;QAAC;KAAU;AACxB,EAAC"}

package/dist/features/migrations/lexicalPluginToLexical/converter/converters/upload/converter.js

@@ -1,22 +1,23 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */export const UploadConverter = {
-  converter({
-    lexicalPluginNode
-  }) {
-    let fields = {};
-    if (lexicalPluginNode?.caption?.editorState) {
-      fields = {
-        caption: lexicalPluginNode?.caption
-      };
-    }
-    return {
-      type: 'upload',
-      fields,
-      format: lexicalPluginNode?.format || '',
-      relationTo: lexicalPluginNode?.rawImagePayload?.relationTo,
-      value: lexicalPluginNode?.rawImagePayload?.value?.id || '',
-      version: 2
-    };
-  },
-  nodeTypes: ['upload']
+/* eslint-disable @typescript-eslint/no-explicit-any */ export const UploadConverter = {
+    converter ({ lexicalPluginNode }) {
+        let fields = {};
+        if (lexicalPluginNode?.caption?.editorState) {
+            fields = {
+                caption: lexicalPluginNode?.caption
+            };
+        }
+        return {
+            type: 'upload',
+            fields,
+            format: lexicalPluginNode?.format || '',
+            relationTo: lexicalPluginNode?.rawImagePayload?.relationTo,
+            value: lexicalPluginNode?.rawImagePayload?.value?.id || '',
+            version: 2
+        };
+    },
+    nodeTypes: [
+        'upload'
+    ]
 };
+
 //# sourceMappingURL=converter.js.map

package/dist/features/migrations/lexicalPluginToLexical/converter/converters/upload/converter.js.map

@@ -1 +1 @@
-{"version":3,"file":"converter.js","names":["UploadConverter","converter","lexicalPluginNode","fields","caption","editorState","type","format","relationTo","rawImagePayload","value","id","version","nodeTypes"],"sources":["../../../../../../../src/features/migrations/lexicalPluginToLexical/converter/converters/upload/converter.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\n\nimport type { SerializedUploadNode } from '../../../../../upload/server/nodes/UploadNode.js'\nimport type { LexicalPluginNodeConverter } from '../../types.js'\n\nexport const UploadConverter: LexicalPluginNodeConverter = {\n  converter({ lexicalPluginNode }) {\n    let fields = {}\n    if ((lexicalPluginNode as any)?.caption?.editorState) {\n      fields = {\n        caption: (lexicalPluginNode as any)?.caption,\n      }\n    }\n    return {\n      type: 'upload',\n      fields,\n      format: (lexicalPluginNode as any)?.format || '',\n      relationTo: (lexicalPluginNode as any)?.rawImagePayload?.relationTo,\n      value: (lexicalPluginNode as any)?.rawImagePayload?.value?.id || '',\n      version: 2,\n    } as const as SerializedUploadNode\n  },\n  nodeTypes: ['upload'],\n}\n"],"mappings":"AAAA,uDAKA,OAAO,MAAMA,eAAA,GAA8C;EACzDC,UAAU;IAAEC;EAAiB,CAAE;IAC7B,IAAIC,MAAA,GAAS,CAAC;IACd,IAAKD,iBAAA,EAA2BE,OAAA,EAASC,WAAA,EAAa;MACpDF,MAAA,GAAS;QACPC,OAAA,EAAUF,iBAAA,EAA2BE;MACvC;IACF;IACA,OAAO;MACLE,IAAA,EAAM;MACNH,MAAA;MACAI,MAAA,EAAQL,iBAAC,EAA2BK,MAAA,IAAU;MAC9CC,UAAA,EAAaN,iBAAA,EAA2BO,eAAA,EAAiBD,UAAA;MACzDE,KAAA,EAAOR,iBAAC,EAA2BO,eAAA,EAAiBC,KAAA,EAAOC,EAAA,IAAM;MACjEC,OAAA,EAAS;IACX;EACF;EACAC,SAAA,EAAW,CAAC;AACd","ignoreList":[]}
+{"version":3,"sources":["../../../../../../../src/features/migrations/lexicalPluginToLexical/converter/converters/upload/converter.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\n\nimport type { SerializedUploadNode } from '../../../../../upload/server/nodes/UploadNode.js'\nimport type { LexicalPluginNodeConverter } from '../../types.js'\n\nexport const UploadConverter: LexicalPluginNodeConverter = {\n  converter({ lexicalPluginNode }) {\n    let fields = {}\n    if ((lexicalPluginNode as any)?.caption?.editorState) {\n      fields = {\n        caption: (lexicalPluginNode as any)?.caption,\n      }\n    }\n    return {\n      type: 'upload',\n      fields,\n      format: (lexicalPluginNode as any)?.format || '',\n      relationTo: (lexicalPluginNode as any)?.rawImagePayload?.relationTo,\n      value: (lexicalPluginNode as any)?.rawImagePayload?.value?.id || '',\n      version: 2,\n    } as const as SerializedUploadNode\n  },\n  nodeTypes: ['upload'],\n}\n"],"names":["UploadConverter","converter","lexicalPluginNode","fields","caption","editorState","type","format","relationTo","rawImagePayload","value","id","version","nodeTypes"],"mappings":"AAAA,qDAAqD,GAKrD,OAAO,MAAMA,kBAA8C;IACzDC,WAAU,EAAEC,iBAAiB,EAAE;QAC7B,IAAIC,SAAS,CAAC;QACd,IAAKD,mBAA2BE,SAASC,aAAa;YACpDF,SAAS;gBACPC,SAAUF,mBAA2BE;YACvC;QACF;QACA,OAAO;YACLE,MAAM;YACNH;YACAI,QAAQ,AAACL,mBAA2BK,UAAU;YAC9CC,YAAaN,mBAA2BO,iBAAiBD;YACzDE,OAAO,AAACR,mBAA2BO,iBAAiBC,OAAOC,MAAM;YACjEC,SAAS;QACX;IACF;IACAC,WAAW;QAAC;KAAS;AACvB,EAAC"}

package/dist/features/migrations/lexicalPluginToLexical/converter/defaultConverters.js

@@ -5,5 +5,14 @@ import { ListItemConverter } from './converters/listItem/converter.js';
 import { QuoteConverter } from './converters/quote/converter.js';
 import { UnknownConverter } from './converters/unknown/converter.js';
 import { UploadConverter } from './converters/upload/converter.js';
-export const defaultConverters = [HeadingConverter, LinkConverter, ListConverter, ListItemConverter, QuoteConverter, UnknownConverter, UploadConverter];
+export const defaultConverters = [
+    HeadingConverter,
+    LinkConverter,
+    ListConverter,
+    ListItemConverter,
+    QuoteConverter,
+    UnknownConverter,
+    UploadConverter
+];
+
 //# sourceMappingURL=defaultConverters.js.map

package/dist/features/migrations/lexicalPluginToLexical/converter/defaultConverters.js.map

@@ -1 +1 @@
-{"version":3,"file":"defaultConverters.js","names":["HeadingConverter","LinkConverter","ListConverter","ListItemConverter","QuoteConverter","UnknownConverter","UploadConverter","defaultConverters"],"sources":["../../../../../src/features/migrations/lexicalPluginToLexical/converter/defaultConverters.ts"],"sourcesContent":["import type { LexicalPluginNodeConverter } from './types.js'\n\nimport { HeadingConverter } from './converters/heading/converter.js'\nimport { LinkConverter } from './converters/link/converter.js'\nimport { ListConverter } from './converters/list/converter.js'\nimport { ListItemConverter } from './converters/listItem/converter.js'\nimport { QuoteConverter } from './converters/quote/converter.js'\nimport { UnknownConverter } from './converters/unknown/converter.js'\nimport { UploadConverter } from './converters/upload/converter.js'\n\nexport const defaultConverters: LexicalPluginNodeConverter[] = [\n  HeadingConverter,\n  LinkConverter,\n  ListConverter,\n  ListItemConverter,\n  QuoteConverter,\n  UnknownConverter,\n  UploadConverter,\n]\n"],"mappings":"AAEA,SAASA,gBAAgB,QAAQ;AACjC,SAASC,aAAa,QAAQ;AAC9B,SAASC,aAAa,QAAQ;AAC9B,SAASC,iBAAiB,QAAQ;AAClC,SAASC,cAAc,QAAQ;AAC/B,SAASC,gBAAgB,QAAQ;AACjC,SAASC,eAAe,QAAQ;AAEhC,OAAO,MAAMC,iBAAA,GAAkD,CAC7DP,gBAAA,EACAC,aAAA,EACAC,aAAA,EACAC,iBAAA,EACAC,cAAA,EACAC,gBAAA,EACAC,eAAA,CACD","ignoreList":[]}
+{"version":3,"sources":["../../../../../src/features/migrations/lexicalPluginToLexical/converter/defaultConverters.ts"],"sourcesContent":["import type { LexicalPluginNodeConverter } from './types.js'\n\nimport { HeadingConverter } from './converters/heading/converter.js'\nimport { LinkConverter } from './converters/link/converter.js'\nimport { ListConverter } from './converters/list/converter.js'\nimport { ListItemConverter } from './converters/listItem/converter.js'\nimport { QuoteConverter } from './converters/quote/converter.js'\nimport { UnknownConverter } from './converters/unknown/converter.js'\nimport { UploadConverter } from './converters/upload/converter.js'\n\nexport const defaultConverters: LexicalPluginNodeConverter[] = [\n  HeadingConverter,\n  LinkConverter,\n  ListConverter,\n  ListItemConverter,\n  QuoteConverter,\n  UnknownConverter,\n  UploadConverter,\n]\n"],"names":["HeadingConverter","LinkConverter","ListConverter","ListItemConverter","QuoteConverter","UnknownConverter","UploadConverter","defaultConverters"],"mappings":"AAEA,SAASA,gBAAgB,QAAQ,oCAAmC;AACpE,SAASC,aAAa,QAAQ,iCAAgC;AAC9D,SAASC,aAAa,QAAQ,iCAAgC;AAC9D,SAASC,iBAAiB,QAAQ,qCAAoC;AACtE,SAASC,cAAc,QAAQ,kCAAiC;AAChE,SAASC,gBAAgB,QAAQ,oCAAmC;AACpE,SAASC,eAAe,QAAQ,mCAAkC;AAElE,OAAO,MAAMC,oBAAkD;IAC7DP;IACAC;IACAC;IACAC;IACAC;IACAC;IACAC;CACD,CAAA"}

package/dist/features/migrations/lexicalPluginToLexical/converter/index.js

@@ -1,78 +1,72 @@
-export function convertLexicalPluginToLexical({
-  converters,
-  lexicalPluginData,
-  quiet
-}) {
-  return {
-    root: {
-      type: 'root',
-      children: convertLexicalPluginNodesToLexical({
-        converters,
-        lexicalPluginNodes: lexicalPluginData?.jsonContent?.root?.children || [],
-        parentNodeType: 'root',
-        quiet
-      }),
-      direction: lexicalPluginData?.jsonContent?.root?.direction || 'ltr',
-      format: lexicalPluginData?.jsonContent?.root?.format || '',
-      indent: lexicalPluginData?.jsonContent?.root?.indent || 0,
-      version: 1
-    }
-  };
+export function convertLexicalPluginToLexical({ converters, lexicalPluginData, quiet }) {
+    return {
+        root: {
+            type: 'root',
+            children: convertLexicalPluginNodesToLexical({
+                converters,
+                lexicalPluginNodes: lexicalPluginData?.jsonContent?.root?.children || [],
+                parentNodeType: 'root',
+                quiet
+            }),
+            direction: lexicalPluginData?.jsonContent?.root?.direction || 'ltr',
+            format: lexicalPluginData?.jsonContent?.root?.format || '',
+            indent: lexicalPluginData?.jsonContent?.root?.indent || 0,
+            version: 1
+        }
+    };
 }
-export function convertLexicalPluginNodesToLexical({
-  converters,
-  lexicalPluginNodes,
-  parentNodeType,
-  quiet
-}) {
-  if (!lexicalPluginNodes?.length || !converters?.length) {
-    return [];
-  }
-  const unknownConverter = converters.find(converter => converter.nodeTypes.includes('unknown'));
-  // @ts-expect-error - vestiges of the migration to strict mode. Probably not important enough in this file to fix
-  return lexicalPluginNodes.map((lexicalPluginNode, i) => {
-    if (lexicalPluginNode.type === 'paragraph') {
-      return convertParagraphNode(converters, lexicalPluginNode, quiet);
-    }
-    if (lexicalPluginNode.type === 'text' || !lexicalPluginNode.type) {
-      return convertTextNode(lexicalPluginNode);
-    }
-    const converter = converters.find(converter => converter.nodeTypes.includes(lexicalPluginNode.type));
-    if (converter) {
-      return converter.converter({
-        childIndex: i,
-        converters,
-        lexicalPluginNode,
-        parentNodeType,
-        quiet
-      });
-    }
-    if (!quiet) {
-      console.warn('lexicalPluginToLexical > No converter found for node type: ' + lexicalPluginNode.type);
+export function convertLexicalPluginNodesToLexical({ converters, lexicalPluginNodes, parentNodeType, quiet }) /**
+   * Type of the parent lexical node (not the type of the original, parent payload-plugin-lexical type)
+   */ {
+    if (!lexicalPluginNodes?.length || !converters?.length) {
+        return [];
     }
-    return unknownConverter?.converter({
-      childIndex: i,
-      converters,
-      lexicalPluginNode,
-      parentNodeType,
-      quiet
-    });
-  }) || [];
+    const unknownConverter = converters.find((converter)=>converter.nodeTypes.includes('unknown'));
+    // @ts-expect-error - vestiges of the migration to strict mode. Probably not important enough in this file to fix
+    return lexicalPluginNodes.map((lexicalPluginNode, i)=>{
+        if (lexicalPluginNode.type === 'paragraph') {
+            return convertParagraphNode(converters, lexicalPluginNode, quiet);
+        }
+        if (lexicalPluginNode.type === 'text' || !lexicalPluginNode.type) {
+            return convertTextNode(lexicalPluginNode);
+        }
+        const converter = converters.find((converter)=>converter.nodeTypes.includes(lexicalPluginNode.type));
+        if (converter) {
+            return converter.converter({
+                childIndex: i,
+                converters,
+                lexicalPluginNode,
+                parentNodeType,
+                quiet
+            });
+        }
+        if (!quiet) {
+            console.warn('lexicalPluginToLexical > No converter found for node type: ' + lexicalPluginNode.type);
+        }
+        return unknownConverter?.converter({
+            childIndex: i,
+            converters,
+            lexicalPluginNode,
+            parentNodeType,
+            quiet
+        });
+    }) || [];
 }
 export function convertParagraphNode(converters, node, quiet) {
-  return {
-    ...node,
-    type: 'paragraph',
-    children: convertLexicalPluginNodesToLexical({
-      converters,
-      lexicalPluginNodes: node.children || [],
-      parentNodeType: 'paragraph',
-      quiet
-    }),
-    version: 1
-  };
+    return {
+        ...node,
+        type: 'paragraph',
+        children: convertLexicalPluginNodesToLexical({
+            converters,
+            lexicalPluginNodes: node.children || [],
+            parentNodeType: 'paragraph',
+            quiet
+        }),
+        version: 1
+    };
 }
 export function convertTextNode(node) {
-  return node;
+    return node;
 }
+
 //# sourceMappingURL=index.js.map

package/dist/features/migrations/lexicalPluginToLexical/converter/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["convertLexicalPluginToLexical","converters","lexicalPluginData","quiet","root","type","children","convertLexicalPluginNodesToLexical","lexicalPluginNodes","jsonContent","parentNodeType","direction","format","indent","version","length","unknownConverter","find","converter","nodeTypes","includes","map","lexicalPluginNode","i","convertParagraphNode","convertTextNode","childIndex","console","warn","node"],"sources":["../../../../../src/features/migrations/lexicalPluginToLexical/converter/index.ts"],"sourcesContent":["import type {\n  SerializedEditorState,\n  SerializedLexicalNode,\n  SerializedParagraphNode,\n  SerializedTextNode,\n} from 'lexical'\n\nimport type { LexicalPluginNodeConverter, PayloadPluginLexicalData } from './types.js'\n\nexport function convertLexicalPluginToLexical({\n  converters,\n  lexicalPluginData,\n  quiet,\n}: {\n  converters: LexicalPluginNodeConverter[]\n  lexicalPluginData: PayloadPluginLexicalData\n  quiet?: boolean\n}): SerializedEditorState {\n  return {\n    root: {\n      type: 'root',\n      children: convertLexicalPluginNodesToLexical({\n        converters,\n        lexicalPluginNodes: lexicalPluginData?.jsonContent?.root?.children || [],\n        parentNodeType: 'root',\n        quiet,\n      }),\n      direction: lexicalPluginData?.jsonContent?.root?.direction || 'ltr',\n      format: lexicalPluginData?.jsonContent?.root?.format || '',\n      indent: lexicalPluginData?.jsonContent?.root?.indent || 0,\n      version: 1,\n    },\n  }\n}\n\nexport function convertLexicalPluginNodesToLexical({\n  converters,\n  lexicalPluginNodes,\n  parentNodeType,\n  quiet,\n}: {\n  converters: LexicalPluginNodeConverter[]\n  lexicalPluginNodes: SerializedLexicalNode[] | undefined\n  /**\n   * Type of the parent lexical node (not the type of the original, parent payload-plugin-lexical type)\n   */\n  parentNodeType: string\n  quiet?: boolean\n}): SerializedLexicalNode[] {\n  if (!lexicalPluginNodes?.length || !converters?.length) {\n    return []\n  }\n  const unknownConverter = converters.find((converter) => converter.nodeTypes.includes('unknown'))\n  // @ts-expect-error - vestiges of the migration to strict mode. Probably not important enough in this file to fix\n  return (\n    lexicalPluginNodes.map((lexicalPluginNode, i) => {\n      if (lexicalPluginNode.type === 'paragraph') {\n        return convertParagraphNode(converters, lexicalPluginNode, quiet)\n      }\n      if (lexicalPluginNode.type === 'text' || !lexicalPluginNode.type) {\n        return convertTextNode(lexicalPluginNode)\n      }\n\n      const converter = converters.find((converter) =>\n        converter.nodeTypes.includes(lexicalPluginNode.type),\n      )\n\n      if (converter) {\n        return converter.converter({\n          childIndex: i,\n          converters,\n          lexicalPluginNode,\n          parentNodeType,\n          quiet,\n        })\n      }\n\n      if (!quiet) {\n        console.warn(\n          'lexicalPluginToLexical > No converter found for node type: ' + lexicalPluginNode.type,\n        )\n      }\n\n      return unknownConverter?.converter({\n        childIndex: i,\n        converters,\n        lexicalPluginNode,\n        parentNodeType,\n        quiet,\n      })\n    }) || []\n  )\n}\n\nexport function convertParagraphNode(\n  converters: LexicalPluginNodeConverter[],\n  node: SerializedLexicalNode,\n  quiet?: boolean,\n): SerializedParagraphNode {\n  return {\n    ...node,\n    type: 'paragraph',\n\n    children: convertLexicalPluginNodesToLexical({\n      converters,\n      lexicalPluginNodes: (node as any).children || [],\n      parentNodeType: 'paragraph',\n      quiet,\n    }),\n    version: 1,\n  } as SerializedParagraphNode\n}\nexport function convertTextNode(node: SerializedLexicalNode): SerializedTextNode {\n  return node as SerializedTextNode\n}\n"],"mappings":"AASA,OAAO,SAASA,8BAA8B;EAC5CC,UAAU;EACVC,iBAAiB;EACjBC;AAAK,CAKN;EACC,OAAO;IACLC,IAAA,EAAM;MACJC,IAAA,EAAM;MACNC,QAAA,EAAUC,kCAAA,CAAmC;QAC3CN,UAAA;QACAO,kBAAA,EAAoBN,iBAAA,EAAmBO,WAAA,EAAaL,IAAA,EAAME,QAAA,IAAY,EAAE;QACxEI,cAAA,EAAgB;QAChBP;MACF;MACAQ,SAAA,EAAWT,iBAAA,EAAmBO,WAAA,EAAaL,IAAA,EAAMO,SAAA,IAAa;MAC9DC,MAAA,EAAQV,iBAAA,EAAmBO,WAAA,EAAaL,IAAA,EAAMQ,MAAA,IAAU;MACxDC,MAAA,EAAQX,iBAAA,EAAmBO,WAAA,EAAaL,IAAA,EAAMS,MAAA,IAAU;MACxDC,OAAA,EAAS;IACX;EACF;AACF;AAEA,OAAO,SAASP,mCAAmC;EACjDN,UAAU;EACVO,kBAAkB;EAClBE,cAAc;EACdP;AAAK,CASN;EACC,IAAI,CAACK,kBAAA,EAAoBO,MAAA,IAAU,CAACd,UAAA,EAAYc,MAAA,EAAQ;IACtD,OAAO,EAAE;EACX;EACA,MAAMC,gBAAA,GAAmBf,UAAA,CAAWgB,IAAI,CAAEC,SAAA,IAAcA,SAAA,CAAUC,SAAS,CAACC,QAAQ,CAAC;EACrF;EACA,OACEZ,kBAAA,CAAmBa,GAAG,CAAC,CAACC,iBAAA,EAAmBC,CAAA;IACzC,IAAID,iBAAA,CAAkBjB,IAAI,KAAK,aAAa;MAC1C,OAAOmB,oBAAA,CAAqBvB,UAAA,EAAYqB,iBAAA,EAAmBnB,KAAA;IAC7D;IACA,IAAImB,iBAAA,CAAkBjB,IAAI,KAAK,UAAU,CAACiB,iBAAA,CAAkBjB,IAAI,EAAE;MAChE,OAAOoB,eAAA,CAAgBH,iBAAA;IACzB;IAEA,MAAMJ,SAAA,GAAYjB,UAAA,CAAWgB,IAAI,CAAEC,SAAA,IACjCA,SAAA,CAAUC,SAAS,CAACC,QAAQ,CAACE,iBAAA,CAAkBjB,IAAI;IAGrD,IAAIa,SAAA,EAAW;MACb,OAAOA,SAAA,CAAUA,SAAS,CAAC;QACzBQ,UAAA,EAAYH,CAAA;QACZtB,UAAA;QACAqB,iBAAA;QACAZ,cAAA;QACAP;MACF;IACF;IAEA,IAAI,CAACA,KAAA,EAAO;MACVwB,OAAA,CAAQC,IAAI,CACV,gEAAgEN,iBAAA,CAAkBjB,IAAI;IAE1F;IAEA,OAAOW,gBAAA,EAAkBE,SAAA,CAAU;MACjCQ,UAAA,EAAYH,CAAA;MACZtB,UAAA;MACAqB,iBAAA;MACAZ,cAAA;MACAP;IACF;EACF,MAAM,EAAE;AAEZ;AAEA,OAAO,SAASqB,qBACdvB,UAAwC,EACxC4B,IAA2B,EAC3B1B,KAAe;EAEf,OAAO;IACL,GAAG0B,IAAI;IACPxB,IAAA,EAAM;IAENC,QAAA,EAAUC,kCAAA,CAAmC;MAC3CN,UAAA;MACAO,kBAAA,EAAoBqB,IAAC,CAAavB,QAAQ,IAAI,EAAE;MAChDI,cAAA,EAAgB;MAChBP;IACF;IACAW,OAAA,EAAS;EACX;AACF;AACA,OAAO,SAASW,gBAAgBI,IAA2B;EACzD,OAAOA,IAAA;AACT","ignoreList":[]}
+{"version":3,"sources":["../../../../../src/features/migrations/lexicalPluginToLexical/converter/index.ts"],"sourcesContent":["import type {\n  SerializedEditorState,\n  SerializedLexicalNode,\n  SerializedParagraphNode,\n  SerializedTextNode,\n} from 'lexical'\n\nimport type { LexicalPluginNodeConverter, PayloadPluginLexicalData } from './types.js'\n\nexport function convertLexicalPluginToLexical({\n  converters,\n  lexicalPluginData,\n  quiet,\n}: {\n  converters: LexicalPluginNodeConverter[]\n  lexicalPluginData: PayloadPluginLexicalData\n  quiet?: boolean\n}): SerializedEditorState {\n  return {\n    root: {\n      type: 'root',\n      children: convertLexicalPluginNodesToLexical({\n        converters,\n        lexicalPluginNodes: lexicalPluginData?.jsonContent?.root?.children || [],\n        parentNodeType: 'root',\n        quiet,\n      }),\n      direction: lexicalPluginData?.jsonContent?.root?.direction || 'ltr',\n      format: lexicalPluginData?.jsonContent?.root?.format || '',\n      indent: lexicalPluginData?.jsonContent?.root?.indent || 0,\n      version: 1,\n    },\n  }\n}\n\nexport function convertLexicalPluginNodesToLexical({\n  converters,\n  lexicalPluginNodes,\n  parentNodeType,\n  quiet,\n}: {\n  converters: LexicalPluginNodeConverter[]\n  lexicalPluginNodes: SerializedLexicalNode[] | undefined\n  /**\n   * Type of the parent lexical node (not the type of the original, parent payload-plugin-lexical type)\n   */\n  parentNodeType: string\n  quiet?: boolean\n}): SerializedLexicalNode[] {\n  if (!lexicalPluginNodes?.length || !converters?.length) {\n    return []\n  }\n  const unknownConverter = converters.find((converter) => converter.nodeTypes.includes('unknown'))\n  // @ts-expect-error - vestiges of the migration to strict mode. Probably not important enough in this file to fix\n  return (\n    lexicalPluginNodes.map((lexicalPluginNode, i) => {\n      if (lexicalPluginNode.type === 'paragraph') {\n        return convertParagraphNode(converters, lexicalPluginNode, quiet)\n      }\n      if (lexicalPluginNode.type === 'text' || !lexicalPluginNode.type) {\n        return convertTextNode(lexicalPluginNode)\n      }\n\n      const converter = converters.find((converter) =>\n        converter.nodeTypes.includes(lexicalPluginNode.type),\n      )\n\n      if (converter) {\n        return converter.converter({\n          childIndex: i,\n          converters,\n          lexicalPluginNode,\n          parentNodeType,\n          quiet,\n        })\n      }\n\n      if (!quiet) {\n        console.warn(\n          'lexicalPluginToLexical > No converter found for node type: ' + lexicalPluginNode.type,\n        )\n      }\n\n      return unknownConverter?.converter({\n        childIndex: i,\n        converters,\n        lexicalPluginNode,\n        parentNodeType,\n        quiet,\n      })\n    }) || []\n  )\n}\n\nexport function convertParagraphNode(\n  converters: LexicalPluginNodeConverter[],\n  node: SerializedLexicalNode,\n  quiet?: boolean,\n): SerializedParagraphNode {\n  return {\n    ...node,\n    type: 'paragraph',\n\n    children: convertLexicalPluginNodesToLexical({\n      converters,\n      lexicalPluginNodes: (node as any).children || [],\n      parentNodeType: 'paragraph',\n      quiet,\n    }),\n    version: 1,\n  } as SerializedParagraphNode\n}\nexport function convertTextNode(node: SerializedLexicalNode): SerializedTextNode {\n  return node as SerializedTextNode\n}\n"],"names":["convertLexicalPluginToLexical","converters","lexicalPluginData","quiet","root","type","children","convertLexicalPluginNodesToLexical","lexicalPluginNodes","jsonContent","parentNodeType","direction","format","indent","version","length","unknownConverter","find","converter","nodeTypes","includes","map","lexicalPluginNode","i","convertParagraphNode","convertTextNode","childIndex","console","warn","node"],"mappings":"AASA,OAAO,SAASA,8BAA8B,EAC5CC,UAAU,EACVC,iBAAiB,EACjBC,KAAK,EAKN;IACC,OAAO;QACLC,MAAM;YACJC,MAAM;YACNC,UAAUC,mCAAmC;gBAC3CN;gBACAO,oBAAoBN,mBAAmBO,aAAaL,MAAME,YAAY,EAAE;gBACxEI,gBAAgB;gBAChBP;YACF;YACAQ,WAAWT,mBAAmBO,aAAaL,MAAMO,aAAa;YAC9DC,QAAQV,mBAAmBO,aAAaL,MAAMQ,UAAU;YACxDC,QAAQX,mBAAmBO,aAAaL,MAAMS,UAAU;YACxDC,SAAS;QACX;IACF;AACF;AAEA,OAAO,SAASP,mCAAmC,EACjDN,UAAU,EACVO,kBAAkB,EAClBE,cAAc,EACdP,KAAK,EASN,EALC;;GAEC;IAID,IAAI,CAACK,oBAAoBO,UAAU,CAACd,YAAYc,QAAQ;QACtD,OAAO,EAAE;IACX;IACA,MAAMC,mBAAmBf,WAAWgB,IAAI,CAAC,CAACC,YAAcA,UAAUC,SAAS,CAACC,QAAQ,CAAC;IACrF,iHAAiH;IACjH,OACEZ,mBAAmBa,GAAG,CAAC,CAACC,mBAAmBC;QACzC,IAAID,kBAAkBjB,IAAI,KAAK,aAAa;YAC1C,OAAOmB,qBAAqBvB,YAAYqB,mBAAmBnB;QAC7D;QACA,IAAImB,kBAAkBjB,IAAI,KAAK,UAAU,CAACiB,kBAAkBjB,IAAI,EAAE;YAChE,OAAOoB,gBAAgBH;QACzB;QAEA,MAAMJ,YAAYjB,WAAWgB,IAAI,CAAC,CAACC,YACjCA,UAAUC,SAAS,CAACC,QAAQ,CAACE,kBAAkBjB,IAAI;QAGrD,IAAIa,WAAW;YACb,OAAOA,UAAUA,SAAS,CAAC;gBACzBQ,YAAYH;gBACZtB;gBACAqB;gBACAZ;gBACAP;YACF;QACF;QAEA,IAAI,CAACA,OAAO;YACVwB,QAAQC,IAAI,CACV,gEAAgEN,kBAAkBjB,IAAI;QAE1F;QAEA,OAAOW,kBAAkBE,UAAU;YACjCQ,YAAYH;YACZtB;YACAqB;YACAZ;YACAP;QACF;IACF,MAAM,EAAE;AAEZ;AAEA,OAAO,SAASqB,qBACdvB,UAAwC,EACxC4B,IAA2B,EAC3B1B,KAAe;IAEf,OAAO;QACL,GAAG0B,IAAI;QACPxB,MAAM;QAENC,UAAUC,mCAAmC;YAC3CN;YACAO,oBAAoB,AAACqB,KAAavB,QAAQ,IAAI,EAAE;YAChDI,gBAAgB;YAChBP;QACF;QACAW,SAAS;IACX;AACF;AACA,OAAO,SAASW,gBAAgBI,IAA2B;IACzD,OAAOA;AACT"}

package/dist/features/migrations/lexicalPluginToLexical/converter/types.js

@@ -1,2 +1,3 @@
-export {};
+export { };
+
 //# sourceMappingURL=types.js.map

package/dist/features/migrations/lexicalPluginToLexical/converter/types.js.map

@@ -1 +1 @@
-{"version":3,"file":"types.js","names":[],"sources":["../../../../../src/features/migrations/lexicalPluginToLexical/converter/types.ts"],"sourcesContent":["import type { SerializedEditorState, SerializedLexicalNode } from 'lexical'\n\nexport type LexicalPluginNodeConverter<T extends SerializedLexicalNode = SerializedLexicalNode> = {\n  converter: ({\n    childIndex,\n    converters,\n    lexicalPluginNode,\n    parentNodeType,\n  }: {\n    childIndex: number\n    converters: LexicalPluginNodeConverter[]\n    lexicalPluginNode: { children?: SerializedLexicalNode[] } & SerializedLexicalNode\n    parentNodeType: string\n    quiet?: boolean\n  }) => T\n  nodeTypes: string[]\n}\n\nexport type PayloadPluginLexicalData = {\n  characters: number\n  comments: unknown[]\n  html?: string\n  jsonContent: SerializedEditorState\n  markdown?: string\n  preview: string\n  words: number\n}\n"],"mappings":"AAkBA","ignoreList":[]}
+{"version":3,"sources":["../../../../../src/features/migrations/lexicalPluginToLexical/converter/types.ts"],"sourcesContent":["import type { SerializedEditorState, SerializedLexicalNode } from 'lexical'\n\nexport type LexicalPluginNodeConverter<T extends SerializedLexicalNode = SerializedLexicalNode> = {\n  converter: ({\n    childIndex,\n    converters,\n    lexicalPluginNode,\n    parentNodeType,\n  }: {\n    childIndex: number\n    converters: LexicalPluginNodeConverter[]\n    lexicalPluginNode: { children?: SerializedLexicalNode[] } & SerializedLexicalNode\n    parentNodeType: string\n    quiet?: boolean\n  }) => T\n  nodeTypes: string[]\n}\n\nexport type PayloadPluginLexicalData = {\n  characters: number\n  comments: unknown[]\n  html?: string\n  jsonContent: SerializedEditorState\n  markdown?: string\n  preview: string\n  words: number\n}\n"],"names":[],"mappings":"AAkBA,WAQC"}

package/dist/features/migrations/lexicalPluginToLexical/feature.client.js

@@ -1,10 +1,12 @@
 'use client';
-
 import { createClientFeature } from '../../../utilities/createClientFeature.js';
 import { UnknownConvertedNode } from './nodes/unknownConvertedNode/index.js';
-export const LexicalPluginToLexicalFeatureClient = createClientFeature(() => {
-  return {
-    nodes: [UnknownConvertedNode]
-  };
+export const LexicalPluginToLexicalFeatureClient = createClientFeature(()=>{
+    return {
+        nodes: [
+            UnknownConvertedNode
+        ]
+    };
 });
+
 //# sourceMappingURL=feature.client.js.map

package/dist/features/migrations/lexicalPluginToLexical/feature.client.js.map

@@ -1 +1 @@
-{"version":3,"file":"feature.client.js","names":["createClientFeature","UnknownConvertedNode","LexicalPluginToLexicalFeatureClient","nodes"],"sources":["../../../../src/features/migrations/lexicalPluginToLexical/feature.client.tsx"],"sourcesContent":["'use client'\n\nimport { createClientFeature } from '../../../utilities/createClientFeature.js'\nimport { UnknownConvertedNode } from './nodes/unknownConvertedNode/index.js'\n\nexport const LexicalPluginToLexicalFeatureClient = createClientFeature(() => {\n  return {\n    nodes: [UnknownConvertedNode],\n  }\n})\n"],"mappings":"AAAA;;AAEA,SAASA,mBAAmB,QAAQ;AACpC,SAASC,oBAAoB,QAAQ;AAErC,OAAO,MAAMC,mCAAA,GAAsCF,mBAAA,CAAoB;EACrE,OAAO;IACLG,KAAA,EAAO,CAACF,oBAAA;EACV;AACF","ignoreList":[]}
+{"version":3,"sources":["../../../../src/features/migrations/lexicalPluginToLexical/feature.client.tsx"],"sourcesContent":["'use client'\n\nimport { createClientFeature } from '../../../utilities/createClientFeature.js'\nimport { UnknownConvertedNode } from './nodes/unknownConvertedNode/index.js'\n\nexport const LexicalPluginToLexicalFeatureClient = createClientFeature(() => {\n  return {\n    nodes: [UnknownConvertedNode],\n  }\n})\n"],"names":["createClientFeature","UnknownConvertedNode","LexicalPluginToLexicalFeatureClient","nodes"],"mappings":"AAAA;AAEA,SAASA,mBAAmB,QAAQ,4CAA2C;AAC/E,SAASC,oBAAoB,QAAQ,wCAAuC;AAE5E,OAAO,MAAMC,sCAAsCF,oBAAoB;IACrE,OAAO;QACLG,OAAO;YAACF;SAAqB;IAC/B;AACF,GAAE"}

package/dist/features/migrations/lexicalPluginToLexical/feature.server.js

@@ -3,47 +3,48 @@ import { defaultConverters } from './converter/defaultConverters.js';
 import { convertLexicalPluginToLexical } from './converter/index.js';
 import { UnknownConvertedNode } from './nodes/unknownConvertedNode/index.js';
 export const LexicalPluginToLexicalFeature = createServerFeature({
-  feature: ({
-    props
-  }) => {
-    if (!props) {
-      props = {};
-    }
-    let converters = [];
-    if (props?.converters && typeof props?.converters === 'function') {
-      converters = props.converters({
-        defaultConverters
-      });
-    } else if (props.converters && typeof props?.converters !== 'function') {
-      converters = props.converters;
-    } else {
-      converters = defaultConverters;
-    }
-    props.converters = converters;
-    return {
-      ClientFeature: '@payloadcms/richtext-lexical/client#LexicalPluginToLexicalFeatureClient',
-      hooks: props.disableHooks ? undefined : {
-        afterRead: [({
-          value
-        }) => {
-          if (!value || !('jsonContent' in value)) {
-            // incomingEditorState null or not from Lexical Plugin
-            return value;
-          }
-          // Lexical Plugin => convert to lexical
-          return convertLexicalPluginToLexical({
-            converters: props.converters,
-            lexicalPluginData: value,
-            quiet: props?.quiet
-          });
-        }]
-      },
-      nodes: [{
-        node: UnknownConvertedNode
-      }],
-      sanitizedServerFeatureProps: props
-    };
-  },
-  key: 'lexicalPluginToLexical'
+    feature: ({ props })=>{
+        if (!props) {
+            props = {};
+        }
+        let converters = [];
+        if (props?.converters && typeof props?.converters === 'function') {
+            converters = props.converters({
+                defaultConverters
+            });
+        } else if (props.converters && typeof props?.converters !== 'function') {
+            converters = props.converters;
+        } else {
+            converters = defaultConverters;
+        }
+        props.converters = converters;
+        return {
+            ClientFeature: '@payloadcms/richtext-lexical/client#LexicalPluginToLexicalFeatureClient',
+            hooks: props.disableHooks ? undefined : {
+                afterRead: [
+                    ({ value })=>{
+                        if (!value || !('jsonContent' in value)) {
+                            // incomingEditorState null or not from Lexical Plugin
+                            return value;
+                        }
+                        // Lexical Plugin => convert to lexical
+                        return convertLexicalPluginToLexical({
+                            converters: props.converters,
+                            lexicalPluginData: value,
+                            quiet: props?.quiet
+                        });
+                    }
+                ]
+            },
+            nodes: [
+                {
+                    node: UnknownConvertedNode
+                }
+            ],
+            sanitizedServerFeatureProps: props
+        };
+    },
+    key: 'lexicalPluginToLexical'
 });
+
 //# sourceMappingURL=feature.server.js.map

package/dist/features/migrations/lexicalPluginToLexical/feature.server.js.map

@@ -1 +1 @@
-{"version":3,"file":"feature.server.js","names":["createServerFeature","defaultConverters","convertLexicalPluginToLexical","UnknownConvertedNode","LexicalPluginToLexicalFeature","feature","props","converters","ClientFeature","hooks","disableHooks","undefined","afterRead","value","lexicalPluginData","quiet","nodes","node","sanitizedServerFeatureProps","key"],"sources":["../../../../src/features/migrations/lexicalPluginToLexical/feature.server.ts"],"sourcesContent":["import type { LexicalPluginNodeConverter, PayloadPluginLexicalData } from './converter/types.js'\n\nimport { createServerFeature } from '../../../utilities/createServerFeature.js'\nimport { defaultConverters } from './converter/defaultConverters.js'\nimport { convertLexicalPluginToLexical } from './converter/index.js'\nimport { UnknownConvertedNode } from './nodes/unknownConvertedNode/index.js'\n\nexport type LexicalPluginToLexicalFeatureProps = {\n  converters?:\n    | (({\n        defaultConverters,\n      }: {\n        defaultConverters: LexicalPluginNodeConverter[]\n      }) => LexicalPluginNodeConverter[])\n    | LexicalPluginNodeConverter[]\n  disableHooks?: boolean\n  quiet?: boolean\n}\n\nexport const LexicalPluginToLexicalFeature =\n  createServerFeature<LexicalPluginToLexicalFeatureProps>({\n    feature: ({ props }) => {\n      if (!props) {\n        props = {}\n      }\n\n      let converters: LexicalPluginNodeConverter[] = []\n\n      if (props?.converters && typeof props?.converters === 'function') {\n        converters = props.converters({ defaultConverters })\n      } else if (props.converters && typeof props?.converters !== 'function') {\n        converters = props.converters\n      } else {\n        converters = defaultConverters\n      }\n\n      props.converters = converters\n\n      return {\n        ClientFeature: '@payloadcms/richtext-lexical/client#LexicalPluginToLexicalFeatureClient',\n        hooks: props.disableHooks\n          ? undefined\n          : {\n              afterRead: [\n                ({ value }) => {\n                  if (!value || !('jsonContent' in value)) {\n                    // incomingEditorState null or not from Lexical Plugin\n                    return value\n                  }\n\n                  // Lexical Plugin => convert to lexical\n                  return convertLexicalPluginToLexical({\n                    converters: props.converters as LexicalPluginNodeConverter[],\n                    lexicalPluginData: value as PayloadPluginLexicalData,\n                    quiet: props?.quiet,\n                  })\n                },\n              ],\n            },\n        nodes: [\n          {\n            node: UnknownConvertedNode,\n          },\n        ],\n        sanitizedServerFeatureProps: props,\n      }\n    },\n    key: 'lexicalPluginToLexical',\n  })\n"],"mappings":"AAEA,SAASA,mBAAmB,QAAQ;AACpC,SAASC,iBAAiB,QAAQ;AAClC,SAASC,6BAA6B,QAAQ;AAC9C,SAASC,oBAAoB,QAAQ;AAcrC,OAAO,MAAMC,6BAAA,GACXJ,mBAAA,CAAwD;EACtDK,OAAA,EAASA,CAAC;IAAEC;EAAK,CAAE;IACjB,IAAI,CAACA,KAAA,EAAO;MACVA,KAAA,GAAQ,CAAC;IACX;IAEA,IAAIC,UAAA,GAA2C,EAAE;IAEjD,IAAID,KAAA,EAAOC,UAAA,IAAc,OAAOD,KAAA,EAAOC,UAAA,KAAe,YAAY;MAChEA,UAAA,GAAaD,KAAA,CAAMC,UAAU,CAAC;QAAEN;MAAkB;IACpD,OAAO,IAAIK,KAAA,CAAMC,UAAU,IAAI,OAAOD,KAAA,EAAOC,UAAA,KAAe,YAAY;MACtEA,UAAA,GAAaD,KAAA,CAAMC,UAAU;IAC/B,OAAO;MACLA,UAAA,GAAaN,iBAAA;IACf;IAEAK,KAAA,CAAMC,UAAU,GAAGA,UAAA;IAEnB,OAAO;MACLC,aAAA,EAAe;MACfC,KAAA,EAAOH,KAAA,CAAMI,YAAY,GACrBC,SAAA,GACA;QACEC,SAAA,EAAW,CACT,CAAC;UAAEC;QAAK,CAAE;UACR,IAAI,CAACA,KAAA,IAAS,EAAE,iBAAiBA,KAAI,GAAI;YACvC;YACA,OAAOA,KAAA;UACT;UAEA;UACA,OAAOX,6BAAA,CAA8B;YACnCK,UAAA,EAAYD,KAAA,CAAMC,UAAU;YAC5BO,iBAAA,EAAmBD,KAAA;YACnBE,KAAA,EAAOT,KAAA,EAAOS;UAChB;QACF;MAEJ;MACJC,KAAA,EAAO,CACL;QACEC,IAAA,EAAMd;MACR,EACD;MACDe,2BAAA,EAA6BZ;IAC/B;EACF;EACAa,GAAA,EAAK;AACP","ignoreList":[]}
+{"version":3,"sources":["../../../../src/features/migrations/lexicalPluginToLexical/feature.server.ts"],"sourcesContent":["import type { LexicalPluginNodeConverter, PayloadPluginLexicalData } from './converter/types.js'\n\nimport { createServerFeature } from '../../../utilities/createServerFeature.js'\nimport { defaultConverters } from './converter/defaultConverters.js'\nimport { convertLexicalPluginToLexical } from './converter/index.js'\nimport { UnknownConvertedNode } from './nodes/unknownConvertedNode/index.js'\n\nexport type LexicalPluginToLexicalFeatureProps = {\n  converters?:\n    | (({\n        defaultConverters,\n      }: {\n        defaultConverters: LexicalPluginNodeConverter[]\n      }) => LexicalPluginNodeConverter[])\n    | LexicalPluginNodeConverter[]\n  disableHooks?: boolean\n  quiet?: boolean\n}\n\nexport const LexicalPluginToLexicalFeature =\n  createServerFeature<LexicalPluginToLexicalFeatureProps>({\n    feature: ({ props }) => {\n      if (!props) {\n        props = {}\n      }\n\n      let converters: LexicalPluginNodeConverter[] = []\n\n      if (props?.converters && typeof props?.converters === 'function') {\n        converters = props.converters({ defaultConverters })\n      } else if (props.converters && typeof props?.converters !== 'function') {\n        converters = props.converters\n      } else {\n        converters = defaultConverters\n      }\n\n      props.converters = converters\n\n      return {\n        ClientFeature: '@payloadcms/richtext-lexical/client#LexicalPluginToLexicalFeatureClient',\n        hooks: props.disableHooks\n          ? undefined\n          : {\n              afterRead: [\n                ({ value }) => {\n                  if (!value || !('jsonContent' in value)) {\n                    // incomingEditorState null or not from Lexical Plugin\n                    return value\n                  }\n\n                  // Lexical Plugin => convert to lexical\n                  return convertLexicalPluginToLexical({\n                    converters: props.converters as LexicalPluginNodeConverter[],\n                    lexicalPluginData: value as PayloadPluginLexicalData,\n                    quiet: props?.quiet,\n                  })\n                },\n              ],\n            },\n        nodes: [\n          {\n            node: UnknownConvertedNode,\n          },\n        ],\n        sanitizedServerFeatureProps: props,\n      }\n    },\n    key: 'lexicalPluginToLexical',\n  })\n"],"names":["createServerFeature","defaultConverters","convertLexicalPluginToLexical","UnknownConvertedNode","LexicalPluginToLexicalFeature","feature","props","converters","ClientFeature","hooks","disableHooks","undefined","afterRead","value","lexicalPluginData","quiet","nodes","node","sanitizedServerFeatureProps","key"],"mappings":"AAEA,SAASA,mBAAmB,QAAQ,4CAA2C;AAC/E,SAASC,iBAAiB,QAAQ,mCAAkC;AACpE,SAASC,6BAA6B,QAAQ,uBAAsB;AACpE,SAASC,oBAAoB,QAAQ,wCAAuC;AAc5E,OAAO,MAAMC,gCACXJ,oBAAwD;IACtDK,SAAS,CAAC,EAAEC,KAAK,EAAE;QACjB,IAAI,CAACA,OAAO;YACVA,QAAQ,CAAC;QACX;QAEA,IAAIC,aAA2C,EAAE;QAEjD,IAAID,OAAOC,cAAc,OAAOD,OAAOC,eAAe,YAAY;YAChEA,aAAaD,MAAMC,UAAU,CAAC;gBAAEN;YAAkB;QACpD,OAAO,IAAIK,MAAMC,UAAU,IAAI,OAAOD,OAAOC,eAAe,YAAY;YACtEA,aAAaD,MAAMC,UAAU;QAC/B,OAAO;YACLA,aAAaN;QACf;QAEAK,MAAMC,UAAU,GAAGA;QAEnB,OAAO;YACLC,eAAe;YACfC,OAAOH,MAAMI,YAAY,GACrBC,YACA;gBACEC,WAAW;oBACT,CAAC,EAAEC,KAAK,EAAE;wBACR,IAAI,CAACA,SAAS,CAAE,CAAA,iBAAiBA,KAAI,GAAI;4BACvC,sDAAsD;4BACtD,OAAOA;wBACT;wBAEA,uCAAuC;wBACvC,OAAOX,8BAA8B;4BACnCK,YAAYD,MAAMC,UAAU;4BAC5BO,mBAAmBD;4BACnBE,OAAOT,OAAOS;wBAChB;oBACF;iBACD;YACH;YACJC,OAAO;gBACL;oBACEC,MAAMd;gBACR;aACD;YACDe,6BAA6BZ;QAC/B;IACF;IACAa,KAAK;AACP,GAAE"}

package/dist/features/migrations/lexicalPluginToLexical/nodes/unknownConvertedNode/Component.js

@@ -1,15 +1,17 @@
 'use client';
-
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import React from 'react';
-export const UnknownConvertedNodeComponent = props => {
-  const {
-    data
-  } = props;
-  return /*#__PURE__*/_jsxs("div", {
-    children: ["Unknown converted payload-plugin-lexical node: ", /*#__PURE__*/_jsx("strong", {
-      children: data?.nodeType
-    })]
-  });
+import './index.scss';
+export const UnknownConvertedNodeComponent = (props)=>{
+    const { data } = props;
+    return /*#__PURE__*/ _jsxs("div", {
+        children: [
+            "Unknown converted payload-plugin-lexical node: ",
+            /*#__PURE__*/ _jsx("strong", {
+                children: data?.nodeType
+            })
+        ]
+    });
 };
+
 //# sourceMappingURL=Component.js.map

package/dist/features/migrations/lexicalPluginToLexical/nodes/unknownConvertedNode/Component.js.map

@@ -1 +1 @@
-{"version":3,"file":"Component.js","names":["React","UnknownConvertedNodeComponent","props","data","_jsxs","_jsx","nodeType"],"sources":["../../../../../../src/features/migrations/lexicalPluginToLexical/nodes/unknownConvertedNode/Component.tsx"],"sourcesContent":["'use client'\nimport React from 'react'\n\nimport type { UnknownConvertedNodeData } from './index.js'\n\nimport './index.scss'\n\ntype Props = {\n  data: UnknownConvertedNodeData\n}\n\nexport const UnknownConvertedNodeComponent: React.FC<Props> = (props) => {\n  const { data } = props\n\n  return (\n    <div>\n      Unknown converted payload-plugin-lexical node: <strong>{data?.nodeType}</strong>\n    </div>\n  )\n}\n"],"mappings":"AAAA;;;AACA,OAAOA,KAAA,MAAW;AAUlB,OAAO,MAAMC,6BAAA,GAAkDC,KAAA;EAC7D,MAAM;IAAEC;EAAI,CAAE,GAAGD,KAAA;EAEjB,oBACEE,KAAA,CAAC;eAAI,mD,aAC4CC,IAAA,CAAC;gBAAQF,IAAA,EAAMG;;;AAGpE","ignoreList":[]}
+{"version":3,"sources":["../../../../../../src/features/migrations/lexicalPluginToLexical/nodes/unknownConvertedNode/Component.tsx"],"sourcesContent":["'use client'\nimport React from 'react'\n\nimport type { UnknownConvertedNodeData } from './index.js'\n\nimport './index.scss'\n\ntype Props = {\n  data: UnknownConvertedNodeData\n}\n\nexport const UnknownConvertedNodeComponent: React.FC<Props> = (props) => {\n  const { data } = props\n\n  return (\n    <div>\n      Unknown converted payload-plugin-lexical node: <strong>{data?.nodeType}</strong>\n    </div>\n  )\n}\n"],"names":["React","UnknownConvertedNodeComponent","props","data","div","strong","nodeType"],"mappings":"AAAA;;AACA,OAAOA,WAAW,QAAO;AAIzB,OAAO,eAAc;AAMrB,OAAO,MAAMC,gCAAiD,CAACC;IAC7D,MAAM,EAAEC,IAAI,EAAE,GAAGD;IAEjB,qBACE,MAACE;;YAAI;0BAC4C,KAACC;0BAAQF,MAAMG;;;;AAGpE,EAAC"}